Questo è un tipo di exploit molto specifico che affligge tutti i tipi di software.

Use-After-Free (UAF) è una vulnerabilità primitiva di danneggiamento della memoria che continua a rappresentare una minaccia significativa per tutti i tipi di software, dai sistemi operativi al software applicativo. Questo critico difetto di sicurezza si verifica quando un componente dell'applicazione tenta di accedere ai dati in un indirizzo di memoria che è già stato liberato, da cui il nome use-after-free.

Le vulnerabilità UAF possono portare al potenziale sfruttamento del software o persino alla compromissione del sistema. Ecco cos'è la vulnerabilità UAF, perché si verifica e come puoi proteggere il tuo software da una vulnerabilità UAF.

Qual è la vulnerabilità Use-After-Free (UAF)?

Prima di immergerci nella vulnerabilità Use-After-Free, facciamo un passo indietro e comprendiamo alcune nozioni di base sulla gestione della memoria. Quando un programma viene eseguito, i suoi dati e il suo codice vengono caricati nella memoria.

instagram viewer

La gestione della memoria è il processo di gestione di come archiviare (chiamata allocazione della memoria) e rimuovere (chiamata deallocazione della memoria) i dati e il codice nella memoria in modo ottimale. I due segmenti di memoria principale in cui sono memorizzati i dati del programma sono la pila e il mucchio.

Ai programmi può essere allocato lo spazio di memoria in modo statico nello stack e dinamicamente nell'heap. Una vulnerabilità use-after-free si verifica quando i programmatori non gestiscono correttamente l'allocazione dinamica della memoria e la deallocazione nei loro programmi. Ciò significa che la classe di vulnerabilità UAF è un tipo di sfruttamento dell'heap. Per comprendere meglio questa vulnerabilità, aiuta ad avere una forte comprensione di come funzionano i puntatori nella programmazione.

Use-After-Free (UAF), come suggerisce il nome, è un tipo di vulnerabilità primitiva di corruzione della memoria che si verifica quando un oggetto che è già stato si accede nuovamente alla deallocazione dalla memoria con conseguenti arresti anomali o conseguenze indesiderate come perdite di memoria, Escalation of Privilege (EOP) o codice arbitrario esecuzione. Impariamo innanzitutto come si verifica questa condizione e come viene sfruttata.

Come viene sfruttato Use-After-Free (UAF)?

Use-After-Free (UAF), come suggerisce il nome, è una vulnerabilità primitiva di corruzione della memoria che si verifica quando un programma continua ad accedere alle posizioni di memoria che ha liberato. Diamo un'occhiata a un codice di esempio:

#includere <stdio.H>
#includere <stlib.H>
intprincipale(){
int *MUO = malloc (dimensione(int));
 *MUO = 69420;
printf("Valore: %d\n", *MUO);
 gratuito (MUO);
printf("Valore?: %d\n", *MUO);
ritorno0;
}

Potrebbe individuare la vulnerabilità? Come puoi vedere, in questo codice, il MUO puntatore viene deallocato dalla memoria utilizzando il gratuito() funzione, tuttavia viene chiamata di nuovo nella riga successiva utilizzando il stampaf() funzione. Ciò si traduce in un comportamento imprevisto del programma e, a seconda di dove è presente la vulnerabilità nel software, può essere sfruttata per ottenere un'escalation dei privilegi e perdite di memoria.

Come mitigare Use-After-Free?

UAF si verifica a causa di errori nella programmazione di un'applicazione. Ci sono alcune precauzioni che puoi prendere per evitare le vulnerabilità Use-After-Free nel tuo software.

