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

Analyse approfondie

Analyse approfondie

Spring Security : injection SpEL et RCE, corrigée en 7.1.3 (CVE-2026-59273)

Spring Security : ELRequestMatcher évalue du SpEL avec accès aux types, permettant une RCE via une propriété RequestMatcher liée ; corrigé en 7.1.3 et 7.0.9.

En bref

  • ELRequestMatcher de Spring Security évalue du SpEL dans un contexte qui autorise les références de type et les méthodes statiques. Une entrée extérieure liée à une propriété RequestMatcher devient cette expression.
  • Spring Security 7.1.0 à 7.1.2 et 7.0.0 à 7.0.8 sont concernés, ainsi que les branches 6.5, 6.4, 5.8 et 5.7. La bibliothèque seule n'est pas joignable ; l'application doit lier une entrée extérieure à un RequestMatcher.
  • Spring la classe Critique, CVSS v3.1 9,8. Deux dépôts publics (2026-11-20 et 2026-11-21) montrent l'accès aux types, pas l'exécution de commandes. Aucune exploitation connue et la CVE n'est pas dans KEV au 2026-11-22.
  • Mettez à niveau vers Spring Security 7.1.3, 7.0.9 ou 7.2.0, ou Spring Boot 4.1.3, 4.0.10 ou 4.2.0. Les correctifs 6.5, 6.4, 5.8 et 5.7 sont réservés à Enterprise. Sinon, supprimez les liaisons de données de requête vers RequestMatcher.

Suis-je concerné ?

Toutes ces conditions doivent être réunies pour qu'une application soit exposée :

  • Elle utilise une version concernée de Spring Security : 7.1.0 à 7.1.2, 7.0.0 à 7.0.8, 6.5.0 à 6.5.12, 6.4.0 à 6.4.19, 5.8.0 à 5.8.28, ou 5.7.26 et antérieure.
  • Un contrôleur, un objet de formulaire ou un autre bean lie une valeur de requête à une propriété de type RequestMatcher, si bien que le lieur de données de Spring crée un ELRequestMatcher à partir d'un texte contrôlé par l'attaquant.
  • Le matcher est évalué sur une requête que l'attaquant peut atteindre.
  • La chaîne liée n'est pas limitée aux opérations documentées hasIpAddress et hasHeader.

La classe est aussi utilisée directement dans la configuration, par exemple dans une table de DelegatingAuthenticationEntryPoint. Un matcher construit à partir d'une chaîne fixe dans le code n'est pas contrôlé par l'attaquant. L'exposition vient de la liaison de données, pas de la classe elle-même.

Branche Versions concernées Version corrigée
7.2.x Aucune 7.2.0 (OSS)
7.1.x 7.1.0 à 7.1.2 7.1.3 (OSS)
7.0.x 7.0.0 à 7.0.8 7.0.9 (OSS)
6.5.x 6.5.0 à 6.5.12 6.5.13 (support Enterprise uniquement)
6.4.x 6.4.0 à 6.4.19 6.4.20 (support Enterprise uniquement)
5.8.x 5.8.0 à 5.8.28 5.8.29 (support Enterprise uniquement)
5.7.x et antérieures 5.7.26 et antérieures 5.7.27 (support Enterprise uniquement)

Spring classe la faille Critique avec un score CVSS v3.1 de 9,8 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Spring a publié 7.1.3, 7.0.9 et 7.2.0 sur Maven Central le 2026-11-19. Les artefacts 6.5.13, 6.4.20, 5.8.29 et 5.7.27 n'étaient pas sur Maven Central lors de la vérification du 2026-11-22, et Spring les réserve au support Enterprise.

Vérifiez la version résolue dans l'application :

mvn dependency:tree -Dincludes=org.springframework.security:spring-security-web,org.springframework.security:spring-security-core
./gradlew dependencyInsight --dependency spring-security-web --configuration runtimeClasspath

Pour une application empaquetée, inspectez le jar :

unzip -l app.jar | grep 'spring-security-web'

Pour une application Spring Boot, affichez la version gérée de Spring Security :

./mvnw help:evaluate -Dexpression=spring-security.version -q -DforceStdout

Cherchez ensuite le point de liaison dans le code source :

grep -rn "RequestMatcher" src/main/java
grep -rn "ELRequestMatcher" src/main/java

La vérification des dépendances affiche la version. La recherche dans le code trouve un champ RequestMatcher. Inspectez le contrôleur ou l'objet de formulaire qui lie ce champ, et confirmez si les données de requête peuvent le définir. Un matcher configuré avec une chaîne fixe dans une méthode @Bean n'est pas le chemin vulnérable.

