Attacchi di Buffer Overflow: Una Pericolosa Minaccia Digitale

Gli attacchi di buffer overflow rappresentano una significativa minaccia alla sicurezza del software. Questi attacchi si verificano quando individui malintenzionati sfruttano vulnerabilità di buffer overflow. Ciò può portare a crash del programma, corruzione dei dati, furto di informazioni sensibili e accesso non autorizzato ai sistemi. Questo articolo spiega il buffer overflow, come viene utilizzato dagli attaccanti e i metodi per prevenirlo nello sviluppo del software.

Le Basi del Buffer Overflow

Un buffer, nel contesto dell’informatica, è una regione di memoria allocata per memorizzare temporaneamente 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 determinata. I problemi si verificano 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 indesiderato può portare a crash del programma, corruzione dei dati e vulnerabilità di sicurezza.

Consideriamo 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 inserisce più di 8 caratteri, sovrascriverà la memoria vicina.

Sfruttamento delle Vulnerabilità di Buffer Overflow

Gli attaccanti sfruttano le vulnerabilità di buffer overflow sovrascrivendo strategicamente porzioni di memoria che contengono codice eseguibile, sostituendolo con codice dannoso. L’attaccante prima identifica un programma con una nota vulnerabilità di buffer overflow. L’attaccante invia intenzionalmente troppi dati per sovraccaricare il sistema e causare corruzione della memoria.

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

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

"A" * 132 + codice_dannoso + indirizzo_di_ritorno_falso

La serie di caratteri “A” trabocca il buffer, permettendo al codice dannoso di scrivere nella memoria. L’indirizzo di ritorno falso assicura che il codice dannoso venga eseguito quando la funzione sovrascritta ritorna.

Esempi Reali di Buffer Overflow

Ogni attacco di buffer overflow si riduce alla stessa strategia:

Ecco alcuni esempi concreti di vulnerabilità di overflow trovate nei popolari DBMS nel corso degli anni.

MySQL COM_FIELD_LIST

Fino al 2012, MySQL e MariaDB erano soggetti alla vulnerabilità COM_FIELD_LIST. Le basi della vulnerabilità erano le seguenti:

Un perpetratore farebbe una query al server MySQL con una clausola ‘FROM’, specificando un nome di tabella molto lungo per causare 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. Ciò causerebbe lo spegnimento del server, ma nel momento tra l’overflow e lo spegnimento il server diventa vulnerabile agli attacchi. In questo momento i perpetratori inserirebbero codice dannoso in forma di byte esadecimali.

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

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

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

Una query completa apparirebbe così:

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

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. L’aggiornamento a queste versioni o successive ha risolto la vulnerabilità e protetto i database da questo specifico attacco.

PostgreSQL 9.3 RESETXLOG Buffer Overflow

In modo simile, nel 2013 è stato scoperto e fissato rapidamente che la funzione pg_resetxlog() di PostgreSQL era soggetta a questi attacchi.

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

SQL Server Slammer Worm

Nel 2003 è stato scoperto l’attacco del worm SQL Server Slammer. Prendeva di mira il server di risoluzione SQL Server, che accetta pacchetti UDP sulla porta 1434. Quando veniva inviato a questa porta un pacchetto appositamente creato, traboccava il buffer e consentiva al worm di eseguire codice arbitrario. Questo codice causava l’invio di ulteriori copie del worm, portando a una diffusione rapida 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 dannoso*, (target_ip, 1434))
sock.close()

Oracle 9i XDB HTTP Buffer Overflow

Nel 2003 è stata scoperta una vulnerabilità di overflow nel server Oracle. Gli attaccanti potevano inviare un nome utente molto lungo in una richiesta HTTP GET, che avrebbe traboccato il buffer e quindi eseguito codice dannoso.

long_username = 'A' * 1000 + *codice dannoso*
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 frammento mostra uno script Python che trasmette credenziali al server Oracle che trabocca il buffer. Di conseguenza, le credenziali eseguono codice dannoso.

Prevenzione delle Vulnerabilità di Buffer Overflow

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

1. Validazione dell’Input: Assicurati che tutti i dati forniti dall’utente siano entro i limiti previsti prima di memorizzarli nei buffer. Valida la lunghezza, il formato e il contenuto dell’input per evitare che dati dannosi o indesiderati causino overflow del buffer.
2. Funzioni di Stringa e Memoria Sicure: Evita di utilizzare le funzioni della libreria standard che sono soggette a buffer overflow. Scegli invece alternative più sicure, come `strncpy` e `memcpy_s`, che includono meccanismi di sicurezza integrati contro gli overflow.
3. Protezioni a Livello di Sistema: Abilita funzionalità di sicurezza a livello di sistema, come l’indirizzamento casuale dello spazio degli indirizzi (ASLR) e la prevenzione dell’esecuzione dei dati (DEP), quando possibile. Questi meccanismi rendono più difficile per gli attaccanti prevedere le disposizione della memoria ed eseguire codice dannoso.
4. Usa lingue di programmazione sicure per la memoria come Rust, Go o Java per proteggere contro i buffer overflow. Questi linguaggi applicano pratiche di gestione della memoria rigorose e impediscono l’accesso diretto alla memoria, riducendo il rischio di vulnerabilità da overflow.
5. Aggiornamenti Regolari del Software: Aggiorna prontamente le librerie software e le dipendenze quando vengono scoperte vulnerabilità di buffer overflow e rilasciate patch. Mantenere il software aggiornato con le ultime patch di sicurezza è cruciale per proteggersi dalle vulnerabilità conosciute.

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

Impatto del Mondo Reale degli Attacchi di Buffer Overflow

Nel corso della storia dell’informatica, numerosi incidenti di sicurezza di alto profilo sono stati attribuiti alle vulnerabilità di buffer overflow. Il worm Morris è stato uno dei primi worm di internet. Si è diffuso sfruttando una falla di sicurezza nel programma Unix `finger` nel 1988.

Nel 2017, il WannaCry virus 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 ingenti perdite finanziarie e interruzioni.

Conclusione

Gli attacchi di buffer overflow rimangono una preoccupazione critica nel campo della sicurezza del software. Gli sviluppatori possono proteggere il loro software dagli attacchi acquisendo una comprensione dei buffer overflow e di come vengano sfruttati dagli aggressori.

È importante utilizzare pratiche di codifica sicure. Queste pratiche comprendono la validazione dell’input e l’uso di funzioni di memoria sicure. Aiutano a prevenire le vulnerabilità di buffer overflow 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 i buffer overflow e rimanendo consapevoli delle nuove minacce. Ciò protegge i dati e garantisce l’affidabilità dei sistemi informatici.