Spring Security Vulnerabilities in 2026: CVE-2026-22732 (CVSS 9.1), 30 CVEs in 60 Days & Developer Hardening GuideVulnérabilités Spring Security en 2026 : CVE-2026-22732 (CVSS 9.1), 30 CVE en 60 Jours & Guide de Durcissement

In March and April 2026, the Spring ecosystem published 30 CVEs — nearly double the 17 disclosed across all of 2025. On a single day in April, 8 Spring Boot CVEs dropped simultaneously. Two days earlier, 7 Spring Security vulnerabilities were disclosed at once, including CVE-2026-22752 (CVSS 9.6), which allows an authenticated attacker to register a malicious OAuth2 client and trigger stored XSS, SSRF, and privilege escalation. For the 14.7% of web framework developers using Spring Boot (Stack Overflow 2025), this acceleration in CVE volume represents a new reality: patching Spring is no longer a quarterly task.

En mars et avril 2026, l'écosystème Spring a publié 30 CVE — soit quasiment le double des 17 divulguées sur toute l'année 2025. En une seule journée d'avril, 8 CVE Spring Boot sont tombées simultanément. Deux jours plus tôt, 7 vulnérabilités Spring Security étaient divulguées d'un coup, dont CVE-2026-22752 (CVSS 9.6), permettant à un attaquant authentifié d'enregistrer un client OAuth2 malveillant et de déclencher du XSS stocké, du SSRF et une escalade de privilèges. Pour les 14,7 % de développeurs web utilisant Spring Boot (Stack Overflow 2025), cette accélération du volume de CVE représente une nouvelle réalité : patcher Spring n'est plus une tâche trimestrielle.

The 2026 Spring CVE Surge: What Happened

L'Explosion des CVE Spring en 2026 : Ce Qui S'est Passé

Spring Security published 17 CVEs across all of 2025. Then, in just 60 days spanning March and April 2026, it published 30 — a figure that HeroDevs attributes to a surge in AI-assisted vulnerability research lowering the activation energy for finding flaws in mature Java frameworks. April 21 alone saw Spring Security 6.5.10, 7.0.5, and 7.1.0-RC1 released to address a cluster of coordinated disclosures. The April 23 release followed with CVE-2026-22752 and CVE-2026-40973. This isn't a slow-burn security debt story — it's a rapidly evolving threat landscape that demands active monitoring of your Spring dependency tree.

Spring Security a publié 17 CVE sur toute l'année 2025. Puis, en seulement 60 jours couvrant mars et avril 2026, il en a publié 30 — un chiffre qu'HeroDevs attribue à l'essor de la recherche de vulnérabilités assistée par IA, qui réduit le seuil de découverte de failles dans les frameworks Java matures. Le seul 21 avril a vu les releases Spring Security 6.5.10, 7.0.5 et 7.1.0-RC1 corriger un groupe de divulgations coordonnées. La release du 23 avril a suivi avec CVE-2026-22752 et CVE-2026-40973. Il ne s'agit pas d'une histoire de dette sécurité lente — c'est un paysage de menaces en évolution rapide qui exige une surveillance active de votre arbre de dépendances Spring.

CVE-2026-22732 (CVSS 9.1): The Security Headers That Vanish

CVE-2026-22732 (CVSS 9.1) : Les En-têtes de Sécurité Qui Disparaissent

CVE-2026-22732 is deceptive because it fails silently. When your Spring Security application is configured to write HTTP response security headers — X-Content-Type-Options, X-Frame-Options, Strict-Transport-Security, Content-Security-Policy — there exists a code path where those headers are simply not written. No exception. No log entry. Your security configuration looks correct; your HTTP responses are not.

CVE-2026-22732 est trompeuse parce qu'elle échoue silencieusement. Quand votre application Spring Security est configurée pour écrire des en-têtes de réponse HTTP de sécurité — X-Content-Type-Options, X-Frame-Options, Strict-Transport-Security, Content-Security-Policy — il existe un chemin de code où ces en-têtes ne sont tout simplement pas écrits. Pas d'exception. Pas de log. Votre configuration de sécurité semble correcte ; vos réponses HTTP ne le sont pas.

