PwnTools
PwnTools
A PwnTools é uma biblioteca python que permite a criação de scripts que ajudam na resolução de desafios CTFs, automatização, análise de binários e desenvolvimento de exploits.
Nesse documento, será apresentado algumas das principais funções disponíveis da biblioteca e alguns exemplos de uso.
Instalação
Utilizando pip:
pip3 install pwntoolsApós instalação, basta apenas colocar a seguinte linha para importar a biblioteca:
from pwn import *Documentação
Nesta seção, serão apresentadas as principais funções da biblioteca.
Conectar a processos
É possível interagir com processos locais ou remotos:
# Cria um processo do binário vuln
p = process("./vuln")
# Cria um processo remoto. Exemplo: Se o servidor for "nc chall.ctf 1234"
p = remote("chall.ctf", 1234)# É possível interagir com esse processo criado
# Irá ler todos os dados gerados pelo processo ou pode receber como parâmetro
# a quantidade de bytes que deve ler
p.recv()
# Irá ler até a quebra de linha '\n'
p.recvline()
# Irá ler até encontrar a string passada como parâmetro
# Nesse caso, irá ler até encontrar a string 'digite:'
p.recvuntil('digite:')
# Irá ler tudo, o decode() no final é apenas para formatar a string corretamente
p.clean().decode()
# Irá enviar a string passada como parâmetro
p.send(b'abc')
# Irá enviar a string passada como parâmetro mas com um '\n' no final
p.sendline(b'abc')
# Irá enviar a a string 'abc' após receber a string 'Digite:'
p.sendafter('Digite:', b'abc')
# Irá abrir uma instância do terminal do processo para interagir manualmente
p.interactive()
# Espera o processo terminar
p.wait()# É possível instanciar o gdb no processo executado
p = process('./exec')
# É possível definir parâmetros como comandos gdb, como breakpoints e se tem ou não aslr
gdb.attach(p, gdbscript='''
b *main+45
''', aslr=False)Ambiente e contexto
É possível definir o ambiente que executará o processo.
# É possível definir a arquitetura
# Valores possíveis 'aarch64', 'arm', 'i386', 'amd64'
# Padrão 'i386'
context.arch = 'amd64'
# É possível definir se o processo é little endian ou big endian
# Padrão 'little'
context.endian = 'big'Codificação e utilidades
Há algumas funções de codificação, decodificação e utilidade gerais
# Transforma de caracteres para hexadecimal e vice-versa
enhex(b'/bin/sh') # = '2f62696e2f7368'
unhex('2f62696e2f7368') # = b'/bin/sh'
# Codifica e decodifica em base64
b64e(b'basemeiaquatro') # = 'YmFzZW1laWFxdWF0cm8='
b64d('YmFzZW1laWFxdWF0cm8=') # = b'basemeiaquatro'
# É possível calcular md5 e sha1
# Para a 'md5filehex' e 'sha1filehex' é preciso passar o caminho do arquivo
md5sumhex(b'hash') # = '0800fc577294c34e0b28ad2839435945'
md5filehex('./exec') # = '9f27142d5424be26f280a50c1ed1b5af'
sha1sumhex(b'hash') # = '2346ad27d7568ba9896f1b7da6b5991251debdf2'
sha1filehex('./exec') # = '28b1419d35ab80a8d49015760fcbafee641e83eb'
# É possível converter de representação inteira
p8(0x41) # = b'\x41'
p16(0x4142) # = b'\x42\x41'
p32(0x41424344) # = b'\x44\x43\x42\x41'
p64(0x4142434445464748) # = b'\x48\x47\x46\x45\x44\x43\x42\x41'
# É possível converter para representação inteira
u8(b'\x41') # = 0x41
u16(b'\x42\x41') # = 0x4142
u32(b'\x44\x43\x42\x41') # = 0x41424344
u64(b'\x48\x47\x46\x45\x44\x43\x42\x41') # = 0x4142434445464748
# É possível fazer essa conversão com string com tamanhos não usuais
pack(0x2F62696E2F7368, 'all') # = b'\x02CBA@'
unpack(b'\x02CBA@', 'all') # = 275972768514 = 0x4041424302
# É possível gerar sequências cíclicas. Útil para encontrar que parte da string
# que ocorre algum buffer overflow
cyclic(32) # = b'aaaabaaacaaadaaaeaaafaaagaaahaaa'
cyclic_find(0x61616166) # = 20
# É possível gerar hexdump de strings de bytes
print(hexdump(data))
'''
00000000 65 4c b6 62 da 4f 1d 1b d8 44 a6 59 a3 e8 69 2c │eL·b│·O··│·D·Y│··i,│
00000010 09 d8 1c f2 9b 4a 9e 94 14 2b 55 7c 4e a8 52 a5 │····│·J··│·+U|│N·R·│
00000020
'''Assembly
É possível escrever código assembly para enviar para o processo. Útil para exploits como shellcode.
shellcode = asm('''
mov rax, 0x68732f6e69622f
push rax
mov rdi, rsp
mov rsi, 0
mov rdx, 0
mov rax, SYS_execve
syscall
''')
shellcode = shellcraft.pushstr('/bin/sh')
shellcode += shellcraft.syscall('SYS_execve', 'rsp', 0, 0)
# É preciso converter para bytes para enviar
payload = bytes(asm(shellcode))# É possível usar um shellcode padrão do pwntools
shellcode = shellcraft.sh()
payload = bytes(asm(shellcode))
'''
* execve(path='/bin///sh', argv=['sh'], envp=0) */
/* push b'/bin///sh\x00' */
push 0x68
push 0x732f2f2f
push 0x6e69622f
mov ebx, esp
/* push argument array ['sh\x00'] */
/* push 'sh\x00\x00' */
push 0x1010101
xor dword ptr [esp], 0x1016972
xor ecx, ecx
push ecx /* null terminate */
push 4
pop ecx
add ecx, esp
push ecx /* 'sh\x00' */
mov ecx, esp
xor edx, edx
/* call execve() */
push SYS_execve /* 0xb */
pop eax
int 0x80
'''ELFs, Strings e símbolos
É possível encontrar diversas informações a respeito do binário, como endereços de algumas funções, de string específicas, etc.
# Instanciar um elf
elf = ELF('./vuln')# Acessando símbolos
elf.plt # Todos os símbolos da PLT
elf.got # Todos os símbolos da GOT
elf.sym # Todos os símbolos conhecidos
# Exemplos
elf.plt['printf'] # = 4160
elf.got['printf'] # = 16384
elf.sym['system'] # = 4144
# É possível setar o endereço base do processo
elf.address = 0x400000
# É possível instanciar a libc
libc = ELF('./libc.so.6')
# É possível setar o endereço base da libc
libc.address = 0x40404000
# É possível procurar por strings no arquivo elf
# Exemplo: Pega a primeira instância da string '/bin/sh'
bin_sh = next(elf.search(b'/bin/sh'))Return Oriented Programming (ROP)
É possível instanciar um analisador ROP.
elf = ELF('./target')
rop = ROP(elf)# É possível procurar por gadgets específicos
pop_rax = rop.find_gadget(['pop rax', 'ret']).address
syscall = rop.find_gadget(['syscall', 'ret']).address
# Outra possibilidade é procurar por gadgets do tipo 'pop registrador; ret'
pop_rdi = rop.rdi.address
pop_rsi = rop.rsi.address
rop.call(elf.sym.puts, [0xdeadbeef])
# A função call, é o mesmo que fazer as seguintes três intruções
rop.raw(rop.rdi.address) # pop rdi; ret
rop.raw(0xdeadbeef)
rop.raw(elf.sym.puts)
# Converte a sequência de rop para bytes
payload = rop.chain()
# Imprime a sequência
print(rop.dump())SROP
É possível criar frame para exploits de SROP.
# Endereço de uma syscall
syscall = 0xdeadbeef
# Endereço de uma string "/bin/sh"
bin_sh = 0xcafebabe
# Instancia uma frame de um objeto sigreturn
frame = SigreturnFrame()
# Setando os valores dos registradores, com rip sendo o endereço de retorno
frame.rax = constants.SYS_execve
frame.rdi = bin_sh
frame.rsi = 0
frame.rdx = 0
frame.rip = syscall
# Convertendo o frame pra bytes
payload = bytes(frame)Format String Exploits
É possível utilizar funções prontas para realizar exploits de format string.
# Função recebe o offset, que é qual argumento da printf o input do usuário começa
# e recebe um dicionário de chave valor, sendo a chave o endereço que deve ser escrito o valor
offset = 5 # O input do usuário começa no argumento 5
write = { 0x40010 : 0xdeadbeef} # Escreve o valor 0xdeadbeef no endereço 0x40010
payload = fmtstr_payload(offset, writes)Carregar libc
Para garantir que a libc carregada no script seja a libc disponibilizada pelo desafio, você pode usar o seguinte script
from pwn import *
exe = ELF("./hunter_patched")
libc = ELF("./libc.so.6")
ld = ELF("./ld-2.23.so")
context.binary = exe
def conn():
if args.LOCAL:
r = process([exe.path])
if args.GDB:
gdb.attach(r)
else:
r = remote("addr", 1337)
return r
def main():
r = conn()
# good luck pwning :)
r.interactive()
if __name__ == "__main__":
main()Referências
pwntools cheatsheet: https://gist.github.com/anvbis/64907e4f90974c4bdd930baeb705dedf#program-interaction
Documentação pwntools: https://docs.pwntools.com/en/stable/intro.html#making-connections
Pwninit: https://github.com/io12/pwninit
Atualizado