Buffer overflow: differenze tra le versioni

Versione delle 21:23, 22 giu 2025

Versione attuale delle 14:18, 29 lug 2025

(Una versione intermedia di un altro utente non mostrate)

Riga 9:

Il primo clamoroso esempio di attacco basato su buffer overflow fu il [[Morris worm|Morris Worm]] (noto anche come Internet Worm), che nel 1988 portò al crash di più di 6.000 sistemi connessi a Internet in poche ore, sfruttando il buffer overflow nel processo demone ''finger'' di UNIX per propagare attraverso la rete.<ref>{{Cita web|url=https://www.sans.org/reading-room/whitepapers/securecode/buffer-overflow-attack-mechanism-method-prevention-386|titolo=Inside the Buffer Overflow Attack:Mechanism, Method, & Prevention}}</ref>

Più tardi, nel 1995, Thomas Lopatic pubblicò sulla [[mailing list]] di Bugtraq un exploit basato sullo stack smashing nel web server NCSA HTTPD su sistema operativo [[HP-UX]], e un anno dopo, nel 1996, Elias Levy (anche noto come Aleph One) pubblicò un articolo intitolato "Smashing the Stack for Fun and Profit" sull'''ezine'' [[Phrack]], una guida step-by-step alle tecniche di exploiting degli stack buffer overflows.<ref>{{Cita web|url=https://rdist.root.org/2010/05/03/why-buffer-overflow-exploitation-took-so-long-to-mature/|titolo=Why buffer overflow exploitation took so long to mature|sito=rdist|data=3 maggio 2010|accesso=5 settembre 2016}}</ref><ref>{{Cita web|url=http://seclists.org/bugtraq/1995/Feb/109|titolo=Bugtraq: Vulnerability in NCSA HTTPD 1.3|cognome=Lopatic|nome=Thomas|sito=seclists.org|accesso=5 settembre 2016}}</ref>

In seguito i buffer overflow furono sfruttati da due importanti ''internet worm'': nel 2001 il [[Code Red (malware)|Code Red worm]], che sfruttava il buffer overflow nei server [[Internet Information Services|Microsoft Internet Information Services]] (IIS) 5.0<ref>{{Cita web|url=https://www.sans.org/reading-room/whitepapers/malicious/code-red-worm-45|titolo=What is Code Red Worm?}}</ref>, e nel 2003 l'[[SQL Slammer]] worm, che compromise le macchine che eseguivano [[Microsoft SQL Server|Microsoft SQL Server 2000]].<ref>{{Cita web|url=http://pen-testing.sans.org/resources/papers/gcih/sql-slammer-worm-101033|titolo=SQL Slammer worm|accesso=5 settembre 2016|dataarchivio=13 settembre 2016|urlarchivio=https://web.archive.org/web/20160913082805/http://pen-testing.sans.org/resources/papers/gcih/sql-slammer-worm-101033|urlmorto=sì}}</ref>

Riga 16:

2011 CWE/SANS Top 25 Most Dangerous Software Errors|sito=cwe.mitre.org|accesso=17 agosto 2016}}</ref>

Nel febbraio 2016 i ricercatori di Google e di Red Hat scoprirono la presenza di una vulnerabilità di tipo stack buffer overflow nella funzione ''getaddrinfo'' della libreria ''[[glibc]]'' (tutte le versioni a partire dalla 2.9). Tale libreria è utilizzata da centinaia di applicazioni e dalla maggior parte delle distribuzioni Linux (incluse quelle installate nei [[router]] e in altro tipo di hardware): la funzione interessata è quella che si occupa del DNS lookup (risoluzione nomi degli host e indirizzi IP) e la vulnerabilità può permettere a un attaccante l'invio di domini o DNS server malevoli, oltre che attacchi ''[[Attacco man in the middle|man-in-the-middle]]'' fino all'esecuzione di codice arbitrario sulla macchina della vittima.<ref>{{Cita web|url=https://security.googleblog.com/2016/02/cve-2015-7547-glibc-getaddrinfo-stack.html|titolo=CVE-2015-7547: glibc getaddrinfo stack-based buffer overflow|lingua=en|accesso=6 settembre 2016}}</ref><ref>{{Cita web|url=https://access.redhat.com/it/node/2171131|titolo=Falla di sicurezza critica: glibc stack-based buffer overflow in getaddrinfo() (CVE-2015-7547) - Red Hat Customer Portal|sito=access.redhat.com|accesso=6 settembre 2016}}</ref>

== Descrizione ==

Quando, per errore o per malizia, vengono inviati più dati della capienza del buffer destinato a contenerli (che per errore, malizia o superficialità non è stato progettato a dovere), i dati ''extra'' vanno a sovrascrivere le variabili interne del programma, o il suo stesso [[Pila (informatica)|stack]]; come conseguenza di ciò, a seconda di cosa è stato sovrascritto e con quali valori, il programma può dare risultati errati o imprevedibili, bloccarsi, o (se è un driver di sistema o lo stesso sistema operativo) bloccare il [[computer]]. Conoscendo molto bene il programma in questione, il sistema operativo e il tipo di computer su cui gira, si può precalcolare una serie di dati ''malevoli'' che inviati per provocare un buffer overflow consenta ad un malintenzionato di prendere il controllo del programma (e a volte, tramite questo, dell'intero computer).

Non tutti i programmi sono vulnerabili a questo tipo di inconveniente. Per i linguaggi di basso livello, come l’assembly, i dati sono semplici array di byte, memorizzati in registri o in memoria centrale: la corretta interpretazione di questi dati (indirizzi, interi, caratteri, istruzioni, ecc…) è affidata alle funzioni e alle istruzioni che li accedono e manipolano; utilizzando linguaggi di basso livello si ha dunque un maggiore controllo delle risorse della macchina, ma è richiesta una maggiore attenzione in fase di programmazione in modo da assicurare l’integritàl’[[integrità dei dati]] (e quindi evitare fenomeni come il buffer overflow). I linguaggi di più alto livello, come Java e Python (e molti altri), che definiscono invece il concetto di tipo di una variabile e che definiscono un insieme di operazioni permesse a seconda del tipo, non soffrono di vulnerabilità come il buffer overflow, perché non consentono di memorizzare in un buffer una quantità maggiore di dati rispetto alla sua dimensione. Fra questi due estremi si trova il linguaggio C che presenta alcune delle astrazioni tipiche dei linguaggi di alto livello insieme a elementi tipici dei linguaggi di basso livello, come la possibilità di accedere e manipolare indirizzi di memoria: ciò rende il linguaggio suscettibile ad usi inappropriati della memoria; se a questo si unisce il fatto che alcune librerie di funzioni molto diffuse (in particolare per l’input e la manipolazione di stringhe come la ''gets'') non effettuano un corretto controllo della dimensione dei buffer su cui lavorano, e che il C è stato usato negli anni ’70 per scrivere il sistema operativo UNIX (e da questo sono poi derivati i sistemi come Linux) e molte delle applicazioni pensate per eseguire su di esso, ne consegue che ancora oggi è presente e circola una grande quantità di codice vulnerabile al buffer overflow.<ref name=":0">{{Cita libro|autore=William Stallings, Lawrie Brown|titolo=Computer Security - Principles and Practice|anno=2015|editore=Pearson|città=|ISBN=978-0-13-377392-7}}</ref>

Non tutti i programmi sono vulnerabili a questo tipo di inconveniente, infatti perché un dato programma sia a rischio è necessario che:

Riga 77:

=== Heap overflow ===

{{Vedi anche|Heap overflow}}

Un programma può richiedere al sistema operativo di allocare dinamicamente una certa quantità di memoria nell'area [[Heap (struttura dati)|heap]], sfruttando chiamate di sistema come ''malloc()'' e ''free''() in C/UNIX. Questi buffer possono ugualmente essere suscettibili a problemi di overflow nel momento in cui vi si possa inserire una quantità di dati superiore alla memoria allocata, e questi dati andrebbero come al solito a sovrascrivere le aree di memoria adiacenti al buffer.