Ecco alcune best practice che puoi adottare per ridurre al minimo le vulnerabilità di danneggiamento della memoria nel tuo software:

  • Utilizzo di linguaggi di programmazione sicuri per la memoria come Rust con meccanismi integrati per prevenire vulnerabilità di corruzione primitiva della memoria come UAF, buffer overflow, ecc. Se usi linguaggi di programmazione come C/C++, è più probabile che tu introduca bug di memoria nel tuo codice. Per lo stesso motivo, anche i sistemi operativi come Windows e Linux stanno lentamente migrando verso Rust. Dovresti anche considerare conoscere Rust se crei programmi di basso livello.
  • Oltre a utilizzare un linguaggio sicuro per la memoria, si consiglia di seguire le procedure consigliate come l'impostazione di un puntatore al valore NULL dopo che è stato liberato per evitare qualsiasi introduzione della vulnerabilità Use-After-Free.
  • Puoi anche implementare tecniche come One Time Allocation (OTA) che impediscono agli aggressori di accedere alla memoria liberata oggetti e una Strict Object Lifecycle Policy, che aiuta a tenere traccia di ogni oggetto di memoria allocato e deallocato. Tieni presente, tuttavia, che queste implementazioni possono aumentare il sovraccarico di memoria e prestazioni.

Esempi reali di vulnerabilità Use-After-Free (UAF).

La vulnerabilità Use-After-Free (UAF) è stata scoperta e sfruttata in vari scenari del mondo reale, dai browser Web al kernel Android fino alle applicazioni di tutti i giorni. Ciò dimostra la necessità di misure di sicurezza proattive. Alcuni esempi reali di UAF includono:

  • Browser Internet: le vulnerabilità UAF nei browser Web sono state sfruttate per eseguire codice arbitrario, compromettere la privacy degli utenti ed eseguire attacchi di esecuzione di codice in modalità remota. Un esempio recente potrebbe essere CVE-2021-38008, che ha sfruttato una vulnerabilità UAF in Google Chrome, consentendo agli attori delle minacce di eseguire codice arbitrario in remoto sulla macchina vittima.
  • Sistemi operativi: le vulnerabilità UAF rilevate nei kernel Windows/Linux/Android hanno consentito agli aggressori di ottenere privilegi elevati, aggirare i meccanismi di sicurezza e ottenere persistenza. Ci sono una miriade di vulnerabilità UAF che sono state trovate e si trovano ancora nei kernel del sistema operativo fino ad oggi. Al momento della stesura di questo documento, CVE-2023-3269, un'altra vulnerabilità UAF nel kernel Linux che porta all'escalation dei privilegi è stata rilasciata pubblicamente. CVE-2022-23270 è un esempio di vulnerabilità UAF nel kernel di Windows.
  • Applicazioni software: le vulnerabilità UAF nelle applicazioni software sono state sfruttate per manipolare il programma comportamento, che porta alla divulgazione di informazioni, all'esecuzione di codice arbitrario, al crash del programma e, nel peggiore dei casi, al privilegio escalation. Diverse applicazioni software sono state e sono tuttora suscettibili agli attacchi UAF. Questi software sono principalmente programmi C/C++ che sono stati sviluppati con approcci di gestione della memoria inefficienti e non sicuri.

Per ulteriori informazioni sulle vulnerabilità Use-After-Free nelle applicazioni del mondo reale, puoi controllare il file ufficiale MITRE CVE elenco pagina e ordina per parola chiave Use-After-Free.

L'efficiente allocazione della memoria aiuta a rendere il software sicuro

Un'allocazione della memoria ottimale e ben ponderata è molto utile per proteggere le tue applicazioni dal cadere preda di comuni vulnerabilità di danneggiamento della memoria primitiva.

UAF insieme a Time Of Check Time of Use (TOCTOU), race condition e Buffer Overflows (BOF) sono alcune delle vulnerabilità della memoria più comunemente sfruttate. Tutti questi possono essere evitati imparando come la memoria del tuo programma è gestita dalla piattaforma su cui gira. Questo ti dà chiarezza su come il sistema operativo sta allocando il tuo programma nella memoria e ti fornisce gli strumenti per progettare software per prestazioni e sicurezza ottimali.

Se non l'hai già fatto, puoi iniziare comprendendo come viene eseguita la gestione della memoria su Linux, il sistema operativo per server più utilizzato al mondo.