79 % contre 51 % : les néobanques indépendantes en retard sur la sécurité des applications. Lire le rapport

Analyse approfondie

Analyse approfondie

Injection de commande dans les sauvegardes Dokploy jusqu'au root de l'hôte (CVE-2026-129433)

Un membre de Dokploy peut injecter une commande shell via le serviceName d'une sauvegarde compose et l'exécuter en root sur l'hôte. Corrigé en 0.31.1.

En bref

  • Un membre de Dokploy peut stocker une commande shell dans le serviceName d'une sauvegarde compose et la faire exécuter en root au moment de la sauvegarde. La commande s'exécute dans le conteneur Dokploy, qui monte la socket Docker de l'hôte.
  • Toutes les versions de Dokploy antérieures à 0.31.1 sont concernées. L'attaquant a besoin d'un compte membre disposant de la permission de créer des sauvegardes et d'un accès à un service compose.
  • CVE-2026-129433 est notée CVSS v3.1 9,9 et CVSS v4.0 9,4, critique. L'avis contient une preuve de concept Python publique ; aucune exploitation dans la nature n'est connue, et la CVE n'est pas dans le catalogue KEV de la CISA au 15 novembre 2026.
  • Mettez à niveau vers 0.31.1 ou une version ultérieure. En attendant, retirez la permission de créer des sauvegardes aux membres et limitez l'accès au panneau ; voir « Comment corriger ? ».

Suis-je concerné ?

Toutes ces conditions doivent être réunies :

  • Vous exploitez Dokploy auto-hébergé dans une version antérieure à 0.31.1.
  • Un membre de l'organisation dispose de la permission de créer des sauvegardes et d'un accès à un service compose. Le rôle membre intégré de Dokploy accorde la création de sauvegardes par défaut.
  • Au moins une destination de sauvegarde est enregistrée dans l'organisation. Le membre n'a besoin que de l'identifiant de la destination, et le rôle membre ne peut pas gérer les destinations.
  • La sauvegarde est activée et sa planification se déclenche. L'avis utilise une planification toutes les minutes, donc la commande s'exécute en moins de 60 secondes.

Une installation avec un seul administrateur contient toujours le code vulnérable, mais cet administrateur est déjà équivalent à root. La faille compte lorsque vous donnez des comptes membres à d'autres personnes.

L'enregistrement CVE liste toutes les versions antérieures à 0.31.1 comme concernées et ne donne aucune borne basse. Le correctif est le commit b24006e16e95 de la demande de fusion #5908, fusionné le 11 novembre 2026. La version 0.31.1 est sortie le 12 novembre 2026, et 0.31.2 est la version actuelle.

Branche Versions concernées Version corrigée
Dokploy auto-hébergé Toutes les versions antérieures à 0.31.1 0.31.1 (12 novembre 2026) ; 0.31.2 est la version actuelle

Dokploy Cloud exécute le même code et reçoit les correctifs de l'éditeur. Si vous utilisez le service hébergé, demandez à Dokploy de confirmer la version que votre organisation utilise.

Vérifiez l'image en cours d'exécution :

docker service inspect dokploy --format '{{.Spec.TaskTemplate.ContainerSpec.Image}}'
docker inspect dokploy --format '{{.Config.Image}}'

La première commande lit le service Swarm que crée l'installateur officiel. La seconde lit un conteneur autonome. L'étiquette après les deux-points est la version. Une étiquette latest ou un digest ne donne pas la version, donc ouvrez aussi la page Paramètres du panneau.

Comment corriger ?

Mettez à niveau vers 0.31.1 ou une version ultérieure :

  1. Sauvegardez /etc/dokploy et la base de données Dokploy avant de changer l'image.
  2. Lancez le programme de mise à jour officiel, qui récupère la dernière image stable et met à jour le service dokploy :
curl -sSL https://dokploy.com/install.sh | sh -s update
  1. Vérifiez que l'image en cours d'exécution est 0.31.1 ou ultérieure avec la commande d'inspection de « Suis-je concerné ? ».
  2. Si vous épinglez une version, récupérez-la et mettez à jour le service explicitement :
