---METADATA---
VENDOR: Spring
PRODUCT: Spring AI Vector Stores
AFFECTED_VERSIONS: Spring AI 1.0.0 - 1.0.x, 1.1.0 - 1.1.x
---END_METADATA---

Description Summary:
Spring AI Vector Stores are vulnerable to arbitrary query execution in Elasticsearch, OpenSearch, and GemFire via special character injection.

Executive Summary:
A query injection vulnerability in Spring AI Vector Stores could allow low-privileged attackers to force the execution of arbitrary queries against backend vector databases.

Vulnerability Details

CVE-ID: CVE-2026-47835

Affected Software: Spring AI

Affected Versions: Spring AI 1.0.0 - 1.0.x, 1.1.0 - 1.1.x

Vulnerability: The vulnerability arises from improper sanitization of special characters within Spring AI Vector Stores. This allows an attacker with low-level access to inject characters that force the execution of unauthorized, arbitrary queries in connected Elasticsearch, OpenSearch, or GemFire VectorDB instances.

Business Impact

With a CVSS score of 8.6, this vulnerability poses a severe risk to the confidentiality and integrity of vector database contents. An attacker could exfiltrate sensitive data stored within the vector space or potentially modify data, impacting the reliability of AI-driven applications and the underlying data sets.

Remediation Plan

Immediate Action: Update Spring AI components to versions 1.0.9 or 1.1.8 as applicable to your environment.

Proactive Monitoring: Monitor query logs for the specified vector databases for unusual or unauthorized query patterns that deviate from standard application behavior.

Compensating Controls: Implement strict input validation and sanitization for any data passed to the Spring AI Vector Store interface to prevent special character injection.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of June 16, 2026, there is no public information indicating active exploitation. However, the ability to manipulate queries in AI-driven databases is a significant concern that requires immediate remediation.

Analyst Recommendation

Organizations integrating Spring AI with vector databases should treat this as a high-priority update. Upgrading to the provided patched versions is the most effective way to secure the query interface and prevent unauthorized access to the vector data store.

---METADATA---
VENDOR: Spring
PRODUCT: Cloud Gateway Server
AFFECTED_VERSIONS: Spring Cloud Gateway 3.1.x, 4.1.x, 4.2.x, 4.3.x, 5.0.x
---END_METADATA---

Description Summary:
Spring Cloud Gateway Server incorrectly forwards X-Forwarded-For and Forwarded headers from untrusted proxies in specific configurations.

Executive Summary:
An improper header handling vulnerability in Spring Cloud Gateway Server could allow attackers to bypass security controls and spoof their source IP address.

Vulnerability Details

CVE-ID: CVE-2026-47825

Affected Software: Spring Cloud Gateway Server

Affected Versions: Spring Cloud Gateway 3.1.x, 4.1.x, 4.2.x, 4.3.x, 5.0.x

Vulnerability: The vulnerability occurs when forwarded-header handling is enabled but the trusted proxy property is misconfigured. This allows an unauthenticated attacker to inject forged headers that are passed to backend services, facilitating IP allowlist bypass and source-address spoofing.

Business Impact

With a CVSS score of 8.6, this vulnerability poses a high risk to network security. Attackers can bypass IP-based access controls for backend services, potentially gaining access to restricted APIs or triggering log forgery, which hampers incident response and forensic investigations.

Remediation Plan

Immediate Action: Update to the patched versions: 3.1.13, 4.1.13, 4.2.9, 4.3.5, or 5.0.2, depending on your current deployment.

Proactive Monitoring: Review application logs for unexpected header values that deviate from expected proxy patterns.

Compensating Controls: Ensure the 'trusted-proxies' property is explicitly and correctly configured to prevent the gateway from trusting headers originating from unauthorized sources.

Exploitation Status

Public Exploit Available: true

Analyst Notes: As of June 16, 2026, public exploit information exists regarding this header manipulation vulnerability. The ease of bypassing security filters makes this a high-priority item for any infrastructure using Spring Cloud Gateway.

Analyst Recommendation