What makes this particularly serious is the breadth of affected versions. According to the NVD and spring.io advisory, six major Spring Security version branches are impacted: 5.7.0–5.7.21, 5.8.0–5.8.23, 6.3.0–6.3.14, 6.4.0–6.4.14, 6.5.0–6.5.8, and 7.0.0–7.0.3. This isn't a niche edge case — it covers every Spring Security release from the past three years. The consequence: if an attacker can trigger the header-stripping code path, secondary attacks like clickjacking (X-Frame-Options missing), MIME sniffing exploits (X-Content-Type-Options missing), or downgrade attacks (no HSTS) become viable.

Ce qui rend cette vulnérabilité particulièrement sérieuse, c'est l'ampleur des versions affectées. Selon le NVD et l'advisory spring.io, six branches majeures de Spring Security sont impactées : 5.7.0–5.7.21, 5.8.0–5.8.23, 6.3.0–6.3.14, 6.4.0–6.4.14, 6.5.0–6.5.8, et 7.0.0–7.0.3. Ce n'est pas un cas limite de niche — cela couvre chaque release Spring Security des trois dernières années. La conséquence : si un attaquant peut déclencher le chemin de code qui supprime les en-têtes, des attaques secondaires comme le clickjacking (sans X-Frame-Options), les exploits de MIME sniffing (sans X-Content-Type-Options), ou les attaques de dégradation (sans HSTS) deviennent envisageables.

Fix: Upgrade to Spring Security 5.7.22+, 5.8.24+, 6.3.15+, 6.4.15+, 6.5.9+, or 7.0.4+. The April 21, 2026 release (7.0.5) already includes this patch.

Correctif : Mettez à jour vers Spring Security 5.7.22+, 5.8.24+, 6.3.15+, 6.4.15+, 6.5.9+ ou 7.0.4+. La release du 21 avril 2026 (7.0.5) inclut déjà ce correctif.

CVE-2026-22752 (CVSS 9.6): OAuth2 Dynamic Client Registration as an Attack Surface

CVE-2026-22752 (CVSS 9.6) : L'Enregistrement Dynamique de Client OAuth2 comme Surface d'Attaque

CVE-2026-22752 sits in the Spring Security Authorization Server's Dynamic Client Registration (DCR) feature — an OAuth2 capability that allows clients to register themselves at runtime. When DCR is enabled, insufficient validation of client metadata fields lets an attacker who holds a valid Initial Access Token craft a registration request with weaponized metadata. Depending on how the authorization server renders that metadata, the result can be stored XSS (injected into admin UIs or token responses), SSRF (targeting internal services via redirect URIs), or privilege escalation (registering a client with elevated scopes).

CVE-2026-22752 se trouve dans la fonctionnalité d'Enregistrement Dynamique de Client (DCR) du Spring Security Authorization Server — une capacité OAuth2 qui permet aux clients de s'enregistrer à l'exécution. Quand le DCR est activé, une validation insuffisante des champs de métadonnées client permet à un attaquant détenant un Initial Access Token valide de créer une requête d'enregistrement avec des métadonnées armées. Selon la manière dont le serveur d'autorisation restitue ces métadonnées, le résultat peut être du XSS stocké (injecté dans des UIs admin ou des réponses de tokens), du SSRF (ciblant des services internes via des redirect URIs), ou une escalade de privilèges (enregistrer un client avec des scopes élevés).

The good news: DCR must be explicitly enabled — it is not on by default. If you haven't configured it in your Spring Authorization Server, this specific vector is not active. But check your configuration: @EnableAuthorizationServer setups migrated from older Spring OAuth2 libraries sometimes enable DCR inadvertently during refactoring.

La bonne nouvelle : le DCR doit être explicitement activé — il n'est pas actif par défaut. Si vous ne l'avez pas configuré dans votre Spring Authorization Server, ce vecteur spécifique n'est pas actif. Mais vérifiez votre configuration : les setups @EnableAuthorizationServer migrés depuis d'anciennes bibliothèques Spring OAuth2 activent parfois le DCR involontairement lors de refactorisations.