docker pull dokploy/dokploy:v0.31.1
docker service update --image dokploy/dokploy:v0.31.1 dokploy
  1. Si Dokploy s'exécute dans un conteneur autonome plutôt que dans un service Swarm, supprimez le conteneur et recréez-le avec la nouvelle image. Récupérer l'image seule ne remplace pas un conteneur en cours d'exécution.

Si vous ne pouvez pas mettre à niveau tout de suite, réduisez l'exposition :

  1. Retirez les permissions de création et de mise à jour des sauvegardes à chaque membre qui n'en a pas besoin. Utilisez l'éditeur de rôles du panneau, ou effacez la surcharge héritée canCreateServices de ce membre.
  2. Auditez chaque sauvegarde compose et supprimez ou corrigez tout serviceName qui contient des caractères autres que des lettres, des chiffres, des points, des traits d'union et des traits de soulignement.
  3. Gardez le panneau hors d'Internet, ou autorisez uniquement des réseaux de confiance à joindre le port 3000.
  4. Surveillez le journal du serveur pour les lignes Executing backup command dont le filtre de service contient des métacaractères shell, avec les vérifications de « Comment vérifier si j'ai été compromis ? ».

Le contournement ne corrige pas le code. Un propriétaire ou un administrateur peut toujours créer la sauvegarde, mais ce compte est déjà équivalent à root. Retirer la permission aux membres est la partie qui aide.

Quelle est la cause racine ?

La fonction de sauvegarde compose de Dokploy stocke le nom du service compose à sauvegarder. Au moment de la sauvegarde, getComposeContainerCommand() construit une commande docker ps qui trouve le conteneur en cours d'exécution par ses étiquettes Compose, et interpole le nom stocké dans un argument --filter entre guillemets doubles.

Voici la fonction en v0.31.0, dans packages/server/src/utils/backups/utils.ts, lignes 144 à 153 :

export const getComposeContainerCommand = (
    appName: string,
    serviceName: string,
    composeType: "stack" | "docker-compose" | undefined,
) => {
    if (composeType === "stack") {
        return `docker ps -q --filter "status=running" --filter "label=com.docker.stack.namespace=${appName}" --filter "label=com.docker.swarm.service.name=${appName}_${serviceName}" | head -n 1`;
    }
    return `docker ps -q --filter "status=running" --filter "label=com.docker.compose.project=${appName}" --filter "label=com.docker.compose.service=${serviceName}" | head -n 1`;
};

La valeur n'est jamais validée ni échappée. Elle vient de la table backups, où serviceName est une simple colonne texte (packages/server/src/db/schema/backups.ts, ligne 49). L'entrée tRPC est construite avec createInsertSchema(backups, {...}). Cet appel remplace prefix, customName, database, schedule et les identifiants de service, mais pas serviceName (apiCreateBackup, lignes 180 à 200). Le champ accepte donc les guillemets, les points-virgules, les accents graves et les substitutions de commande.

getContainerSearchCommand() lit la valeur stockée et la passe à getComposeContainerCommand() (lignes 155 à 183). getBackupCommand() enveloppe le résultat dans un script bash. Le lanceur de sauvegarde compose exécute ce script avec execAsync(backupCommand, { shell: "/bin/bash" }) dans packages/server/src/utils/backups/compose.ts, lignes 53 à 57.

L'opération vulnérable est l'interpolation elle-même. La valeur se trouve entre guillemets doubles, donc un " dans serviceName ferme le guillemet. Tout ce qui suit est analysé comme de la syntaxe shell.