This vulnerability represents a significant security misconfiguration risk. IT teams must verify their Spring Cloud Gateway version and apply the recommended patches immediately to restore the integrity of their header-based security controls.

---METADATA---
VENDOR: Spring
PRODUCT: Spring Statemachine
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
---END_METADATA---

Description Summary:
Spring Statemachine's persistence backends fail to enforce a class allowlist during deserialization, enabling potential remote code execution.

Executive Summary:
A critical deserialization vulnerability in Spring Statemachine allows remote attackers to execute arbitrary code within the application JVM.

Vulnerability Details

CVE-ID: CVE-2026-41862

Affected Software: Spring Spring Statemachine

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The software uses Kryo-based persistence backends (JPA, MongoDB, Redis, and ZooKeeper) to process state-machine contexts without enforcing a class allowlist. This insecure deserialization of untrusted data (CWE-502) allows attackers to manipulate serialized objects to achieve remote code execution.

Business Impact

The ability for an attacker to execute arbitrary code within the application JVM represents a critical risk. With a CVSS score of 8.8, this vulnerability could lead to total system compromise, unauthorized data access, and the deployment of malicious payloads, jeopardizing the confidentiality and integrity of the entire application environment.

Remediation Plan

Immediate Action: Upgrade to the latest patched version of Spring Statemachine immediately to implement class allowlisting.

Proactive Monitoring: Review application logs for unexpected deserialization errors or unusual class instantiation attempts. Monitor JVM performance and outbound network connections for signs of unauthorized activity.

Compensating Controls: Implement strict network segmentation to limit access to persistence backends (Redis, MongoDB, etc.) and utilize WAF rules to inspect traffic for serialized object payloads.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of June 24, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

This vulnerability is highly critical due to the potential for remote code execution. Organizations utilizing Spring Statemachine must treat this as a high-priority incident and apply vendor-provided patches as soon as they become available.

---METADATA---
VENDOR: Spring
PRODUCT: GraphQL
AFFECTED_VERSIONS: See vendor advisory for specific affected versions
---END_METADATA---

Description Summary:
Spring for GraphQL applications utilizing WebSocket transport are susceptible to Cross-Site WebSocket Hijacking (CSWSH) attacks.

Executive Summary:
Spring for GraphQL applications are at risk of Cross-Site WebSocket Hijacking, which may allow unauthorized parties to intercept or interact with WebSocket sessions.

Vulnerability Details

CVE-ID: CVE-2026-41700

Affected Software: Spring GraphQL

Affected Versions: See vendor advisory for specific affected versions

Vulnerability: The application fails to properly validate the origin of WebSocket upgrade requests, allowing an attacker to perform Cross-Site WebSocket Hijacking. This requires the application to have the WebSocket transport functionality enabled.

Business Impact

The CVSS score of 8.1 (High) indicates a significant risk of unauthorized interaction with user sessions. Exploitation could lead to the theft of sensitive session data or the execution of unauthorized actions within the context of an authenticated user's session, resulting in a potential compromise of application integrity.

Remediation Plan

Immediate Action: Update to the latest version of Spring for GraphQL as soon as a security patch is released by the vendor.

Proactive Monitoring: Monitor WebSocket traffic logs for connections originating from unexpected or suspicious domains.

Compensating Controls: Configure strict CORS (Cross-Origin Resource Sharing) policies and origin validation on the WebSocket endpoint to ensure only authorized clients can establish connections.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of June 14, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Security teams should immediately audit their Spring for GraphQL implementations to determine if WebSocket transport is enabled. Until a patch is available, enforcing strict origin checks is essential to prevent unauthorized session hijacking.

---METADATA---
VENDOR: Spring
PRODUCT: Spring for GraphQL
AFFECTED_VERSIONS: Spring for GraphQL 2.0.0 through 2.0.3; 1.4.0 through 1.4.5; 1.3.0 through 1.3.8
---END_METADATA---

Description Summary:
Spring for GraphQL applications are vulnerable to unsafe deserialization during the processing of paginated queries, which can lead to remote code execution.

Executive Summary:
A high-severity unsafe deserialization vulnerability in Spring for GraphQL allows attackers to achieve remote code execution through malicious paginated queries.

