💻 computer science

One (Thread) Can Keep a (PRNG) Secret, but not Two

Cet article présente la première attaque cryptanalytique exploitant une condition de concurrence dans le générateur de nombres pseudo-aléatoires (PRNG) de l'identifiant de fragmentation IPv6 du noyau XNU pour prédire les numéros de séquence et permettre l'usurpation de trafic TCP et UDP hors réseau, une vulnérabilité désormais corrigée par Apple sous la référence CVE-2024-27823.

Auteurs originaux : Ehood Porat, Amit Klein, Benny Pinkas

Publié 2026-06-03

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Ehood Porat, Amit Klein, Benny Pinkas

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous envoyez une grande lettre importante à un ami. Comme la lettre est trop volumineuse pour une seule enveloppe, la poste (le réseau) la découpe en morceaux plus petits, ou fragments. Pour s'assurer que les morceaux soient remis dans le bon ordre, chaque morceau reçoit un numéro de ticket unique (appelé ID de fragment).

Le document que vous avez consulté décrit une manière ingénieuse dont un pirate peut deviner ces numéros de tickets à l'avance, ce qui lui permet de remplacer un morceau de votre lettre par un faux sans que vous ou votre ami ne vous en aperceviez.

Voici la décomposition de l'attaque, expliquée simplement :

1. La machine à tickets secrète (le PRNG)

Les ordinateurs d'Apple (macOS et iOS) utilisent une machine à « tickets » spéciale à l'intérieur de leur cerveau (le noyau/kernel) pour générer ces numéros de tickets aléatoires. La machine est censée être imprévisible, comme un lancer de dés. Si les nombres sont réellement aléatoires, personne ne peut deviner le prochain ticket.

Cependant, les chercheurs ont découvert une faille dans le fonctionnement de cette machine lorsqu'elle est très sollicitée.

2. Le problème du « Deux personnes, une machine » (La Race Condition)

Imaginez un guichet de tickets très fréquenté où deux personnes (deux threads de l'ordinateur) tentent de saisir un ticket à la milliseconde exacte près.

Normalement : La machine donne un ticket à la Personne A, puis un ticket différent à la Personne B.
Le bug : Comme la machine n'est pas « thread-safe » (elle ne possède pas de verrou pour empêcher les gens de saisir des tickets en même temps), les deux personnes pourraient saisir le même numéro de départ. Elles exécutent toutes deux le calcul, mais parce qu'elles ont commencé avec le même nombre et ont suivi des étapes légèrement différentes, elles produisent un motif étrange.

Le motif : Les chercheurs ont découvert que si vous déclenchez cette « course » (race), la machine produit une séquence spécifique de nombres qui ressemble à ceci : A, B, C, B.
Remarquez que B apparaît deux fois, séparé par C. Ce « B-C-B » est la preuve irréfutable. Cela indique à l'attaquant : « Hé ! La machine vient de subir une race condition ! Je peux maintenant voir comment les engrenages internes de la machine tournent. »

3. Craquer le code (Cryptanalyse)

Une fois que l'attaquant voit suffisamment de motifs « B-C-B », il peut faire de l'ingénierie inverse sur la machine.

Considérez la machine comme un cadran de combinaison. Le motif « B-C-B » donne à l'attaquant un indice sur la position actuelle des disques à l'intérieur du cadran.
En collectant suffisamment de ces indices, l'attaquant peut découvrir l'état interne complet de la machine.
Une fois qu'il connaît l'état interne, il peut prédire exactement quels seront les prochains numéros de tickets.

4. L'échange (L'Attaque)

Maintenant que l'attaquant peut prédire les numéros de tickets, il peut effectuer un tour de passe-passe de type « homme du milieu » (man-in-the-middle), mais sans être réellement au milieu.

Le scénario : Vous envoyez un gros fichier (comme une sauvegarde de votre code) vers un serveur. Le fichier est divisé en morceaux.
La protection : Le premier morceau du fichier contient votre mot de passe et votre signature (authentification). Le serveur vérifie ce premier morceau pour s'assurer que c'est bien vous.
L'astuce : L'attaquant attend que le premier morceau arrive. Ensuite, il utilise sa prédiction pour deviner le numéro de ticket du deuxième morceau. Il envoie rapidement un deuxième morceau de synthèse contenant un message malveillant (comme un virus ou un fichier modifié) qui possède le bon numéro de ticket.
Le résultat : Le serveur reçoit le premier morceau authentique (avec le mot de passe valide) et le deuxième morceau factice (avec le virus). Il les assemble, pense que tout est en ordre, et enregistre le fichier infecté. L'attaquant a contourné la vérification de sécurité car celle-ci n'a eu lieu que sur le premier morceau.

Exemples concrets de l'article

Les chercheurs ont testé cela sur deux éléments spécifiques :

