CopyFail Guard

   ______                 ______      _ __   ______                     __
  / ____/___  ____  __  _/ ____/___ _(_) /  / ____/_  ______ __________/ /
 / /   / __ \/ __ \/ / / / /_  / __ `/ / /  / / __/ / / / __ `/ ___/ __  /
/___/ /_/ / /_/ / /_/ / / __/ / /_/ / / /  / /_/ / /_/ / /_/ / /  / /_/ /
\____/\____/ .___/\__, /_/    \__,_/_/_/   \____/\__,_/\__,_/_/   \__,_/
          /_/    /____/

Évaluation et atténuation rapides et audivables de l’exposition Linux pour CVE‑2026‑31431 « Copy Fail » pendant que les noyaux sont corrigés.

CopyFail Guard est un outil d’opérations défensives pour les administrateurs Linux, les ingénieurs DevSecOps, les équipes plateformes et les répondants aux incidents. Il aide à réduire l’exposition au problème Linux algif_aead / AF_ALG en :

• évaluant en toute sécurité l’exposition sans code d’exploitation
• vérifiant si algif_aead est disponible, chargé, intégré ou déjà bloqué
• installant un bloc persistant modprobe.d et déchargeant le module lorsque c’est sûr
• ajoutant une règle de refus AF_ALG aux profils seccomp de Docker, Podman et Kubernetes
• validant l’accessibilité AF_ALG sans fournir de code d’exploitation

Correctif final : installez le noyau corrigé de votre fournisseur et redémarrez.
Cet outil couvre l’écart opérationnel entre la divulgation et le correctif complet de la flotte.

Pourquoi les opérateurs peuvent lui faire confiance

• Aucun code d’exploitation : vérifie l’exposition et l’accessibilité AF_ALG sans écritures dans le cache de pages, splice, changements setuid, escalade de privilèges ou sondes destructrices.
• Modification hôte vérifiable : l’atténuation hôte écrit un fichier géré, /etc/modprobe.d/99-copyfail-guard.conf, et la restauration ne supprime que ce fichier.
• Seccomp préservant la base de référence : seccomp-patch ajoute un refus AF_ALG à un profil seccomp Docker/Podman/Kubernetes existant au lieu de remplacer votre durcissement d’exécution.
• Prêt pour l’automatisation : assess --json et codes de sortie documentés prennent en charge les scans de flotte, la capture SIEM et les preuves de gestion des changements.
• Couvert par CI : syntaxe shell, génération de profil seccomp, sortie JSON et tests de fumée exécutés sur des conteneurs de distributions Linux courantes.

Parcours 30 secondes

Si vous êtes sur un hôte Linux et avez besoin d’une réponse rapide :

git clone --depth 1 https://github.com/juliosuas/copyfail-guard.git
cd copyfail-guard
sudo ./bin/copyfail-guard.sh doctor
sudo ./bin/copyfail-guard.sh assess

Si le verdict est exposé et que algif_aead est modulaire :

sudo ./bin/copyfail-guard.sh mitigate --yes
sudo ./bin/copyfail-guard.sh verify

Pour des installations reproductibles, fixez une étiquette de version :

git clone --branch v0.3.0 --depth 1 https://github.com/juliosuas/copyfail-guard.git

Remplacez v0.3.0 par la dernière version publiée lorsque des versions plus récentes sont disponibles.

Suis-je affecté ?

Exécutez d’abord la vérification sécurisée de l’exposition :

sudo ./bin/copyfail-guard.sh assess

Comment lire le résultat :

Si vous exécutez des conteneurs non fiables, des jobs CI, des sandbox ou des charges de travail multi‑utilisateurs, testez également si la création de socket AF_ALG est bloquée dans cet environnement d’exécution :

python3 tools/afalg-socket-test.py

PERMITTED ne prouve pas une exploitation réussie, mais prouve que l’API crypto espace utilisateur concernée est accessible. Pour les opérations défensives, c’est une raison suffisante pour appliquer l’atténuation pendant que vous confirmez le déploiement du noyau corrigé.

Cela prouve-t-il la vulnérabilité ?

Aucune preuve de concept destructive n’est incluse. C’est une fonctionnalité, pas une lacune.

Une véritable preuve d’exploitation Copy Fail devrait valider l’impact sur la mémoire du noyau / le cache de pages ou l’escalade de privilèges. Inclure cela dans un référentiel d’atténuation public rendrait le projet moins sûr et moins déployable en production.

CopyFail Guard prouve les choses sur lesquelles les opérateurs peuvent agir en toute sécurité :