Vulnerability Details

CVE-ID: CVE-2026-41699

Affected Software: Spring for GraphQL

Affected Versions: Spring for GraphQL 2.0.x (2.0.0-2.0.3), 1.4.x (1.4.0-1.4.5), and 1.3.x (1.3.0-1.3.8)

Vulnerability: The application is vulnerable to unsafe deserialization when processing paginated GraphQL queries. An attacker can craft a malicious request that triggers the execution of arbitrary code if the application environment includes specific exploitable classes.

Business Impact

A CVSS score of 8.1 indicates a high risk of total system compromise. If exploited, an attacker could achieve remote code execution (RCE), potentially resulting in full system takeover, data exfiltration, or the deployment of ransomware within the application environment.

Remediation Plan

Immediate Action: Update to the patched versions: 2.0.4, 1.4.6, or 1.3.9, depending on the current version in use.

Proactive Monitoring: Monitor GraphQL request logs for unusual or malformed queries, particularly those related to pagination (Connection fields).

Compensating Controls: Implement a Web Application Firewall (WAF) with rules to inspect and filter suspicious GraphQL payloads and restrict input to trusted sources.

Exploitation Status

Public Exploit Available: False

Analyst Notes: As of June 14, 2026, there is no public information indicating active exploitation of this vulnerability. However, the potential for RCE makes this a high-priority remediation item.

Analyst Recommendation

Developers and system administrators should immediately update all instances of Spring for GraphQL to the latest secure versions. Review the application classpath to identify and remove any unnecessary classes that could be leveraged in a deserialization attack.

---METADATA---
VENDOR: Spring
PRODUCT: Spring WS
AFFECTED_VERSIONS: Deployments using AbstractAddressingEndpointMapping with WebServiceMessageSender configured for out-of-band replies
---END_METADATA---

Description Summary:
Spring WS is vulnerable to Server-Side Request Forgery (SSRF) when processing WS-Addressing headers, allowing attackers to force outbound connections to arbitrary destinations.

Executive Summary:
Spring WS exhibits a Server-Side Request Forgery vulnerability that allows remote attackers to force the server to initiate unauthorized outbound connections via crafted WS-Addressing headers.

Vulnerability Details

CVE-ID: CVE-2026-40999

Affected Software: Spring WS

Affected Versions: See vendor advisory for specific configuration requirements.

Vulnerability: This is a Server-Side Request Forgery (SSRF) vulnerability occurring when an AbstractAddressingEndpointMapping subclass is used. Attackers can supply crafted wsa:ReplyTo or wsa:FaultTo headers, causing the server to initiate outbound connections to internal hosts or sensitive cloud metadata endpoints without verification.

Business Impact

With a CVSS score of 8.6, this vulnerability poses a high risk to applications using Spring WS in specific configurations. Successful exploitation can lead to internal network reconnaissance, access to cloud environment credentials via metadata services, and potential compromise of internal-only services, significantly damaging the security posture of the host environment.

Remediation Plan

Immediate Action: Review your Spring WS configuration and apply the recommended security updates or configuration changes provided by the vendor.

Proactive Monitoring: Inspect logs for unusual outbound connection attempts originating from the service, particularly those targeting internal IP ranges or cloud metadata endpoints.

Compensating Controls: Implement a restrictive destination validator or network-level egress control policies to ensure the application can only communicate with authorized, expected endpoints.

Exploitation Status

Public Exploit Available: null

Analyst Notes: As of June 11, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Given the potential for SSRF to expose internal environments, administrators must immediately assess their Spring WS implementations to determine if they meet the criteria for vulnerability. Applying the vendor's recommended mitigations is critical to preventing unauthorized lateral movement or information disclosure within the network.

---METADATA---
VENDOR: Spring
PRODUCT: Web Services
AFFECTED_VERSIONS: Spring Web Services 5.0.0 through 5.0.1; 4.1.0 through 4.1.3; 4.0.0 through 4.0.18; 3.1.0 through 3.1.8
---END_METADATA---

Description Summary:
The Jaxp13XPathTemplate component uses an insecure, unhardened XML parser for XPath expressions, potentially exposing applications to XML External Entity (XXE) attacks.

