rivista HAX #4 - Il mondo di Paolettopn

Il segmento heap, invece, viene utilizzato per l'allocazione
dinamica di porzioni di memoria, come ad
esempio per le strutture in c che vengono accedute
tramite puntatori. E' da notare che questo segmento
non ha una dimensione fissa ma può aumentare o
diminuire in base alle necessità del programma. La
fase di allocazione e di deallocazione delle porzioni
di memoria viene gestita da algoritmi specializzati.
Il segmento stack viene utilizzato per immagazzinare
i dati durante il richiamo di funzioni. Esso funziona
secondo uno schema FIFO, first-in first-out: il primo
elemento inserito nello stack è l'ultimo ad essere
estratto, come avverrebbe in una pila di piatti. Nel
registro ESP viene mantenuto l'indirizzo di memoria
dell'ultimo elemento contenuto nello stack. Anche lo
stack come l'heap non ha una dimensione fissa ma
aumenta e diminuisce in modo dinamico.
Per comprendere i meccanismi che stanno dietro
alle vulnerabilità del codice è anche importante conoscere
alcuni registri della cpu.
La cpu contiene numerosi registri, quelli che interessano
a noi sono EIP e EBP.
L'EIP (Instruction Pointer) contiene l'indirizzo della
successiva istruzione da eseguire.
Nell''EBP (Base Pointer) ,viene salvato l'indirizzo di
ESP prima che questo venga modificato dalla chiamata
di una funzione (che vedremo tra breve cosa
comporta). Viene utilizzato per accedere alle informazioni
del record di attivazione corrente sommando
o sottraendo ad esso un'offset (calcolato in base alla
dimensione occupata dalle variabili che precedono il
punto in cui si vuole arrivare).
Lo stack è molto importante per la gestione del flusso
di esecuzione del programma perchè quando viene
chiamata una funzione viene creato record di attivazione
(o stack frame) in questo modo: prima vengono
inseriti gli argomenti passati alla funzione in
ordine inverso (dall'ultimo al primo), poi viene inserito
l'indirizzo di ritorno contenuto in EIP, poi viene
inserito il valore corrente contenuto nel registro EBP.
I valori salvati nello stack di EBP e dell'indirizzo di
ritorno servono per reimpostare i valori di EBP e EIP
all'interno della cpu dopo che la funzione termina la
sua esecuzione, in questo modo si può ritornare allo
stato precedente della chiamata ad essa. Un esempio
di record di attivazione quando dalla funzione
main viene richiamata la funzione prova e quello
nell'immagine 2.
Ora che sappiamo come un programma viene rappresentato
in memoria durante la sua esecuzione
siamo in grado di capire come sfruttare eventuali
vulnerabilità, ma prima bisogna trovarle!!!!
Per questo scopo utilizziamo un debugger, un programma
che ci permette di eseguire un programma
passo passo e di vedere anche la sua rappresentazione
in memoria, alcuni mostrano anche il programma
in codice assembly. Il più famoso e utilizzato è
GDB (GNU Debugger), in rete ci sono moltissime
guide e inoltre moltissime informazioni è possibile
reperirle nelle pagine di man con il comando:
man gdb
41
Una tipica vulnerabilità del codice che interessa la
memoria è quella del Buffer Overflow e si verifica
quando si passano i limiti dello spazio di memoria
allocato, andando a sovrascrivere lo spazio adiacente.
Quindi è possibili non solo andare a sporcare aree
di memoria ma anche riuscire ad iniettare del codice
da far eseguire, e sta proprio qui il punto di forza
di questa vulnerabilità!!!
Pensate ad un programma per login che abbia una
vulnerabilità di questo tipo :)!!!
Infine vi lascio con un semplice programma:
void prova(char* buff)
{
char buffer[10];
strcpy(buffer,buf);
}
int main()
{
char buffer[30];
int i = 0;
for(i=0; i