Buffer OverflowAttacchi ai servizi di rete

Avella GianluigiCerqua PasqualeCrucil SergioD’Alessandro Oreste

Sicurezza su reti A.A. 2004/2005Prof. Masucci Barbara

Argomenti trattati

InternetI servizi di reteBuffer Overflow: teoria, esempiTecniche di protezioneAggirare StackGuard

In principio era….Arpanet ……e poi venne Internet

Internet è una suite di servizi

Tutti basati sul protocollo TCP/IP

I più importanti attualmentehttp: web (es. Apache, Tomcat, IIS)ftp: trasferimento file (es. wu-ftp)smtp, pop, imap: posta elettronica (es. sendmail,postfix)

Lo sviluppo di Internet

0

50.000.000

100.000.000

150.000.000

200.000.000

250.000.000

300.000.000

Dicembre1994

Dicembre1996

Dicembre1998

Dicembre2000

Dicembre2002

Tecnologie di sicurezza

0% 20% 40% 60% 80% 100%

BiometriaChiave pubblica

Smart cards - e-tokenCrittografia dei files

Prevenzione intrusioniAccounting utenti

Crittografia dati trasmessiIDS

ACLFirewall

Antivirus

Tecnologie di sicurezza utilizzate

Sicurezza InformaticaProblemi dovuti alla “insicurezza” dei servizi informatici

Acquisizione illecita di dati. Accesso indebito a un sistema per l’elaborazione di dati. Danneggiamento di dati, inclusa la fabbricazione e la messa in circolazione di virus informatici.Conseguimento fraudolento di una prestazione informatica.Attacchi a sistemi informatici di tipo “denial of service“. Danneggiamento grave delle reti di comunicazione: perturbamento di pubblici servizi

Danni economici

$0 $10 $20 $30 $40 $50 $60

Milioni

SabotaggioViolazione del sistemaSito w eb "defacciato"

Abuso di applicazioni w ebFrode informatica

Accesso non autorizzatoFurto di componenti

Frode finanziariaAbuso della rete w ireless

Abuso della rete internaFurto di informazioni

Denial of ServiceVirus

Perdite per tipo di attacco (2004)

Milioni di dollari.

Errori nelle configurazioni

Le principali cause della vulnerabilità del software

Configurazioni errateAllocazione di tipi differenti di variabiliErrata deallocazione della memoriaCicli infinitiAssenza di controllo sulle operazioni e sui puntatori

Buffer overflow

Introduzione al Buffer overflow

Conoscenze necessarieLinguaggio Assembler.Registri CPU.Funzionamento a basso livello di un sistema operativo.Funzionamento (in genere) dei linguaggi di programmazione.Conoscenza di un debugger.Nello specifico:

Un sistema GNU/LinuxGnu DebuggerLinguaggio CArchitettura x86 Intel

Teoria ed esempio di un attacco

Il buffer overflow è un errore di programmazione dovuto all’errata gestione dei dati all’interno di un programma.In C un buffer viene normalmente associato ad un array. L’overflow di un buffer consiste nel riempire oltre il limite tale buffer.Un attacker è in grado di sfruttare questo errore per causare il crash di un servizio remoto o penetrare all'interno di un sistema.Tipi di attacchi dovuti a questo errore:

Modifica del flusso di un programma.Iniezione ed esecuzione di codice arbitrario.Modifica di un puntatore a funzione.Modifica dei dati passati ad una funzione.

Scenari

Server

Attacco locale WebFTP SSH

Scenario “domestico”

Attacco a client di servizi remoti.Internet Explorer è probabilmente il client più buggato che si ricordi.

Un processo in memoriaOgni processo caricato in memoria, viene diviso in tre parti.

Segmento testoSegmento datiStack

Lo stack è una struttura dati cruciale per il funzionamento di un processo.

Funzionamento di tipo LIFO PUSH e POP ( Operazioni )

Stack

Segmento dati

Segmento testo

Indirizzi di memoria bassi

Indirizzi di memoria alti

