Java

Charset-confusion in MariaDB Connector/J (all branches prior to 2.7.14, 3.3.5, 3.4.3, and 3.5.9) allows a server-side character set change mid-session to silently decouple the driver's UTF-8 encoding assumption from the server's active encoding. Because the driver continues escaping SQL string literals as UTF-8 while the server parses incoming bytes under a different multi-byte encoding (e.g., GBK or BIG5), the mismatch can defeat byte-wise SQL quoting and enable SQL injection - a well-documented attack class for charset-confusion primitives. No public exploit has been identified and this CVE is not listed in CISA KEV at time of analysis.

MariaDB Connector/J exposes database account passwords in cleartext to on-path attackers or hostile servers when PAM (dialog) authentication is used over plain TCP. The driver's PAM handler (SendPamAuthPacketFactory, plugin name 'dialog') failed to override the requireSsl() gate that correctly protects its sibling mysql_clear_password plugin, inheriting a default value of false and thus omitting the secure-transport requirement. Under the default connector configuration (sslMode=DISABLE, restrictedAuth=null), a man-in-the-middle or rogue server can issue an Authentication Switch Request for the dialog plugin and receive the account password in cleartext, granting full credential reuse against the real database. No public exploit has been identified and the vulnerability is not listed in CISA KEV, but the attack mechanics are straightforward for any on-path attacker against affected deployments.

Cleartext database password disclosure in MariaDB Connector/J (all versions before 2.7.14, 3.3.5, 3.4.3, and 3.5.9) allows an active network man-in-the-middle to capture a victim application's full database password during the initial TLS handshake. The connector's initial-handshake code path transmits a mysql_clear_password authentication response before validating the certificate fingerprint that is supposed to enforce server identity - a guard that the OK-packet and auth-switch paths correctly enforce but that HandshakeResponse.encode() bypasses entirely. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code is identified at time of analysis, though the vulnerability mechanism is fully documented in a vendor-published HackerOne report and GHSA advisory.

Unauthenticated XML External Entity (XXE) injection in MapFish Print's GML layer parser allows remote attackers to read arbitrary server-side files and conduct server-side request forgery (SSRF) via a single crafted HTTP POST to the /api/print3/print endpoint. All 3.x branches prior to 3.28.30, 3.30.32, 3.31.24, and 3.33.16, as well as 4.x prior to 4.0.5, are affected. A fully functional proof-of-concept exploit has been publicly disclosed in the GitHub Security Advisory GHSA-5v29-34h8-v68r, enabling exfiltration of Kubernetes service account tokens, OS credential files, and TLS certificates with no authentication required.

Unauthorized token deletion in Graylog's REST API (versions 6.2.0 through 6.3.11, 7.0.0-7.0.6, and 7.1.0-7.1.1) allows any authenticated user to revoke access tokens belonging to other accounts - including administrators and service accounts - by exploiting a misplaced permission check in the token revocation endpoint. The flaw does not expose token secret values but can invalidate privileged credentials and disrupt automated integrations that rely on access tokens. No public exploit code or CISA KEV listing has been identified at time of analysis; vendor-released patches are available in versions 6.3.12, 7.0.7, and 7.1.2.

Log-record tampering in Graylog's FortiGate syslog parser enables unauthenticated network senders to overwrite or erase critical security-log fields - including srcip, dstip, date, time, and tz - or cause entire log messages to be silently discarded, creating a viable log-evasion primitive. Affected are Graylog Server versions prior to 6.3.12, 7.0.7, and 7.1.2 (all branches), and Graylog Forwarder prior to version 7.3, on any deployment ingesting FortiGate key-value syslog. No public exploit code exists and this is not in CISA KEV, but the attack requires no authentication and minimal crafting skill, making it a realistic threat to security-monitoring integrity in FortiGate-centric environments.

Remote code execution in Yamcs (yamcs-core <= 5.12.7 and 5.13.0-5.13.1) lets an authenticated, low-privileged user run arbitrary OS commands by injecting a StreamSQL LIKE pattern that breaks out of a generated Java string literal compiled at runtime by Janino. Because the pattern is embedded raw whether it arrives as a SQL literal or a bound '?' argument, the sink is reachable not only from the archiving endpoints but from routine read-only APIs (readRows, events search, activities listing), including the Events page search box. A detailed vendor-published proof of concept exists; this is not in CISA KEV, so it is publicly available exploit code rather than confirmed active exploitation.

Remote code execution in Yamcs (open-source mission-control server) versions <= 5.12.7 and 5.13.0-5.13.1 allows a caller with the CreateInstances privilege - or any unauthenticated user in the default no-security.yaml configuration where guest is superuser - to inject YAML into an instance template via the templateArgs parameter of POST /api/instances (and PATCH /api/instances/{instance}). Because arguments are written into the rendered config as raw, unescaped text and then loaded as YAML, an attacker can inject a services: entry that instantiates org.yamcs.ProcessRunner and executes an arbitrary command as the Yamcs service account. Publicly available exploit code exists (a full PoC with a reverse shell is published in the GitHub Security Advisory), and vendor patches are available in 5.12.8 and 5.13.2.

