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

Analyse approfondie

Analyse approfondie

RCE dans Craft CMS via un contournement de la garde de classe des transformations d'image (CVE-2026-130675)

Un contournement de classe dans les transformations d'image de Craft CMS 5.0.0 à 5.11.3 peut mener à l'exécution de code PHP ; corrigé en 5.11.4.

En bref

  • Un contournement de la garde de classe dans les transformations d'image de Craft CMS permet à un attaquant d'instancier des classes PHP arbitraires, ce qui, selon l'éditeur, peut mener à une exécution de code à distance. VulnCheck lui a attribué un score CVSS v3.1 de 9,8 (Critique) le 2026-11-18.
  • Touche Craft CMS 5.0.0 à 5.11.3. Le correctif figure dans la version 5.11.4, publiée le 2026-10-01.
  • Aucune exploitation dans la nature n'est connue, et la CVE ne figure pas dans KEV au 2026-11-18.
  • Passez à 5.11.4 ou une version ultérieure, et vérifiez le modèle payments/pay de Craft Commerce ainsi que l'accès public aux photos de profil.

Suis-je concerné ?

Toutes ces conditions doivent être réunies :

  • Craft CMS 5.0.0 ou une version ultérieure, mais antérieure à 5.11.4, est installé.
  • Craft Commerce est installé et l'action payments/pay est joignable.
  • Un utilisateur public disposant d'une photo de profil peut atteindre le modèle sandboxé qui appelle customer.photo.getUrl().
  • Le déploiement accepte un tableau de transformation d'image contrôlé par l'attaquant via ce modèle.

L'avis de l'éditeur liste les versions 5.0.0 à 5.11.3 et indique que la faille est joignable via le modèle de redirection payments/pay de Craft Commerce. L'éditeur décrit l'impact comme celui d'un attaquant distant non authentifié exécutant du PHP « dans les bonnes circonstances ». L'avis ne publie pas d'exploit complet de bout en bout, et aucune preuve de concept publique n'est liée.

Craft CMS a enregistré 86 099 téléchargements Packagist sur le mois précédant le 2026-11-18 et 3 891 091 au total. Ce chiffre couvre le paquet craftcms/cms, pas le nombre de sites qui exécutent Craft Commerce.

Craft Commerce est un greffon commercial distinct. Vérifiez-le avec composer show craftcms/commerce. Un site sans ce greffon ne correspond pas au parcours documenté, mais la garde de classe fait toujours partie de Craft CMS : la mise à jour s'applique donc dans les deux cas.

Branche Versions concernées Version corrigée
5.x 5.0.0 à 5.11.3 5.11.4
4.x et antérieures Non listée comme concernée Sans objet

Vérifiez ce qui est installé :

# The installed Craft CMS version
composer show craftcms/cms | grep -E "^versions|^name"

# The locked version in a project
grep -n -A 2 '"name": "craftcms/cms"' composer.lock

# The Craft CLI, when the project ships it
php craft --version

Comment corriger ?

Passez à 5.11.4 ou une version ultérieure et exécutez les migrations. Le correctif se trouve dans la garde de classe : un simple changement de modèle ne suffit donc pas à l'éliminer.

  1. Mettez à jour le paquet et exécutez les migrations de base de données :
composer require craftcms/cms:^5.11.4
php craft migrate/all
  1. Reconstruisez chaque conteneur ou artefact de version qui épingle une version 5.x antérieure, puis videz les modèles compilés et les caches :
php craft clear-caches
  1. Vérifiez le modèle payments/pay et la fonctionnalité publique de photo de profil. Si vous n'avez besoin ni de l'un ni de l'autre, désactivez-les jusqu'au déploiement de la mise à jour.

  2. Si vous ne pouvez pas encore mettre à jour, supprimez les photos de profil publiques et restreignez l'accès à l'action payments/pay au niveau du serveur web. Cela réduit le parcours documenté, mais ne corrige pas la garde de classe : considérez donc cette mesure comme temporaire.

  3. Lisez les notes de version de la 5.11.4 avant de déployer. La même version contient d'autres correctifs de sécurité, et les migrations doivent d'abord être exécutées sur une copie de préproduction.

Le correctif ne change pas l'API des transformations, donc les configurations existantes continuent de fonctionner. Testez une transformation sur une copie de préproduction après la mise à jour et vérifiez que les URL générées répondent toujours.

Quelle est la cause racine ?

Le normaliseur de transformation tente d'empêcher un attaquant de choisir la classe PHP, mais sa garde utilise isset() et l'étalement de tableau qui suit permet à l'attaquant d'écraser la classe fixée. L'avis de l'éditeur qualifie le résultat de primitive d'instanciation de classe arbitraire.

