Format string attack

Questa voce sull'argomento sicurezza informatica è solo un abbozzo.

Contribuisci a migliorarla secondo le convenzioni di Wikipedia.

Le format string attack (vulnerabilità di formato della stringa) sono una classe di vulnerabilità scoperte nel 1999.

Il tipo di attacco Format String è una classe di vulnerabilità scoperte nel 1999, presenti prevalentemente in linguaggi di programmazione imperativi come il C. Un Format String Attack è formato da tre componenti fondamentali:

• Format Function: in ANSI C è una funzione che converte una variabile di tipo primitivo, in una stringa user-friendly cioè leggibile dall’uomo.

   printf: per stampare su stdout
   fprintf: per stampare la format string su file
   sprintf: per stampare una stringa dentro un buffer
   snprintf: per stampare esattamente 'n' caratteri della stringa in ingresso nella seconda

• Format String: è l’argomento della format function ed è una stringa ASCII che contiene sia testo che parametri di formato.

   printf(“The magic number is %d\n”, 3);

• Format String Parameter definiscono il tipo di conversione da effettuare in relazione alla variabile presente nella format string.

   “%s”: per stampare una stringa
   “%d”: per stampare degli interi
   “%c”: per stampare dei caratteri
   “%x”: per stampare caratteri esadecimali

Lo stack è un'area di memoria in cui vengono salvate le variabili locali e i parametri passati alla funzione. La sua gestione è di tipo LIFO e cresce verso indirizzi bassi. Eseguendo questo semplice codice, ad esempio:

#include <stdio.h>
    
void main(int argc , char* argv){
   int A=3, B=5;
   printf("Valore var. A: %d - Indirizzo var. A: %x\n", A, &A);
   printf("Valore var. B: %d - Indirizzo var. B: %x\n", B, &B);
}

il programma stamperà:

Valore var. A: 3 - Indirizzo var. A: 7fdc
Valore var. B: 5 - Indirizzo var. B: 7fd8

se invece la printf() riceve come parametro una stringa "maligna" (senza controllarne le caratteristiche) il risultato sarebbe proprio un attacco di tipo format string.

Crash del programma

Un modo molto semplice per mandare in crash un programma è passare alla funzione printf() una stringa formattata in questo modo:

printf("%s%s%s%s%s%s%s%s%s%s%s");

Ogni "%s" cerca di visualizzare il contenuto di un buffer di caratteri (una stringa) dall'indirizzo iniziale presente sullo stack fino al carattere terminatore ("0"). Inserendo quindi molti “%s", la funzione sposterà il puntatore in avanti fino ad aree di memoria non mappate nel frame dell'applicazione, così facendo cercherà di leggere da "indirizzi illegali", causando l'errore “segmentation fault” che manda in crash il programma.

Leggere lo stack

Utilizzando sempre la printf(), è possibile leggere parte del contenuto dello stack, usando una format string di questo tipo:

printf("%08x-%08x-%08x-%08x-%08x\n");

l'output potrebbe essere il seguente:

4306ea40-43074920-0062de90-70706970-02000002

Questo perché essendo il numero degli argomenti della printf() variabili, questa utilizza la format string per sapere quanti gliene sono stati passati. In questo caso quindi crede (erroneamente) che siano cinque parametri, e andrà quindi a stampare i prossimi cinque indirizzi sullo stack, pensando siano i parametri richiesti.

Il parametro di formato "%08x" è costituito dai seguenti componenti:

• x (converti i caratteri in esadecimale),
• 8 (mostra otto caratteri),
• 0 (riempi di zeri i caratteri nulli, se presenti).

Leggere memoria in ogni locazione di memoria

È possibile anche leggere aree di memoria diverse dallo stack. Dobbiamo però creare una format function che visualizza il contenuto della memoria all’indirizzo che gli forniamo. Ci servirà quindi l’indirizzo da cui andare a leggere ed il giusto parametro di formato per leggerlo.

La nostra format function mantiene all’interno dello stack il puntatore alla locazione di memoria del parametro di formato. Se fossimo in grado di far puntare quel puntatore all’area di memoria che ci interessa, potremmo dare quell’indirizzo al formato parametro "%s" così che, invocando la printf(), questa leggerà la memoria da quell’indirizzo fino a che non trova un carattere terminatore ‘0’.

Utilizzando ad esempio la seguenti stringa di formato:

  printf ("\x10\x01\x48\x08_%08x-%08x-%08x-|%s|");

la sequenza di "%08x" incrementa il puntatore interno della format function verso il top dello stack. Dopo alcuni di questi incrementi, lo stack pointer punterà esattamente all'indirizzo della nostra format string. Con il giusto numero di ‘%08x’ potremmo visualizzare la memoria (codificata in ASCII) da un qualsiasi indirizzo.

Bisogna quindi sostituire la parte iniziale della format string con un vero indirizzo.

Vogliamo leggere aree di memoria vicino a questo indirizzo ‘0x08480110’:

• Per prima cosa bisogna codificare l'indirizzo in una stringa a 32 bit secondo la regola little-endian.
• l'indirizzo "0x08480110" verrà quindi ribaltato e separato da caratteri speciali diventando: "\x10\x01\x48\x08"

La codifica dell’indirizzo scelto in una stringa a 32 bit "\x10\x01\x48\x08" dove il carattere "\x10" inserito in una stringa dice al compilatore di mettere un carattere esadecimale "0x10" nella posizione corrente.

Il carattere "\x" dice al compilatore di mettere il carattere esadecimanle "0x10" nella posizione corrente sullo stack. Altrimenti il valore ASCII salvato nella stringa sarebbe ‘1’ e ‘0’ i cui rispettivi valori ASCII sono ‘49’ e ‘48’, che risulterebbe errato.

Quindi la seguente invocazione andrà a leggere memoria dall’indirizzo che gli abbiamo fornito finché non raggiunge un NULL byte. Incrementando l’indirizzo di memoria dinamicamente possiamo mappare l’intera memoria di processo!

Scrivere un intero in (qualsiasi) locazione di memoria

La printf() ha un altro parametro di formato molto interessante: "%n".

int i;
printf ("12345%n", &i);

Con questo parametro il numero di caratteri scritti prima di lui verrà salvato nella variabile "i"! Quindi usando lo stesso metodo implementato per visualizzare il contenuto della memoria, possiamo andare a scrivere un intero (praticamente) ovunque. Basta sostituire "%n" al posto di "%s" ed il contenuto della cella "0x10014808" verrà sovrascritto. L'attaccante potrebbe quindi andare a cambiare certi flag che gli garantiscano il controllo o sovrascrivere celle con indirizzi di ritorno a nostro piacimento.

• Cross Application Scripting
• Stack overflow
• Linguaggio C

• (EN) scut / team teso Come sfruttare le Format String Vulnerabilities v1.2 Sept 24, 2001
• (EN) CERT standard di programmazione sicura, su securecoding.cert.org.
• (EN) CERT iniziativa per la programmazione sicura, su cert.org.
• (EN) programmazione sicura in C e C++, su cert.org.

Portale Sicurezza informatica: accedi alle voci di Wikipedia che trattano di sicurezza informatica