Comment la faille est-elle exploitée ?

  1. L'attaquant se connecte au panneau avec un compte membre.
  2. L'attaquant crée, ou réutilise, un service compose dans un projet auquel le compte a accès.
  3. L'attaquant appelle backup.create avec backupType défini sur compose, l'identifiant du compose, un identifiant de destination de l'organisation et un serviceName forgé.
  4. Dokploy stocke la sauvegarde et la planifie.
  5. Au prochain déclenchement, getBackupCommand() construit le script bash, et bash exécute la commande docker ps puis la commande injectée en root.
  6. La commande peut utiliser la socket Docker montée pour démarrer un conteneur privilégié et monter le système de fichiers de l'hôte.

L'avis publie une preuve de concept Python et la séquence de requêtes. Le cœur est la valeur stockée. Voici la valeur réduite de l'avis :

"serviceName": "svc\" ; id ; echo \""

La valeur plus complète de l'avis capture la sortie de id et l'envoie à un webhook. La même requête définit schedule sur */1 * * * * et enabled sur true, donc la commande s'exécute en moins d'une minute. La preuve de concept ne demande qu'un compte membre et un identifiant de destination, pas les identifiants de la destination.

Comment se déroule l'attaque ?

Un membre stocke une commande shell dans le nom de service d'une sauvegarde compose, et la sauvegarde planifiée l'exécute en root via la socket Docker.

flowchart LR A["Un membre appelle backup.create"] --> B["serviceName accepté comme n'importe quelle chaîne"] --> C["La sauvegarde stocke la charge utile"] --> D["Le cron construit le filtre docker ps"] --> E["Aucun échappement shell dans getComposeContainerCommand"] --> F["bash exécute la commande en root"] --> G["La socket Docker expose l'hôte"]

Que peut faire un attaquant ?

L'attaquant exécute des commandes arbitraires en root dans le conteneur Dokploy. Sur une installation standard, ce conteneur monte la socket Docker de l'hôte en lecture-écriture. L'attaquant peut démarrer un conteneur privilégié qui monte le système de fichiers racine de l'hôte, puis lire ou modifier chaque fichier de l'hôte. L'avis parle d'une compromission complète de l'hôte.

Le même accès atteint la configuration du panneau sous /etc/dokploy et les secrets Docker sous /run/secrets, dont le mot de passe de la base de données et le secret d'authentification. Ces secrets donnent à l'attaquant un accès direct à la base de données et à l'authentification du panneau.

Toutes ces conditions doivent être réunies :

  • Un compte de niveau membre sur le panneau.
  • La permission de créer des sauvegardes pour ce compte. Le rôle membre par défaut l'a.
  • L'accès à au moins un service compose.
  • Un identifiant de destination qui appartient à l'organisation.
  • Une planification de sauvegarde qui se déclenche pendant que la charge utile est stockée.

La faille n'est pas exploitable sans authentification. Un membre sans la permission de sauvegarde ne peut pas créer la sauvegarde. Lorsque le service compose est affecté à un serveur distant, Dokploy exécute le script de sauvegarde via execAsyncRemote sur ce serveur. La commande s'exécute là-bas plutôt que sur l'hôte du panneau.

Pourquoi le correctif fonctionne-t-il ?

Le correctif échappe chaque valeur interpolée avec quote() du paquet shell-quote, donc bash reçoit chaque filtre comme un seul argument. Voici le changement dans getComposeContainerCommand() :

    if (composeType === "stack") {
-       return `docker ps -q --filter "status=running" --filter "label=com.docker.stack.namespace=${appName}" --filter "label=com.docker.swarm.service.name=${appName}_${serviceName}" | head -n 1`;
+       return `docker ps -q --filter "status=running" --filter ${quote([`label=com.docker.stack.namespace=${appName}`])} --filter ${quote([`label=com.docker.swarm.service.name=${appName}_${serviceName}`])} | head -n 1`;
    }
-   return `docker ps -q --filter "status=running" --filter "label=com.docker.compose.project=${appName}" --filter "label=com.docker.compose.service=${serviceName}" | head -n 1`;
+   return `docker ps -q --filter "status=running" --filter ${quote([`label=com.docker.compose.project=${appName}`])} --filter ${quote([`label=com.docker.compose.service=${serviceName}`])} | head -n 1`;
 };

