Uno sguardo allo sfruttamento delle vulnerabilità

Dato che non vedevo l'ora di continuare a discutere di questo argomento, lascia che ti racconti un po 'di storia, teoria e pratica sulle vulnerabilità. Ormai abbiamo tutti sentito che le falle di sicurezza possono costare molto, sappiamo tutti che dobbiamo mantenere aggiornato il nostro software, sappiamo tutti che molti aggiornamenti sono causati da errori di sicurezza. Ma oggi vi parlerò un po 'di come questi errori vengono trovati e sfruttati 🙂 Ma prima di questo chiariremo alcuni dettagli per avere una migliore visione d'insieme.

Prima di cominciare

Per prima cosa voglio dirti che ci concentreremo sulla prima vulnerabilità che ho imparato a sfruttare, quella conosciuta Buffer overflow, in questa vulnerabilità approfittiamo della mancanza di verifica della memoria per fare cose divertenti 🙂 Ma chiariamo un po 'di più al riguardo.

Questo non sarà uno scenario del mondo reale

Non posso permettermi di insegnare loro a rompere qualsiasi programma che guardano, primo perché è pericoloso per i loro computer, secondo perché ci vorrebbe più della mia solita quota di parole.

Facciamo un viaggio negli anni '80

Quello che ti mostrerò che posso fare sul mio laptop, ma non significa che possa essere fatto oggi in modo semplice 🙂 molti di questi concetti sono già stati sfruttati così tante volte che nuovi metodi di protezione e nuovi metodi per eludere sono emersi 😛 ma questo ci riporta allo stesso posto, non c'è spazio per poter raccontare tutto ciò 🙂

Potrebbe non funzionare sul tuo processore

Anche se userò un esempio molto semplice, voglio che sia abbastanza chiaro fin dall'inizio che i dettagli di questo sono così tanti e così vari che così come può venire fuori come me, se vuoi provarlo , l'effetto desiderato potrebbe anche non essere ottenuto 🙂 Ma potete immaginare che non posso spiegarlo in questo spazio, soprattutto perché con questa introduzione ho già preso più di 300 parole, quindi arriviamo subito al nostro punto.

Cos'è un file Buffer Overflow

Per rispondere a questa domanda dobbiamo prima capire la prima metà di questa combinazione.

buffer

Poiché tutto riguarda la memoria in un computer, è logico che ci debba essere un qualche tipo di contenitore di informazioni. Quando parliamo di Ingressi o uscite, arriviamo direttamente al concetto di tamponi. Per farla breve, a bufferizzare È uno spazio di memoria di dimensioni definite in cui memorizzeremo una quantità di informazioni, semplice 🙂

Gli overflow si verificano, come suggerisce il nome, quando un buffer si riempie di più informazioni di quante ne possa gestire. Ma perché è così importante?

pila

Conosciuti anche come stack, sono un tipo di dati astratto in cui possiamo pila informazioni, la loro caratteristica principale è che hanno un ordinamento LIFO (ultimo arrivato primo uscito). Pensiamo per un secondo a una pila di piatti, li mettiamo sopra uno per uno e poi li tiriamo fuori uno ad uno dall'alto, questo fa l'ultimo piatto che abbiamo messo (quello che sta in alto ) è il primo piatto che andiamo a togliere, ovviamente se ne possiamo estrarre solo un piatto alla volta e decidiamo di farlo in quest'ordine: P.

Ora che conosci questi due concetti, dobbiamo metterli in ordine. Gli stack sono importanti perché ogni programma che eseguiamo ha i suoi stack di esecuzione. Ma questo stack ha un'estensione caratteristica particolare, cresce. L'unica cosa che devi sapere su questo è che mentre un programma è in esecuzione, quando viene chiamata una funzione, lo stack passa da un numero X in memoria a un numero (Xn). Ma per continuare dobbiamo capire un altro concetto.

Puntatori

Questo è un concetto che fa impazzire molti programmatori quando iniziano nel mondo del C, infatti il ​​grande potere della programmazione in C è dovuto in parte all'uso dei puntatori. Per mantenerlo semplice, un puntatore punta a un indirizzo di memoria. Sembra complesso, ma non è così complesso, abbiamo tutti la RAM nelle nostre macchine, giusto? Bene, questo può essere definito come un file disposizione consecutiva di blocchi, queste posizioni sono normalmente espresse in numeri esadecimali (da 0 a 9 e quindi da A a F, come 0x0, 0x1, 0x6, 0xA, 0xF, 0x10). Qui come nota curiosa, 0x10 NO è uguale a 10 😛 se lo convertiamo in decimale sarebbe come dire 15. Questo è qualcosa che all'inizio confonde anche più di uno, ma passiamo al punto.

Records

I processori funzionano con una serie di record, che funzionano per trasmettere posizioni dalla memoria fisica al processore, per architetture che utilizzano 64 bit, il numero di registri è grande e difficile da descrivere qui, ma per avere un'idea, i registri sono come puntatori, indicano tra le altre cose , uno spazio di memoria (posizione).

Adesso esercitati

So che sono state molte le informazioni da elaborare fino ad ora, ma in realtà sono questioni alquanto complesse che cerco di spiegare in un modo molto semplice, vedremo un piccolo programma che usa i buffer e andremo a romperlo per capire questo sugli overflow, ovviamente questo non lo è È un programma reale e "eluderemo" molte delle contromisure che vengono utilizzate oggi, solo per mostrare come si facevano le cose prima 🙂 e perché alcune sono necessari principi per poter imparare cose più complesse 😉

GDB

Un ottimo programma che è senza dubbio uno dei più utilizzati dai programmatori C. Tra le sue tante virtù abbiamo il fatto che ci permette di vedere tutto ciò di cui abbiamo parlato finora, i registri, lo stack, i buffer, ecc. 🙂 Vediamo il programma che useremo per il nostro esempio.