Executive Summary:
An insecure XML parsing implementation in Spring Web Services exposes applications to potential XML External Entity (XXE) injection attacks when processing XPath expressions.

Vulnerability Details

CVE-ID: CVE-2026-40998

Affected Software: Spring Web Services

Affected Versions: Spring Web Services 5.0.0 through 5.0.1; 4.1.0 through 4.1.3; 4.0.0 through 4.0.18; 3.1.0 through 3.1.8

Vulnerability: The Jaxp13XPathTemplate incorrectly utilizes the JDK's default DocumentBuilderFactory rather than the hardened configuration provided by Spring. This allows attacker-controlled XML inputs via StreamSource or SAXSource to trigger unauthorized external entity processing.

Business Impact

Assessed at a CVSS score of 8.2, this vulnerability is critical for any application processing XML-based inputs. Successful exploitation of an XXE vulnerability can lead to local file disclosure, server-side request forgery (SSRF), and potential denial of service, severely compromising the confidentiality and availability of the underlying server.

Remediation Plan

Immediate Action: Upgrade to the latest fixed version of Spring Web Services as defined in the vendor advisory to ensure the use of secure, hardened XML parsing configurations.

Proactive Monitoring: Monitor for anomalous outbound network traffic from the application server, which may indicate an attempt to perform SSRF via an XXE injection.

Compensating Controls: Implement a Web Application Firewall (WAF) configured to inspect XML payloads and block requests containing malicious DOCTYPE or ENTITY declarations.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of June 12, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

XXE vulnerabilities are a classic but dangerous vector for internal system compromise. It is imperative that teams apply the recommended patches to move away from default, insecure XML parsing behaviors toward the hardened configurations provided by the vendor.

---METADATA---
VENDOR: Spring
PRODUCT: Web Services
AFFECTED_VERSIONS: Spring Web Services 5.0.0 through 5.0.1; 4.1.0 through 4.1.3; 4.0.0 through 4.0.18; 3.1.0 through 3.1.8
---END_METADATA---

Description Summary:
An initialization error in Wss4jSecurityInterceptor disables WS-I Basic Security Profile enforcement, potentially causing services to accept invalid security messages.

Executive Summary:
An incorrect configuration in Spring Web Services disables critical security profile enforcement, leaving applications vulnerable to accepting non-compliant message data.

Vulnerability Details

CVE-ID: CVE-2026-40994

Affected Software: Spring Web Services

Affected Versions: Spring Web Services 5.0.0 through 5.0.1; 4.1.0 through 4.1.3; 4.0.0 through 4.0.18; 3.1.0 through 3.1.8

Vulnerability: The Wss4jSecurityInterceptor fails to initialize the BSP compliance flag correctly during inbound validation. This results in the system failing to enforce WS-I Basic Security Profile rules on RequestData, which could allow attackers to submit malformed or malicious SOAP messages that bypass security standards.

Business Impact

With a CVSS score of 8.2, this vulnerability represents a significant risk to the security posture of enterprise service integrations. By bypassing BSP enforcement, attackers may successfully inject messages that would otherwise be rejected, potentially leading to unauthorized service execution or downstream system instability.

Remediation Plan

Immediate Action: Upgrade to Spring Web Services version 5.0.2, 4.1.4, or later to restore proper security enforcement.

Proactive Monitoring: Inspect application logs for incoming SOAP requests that deviate from established security schemas or trigger validation errors.

Compensating Controls: If immediate patching is not feasible, explicitly enable BSP compliance by invoking the setBspCompliant setter method with the argument true in your application configuration.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of June 12, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

Standard security profiles are foundational to preventing message-based attacks. Organizations should prioritize updating their Spring Web Services dependencies to ensure that all inbound traffic is strictly validated against the WS-I Basic Security Profile.

---METADATA---
VENDOR: Spring
PRODUCT: Spring AI
AFFECTED_VERSIONS: 1.0.0 before 1.0.5, 1.1.0 before 1.1.4
---END_METADATA---