Unauthenticated directory traversal in Yamcs versions up to and including 5.8.6 (per advisory scope, < 5.11.13 per package metadata) allows any remote attacker to read arbitrary files from the underlying host operating system by sending a crafted HTTP request. The flaw resides in StaticFileHandler.java, which resolves user-supplied URL paths against a static file root without verifying the resolved path stays within that root - a double-slash prefix (e.g., //etc/passwd) is sufficient to escape the boundary. No public exploit identified at time of analysis, though the steps-to-reproduce are fully published in the GitHub Security Advisory and the vulnerability was demonstrated in a public CTF challenge at DEFCON 33.

Reflected XSS in Yamcs versions through 5.8.6 allows unauthenticated remote attackers to inject and execute arbitrary JavaScript in a logged-in user's browser by delivering a specially crafted URL targeting the OAuth authorization endpoint. Exploitation exfiltrates the victim's session and refresh tokens to an attacker-controlled server, enabling complete account takeover. No public exploit identified at time of analysis independent of the advisory, though GHSA-rxpg-wjf8-qv9c includes a working reproduction payload with exact URL and netcat listener steps; vendor patch is available in 5.9.4 (CVSS 6.5, UI:R).

Missing authorization checks on three IAM REST API endpoints in Yamcs allow any authenticated low-privilege user to enumerate the server's complete privilege taxonomy and role-to-privilege mappings, directly enabling targeted privilege escalation reconnaissance. Affected are yamcs-core versions up to 5.12.7 and 5.13.0 through 5.13.1, used in production spacecraft operations and ground station environments. A proof-of-concept is confirmed in the GHSA advisory; no active exploitation (CISA KEV) has been identified, but the leaked data (including the ControlAccess and ChangeMissionDatabase privilege names) provides a precise roadmap for chained attacks including, per the advisory, algorithm-level remote code execution.

Remote code execution in Yamcs (Mission Control) versions <= 5.12.7 and 5.13.0-5.13.1 allows an authenticated user holding the ControlArchiving system privilege to run arbitrary Java on the server host by embedding executable code in a StreamSQL column name. The malicious name is interpolated unescaped into Java source that Janino compiles without a sandbox when a sum() aggregate is evaluated over that column via POST /api/archive/{instance}:executeSql. This is a second, independent Janino sink sharing the root cause of CVE-2026-44632, which the earlier fix did not close; the advisory (GHSA-3g44-3m7x-cgg2) includes a full working PoC verified end-to-end against a real, security-enabled Yamcs 5.13.0, though there is no CISA KEV listing.

Unauthenticated access to Spring Boot Actuator management endpoints in Zipkin through 3.6.1 exposes sensitive operational data and configuration controls on the same port as the tracing API. Remote attackers with network reach to the Zipkin API port can read environment variables, bean configurations, and storage backend credentials via endpoints such as /actuator/env and /actuator/beans, or silently suppress security-relevant logging by modifying log levels via /actuator/loggers. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms low-complexity, unauthenticated remote exploitation; no public exploit identified at time of analysis, and the vulnerability is not listed in CISA KEV.

Remote code execution affects PaperCut MF and PaperCut NG through unsafe dynamic class loading in the database connection utilities, which instantiate JDBC driver classes from configurable driver names without validating them against an allowlist. An attacker who can control administrative system configuration parameters can force the server to load and execute arbitrary Java bytecode already present on the application classpath, running with the full privileges of the PaperCut server process. No public exploit identified at time of analysis, but the PR:H requirement and PaperCut's history of being targeted make prompt patching advisable.

Spring Integration's reactive message pipeline leaks reply routing and security headers across concurrent users when an IntegrationFlow uses .fluxTransform() with an asynchronous or reordering operator that emits raw payloads, causing one user's replyChannel, correlationId, and security or tenant headers to be applied to another concurrent user's response. Affected versions span the 5.5.x, 6.4.x, 6.5.x, 7.0.x, and 7.1.0 release lines across the core Spring Integration library, as confirmed by VMware via the spring.io security advisory. The CVSS 8.2 score reflects network exploitability with no authentication required and high confidentiality impact; no public exploit has been identified at time of analysis.

Unsafe header deserialization in Spring Integration's EmbeddedHeadersJsonMessageMapper exposes applications to header injection across all active release trains (5.5.x through 7.1.0). The decodeNativeFormat method constructs GenericMessage objects with MutableMessageHeaders populated directly from attacker-controlled JSON-deserialized header maps, bypassing sanitization by default in the constructor. Low-privileged network attackers who can submit crafted byte payloads to an affected consumer channel can manipulate message headers, yielding partial confidentiality, integrity, and availability impacts. No public exploit has been identified at time of analysis and this CVE is not listed in CISA KEV.

Concurrent message processing in Spring Integration's script-backed channels causes shared ScriptEngine state corruption when using JSR-223 engines that declare THREADING=null, such as the Kotlin KTS engine. Affected Spring Integration versions from 5.5.21 and earlier through 7.1.0 are susceptible to cross-message data leakage, where one message's payload or header bindings can bleed into another message's script evaluation context under concurrent load. No public exploit has been identified at time of analysis, and the CVSS 4.2 Medium rating reflects the high attack complexity imposed by the required race condition, though the information disclosure and partial integrity impact are real concerns in multi-tenant or high-throughput deployments.

Link credit exhaustion in Spring AMQP 4.1.0 silently stalls AMQP listener containers when a container-level ErrorHandler is active. Each message delivery whose processing throws an exception permanently consumes one link credit without returning it to the broker; once the pool reaches zero (after the default 100 credits), the broker halts delivery while isRunning() continues to report true, masking the outage from standard health checks. No active exploitation has been confirmed (no CISA KEV listing, no public POC), but this is a realistic denial-of-service condition for any Spring-based messaging consumer running the affected version with an ErrorHandler configured.

RediSearch query injection in Spring AI 2.0.0's RedisChatMemoryRepository grants authenticated low-privilege users read access to all indexed chat messages across every conversation in the Redis index. The findByMetadata() method omits the RediSearchUtil.escape() call consistently applied by sibling methods (get(), clear(), findByTimeRange()), allowing attacker-controlled metadata values to break out of RediSearch tag query clauses via injected syntax such as x} | * and match all documents in the index. No public exploit code has been identified at time of analysis, and the CVE does not appear in the CISA KEV catalog.

Denial-of-service in Spring for Apache Kafka's `DeadLetterPublishingRecovererFactory` exposes consumer JVMs across all supported branches (2.8.x through 4.1.0) to crash or hang when processing messages with a crafted `retry_topic-original-timestamp` header. An authenticated Kafka producer can inject a ConsumerRecord carrying an oversized or malformed header byte array, which is passed without any length or format validation directly to Java's `BigInteger(byte[])` constructor, triggering heap memory exhaustion or an unhandled exception that disrupts message consumption. No public exploit code has been identified and the CVE does not appear in CISA KEV at time of analysis, but low attack complexity combined with broad version coverage makes this a credible availability threat for any Spring Kafka deployment using retry or dead-letter queue features.

Stored cross-site scripting in Spring Authorization Server's DefaultConsentPage allows network-accessible, unauthenticated attackers to inject arbitrary JavaScript into the OAuth2 consent screen presented to legitimate users. Affected versions span 1.4.0-1.4.11 and 1.5.0-1.5.8; the attack payload is embedded in a crafted OAuth2 authorization request, persisted server-side, and executed in the victim's browser when they view the consent dialog. No public exploit has been identified at time of analysis, but the low-complexity injection mechanism combined with a CVSS 8.2 base score and high confidentiality impact makes this an urgent remediation target for any deployment relying on the default consent page.

Denial of Service in Spring Cloud Config's Monitor component allows unauthenticated remote attackers to crash or degrade the configuration server by submitting malicious payloads to the webhook endpoint. Affected versions span the 3.x, 4.x, and 5.x release lines, covering a broad installed base of Spring Boot microservice environments. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, though the unauthenticated network-accessible attack surface (PR:N, AV:N, AC:L) means exploitation requires minimal capability.

Applications that build a Content-Disposition header value from untrusted input may be vulnerable to HTTP response splitting when the input is a malicious file name. Spring Framework 7.0.0 - 7.0.8 Spring Framework 6.2.0 - 6.2.19 Spring Framework 6.1.0 - 6.1.28 Spring Framework 6.0.0 - 6.0.30 Spring Framework 5.3.0 - 5.3.49 Spring Framework 5.2.25.RELEASE and earlier

Symlink redirection in Spring Integration's Zip/UnZip transformer allows a local unprivileged user sharing the same host to hijack transformer output by pre-creating /tmp/ziptransformer as a symlink before application startup. Affected versions span the 6.4, 6.5, 7.0, and 7.1 release lines, covering a wide range of enterprise Java deployments that use Spring Integration's file transformation capabilities. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in CISA KEV, though the integrity and availability impact is rated High by the vendor-assigned CVSS score.

Spring Cloud Stream versions 5.0.0-5.0.2, 4.3.0-4.3.3, and 4.2.0-4.2.6 expose a deserialization of untrusted types flaw that could allow a network-positioned attacker with high privileges and required user interaction to gain limited read and write access to application data. The CVSS vector (AV:N/AC:H/PR:H/UI:R/S:U/C:L/I:L/A:N) reflects heavy exploitation constraints, making real-world abuse unlikely without insider-level access and specific preconditions. No public exploit code has been identified and the vulnerability is absent from CISA KEV at time of analysis.

Server-Sent Events (SSE) stream corruption affects Spring MVC applications built on the functional web framework across Spring Framework 5.3.0-5.3.49, 6.0.0-6.0.30, 6.1.0-6.1.28, 6.2.0-6.2.19 and 7.0.0-7.0.8, where unneutralized CRLF sequences (CWE-93) let an attacker inject into or corrupt the event stream. Reported by VMware/Spring and tagged as Information Disclosure, the flaw can break stream framing and potentially leak or splice data across SSE responses. No public exploit identified at time of analysis, and EPSS is low (0.16%, 6th percentile), but the vendor-assigned CVSS of 9.8 (all-High impact) sits in tension with the information-disclosure framing and warrants scrutiny.

JdbcMessageStore deserialization allowlist protection in Spring Integration silently fails when the store is configured as a Spring-managed bean, rendering the security control entirely ineffective. Operators who call addAllowedPatterns() to restrict which Java classes can be deserialized from the JDBC message store receive no actual protection - any class remains deserializable despite the configured allowlist - leaving applications exposed to unsafe Java deserialization attacks while operators believe they have hardened the component. Affected across Spring Integration 6.4.x through 7.1.0; no public exploit identified at time of analysis.

Spring Cloud Stream's partition interceptor logic improperly inserts a partition interceptor during message sends under specific conditions, potentially routing messages to unintended partitions. Affected versions span three active release lines: 5.0.0-5.0.2, 4.3.0-4.3.3, and 4.2.0-4.2.6. An authenticated operator with high privileges who triggers a message send under the required conditions could cause limited information disclosure or message integrity degradation by routing data to an unintended partition consumer. No public exploit identified at time of analysis; CVSS score of 3.1 reflects the high access bar and narrow impact.

Improper content-type caching in the Avro component of Spring Cloud Stream can produce incorrect content-type metadata on processed messages, creating a low-severity information-disclosure and data-integrity risk. Affected versions span the 4.2.x, 4.3.x, and 5.0.x release trains. Exploitation requires network access, high privilege level, high attack complexity, and user interaction, making real-world impact minimal; no public exploit code or active exploitation has been identified at time of analysis.

Spring Cloud Stream's dynamic destination cache lacks an upper bound on its size, exposing applications to limited information disclosure and integrity concerns under constrained conditions. Affected versions span the 4.2.x, 4.3.x, and 5.0.x release lines, reported by VMware (Broadcom), the Spring project maintainer. No public exploit code exists and the vulnerability is not listed in CISA KEV; the low CVSS score of 3.1 reflects the highly constrained exploitation prerequisites including high privilege requirements and user interaction.

Sensitive data exposure in Spring Cloud Stream versions 4.2.0-4.2.6, 4.3.0-4.3.3, and 5.0.0-5.0.2 allows logging of sensitive information - such as message payloads, headers, or configuration values - under specific conditions. The vulnerability is classified as information disclosure with a low CVSS base score of 3.1, reflecting the high attack complexity and privilege requirements. No public exploit code has been identified and this vulnerability is not listed in the CISA Known Exploited Vulnerabilities catalog.

Spring Cloud Function's Azure integration may inadvertently log sensitive data across three affected release lines (4.2.0-4.2.7, 4.3.0-4.3.4, 5.0.0-5.0.3), resulting in low-impact information disclosure. The vulnerability is constrained by a high-privilege, high-complexity, user-interaction-required exploitation profile (CVSS 3.1), making it a low-priority issue for most organizations. No public exploit code exists and the vulnerability has not been added to the CISA KEV catalog; the primary risk is credential or token leakage through application log aggregators accessible to operators or compromised log pipelines.

Spring Cloud Function's AWS adapter component may inadvertently write sensitive data to application logs, creating an information disclosure exposure across a wide range of maintained version branches (3.x through 5.x). The CVSS score of 3.1 reflects genuinely low severity - exploitation requires high privileges and high attack complexity - but the risk in regulated or multi-tenant environments is elevated if log stores are accessible to unauthorized parties or if sensitive data (credentials, payloads, tokens) persists in cloud-native logging services such as AWS CloudWatch. No public exploit code exists and no active exploitation has been identified at time of analysis.

Spring Cloud Function's composition lookup mechanism can be abused by a highly privileged attacker to poison the base function, potentially degrading the integrity and confidentiality of function execution across versions 3.2.16 and earlier through 5.0.3. The vendor-assigned CVSS base score of 3.1 reflects severely constrained exploitation prerequisites - high privilege level, high attack complexity, and required user interaction - substantially limiting realistic exposure. No public exploit code has been identified, and the vulnerability does not appear in the CISA KEV catalog at time of analysis.

HTTP header filtering deficiency in Spring Cloud Function versions 5.0.0-5.0.3, 4.3.0-4.3.4, 4.2.0-4.2.7, and 3.2.16 and earlier allows network-accessible authenticated attackers - under high-complexity conditions and requiring user interaction - to achieve limited confidentiality and integrity impacts via crafted HTTP headers. Reported by VMware, the flaw scores 3.1 (Low) under CVSS 3.1, with multiple compounding prerequisites that substantially restrict real-world exploitability. No public exploit code and no CISA KEV listing have been identified at time of analysis.

Spring Cloud Function's ServerlessHttpServletRequest.isSecure() method returns an unchecked result that does not reflect the actual HTTP transport scheme, enabling applications that gate security decisions on this call to behave incorrectly. Affected versions span three active release lines: 5.0.0-5.0.3, 4.3.0-4.3.4, and 4.2.0-4.2.7. No public exploit code exists and the vulnerability is not listed in CISA KEV; the vendor-assigned CVSS of 3.1 (Low) reflects constrained exploitation prerequisites including high privilege and user interaction.

Path traversal in Spring AI's ResourceCacheService allows an authenticated low-privileged network attacker to write files outside the intended cache directory. The getCacheName() method appends URI fragments verbatim - including '../' sequences and path separators - to a base directory path before passing the result to new File(resourceParentFolder, newFileName) and writing downloaded bytes there. Affected versions span Spring AI 1.0.9 and earlier, 1.1.0 through 1.1.8, and 2.0.0; no public exploit or CISA KEV listing has been identified at time of analysis.

Spring Integration's jCIFS-based SMB client silently negotiates down to legacy SMB1/CIFS when applications omit an explicit `smbMinVersion` setting, exposing file transfer sessions to NTLM relay attacks and in-transit content tampering by a network-positioned adversary. Affected versions span Spring Integration 6.4.0-6.4.12, 6.5.0-6.5.10, 7.0.0-7.0.5, and the standalone release 7.1.0 - covering all currently active Spring Integration release trains at time of disclosure. No CISA KEV listing or public exploit code specific to this CVE has been identified at time of analysis, though NTLM relay is a mature, extensively tooled attack class; EPSS data was not available in the sourced intelligence.

Spring Integration's default file-based metadata store writes persistent state to a world-readable file under java.io.tmpdir, exposing integration metadata to any local OS user on the affected host. All actively maintained branches are affected, spanning versions 5.5.21 and earlier through 7.1.0. No public exploit code or active exploitation has been identified at time of analysis; practical impact is limited to local confidentiality disclosure on shared or multi-user systems.

Spring Cloud Function versions across three actively maintained release lines (4.2.x, 4.3.x, and 5.0.x) are affected by a potential arbitrary file read and SSRF vulnerability reported by VMware. The vendor-assigned CVSS 3.1 score of 2.0 reflects severe constraints on exploitability - high privilege requirements (PR:H), required user interaction (UI:R), and high attack complexity (AC:H) together make opportunistic or unauthenticated exploitation implausible. No public exploit code exists and the vulnerability has not been added to the CISA KEV catalog at time of analysis.

Spring for GraphQL's Spring Data pagination support resolves arguments of a scrollable query and forwards the client-supplied values to the underlying repository. An attacker can forge a malicious query for a Connection field that can exhaust application memory or place significant, prolonged load on the underlying datastore, resulting in a Denial of Service. Spring for GraphQL 2.0.0 - 2.0.4 Spring for GraphQL 1.4.0 - 1.4.6 Spring for GraphQL 1.2.0 - 1.3.9

The GraphiQL page bundled with Spring for GraphQL sends requests to the GraphQL endpoints of the application. An attacker can share a malicious URL so that the victim's browser might leak confidential information to the attacker's website. Spring for GraphQL 2.0.0 - 2.0.4 Spring for GraphQL 1.4.0 - 1.4.6 Spring for GraphQL 1.1.0 - 1.3.9 Spring for GraphQL 1.0.0 - 1.0.7

Spring for GraphQL is vulnerable to Denial of Service attacks when using the WebSocket client with keepAlive enabled. Spring for GraphQL 2.0.0 - 2.0.4 Spring for GraphQL 1.4.0 - 1.4.6 Spring for GraphQL 1.3.0 - 1.3.9

The GraphiQL page bundled with Spring for GraphQL loads JavaScript libraries from a public CDN, without Subresource Integrity checks. An attacker can inject malicious code in those scripts and execute arbitrary code on the browser loading the GraphiQL page. Spring for GraphQL 2.0.0 - 2.0.4 Spring for GraphQL 1.4.0 - 1.4.6 Spring for GraphQL 1.1.0 - 1.3.9 Spring for GraphQL 1.0.0 - 1.0.7

Spring for GraphQL applications are vulnerable to Unsafe Deserialization when processing paginated GraphQL queries. Spring for GraphQL 2.0.0 - 2.0.4

Unrestricted property key injection via Spring Cloud Commons' writable /actuator/env endpoint allows authenticated administrators to POST arbitrary environment properties with no allow-list enforcement, affecting all currently maintained release lines (3.1.10 and earlier through 5.0.2). With CVSS PR:H and a scope change (S:C), exploitation requires admin-level access to the actuator endpoint but can cascade integrity impacts across the entire Spring application context. No public exploit has been identified at time of analysis, and exploitation is gated on a non-default configuration requiring deliberate enablement of write access to the actuator endpoint.

Safety-guard bypass in the Spring Framework SpEL engine (VMware/Broadcom) lets attacker-controlled expression input escape the restricted SimpleEvaluationContext sandbox when the SpEL bytecode compiler is active, affecting Spring Framework 5.2.x through 7.0.8 across the 5.3, 6.0, 6.1, 6.2 and 7.0 lines. Because SimpleEvaluationContext is the API applications are told to use to safely evaluate untrusted expressions, this bypass can escalate a data-binding-only context into broader method invocation with high integrity and availability impact (CVSS 9.1, CWE-913). There is no public exploit identified at time of analysis, and EPSS is low (0.16%, 5th percentile), indicating no observed mass exploitation yet.

Denial of Service exposure in Spring Framework's data binding infrastructure allows unauthenticated remote attackers to exhaust application resources by submitting crafted property path expressions to any endpoint that binds user-supplied paths onto Java target objects. Affected versions span the entire actively maintained Spring Framework lineage - 5.2.x through 7.0.x - making the aggregate exposure footprint very large. No public exploit is referenced and EPSS sits at 0.15% (4th percentile), indicating low current exploitation activity despite the high CVSS score of 7.5.

Reflected XSS in Spring Framework's MVC and WebFlux data-binding error rendering exposes users of vulnerable applications to arbitrary HTML and JavaScript injection. All active Spring Framework release trains are affected - versions 5.2.x through 7.0.8 - making the exposure surface extremely broad across enterprise Java deployments. An unauthenticated attacker (per CVSS PR:N) can craft a malicious URL containing injected script payloads that, when a victim clicks it, execute in the victim's browser context via reflected field-error output. No public exploit code has been identified and EPSS sits at 0.17% (7th percentile), indicating limited observed exploitation activity at time of analysis.

Spring Security 7.1.0's InetAddressMatchers utility contains a flaw in its IP address classification logic - the matchInternal() and matchExternal() builders may incorrectly categorize certain IP addresses as belonging to internal or external networks, enabling unauthenticated remote attackers to bypass IP-based access controls under high-complexity conditions. Applications that rely on InetAddressMatchers to enforce network-level access restrictions are exposed to limited information disclosure where restricted endpoints or data may become accessible to external parties. No public exploit code exists and no CISA KEV listing is present, indicating no confirmed active exploitation at time of analysis.

Timing side-channel exposure in Spring Security allows remote unauthenticated attackers to progressively infer security-sensitive string values - such as CSRF tokens, bearer tokens, or other secrets compared at the application layer - by statistically measuring the time differential between rejection responses. Multiple active Spring Security release trains are affected, spanning versions 5.7.x through 7.1.x, representing a broad swath of production Spring-based Java applications. No public exploit code has been identified at time of analysis, and CISA KEV status is absent; however, the confidentiality impact is rated High in the CVSS vector, reflecting that successful exploitation could fully compromise protected secrets under favorable network conditions.

Incomplete NAT64 prefix filtering in CC: Tweaked prior to 1.120.0 allows any Lua-capable Minecraft player on a dual-stack server to bypass SSRF protections and reach loopback, RFC 1918, cloud metadata, or internal API endpoints. The flaw resides in AddressPredicate.java, which correctly blocks the RFC 6052 Well-Known NAT64 prefix (64:ff9b::/96) but omits the RFC 8215 Local-Use prefix (64:ff9b:1::/48), enabling requests via http.request or http.websocket to mapped internal IPv4 addresses. No public exploit code has been identified and this vulnerability is not listed in the CISA KEV catalog; exploitation requires a non-default dual-stack NAT64 deployment.

Path traversal in Spring Framework's FreeMarker integration allows authenticated remote attackers to read arbitrary files from the server's template path when a controller passes user-controlled input directly as a view name. Affected versions span every maintained Spring Framework branch from 5.2.x through 7.0.8, making the exposure broad in the Java ecosystem. No public exploit code or active exploitation has been identified; CISA's SSVC assessment rates technical impact as partial and the vulnerability as non-automatable, consistent with the configuration dependency required to trigger it.

TLS certificate validation is absent by default in Spring AMQP's Log4j2 appender when shipping log events to a RabbitMQ broker, leaving all log traffic fully exposed to man-in-the-middle interception. Spring AMQP versions 2.4.18 and earlier, 3.2.0-3.2.12, 4.0.0-4.0.4, and 4.1.0 are affected when the Log4j2 appender is used with its documented default configuration. No public exploit has been identified at time of analysis, but the high confidentiality and integrity CVSS impact reflects that intercepted log streams may contain API keys, session tokens, and other sensitive application data.

Open redirect in Spring Authorization Server 1.5.0-1.5.7 allows remote unauthenticated attackers to redirect victims to attacker-controlled sites by crafting authorization requests that pair an invalid request_uri with an unvalidated redirect_uri. The CVSS scope change (S:C) reflects that the redirect escapes the authorization server's security boundary, enabling high-trust phishing attacks because victims see the legitimate authorization server domain before being redirected. No public exploit has been identified at time of analysis, and exploitation requires user interaction.

Client-metadata injection in Spring Security's OAuth2 Authorization Server module (7.0.0 through 7.0.4) lets an attacker holding a valid Initial Access Token register a malicious OAuth2 client whose insufficiently validated metadata can yield Stored XSS, Privilege Escalation, or SSRF. Exploitation requires that the optional Dynamic Client Registration (DCR) endpoint be explicitly enabled, and the concrete impact depends on how the server later renders or consumes the stored metadata. There is no public exploit identified at time of analysis and it is not listed in CISA KEV, but the vendor-rated CVSS of 9.6 reflects a scope-changing, high-confidentiality/high-integrity outcome.

Header type injection in Spring for Apache Kafka's default mapper configuration allows any Kafka producer with access to a consumed topic to inject java.net.InetAddress objects through the spring_json_header_types message header, triggering DNS resolution on the consumer host. All applications using @KafkaListener with the default JsonKafkaHeaderMapper or DefaultKafkaHeaderMapper - spanning versions 2.8.x through 4.1.0 - are affected without any non-default configuration required. No public exploit code has been identified at time of analysis, and the CVE is not listed in CISA KEV.

Denial-of-service in Spring AMQP across multiple supported release lines allows a privileged AMQP publisher to force a System.exit(99) call inside the consumer JVM, killing the entire process rather than isolating the failure to the listener thread. Affected versions span the 2.4.x, 3.2.x, 4.0.x, and 4.1.0 release trains, covering a wide swath of actively maintained Spring deployments. No public exploit code or CISA KEV listing has been identified at time of analysis, but the total, immediate JVM termination and the collateral impact on every co-located workload make this operationally significant in RabbitMQ-integrated Spring environments.

Spring Integration's UnZipTransformer component fails to impose any limit on decompressed entry size or entry count, enabling a low-privileged remote attacker to trigger JVM heap exhaustion via a crafted zip bomb archive. Affected versions span 6.4.0-6.4.12, 6.5.0-6.5.10, and 7.0.0-7.1.0 across the widely-used Spring enterprise Java framework. The attack primitive is well-understood and trivially constructable, though exploitation requires access to an integration endpoint that routes payloads through UnZipTransformer; no public exploit code has been identified at time of analysis and this CVE is not listed in the CISA KEV catalog.

Cleartext credential exposure in Spring AMQP affects applications that use the RabbitMQ management aliveness check: when that check fails at runtime, the configured admin password is embedded verbatim in the thrown Java exception message, making it visible to anyone with access to exception output. The vulnerability spans multiple major release lines - 2.4.x, 3.2.x, and 4.0.x through 4.1.0 - and was reported by security@vmware.com, the Spring Security team. No public exploit code has been identified at time of analysis and CISA KEV status is unconfirmed, but a successful credential leak would yield full RabbitMQ administrative control.

Credential and network exposure in Spring Security's embedded UnboundID LDAP server (UnboundIdContainer) lets remote attackers reach an LDAP listener that is bound to all interfaces (0.0.0.0) and authenticate with an administrative credential that the container registers unconditionally. Any application across the affected 5.7.x through 7.1.0 lines that instantiates UnboundIdContainer exposes full read/write control over the embedded directory to the network. No public exploit identified at time of analysis and the issue is not in CISA KEV, but the CVSS 9.4 rating reflects that no attacker skill or authentication barrier stands in the way once the listener is reachable.

Path traversal in Spring Cloud Config Server's native environment repository allows high-privileged authenticated users to read configuration files outside the designated repository root. All active Spring Cloud Config release lines are affected - 3.1.x through 5.0.x - when the native filesystem backend is in use. The exposure is strictly confidentiality-based: an admin-level attacker can retrieve arbitrary files readable by the server process but cannot modify data or disrupt service. No public exploit code or CISA KEV listing has been identified at time of analysis.

Spring WebFlux applications that enable WebSocket connections leak request headers - potentially containing Authorization tokens, session cookies, or API keys - through exception reason messages exposed over the WebSocket channel. All maintained Spring Framework release trains from 5.2.x through 7.0.x are affected, covering the vast majority of actively deployed Spring reactive applications. The vulnerability is classified as information disclosure (CWE-209), and while the CVSS score is 7.5, the EPSS score of 0.14% (4th percentile) indicates very low observed exploitation probability; no public exploit or CISA KEV listing exists at time of analysis.

Authorization bypass in Spring Framework WebFlux functional-endpoint applications deployed on DispatcherServlet allows an attacker to defeat header-based route predicates by sending a CORS pre-flight (OPTIONS) request, reaching routes that should have been gated by header conditions. It affects Spring Framework 5.2.5-5.2.25, 5.3.0-5.3.49, 6.0.0-6.0.30, 6.1.0-6.1.28, 6.2.0-6.2.19, and 7.0.0-7.0.8 in the specific WebFlux-functional-plus-DispatcherServlet deployment mode. No public exploit identified at time of analysis, and EPSS exploitation probability is low (0.19%, 9th percentile).

Denial of service in Spring Framework WebFlux applications (5.2.25.RELEASE and earlier, 5.3.0-5.3.49, 6.0.0-6.0.30, 6.1.0-6.1.28, 6.2.0-6.2.19, 7.0.0-7.0.8) occurs when the Aalto XML processor is used to parse request bodies, because the maxInMemorySize buffering limit is not correctly enforced. Remote attackers can submit oversized XML to trigger unbounded in-memory buffering and exhaust heap memory. No public exploit identified at time of analysis; EPSS is low (0.14%, 4th percentile) and CISA SSVC lists exploitation status as none, though it rates the flaw automatable with total technical impact.

Cross-response information disclosure and stream corruption affects Spring Framework 6.2.0-6.2.19 and 7.0.0-7.0.8 (both MVC and WebFlux) when applications serve Server-Sent Events (SSE) together with view fragments, letting remote attackers corrupt the event stream and potentially bleed data across responses. No public exploit is identified at time of analysis and CISA has not listed the flaw in KEV; EPSS is low at 0.15% (5th percentile). The vendor-assigned 9.8 rating sits uneasily against the CWE-93 root cause, the 'Information Disclosure' tagging, and the SSVC 'exploitation: none' status, suggesting the paper severity outruns observed real-world risk.

WebFlux applications in Spring Framework running on the Jetty 12 Core reactive adapter omit the SameSite cookie attribute from serialized response cookies, exposing session and authentication cookies to cross-site request contexts. Affected versions span Spring Framework 6.2.0-6.2.19 and 7.0.0-7.0.8, covering a substantial footprint of reactive Java deployments on Jetty 12. The vulnerability carries a vendor CVSS of 7.5 with C:H reflecting potential session-token disclosure; no public exploit code or active exploitation (CISA KEV) has been identified, and EPSS places exploitation probability at 0.14% (4th percentile).

Memory exhaustion in Spring Framework's RSocket server implementation allows unauthenticated remote attackers to crash or degrade affected applications by sending malformed SETUP frames that trigger unreclaimed heap allocations. All actively maintained Spring Framework branches are affected - 5.2.x through 7.0.x - with the condition that the application must explicitly expose an RSocket endpoint. No public exploit code has been identified at time of analysis, and CISA SSVC confirms no current exploitation activity, though the attack is classified as automatable.

Open redirect in Spring Framework's UrlFileNameViewController exposes users of affected Spring MVC applications to phishing and credential-harvesting attacks across all active Spring Framework release trains (5.2.x through 7.0.x). The flaw allows an unauthenticated attacker to craft a URL that causes the vulnerable application to redirect victims to an arbitrary external domain, exploiting the controller's path-to-view-name resolution when end-of-path mapping is used without a configured prefix. No active exploitation has been confirmed - EPSS sits at 0.14% (4th percentile) and CISA SSVC reports exploitation status as none, making this a targeted patching priority rather than an emergency.

Uncontrolled resource consumption in Spring Framework's SpEL evaluator allows unauthenticated remote attackers to trigger a Denial of Service by submitting expressions using the power operator (^) with BigDecimal or BigInteger operands and arbitrarily large exponents, causing unbounded CPU and memory exhaustion in the JVM. All maintained Spring Framework release lines from 5.2.x through 7.0.x are affected, covering a large portion of the enterprise Java ecosystem. No public exploit has been identified and exploitation probability is very low (EPSS 0.15%, 4th percentile), though SSVC flags the attack class as automatable.

Spring WebFlux's PartEventHttpMessageReader fails to enforce the configured maxPartSize limit when maxInMemorySize is explicitly set to -1, allowing remote unauthenticated attackers to upload multipart request parts of arbitrary size in violation of application-defined policy. Affected are Spring Framework 6.1.0 through 6.1.28, 6.2.0 through 6.2.19, and 7.0.0 through 7.0.8. No public exploit code has been identified at time of analysis and EPSS is very low at 0.15% (4th percentile), but the SSVC automatable flag means scanning and exploitation can be automated at scale against exposed endpoints.

Server-side request forgery and remote code execution affect the Spring Framework's XsltView component across the 5.2.x through 7.0.x branches (5.2.25.RELEASE and earlier, 5.3.0-5.3.49, 6.0.0-6.0.30, 6.1.0-6.1.28, 6.2.0-6.2.19, and 7.0.0-7.0.8). When a Spring MVC application maps '/**' to view rendering and does not explicitly set a view name, an attacker can steer view resolution to XsltView and supply a path that triggers outbound requests and code execution. There is no public exploit identified at time of analysis, and the EPSS probability is low (0.16%), but SSVC rates the technical impact as total and automatable.

Open redirect in Spring Framework's UrlHandlerFilter allows unauthenticated remote attackers to silently redirect authenticated users to attacker-controlled URLs. Affected are Spring Framework 7.0.0-7.0.8 and 6.2.0-6.2.19 in both Spring MVC and Spring WebFlux deployments where UrlHandlerFilter is configured with broadly matching URL patterns. No public exploit code exists and SSVC indicates no known active exploitation; however, the no-privilege, network-reachable attack vector makes this a credible phishing enabler in affected applications. EPSS sits at 0.15% (5th percentile), consistent with low-automated-exploitation likelihood.

Excessive resource consumption in Spring Batch's FlatFileItemReader allows a denial-of-service condition when processing specially crafted input files containing embedded newlines within quoted fields. Affected versions span three release trains: 4.3.x through 4.3.13, 5.2.x through 5.2.6, and 6.0.x through 6.0.4. An attacker who can supply malformed input to a batch job using multi-line record parsing can cause the job to stall indefinitely or exhaust JVM heap memory, effectively disabling batch processing pipelines. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis; the CVSS AC:H rating reflects the access prerequisite of controlling batch input.

Spring Integration JMS inbound components copy inbound JMS message properties verbatim into Spring MessageHeaders without filtering reserved internal header names, enabling any authorized JMS producer to inject routing and type-resolution headers. All supported release lines are affected - from 5.5.21 and earlier through the current 7.1.0 - making this a broad exposure across enterprise Java integration deployments. No public exploit has been identified at time of analysis; however, injection of the json__TypeId__ header may interact with Jackson polymorphic deserialization if enabled, potentially elevating practical impact beyond the assigned CVSS 5.4 Medium.

Spring Cloud Gateway's JsonToGrpcGatewayFilterFactory permits an authenticated administrator to supply arbitrary Spring Resource location strings when defining the proto descriptor file. The gateway subsequently resolves these locations without restriction, enabling access to sensitive internal file paths, classpath resources, or remote endpoints via SSRF-like traversal - effectively granting the admin-level attacker read and potential integrity impact on systems beyond the gateway's own scope. No public exploit code or CISA KEV listing exists at time of analysis, but the scope-changed CVSS vector (S:C with C:H/I:H) and the breadth of affected version lines (3.x through 5.x) make this a meaningful risk in enterprise Spring microservice architectures.

Unsafe Java deserialization in Spring Batch's DefaultExecutionContextSerializer exposes JDBC-backed job repositories to potential gadget-chain attacks across Spring Batch 5.2.6 and earlier and 6.0.0-6.0.4. Base64-decoded bytes are fed directly to ObjectInputStream.readObject() without an ObjectInputFilter type allowlist, meaning any class resolvable from the JVM classpath can be instantiated during deserialization. An attacker able to influence data written to the job repository could leverage available gadget chains to achieve remote code execution. No public exploit has been identified at time of analysis, and the CVE is not listed in CISA KEV.

Reflected cross-site scripting (XSS) in Spring Security's built-in OAuth2 Authorization Server consent page allows an unauthenticated remote attacker to execute arbitrary JavaScript in a victim's browser by delivering a crafted authorization request URL. Affected versions include Spring Security 7.1.0 and 7.0.0 through 7.0.6; the consent page reflects user-controlled values (such as client name or scope parameters) directly into the HTML response without encoding. No public exploit has been identified at time of analysis, and this CVE does not appear in the CISA KEV catalog, but the changed-scope CVSS vector reflects the elevated risk of token and session theft in OAuth2 flows.

Arbitrary code execution via Jackson deserialization affects Spring Batch 5.2.0-5.2.6 and 6.0.0-6.0.4 when applications use Jackson2ExecutionContextStringSerializer and read job execution contexts from an untrusted data source. The JobParameterDeserializer's failure to enforce Jackson's trusted-types allowlist exposes the application to well-known Jackson polymorphic deserialization gadget chains, which can yield full remote code execution on the batch server. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog, though the exploitation technique leverages established RCE primitives broadly understood by attackers targeting Java environments.

Unsafe Java deserialization in Spring Integration's SerializingHttpMessageConverter exposes applications to remote code execution via crafted HTTP requests bearing Content-Type: application/x-java-serialized-object. The converter passes the request body directly to a raw java.io.ObjectInputStream.readObject() call with no ObjectInputFilter or class allowlist, meaning any Serializable object - including known gadget-chain payloads - is fully deserialized. Exploitation is conditional on the presence of a compatible gadget library (e.g., Apache Commons Collections) on the classpath, but that condition is frequently met in enterprise Java deployments; no public exploit has been identified at time of analysis and CISA KEV status is not confirmed.

Spring Data REST fails to protect entity identifier (@Id) and optimistic-locking version (@Version) fields from mutation through RFC 6902 JSON Patch (application/json-patch+json) PATCH requests, allowing authenticated low-privilege network attackers to overwrite primary keys and version counters on exposed JPA entities. Affected versions span the full 3.x lineage through 5.1.0, representing a broad swath of the Spring ecosystem. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.

Spring Integration's UDP inbound adapter can be abused by unauthenticated remote attackers to coerce the server into emitting outbound UDP datagrams to arbitrary hosts and ports - a classic UDP Server-Side Request Forgery (SSRF). Affected versions span the entire supported line from 5.5.x through 7.1.0, covering a wide range of enterprise Java deployments. No public exploit code or active exploitation has been identified at time of analysis, but the low attack complexity (single crafted UDP packet) makes this straightforward to weaponize once the adapter port is located.

Path traversal in Spring Integration's ZipTransformer allows a low-privileged attacker who controls the file_name message header to write ZIP archive output to arbitrary filesystem paths outside the configured workDirectory. Affected versions span the 6.4.x, 6.5.x, 7.0.x, and 7.1.0 release lines of Spring Integration, and exploitation is viable by default since ZipResultType.FILE is the standard configuration. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Spring AMQP's optional message decompression feature allows any principal with queue publish access to crash the consumer JVM by sending a single crafted ~1 MB compressed message. Affected versions span the 2.4.x, 3.2.x, 4.0.x, and 4.1.0 release lines, making this a broad supply-chain concern for Spring-based Java messaging infrastructure. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog, but the low attack complexity and high availability impact warrant prompt remediation in any environment where queue publish access is shared or externally reachable.

Uncontrolled memory allocation in Spring Integration's RFC6587SyslogDeserializer allows any network-reachable, low-privileged syslog sender to supply an arbitrarily large octet count, causing the TCP inbound adapter to allocate an unbounded byte array and potentially read across RFC 6587 message frame boundaries. Affected release lines span 5.5.x through 7.1.0. No public exploit code has been identified and the vulnerability is absent from CISA KEV, but the low attack complexity and low privilege requirement make exploitation straightforward for any entity permitted to deliver syslog messages to the adapter.

Unsafe deserialization in Spring Integration exposes network-accessible, low-privilege attackers to arbitrary Java class instantiation by manipulating the json__TypeId__ message header, which is resolved via ClassUtils.forName without any type or package allowlist. All maintained Spring Integration branches are affected - 5.5.21 and earlier, 6.4.0-6.4.12, 6.5.0-6.5.10, 7.0.0-7.0.5, and 7.1.0 - making the exposure broad across the Spring ecosystem. No public exploit code or CISA KEV listing has been identified at time of analysis, though the deserialization-via-header-controlled-type pattern is a well-understood Java attack class with a mature exploit toolkit.

Predictable ONNX model cache path creation in Spring AI enables a local attacker on a shared multi-user host to pre-create the cache location and substitute a malicious ONNX model before the application writes its legitimate copy. Affected versions span Spring AI 1.0.0-1.0.9, 1.1.0-1.1.8, and 2.0.0. No public exploit code or CISA KEV listing has been identified at time of analysis; critically, the supplied CVSS vector (AV:N/PR:N) is materially inconsistent with the description's local-access requirement, meaning the raw score of 7.5 substantially overstates the realistic attack surface.

Denial of service in Spring AI's PDF document ingestion crashes the processing thread when parsing a crafted PDF with a deeply nested or cyclic table of contents structure. Affected versions span the 1.0.x and 1.1.x release lines as well as the 2.0.0 release. An unauthenticated remote attacker who can supply a malicious PDF to an application's ingestion pipeline can trigger a StackOverflowError, halting document processing availability with no confidentiality or integrity impact. No public exploit code or CISA KEV listing has been identified at time of analysis.

Spring Data REST's HTTP PUT handler silently drops the persisted `@Version` field when writing immutable aggregate root types, bypassing the framework's optimistic locking mechanism. Affected release trains span versions 3.x through 5.1.0, covering a broad surface of Spring-based enterprise REST APIs that use versioned immutable entities. An authenticated low-privilege attacker can exploit this to perform lost-update attacks - overwriting entity state without triggering concurrency conflict detection - undermining data integrity guarantees in concurrent-write environments. No public exploit code exists and the vulnerability is not listed in CISA KEV at time of analysis.

Denial-of-service and minor integrity impact in Oracle Java SE 7u511 allows unauthenticated remote attackers to crash or hang the JVM via the 2D graphics rendering component, exploitable across multiple network protocols with no authentication or user interaction required. The attack surface is broadened by the component's exposure through APIs consumed by web services, sandboxed Java Web Start applications, and sandboxed Java applets loading untrusted code. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog at time of analysis, though the low exploitation complexity means automated scanning is feasible.