Le code vulnérable se trouve dans src/helpers/ImageTransforms.php en 5.11.3 :

if (isset($transform['class'])) {
    throw new InvalidArgumentException('Invalid transform config.');
}
// ...
return Craft::createObject([
    'class' => ImageTransform::class,
    ...$transform,
]);

isset($transform['class']) renvoie false lorsque la valeur est null. L'étalement écrase alors l'entrée class avec le null de l'attaquant et ajoute une entrée __class. La seconde garde dans Craft::createObject() présente le même problème :

if (is_array($type) && isset($type['__class']) && isset($type['class'])) {
    throw new InvalidConfigException('`__class` and `class` cannot both be specified.');
}

Avec class défini sur null, le second isset() est faux, et la vérification de conflit est donc contournée. Yii donne la priorité à __class lorsque les deux clés sont présentes : la classe de l'attaquant est donc instanciée avec les propriétés de l'attaquant.

Component::cleanseConfig() ne supprime pas __class. La méthode nettoie les valeurs de configuration et laisse la clé en place : le nom de classe de l'attaquant survit donc à l'étape de normalisation. La garde censée le rejeter est justement celle que isset() met en échec.

Comment la faille est-elle exploitée ?

L'attaquant a besoin d'un parcours qui transmet un tableau de transformation contrôlé par l'attaquant à ImageTransforms::normalizeTransform(). L'éditeur documente un parcours via Craft Commerce.

  1. Un utilisateur public disposant d'une photo de profil atteint l'action payments/pay. Craft Commerce rend le paramètre redirect signé sous forme de modèle Order exécuté en bac à sable.
  2. Le modèle appelle customer.photo.getUrl() avec un tableau de transformation qui contient class => null, __class => 'yii\rbac\PhpManager' et des propriétés contrôlées par l'attaquant.
  3. normalizeTransform() exécute isset() sur class, voit null et ne lève pas d'exception.
  4. Craft::createObject() reçoit class => null et __class => 'yii\rbac\PhpManager', et sa vérification de double classe passe elle aussi.
  5. Yii instancie la classe de l'attaquant avec les propriétés de l'attaquant. L'avis cite yii\rbac\PhpManager comme exemple et indique que le résultat peut exécuter du PHP.

L'avis publie cette forme de transformation :

[
    'class' => null,
    '__class' => 'yii\rbac\PhpManager',
    // attacker-controlled properties
]

La phrase de l'éditeur sur l'impact est conditionnelle : un attaquant distant non authentifié peut exécuter du PHP « dans les bonnes circonstances ». Les circonstances documentées sont un site Craft Commerce, une action payments/pay joignable et un utilisateur public disposant d'une photo de profil.

Comment se déroule l'attaque ?

Un tableau de transformation qui ressemble à une configuration d'image normale franchit deux gardes isset() et atteint l'instanciation de classe de Yii, où le nom de classe de l'attaquant l'emporte.

