Sicurezza Informatica

Esercitazioni, Competizioni e Test:

LABORATORIO DI SICUREZZA INFORMATICA

a cura di: Francesco (Galt) Faloci

General Software Security

General Software Security
- Buffer Overflow
- Format String

BUF-...WHU?

E’ il più comune tra tutti i tipi di insicurezza nel
codice C
E’ quasi del tutto assente nei linguaggi ad alto
livello che non permettono la gestione diretta
della memoria
Consiste nel forzare la scrittura in memoria con una quantità di informazione superiore a quella accettabile

Se il software è privo di controlli è possibile
inserire del codice eseguibile in queste stringhe di
overflow
Può essere eseguito nello stack, nell’heap e nel
BSS(block started by symbol, contiene variabili
statiche)

BUF-...WHU?

Per poter svolgere l’esercitazione bisogna prima scaricare tre file che spiegheremo nel dettaglio successivamente:

call_shellcode.c
exploit.c
stack.c

BUF-...WHU?

http://www.cis.syr.edu/~wedu/seed/software_security.html

Weird thing

Disattiviamo la prima protezione utilizzate dai
sistemi Linux per la memoria dinamica

- sudo sysctl -w kernel.randomize_va_space=0
- sudo sysctl kernel.randomize_va_space (verifica)

First Try

Prima di cominciare l’attacco abbiamo bisogno di uno shellcode, ovvero un codice per lanciare una shell
Esso deve essere caricato in memoria così da permetterci di forzare il programma vulnerabile a "saltarci dentro"
Nel nostro caso è un codice assembler "shellcode.c" :
- crea un array di caratteri che contiene lo shellcode
- all'interno del main copia l’array in un buffer

First Try

Compiliamo e lanciamo il file:

gcc -z execstack -o call_shellcode call_shellcode.c
./call_shellcode
> id (vedere che siamo ancora seed)

First Try

Il nostro scopo sarà usare questo shell code in modo da poter aprire una bash con i permessi di root

sudo chown root call_shellcode (pass di seed)
sudo chmod u+s call_shellcode
./call_shellcode
> id (vedere che NON siamo seed)

Second Try

Passiamo ora a vedere il programma vulnerabile stack.c
Contiene 2 funzioni:

Main(): legge il contenuto di un file chiamato badfile da un buffer di lunghezza 517 byte
Bof(): prende come parametro l’indirizzo del buffer precedente e ne copia il contenuto in un buffer locale

poiché la funzione strcpy() non controlla la lunghezza del buffer, continua a copiare il buffer di input all'interno del buffer locale andando a sovrascrivere il contenuto dello
stack sopra il buffer locale

Second Try

Il compilatore gcc implementa un meccanismo di sicurezza
chiamato Stack Guard per Prevenire buffer overflows.

In presenza di questa protezione il buffer overflow non lavora
perciò bisogna disabilitarlo compilando il programma con il
flag -fno-stack-protector

Second Try

Il nostro scopo è quello di creare il contenuto del file badfile in
modo da ottenere una shell con privilegi di root

Per ottenere ciò il nostro badfile dovrà contenere:

Lo shellcode
Indirizzo dello shell code

Lo shell code presente in badfile sarà copiato nello stack del
programma in modo da provocare un buffer overflow e sarà
eseguito solo se l’indirizzo di ritorno di bof contiene il suo
indirizzo. Dovrà quindi essere piazzato alla giusta distanza dall'inizio del badfile

Second Try

Trovare l’indirizzo della variabile buffer[ ] nel metodo bof
Trovare la distanza dell’indirizzo di ritorno dalla variabile buffer
Trovare la distanza dello shell code dalla variabile buffer
Dato 1) e 3), trovare l’indirizzo a nel quale posizionare lo shellcode
Dato 2) e 4), inserire l’indirizzo citato sopra alla giusta distanza dall'inizio di badfile

Second Try

Per trovare l’indirizzo della variabile buffer in bof() bisogna
prima compilare una copia di stack.c usando i flag di debug

gcc -z execstack -fno-stack-protector -g -o stack_dbg stack.c
touch badfile
gdb stack_dbg
b bof
x &buffer (indirizzo di buffer)
x $ebp (indirizzo dell'ebp)

Second Try

Dallo screen precedente si può vedere che l’indirizzo di buffer è
0xbffff118 mentre quello dell’ebp è 0xbffff138
Calcoliamo la distanza tra di essi...

L'indirizzo del buffer dista dall’ebp 0x20 bytes; nei sistemi a 32bit i puntatori sono lunghi 4 byte

Per questo motivo per arrivare all'indirizzo di ritorno bisogna sommare 4 bytes alla distanza = 0x20+4 = 0x24

Bisogna quindi aggiungere altri 4 bytes a causa dell’indirizzo di ritorno: per iniettare il nostro sarà "indirizzo" + 0x28 bytes

Second Try

L’indirizzo di ritorno è almeno 0xbffff118 + 0x28 = 0xbffff140

Avendo runnato il programma precedente sotto gdb, ci sono
delle possibilità che lo stack frame sia alcuni bytes sfasato
rispetto alla normale esecuzione
Per incrementare le nostre chance di successo riempiamo il
nostro badfile con istruzioni NOP (una istruzione che fa
avanzare il contatore del programma all'istruzione successiva)

Inseriremo lo shellcode alla fine del file

Modifichiamo quindi il file exploit.cs

Second Try

Aggiungeremo a exploit.cs:

*((long *) (buffer + 0x30)) = 0xbffff140;

memcpy(buffer + sizeof(buffer) - sizeof(shellcode), shellcode, sizeof(shellcode));

Second Try

Per verificare che tutto sia stato correttamente compilato:

gcc exploit.c -o exploit
hexdump -C badfile

Second Try

Eseguendo ora stack, precedentemente salvato coi privilegi di root, avremo:

Third Try

Riattiviamo la address randomization ed eseguiremo lo stesso attacco sviluppato nel primo task

Essendo dinamica l'allocazione della memoria però, il sistema non ci permette di scrivere in posizioni non idonee...

Third Try

Bisogna individuare una posizione adeguata quindi...

Per vedere come lavora la randomizzazione modifichiamo il
programma stack.c in modo da stampare l’indirizzo del buffer

Aggiungeremo:

printf("%p/n", &buffer);

Third Try

... cambia in continuazione

Third Try

Per aggirare questa protezione creiamo uno script bash che
ripete all’infinito l’esecuzione dello script

Se siamo fortunati ad un certo punto avverrà una esecuzione
uguale a quella che abbiamo calcolato nello script precedente

/end

... grazie per l'attenzione.