Faille du trousseau du noyau Linux : root local, sans correctif
Une faille du tableau associatif du noyau Linux permet à un utilisateur local de devenir root ; le correctif n'est pas fusionné.
En bref
- Un utilisateur local non privilégié peut corrompre le tableau associatif d'un trousseau et obtenir des capacités root sur les noyaux Linux qui portent le code d'origine. Le chercheur Daniel Wade a publié un exploit fonctionnel le 2026-11-15.
- Tous les noyaux depuis le commit 3cb989501c26 (2013-09-24) sont concernés en principe. Le noyau principal 7.4-rc3 et toutes les branches stables vérifiées portent encore le code vulnérable le 2026-11-16.
- Aucun identifiant CVE ni score CVSS n'est attribué, aucune exploitation réelle n'est connue et la faille n'est pas dans le catalogue KEV de la CISA au 2026-11-16.
- Aucun noyau publié ne contient le correctif. Appliquez le commit 48691075b0ad si vous compilez votre propre noyau. Restreignez aussi les sockets AF_ALG non privilégiés, ce qui, selon le chercheur, supprime l'oracle de heap dont la chaîne publiée a besoin.
Suis-je concerné ?
Toutes ces conditions doivent être réunies pour qu'un hôte soit exposé :
- Le noyau en cours d'exécution a été compilé à partir d'une source qui ne contient pas le commit 48691075b0ad. Le 2026-11-16, cela incluait le noyau principal 7.4-rc3 et toutes les versions des branches stables du tableau.
- Le noyau a été compilé avec le sous-système des trousseaux (
CONFIG_KEYS), ce qui est la valeur par défaut des distributions généralistes. - Un attaquant peut exécuter du code en tant qu'utilisateur local non privilégié sur l'hôte. Aucune capacité, aucun espace de noms utilisateur et aucun groupe spécial ne sont nécessaires.
- Les sockets
AF_ALGnon privilégiés sont disponibles, ce que l'exploit publié utilise comme oracle de heap. Les bloquer augmente le coût de cette chaîne, mais ne corrige pas la faille.
La faille se trouve dans lib/assoc_array.c, le tableau associatif générique que le code des trousseaux sous security/keys/ utilise pour stocker les clés. Tout noyau qui porte ce fichier et CONFIG_KEYS est concerné en principe.
L'exploit public est écrit pour une image de noyau précise. Une autre compilation peut donc demander un autre réglage, mais l'état corrompu de l'arbre n'est pas propre à une compilation.
| Branche | Versions concernées | Version corrigée |
|---|---|---|
| noyau principal | 7.4-rc3 et antérieures | Aucune le 2026-11-16 |
| 7.3.y | 7.3.4 et antérieures | Aucune le 2026-11-16 |
| 6.18.y | 6.18.63 et antérieures | Aucune le 2026-11-16 |
| 6.12.y | 6.12.117 et antérieures | Aucune le 2026-11-16 |
| 6.6.y | 6.6.162 et antérieures | Aucune le 2026-11-16 |
| 6.1.y | 6.1.192 et antérieures | Aucune le 2026-11-16 |
| 5.15.y | 5.15.225 et antérieures | Aucune le 2026-11-16 |
| 5.10.y | 5.10.274 et antérieures | Aucune le 2026-11-16 |
| 4.19.y | Toutes les versions | Aucune le 2026-11-16 |
Chaque extrémité de branche du tableau a été vérifiée le 2026-11-16 : chacune déclare encore excised_meta[1], le tableau que le correctif agrandit. Les noyaux des distributions demandent le journal des modifications du fournisseur, car un fournisseur peut intégrer le commit sans changer la chaîne de version.
Vérifiez le noyau en cours d'exécution :
uname -r
Pour un noyau que vous compilez vous-même, vérifiez si le correctif est dans l'arbre. La première commande affiche le commit du correctif s'il est présent ; la seconde affiche [2] lorsque l'en-tête corrigé est en place et [1] sinon :
git -C /path/to/linux log --oneline --all --grep="assoc_array: don't chain a new shortcut"
grep -n 'excised_meta' include/linux/assoc_array_priv.h
Vérifiez si un utilisateur non privilégié peut ouvrir une socket AF_ALG. Exécutez cette commande en tant qu'utilisateur non privilégié, pas en root :
python3 - <<'PY'
import socket
s = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
print("AF_ALG is available to this user")
s.close()
PY
Comment corriger ?
Aucune mise à jour de noyau d'un fournisseur n'existe. Le correctif est un patch de deux fichiers, commité dans un arbre du noyau mais non fusionné dans le noyau principal. La remédiation consiste donc à l'appliquer vous-même ou à attendre votre distribution.
- Si vous compilez votre propre noyau, appliquez le commit 48691075b0ad, ou cherry-pickez-le sur votre branche, puis recompilez. Le commit modifie
include/linux/assoc_array_priv.hetlib/assoc_array.c. - Si vous utilisez un noyau de distribution, suivez l'avis de sécurité du fournisseur. Aucune distribution n'avait publié de noyau corrigé le 2026-11-16.
- Là où vous ne pouvez pas appliquer le patch, restreignez l'accès non privilégié à l'interface de sockets
AF_ALG. Le chercheur le recommande parce que la chaîne publiée utiliseAF_ALGcomme oracle de heap. Compromis : cela augmente le coût de cette chaîne précise, mais le code des trousseaux reste joignable et la faille reste ouverte. - Traitez l'accès shell local sur un hôte non corrigé comme équivalent à root. Compromis : il s'agit d'un contrôle opérationnel, pas d'un correctif, et il n'aide pas contre un attaquant qui possède déjà un compte.
Le correctif ferme l'état que l'exploit crée. Il ne supprime pas le BUG_ON() de assoc_array_apply_edit(), qui reste une garde contre un arbre mal formé.
Quelle est la cause racine ?
Le tableau associatif supposait qu'un raccourci mène toujours à un nœud. Une suppression suivie d'une insertion pouvait installer un raccourci derrière un autre, un état que le parcours et la comptabilité de l'édition ne gèrent pas.
lib/assoc_array.c est un arbre radix protégé par RCU. Un nœud possède 16 emplacements. Un raccourci compresse une branche à un seul occupant en un saut et stocke les bits d'index sautés en ligne. La garantie de conception est que le parent d'un raccourci est toujours un nœud, jamais un autre raccourci, car le premier raccourci aurait absorbé les bits du second.
La suppression peut briser cette garantie. Lorsque le sous-arbre sous un raccourci rétrécit suffisamment, assoc_array_delete() le réduit à un seul nœud sous le raccourci. Un nœud simple occupe alors la place de la cible du raccourci.
L'insertion peut ensuite placer un raccourci derrière ce raccourci. Lorsque les feuilles d'un nœud plein et la nouvelle clé partagent le segment du nœud, assoc_array_insert_into_terminal_node() remplace le nœud par un raccourci en appelant assoc_array_insert_shortcut(). Si le nœud est lui-même la cible d'un raccourci, le nouveau raccourci est installé comme next_node de l'ancien.
Le code vulnérable règle le pointeur arrière du nouveau raccourci sur le pointeur arrière du nœud, c'est-à-dire l'ancien raccourci :
new_s0->back_pointer = node->back_pointer;
new_s0->parent_slot = node->parent_slot;
new_s0->next_node = assoc_array_node_to_ptr(new_n0);
Deux choses vont alors mal. assoc_array_walk() suit un raccourci en lisant shortcut->next_node. Lorsque ce pointeur est un autre raccourci, le parcours le traite comme un nœud et indexe les bits sautés comme un emplacement. Un lecteur suit alors un pointeur depuis le mauvais niveau de l'arbre.
Séparément, assoc_array_apply_edit() remonte les pointeurs arrière pour ajuster nr_leaves_on_branch. Il suit le back_pointer d'un raccourci et vérifie que le résultat est un nœud :
if (assoc_array_ptr_is_shortcut(ptr)) {
shortcut = assoc_array_ptr_to_shortcut(ptr);
ptr = shortcut->back_pointer;
if (!ptr)
break;
}
BUG_ON(!assoc_array_ptr_is_node(ptr));
Avec deux raccourcis chaînés, ptr est un raccourci et l'assertion se déclenche. Le thread qui insère meurt dans le BUG du noyau. Un lecteur qui parcourait déjà l'arbre à ce moment survit et traite la structure corrompue.
Le déclencheur est petit. Le commit du correctif donne la recette. Il faut seize clés qui s'accordent sur les bits 0 à 11, une qui diverge au bit 8 puis est supprimée, et une dernière qui rejoint les seize. Cela fait dix-huit insertions et une suppression, suivies de l'appel final à add_key().
Comment la faille est-elle exploitée ?
Un utilisateur local amène le trousseau dans l'état cassé avec dix-huit insertions de clés et une suppression, puis gagne une course contre le thread qui plante.
- L'attaquant s'exécute en tant qu'utilisateur local non privilégié et crée un trousseau avec
add_key()etkeyctl(). - L'attaquant effectue les dix-huit insertions et la suppression décrites par le commit du correctif. La suppression réduit le sous-arbre sous un raccourci à un seul nœud.
- L'appel final à
add_key()trouve le nœud plein et la nouvelle clé partageant le segment du nœud.assoc_array_insert_shortcut()remplace le nœud par un raccourci, et comme le nœud était déjà la cible d'un raccourci, le nouveau raccourci se place derrière l'ancien. - Le thread qui insère atteint
assoc_array_apply_edit()et déclenche leBUG_ON(). Le noyau tue ce thread. L'exploit a garé un second thread danskey_link, qui parcourt le même arbre, donc le lecteur survit. - Le lecteur traite une allocation contrôlée par l'attaquant comme une
struct key. La chaîne place le pointeuruserde la fausse clé huit octets avant une vraiestruct cred. La comptabilité des quotas de clés par UID du noyau écrit alors dans les mots de capacité de la structure cred. - L'écriture règle les 32 bits de poids faible de
cred->cap_effective, qui contiennentCAP_DAC_OVERRIDEetCAP_SETUID. Le processus garde son identifiant utilisateur d'origine mais peut désormais lire des fichiers réservés à root. - L'exploit appelle
setresuid(0, 0, 0)etexecve()pour lancer un shell root. Le noyau accorde l'ensemble complet des capacités àexecveparce que l'identifiant utilisateur effectif vaut 0.
La preuve de concept publique enregistre le plantage à l'insertion :
kernel BUG at lib/assoc_array.c:1387!
assoc_array_apply_edit+0x221/0x230
__key_link+0x51/0x80
__key_instantiate_and_link+0xc0/0x140
__key_create_or_update+0x51a/0x580
key_create_or_update+0x14/0x30
__se_sys_add_key+0x1d0/0x240
L'exploit est un artefact de laboratoire. Il est compilé pour l'image durcie kernelCTF 7.2-rc5 de Google et a besoin de l'image correspondante et d'un initramfs de type kernelCTF, que le dépôt ne fournit pas.
Le correctif a été écrit le 11 octobre 2026 et commité le 13 octobre 2026. L'exploit public est apparu le 15 novembre 2026, 35 jours après l'écriture du correctif.
Comment se déroule l'attaque ?
Un utilisateur local amène le tableau associatif du trousseau dans un état de raccourci derrière un raccourci. Un lecteur concurrent survit au plantage du thread qui insère, et la comptabilité de quotas du noyau devient une écriture de capacité.
puis un dernier add_key()"] B --> C["raccourci derrière un raccourci
aucune vérification de cet état"] C --> D["assoc_array_apply_edit()
le BUG_ON tue le thread qui insère"] C --> E["lecteur garé dans key_link()
parcourt l'arbre cassé"] E --> F["fausse struct key
alias d'une struct cred"] F --> G["écriture du quota de clés
règle CapEff"] G --> H["CAP_SETUID puis setresuid(0)
shell root"]
Que peut faire un attaquant ?
L'impact démontré est une élévation de privilèges locale vers root. L'exploit a besoin d'un compte local non privilégié, d'aucune capacité, d'aucun espace de noms utilisateur et d'aucun groupe spécial. Il n'a pas besoin d'une position réseau.
La première étape est une élévation de capacités, pas un changement d'identifiant utilisateur. Le processus garde uid 1000 et obtient CapEff=00000000ffffffff, les 32 bits de poids faible du compteur de quota aliasé. CAP_DAC_OVERRIDE dans cet ensemble rend lisibles des fichiers réservés à root.
La seconde étape utilise CAP_SETUID pour appeler setresuid(0,0,0) et execve(), moment où le noyau accorde l'ensemble complet et où le processus est root.
Les chiffres de fiabilité sont ceux du chercheur, mesurés sur l'unique image épinglée avec deux vCPU. La compilation « root shell » a réussi 7 fois sur 8 ; la compilation « lecture de drapeau » a réussi 14 fois sur 20.
Les échecs viennent de la course elle-même, pas d'une primitive manquante. Une autre compilation du noyau a un comportement d'allocation différent, donc le même binaire ne fonctionnera pas à l'identique.
Aucun chemin distant n'est démontré. La faille est atteinte par des opérations locales sur le trousseau, et la chaîne publiée exige une exécution de code locale. Aucune exploitation réelle n'est connue et aucune source ne rapporte de compromission.
Pourquoi le correctif fonctionne-t-il ?
Le patch fait remplacer par le nouveau raccourci le raccourci situé devant le nœud, de sorte que l'arbre ne contient jamais un raccourci qui mène à un autre raccourci.
new_s0->back_pointer = node->back_pointer;
new_s0->parent_slot = node->parent_slot;
+
+ /* A shortcut has to lead to a node, so a node at the end of a shortcut
+ * is replaced together with that shortcut. The new one holds the index
+ * key from the root, so it covers what the old one did.
+ */
+ if (node->back_pointer &&
+ assoc_array_ptr_is_shortcut(node->back_pointer)) {
+ struct assoc_array_shortcut *above =
+ assoc_array_ptr_to_shortcut(node->back_pointer);
+
+ new_s0->back_pointer = above->back_pointer;
+ new_s0->parent_slot = above->parent_slot;
+ edit->excised_meta[1] = node->back_pointer;
+ }
new_s0->next_node = assoc_array_node_to_ptr(new_n0);
new_n0->back_pointer = assoc_array_shortcut_to_ptr(new_s0);
new_n0->parent_slot = 0;
Le nouveau raccourci hérite du pointeur arrière et de l'emplacement parent de l'ancien, donc il est installé là où était l'ancien. L'ancien raccourci est enregistré dans le second emplacement de excised_meta, ce qui explique le passage de excised_meta[1] à excised_meta[2].
L'ancien raccourci est retiré dans la même édition. Le parcours atteint donc toujours un nœud, et la comptabilité de l'édition ne voit jamais un raccourci là où elle attend un nœud.
Le patch couvre le chemin d'insertion qui crée l'état. Il n'existe qu'une implémentation de assoc_array dans le noyau, donc il n'y a pas de seconde copie à corriger. Le BUG_ON() reste comme garde.
Comment vérifier si j'ai été compromis ?
Aucun indicateur de compromission n'est publié et aucune exploitation réelle n'est connue. Le seul observable public est le BUG du noyau provoqué par une tentative ratée.
Cherchez l'assertion dans le journal du noyau. Une correspondance signifie que l'insertion vulnérable a eu lieu et que le thread qui insérait est mort. Elle ne prouve pas que l'écriture de capacité a réussi :
dmesg -T | grep -i "assoc_array"
Cherchez dans le journal d'audit un processus non root qui a appelé setresuid(0) ou obtenu des capacités qu'il n'avait pas auparavant. L'écriture de capacité ne laisse aucun fichier. Traitez donc comme suspect un hôte où un utilisateur non privilégié pouvait lancer l'exploit et où un shell root apparaît sans entrée de connexion correspondante.
Une tentative qui échoue avant le BUG peut ne laisser aucune trace. L'absence d'entrée de journal ne prouve pas que l'hôte n'a pas été visé.
Chronologie
- 2013-09-24 : le commit 3cb989501c26 ajoute l'implémentation générique du tableau associatif.
- 2026-10-11 : Linus Torvalds écrit le correctif.
- 2026-10-13 : le correctif est commité dans un arbre du noyau.
- 2026-11-15 : Daniel Wade publie l'exploit.
- 2026-11-16 : le noyau principal 7.4-rc3 et les branches stables portent encore le code vulnérable.
FAQ
Y a-t-il un CVE ?
Non. Aucun identifiant CVE ni score CVSS n'est attribué au 2026-11-16. Le commit du correctif, le dépôt de l'exploit et l'analyse du chercheur constituent le dossier public.
Ma distribution est-elle concernée ?
Oui, en principe. Tout noyau de distribution compilé à partir d'un arbre sans le commit 48691075b0ad porte la faille. Aucune distribution n'avait publié de noyau corrigé le 2026-11-16, donc consultez l'avis de sécurité du fournisseur plutôt que la chaîne de version.
L'exploit est-il fiable ?
Sur la cible publiée, oui. Le chercheur rapporte 7 shells root sur 8 exécutions et 14 lectures de drapeau sur 20 sur l'image kernelCTF 7.2-rc5 avec deux vCPU. Il faut cette image et cet initramfs ; une autre compilation demande un autre réglage.
Un attaquant distant peut-il l'utiliser ?
Aucun chemin distant n'est démontré. L'exploit exige un compte local non privilégié, et la faille est atteinte par des opérations locales sur le trousseau.
Bloquer AF_ALG corrige-t-il la faille ?
Non. Cela supprime l'oracle de heap utilisé par la chaîne publiée, ce que le chercheur recommande, mais le code des trousseaux reste joignable et la faille reste. Seul le patch du noyau la ferme.
Quelle est l'urgence ?
Il n'y a aucune exploitation réelle et l'exploit est un artefact de laboratoire. Un utilisateur local sur un hôte non corrigé peut néanmoins devenir root. Corrigez donc vos propres noyaux ou restreignez l'accès local en attendant une mise à jour de la distribution.
Références
- Commit du correctif, « assoc_array: don't chain a new shortcut onto an existing one », https://github.com/torvalds/linux/commit/48691075b0adc590a6831390723e3603dfca76fc (vérifié le 16 novembre 2026)
- Commit d'introduction, « Add a generic associative array implementation », https://github.com/torvalds/linux/commit/3cb989501c26 (vérifié le 16 novembre 2026)
- Dépôt de l'exploit et analyse technique, Daniel Wade, https://github.com/Rat5ak/ASSOC_ARRAY_SHORTCUT-CHAIN-EoP (vérifié le 16 novembre 2026)
lib/assoc_array.cà v7.4-rc3, https://github.com/gregkh/linux/blob/v7.4-rc3/lib/assoc_array.c (vérifié le 16 novembre 2026)include/linux/assoc_array_priv.hà v7.4-rc3, https://github.com/gregkh/linux/blob/v7.4-rc3/include/linux/assoc_array_priv.h (vérifié le 16 novembre 2026)- Cyber Kendra, « Unpatched Linux Kernel Keyring Flaw Gives Local Root », https://www.cyberkendra.com/2026/11/linux-kernel-assoc-array-keyring-root-exploit.html (vérifié le 16 novembre 2026)
- Catalogue Known Exploited Vulnerabilities de la CISA, https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 16 novembre 2026)
- CVE-2016-7914, une faille antérieure dans la même fonction, https://www.cve.org/CVERecord?id=CVE-2016-7914 (vérifié le 16 novembre 2026)
- CVE-2017-12193, une autre faille antérieure dans la même fonction, https://www.cve.org/CVERecord?id=CVE-2017-12193 (vérifié le 16 novembre 2026)