v0idnetwork/cve-2026-46331pedit COW
CVE-2026-46331 (surnommé « pedit COW ») est une faille locale d'élévation de privilèges dans le noyau Linux, située dans le sous-système de contrôle de trafic. Un utilisateur non privilégié (dans un espace de noms réseau non privilégié) peut configurer le filtre act_pedit (éditeur de paquets) pour déclencher une écriture partielle par copie sur écriture (COW) dans le cache de pages. En pratique, le noyau écrit des données contrôlées par l'attaquant dans l'image en mémoire d'un fichier sans marquer la page comme privée, corrompant ainsi la copie mise en cache de ce fichier. Point crucial : l'exploitation nécessite uniquement CAP_NET_ADMIN (obtenable dans un espace de noms utilisateur) et ne modifie pas le fichier sur disque. Concrètement, une preuve de concept (PoC) fonctionnelle appelée packet_edit_meme a été publiée le 17 juin 2026, démontrant comment écraser l'image en cache d'un binaire setuid (par exemple /bin/su) pour obtenir un shell root. La vulnérabilité provient d'un calcul incorrect de la plage COW dans tcf_pedit_act() et a été corrigée en amont (4 juin 2026) en déplaçant la vérification de la zone accessible en écriture dans la boucle par clé.
act_pedit. Les versions stables non corrigées (y compris de nombreux noyaux de distributions) sont vulnérables.tc, puis écrase en mémoire le point d'entrée ELF d'un binaire setuid avec du shellcode.skb_ensure_writable() à l'intérieur de la boucle des clés). Comme solution de contournement, bloquer ou décharger le module act_pedit ou désactiver les espaces de noms utilisateur non privilégiés (par exemple sysctl user.max_user_namespaces=0). Après atténuation, vider les caches (echo 3 > /proc/sys/vm/drop_caches) pour expulser les pages empoisonnées.Ce rapport fournit une analyse technique détaillée de CVE-2026-46331 : sa cause, son exploitation, sa détection et les stratégies de correction, avec des références aux avis de l'éditeur, aux CVE et à l'exploit public.
Définition : CVE-2026-46331 est un bogue d'écriture hors limites dans le sous-système Contrôle de trafic (net/sched) du noyau Linux, plus précisément dans l'action act_pedit (éditeur de paquets). La fonction tcf_pedit_act() calcule une plage de « copie sur écriture » pour les opérations d'édition de paquets avant d'itérer sur les clés typées, en utilisant une indication statique tcfp_off_max_hint. Cependant, certaines clés (par exemple les modifications d'en-tête TCP/UDP) ne déterminent leur décalage final qu'à l'exécution. Le code ne revérifie jamais l'accessibilité en écriture pour ces décalages dynamiques. Par conséquent, des écritures peuvent se produire en dehors de la région pré-COW : une partie de l'écriture du paquet n'est jamais rendue privée, ce qui conduit à une COW partielle. Cette écriture erronée se propage dans la mémoire partagée du cache de pages d'un fichier (si les tampons de paquets référencent par hasard des pages de fichier), corrompant l'image du fichier en cache.
Contexte : L'action éditeur de paquets (pedit) de Linux permet aux administrateurs de réécrire des octets arbitraires dans les en-têtes de paquets (couches liaison, réseau ou transport) au fur et à mesure que les paquets traversent un filtre tc configuré. Elle fonctionne en spécifiant un décalage (éventuellement ancré à un en-tête) et une valeur/masque 32 bits. En interne, pedit opère sur les tampons de socket (sk_buff) et doit rendre la mémoire du paquet cible accessible en écriture avant de la modifier (via skb_ensure_writable() de manière COW). Idéalement, le noyau devrait cloner (copie privée) toute page partagée avant d'écrire pour éviter de modifier la mémoire utilisée ailleurs.
Cause racine : Dans tcf_pedit_act(), le code calcule par erreur la plage accessible en écriture une seule fois au début, en utilisant tcfp_off_max_hint (le décalage statique maximal). Cette indication n'inclut aucun décalage d'en-tête d'exécution que les clés typées ajoutent lors du traitement du paquet. Les clés comme TCP ou UDP peuvent calculer un décalage basé sur la position de l'en-tête IP à l'exécution (par exemple, si une clé précédente décale l'en-tête réseau). Ainsi, pendant la boucle par clé, le décalage réel d'une clé peut dépasser la plage pré-allouée comme accessible en écriture. Le code écrit alors dans la mémoire du paquet via skb_store_bits(), mais comme la page au-delà de la région pré-COW n'a pas été rendue privée, l'écriture corrompt une page toujours partagée avec le cache de pages. En bref, « calculer trop tôt la plage accessible en écriture du paquet » entraîne une écriture hors limites entre pages. Les décalages négatifs (par exemple lors de l'édition d'en-têtes Ethernet en entrée) sont également mal gérés, et même offset_valid() manquait d'une protection contre INT_MIN, aggravant la faille.
Pourquoi cela se produit : Ce bogue est essentiellement une erreur de logique dans le calcul de la plage de copie sur écriture. Le noyau supposait que le décalage statique maximal (connu au chargement) était suffisant pour toutes les modifications. Il n'a pas mis à jour la plage COW lorsque des clés avec des décalages dynamiques étaient réellement appliquées. Après une série de modifications en file d'attente, l'écriture finale pouvait se situer en dehors de la région pré-vérifiée. Comme les tampons de paquets peuvent référencer des pages de fichier mappées en mémoire (par exemple via des mécanismes de copie zéro), cette écriture « COW partielle » peut atteindre le cache de pages d'un fichier sur disque. En pratique, l'action de l'éditeur de paquets peut recevoir des pages provenant d'un sendfile ou d'un splice ; ainsi une simple opération de filtre de paquets peut écrire indirectement des données choisies par l'attaquant dans l'image mémoire d'un fichier, sans modifier le disque.
Composants et flux de données : Le code vulnérable réside dans le sous-système net/sched de Linux (act_pedit.c). Lorsqu'un paquet correspond à une règle pedit configurée, tcf_pedit_act() est invoquée. En interne, elle appelle skb_ensure_writable(skb, X) une seule fois, où X = tcfp_off_max_hint. Cela rend les premiers X octets du paquet privés (COW). Ensuite, dans une boucle sur chaque clé (opération d'édition), elle calcule le décalage réel d'écriture de la clé en ajoutant le décalage d'en-tête d'exécution au décalage spécifié de la clé, et écrit une valeur 32 bits dans le paquet. En pseudo-code :```c
u32 off_max = action->tcfp_off_max_hint;
skb_ensure_writable(skb, off_max);
for (i = 0; i < num_keys; i++) {
u32 hdr_off = compute_header_offset(skb, key[i].hdr_type);
u32 write_off = hdr_off + key[i].offset;
skb_store_bits(skb, write_off, &key[i].value, 4);
}
Parce que `hdr_off` n'est calculé qu'au moment du traitement de chaque clé, l'appel initial à `skb_ensure_writable()` n'en tenait pas compte. Si `hdr_off + key[i].offset` dépasse `off_max`, le code se rabat sur `skb_store_bits()` sur les fragments plutôt que sur la zone linéaire principale, ce qui signifie qu'il écrit dans une page qui n'a pas été rendue privée. C'est le point de défaillance.