mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-19 09:34:03 +00:00
121 lines
10 KiB
Markdown
121 lines
10 KiB
Markdown
# Metodologia Básica de Exploração Binária
|
|
|
|
{% hint style="success" %}
|
|
Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
|
|
Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
|
|
|
<details>
|
|
|
|
<summary>Suporte ao HackTricks</summary>
|
|
|
|
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
|
|
* **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 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>
|
|
{% endhint %}
|
|
|
|
## Informações Básicas sobre ELF
|
|
|
|
Antes de começar a explorar qualquer coisa, é interessante entender parte da estrutura de um **binário ELF**:
|
|
|
|
{% content-ref url="elf-tricks.md" %}
|
|
[elf-tricks.md](elf-tricks.md)
|
|
{% endcontent-ref %}
|
|
|
|
## Ferramentas de Exploração
|
|
|
|
{% content-ref url="tools/" %}
|
|
[ferramentas](tools/)
|
|
{% endcontent-ref %}
|
|
|
|
## Metodologia de Estouro de Pilha
|
|
|
|
Com tantas técnicas, é bom ter um esquema de quando cada técnica será útil. Note que as mesmas proteções afetarão diferentes técnicas. Você pode encontrar maneiras de contornar as proteções em cada seção de proteção, mas não nesta metodologia.
|
|
|
|
## Controlando o Fluxo
|
|
|
|
Existem diferentes maneiras de controlar o fluxo de um programa:
|
|
|
|
* **Estouros de Pilha** sobrescrevendo o ponteiro de retorno da pilha ou o EBP -> ESP -> EIP.
|
|
* Pode ser necessário abusar de um **Estouro de Inteiro** para causar o estouro
|
|
* Ou via **Gravação Arbitrária + Escrever Onde para Executar**
|
|
* **Strings de Formato:** Abusar do `printf` para escrever conteúdo arbitrário em endereços arbitrários.
|
|
* **Indexação de Arrays:** Abusar de uma indexação mal projetada para poder controlar alguns arrays e obter uma gravação arbitrária.
|
|
* Pode ser necessário abusar de um **Estouro de Inteiro** para causar o estouro
|
|
* **bof para WWW via ROP:** Abusar de um estouro de buffer para construir um ROP e ser capaz de obter um WWW.
|
|
|
|
Você pode encontrar as técnicas de **Escrever Onde para Executar** em:
|
|
|
|
{% content-ref url="../arbitrary-write-2-exec/" %}
|
|
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
|
{% endcontent-ref %}
|
|
|
|
## Laços Eternos
|
|
|
|
Algo a se ter em conta é que geralmente **apenas uma exploração de uma vulnerabilidade pode não ser suficiente** para executar um exploit com sucesso, especialmente algumas proteções precisam ser contornadas. Portanto, é interessante discutir algumas opções para **tornar uma única vulnerabilidade explorável várias vezes** na mesma execução do binário:
|
|
|
|
* Escrever em uma cadeia **ROP** o endereço da função **`main`** ou para o endereço onde a **vulnerabilidade** está ocorrendo.
|
|
* Controlando uma cadeia ROP adequada, você pode ser capaz de realizar todas as ações nessa cadeia
|
|
* Escrever no endereço **`exit` em GOT** (ou em qualquer outra função usada pelo binário antes de terminar) o endereço para voltar à **vulnerabilidade**
|
|
* Como explicado em [**.fini\_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md#eternal-loop)**,** armazene 2 funções aqui, uma para chamar a vulnerabilidade novamente e outra para chamar**`__libc_csu_fini`** que chamará novamente a função de `.fini_array`.
|
|
|
|
## Objetivos de Exploração
|
|
|
|
### Objetivo: Chamar uma Função Existente
|
|
|
|
* [**ret2win**](./#ret2win): Existe uma função no código que você precisa chamar (talvez com alguns parâmetros específicos) para obter a flag.
|
|
* Em um **bof regular sem** [**PIE**](../common-binary-protections-and-bypasses/pie/) **e** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), você só precisa escrever o endereço no endereço de retorno armazenado na pilha.
|
|
* Em um bof com [**PIE**](../common-binary-protections-and-bypasses/pie/), você precisará contorná-lo
|
|
* Em um bof com [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), você precisará contorná-lo
|
|
* Se você precisar definir vários parâmetros para chamar corretamente a função **ret2win**, você pode usar:
|
|
* Uma cadeia [**ROP**](./#rop-and-ret2...-techniques) **se houver gadgets suficientes** para preparar todos os parâmetros
|
|
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (caso possa chamar essa chamada de sistema) para controlar muitos registradores
|
|
* Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar vários registradores
|
|
* Através de um [**Escrever Onde para Executar**](../arbitrary-write-2-exec/) você poderia abusar de outras vulnerabilidades (não bof) para chamar a função **`win`**.
|
|
* [**Redirecionamento de Ponteiros**](../stack-overflow/pointer-redirecting.md): Caso a pilha contenha ponteiros para uma função que será chamada ou para uma string que será usada por uma função interessante (system ou printf), é possível sobrescrever esse endereço.
|
|
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) podem afetar os endereços.
|
|
* [**Variáveis não inicializadas**](../stack-overflow/uninitialized-variables.md): Você nunca sabe.
|
|
|
|
### Objetivo: RCE
|
|
|
|
#### Via shellcode, se nx desativado ou misturando shellcode com ROP:
|
|
|
|
* [**(Stack) Shellcode**](./#stack-shellcode): Isso é útil para armazenar um shellcode na pilha antes ou depois de sobrescrever o ponteiro de retorno e então **pular para ele** para executá-lo:
|
|
* **De qualquer forma, se houver um** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** em um bof regular você precisará contorná-lo (vazar)
|
|
* **Sem** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) é possível pular para o endereço da pilha, pois ele nunca mudará
|
|
* **Com** [**ASLR**](../common-binary-protections-and-bypasses/aslr/), você precisará de técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para pular para ele
|
|
* **Com** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), você precisará usar algum [**ROP**](../rop-return-oriented-programing/) **para chamar `memprotect`** e tornar alguma página `rwx`, para então **armazenar o shellcode lá** (chamando read, por exemplo) e então pular para lá.
|
|
* Isso misturará shellcode com uma cadeia ROP.
|
|
#### Via syscalls
|
|
|
|
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Útil para chamar `execve` para executar comandos arbitrários. Você precisa ser capaz de encontrar os **gadgets para chamar a syscall específica com os parâmetros**.
|
|
* Se [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) estiverem habilitados, você precisará derrotá-los **para usar gadgets ROP** do binário ou bibliotecas.
|
|
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) pode ser útil para preparar o **ret2execve**
|
|
* Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar vários registradores
|
|
|
|
#### Via libc
|
|
|
|
* [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Útil para chamar uma função de uma biblioteca (geralmente de **`libc`**) como **`system`** com alguns argumentos preparados (por exemplo, `'/bin/sh'`). Você precisa que o binário **carregue a biblioteca** com a função que deseja chamar (geralmente libc).
|
|
* Se **compilado estaticamente e sem** [**PIE**](../common-binary-protections-and-bypasses/pie/), o **endereço** de `system` e `/bin/sh` não vão mudar, então é possível usá-los estaticamente.
|
|
* **Sem** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e conhecendo a versão da libc** carregada, o **endereço** de `system` e `/bin/sh` não vão mudar, então é possível usá-los estaticamente.
|
|
* Com [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **mas sem** [**PIE**](../common-binary-protections-and-bypasses/pie/)**, conhecendo a libc e com o binário usando a função `system`** é possível **`ret` para o endereço do system no GOT** com o endereço de `'/bin/sh'` no parâmetro (você precisará descobrir isso).
|
|
* Com [ASLR](../common-binary-protections-and-bypasses/aslr/) mas sem [PIE](../common-binary-protections-and-bypasses/pie/), conhecendo a libc e **sem o binário usando o `system`** :
|
|
* Use [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver o endereço de `system` e chamá-lo 
|
|
* **Burlar** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) e calcular o endereço de `system` e `'/bin/sh'` na memória.
|
|
* **Com** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**PIE**](../common-binary-protections-and-bypasses/pie/) **e sem conhecer a libc**: Você precisa:
|
|
* Burlar [**PIE**](../common-binary-protections-and-bypasses/pie/)
|
|
* Encontrar a **versão da libc** usada (vazar alguns endereços de função)
|
|
* Verificar os **cenários anteriores com ASLR** para continuar.
|
|
|
|
#### Via EBP/RBP
|
|
|
|
* [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Controlar o ESP para controlar o RET através do EBP armazenado na pilha.
|
|
* Útil para **estouros de pilha off-by-one**
|
|
* Útil como uma maneira alternativa de controlar o EIP enquanto abusa do EIP para construir a carga na memória e então pular para ela via EBP
|
|
|
|
#### Misc
|
|
|
|
* [**Redirecionamento de Ponteiros**](../stack-overflow/pointer-redirecting.md): Caso a pilha contenha ponteiros para uma função que será chamada ou para uma string que será usada por uma função interessante (system ou printf), é possível sobrescrever esse endereço.
|
|
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ou [**PIE**](../common-binary-protections-and-bypasses/pie/) podem afetar os endereços.
|
|
* [**Variáveis não inicializadas**](../stack-overflow/uninitialized-variables.md): Você nunca sabe
|