NFS (Network File System) : Ils ont montré comment un attaquant pourrait modifier un fichier en cours de sauvegarde vers un serveur. Par exemple, ils pourraient injecter un « cheval de Troie » dans un fichier de code informatique standard. Lorsqu'un développeur compilera plus tard ce code, le virus s'exécutera.
HTTP (Navigation Web) : Ils ont montré comment un attaquant pourrait modifier une requête web (comme une connexion ou l'envoi d'un formulaire) pendant qu'elle voyage sur le réseau.

Pourquoi c'est important

C'est nouveau : C'est la première fois que quelqu'un utilise une « race condition » (un bug de synchronisation) pour briser un générateur de nombres aléatoires. Habituellement, les race conditions provoquent des plantages ; ici, elles ont été utilisées pour voler des secrets.
C'est concret : L'attaque fonctionne sur de vrais appareils Apple (puces M1, M2, Mac Intel) tournant sur diverses versions de macOS et iOS.
Le correctif : Apple a déjà corrigé cela. Ils lui ont attribué l'identifiant CVE-2024-27823. Le correctif consiste à rendre la machine à tickets « thread-safe » afin que deux personnes ne puissent pas saisir le numéro de départ au même moment.

En résumé : L'article montre que si le générateur de nombres aléatoires d'un ordinateur est perturbé par deux événements se produisant simultanément, un pirate peut utiliser cette confusion pour prédire l'avenir, échanger des parties de vos données et faire passer des logiciels malveillants en douce malgré vos contrôles de sécurité.

Résumé Technique : « Un (Thread) peut garder un (PRNG) secret, mais pas deux »

Énoncé du Problème

Le document traite d'une vulnérabilité critique dans l'algorithme de génération d'ID de fragmentation IPv6 au sein du noyau XNU, qui alimente les systèmes d'exploitation macOS et iOS d'Apple. Bien que les générateurs de nombres pseudo-aléatoires (PRNG) soient essentiels pour générer des identifiants réseau imprévisibles (tels que les ID de session et les numéros de séquence) afin de prévenir le détournement de trafic et l'usurpation, l'implémentation spécifique dans XNU s'est avérée susceptible de conditions de concurrence (race conditions).

Le problème central est que le PRNG du noyau XNU, utilisé pour générer des ID de fragments de 32 bits, manque de mécanismes de sécurité de thread (tels que le verrouillage ou locking). Lorsque plusieurs threads invoquent le PRNG de manière concurrente, l'état interne peut être lu et mis à jour de manière non atomique. Cette condition de concurrence permet à un attaquant d'induire des valeurs de sortie dupliquées dans le flux d'ID de fragments. Le document postule que ces doublons ne sont pas de simples bruits, mais contiennent des motifs distinguables qui révèlent l'état interne du PRNG, permettant ainsi à un attaquant de briser cryptographiquement le générateur et de prédire les futurs ID de fragments.

Méthodologie

Les auteurs proposent un nouveau cadre d'attaque composé de trois primitives : déclencher une condition de concurrence, effectuer une cryptanalyse basée sur les motifs résultants, et exécuter une attaque d'usurpation partielle.

1. Déclencher la Condition de Concurrence

L'attaque nécessite qu'un attaquant hors-chemin (off-path) induise une condition de concurrence dans la fonction ip6 randomid() du noyau XNU. Cela est réalisé en forçant l'hôte macOS cible à générer des paquets IPv6 fragmentés de manière concurrente. Les auteurs ont démontré deux méthodes pour y parvenir :

Service de Fragmentation à distance : L'attaquant envoie un volume élevé de requêtes (environ 1 Gbps) à un service tournant sur la cible (par exemple, un serveur d'écho UDP), provoquant la génération simultanée de paquets fragmentés par la cible en réponse.
Application Malveillante Locale : Un processus à bas privilège sur l'appareil cible envoie rapidement des paquets fragmentés à l'attaquant.

L'absence de verrouillage dans le noyau permet à deux threads de lire le même état interne $x$ , d'effectuer un nombre différent d'étapes internes ( $n_A$ et $n_B$ ), et de réécrire les nouveaux états. Cela résulte en une séquence de sortie spécifique : $X, Y, Z, Y$ , où $Y$ est une valeur dupliquée séparée par $Z$ .

2. Cryptanalyse Assistée par Condition de Concurrence

Les auteurs introduisent une nouvelle méthode de cryptanalyse qui exploite la séquence $XYZY$.

L'Intuition : La séquence implique des relations mathématiques spécifiques entre les états internes correspondant à $X, Y,$ et $Z$ . Plus précisément, la probabilité que les états internes de $X$ et $Z$ (ou $Y$ et $Z$ ) diffèrent modulo 4 est significativement plus élevée que le hasard (environ 0,9 contre 0,75).
L'Attaque : L'attaquant collecte un grand nombre de séquences $XYZY$. En utilisant celles-ci, il effectue une cryptanalyse en quatre phases pour extraire les clés statiques du PRNG ( $s_1, g, s_2, a, b$ $s_{1}, g, s_{2}, a, b$ ) :
1. Extraire $s_1$ : En maximisant le nombre d'inégalités qui sont vérifiées pour les séquences observées à travers toutes les $2^{31}$ valeurs possibles de $s_1$ .
2. Extraire $g$ : En utilisant $s_1$ connu et les dépendances dans les ID de fragments consécutifs.
3. Extraire $s_2$ : En étendant la technique de la phase 2.
4. Extraire $a, b$ : En résolvant des équations linéaires basées sur les états internes reconstruits.
Synchronisation : Une fois les clés récupérées, l'attaquant synchronise son simulateur de PRNG local avec l'état actuel de la cible (en tenant compte de la perte de paquets) pour prédire les futurs ID de fragments.

