Mustache pour Ruby : RCE via les modèles (CVE-2026-130001)
Un attaquant contrôlant un modèle Mustache peut appeler des méthodes Ruby et exécuter du code ; corrigé dans mustache 1.1.3.
En bref
- Dans les versions vulnérables de Mustache pour Ruby, un modèle de source non fiable pouvait appeler des méthodes intégrées de Ruby et exécuter du code avec les droits du processus de rendu. Le score CVSS v3.1 de CVE-2026-130001 est de 9,8 (critique).
- Toutes les versions jusqu'à 1.1.2 sont concernées. Le correctif est dans 1.1.3, publié le 2026-08-20.
- Aucune exploitation dans la nature n'est connue, et la CVE n'est pas dans le KEV au 2026-11-19. L'avis ne publie pas les charges utiles.
- Mettez à niveau vers mustache 1.1.3 ou une version ultérieure. Le nouveau niveau par défaut bloque les méthodes de réflexion ; examinez tout endroit où les utilisateurs fournissent la chaîne de modèle.
Suis-je concerné ?
Toutes ces conditions doivent être réunies :
- L'application utilise la gem Ruby
mustacheen 1.1.2 ou antérieure. - Un attaquant peut influencer la chaîne de modèle, pas seulement les données qui lui sont passées.
L'avis indique que l'exploitation ne dépend d'aucune configuration ni des objets passés au moteur de modèles. C'est la distinction importante : un modèle Mustache est généralement traité comme du code de confiance écrit par le développeur, mais la faille est exploitable lorsque le modèle lui-même vient d'une source non fiable.
| Branche | Versions concernées | Version corrigée |
|---|---|---|
| 1.x | 1.1.2 et antérieures | 1.1.3 |
| 1.1.3 | Non concernée | Version actuelle |
La gem a enregistré 83 857 242 téléchargements au total sur RubyGems, et 508 178 téléchargements de la version 1.1.3. C'est le nombre de téléchargements du paquet, pas le nombre d'applications qui acceptent des modèles fournis par l'utilisateur.
Vérifiez ce qui est installé :
# Bundler projects
bundle list | grep -i mustache
# A global gem install
gem list mustache
# The resolved version in a lockfile
grep -n -A 2 "mustache" Gemfile.lock
Toute version jusqu'à 1.1.2 incluse est concernée. Un projet sans dépendance directe peut tout de même inclure la gem via une autre gem, donc vérifiez le lockfile plutôt que seulement le Gemfile.
Comment corriger ?
Mettez à niveau vers 1.1.3 ou une version ultérieure. Le correctif ajoute un niveau de sécurité d'accès au contexte, et le niveau par défaut bloque les méthodes de réflexion qui rendent l'évasion possible.
# Bundler
bundle update mustache
# A global gem install
gem update mustache
- Mettez à niveau la gem et validez le
Gemfile.lockmis à jour. - Reconstruisez et redéployez chaque application qui l'embarque. Un processus en cours garde l'ancienne gem jusqu'à son redémarrage.
- Recherchez les endroits où les utilisateurs fournissent la chaîne de modèle, comme les modèles stockés, les corps de notification ou les mises en page de rapport. Déplacez ces modèles vers un stockage de confiance ou rendez-les avec un format non exécutable.
- Si vous ne pouvez pas mettre à niveau immédiatement, ne rendez pas de chaînes de modèle non fiables. Passer des valeurs non fiables comme données n'équivaut pas à laisser l'attaquant écrire le modèle.
La mise à niveau conserve l'API normale. Le niveau de sécurité par défaut est 2, qui bloque une liste de méthodes de réflexion. Un modèle qui appelle légitimement ces méthodes devra être repensé ; ne baissez pas le niveau pour le faire fonctionner sans comprendre l'exposition.
Quelle est la cause racine ?
Lorsqu’une clé désignait une méthode de l’objet de vue, Mustache vérifiait que l’objet répondait à ce nom. Cette vérification écartait normalement les méthodes privées, mais certaines méthodes publiques donnaient accès à des fonctions de l’application qui devaient rester inaccessibles à l’auteur du modèle.
Que peut faire un attaquant ?
L'attaquant peut exécuter du code avec les privilèges de l'application Ruby qui rend le modèle. C'est généralement le compte du serveur d'application, avec accès à la configuration, aux identifiants de base de données et aux fichiers de l'application.
- L'attaquant peut lire les variables d'environnement et les fichiers de configuration accessibles au processus.
- L'attaquant peut lire et modifier les données accessibles à l'application.
- L'attaquant peut exécuter des commandes sur l'hôte, selon le déploiement de l'application.
- L'attaquant peut utiliser l'application comme point d'appui pour un accès ultérieur.
Les conditions sont listées en entier dans « Suis-je concerné ? ». La condition critique est le contrôle de la chaîne de modèle. Une application qui ne rend que des modèles écrits par le développeur n'expose pas ce chemin, même si elle passe des données utilisateur dans le modèle. L'avis indique qu'aucune configuration ni objet supplémentaire n'est nécessaire, donc un seul modèle non fiable suffit.
La chaîne de modèle est souvent stockée dans une base de données, un modèle de notification ou une mise en page de rapport : l'attaquant n'a donc pas forcément besoin d'une requête en direct pour l'injecter. Un modèle stocké qui est rendu plus tard atteint quand même la recherche de méthode.
L'avis décrit l'impact comme une exécution de code arbitraire et note la faille CVSS v3.1 9,8. Il ne publie ni victime ni rapport d'exploitation.
Pourquoi le correctif fonctionne-t-il ?
Le correctif ajoute context_access_security_level à Mustache, avec une valeur par défaut de 2, et le vérifie avant de résoudre une clé. Le niveau 2 bloque une liste noire de méthodes de réflexion ; les niveaux supérieurs bloquent les méthodes héritées, tout accès aux méthodes, ou tout contexte qui n'est pas un Hash exact.
Les niveaux 3, 4 et 5 sont des options plus strictes pour les applications qui rendent des modèles non fiables. Le niveau 3 bloque les méthodes héritées, le niveau 4 bloque tout accès aux méthodes, et le niveau 5 exige que le contexte soit exactement un Hash. Le niveau par défaut 2 est le choix de compatibilité : il bloque les méthodes d'évasion connues tout en gardant les objets de vue ordinaires fonctionnels.
Comment vérifier si j'ai été compromis ?
Aucun indicateur de compromission n'est publié. La requête est un appel de rendu ordinaire, et le modèle peut être stocké longtemps avant son utilisation.
# Search template files for selected bare or dotted method names
grep -RInE '\{\{[[:space:]]*([^{}[:space:]]+\.)?(send|method|class|instance_eval|instance_exec|const_get)(\.|[[:space:]]*\}\})' /path/to/templates
# Recent changes to stored templates
find /path/to/templates -type f -mtime -30 2>/dev/null
# Candidate Ruby application processes for manual inspection
ps -eo user,pid,ppid,cmd | grep -E "ruby|rails|puma|sidekiq" | grep -v grep
Une correspondance signale un modèle à examiner. Des clés de données légitimes peuvent porter les mêmes noms. Cette recherche parcourt ligne par ligne les fichiers du répertoire indiqué. Vérifiez séparément les modèles stockés en base de données, l’historique des modifications et les journaux de l’application. La liste des processus reflète un instant précis. Pour rechercher la trace d’un lancement de shell, examinez le PID du processus parent, l’exécutable et l’horodatage dans l’historique des événements de processus. Si vous trouvez un modèle suspect, conservez-le avec les journaux, renouvelez les secrets accessibles au processus Ruby et vérifiez qui peut modifier les modèles.
L'avis ne publie ni motifs de requêtes ni noms de fichiers, donc la recherche doit partir du propre stockage de modèles de l'application.
Chronologie
- 2026-08-20 — Le responsable du projet publie l’avis de sécurité et la version 1.1.3 de mustache paraît sur RubyGems.
- 2026-11-18 — GitHub ajoute l’avis à sa base de données d’avis vérifiés.
- 2026-11-19 : aucune exploitation n'est connue et la CVE n'est pas dans le KEV.
FAQ
La faille est-elle non authentifiée ?
Cela dépend de l'application. La faille exige le contrôle de la chaîne de modèle, pas un compte Mustache. Si l'application laisse un utilisateur non authentifié stocker ou modifier un modèle, le chemin est non authentifié ; si seul un administrateur authentifié peut modifier les modèles, l'attaquant a besoin de ce rôle.
Quelles versions sont concernées ?
Toutes les versions de mustache jusqu'à 1.1.2. Le correctif est dans 1.1.3, publié le 2026-08-20. Un projet qui verrouille une version antérieure reste concerné jusqu'à la mise à niveau.
Existe-t-il un exploit public ?
Le responsable du projet a différé la publication des charges de démonstration.
La faille a-t-elle été exploitée dans la nature ?
Aucune exploitation n'est connue, et CVE-2026-130001 n'est pas dans le KEV au 2026-11-19. L'avis ne signale aucune attaque.
Le correctif casse-t-il les modèles ?
Le niveau par défaut 2 bloque les méthodes de réflexion comme send, method et class. Les champs de données ordinaires et les méthodes de vue continuent de fonctionner. Un modèle qui appelle délibérément une méthode bloquée doit être repensé ; ne baissez pas le niveau pour un modèle non fiable.
Mustache reste-t-il sûr pour les modèles fournis par l'utilisateur ?
Seulement avec les niveaux plus stricts et une conception qui traite le modèle comme des données. La recommandation de l'avis est de mettre à niveau, et les niveaux 4 et 5 suppriment la résolution de méthodes. Si l'application n'a pas besoin de modèles écrits par l'utilisateur, gardez-les sous le contrôle du développeur.
Trouvez les dépendances Mustache vulnérables avec Ostorlab
Le SCA et SBOM d'Ostorlab inventorie les paquets open source de vos applications et images de conteneurs. Pour un service Ruby, il montre quels lockfiles résolvent encore mustache en 1.1.2 ou antérieure, afin que vous mettiez à niveau en premier les applications qui rendent des modèles fournis par l'utilisateur.
Références
- GHSA-5hrj-7fc3-cmx9 (Mustache)
- Avis GitHub, GHSA-5hrj-7fc3-cmx9, « Mustache for Ruby: RCE using built-in method access » : https://github.com/advisories/GHSA-5hrj-7fc3-cmx9 (vérifié le 19 novembre 2026)
- Enregistrement CVE, CVE-2026-130001 : https://www.cve.org/CVERecord?id=CVE-2026-130001 (vérifié le 19 novembre 2026)
- Mustache 1.1.3 sur RubyGems : https://rubygems.org/gems/mustache/versions/1.1.3 (vérifié le 19 novembre 2026)
- Source Mustache en 1.1.2,
context.rb: https://github.com/mustache/mustache/blob/v1.1.2/lib/mustache/context.rb (vérifié le 19 novembre 2026) - Commit de correctif Mustache
6f0b0a27ajoutant le niveau de sécurité d'accès au contexte : https://github.com/mustache/mustache/commit/6f0b0a27a864 (vérifié le 19 novembre 2026) - Statistiques de téléchargement RubyGems pour mustache : https://rubygems.org/gems/mustache (vérifié le 19 novembre 2026)