• si le composant risqué est disponible, chargé, intégré ou bloqué
• si la création de socket AF_ALG est autorisée dans un environnement d’exécution cible
• si l’hôte dispose d’une atténuation provisoire en place
• si l’action restante requise est le déchargement, le redémarrage, seccomp ou le correctif du fournisseur

Pour le statut final de la vulnérabilité, combinez cet outil avec l’inventaire des avis/correctifs du fournisseur et les preuves de redémarrage.

Modèle de résolution

CopyFail Guard est une atténuation, pas un remède. Il réduit l’exposition et vérifie les contrôles provisoires. Le correctif durable reste le noyau corrigé par le fournisseur plus le redémarrage.

L’outil est intentionnellement conçu pour être cloné et exécuté en réponse aux incidents : aucun compilateur, en‑têtes noyau, code d’exploitation ou gestionnaire de paquets tiers n’est nécessaire pour le flux hôte de base. python3 est nécessaire pour la sortie --json, seccomp-patch et le test non‑exploit de socket AF_ALG.

Démarrage rapide

Clonez et exécutez :

git clone https://github.com/juliosuas/copyfail-guard.git
cd copyfail-guard
chmod +x bin/copyfail-guard.sh

sudo ./bin/copyfail-guard.sh doctor
sudo ./bin/copyfail-guard.sh assess
sudo ./bin/copyfail-guard.sh mitigate --yes
sudo ./bin/copyfail-guard.sh verify

Installation système optionnelle :

git clone https://github.com/juliosuas/copyfail-guard.git
cd copyfail-guard
sudo ./scripts/install.sh
sudo copyfail-guard status

L’installateur permet de fixer la source et la destination pour des déploiements contrôlés :

sudo env COPYFAIL_GUARD_REF=v0.3.0 ./scripts/install.sh

Utilisez la dernière version publiée pour COPYFAIL_GUARD_REF lorsque des versions plus récentes sont disponibles.

Durcissement des conteneurs / CI :

./bin/copyfail-guard.sh seccomp-patch docker-default.json copyfail-seccomp.json
docker run --security-opt seccomp=./copyfail-seccomp.json IMAGE

Validez qu’AF_ALG est bloqué à l’intérieur d’un conteneur protégé :

docker run --rm \
  --security-opt seccomp=./copyfail-seccomp.json \
  -v "$PWD/tools:/tools:ro" \
  python:3.12-alpine \
  python /tools/afalg-socket-test.py

Résultat attendu en mode protégé :

BLOCKED: socket(AF_ALG) denied by policy (...)

Voir Exemples de sorties pour les verdicts attendus, la forme JSON et les résultats de validation conteneur.

Pourquoi c’est important

Copy Fail est une escalade de privilèges locale Linux dans le composant algif_aead de l’API crypto espace utilisateur AF_ALG. Les avis publics décrivent une primitive d’écriture dans le cache de pages accessible par des utilisateurs locaux non privilégiés, particulièrement dangereuse sur les systèmes à noyau partagé : nœuds Kubernetes, exécuteurs CI/CD, hôtes multi‑locataires, sandbox d’agents et postes de développeurs.

Le correctif approprié est une mise à jour du noyau du fournisseur contenant le revert/correctif en amont et un redémarrage sur le noyau corrigé. CopyFail Guard est un assistant d’opérations défensives pour la fenêtre avant que ce redémarrage ne soit terminé sur toute la flotte.

Ce que fait l’outil

Prérequis d’installation

Commandes hôte de base :

• Linux
• bash
• Outils kmod : modinfo, modprobe, lsmod, rmmod si disponibles
• grep, awk, mktemp, install

Outils de visibilité optionnels :

• lsof ou ss pour les vérifications des consommateurs AF_ALG

Patchage de profil seccomp :

• python3 est requis pour --json, seccomp-patch et tools/afalg-socket-test.py

Aucun code d’exploitation, compilateur, en‑têtes noyau ou paquets tiers n’est requis.

Évaluation sécurisée vs preuve de concept

CopyFail Guard n’inclut pas de preuve de concept d’exploitation. C’est intentionnel. Voir Cela prouve-t-il la vulnérabilité ?.

À la place, assess effectue une vérification opérationnelle sécurisée :

• détecte si algif_aead semble disponible, chargé, intégré ou bloqué
• distingue « atténué provisoirement » de « réellement résolu »
• recommande atténuation hôte, seccomp ou correctif/redémarrage
• retourne des codes de sortie pour l’automatisation de la flotte

JSON d’automatisation :

sudo ./bin/copyfail-guard.sh assess --json
./bin/copyfail-guard.sh doctor --json

Codes de sortie :