quote() échappe l'argument de filtre entier, y compris le préfixe de l'étiquette et la valeur. Un guillemet, un point-virgule ou un $() dans serviceName reste une partie de l'argument et n'est jamais analysé comme de la syntaxe shell.

Le même commit échappe la destination rclone et les chemins des fichiers de sauvegarde dans getBackupCommand() et keepLatestNBackups(), et ajoute des garde-fous qui désactivent les sauvegardes de serveur web et le nettoyage des dernières sauvegardes sur Dokploy Cloud. Les notes de version listent plusieurs correctifs voisins d'injection de commande dans la même version, dans les chemins du montage de fichiers, de la planification, de la sauvegarde de volumes, du mot de passe de base de données et de la construction d'application. Le correctif ferme le chemin serviceName décrit par cette CVE.

Comment vérifier si j'ai été compromis ?

Le serveur journalise la commande de sauvegarde complète avant que bash ne l'exécute. Sur une installation Swarm, lisez le journal du service :

docker service logs dokploy 2>&1 | grep -i "Executing backup command"

Sur un conteneur autonome, lisez le journal du conteneur :

docker logs dokploy 2>&1 | grep -i "Executing backup command"

Un serviceName légitime est un simple nom de service Compose. Sur une installation Swarm, ces deux recherches affichent les lignes dont le filtre de service contient un point-virgule, un $( ou un accent grave :

docker service logs dokploy 2>&1 | grep -i "Executing backup command" | grep -E 'service=[^|]*;'
docker service logs dokploy 2>&1 | grep -i "Executing backup command" | grep -E 'service=[^|]*(\$\(|`)'

Sur un conteneur autonome, remplacez docker service logs dokploy par docker logs dokploy dans les deux recherches. Les recherches ne couvrent pas les guillemets, les tubes ni les esperluettes ; vérifiez-les avec l'inspection du panneau ci-dessous.

Ouvrez aussi la liste des sauvegardes du panneau pour chaque service compose et inspectez le nom de service stocké. Une valeur qui n'est pas un simple nom est une piste à vérifier, pas une preuve d'exécution. Le journal de déploiement de la sauvegarde enregistre aussi les lignes Executing backup command et Starting backup and upload to S3.

Aucun indicateur de compromission n'est publié pour cette CVE. Une tentative échouée laisse tout de même la chaîne de commande dans le journal, car Dokploy écrit la ligne de journal avant que bash n'exécute le script. Si vous trouvez une correspondance, traitez l'hôte comme compromis. Renouvelez les secrets de /etc/dokploy et de /run/secrets, dont le mot de passe de la base de données et le secret d'authentification, puis reconstruisez le panneau à partir d'une image propre.

Chronologie

  • 2026-11-11 : correctif fusionné dans la demande de fusion #5908, commit b24006e16e95.
  • 2026-11-12 : Dokploy v0.31.1 publiée ; avis GHSA-j329-jw7j-rxjm publié avec une preuve de concept publique.
  • 2026-11-14 : CVE-2026-129433 publiée.

Le correctif est sorti avant l'enregistrement CVE, trois jours après la fusion du patch
Figure 1 : Du correctif à l'enregistrement CVE. Source : avis Dokploy, commit du correctif et enregistrement CVE, vérifiés le 15 novembre 2026

FAQ

La faille me concerne-t-elle si je n'ai jamais créé de sauvegarde compose ?

Uniquement si un membre disposant de la permission de sauvegarde en crée une avec un nom de service forgé. Le code vulnérable est présent dans toutes les versions antérieures à 0.31.1, donc un compte qui peut créer la sauvegarde peut déclencher la faille. Retirez cette permission aux membres auxquels vous ne faites pas confiance.

Un attaquant non authentifié peut-il l'exploiter ?

Non. L'attaquant a besoin d'un compte membre connecté avec la permission de créer des sauvegardes et d'un accès à un service compose. La preuve de concept de l'avis part d'une connexion membre.

J'ai mis à niveau vers 0.31.1. La faille est-elle corrigée ?

Oui pour ce chemin. La version échappe le nom de service et les autres valeurs interpolées dans les commandes de sauvegarde. La version 0.31.2 est la version actuelle et contient aussi le correctif.

CVE-2026-129433 a-t-elle été exploitée dans la nature ?

Aucune exploitation n'est signalée dans l'avis ni dans l'enregistrement CVE. La CVE n'est pas dans le catalogue KEV de la CISA au 15 novembre 2026, et l'enregistrement CVE ne contient aucune évaluation d'exploitation de la CISA.

Que gagne un attaquant au-delà du panneau ?

La socket Docker. Root dans le conteneur Dokploy peut démarrer un conteneur privilégié avec le système de fichiers de l'hôte monté, ce qui donne le contrôle de l'hôte et de chaque service géré par Dokploy. La configuration du panneau sous /etc/dokploy et les secrets Docker sous /run/secrets deviennent aussi lisibles.

Puis-je continuer à utiliser Dokploy pendant que je prépare la mise à niveau ?

Oui, si vous retirez les permissions de création et de mise à jour des sauvegardes aux membres et gardez le panneau sur un réseau de confiance. Un propriétaire ou un administrateur peut toujours créer la sauvegarde, donc traitez ces comptes comme équivalents à root.

Références

  • GitHub Security Advisory, « OS Command Injection via serviceName in Compose Backup », GHSA-j329-jw7j-rxjm (publié le 12 novembre 2026) : https://github.com/Dokploy/dokploy/security/advisories/GHSA-j329-jw7j-rxjm (vérifié le 15 novembre 2026)
  • Enregistrement du programme CVE, CVE-2026-129433 (publié le 14 novembre 2026) : https://www.cve.org/CVERecord?id=CVE-2026-129433 (vérifié le 15 novembre 2026)
  • Commit du correctif Dokploy b24006e16e95 (fusionné le 11 novembre 2026) : https://github.com/Dokploy/dokploy/commit/b24006e16e95a10ce3daf739d06ac783e5c70ba0 (vérifié le 15 novembre 2026)
  • Demande de fusion Dokploy #5908, « fix(security): backup prefix/bucket/serviceName command injection » : https://github.com/Dokploy/dokploy/pull/5908 (vérifié le 15 novembre 2026)
  • Version Dokploy v0.31.1 (12 novembre 2026) : https://github.com/Dokploy/dokploy/releases/tag/v0.31.1 (vérifié le 15 novembre 2026)
  • Utilitaires de sauvegarde Dokploy v0.31.0, packages/server/src/utils/backups/utils.ts : https://github.com/Dokploy/dokploy/blob/v0.31.0/packages/server/src/utils/backups/utils.ts (vérifié le 15 novembre 2026)
  • Schéma de sauvegarde Dokploy v0.31.0, packages/server/src/db/schema/backups.ts : https://github.com/Dokploy/dokploy/blob/v0.31.0/packages/server/src/db/schema/backups.ts (vérifié le 15 novembre 2026)
  • Lanceur de sauvegarde compose Dokploy v0.31.0, packages/server/src/utils/backups/compose.ts : https://github.com/Dokploy/dokploy/blob/v0.31.0/packages/server/src/utils/backups/compose.ts (vérifié le 15 novembre 2026)
  • Script d'installation officiel de Dokploy, qui monte /var/run/docker.sock : https://dokploy.com/install.sh (vérifié le 15 novembre 2026)
  • Dépôt Docker Hub de Dokploy, 16 328 179 téléchargements : https://hub.docker.com/r/dokploy/dokploy (vérifié le 15 novembre 2026)
  • Dépôt GitHub de Dokploy, 38 523 étoiles : https://github.com/Dokploy/dokploy (vérifié le 15 novembre 2026)
  • Catalogue des vulnérabilités exploitées connues de la CISA, version 2026.11.13 : https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json (vérifié le 15 novembre 2026)