Comment corriger ?

Mettez à niveau vers une version corrigée de Spring Security. Spring Boot 4.1.3, 4.0.10 et 4.2.0 gèrent Spring Security 7.1.3, 7.0.9 et 7.2.0, donc la mise à niveau du parent ou du plugin Boot est le chemin le plus court pour une application Boot.

  1. Changez le parent Spring Boot dans Maven :
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>4.1.3</version>
</parent>
  1. Ou changez le plugin Spring Boot dans Gradle :
plugins {
  id 'org.springframework.boot' version '4.1.3'
}
  1. Pour une application qui déclare Spring Security directement, augmentez la dépendance :
<dependency>
  <groupId>org.springframework.security</groupId>
  <artifactId>spring-security-web</artifactId>
  <version>7.1.3</version>
</dependency>
implementation 'org.springframework.security:spring-security-web:7.1.3'
  1. Reconstruisez, redéployez et redémarrez l'application. Un processus en cours garde les anciennes classes jusqu'au redémarrage.

Les applications des branches 6.5, 6.4, 5.8 ou 5.7 ont besoin du correctif commercial de leur branche. Le dépôt public Maven Central ne contient pas 6.5.13, 6.4.20, 5.8.29 ni 5.7.27. Spring Boot 3.5.16, la dernière version 3.5, gère Spring Security 6.5.11, donc une application Boot 3.5 n'a pas d'artefact corrigé public sans passage à 4.x ou un contrat de support.

Si la mise à niveau ne peut pas avoir lieu maintenant, supprimez le point de liaison :

  1. Trouvez chaque propriété de type RequestMatcher que Spring lie à partir des données de requête.
  2. Retirez cette propriété de l'objet lié, ou rendez-la en lecture seule et définissez-la dans le code.
  3. Si la valeur doit être configurable, acceptez un nom fixe et construisez le matcher à partir d'une constante.
  4. N'essayez pas de filtrer les chaînes SpEL comme correctif durable. Le parseur accepte de nombreuses formes équivalentes, et le correctif pris en charge est le contexte d'évaluation restreint.

L'avis ne liste aucun réglage de configuration qui garde le matcher utilisable et sûr. La restriction de liaison est un contournement au niveau de l'application, pas un réglage pris en charge par le fournisseur.

Quelle est la cause racine ?

ELRequestMatcher stockait une expression SpEL et l'évaluait dans un StandardEvaluationContext, un contexte qui accorde les références de type, les constructeurs, les appels de méthodes statiques, les références de beans et l'accès arbitraire aux propriétés. Le matcher n'a besoin que de hasIpAddress() et hasHeader() sur son objet racine, mais le contexte ne limitait pas l'évaluation à ces deux méthodes.

Le code vulnérable se trouve dans web/src/main/java/org/springframework/security/web/util/matcher/ELRequestMatcher.java au tag 7.1.2. Le constructeur, aux lignes 47 à 50, analyse la chaîne :

public ELRequestMatcher(String el) {
    SpelExpressionParser parser = new SpelExpressionParser();
    this.expression = parser.parseExpression(el);
}

matches() aux lignes 53 à 60 crée le contexte, et createELContext() aux lignes 66 à 68 le renvoie :

@Override
public boolean matches(HttpServletRequest request) {
    EvaluationContext context = createELContext(request);
    Boolean result = this.expression.getValue(context, Boolean.class);
    Assert.notNull(result,
            "The expression " + this.expression.getExpressionString() + " returned null. Expected true|false");
    return result;
}

public EvaluationContext createELContext(HttpServletRequest request) {
    return new StandardEvaluationContext(new ELRequestMatcherContext(request));
}

L'objet racine expose les deux méthodes documentées :

class ELRequestMatcherContext {

    private final HttpServletRequest request;

    ELRequestMatcherContext(HttpServletRequest request) {
        this.request = request;
    }

    public boolean hasIpAddress(String ipAddress) {
        return (new IpAddressMatcher(ipAddress).matches(this.request));
    }

    public boolean hasHeader(String headerName, String value) {
        String header = this.request.getHeader(headerName);
        return StringUtils.hasText(header) && header.contains(value);
    }
}

Un StandardEvaluationContext ne limite pas l'expression à l'objet racine. Une expression comme T(java.lang.Math).abs(-1) == 1 résout directement le type java.lang.Math, même si ELRequestMatcherContext n'a pas de méthode abs.

La seconde moitié est la liaison de données. Spring Security fournit un éditeur de propriété pour ce type :

public class RequestMatcherEditor extends PropertyEditorSupport {

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        setValue(new ELRequestMatcher(text));
    }
}