Détails de l’atténuation hôte

mitigate écrit :

/etc/modprobe.d/99-copyfail-guard.conf

avec :

# Managed by CopyFail Guard for CVE-2026-31431
install algif_aead /bin/false
blacklist algif_aead

Puis il tente :

sudo rmmod algif_aead

Si le module est actuellement utilisé, rmmod peut échouer. Dans ce cas, le bloc persistant reste installé ; arrêtez les consommateurs AF_ALG ou redémarrez après avoir appliqué l’atténuation.

Le script refuse d’écraser un lien symbolique à son chemin modprobe géré et écrit le fichier de manière atomique avec des permissions sûres.

Durcissement des conteneurs et CI

Pour les charges de travail non fiables, bloquez la création de socket AF_ALG avec seccomp même pendant que vous corrigez les hôtes.

Chemin recommandé : patchez votre baseline seccomp d’exécution existante au lieu de la remplacer :

./bin/copyfail-guard.sh seccomp-patch docker-default.json copyfail-seccomp.json

Utilisation avec Docker :

docker run --security-opt seccomp=./copyfail-seccomp.json IMAGE

Utilisation avec Podman :

podman run --security-opt seccomp=./copyfail-seccomp.json IMAGE

Chemin d’urgence uniquement si vous n’avez pas de profil de base :

./bin/copyfail-guard.sh seccomp-docker ./copyfail-afalg-seccomp.json

Le profil d’urgence généré bloque AF_ALG mais autorise par ailleurs les appels système. Traitez-le comme un palliatif ciblé, pas comme un remplacement du durcissement seccomp normal par défaut de Docker.

Pour Kubernetes, placez le profil sous la racine seccomp du kubelet, généralement :

/var/lib/kubelet/seccomp/profiles/copyfail-seccomp.json

Référencez-le ensuite avec :

securityContext:
  seccompProfile:
    type: Localhost
    localhostProfile: profiles/copyfail-seccomp.json

Voir examples/kubernetes-seccomp-pod.yaml.

Validation sécurisée

Ce projet inclut un test non‑exploit d’accessibilité AF_ALG :

python3 tools/afalg-socket-test.py

Il tente uniquement de créer et fermer une socket AF_ALG. Il n’attache pas d’opérations crypto, n’appelle pas splice, ne touche pas aux binaires setuid, ne corrompt pas le cache de pages et ne tente pas d’escalade de privilèges.

Résultats :

• BLOCKED signifie que la politique a refusé AF_ALG pour ce processus.
• PERMITTED signifie que la création de socket AF_ALG est encore autorisée pour ce processus.
• UNSUPPORTED signifie qu’AF_ALG n’est pas disponible dans cet environnement d’exécution.

Validation par la communauté

CopyFail Guard a besoin de rapports de compatibilité réels provenant d’hôtes Linux, d’environnements d’exécution de conteneurs, d’exécuteurs CI et de nœuds Kubernetes. Si vous pouvez le tester en toute sécurité, ouvrez un problème Rapport de compatibilité avec les sorties nettoyées de doctor, assess --json, verify ou du test de socket AF_ALG.

Les rapports utiles aident à répondre :

• quelles combinaisons distro/noyau/environnement d’exécution sont faciles à atténuer
• où algif_aead est intégré et nécessite correctif/redémarrage uniquement
• quelles baselines seccomp ont besoin de notes spécifiques à l’environnement d’exécution
• si la documentation est assez claire pour une utilisation en réponse aux incidents

Voir Guide de validation communautaire.

Commandes

copyfail-guard assess                 Évaluation sécurisée de l’exposition, aucune tentative d’exploit
copyfail-guard status                 Inspecter les indicateurs d’exposition hôte
copyfail-guard doctor                 Vérifier les dépendances et la disponibilité d’exécution
copyfail-guard mitigate               Désactiver algif_aead de manière persistante et le décharger
copyfail-guard verify                 Vérifier que l’atténuation hôte est active
copyfail-guard rollback               Supprimer l’atténuation modprobe de CopyFail Guard
copyfail-guard seccomp-docker [FILE]  Générer un profil d’urgence de refus AF_ALG
copyfail-guard seccomp-patch BASE OUT  Patcher un profil seccomp existant en toute sécurité
copyfail-guard k8s-example            Afficher un exemple seccomp Kubernetes

Les options peuvent être placées avant ou après la commande :

--dry-run      Afficher les changements prévus sans écrire de fichiers ni décharger de modules
--yes          Confirmation non‑interactive
--no-logo      Désactiver la bannière ASCII
--json         Émettre du JSON pour les commandes prises en charge : assess, doctor