Description Summary:
Spring AI versions prior to 1.0.5 and 1.1.4 are vulnerable to SpEL injection in SimpleVectorStore when user-supplied input is used as a filter expression key, leading to remote code execution.

Executive Summary:
Spring AI applications utilizing SimpleVectorStore are vulnerable to critical remote code execution if they allow user-controlled input to define filter expression keys.

Vulnerability Details

CVE-ID: CVE-2026-22738

Affected Software: Spring AI

Affected Versions: 1.0.0 to 1.0.4 and 1.1.0 to 1.1.3

Vulnerability: The vulnerability is a Spring Expression Language (SpEL) injection. When an application uses SimpleVectorStore and passes unvalidated user input as a key in a filter expression, a remote attacker can inject malicious SpEL expressions that are evaluated by the server, resulting in arbitrary code execution.

Business Impact

Exploitation of this vulnerability allows for unauthenticated remote code execution (RCE) depending on how the application exposes its search or filtering functionality. With a CVSS score of 9.8, the risk involves complete system takeover, data theft, and potential use of the server for further internal network attacks.

Remediation Plan

Immediate Action: Update Spring AI to version 1.0.5, 1.1.4, or later. Ensure that no user-supplied data is directly used as a key in filter expressions.

Proactive Monitoring: Monitor for application errors related to SpEL parsing and audit code for any dynamic expression building using external inputs.

Compensating Controls: Implement strict input validation or use an allowlist for filter keys to prevent the injection of special characters used in SpEL expressions.

Exploitation Status

Public Exploit Available: false

Analyst Notes: As of Mar 27, 2026, there is no public information indicating active exploitation of this vulnerability. However, due to the nature of the flaw, the potential for exploitation is high.

Analyst Recommendation

SpEL injection is a well-known and highly dangerous vulnerability class. Developers using Spring AI must update their dependencies immediately and review their implementation of SimpleVectorStore to ensure secure input handling practices are followed.

---METADATA---
VENDOR: Spring
PRODUCT: Spring Security
AFFECTED_VERSIONS: 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, 7.0.0–7.0.3
---END_METADATA---

Description Summary:
Spring Security may fail to write HTTP response headers in certain servlet applications. This failure can bypass critical security protections like HSTS or CSP, leaving users vulnerable to web-based attacks.

Executive Summary:
A critical vulnerability in Spring Security causes a failure to apply security headers, potentially exposing web applications to cross-site scripting, session hijacking, and other browser-based exploits.

Vulnerability Details

CVE-ID: CVE-2026-22732

Affected Software: Spring Security

Affected Versions: 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, 7.0.0–7.0.3

Vulnerability: This issue involves a failure in the header-writing logic for servlet applications. Under certain conditions, unauthenticated requests may result in responses where security-critical HTTP headers (such as Content-Security-Policy or X-Frame-Options) are omitted, effectively disabling the application's browser-level security posture.

Business Impact

With a CVSS score of 9.1, this vulnerability significantly increases the risk of successful client-side attacks against application users. The absence of security headers can facilitate credential theft via phishing, data exfiltration through XSS, or UI redressing via clickjacking. This can lead to a loss of customer trust and potential regulatory non-compliance regarding data protection standards.

Remediation Plan

Immediate Action: Update Spring Security dependencies to the latest patched maintenance release (e.g., 5.7.22, 5.8.24, 6.3.15, 6.4.15, 6.5.9, or 7.0.4).

Proactive Monitoring: Use automated security scanning tools to verify that all production endpoints are consistently returning expected security headers in their HTTP responses.

Compensating Controls: Configure a reverse proxy or load balancer to inject missing security headers (HSTS, CSP, X-Content-Type-Options) as a temporary global fix.

Exploitation Status

Public Exploit Available: No

Analyst Notes: As of Mar 19, 2026, there is no public information indicating active exploitation. However, the widespread use of Spring Security in enterprise environments makes this a high-impact vulnerability that requires prompt attention.

Analyst Recommendation

We recommend that development teams immediately audit their Spring Security versions and apply the necessary patches. Given the silent nature of this failure, automated testing should be implemented to ensure that security headers are correctly applied across all application routes.