flowchart LR A["Utilisateur public avec une photo de profil"] --> B["payments/pay rend la redirection signée"] B --> C["Le modèle appelle customer.photo.getUrl
avec une transformation forgée"] C --> D["normalizeTransform : isset(class) est faux"] D --> E["Craft::createObject : la vérification de double classe est contournée"] E --> F["Yii instancie __class
avec les propriétés de l'attaquant"] F --> G["Exécution de code PHP"]

Que peut faire un attaquant ?

L'attaquant peut instancier une classe PHP autochargeable arbitraire avec des propriétés contrôlées par l'attaquant. L'avis indique que cela peut mener à une exécution de code PHP, et l'éditeur classe le problème en gravité élevée.

  • L'exécution de code s'effectue sous l'utilisateur du processus PHP, qui peut lire le fichier .env de Craft et les identifiants de base de données.
  • L'attaquant peut lire et écrire les fichiers accessibles au serveur web, y compris les modèles et les ressources téléversées.
  • L'attaquant peut atteindre la base de données et le panneau d'administration de Craft avec les identifiants propres à l'application.
  • L'attaquant peut utiliser le site comme point d'appui pour accéder plus loin au compte d'hébergement.

L'avis ne démontre pas de charge utile de bout en bout précise ni de chaîne de classes particulière au-delà de la mention de yii\rbac\PhpManager. Cette classe est un gadget plausible parce qu'elle charge ses données RBAC avec require dans loadFromFile(). Si l'attaquant peut pointer itemFile vers un fichier qu'il peut écrire, le require l'exécute. Considérez l'affirmation d'exécution de code comme l'évaluation de l'éditeur et de VulnCheck, et non comme un exploit démontré contre toutes les configurations.

Les conditions sont listées en intégralité dans « Suis-je concerné ? ». Un site sans Craft Commerce, ou qui n'expose pas l'action payments/pay aux utilisateurs publics, ne correspond pas au parcours documenté.

L'écart entre l'instanciation d'une classe et l'exécution de code réside dans la chaîne de gadgets. L'avis nomme une classe, et l'éditeur indique que les bonnes circonstances sont nécessaires. Un site qui correspond au parcours documenté mais bloque les écritures dans la racine web peut encore être exposé via une autre classe : la réponse sûre est donc la mise à jour, et non un blocage propre à un gadget.

Si l'attaquant atteint l'exécution de code, son PHP s'exécute avec les mêmes permissions de base de données et de fichiers que le processus Craft, donc les secrets du site sont exposés même si l'attaquant n'atteint jamais le panneau de contrôle.

Pourquoi le correctif fonctionne-t-il ?

Le correctif remplace les deux vérifications isset() par array_key_exists() et déplace l'étalement avant l'entrée class fixée, de sorte que l'attaquant ne peut plus l'écraser.

-            if (isset($transform['class'])) {
+            if (array_key_exists('class', $transform) || array_key_exists('__class', $transform)) {
                 throw new InvalidArgumentException('Invalid transform config.');
             }
@@
             return Craft::createObject([
-                'class' => ImageTransform::class,
                 ...$transform,
+                'class' => ImageTransform::class,
             ]);
-        if (is_array($type) && isset($type['__class']) && isset($type['class'])) {
+        if (is_array($type) && array_key_exists('__class', $type) && array_key_exists('class', $type)) {
             throw new InvalidConfigException('`__class` and `class` cannot both be specified.');
         }

array_key_exists() renvoie true pour une clé dont la valeur est null : la garde rejette donc désormais la forme class => null. Déplacer l'étalement avant l'entrée fixée signifie que la class fixée l'emporte toujours, même si un futur appelant oublie la première garde. Le commit ajoute aussi des tests de non-régression pour les cas de classe nulle et de transformation imbriquée.

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

Il n'existe aucun indicateur de compromission publié. La requête est une requête payments/pay normale avec une redirection signée, et la forme de l'exploit n'est visible que dans le corps de la requête ou la sortie du modèle.

# Requests to the Commerce pay action
grep -i "payments/pay" /var/log/nginx/access.log /var/log/apache2/access.log 2>/dev/null

# Class markers appear only if the logged request retains the decoded template.
# Default access logs omit POST bodies; encoded redirects need decoding first.
grep -i "__class\|PhpManager\|class%3Anull\|class.*null" /var/log/nginx/access.log /var/log/apache2/access.log 2>/dev/null

# Unexpected PHP files in the web root
find /path/to/craft/web -name '*.php' -mtime -30 2>/dev/null

Une occurrence de payments/pay est une piste, pas une preuve, car l'action fait partie du paiement normal. Une occurrence qui contient aussi __class, PhpManager ou une valeur class à null est bien plus solide. Si vous en trouvez une, conservez les journaux, examinez les utilisateurs de Craft et les comptes de base de données, et reconstruisez l'hôte à partir d'une image de confiance.

La conservation des journaux détermine si cette vérification est possible. Si le serveur web ne conserve que quelques jours de journaux d'accès, exportez-les avant la fermeture de la fenêtre. Le corps de la requête n'est souvent pas journalisé du tout : un proxy ou un journal au niveau de l'application est donc le seul endroit où le tableau de transformation apparaît.

Chronologie

  • 2026-09-28 : le commit 0d1d8c55 corrige la garde de classe.
  • 2026-10-01 : Craft CMS 5.11.4 est publiée.
  • 2026-11-02 : l'éditeur publie l'avis GHSA-hq78-cm2m-h24h.
  • 2026-11-18 : VulnCheck publie la CVE-2026-130675 avec un score CVSS v3.1 de 9,8 et v4.0 de 9,3.
  • 2026-11-18 : la CVE ne figure pas dans KEV et aucune exploitation n'est connue.

Chronologie de la CVE-2026-130675 : le correctif est arrivé le 28 septembre, la version a suivi le 1er octobre et la CVE a été publiée le 18 novembre
Figure 1 : le correctif est livré sept semaines avant l'enregistrement de la CVE, donc les sites en 5.11.4 sont déjà protégés. Source : le commit et l'avis de Craft CMS, vérifiés le 18 novembre 2026.

FAQ

La faille est-elle exploitable sans authentification ?

L'éditeur indique qu'un attaquant distant non authentifié peut exécuter du PHP dans les bonnes circonstances. Le parcours documenté commence par un utilisateur public disposant d'une photo de profil : l'attaquant peut donc devoir s'inscrire ou contrôler un tel compte sur le site.

La faille touche-t-elle Craft 4 ?

L'avis de l'éditeur liste Craft CMS 5.0.0 à 5.11.3. Il ne liste pas la branche 4.x, et le correctif se trouve dans la branche 5.x. Considérez la 4.x comme hors du champ de cet avis, et non comme confirmée sûre.

Existe-t-il un exploit public ?

Aucun code d'exploit fonctionnel n'est publié. L'avis documente le tableau de transformation et l'accesseur Twig, et l'enregistrement de la CVE reprend cette forme.

Craft Commerce est-il nécessaire ?

Le parcours documenté utilise le modèle payments/pay de Craft Commerce. La garde de classe se trouve dans Craft CMS lui-même : un autre modèle qui transmet des transformations contrôlées par l'attaquant pourrait donc atteindre le même code. L'avis n'en nomme aucun.

A-t-elle été exploitée dans la nature ?

Aucune exploitation n'est connue. La CVE ne figure pas dans KEV au 2026-11-18, et ni l'éditeur ni VulnCheck ne signale d'attaque.

Pourquoi l'éditeur la classe-t-il en gravité élevée alors que la CVE est notée 9,8 ?

La politique de sécurité de Craft évalue l'impact selon l'accès nécessaire à l'attaquant et l'effet qu'il peut produire. L'éditeur parle d'une RCE de gravité élevée, tandis que VulnCheck, en tant qu'autorité de numérotation CVE, note le vecteur réseau à 9,8. Les deux descriptions désignent la même faille ; la différence tient à la politique de notation, pas au code concerné.

Comment savoir si Craft Commerce est installé ?

Exécutez composer show craftcms/commerce dans le projet. La commande affiche la version du greffon lorsqu'il est installé et se termine par une erreur lorsqu'il ne l'est pas. La liste des greffons du panneau d'administration le mentionne aussi.

La 5.11.4 corrige-t-elle la faille ?

Oui. La 5.11.4 contient le commit de correctif et les tests de non-régression. Toute version 5.x ultérieure embarque le même changement.

Détectez les sites Craft CMS exposés avec Ostorlab

Le Web Agentic Deep Scan d'Ostorlab recense et teste les applications web que vous exposez. Pour un site Craft CMS, il cartographie les modèles publics et les actions Commerce, ainsi que l'authentification qui les précède. Vous pouvez voir quels sites exposent le parcours documenté avant de mettre à jour.

Références

  • GitHub Advisory Database, GHSA-hq78-cm2m-h24h, « Le contournement de la garde de classe des transformations d'image avec class:null et __class peut mener à une RCE » : https://github.com/craftcms/cms/security/advisories/GHSA-hq78-cm2m-h24h (vérifié le 18 novembre 2026)
  • Enregistrement CVE, CVE-2026-130675 : https://www.cve.org/CVERecord?id=CVE-2026-130675 (vérifié le 18 novembre 2026)
  • Commit de correctif de Craft CMS 0d1d8c55, « Correction de GHSA-hq78-cm2m-h24h » : https://github.com/craftcms/cms/commit/0d1d8c55602042b2313448e560a2c0e4f582b498 (vérifié le 18 novembre 2026)
  • Version 5.11.4 de Craft CMS : https://github.com/craftcms/cms/releases/tag/5.11.4 (vérifié le 18 novembre 2026)
  • Code source de Craft CMS en 5.11.3, ImageTransforms.php : https://github.com/craftcms/cms/blob/5.11.3/src/helpers/ImageTransforms.php (vérifié le 18 novembre 2026)
  • Code source de Craft CMS en 5.11.3, Craft.php : https://github.com/craftcms/cms/blob/5.11.3/src/Craft.php (vérifié le 18 novembre 2026)
  • Code source de Craft CMS en 5.11.3, Component.php : https://github.com/craftcms/cms/blob/5.11.3/src/helpers/Component.php (vérifié le 18 novembre 2026)
  • Source de PhpManager de Yii 2, loadFromFile() : https://github.com/yiisoft/yii2/blob/master/framework/rbac/PhpManager.php (vérifié le 18 novembre 2026)
  • Packagist, statistiques de téléchargement de craftcms/cms : https://packagist.org/packages/craftcms/cms (vérifié le 18 novembre 2026)
  • Flux du catalogue Known Exploited Vulnerabilities de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 18 novembre 2026)