Attacchi di Overflow del Buffer

Gli attacchi di overflow del buffer rappresentano una minaccia significativa per la sicurezza del software. Questi attacchi si verificano quando individui malintenzionati sfruttano vulnerabilità di overflow del buffer. Questo può portare a crash dei programmi, corruzione dei dati, furto di informazioni sensibili e accesso non autorizzato al sistema. Questo articolo spiega cosa sono gli overflow del buffer, come gli aggressori li utilizzano e i metodi per prevenirli nello sviluppo software.

Le Basi degli Overflow del Buffer

Un buffer, nel contesto dell’informatica, è una regione di memoria allocata per memorizzare temporaneamente dei dati. I programmi utilizzano i buffer per contenere vari tipi di dati, come input dell’utente, contenuti di file o stringhe.

Ogni buffer ha una dimensione impostata. I problemi sorgono quando un programma tenta di memorizzare più dati di quanti il buffer possa contenere. In tali casi, i dati in eccesso traboccano dal buffer, invadendo le posizioni di memoria adiacenti. Questo comportamento non intenzionale può portare a crash del programma, corruzione dei dati e vulnerabilità alla sicurezza.

Consideri il seguente esempio nel linguaggio di programmazione C:

char buffer[8];
scanf("%s", buffer);

Questo frammento di codice alloca un buffer di 8 byte per memorizzare una stringa ottenuta dall’input dell’utente. Se l’utente digita più di 8 caratteri, sovrascriverà la memoria vicina.

Sfruttare le Vulnerabilità di Overflow del Buffer

Gli aggressori sfruttano le vulnerabilità di overflow del buffer sovrascrivendo strategicamente parti di memoria che contengono codice eseguibile, sostituendolo con codice malevolo. L’aggressore identifica prima un programma con una nota vulnerabilità di overflow del buffer. L’aggressore invia deliberatamente troppi dati per sopraffare il sistema e causare la corruzione della memoria.

L’aggressore vuole sostituire il buffer con codice malevolo. Questo codice può eseguire azioni dannose, come aprire una shell o eseguire comandi senza permesso. L’attacco riesce quando l’aggressore cambia l’indirizzo di ritorno di una funzione o un gestore di eccezioni. Quando l’utente esegue il codice alterato, esso esegue il codice malevolo.

Per illustrare questo concetto, consideri un programma server che riceve nomi utenti dai client. Se lo spazio di memorizzazione del nome utente è di 128 byte, un hacker potrebbe inviare un nome utente dannoso in un determinato formato.

"A" * 132 + codice_malevolo + falso_indirizzo_di_ritorno

La serie di caratteri “A” fa traboccare il buffer, permettendo al codice malevolo di scrivere nella memoria. Il falso indirizzo di ritorno assicura che il codice malevolo venga eseguito quando la funzione sovrascritta ritorna.

Esempi Reali di Overflow del Buffer

Ogni attacco di overflow del buffer si riduce alla stessa strategia:

Ecco alcuni esempi reali di vulnerabilità di overflow trovate in popolari DBMS nel corso degli anni.

MySQL COM_FIELD_LIST

Fino al 2012 MySQL e MariaDB erano soggetti alla vulnerabilità COM_FIELD_LIST. I fondamenti della vulnerabilità erano i seguenti:

Il colpevole eseguiva una query al Server MySQL con una clausola ‘FROM’, specificando un nome di tabella molto lungo per causare un overflow del buffer.

SELECT * FROM 'nome_molto_lungo_di_una_tabella'.

La lunghezza esatta non era specificata, ma 5000 byte erano sufficienti per causare un overflow. Questo causava lo spegnimento del server, ma nel momento tra l’overflow e lo spegnimento il server diventava vulnerabile agli attacchi. In questo punto i colpevoli inserivano codice malevolo in forma di byte esadecimali.

SELECT * FROM 'nome_molto_lungo'.\x31\xc0\x50\x68\x2f\x2f\x73'

Il codice doveva eseguire comandi bash, ad esempio ‘rm -rf /bin/’.

Per una maggiore probabilità di successo, i colpevoli aggiungevano un segmento No Operation al codice, in altre parole codice che non esegue nulla.

Una query completa avrebbe l’aspetto seguente:

SELECT * FROM 'AAAAAAAAAAA..' causando overflow del buffer
'\x0\x0\x0\x0\x0' - No Operation slide
'\xe3\x50\x53\x89\xe1\xb0\x0b' - Codice malevolo.

La vulnerabilità è stata affrontata nelle versioni MySQL 5.5.23, 5.1.63 e 5.6.6, nonché nelle versioni MariaDB 5.5.23, 5.3.12, 5.2.14 e 5.1.63. Aggiornare a queste versioni o successive ha corretto la vulnerabilità e protetto i database da questo specifico attacco.

PostgreSQL 9.3 RESETXLOG Buffer Overflow

Allo stesso modo nel 2013 fu scoperto e rapidamente risolto che la funzione pg_resetxlog() di PostgreSQL era soggetta a questi attacchi.

postgres=# SELECT pg_resetxlog('A' * 1000 + *codice malevolo*);

