Firefox CVE-2024-9680

CVE-2024-9680

Description

Un attaquant a pu exécuter du code dans le processus de contenu en exploitant une use-after-free dans les timelines d'animation. Nous avons eu des signalements de cette vulnérabilité exploitée dans la nature. Cette vulnérabilité affecte Firefox < 131.0.2, Firefox ESR < 128.3.1, Firefox ESR < 115.16.1, Thunderbird < 131.0.1, Thunderbird < 128.3.1, et Thunderbird < 115.16.0.

tl;dr (Version vidéo)

Crédit : Fireship

Exploitation de type Use-After-Free ?!

Une vulnérabilité de type « use-after-free » est un problème de corruption mémoire qui survient lorsqu'un programme continue d'utiliser un pointeur (ou une référence) vers une mémoire après qu'elle a été libérée (désallouée). C'est une condition dangereuse car la mémoire en question n'est plus détenue par le programme, ce qui signifie qu'elle pourrait être réaffectée à un autre usage ou modifiée par d'autres parties du programme. Si le programme continue d'utiliser cette mémoire libérée, cela peut entraîner un comportement imprévisible, notamment des plantages, une corruption de données ou une exploitation par des attaquants.

Décomposition de la vulnérabilité :

1. Allocation et désallocation de mémoire :

   • Dans de nombreux langages de programmation, en particulier ceux comme C et C++, la mémoire est gérée manuellement. Les développeurs allouent la mémoire lorsqu'ils en ont besoin (par exemple, avec des fonctions comme malloc() ou new) et la libèrent lorsqu'ils ont fini (par exemple, avec free() ou delete).

2. Le problème :

   • Un problème de use-after-free survient lorsqu'un pointeur pointe encore vers une mémoire qui a déjà été libérée. Si le programme tente ensuite de lire ou d'écrire dans cette mémoire, des choses inattendues peuvent se produire car la mémoire peut maintenant être réallouée à une autre partie du programme, modifiée, ou même plus disponible pour une utilisation sécurisée.

3. Conséquences :

   • Plantage : Le programme peut tenter d'accéder à une mémoire invalide ou corrompue, ce qui provoque un plantage.
   • Corruption de données : Le programme peut involontairement écraser ou lire des données non intentionnelles, entraînant une corruption.
   • Exploitation de sécurité : Les attaquants peuvent exploiter les vulnérabilités de use-after-free en manipulant l'espace mémoire du programme. Par exemple, si un attaquant peut allouer des données contrôlées dans la mémoire libérée, il pourrait potentiellement exécuter du code arbitraire, modifier le flux d'exécution du programme ou obtenir un accès non autorisé.

Exemple de scénario :

Prenons un exemple simplifié en C :

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

int main() {
    int *ptr = (int *)malloc(sizeof(int)); // Allouer de la mémoire
    *ptr = 42;                             // Utiliser la mémoire allouée
    free(ptr);                             // Libérer la mémoire

    // Utiliser le pointeur après avoir libéré la mémoire (use-after-free)
    printf("%d\n", *ptr);                  // Comportement indéfini, plantage ou exploitation potentielle
    return 0;
}

Dans cet exemple :

• La mémoire est allouée pour un entier, et la valeur 42 lui est assignée.
• La mémoire est ensuite libérée avec free(ptr).
• Après avoir libéré la mémoire, le pointeur ptr est toujours utilisé (déréférencé dans l'instruction printf()), ce qui conduit à un comportement indéfini. La mémoire peut avoir été réassignée, et y accéder peut provoquer un plantage ou, dans un scénario plus dangereux, une exploitation du programme.

Potentiel d'exploitation :

Les attaquants peuvent exploiter les vulnérabilités de use-after-free en manipulant soigneusement la gestion de la mémoire. Voici comment un attaquant pourrait potentiellement utiliser cette vulnérabilité :

1. Réallocation de mémoire : Après que la mémoire a été libérée, si l'attaquant peut contrôler les données placées dans cette mémoire libérée, il peut amener le programme à utiliser ces nouvelles données à la place des données d'origine.
2. Injection de code : Dans certains cas, l'attaquant pourrait injecter du code malveillant dans l'emplacement mémoire, ce qui lui permettrait de détourner le flux de contrôle du programme, conduisant à une exécution de code à distance ou à une élévation de privilèges.

Atténuations :

Pour prévenir les vulnérabilités de use-after-free, les développeurs peuvent :

• Mettre les pointeurs à NULL après les avoir libérés : Cela garantit que si un pointeur est accidentellement utilisé après avoir été libéré, le programme plantera de manière plus prévisible ou se comportera de manière contrôlée, plutôt que d'accéder à une mémoire invalide.
• Pointeurs intelligents : Dans des langages comme C++, l'utilisation de pointeurs intelligents (par exemple, std::shared_ptr, std::unique_ptr) peut aider à gérer la mémoire automatiquement, réduisant les risques de mauvaise gestion manuelle de la mémoire.
• Vérification des limites et sanitizers : Utilisez des outils comme AddressSanitizer (ASan) qui aident à détecter les conditions de use-after-free pendant le développement.

Comment la timeline d'animation CSS a exploité la faille

Dans ce cas spécifique, la timeline d'animation CSS—qui est responsable du contrôle du timing des animations dans une page web—interagissait avec d'autres composants du navigateur de telle manière qu'un objet lié à la timeline de l'animation a été libéré, alors que le navigateur continuait à l'utiliser.