// Check if DCR is enabled in your Authorization Server config
@Bean
public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http)
    throws Exception {
  OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http);
  http.getConfigurer(OAuth2AuthorizationServerConfigurer.class)
      // ⚠ If you see .clientRegistrationEndpoint(...), DCR is enabled
      .clientRegistrationEndpoint(Customizer.withDefaults())  // ← THIS enables DCR
      ;
  return http.build();
}

Fix: Upgrade to Spring Authorization Server 1.5.7 or 7.0.5. If you cannot upgrade immediately, disable DCR or implement strict server-side validation on all client metadata fields (especially client_name, redirect_uris, and logo_uri).

Correctif : Mettez à jour vers Spring Authorization Server 1.5.7 ou 7.0.5. Si une mise à jour immédiate est impossible, désactivez le DCR ou implémentez une validation stricte côté serveur sur tous les champs de métadonnées client (notamment client_name, redirect_uris et logo_uri).

CVE-2026-22753 & CVE-2026-22754 (CVSS 8.1): Authorization Rules That Don't Apply

CVE-2026-22753 & CVE-2026-22754 (CVSS 8.1) : Les Règles d'Autorisation Qui Ne S'appliquent Pas

These two vulnerabilities share the same root cause: incorrect servlet path handling in authorization rule matching. CVE-2026-22753 affects applications that use HttpSecurity#securityMatchers(String) together with a PathPatternRequestMatcher.Builder bean to prepend a servlet path. When this configuration is present, requests that should match the filter chain's security rules may bypass them entirely — meaning authentication, authorization, CSRF protection, and other security controls are silently inactive on those endpoints.

Ces deux vulnérabilités partagent la même cause racine : une gestion incorrecte du chemin servlet dans la correspondance des règles d'autorisation. CVE-2026-22753 affecte les applications qui utilisent HttpSecurity#securityMatchers(String) conjointement avec un bean PathPatternRequestMatcher.Builder pour préfixer un chemin servlet. Quand cette configuration est présente, les requêtes qui devraient correspondre aux règles de sécurité de la chaîne de filtres peuvent les contourner entièrement — ce qui signifie que l'authentification, l'autorisation, la protection CSRF et d'autres contrôles de sécurité sont silencieusement inactifs sur ces endpoints.

CVE-2026-22754 is the XML configuration sibling of the same bug: XML-based authorization rules using <intercept-url> patterns also fail to include the servlet path in path matching. Teams using legacy XML-based Spring Security configurations — common in enterprise Java projects migrated from Spring 4.x — are specifically at risk.

CVE-2026-22754 est l'équivalent en configuration XML du même bug : les règles d'autorisation basées sur XML utilisant des patterns <intercept-url> échouent également à inclure le chemin servlet dans la correspondance. Les équipes utilisant des configurations Spring Security XML héritées — fréquentes dans les projets Java d'entreprise migrés depuis Spring 4.x — sont spécifiquement exposées.

// Pattern vulnerable to CVE-2026-22753 — pre-patch
@Bean
public SecurityFilterChain appSecurity(HttpSecurity http,
    PathPatternRequestMatcher.Builder builder) throws Exception {
  http
    .securityMatchers(matchers -> matchers.requestMatchers("/api/**"))
    .authorizeHttpRequests(auth -> auth
      .requestMatchers(builder.matcher("/admin/**")).hasRole("ADMIN")
      .anyRequest().authenticated()
    );
  return http.build();
}

// ✅ Fix: upgrade to 7.0.5 / 6.5.10 — patch corrects servlet path resolution

CVE-2026-40973: Session Hijacking via Predictable Temp Directory

CVE-2026-40973 : Vol de Session via Répertoire Temporaire Prévisible

This vulnerability targets applications with persistent sessions enabled (server.servlet.session.persistent=true). Spring Boot uses ApplicationTemp — a temporary directory — to store serialized session data between restarts. The flaw: the directory path is predictable, and a local attacker on the same host can seize control of it. Once they control the temp directory, they can read active session tokens (and impersonate authenticated users) or inject a Java deserialization gadget chain to execute code as the application user.