SQL Server Slammer Worm

Nel 2003 fu scoperto l’attacco SQL Server Slammer Worm. Questo attacco mirava al server di risoluzione di SQL Server, che accetta pacchetti UDP sulla porta 1434. Quando veniva inviato un pacchetto appositamente costruito a questa porta, si verificava un overflow del buffer che permetteva al worm di eseguire codice arbitrario. Questo codice causava al server di inviare più copie del worm, portando a una rapida diffusione e a una massiccia congestione della rete. Un esempio sarebbe simile a questo:

payload = create_malicious_packet()
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto('A' * 1000, *codice malevolo*, (target_ip, 1434))
sock.close()

Oracle 9i XDB HTTP Buffer Overflow

Nel 2003 fu scoperta una vulnerabilità di overflow in Oracle Server. Gli aggressori potevano inviare un nome utente molto lungo in una richiesta HTTP GET, che avrebbe causato l’overflow del buffer e quindi eseguito codice malevolo.

long_username = 'A' * 1000 + *codice malevolo*
password = 'password'
credentials = f"{long_username}:{password}"
encoded_credentials = base64.b64encode(credentials.encode()).decode()
http_request = ( "GET / HTTP/1.1\r\n" f"
Host: {target_ip}\r\n" "User-Agent: Mozilla/5.0\r\n" f"
Authorization: Basic {payload}\r\n" "Accept: */*\r\n" "\r\n" )
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((target_ip, target_port))
sock.sendall(http_request.encode())

Questo snippet mostra uno script Python che trasmette credenziali al server Oracle che manda in overflow il suo buffer. Di conseguenza, le credenziali eseguono il codice malevolo.

Prevenire le Vulnerabilità di Overflow del Buffer

Sviluppare software sicuri richiede un approccio proattivo per prevenire le vulnerabilità di overflow del buffer. Le seguenti strategie sono essenziali per mitigare i rischi associati agli overflow del buffer:

1. Validazione dell’Input: Assicurarsi che tutti i dati forniti dall’utente rientrino nei limiti previsti prima di memorizzarli nei buffer. Validare la lunghezza dell’input, il formato e il contenuto per prevenire che dati malevoli o non intenzionali causino overflow del buffer.
2. Funzioni di Stringa e Memoria Sicure: Evitare l’uso di funzioni di libreria standard che sono inclini agli overflow del buffer. Invece, optare per alternative più sicure, come `strncpy` e `memcpy_s`, che includono meccanismi di protezione contro gli overflow.
3. Protezioni a Livello di Sistema: Abilitare funzionalità di sicurezza a livello di sistema, come la casualizzazione del layout dello spazio di indirizzamento (ASLR) e la prevenzione dell’esecuzione dei dati (DEP), quando possibile. Questi meccanismi rendono più difficile per gli attaccanti prevedere i layout della memoria ed eseguire codice malevolo.
4. Utilizzare linguaggi di programmazione sicuri per la memoria come Rust, Go o Java per proteggere dagli overflow del buffer. Questi linguaggi impongono pratiche di gestione della memoria rigorose e impediscono l’accesso diretto alla memoria, riducendo il rischio di vulnerabilità di overflow.
5. Aggiornamenti Software Regolari: Aggiornare prontamente le librerie software e le dipendenze appena vengono scoperte e rilasciate patch per le vulnerabilità di overflow del buffer. Mantenersi aggiornati con le ultime patch di sicurezza è cruciale per proteggere da vulnerabilità note.

L’uso di strumenti di fuzz testing e tecniche SAST come l’analisi delle contaminazioni può aiutare a trovare bug di overflow del buffer durante lo sviluppo software.

Impatto Reale degli Attacchi di Overflow del Buffer

Nel corso della storia dell’informatica, molti incidenti di sicurezza di alto profilo sono stati attribuiti a vulnerabilità di overflow del buffer. Il worm Morris fu uno dei primi worm su Internet. Si diffondeva sfruttando una falla di sicurezza nel programma Unix `finger` nel 1988.

Nel 2017, il virus WannaCry ha sfruttato una debolezza nel protocollo Windows Server Message Block per diffondersi. In un solo giorno, WannaCry ha infettato oltre 230.000 computer in tutto il mondo, causando notevoli perdite finanziarie e interruzioni.

Conclusione

Gli attacchi di overflow del buffer rimangono una preoccupazione critica nel campo della sicurezza del software. Gli sviluppatori possono proteggere il loro software dagli attacchi imparando sugli overflow del buffer e come gli aggressori li sfruttano.

È importante utilizzare pratiche di codifica sicura. Queste pratiche includono la validazione dell’input e funzioni di memoria sicure. Aiutano a prevenire le vulnerabilità di overflow del buffer nei sistemi. Adottare linguaggi di programmazione sicuri per la memoria e mantenere aggiornate le dipendenze software migliora ulteriormente la resilienza dei sistemi software.

Gli sviluppatori di software possono migliorare la sicurezza dei sistemi digitali prevenendo gli overflow del buffer e rimanendo al corrente delle nuove minacce. Questo protegge i dati e assicura che i sistemi informatici rimangano affidabili.

“`