Funzionamento dello stackmain(){//codice

foo(buffer);//codice}

foo(char *buffer){char a [ 5 ];strcpy(a,buffer);}

EIP = Indirizzo dell’istruzione successiva

EBP = Base pointer

ESP = Top dello Stack

RETSFPa [ 4 ]a [ 3 ]a [ 2 ]a [ 1 ]a [ 0 ]

BP

Registri del processore

ESP

Record di attivazione

call 0x80483a9 <foo>

push %ebpmov %esp,%ebpsub $0x18,%espsub $0x8,%esp

Funzionamento dello stackmain(){//codice

foo(buffer);//codice}

foo(char *buffer){char a [ 5 ];strcpy(a,buffer);}

EIP = Indirizzo dell’istruzione successiva

EBP = Base pointer

ESP = Top dello Stack

RETSFPa [ 4 ]a [ 3 ]a [ 2 ]a [ 1 ]a [ 0 ]

BP

Registri del processore

ESP

add $0x10,%espleaveret

EBPEIP

Smashing the stackSe il buffer passato alla funzionefoo() è più di 5 caratteri….Es: “bbbbbbbbbbbbbbb”

foo(char *buffer){a[ 5 ];strcpy(a,buffer);

}

Segmentation

Fault

I caratteri che eccedono il buffer hanno sovrascritto l’indirizzo di ritorno. EIP adesso punta ad una locazione di memoria non valida.

a [ 0 ]a [ 1 ]

a [ 2 ]

a [ 3 ]a [ 4 ]

SFP

RET

Ghost in the shellA questo punto il programma è andato in crash!Ma un attacker potrebbe “confezionare” un array da passare alla funzione foo() in modo tale che venga dirottata l’esecuzione del programma stesso. Ma nella maggior parte dei casi questo bug viene sfruttato per costringere il programma ad eseguire codice arbitrario!

Nop (\bin/sh) 0x0809ff34\x1f\xeb\x8bNop

No operation Codice arbitrario

“Shellcode”

Puntatore Inizio del buffer

Un esempio

#include <stdio.h>

main(int argc, char **argv){

char buffer[10];

if(argc!=2){printf("Usage:./esempio qualcosa\n");

exit(0);}

strcpy(buffer,argv[1]);}

foo(){printf("Corso di sicurezza su reti\n");exit(0);}

#include <stdio.h>

main() {

int i;char buffer[33];

for(i=0;i<28;i++)buffer[i]=0x61;

*(long *)&buffer[28] =0x0804843d;

execl("./esempio","esempio",buffer,NULL);

}

Codice esempio Codice exploit

Analisi del problema - 1

Modifica del flusso di un programma.

“Iniezione” di codice arbitrario.

Un attacker può prendere pieno possesso della macchina “vittima”.

Analisi del problema - 2

Firewall ed antivirus sono impotenti!

Danni economici elevati.

Metà degli advisory del Cert, sono su problemi legati al Buffer Overflow.

Difesa dal Buffer Overflow Come difendersi

Programmi modulari e facili da debuggare.Testing.Stack non eseguibile.Controllo della dimensione degli array.Utilizzo di linguaggi “tipizzati”.Controllo dell’integrità sui puntatori.Utilizzo di tool specifici.Pregare….

Tool di difesaStackGuard, StackShield, FlawFinderautomatizzano alcuni dei suddetti metodi di prevenzione.Sono programmi open source.Disponibili unicamente per il mondo Unix.StackGuard e StackShield non richiedono aggiunte al codice esistente, ma non tutti i programmi possono essere ricompilati.

StackGuardStackGuard è una “patch” per gcc.La prima versione prevedeva la protezione da scrittura della word RET. (Memguard)Interviene nel prologo e nell’epilogodi ogni funzione.Utilizza una “canary” word nel record di attivazione.Un tentativo di sovrascrivere il RET provocherebbe “il canto” del canarino.

Canary RETSFP

Metodi difensivi di StackGuardL’attacker potrebbe leggere la word canaryQuindi tre metodi di difesa

Terminator CanaryLa word è scelta come combinazione di caratteri nulli, ritorno a capo e fine linea.

Random CanaryLa word è scelta in modo random a run-time.Esiste una variante chiamata XOR random canary.

Null CanaryLa word e una serie di caratteri nulli

Es. 0x00000000

StackShieldStackShield è un software simile a StackGuard.Protegge il valore RET da attacchi ti tipo Buffer Overflow.Aggiunge codice assembly al prologo ed all’epilogo di ogni funzione.Utilizza tre metodi di funzionamento

Global Ret StackRet range check.Modalità speciale ( attacchi contro puntatori a funzione ).

Non richiede al programmatore di aggiungere codice.

Global Ret StackLa prima tecnica di protezione prevede l’utilizzo di un array di 256 elementi (Retarray) da trattare come uno stackdove verranno salvati gli indirizzi di ritorno.Si utilizzano due puntatori speciali

Retptr ( puntatore alla prima locazione libera di Retarray).Rettop ( puntatore all’ultimo elemento dell’array.)

Funzionamento del Global Ret Stack

……………………………0x010x00

Retptr Rettop

Nel prologo di ogni funzione, Retptr viene confrontato con Rettop.Se Retptr è <= di Rettop, l’indirizzo viene memorizzato nell’array e Retptr viene incrementato.Altrimenti l’indirizzo di ritorno non viene salvato ma Retptrviene incrementato comunque per “sincronizzazione”.

Nell’epilogo avviene nuovamente il controllo e se Retptr è <= di Rettop l’indirizzo salvato viene ripristinato e Retptr decrementato.

Retarray

Esempio di funzionamento

………..

Retptr

Rettopmain(){//codicefoo();//codice}

foo(){foo2();//codice

}foo2(){//codice} 0x01

0x02

Retarray

Global Ret StackIn questo modo anche se un buffer overflow sovrascrive il RET, questo viene ripristinato all’epilogo.La dimensione di Retarray può essere aumentata.L’attacco viene inibito ma non segnalato.Esiste una modalità alternativa in cui il RET viene confrontato con il suo “clone” nel Retarray.

Ret Range check

Stack

Segmento dati

Segmento testo

Gli attacchi basati sul buffer overflow, tentano di dirottare il flusso del programma verso il buffer contenete lo shellcodee quindi verso lo stack.Il Ret range check rende lostack non eseguibile.

RANGE

VALIDO

Modalità SpecialeUn puntatore a funzione viene allocato in una zona di memoria in modo casuale. ( stack, heap, segmento dati).Se viene allocato nello stack, l’attackercerca di corrompere il puntatore tramite l’overflow di un buffer.StackShield inizializza un variabile casuale e controlla che non si trovi al di fuori del segmento dati, poiché anche il puntatore verrà allocato nei pressi della variabile.

Flaw Finder

E’ un tool di sviluppo a supporto dei programmatori.È capace di analizzare codice sorgente C/C++.È un semplice parser. Produce in output solo una lista con un grado di potenziale pericolosità delle funzioni.Il database del programma (ruleset) contiene informazioni su operazioni comuni che possono manifestare problemi concernenti la sicurezza.La Ruleset è aggiornabile. Ogni elemento è costituito dalla tupla (Hook, Level, Warning, Suggestion, Category, URL, Other).Per ogni match si propone al programmatore una soluzione.

Flaw Finder

Analisi dei metodi di difesaStackguard e StackShield aggiungono codice e soprattutto “controlli” ai programmi aumentando sensibilmente l’overhead.Ma attenzione….non sono infallibili!

Attacchi a StackGuard

Falle di StackGuardVantaggio offerto da StackGuard:

Protezione dell’indirizzo di ritorno (RET)…

Non basta. Infatti:L’overflow viene scoperto al termine della funzioneNon protegge nessun altro indirizzo (saved frame pointer…)canary può essere aggirato

Falle di StackGuardInefficienze

Un overflow su un buffer situato prima di una o più variabili locali permette di sovrascrivere anche queste ultime.

Se vi è la possibilità di manipolare un puntatore si possono alterare importanti sezioni di memoria (fnlist, GOT, frame pointer).

Attacchi a StackGuard - 1

Attacco Emsi: sostituzioni nella fnlist

fnlist contiene gli indirizzi delle funzioni registrate attraverso atexit()(gdb) b mainBreakpoint 1 at 0x8048790(gdb) rStarting program: /root/StackGuard/c/StackGuard/vulBreakpoint 1, 0x8048790 in main ()(gdb) x/10x &fnlist0x400eed78 <fnlist>: 0x00000000 0x00000002 0x00000003 0x4000b8c00x400eed88 <fnlist+16>: 0x00000000 0x00000003 0x08048c20 0x000000000x400eed98 <fnlist+32>: 0x00000000 0x00000000

Attacchi a StackGuard - 1

È possibile con un debugger scoprirne l’indirizzo e, avendo un puntatore a disposizione nel programma, alterare la registrazione delle funzioni da eseguire all’invocazione di exit().

Nemmeno StackShield è immune a questo attacco

Attacchi a StackGuard - 2

Sostituzioni nella Global Offset Table (GOT)

Simile al precendente attacco: l’obiettivo è alterare l’ordine dell’invocazione delle funzioni.

GOT contiene la corrispondenza indirizzo –funzione.

Avendo la possibilità di manipolare un puntatore è possibile cambiare l’indirizzo associato a una funzione utilizzata.

Attacchi a StackGuard - 2

oredal@Homer:~/src/sg/tests$ cc -o sg1 sg1.coredal@Homer:~/src/sg/tests$ readelf –S sg1|grep got[ 8] .rel.got REL 08048358 etc...[20] .got PROGBITS 08049888 etc...

Come risultato una printf() potrebbe invocare invece una system().

L’attacco riesce anche se SG è utilizzato in combinazione con StackPatch (rende lo stacknon eseguibile).

Attacchi a StackGuard - 3

Alterazione del frame pointer

La combinazione d’uso di SG con un terminator canary (valore fisso 0x000aff0d) permette di arrivare alla sovrascrittura del frame pointer(e di non sovrascrivere il canary) attraverso le comuni funzioni di manipolazione delle stringhe.

In questo modo è possibile ottenere il controllo completo delle variabili locali e degli argomenti delle funzioni.

Il frame pointer non è utilizzato nei programmi compilati con l’opzione –fomit-frame-pointer

That’s all folk!Buffer Overflow: attacco ai servizi di rete

Progetto realizzato da:

Avella GianluigiCerqua PasqualeCrucil SergioD’Alessandro Oreste