Le lieur de données de Spring découvre les éditeurs par convention de nom, donc une propriété RequestMatcher accepte une chaîne et la convertit en ELRequestMatcher. Le harnais public a constaté que la liaison réussit aussi par le constructeur ELRequestMatcher(String) sur un classpath standard, sans que l'éditeur soit enregistré. Les deux chemins transforment un texte contrôlé par l'attaquant en expression.

Comment la faille est-elle exploitée ?

Un attaquant envoie une expression SpEL comme valeur liée à une propriété RequestMatcher. Quand le matcher s'exécute, l'expression est évaluée avec les privilèges de l'application.

  1. L'application expose un paramètre de requête, un champ de formulaire ou une propriété JSON qui correspond à une propriété RequestMatcher.
  2. L'attaquant fournit une expression SpEL dans ce champ.
  3. Spring convertit la chaîne en ELRequestMatcher et la stocke sur l'objet.
  4. Une requête ultérieure atteint le matcher, et matches() évalue l'expression.
  5. Une référence de type T(...) résout une classe, et une méthode statique ou un constructeur s'exécute.
  6. L'expression exécute du code dans le processus de l'application.

Le harnais public montre la première moitié de cette chaîne sans exécuter de commande :

ELRequestMatcher requestMatcher = new ELRequestMatcher("T(java.lang.Math).abs(-1) == 1");
requestMatcher.matches(new MockHttpServletRequest());

Sur 7.1.2, l'expression correspond. Sur 7.1.3, la même expression lève SpelEvaluationException. Le harnais utilise Math.abs, et son README indique qu'il ne contient aucune charge de processus. L'avis décrit l'impact comme une exécution de code à distance. Le matériel public démontre l'accès aux types, pas une chaîne de commandes armée.

Comment se déroule l'attaque ?

Un texte contrôlé par l'attaquant devient un ELRequestMatcher par la liaison de données. Le matcher l'évalue dans un contexte qui autorise l'accès aux types, donc une référence de type SpEL peut exécuter du code avec les droits de l'application.