Ce qui ne devrait pas casser

Dans les configurations typiques, désactiver algif_aead ne devrait pas affecter :

• LUKS / dm-crypt
• SSH
• Les builds par défaut d’OpenSSL, GnuTLS, NSS
• kTLS / TLS dans le noyau
• IPsec / XFRM
• les consommateurs crypto normaux dans le noyau

Cela peut affecter les applications explicitement configurées pour utiliser le moteur AF_ALG ou les applications qui créent directement des sockets AF_ALG. Vérifiez d’abord :

sudo lsof | grep AF_ALG || true
ss -xa | grep -i alg || true

Documentation opérateur

• Runbook de réponse aux incidents
• Guide de déploiement flotte
• Guide de validation communautaire
• Exemples de sorties
• Checklist de publication
• Notes de validation seccomp
• Modèle d’évaluation sécurisée
• Politique de sécurité
• Politique de support
• Guide de contribution
• Journal des modifications

Maturité du projet

• Périmètre actuel : évaluation défensive, atténuation hôte pour algif_aead modulaire, durcissement seccomp pour charges de travail non fiables et restauration.
• Utilisateur cible : opérateurs à l’aise avec le durcissement hôte et conteneur Linux.
• Style de publication : versions étiquetées, entrées de changelog, tests de fumée GitHub Actions et modèles de problèmes pour des rapports reproductibles.
• Signal communautaire : les rapports de compatibilité sont le signal de confiance le plus fort ; les preuves terrain peuvent devenir documentation, tests et exemples.
• Promesse de stabilité : éviter le comportement d’exploitation, garder les écritures hôte étroites, documenter la sémantique des codes de sortie et préserver les baselines seccomp d’exécution existantes.

Limitations

CopyFail Guard ne :

• patche pas votre noyau
• prouve pas que votre build exacte du noyau est exploitable
• fournit pas de code d’exploitation
• protège pas contre des utilisateurs root déjà compromis
• remplace pas l’EDR, l’inventaire de flotte, les avis fournisseur ou la planification des redémarrages

L’atténuation hôte par module fonctionne pour algif_aead modulaire. Si algif_aead est intégré à votre noyau, modprobe.d et rmmod ne peuvent pas le désactiver ; un correctif/redémarrage est obligatoire et seccomp doit être utilisé pour les charges de travail non fiables pendant le correctif.

Seccomp protège uniquement les charges de travail lancées avec le profil. Les conteneurs ou pods en cours d’exécution doivent être redémarrés avec le profil durci.

Restauration

sudo ./bin/copyfail-guard.sh rollback --yes

La restauration supprime uniquement le fichier géré par cet outil. Elle ne recharge pas le module. Redémarrez ou exécutez manuellement modprobe algif_aead seulement si vous en avez explicitement besoin et avez accepté le risque ou corrigé le noyau.

FAQ

Est-ce un remplacement du correctif ?

Non. Le correctif et le redémarrage restent le correctif final.

Cela teste-t-il l’exploitation ?

Non. Le projet évite intentionnellement le comportement d’exploitation. tools/afalg-socket-test.py vérifie uniquement si la création de socket AF_ALG est accessible.

Pourquoi bloquer AF_ALG dans les conteneurs même après l’atténuation hôte ?

Défense en profondeur. Les conteneurs et les charges de travail CI sont des endroits courants où du code non fiable s’exécute sur un noyau partagé. Seccomp rend la première étape de cette classe d’attaque inaccessible pour cette charge de travail.

Pourquoi patcher un profil seccomp existant plutôt qu’en générer un nouveau ?

Parce que les profils d’exécution par défaut contiennent de nombreuses décisions de durcissement. Les remplacer par un profil d’urgence minimal peut supprimer accidentellement des protections. seccomp-patch conserve votre baseline et ajoute le refus AF_ALG.

Puis-je l’utiliser sur toute une flotte ?

Oui. Commencez par doctor et assess --json, déployez l’atténuation sur un petit échantillon Linux, puis déployez séparément l’atténuation hôte et les modifications de profil seccomp. Voir Guide de déploiement flotte.

Références

• NVD : CVE-2026-31431
• Avis CERT-EU : Vulnérabilité élevée dans le noyau Linux (« Copy Fail ») – Version anglaise
• Entrée du catalogue CISA des vulnérabilités exploitées connues
• Avis technique public copy.fail
• Correctif stable Linux : crypto: algif_aead - Revert to operating out-of-place

Auteur

Construit par Julio César Suástegui Calderón.

Ingénierie sécurité, systèmes Linux et automatisation défensive pratique.

Licence

MIT