Dokploy : une commande compose atteint la racine de l'hôte
Un membre Dokploy avec service:create peut exécuter une commande en root avec le système de fichiers de l'hôte monté ; aucune version corrigée au 21 novembre.
En bref
- Dokploy valide les caractères d'une commande compose mais jamais le premier mot, donc un membre peut faire exécuter
docker runau script de déploiement avec la racine de l'hôte montée. - Toutes les versions de Dokploy qui acceptent une commande compose sont concernées, y compris 0.31.4, la version actuelle. L'attaquant a besoin d'un compte membre avec
service:createet d'un accès à un service compose. - Le chercheur évalue chaque chemin Critical, CVSS v3.1 9,9, et a publié une preuve réelle le 2026-11-21. Aucune version corrigée n'existe et aucune CVE n'est attribuée. Aucune exploitation en conditions réelles n'est connue, et le problème n'est pas dans le catalogue KEV de la CISA au 2026-11-21.
- Réservez
service:createaux membres de confiance, gardez Dokploy hors des réseaux non fiables et auditez les commandes compose stockées en base. Voir « Comment corriger ? ».
Suis-je concerné ?
Toutes ces conditions doivent être réunies :
- Le déploiement est un Dokploy auto-hébergé, et le conteneur serveur s'exécute avec la socket Docker de l'hôte, ce qui correspond à l'installation standard.
- Un membre de l'organisation qui n'est ni propriétaire ni administrateur possède la permission
service:create. Le rôle membre par défaut peut créer des services, et un rôle personnalisé peut l'accorder. - Ce membre peut atteindre un service compose, le sien ou un service partagé avec l'organisation.
- Le service compose accepte une commande personnalisée dans le champ de commande.
Un administrateur Dokploy n'est pas le modèle de menace. La faille permet à un membre ordinaire de franchir la frontière entre membre et hôte. Un déploiement qui n'accorde service:create qu'aux administrateurs n'est pas exposé par ce chemin.
Dokploy est conçu pour les équipes : une organisation possède des projets, les projets possèdent des environnements, et les environnements possèdent des services. Le rôle membre existe pour que les développeurs déploient sans détenir le rôle propriétaire ou administrateur. Cette séparation est la frontière de contrôle d'accès du produit, et le champ de commande compose se trouve du côté membre.
| Version | Concernée | Version corrigée |
|---|---|---|
| 0.29.13 à 0.31.4, y compris la version actuelle | Oui | Aucune au 2026-11-21 |
| Avant 0.29.13 | Oui, via l'injection de commande d'origine | Aucune au 2026-11-21 |
La version 0.29.13 a ajouté le filtre de caractères que ce contournement met en échec. Les versions antérieures acceptent le même champ de commande sans ce filtre, elles sont donc aussi concernées.
Vérifiez la version en cours et les membres qui peuvent créer des services :
docker inspect dokploy --format '{{.Config.Image}}'
docker exec dokploy sh -c 'cat /app/package.json | grep version'
Dans l'interface Dokploy, examinez les membres et les rôles personnalisés de chaque organisation. Un membre avec service:create peut utiliser ce chemin. L'API expose le même ensemble de permissions.
Comment corriger ?
Aucune version corrigée de Dokploy n'existe au 2026-11-21. La version actuelle, 0.31.4, interpole toujours la commande non validée. En attendant un correctif, réduisez qui peut atteindre la fonctionnalité.
- Retirez
service:createà chaque membre qui n'a pas besoin de déployer des services. Utilisez un rôle personnalisé pour les déployeurs plutôt que le rôle membre par défaut. - Retirez les membres non fiables des organisations qui possèdent des services compose.
- Gardez l'interface et l'API Dokploy hors d'Internet. Placez-les derrière un VPN, un proxy conscient de l'identité ou une liste d'autorisation.
- Auditez les commandes compose déjà stockées. Un membre a peut-être utilisé ce chemin avant la divulgation.
- Surveillez les notes de version de Dokploy pour un correctif qui valide la commande comme une liste d'arguments, pas comme une chaîne.
Un reverse proxy qui bloque le point d'entrée de mise à jour compose réduit l'exposition, mais bloque aussi les déploiements légitimes. Traitez-le comme un contrôle temporaire et conservez la réduction des permissions.
La revue des permissions est le contrôle durable, car elle ne dépend pas d'un correctif. Listez chaque membre de l'organisation et chaque rôle personnalisé, puis retirez service:create là où le membre ne déploie pas. Un déployeur qui doit seulement redémarrer un service peut recevoir un rôle plus étroit. Consignez le changement pour que la prochaine revue d'accès parte de l'ensemble réduit.
Quelle est la cause racine ?
La commande compose est stockée comme texte libre, filtrée pour les métacaractères de shell, puis interpolée dans une commande docker qui s'exécute via un shell. Le filtre ne vérifie jamais le premier jeton de la commande.
Le champ de commande est une simple chaîne optionnelle dans packages/server/src/db/schema/compose.ts à l'étiquette 0.31.2, lignes 200 et 283. Le constructeur le lit dans packages/server/src/utils/builders/compose.ts :
// compose.ts, 0.31.2, lines 84-123 (abridged)
const UNSAFE_COMPOSE_COMMAND = /[;|`$(){}<>\n\\]/;
const sanitizeCommand = (command: string) => {
const sanitizedCommand = command.trim();
if (UNSAFE_COMPOSE_COMMAND.test(sanitizedCommand)) {
throw new Error("Invalid characters in compose command: shell control characters are not allowed");
}
if (sanitizedCommand.includes("&")) {
// ...
const chains = sanitizedCommand.split("&&").map((cmd) => cmd.trim());
const isSafeChain = chains.slice(1).every(
(cmd) => cmd.startsWith("docker compose ") || cmd.startsWith("docker-compose "),
);
if (!isSafeChain) {
throw new Error("Chained commands must strictly start with 'docker compose '");
}
}
const parts = sanitizedCommand.split(/\s+/);
return parts.map((arg) => arg.replace(/^"(.*)"$/, "$1")).join(" ");
};
Le filtre bloque les points-virgules, les barres verticales, les accents graves, $(), les accolades, les chevrons, les retours à la ligne et les barres obliques inversées. Il vérifie aussi les commandes après &&. Il ne vérifie pas le premier mot, et la charge utile n'a besoin d'aucun métacaractère.
createCommand renvoie la chaîne assainie quand le champ est défini. getBuildComposeCommand la place après docker :
// compose.ts, 0.31.2, line 128 and the deploy script
return `${sanitizeCommand(compose.command)}`;
// ...
env -i PATH="$PATH" HOME="$HOME" ${exportEnvCommand} docker ${command.split(" ").join(" ")} 2>&1
packages/server/src/services/compose.ts exécute ce script via execAsync, qui enveloppe child_process.exec de Node et donc /bin/sh. Le processus serveur de Dokploy est root dans son conteneur, et l'installation standard monte /var/run/docker.sock. Un docker run qui monte / comme volume écrit donc dans le système de fichiers racine de l'hôte.
Le chemin du formulaire au shell est court. Un enregistrement de déploiement est créé, le constructeur assemble un script bash, et execAsync l'exécute avec les privilèges du serveur. Aucune étape n'analyse la commande en liste d'arguments ni ne compare le premier mot à une liste d'autorisation. Le filtre de caractères est le seul contrôle, et il a été écrit pour une autre forme de charge utile.
La frontière de confiance est le point central. Un membre est autorisé à décrire un déploiement, pas à choisir le processus qui l'exécute. Dès que la chaîne de commande atteint un shell, le texte du membre devient le processus du serveur, et la distinction entre les deux rôles disparaît.
Le correctif de CVE-2026-72884 a ajouté ce filtre dans le commit d48037a80 le 2026-07-20. Il a arrêté les charges utiles à métacaractères décrites par la CVE. Il a laissé ouvert le chemin du premier jeton.
Comment la faille est-elle exploitée ?
- L'attaquant se connecte en tant que membre avec
service:createet ouvre un service compose auquel il a accès. - L'attaquant place dans le champ de commande une invocation
docker runqui monte le système de fichiers de l'hôte. La preuve du chercheur utilisaitrun --rm -v /:/hostfs alpine touch /hostfs/tmp/canary. sanitizeCommandne trouve aucun caractère bloqué. La chaîne ne contient ni point-virgule, ni accent grave, ni$, ni accolade, ni chevron, ni retour à la ligne, ni barre oblique inversée.getBuildComposeCommandproduitdocker run --rm -v /:/hostfs alpine touch /hostfs/tmp/canary.- Un déploiement exécute le script en root via
/bin/sh. - Le conteneur monte le
/de l'hôte sur/hostfset écrit le fichier témoin en root sur l'hôte.
Le chercheur a aussi signalé un second chemin via un fichier compose brut, qui accepte privileged: true, un montage de l'hôte et cap_add: SYS_ADMIN. Cet article couvre le champ de commande, qui a été vérifié dans le code source publié.
La preuve publique est un test réel sur le banc du chercheur. Elle inclut une exécution de contrôle de la suite de régression de l'éditeur, qui rejette les 13 charges utiles à métacaractères, et la charge utile du premier jeton, que le même code accepte. Le document est lié dans les références.
Comment se déroule l'attaque ?
Un membre écrit une commande qui commence par run au lieu de compose, le validateur ne vérifie que les caractères, et le script de déploiement exécute le résultat en root avec la socket Docker de l'hôte.
commande compose"] --> B["sanitizeCommand bloque
les métacaractères"] B --> C["Le premier jeton
n'est jamais validé"] C --> D["docker run avec
la racine de l'hôte montée"] D --> E["Le script de déploiement
s'exécute en root via /bin/sh"] E --> F["Écriture sur le système
de fichiers de l'hôte en root"]
Que peut faire un attaquant ?
Un membre qui peut créer ou modifier un service compose peut exécuter un conteneur en root avec le système de fichiers de l'hôte monté en lecture-écriture. Cela atteint les fichiers de l'hôte, le démon Docker et tous ses conteneurs.
L'impact exige toutes ces conditions :
- Un compte membre avec
service:create. - Un accès à au moins un service compose.
- Un déclenchement du déploiement, par l'action du membre ou par la planification du service.
- L'installation standard, où le conteneur serveur détient la socket Docker de l'hôte.
Le résultat démontré est un fichier appartenant à root sur l'hôte. La même primitive peut lire les fichiers de l'hôte, modifier l'état du démon Docker, démarrer des conteneurs privilégiés et atteindre les charges des autres locataires. Le chercheur n'a pas revendiqué de compromission de production et n'a testé que sur son propre banc.
L'hôte est la frontière de confiance partagée. Chaque projet sur ce serveur conserve ses variables d'environnement, ses volumes et ses identifiants de base de données sur le même système de fichiers. Un membre qui atteint l'hôte peut les lire sans toucher au compte d'une autre organisation.
Aucune exploitation en conditions réelles n'est connue au 2026-11-21. Le problème n'a pas de CVE et n'est pas dans le catalogue KEV de la CISA.
Pourquoi le correctif fonctionne-t-il ?
Aucun correctif n'existe encore. Un correctif ne fonctionne que s'il cesse de traiter la commande comme une chaîne et la valide comme une liste d'arguments.
La forme sûre est une liste d'autorisation de sous-commandes. Le premier jeton doit être compose (ou le binaire compose configuré), et les jetons restants doivent être analysés comme des arguments, pas recomposés en chaîne de shell. Une vérification qui ne bloque que les métacaractères laisse le chemin du premier jeton ouvert, comme ce cas le montre.
En attendant un tel contrôle, la maîtrise repose sur les permissions : seuls des membres de confiance peuvent définir une commande compose, et le déploiement s'exécute là où la compromission d'un membre n'atteint pas l'hôte.
Comment vérifier si j'ai été compromis ?
Aucun indicateur de compromission n'est publié. Le fichier témoin du chercheur est un artefact de test, pas un indicateur d'attaquant.
Examinez les commandes compose stockées et les déploiements qui les ont exécutées :
SELECT "composeId", "name", command
FROM compose
WHERE command <> ''
ORDER BY "createdAt" DESC;
Cherchez les commandes qui commencent par run, exec, create ou volume, et les -v /: ou --privileged dans les arguments. Examinez les journaux de déploiement pour des lignes docker run dont le service n'avait pas besoin.
La charge utile publiée utilise --rm, donc elle ne laisse aucun conteneur à inspecter. L'indicateur principal est donc un fichier créé sur l'hôte hors des chemins de déploiement attendus, notamment sous /tmp et /root. Pour une variante qui conserve son conteneur, inspectez chaque conteneur pour un montage de l'hôte ou l'indicateur privileged :
docker ps -aq | xargs docker inspect --format '{{.Name}} {{.HostConfig.Binds}} {{.HostConfig.Privileged}}' | grep -E '/:|docker\.sock|true'
Un conteneur qui monte / ou /var/run/docker.sock et n'a pas été créé par un déploiement connu est une piste. Le nom de l'image est choisi par l'attaquant, donc ne filtrez pas dessus.
Chronologie
- 2026-07-20 : le commit d48037a80 ajoute
sanitizeCommandà Dokploy, le correctif de CVE-2026-72884. - 2026-08-10 : CVE-2026-72884 est publiée avec CVSS v4.0 8,7.
- 2026-11-13 : Dokploy 0.31.2 est publié avec le même manque sur le premier jeton.
- 2026-11-17 : Dokploy 0.31.4 est publié, toujours sans vérification du premier jeton.
- 2026-11-21 : le chercheur publie le contournement et une preuve réelle.
FAQ
Est-ce la même chose que CVE-2026-72884 ?
Non. CVE-2026-72884 couvrait les métacaractères de shell dans la commande compose, et Dokploy l'a corrigée en 0.29.13. Ce contournement utilise le premier jeton, donc il passe le nouveau filtre sans aucun métacaractère.
Faut-il être administrateur ?
Non. Un membre non propriétaire et non administrateur avec service:create suffit. Le rôle membre par défaut peut créer des services, et un rôle personnalisé peut accorder la permission.
Existe-t-il une version corrigée ?
Non. Dokploy 0.31.4, la version actuelle au 2026-11-21, accepte encore la charge utile. Le projet n'a publié ni avis ni CVE pour ce chemin.
L'attaque nécessite-t-elle un déploiement planifié ?
Non. Le membre peut déclencher le déploiement. Une planification retire seulement le besoin d'une seconde action.
L'attaquant peut-il atteindre d'autres organisations ?
L'impact démontré est l'hôte, et l'hôte détient les conteneurs et volumes de toutes les organisations. Un membre d'une organisation peut donc atteindre des données hors de son organisation si le déploiement s'exécute sur un hôte partagé.
La faille est-elle exploitée en conditions réelles ?
Aucune exploitation n'est connue au 2026-11-21. Le problème n'est pas dans le catalogue KEV de la CISA, et aucune CVE n'est attribuée.
Trouvez les instances Dokploy exposées avec Ostorlab
Dokploy est souvent joignable sur l'hôte qui exécute les charges de production. La découverte de surface d'attaque d'Ostorlab inventorie les services exposés sur Internet par votre organisation, afin de trouver un panneau Dokploy qui devrait rester derrière un VPN : https://ostorlab.co/product/attacksurface_discovery
Références
- Divulgation du chercheur à oss-security, 2026-11-21 : https://www.openwall.com/lists/oss-security/2026/11/21/3 (vérifié le 21 novembre 2026)
- Document du chercheur, « Two doors, same room » : https://archive.org/details/knell-two-doors (vérifié le 21 novembre 2026)
- Source Dokploy 0.31.2, schéma de commande : https://github.com/Dokploy/dokploy/blob/v0.31.2/packages/server/src/db/schema/compose.ts (vérifié le 21 novembre 2026)
- Source Dokploy 0.31.2, constructeur de commande : https://github.com/Dokploy/dokploy/blob/v0.31.2/packages/server/src/utils/builders/compose.ts (vérifié le 21 novembre 2026)
- Source Dokploy 0.31.2, service compose : https://github.com/Dokploy/dokploy/blob/v0.31.2/packages/server/src/services/compose.ts (vérifié le 21 novembre 2026)
- Version Dokploy 0.31.4 : https://github.com/Dokploy/dokploy/releases/tag/v0.31.4 (vérifié le 21 novembre 2026)
- Dossier CVE-2026-72884 : https://www.cve.org/CVERecord?id=CVE-2026-72884 (vérifié le 21 novembre 2026)
- Commit de correction d48037a80 : https://github.com/Dokploy/dokploy/commit/d48037a80203bb0ecaec4f5653aef75fcfdb656d (vérifié le 21 novembre 2026)
- Contrôle d'accès Dokploy,
service:create: https://github.com/Dokploy/dokploy/blob/v0.31.2/packages/server/src/lib/access-control.ts (vérifié le 21 novembre 2026) - Dépôt Docker Hub, 16 550 010 téléchargements : https://hub.docker.com/r/dokploy/dokploy (vérifié le 21 novembre 2026)
- Dépôt Dokploy, 38 636 étoiles : https://github.com/Dokploy/dokploy (vérifié le 21 novembre 2026)
- Catalogue Known Exploited Vulnerabilities de la CISA, version 2026.11.20 : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 21 novembre 2026)