Cette vulnérabilité cible les applications avec des sessions persistantes activées (server.servlet.session.persistent=true). Spring Boot utilise ApplicationTemp — un répertoire temporaire — pour stocker les données de session sérialisées entre les redémarrages. Le problème : le chemin du répertoire est prévisible, et un attaquant local sur le même hôte peut en prendre le contrôle. Une fois qu'il contrôle le répertoire temporaire, il peut lire les tokens de session actifs (et usurper l'identité des utilisateurs authentifiés) ou injecter une chaîne de gadgets de désérialisation Java pour exécuter du code en tant qu'utilisateur de l'application.

The local-only attack vector makes this lower severity than CVE-2026-22732, but shared hosting environments, containerized workloads with writable volumes, or multi-tenant deployment topologies elevate the real-world risk significantly. The fix requires a Spring Boot upgrade that patches the ApplicationTemp directory ownership verification.

Le vecteur d'attaque local uniquement rend cette vulnérabilité moins sévère que CVE-2026-22732, mais les environnements d'hébergement mutualisés, les charges de travail conteneurisées avec des volumes accessibles en écriture, ou les topologies de déploiement multi-locataires élèvent considérablement le risque réel. Le correctif nécessite une mise à jour Spring Boot qui patche la vérification de propriété du répertoire ApplicationTemp.

How to Check Your Spring Security Version

Comment Vérifier Votre Version de Spring Security

With Maven, run mvn dependency:tree | grep spring-security. With Gradle, ./gradlew dependencies --configuration runtimeClasspath | grep spring-security. Check the output against the patched versions below:

Avec Maven, exécutez mvn dependency:tree | grep spring-security. Avec Gradle, ./gradlew dependencies --configuration runtimeClasspath | grep spring-security. Vérifiez le résultat face aux versions corrigées ci-dessous :

# Maven: check spring-security-core version
mvn dependency:tree | grep spring-security-core

# Gradle: full runtime classpath
./gradlew dependencies --configuration runtimeClasspath | grep -E "spring-security|spring-authorization"

# Expected output for patched Spring Boot 3.x app (spring-security-core:6.5.10)
+--- org.springframework.security:spring-security-core:6.5.10
+--- org.springframework.security:spring-security-web:6.5.10
+--- org.springframework.security:spring-security-config:6.5.10

Spring Security Hardening Checklist for 2026

Checklist de Durcissement Spring Security pour 2026

Beyond patching, the April 2026 CVE cluster exposes architectural patterns that create recurring vulnerabilities. Here's what to audit:

Au-delà des mises à jour, la grappe de CVE d'avril 2026 expose des patterns architecturaux qui créent des vulnérabilités récurrentes. Voici ce qu'il faut auditer :

• 01.
  Verify security headers are written Vérifiez que les en-têtes de sécurité sont écrits

  After upgrading, curl a representative endpoint and confirm: X-Content-Type-Options: nosniff, X-Frame-Options: DENY, Strict-Transport-Security are all present.

  Après mise à jour, faites un curl sur un endpoint représentatif et confirmez la présence de : X-Content-Type-Options: nosniff, X-Frame-Options: DENY, Strict-Transport-Security.

• 02.
  Disable Dynamic Client Registration if not needed Désactivez l'Enregistrement Dynamique de Client si inutile

  Search your codebase for clientRegistrationEndpoint. If DCR is enabled without a clear business need, remove it. If needed, validate all client metadata fields against an allow-list before persisting.

  Cherchez clientRegistrationEndpoint dans votre codebase. Si le DCR est activé sans besoin métier clair, retirez-le. Si nécessaire, validez tous les champs de métadonnées client contre une liste blanche avant persistance.