flowchart LR A["Une entrée de requête atteint
une propriété RequestMatcher"] --> B["Le lieur Spring convertit
la chaîne en ELRequestMatcher"] B --> C["Le constructeur analyse
l'expression SpEL"] C --> D["matches construit un contexte
sans limite de référence de type"] D --> E["T(...) résout une classe
et une méthode statique s'exécute"] E --> F["Le code s'exécute dans
le processus de l'application"]

Que peut faire un attaquant ?

Un attaquant qui contrôle la valeur liée peut exécuter du code dans le processus de l'application. L'avis qualifie cet impact d'exécution de code à distance. Le harnais public prouve l'étape de référence de type et s'arrête avant une commande.

  • Exécuter des commandes avec l'utilisateur de l'application. Les permissions de fichiers, les variables d'environnement et l'accès réseau de l'application deviennent le point de départ de l'attaquant.
  • Lire les secrets de l'application. Les propriétés de configuration, les identifiants de base de données et les identifiants cloud sont accessibles quand le processus peut les lire.
  • Modifier les données de l'application. L'expression s'exécute dans le fil de la requête et peut utiliser le classpath et l'état du processus.
  • Atteindre d'autres systèmes. La position réseau de l'application et ses relations de confiance déterminent jusqu'où l'attaquant peut aller.

Toutes les conditions sont listées ici. L'application doit utiliser une version concernée. Elle doit lier une entrée extérieure à une propriété RequestMatcher. L'attaquant doit contrôler la chaîne liée. Le matcher doit être évalué sur une requête que l'attaquant peut atteindre. Aucune authentification n'est nécessaire quand le point de liaison est public. Une application qui construit uniquement ses matchers à partir de chaînes fixes dans le code n'est pas exposée, même avec une version concernée.

Pourquoi le correctif fonctionne-t-il ?

Le correctif remplace StandardEvaluationContext par SimpleEvaluationContext, un contexte qui désactive les références de type, les constructeurs, les références de beans et l'invocation arbitraire de méthodes. L'option withInstanceMethods() conserve les deux méthodes d'instance documentées par le matcher.

-import org.springframework.expression.spel.support.StandardEvaluationContext;
+import org.springframework.expression.spel.support.SimpleEvaluationContext;
@@
-   public EvaluationContext createELContext(HttpServletRequest request) {
-       return new StandardEvaluationContext(new ELRequestMatcherContext(request));
-   }
+   public EvaluationContext createELContext(HttpServletRequest request) {
+       return SimpleEvaluationContext.forReadOnlyDataBinding()
+           .withInstanceMethods()
+           .withRootObject(new ELRequestMatcherContext(request))
+           .build();
+   }

SimpleEvaluationContext.forReadOnlyDataBinding() autorise la lecture des propriétés mais pas l'écriture. withInstanceMethods() autorise les appels sur l'objet racine, ce dont hasIpAddress('10.0.0.0/8') et hasHeader('User-Agent', 'curl') ont besoin. Le contexte ne résout plus T(java.lang.System) et n'appelle plus getClass() sur le résultat de hasIpAddress(). Le commit du correctif ajoute des tests de régression pour les deux cas.

Le correctif est complet pour le chemin ELRequestMatcher. Une sous-classe qui redéfinit createELContext et renvoie son propre StandardEvaluationContext garderait l'ancien comportement, donc vérifiez ces redéfinitions pendant la mise à niveau.

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

Aucun indicateur de compromission n'est publié pour cette CVE. L'expression s'exécute en mémoire et peut ne laisser aucune trace applicative, donc l'absence d'alerte ne prouve pas qu'aucune tentative n'a eu lieu.

Commencez par les journaux de requêtes. Les expressions des matchers en production appellent hasIpAddress ou hasHeader. Un paramètre de requête qui contient T( ou sa forme encodée %54%28 mérite une enquête :

grep -Ei 'T\(|%54%28' /var/log/nginx/access.log /var/log/apache2/access.log 2>/dev/null

Cherchez SpelEvaluationException dans le journal de l'application autour des requêtes inhabituelles. Une expression qui échoue peut lever une exception avant de s'exécuter :

grep -i "SpelEvaluationException" /var/log/spring-app.log

Cherchez les processus enfants lancés par le processus Java et les connexions sortantes qui ne correspondent pas à l'egress normal de l'application :

ps -eo pid,ppid,user,args | grep -E '[j]ava|[b]ash|[c]url|[w]get'

Un T( trouvé dans un journal de requêtes est une piste, pas une preuve d'exploitation. Une expression échouée peut ne laisser aucune trace. Si l'application redéfinit createELContext, examinez ce code séparément.

Chronologie

  • 2026-09-30 : le commit de correctif 5d28474a5cef a été écrit dans le dépôt Spring Security.
  • 2026-10-22 : Spring Security 7.1.2 et 7.0.8 sont sortis, les derniers artefacts open source vulnérables.
  • 2026-11-19 : Spring a publié l'avis et les versions 7.1.3, 7.0.9 et 7.2.0 sur Maven Central.
  • 2026-11-20 : le premier dépôt public de preuve de concept est apparu.
  • 2026-11-21 : le second dépôt public de preuve de concept est apparu à 21:26 UTC.

Du commit de correctif à la preuve de concept publique en 52 jours
Figure 1 : le correctif a été écrit le 2026-09-30, l'avis et les artefacts corrigés sont arrivés le 2026-11-19, et les dépôts publics de preuve de concept ont suivi les 2026-11-20 et 2026-11-21. Source : avis et commits Spring Security, dépôts GitHub, vérifiés le 22 novembre 2026

FAQ

Toutes les applications Spring Security doivent-elles être corrigées ?

Non. La bibliothèque seule n'est pas joignable à distance. Une application est exposée seulement quand elle lie une entrée extérieure à une propriété RequestMatcher et évalue ce matcher. Les applications qui construisent leurs matchers à partir de chaînes fixes dans le code doivent tout de même se mettre à niveau, mais elles n'ont pas la même exposition.

Existe-t-il un exploit public ?

Il existe deux dépôts publics de preuve de concept. Le plus substantiel est un harnais différentiel qui montre que T(java.lang.Math) se résout sur 7.1.2 et lève une exception sur 7.1.3. Il ne contient aucune charge de processus et ne démontre pas l'exécution de commandes.

La CVE-2026-59273 est-elle exploitée en conditions réelles ?

Aucune exploitation en conditions réelles n'est connue au 2026-11-22, et la CVE n'est pas dans le catalogue KEV de la CISA. Le matériel public est un harnais de laboratoire, pas un rapport d'attaque.

Quelle version de Spring Boot corrige la faille ?

Spring Boot 4.1.3 gère Spring Security 7.1.3, Spring Boot 4.0.10 gère 7.0.9, et Spring Boot 4.2.0 gère 7.2.0. Spring Boot 3.5.16 gère encore 6.5.11, et le correctif 6.5.13 est réservé au support Enterprise.

Puis-je continuer à utiliser ELRequestMatcher ?

Oui, sur une version corrigée, quand l'expression vient d'un code de confiance. Le correctif conserve hasIpAddress et hasHeader. N'acceptez pas l'expression depuis les données de requête.

DelegatingAuthenticationEntryPoint me rend-il vulnérable ?

Pas à lui seul. Sa table de matchers est généralement construite en configuration à partir de chaînes fixes. Le chemin vulnérable est une propriété RequestMatcher que le lieur de données de Spring remplit à partir d'une entrée de requête.

Références

  • Avis de sécurité Spring Security pour la CVE-2026-59273, publié le 2026-11-19 (vérifié le 22 novembre 2026) : https://spring.io/security/cve-2026-59273
  • Commit de correctif 5d28474a5cef, « Fix ELRequestMatcher to use restricted SpEL evaluation context », écrit le 2026-09-30 (vérifié le 22 novembre 2026) : https://github.com/spring-projects/spring-security/commit/5d28474a5cefab43d41b0da8c487ce40df957855
  • ELRequestMatcher vulnérable au tag 7.1.2 (vérifié le 22 novembre 2026) : https://github.com/spring-projects/spring-security/blob/7.1.2/web/src/main/java/org/springframework/security/web/util/matcher/ELRequestMatcher.java
  • ELRequestMatcher corrigé au tag 7.1.3 (vérifié le 22 novembre 2026) : https://github.com/spring-projects/spring-security/blob/7.1.3/web/src/main/java/org/springframework/security/web/util/matcher/ELRequestMatcher.java
  • RequestMatcherEditor au tag 7.1.2 (vérifié le 22 novembre 2026) : https://github.com/spring-projects/spring-security/blob/7.1.2/web/src/main/java/org/springframework/security/web/util/matcher/RequestMatcherEditor.java
  • Version Spring Security 7.1.3, publiée le 2026-11-20 (vérifiée le 22 novembre 2026) : https://github.com/spring-projects/spring-security/releases/tag/7.1.3
  • Version Spring Security 7.0.9, publiée le 2026-11-20 (vérifiée le 22 novembre 2026) : https://github.com/spring-projects/spring-security/releases/tag/7.0.9
  • Version Spring Security 7.2.0, publiée le 2026-11-20 (vérifiée le 22 novembre 2026) : https://github.com/spring-projects/spring-security/releases/tag/7.2.0
  • Version Spring Boot 4.1.3, publiée le 2026-11-19 (vérifiée le 22 novembre 2026) : https://github.com/spring-projects/spring-boot/releases/tag/v4.1.3
  • Version Spring Boot 4.0.10, publiée le 2026-11-19 (vérifiée le 22 novembre 2026) : https://github.com/spring-projects/spring-boot/releases/tag/v4.0.10
  • Version Spring Boot 4.2.0, publiée le 2026-11-19 (vérifiée le 22 novembre 2026) : https://github.com/spring-projects/spring-boot/releases/tag/v4.2.0
  • Version Spring Boot 3.5.16, publiée le 2026-06-25 (vérifiée le 22 novembre 2026) : https://github.com/spring-projects/spring-boot/releases/tag/v3.5.16
  • Gestion des dépendances de Spring Boot 3.5.16, qui fixe Spring Security 6.5.11 (vérifiée le 22 novembre 2026) : https://repo1.maven.org/maven2/org/springframework/boot/spring-boot-dependencies/3.5.16/spring-boot-dependencies-3.5.16.pom
  • Artefact Spring Security 7.1.3 sur Maven Central (vérifié le 22 novembre 2026) : https://repo1.maven.org/maven2/org/springframework/security/spring-security-core/7.1.3/
  • Harnais public d'Abraxas Labs, créé le 2026-11-21 (vérifié le 22 novembre 2026) : https://github.com/abraxas/cve-2026-59273-spring-security-elmatcher
  • Dépôt public de preuve de concept d'afernandesvigo, créé le 2026-11-20 (vérifié le 22 novembre 2026) : https://github.com/afernandesvigo/PoC-CVE-2026-59273
  • CWE-94, Improper Control of Generation of Code (vérifié le 22 novembre 2026) : https://cwe.mitre.org/data/definitions/94.html
  • CWE-95, Improper Neutralization of Directives in Dynamically Evaluated Code (vérifié le 22 novembre 2026) : https://cwe.mitre.org/data/definitions/95.html
  • CWE-470, Use of Externally-Controlled Input to Select Classes or Code (vérifié le 22 novembre 2026) : https://cwe.mitre.org/data/definitions/470.html
  • Catalogue Known Exploited Vulnerabilities de la CISA, consulté pour la CVE-2026-59273 le 2026-11-22 : https://www.cisa.gov/known-exploited-vulnerabilities-catalog