3. Usurpation Partielle UDP/TCP

Avec la capacité de prédire les ID de fragments, l'attaquant peut effectuer une usurpation partielle.

Cas NFS (UDP) : Les auteurs ciblent les appels NFS WRITE via UDP avec une authentification Kerberos (RPCSEC GSS). La signature d'authentification couvre l'en-tête RPC (contenu dans le 1er fragment) mais pas la charge utile du fichier (contenue dans les fragments suivants). En prédisant l'ID de fragment, l'attaquant peut forger le 2ème fragment (contenant un contenu de fichier malveillant) tout en laissant le 1er fragment (contenant une authentification valide) intact. L'attaquant ajuste également la somme de contrôle (checksum) UDP pour garantir que le paquet est accepté.
Cas HTTP (TCP) : La technique est appliquée aux segments TCP pour modifier les requêtes HTTP POST, injectant un contenu conçu par l'attaquant.

Contributions Clés

Première Cryptanalyse Assistée par Condition de Concurrence : Le papier présente la première attaque cryptanalytique connue qui repose sur le déclenchement d'une condition de concurrence pour briser une primitive cryptographique (PRNG).
Rupture du PRNG de XNU : Une attaque pratique sur l'algorithme de génération d'ID de fragmentation IPv6 de XNU, permettant l'extraction complète de l'état interne et la prédiction des sorties futures.
Contournement d'Authentification : Une démonstration du contournement de l'authentification Kerberos dans NFS en exploitant la fragmentation, spécifiquement la modification des contenus de fichiers pendant le transfert sans identifiants valides.
Usurpation de Segment TCP : Application réussie de la technique pour usurper des segments TCP, modifiant des requêtes HTTP.

Résultats Expérimentaux

Les auteurs ont validé l'attaque sur divers matériels (Intel x64, Apple M1/M2 ARM64) et versions de macOS (de Catalina à Sonoma).

Succès de la Cryptanalyse : Dans les expériences, l'attaque a réussi à extraire l'état du PRNG. La métrique statistique $z$ (distance par rapport à l'attente aléatoire) variait de 8,7 à 15,5, bien au-dessus du seuil requis de 7, confirmant la validité de l'analyse du motif $XYZY$.
Exécution de l'Attaque : Les auteurs ont réussi à injecter du contenu malveillant dans des fichiers sur un serveur NFS. Sur 10 essais, l'attaque a réussi à chaque fois, modifiant un fichier d'en-tête (random.h) avec un code piégé.
Temps d'Exécution : La phase de cryptanalyse a pris entre 3 et 8 minutes sur une machine virtuelle Azure puissante (48 cœurs). Bien que cela soit plus lent que l'intervalle de re-sellement (reseeding) de 180 secondes du PRNG, les auteurs notent qu'avec un matériel plus rapide (accélération de 6 à 8 fois), une attaque en temps réel est réalisable. Ils ont également démontré la validité de l'attaque en prolongeant le délai de re-sellement via un module noyau pour permettre une exécution en temps réel dans un environnement contrôlé.

Signification et Revendications

Le document affirme ouvrir une nouvelle porte à la cryptanalyse en démontrant que les conditions de concurrence, souvent vues comme des bugs de performance, peuvent avoir de graves implications cryptographiques.

Nouveauté : C'est la première attaque utilisant les conditions de concurrence comme vecteur primaire pour la cryptanalyse.
Gravité : La vulnérabilité permet à des attaquants hors-chemin de contourner des mécanismes d'authentification forts (Kerberos) et de modifier des données en transit, une capacité auparavant considérée comme nécessitant une position d'homme du milieu (MITM) ou une cryptographie faible.
Cause Racine : Les auteurs soulignent que la vulnérabilité (introduite en 2012) a persisté pendant plus d'une décennie car les conditions de concurrence dans les PRNG ne provoquent ni plantages système ni dégradation des performances, ce qui les rend invisibles aux tests standards et aux rapports d'utilisateurs.
Résolution : La vulnérabilité a été divulguée à Apple le 28 février 2024, et corrigée dans tous les produits basés sur XNU sous l'identifiant CVE-2024-27823.

Le papier conclut que, bien que le PRNG spécifique de XNU ne soit pas de "qualité industrielle", le concept de cryptanalyse assistée par condition de concurrence pourrait potentiellement s'appliquer à des algorithmes cryptographiques plus robustes, suggérant une classe plus large de vulnérabilités dans les implémentations cryptographiques concurrentes.