• 03.
  Audit securityMatchers with PathPatternRequestMatcher Auditez les securityMatchers avec PathPatternRequestMatcher

  If you have multiple SecurityFilterChain beans with servlet path prefixes, test each explicitly: hit the configured paths before and after authentication, verify the expected HTTP status codes (401/403 vs 200).

  Si vous avez plusieurs beans SecurityFilterChain avec des préfixes de chemin servlet, testez-les chacun explicitement : accédez aux chemins configurés avant et après authentification, vérifiez les codes de statut HTTP attendus (401/403 vs 200).

• 04.
  Disable persistent sessions or harden temp directory Désactivez les sessions persistantes ou durcissez le répertoire temporaire

  Set server.servlet.session.persistent=false unless strictly required. For containerized deployments, ensure the temp directory is on an ephemeral volume not shared with other containers.

  Définissez server.servlet.session.persistent=false sauf nécessité stricte. Pour les déploiements conteneurisés, assurez-vous que le répertoire temporaire est sur un volume éphémère non partagé avec d'autres conteneurs.

• 05.
  Use dependencyManagement to enforce Spring BOM versions Utilisez dependencyManagement pour imposer les versions Spring BOM

  Spring Boot's BOM (Bill of Materials) pins all Spring Security versions. Use spring-boot-dependencies BOM to ensure all modules upgrade together. Never pin individual Spring Security modules — version skew between spring-security-core and spring-security-web has historically introduced bugs.

  Le BOM (Bill of Materials) de Spring Boot épine toutes les versions Spring Security. Utilisez le BOM spring-boot-dependencies pour s'assurer que tous les modules se mettent à jour ensemble. Ne fixez jamais des modules Spring Security individuels — la divergence de version entre spring-security-core et spring-security-web a historiquement introduit des bugs.

• 06.
  Enable X.509 CN validation if using certificate authentication Activez la validation CN X.509 si vous utilisez l'authentification par certificat

  CVE-2026-22747 targets SubjectX500PrincipalExtractor. If your app uses X.509 mutual TLS authentication, add explicit CN format validation before the extractor processes incoming certificates.

  CVE-2026-22747 cible SubjectX500PrincipalExtractor. Si votre application utilise l'authentification mutuelle TLS X.509, ajoutez une validation explicite du format CN avant que l'extracteur traite les certificats entrants.

Why Is Spring Seeing a CVE Surge in 2026?

Pourquoi Spring Voit-il une Explosion de CVE en 2026 ?

HeroDevs, which tracks Spring CVE history for EOL support customers, attributes the 2026 surge to AI-assisted security research. Tools that use large language models to analyze framework source code have meaningfully lowered the barrier to finding logical vulnerabilities in well-established codebases. The April 2026 batch — 7 Spring Security CVEs in two days — reflects coordinated disclosure from multiple researchers who independently discovered related authorization-logic flaws.

HeroDevs, qui suit l'historique des CVE Spring pour ses clients sous support EOL, attribue la vague 2026 à la recherche de sécurité assistée par IA. Des outils utilisant des grands modèles de langage pour analyser le code source des frameworks ont significativement abaissi la barrière pour trouver des vulnérabilités logiques dans des codebases bien établis. Le lot d'avril 2026 — 7 CVE Spring Security en deux jours — reflète une divulgation coordonnée de plusieurs chercheurs ayant indépendamment découvert des failles liées à la logique d'autorisation.

The implication is structural: we should expect more CVE clusters like this as AI-assisted analysis tools improve and target high-value frameworks. Quarterly manual patching reviews are no longer sufficient. Teams using Spring Boot need automated monitoring of their pom.xml and build.gradle to catch new advisories before they age into exploitable windows.

L'implication est structurelle : nous devrions nous attendre à plus de grappes de CVE similaires à mesure que les outils d'analyse assistée par IA s'amélioreront et cibleront des frameworks à haute valeur. Les revues manuelles de patch trimestrielles ne sont plus suffisantes. Les équipes utilisant Spring Boot ont besoin d'une surveillance automatisée de leurs pom.xml et build.gradle pour détecter les nouveaux avis avant qu'ils ne deviennent des fenêtres exploitables.

Frequently Asked Questions

Questions Fréquentes