> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/pt-br/useful-resources/exploit-development/linux-buffer-overflow-custom.md).
# Buffer Overflow em Linux - Customizado
Notas customizadas de buffer overflow em Linux para construir exploits, controlar o fluxo de execução, criar payloads e documentar a metodologia de corrupção de memória.
## Primeiro exemplo de binário personalizado (Pdmenu/exim):
Baixe a máquina extrair
> O primeiro exemplo foca na exploração do binário legítimo exim-4.84-7, que possui uma vulnerabilidade identificada como CVE-2016-1531. Essa vulnerabilidade permite que um atacante execute comandos com privilégios ao abusar de certas variáveis de ambiente.
* Neste caso, quando acessamos o usuário Paul, um **Pdmenu** é atribuído a ele com certas funcionalidades (listagem de diretórios, edição de arquivos, execução de ping etc.):
* Para sair deste menu, nós **editamos um arquivo**, por exemplo (etc/host):
* Neste caso, **vi** é usado como editor de texto:
* Observando **gtfobins**, se filtrarmos por vi, obtemos os comandos para sair do Pdmenu e **executar um shell**:
* Filtramos **SUID** arquivos e encontramos um chamado exim:
* Com a **searchsploit** ferramenta, procuramos possíveis vulnerabilidades para este binário:
* Agora faça o download do script e sirva-o com **python3** para que ele possa ser carregado depois que a máquina for comprometida:
* Executamos o script e, de fato, a vulnerabilidade deste binário é explorada; assim obtemos **acesso root**:
## Segundo exemplo (overflow de buffer):
Baixe a vulnerávelUbuntumáquinaInstale a ferramentaPeda
> O segundo exemplo diz respeito a um **overflow de buffer** em um binário personalizado [binário](https://hack4u.io/wp-content/uploads/2023/04/custom) em uma máquina Linux de 32 bits com proteções ativas e ASLR habilitado. Neste caso, focamos em explorar ret2libc em um binário que tem permissões SUID e pertence ao root. Por meio do overflow de buffer, demonstramos como injetar comandos privilegiados e elevar os privilégios do usuário.
\***overflow de buffer** envolve sobrescrever certos registradores do sistema e, como o binário é criado pelo usuário e pertence ao grupo root, **ele será executado como um usuário privilegiado**:
* O binário chamado "custom" espera uma **entrada de string** e, quando é executado, nada acontece:
* Mas se inserirmos uma **string muito longa**, ele retorna um erro (core dumped):
Enviamos uma **string curta** de AAAAAAAA e nenhum **erro aparece**:
* Para analisar o binário em profundidade, usaremos a **gdb-peda** ferramenta.
* Mas se enviarmos **muitos caracteres**, obtemos o seguinte erro:
1. A primeira coisa a fazer é **determinar o número total de strings** necessárias para sobrescrever o registrador (EIP).
* O primeiro método consiste em usar um **padrão (pattern)** que cria uma sequência **projetada espacialmente** (neste caso, 300 caracteres) que utilizamos em nossas execuções no binário:
* Na resposta de **EIP**, sabemos que a **sequência visível inferior** é "AA8A":
* O **automático** O modo automático de fazer isso é com o `offset do padrão $eip` comando:
* Para verificar isso, usamos **python3** enviando 112 caracteres A seguidos de 4 B finais:
```bash
r $(python3 -c 'print("A"*112 + "B"*4)')
```
* Na prática, agora confirmamos a cauda graças a **EIP** que detecta os 4 últimos B:
2. Uma vez que sabemos o número máximo de strings, nós **verificamos o ASLR** que determinará se há **aleatoriedade nos endereços de memória** ou não:
/- Com o seguinte comando, filtramos as strings de nosso interesse especificamente para executar o binário 10 vezes, para ver se ele muda a cada vez e para ver se a **biblioteca C** é aleatória ou não:
De fato, é "aleatório"
3. O problema com esses **32 bits** binários é que, frequentemente, se executarmos, por exemplo, agora **1000 vezes** A e filtrarmos por uma string fixa, vemos que, a cada vez, **ela se repetirá pelo menos uma vez**:
4. O objetivo agora é primeiro encontrar **EIP** strings (**system + exit + bin/\_sh**), que sempre estarão fixas e são necessárias para executar um **Bash como root** como no exemplo a seguir, mas em Python:
* Criamos um **ponto de interrupção** para que o fluxo do programa pare no ponto desejado:
* Injetamos o **EIP** de (system/exit/bin/\_sh):
5. Assim que vemos que há **aleatoriedade**, precisaremos usar **força bruta** até que o **base/\_libc/\_addr** seja igual ao valor desejado:
/- Com o seguinte, veremos as **bibliotecas em execução** (neste caso **libc.so**):
* Com **readelf**, usamos nossos filtros para a biblioteca e buscamos as variáveis injetadas anteriormente, que são (**exit e system**) com os códigos:
* E para encontrar a string **/bin/sh**, fazemos o seguinte, adicionando um **0x00** no início:
O seguinte script em Python3 irá **automatizar todo o brute force** até que **base/\_libc/\_addr** seja o mesmo:
```python
#!/usr/bin/python3
import subprocess
from struct import pack
import sys
offset = 112
before_eip = b"A" * 112
# Overflow de buffer personalizado no Linux
base_libc_addr = 0xb7595000
system_addr_off = 0xb7d86db0
exit_addr_off = 0xb7d7a9e0
bin_sh_addr_off = 0xb7ea7b2b
system_addr = pack("
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://hacking-notes.jord4n.pro/pt-br/useful-resources/exploit-development/linux-buffer-overflow-custom.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
