Firefox CVE-2024-9680

CVE-2024-9680

Descrizione

Un attaccante è riuscito a ottenere l'esecuzione di codice nel processo dei contenuti sfruttando una use-after-free nelle timeline delle animazioni. Abbiamo ricevuto segnalazioni di questa vulnerabilità sfruttata in natura. Questa vulnerabilità riguarda Firefox < 131.0.2, Firefox ESR < 128.3.1, Firefox ESR < 115.16.1, Thunderbird < 131.0.1, Thunderbird < 128.3.1 e Thunderbird < 115.16.0.

tl;dr (Versione video)

Crediti: Fireship

Exploit use-after-free ?!

Una vulnerabilità "use-after-free" è un tipo di problema di corruzione della memoria che si verifica quando un programma continua a utilizzare un puntatore (o riferimento) alla memoria dopo che questa è stata liberata (deallocata). Questa è una condizione pericolosa perché la memoria in questione non è più di proprietà del programma, il che significa che potrebbe essere riassegnata per un altro scopo o alterata da altre parti del programma. Se il programma continua a utilizzare questa memoria liberata, può portare a comportamenti imprevedibili, inclusi crash, corruzione dei dati o sfruttamento da parte di attaccanti.

Analisi della vulnerabilità:

1. Allocazione e deallocazione della memoria:

   • In molti linguaggi di programmazione, specialmente quelli come C e C++, la memoria è gestita manualmente. Gli sviluppatori allocano memoria quando ne hanno bisogno (ad esempio, con funzioni come malloc() o new) e la liberano quando hanno finito (ad esempio, con free() o delete).

2. Il problema:

   • Un problema di use-after-free si verifica quando un puntatore punta ancora a memoria che è già stata liberata. Se il programma successivamente tenta di leggere o scrivere in questa memoria, possono accadere cose inaspettate perché la memoria può ora essere riallocata a un'altra parte del programma, alterata o addirittura non più disponibile per un uso sicuro.

3. Conseguenze:

   • Crash: il programma potrebbe tentare di accedere a memoria non valida o corrotta, causando un crash.
   • Corruzione dei dati: il programma potrebbe sovrascrivere o leggere involontariamente dati non desiderati, causando corruzione.
   • Sfruttamento della sicurezza: gli attaccanti possono sfruttare le vulnerabilità use-after-free manipolando lo spazio di memoria del programma. Ad esempio, se un attaccante può allocare dati controllati nella memoria liberata, potrebbe potenzialmente eseguire codice arbitrario, modificare il flusso di esecuzione del programma o ottenere accessi non autorizzati.

Scenario di esempio:

Considera un esempio semplificato in C:

#include <stdlib.h>
#include <stdio.h>

int main() {
    int *ptr = (int *)malloc(sizeof(int)); // Allocate memory
    *ptr = 42;                             // Use the allocated memory
    free(ptr);                             // Free the memory

    // Use the pointer after freeing the memory (use-after-free)
    printf("%d\n", *ptr);                  // Undefined behavior, potential crash or exploit
    return 0;
}

Nell'esempio:

• La memoria viene allocata per un intero e il valore 42 viene assegnato ad esso.
• La memoria viene quindi liberata con free(ptr).
• Dopo aver liberato la memoria, il puntatore ptr viene ancora utilizzato (dereferenziato nell'istruzione printf()), il che porta a un comportamento indefinito. La memoria potrebbe essere stata riassegnata e l'accesso ad essa potrebbe causare un crash o, in uno scenario più pericoloso, lo sfruttamento del programma.

Potenziale di sfruttamento:

Gli attaccanti possono sfruttare le vulnerabilità use-after-free manipolando attentamente la gestione della memoria. Ecco come un attaccante potrebbe potenzialmente utilizzare questa vulnerabilità:

1. Riallocazione della memoria: dopo che la memoria è stata liberata, se l'attaccante può controllare quali dati vengono inseriti in quella memoria liberata, può far sì che il programma utilizzi questi nuovi dati al posto di quelli originali.
2. Iniezione di codice: in alcuni casi, l'attaccante potrebbe iniettare codice malevolo nella posizione di memoria, consentendogli di dirottare il flusso di controllo del programma, portando all'esecuzione remota di codice o all'escalation dei privilegi.

Mitigazioni:

Per prevenire le vulnerabilità use-after-free, gli sviluppatori possono:

• Impostare i puntatori a NULL dopo averli liberati: ciò garantisce che, se un puntatore viene accidentalmente utilizzato dopo essere stato liberato, il programma vada in crash in modo più prevedibile o si comporti in modo controllato, piuttosto che accedere a memoria non valida.
• Puntatori intelligenti: in linguaggi come C++, l'uso di puntatori intelligenti (ad esempio std::shared_ptr, std::unique_ptr) può aiutare a gestire la memoria automaticamente, riducendo le probabilità di una gestione manuale errata della memoria.
• Controllo dei limiti e sanitizer: utilizzare strumenti come AddressSanitizer (ASan) che aiutano a rilevare le condizioni di use-after-free durante lo sviluppo.

Come la timeline delle animazioni CSS ha sfruttato la falla

In questo caso specifico, la timeline delle animazioni CSS—responsabile del controllo della temporizzazione delle animazioni in una pagina web—interagiva con altri componenti del browser in modo tale che un oggetto legato alla timeline dell'animazione veniva liberato, ma il browser continuava a utilizzarlo.

1. Meccanismo della timeline delle animazioni CSS:

• La timeline delle animazioni CSS in Firefox è responsabile del coordinamento della temporizzazione e della progressione delle animazioni. Gestisce essenzialmente quando e come le animazioni iniziano, si fermano e transitano tra i keyframe. Ogni volta che un'animazione viene aggiornata o interrogata, il browser deve recuperare e manipolare gli oggetti associati alla timeline.

2. Gestione errata degli oggetti:

• A causa di un difetto nella gestione della timeline delle animazioni CSS da parte di Firefox, un oggetto (o una serie di oggetti) che avrebbe dovuto essere protetto (mantenuto in memoria) mentre era ancora in uso nella timeline è stato invece liberato (deallocato) prematuramente.
• Nonostante la memoria fosse stata liberata, la timeline tentava ancora di fare riferimento all'oggetto per aggiornare o interrogare l'animazione, innescando una condizione di use-after-free. In questo stato, la memoria poteva essere riassegnata, oppure i dati potevano essere corrotti o controllati da un attaccante.

3. Controllo dell'attaccante:

• La chiave per sfruttare una vulnerabilità use-after-free è il tempismo e il controllo dello stato della memoria. Un attaccante potrebbe creare una pagina web malevola che innesca l'animazione CSS per manipolare gli stati interni degli oggetti del browser.
• Dopo che la memoria legata alla timeline viene liberata, l'attaccante potrebbe potenzialmente riempire quello spazio di memoria con dati controllati (ad esempio, iniettando dati specifici nella memoria liberata). Quando la timeline delle animazioni CSS tenta di fare riferimento alla memoria liberata, potrebbe finire per accedere a questi dati iniettati, portando alla possibilità di esecuzione remota di codice (RCE), crash del browser o altri comportamenti indesiderati.

4. Meccanismo di sfruttamento:

• Innescare la vulnerabilità: un attaccante potrebbe creare contenuti HTML e CSS specifici per costringere il browser a liberare memoria ancora in uso dalla timeline delle animazioni CSS. Ciò comporterebbe probabilmente la manipolazione della temporizzazione delle animazioni, l'interruzione e l'avvio delle animazioni in rapida successione o lo sfruttamento di casi limite nell'elaborazione dei keyframe delle animazioni.
• Sfruttare la memoria liberata: una volta che l'oggetto viene liberato, l'attaccante potrebbe essere in grado di controllare attentamente ciò che viene inserito nello slot di memoria liberato (tramite tecniche di allocazione della memoria), il che potrebbe consentirgli di sovrascrivere l'oggetto con dati malevoli.
• Esecuzione di codice malevolo: quando la timeline delle animazioni CSS tenta di accedere a questa memoria, potrebbe erroneamente utilizzare i dati controllati dall'attaccante, eseguendo potenzialmente codice iniettato dall'attaccante.

5. Impatto:

• Esecuzione remota di codice (RCE): l'obiettivo finale di molti exploit use-after-free è ottenere la RCE, dove l'attaccante può eseguire codice arbitrario sulla macchina dell'utente. Ciò accade quando l'attaccante riesce a manipolare lo spazio di memoria del browser abbastanza da controllare ciò che viene eseguito successivamente.
• Crash del browser: anche se l'exploit non raggiunge la RCE, le vulnerabilità use-after-free spesso causano il crash del browser quando questo tenta di accedere a memoria non valida.

Perché la timeline delle animazioni CSS è vulnerabile:

La timeline delle animazioni CSS è un sistema complesso che interagisce con molte parti diverse del motore del browser, come il motore di rendering, il DOM (Document Object Model) e l'ambiente di esecuzione di JavaScript. Gestire il ciclo di vita degli oggetti legati alle animazioni—specialmente quando vengono aggiornati o rimossi dinamicamente—è complicato, e anche piccoli errori nella gestione della memoria possono portare a bug di use-after-free.

Nel caso di CVE-2024-9680, sembra che l'oggetto della timeline non sia stato tracciato correttamente, quindi è stato liberato mentre era ancora in uso. Se un attaccante può innescare ripetutamente questo bug con aggiornamenti o manipolazioni delle animazioni tempestivamente calibrati, può potenzialmente sfruttare la vulnerabilità.

Esempio concettuale:

Questo esempio ipotetico potrebbe comportare la creazione di una pagina web con un set complesso di animazioni CSS e la loro manipolazione dinamica tramite JavaScript per innescare una condizione di use-after-free.

<!DOCTYPE html>
<html>
<head>
    <style>
        @keyframes exampleAnimation {
            from { opacity: 0; }
            to { opacity: 1; }
        }

        .animate {
            animation: exampleAnimation 5s infinite;
        }
    </style>
</head>
<body>
    <div id="targetElement" class="animate">Animating Element</div>

    <script>
        // Example setup: A function that continuously creates and destroys animations
        // The goal here is to simulate rapid, repeated manipulations of the CSS animation timeline
        function triggerVulnerability() {
            const target = document.getElementById('targetElement');

            // Create an animation, then remove it quickly in a loop
            let i = 0;
            const interval = setInterval(() => {
                i++;
                if (i % 2 === 0) {
                    target.classList.add('animate');
                } else {
                    target.classList.remove('animate');
                }

                // Potentially causing a race condition or triggering the vulnerability
                if (i > 1000) { 
                    clearInterval(interval); 
                }
            }, 1); // Rapid manipulation of the animation state
        }

        // Simulating dynamic DOM manipulation and timeline interaction
        triggerVulnerability();
    </script>
</body>
</html>

Cosa fa questo codice:

1. Il CSS definisce un'animazione (exampleAnimation) che fa dissolvere in entrata l'opacità di un elemento.
2. JavaScript (triggerVulnerability()) aggiunge e rimuove rapidamente la classe animate da un elemento, causando l'aggiornamento ripetuto della timeline delle animazioni del browser e potenzialmente costringendo il browser a gestire la creazione e la distruzione degli oggetti in rapida successione.
3. Questa rapida manipolazione delle animazioni potrebbe, in teoria, causare una gestione impropria della memoria da parte del browser se c'è un difetto nel modo in cui traccia gli oggetti delle animazioni (come nella timeline delle animazioni CSS).

Percorso concettuale verso lo sfruttamento:

1. Allocazione e deallocazione degli oggetti: quando viene creata un'animazione, il browser alloca memoria per gestirla. Se l'animazione viene interrotta o rimossa, questa memoria viene liberata.
2. Innesco della use-after-free: nel caso ipotetico di una vulnerabilità, la rapida creazione e distruzione degli oggetti dell'animazione potrebbe far sì che il browser tenti di accedere a un oggetto già deallocato, portando a una condizione di use-after-free.
3. Potenziale di sfruttamento: se un attaccante può controllare questa memoria (magari costringendo il browser ad allocare dati controllati nello spazio di memoria liberato), potrebbe potenzialmente manipolare il comportamento del browser, portando all'esecuzione remota di codice.