reinput.c

Questo è un programma abbastanza semplice, useremo la libreria stdio.h per poter ottenere informazioni e visualizzarle in un terminale. Possiamo vedere una funzione chiamata return_input che genera un file bufferizzare detto schieramento, che ha una lunghezza di 30 bytes (il tipo di dati char è lungo 1 byte).

La funzione gets(array); richiedere informazioni per console e funzione printf() restituisce il contenuto dell'array e lo visualizza sullo schermo.

Ogni programma scritto in C inizia con la funzione main(), questo sarà solo incaricato di chiamare return_input, ora compileremo il programma.

Diamo un po 'di quello che ho appena fatto. L'opzione -ggdb dice a gcc di compilare il programma con le informazioni affinché gdb possa eseguire correttamente il debug. -fno-stack-protector È un'opzione che ovviamente non dovremmo usare, ma che useremo perché altrimenti sarebbe possibile generare il buffer overflow nello stack. Alla fine ho testato il risultato. ./a.out esegue solo quello che ho appena compilato, mi chiede informazioni e le restituisce. In esecuzione 🙂

Avvertenze

Un'altra nota qui. Riesci a vedere gli avvertimenti? chiaramente è qualcosa da tenere in considerazione quando lavoriamo con il codice o compiliamo, questo è un po 'ovvio e ci sono pochi programmi che oggi hanno la funzione gets() Nel codice. Un vantaggio di Gentoo è che compilando ogni programma, posso vedere cosa potrebbe esserci di sbagliato, un programma "ideale" non dovrebbe averli, ma saresti sorpreso di quanti programmi di grandi dimensioni hanno questi avvisi perché sono MOLTO grandi ed è è difficile tenerne traccia Funzioni pericolose quando ci sono molti avvisi contemporaneamente. Ora se continuiamo

Debug del programma

Ora questa parte può creare un po 'di confusione, ma dato che ho già scritto abbastanza, non posso permettermi di spiegare tutto, quindi scusa se vedi che sto andando troppo veloce 🙂

Disinserimento del codice

Cominciamo guardando il nostro programma in linguaggio macchina compilato.

Questo è il codice della nostra funzione principale in montaggio, questo è ciò che capisce il nostro processore, la riga a sinistra è l'indirizzo fisico in memoria, il <+ n> è conosciuto come offset, fondamentalmente la distanza dall'inizio della funzione (main) a quell'istruzione (nota come codice operativo). Quindi vediamo il tipo di istruzione (push / mov / callq…) e uno o più registri. Riassumendo possiamo dire che è l'indicazione seguita dalla fonte / origine e dalla destinazione. <return_input> si riferisce alla nostra seconda funzione, diamo un'occhiata.

input_ritorno

Questo è un po 'più complesso, ma voglio solo che controlli un paio di cose, c'è un tag chiamato <gets@plt> e un ultimo codice operativo chiamato retq indicando la fine della funzione. Metteremo un paio di punti di interruzione, uno nella funzione gets e un altro in retq.

Correre

Ora eseguiremo il programma per vedere come inizia l'azione.

Possiamo vedere che appare una piccola freccia che indica il codice operativo in cui ci troviamo, voglio che tengano conto della direzione 0x000055555555469b, questo è l'indirizzo dopo la chiamata a return_input in funzione main , questo è importante poiché è qui che il programma dovrebbe tornare quando finisci di ricevere il ingresso, entriamo nella funzione. Adesso controlliamo la memoria prima di entrare nella funzione gets.

Ho ripristinato la funzione principale per te e ho evidenziato il codice a cui mi riferivo, come puoi vedere, a causa del endianità è stato separato in due segmenti, voglio che tengano conto della direzione 0x7fffffffdbf0 (il primo da sinistra dopo il commando x/20x $rsp) poiché questa è la posizione che dobbiamo utilizzare per controllare i risultati di gets, continuiamo:

Rompere il programma

Li ho evidenziati 0x44444444perché sono la rappresentazione delle nostre D 🙂 ora abbiamo iniziato ad aggiungere ingresso al programma e, come puoi vedere, siamo solo a due righe dal nostro indirizzo desiderato, lo riempiremo fino a quando non saremo appena prima degli indirizzi che abbiamo evidenziato nel passaggio precedente.

Modifica del percorso di ritorno

Ora che siamo riusciti ad entrare in questa sezione del codice dove indica il ritorno della funzione, vediamo cosa succede se cambiamo l'indirizzo 🙂 invece di andare nella posizione dell'opcode che segue quello che avevamo un attimo fa, cosa ne pensi se torniamo a return_input? Ma per questo, è necessario scrivere l'indirizzo che vogliamo in binario, lo faremo con la funzione printf da bash 🙂

Ora abbiamo ricevuto le informazioni due volte 😀 sicuramente il programma non è stato fatto per questo, ma siamo riusciti a rompere il codice e fargli ripetere qualcosa che non avrebbe dovuto fare.

riflessioni

Questa semplice modifica può essere considerata a sfruttare molto semplice 🙂 è riuscito a rompere il programma e fare qualcosa che vogliamo che faccia.

Questo è solo il primo passo in un elenco quasi infinito di cose da vedere e aggiungere, ci sono modi per aggiungere più cose che semplicemente ripetere un ordine, ma questa volta ho scritto molto e tutto ciò che riguarda codifica della shell è un argomento da scrivere più che articoli, libri completi direi. Scusa se non sono stato in grado di approfondire un po 'di più gli argomenti che mi sarebbero piaciuti, ma sicuramente ci sarà una possibilità 🙂 Saluti e grazie per essere arrivato qui