GHSA-wr93-w764-3636
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach WS-Policy parsing endpoint
-
DeliverySubmit deeply nested policy document
-
ExploitBypass nesting-depth limit
-
ExecutionTrigger uncontrolled recursion
-
PersistExhaust thread stack (StackOverflowError)
-
ImpactCrash parser, deny service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Exploitation requires that the target application actually parse an attacker-supplied WS-Policy document with Apache Neethi before 3.2.4 - typically a SOAP/WS-* service built on Apache Axis2 or CXF that accepts and processes client- or peer-provided policy assertions. The single crafted input is a policy document whose element nesting exceeds Neethi's depth guard, which the flaw allows to slip past into unbounded recursion. No authentication, no user interaction, and no non-default toggle is named in the advisory (AV:N/AC:L/PR:N/UI:N), so against a service that reaches Neethi's policy parser with untrusted input it is remotely reachable; the practical limiting factor is that many deployments only parse trusted, locally-configured policy, which removes the untrusted-input path entirely. |
| Impact | All available signals are consistent and point to a genuine but availability-only risk. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 HIGH) indicates a remote, unauthenticated, low-complexity attack with no confidentiality or integrity impact - pure denial of service, which matches CWE-674 (Uncontrolled Recursion) and the description of a thread-stack exhaustion parser crash. No EPSS score, no CISA KEV listing, and no public POC were provided, so there is no evidence of active exploitation or weaponization; the elevated 7.5 is driven entirely by the unauthenticated network reach, not by breadth of impact. This is a real patch-worthy defect for anyone parsing untrusted WS-Policy documents, but it is not a top-tier emergency: a single crashed parser thread/process is recoverable, there is no data exposure, and real exposure is gated on whether the deploying application actually feeds attacker-supplied policy documents to Neethi. No signals conflict; the main missing datum is exploitation telemetry (EPSS/KEV/POC all absent), so ranking should lean on deployment exposure rather than exploitation likelihood. |
| Exploit ScenarioDerived | An attacker sends a specially crafted WS-Policy document with policy elements nested far deeper than Neethi's intended limit to a SOAP/WS-* endpoint (e.g. an Apache Axis2 or CXF service) that parses client-supplied policy. The malformed nesting bypasses the depth guard and drives unbounded recursion until the thread stack overflows, crashing the parser and denying service. No authentication or user interaction is required and no public exploit code is currently identified. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Sep 21, 2026
Stack exhaustion in Apache Neethi before 3.2.4 lets an unauthenticated remote attacker crash the WS-Policy parser by supplying a policy document whose element nesting is deep enough to slip past Neethi's nesting-depth guard and drive unbounded recursion until the thread stack is exhausted. Per the CVSS vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) the impact is availability-only: no confidentiality or integrity loss, but a successful parse failure can take down the parser thread and potentially the hosting SOAP endpoint. The practical reachability condition is that the target application must actually hand attacker-controlled WS-Policy content to Neethi - typical of Apache Axis2 or CXF-based WS-* services that accept client- or peer-supplied policy - whereas deployments that only parse locally configured, trusted policy are not exposed; no public exploit code was identified at time of analysis and neither CISA KEV nor EPSS data accompanies this record.
Earlier versions of this analysis (1)
Stack-exhaustion denial of service in Apache Neethi (org.apache.neethi:neethi) before version 3.2.4 allows unauthenticated remote attackers to crash a WS-Policy parser by supplying a crafted policy document containing deeply nested policy elements that bypass Neethi's nesting-depth limit and trigger uncontrolled recursion until the thread stack is exhausted. The flaw is availability-only (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H - no confidentiality or integrity impact), and exposure is limited to Java WS-* stacks that feed attacker-controlled policy into Neethi, such as Apache CXF, Axis2, or WSS4J-based services accepting inbound WSDL, policy attachments, or message content from untrusted parties; deployments that parse only trusted local policy configuration are not reachable through this vector. No CISA KEV listing and no EPSS data were supplied, and no public exploit identified at time of analysis; vendor-released patch 3.2.4 fixes the issue.
RemediationAI
Vendor-released patch: upgrade Apache Neethi to 3.2.4, which is the version the advisory states fixes the nesting-depth bypass; because Neethi typically arrives as a transitive dependency, most teams must pin it explicitly (for example via Maven dependencyManagement for org.apache.neethi:neethi at 3.2.4) and then rebuild and retest the dependent Axis2, Rampart or CXF application rather than waiting for a container upgrade. Where an immediate upgrade is not possible, apply compensating controls at the point where untrusted XML enters the service: enforce a maximum document size and an element-nesting/element-count cap in the XML parser in front of Neethi (hardened parser limits plus a pre-parse depth check), or reject oversized or excessively nested WS-Policy payloads at the API gateway or WAF - the trade-off is that legitimate but deeply structured policies may be rejected, so the threshold must be set from the deepest nesting your real policies exhibit, and gateway-only filtering does not protect internal peer-to-peer policy exchange paths. Disabling WS-Policy processing entirely where it is not required (removing the relevant policy module/engagement from Axis2 or CXF) closes the path completely but breaks any WS-Security/WS-ReliableMessaging negotiation that depends on policy. Increasing JVM thread stack size or adding a recursion/depth limit via an interceptor is not a fix and should be treated only as a short-term hardening measure that raises the threshold rather than eliminating it; consult the Apache WS-Policy advisories at https://ws.apache.org/, https://lists.apache.org/thread/72kxj71lvrqqx90xxqqctvpbw0t8mpxw and https://seclists.org/oss-sec/2026/q3/829 for vendor guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Apache Neethi is the standalone WS-Policy implementation (the WS-Policy/WS-PolicyAttachment object model and normalizer) used as a library by Apache WS-* stacks such as Axis2, Rampart and CXF to read, merge and normalize policy assertions. The root cause is CWE-674 (Uncontrolled Recursion): the parser walks nested policy elements recursively, and the existing nesting-depth limit is not enforced in a way that covers all documents, so a crafted WS-Policy document with deeply nested policy elements is processed past the intended guard and consumes stack frames until a StackOverflowError terminates the parser thread. Because Neethi is an embedded Java library rather than a network service, the vulnerability is not directly remotely exploitable - exposure exists only where a host application (for example a SOAP/WS-* endpoint that ingests policy documents from clients or federation peers) reaches Neethi's policy parsing code with untrusted input. No CPE identifiers were supplied with this record; the EUVD-provided affected range is Apache Neethi 0 through versions earlier than 3.2.4, and the assigned vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H confirms a network-vector, low-complexity, unauthenticated, no-user-interaction issue whose sole impact is high availability loss.
Know when Neethi gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Remote unauthenticated crafted-document parsing with no auth or interaction (AV:N/AC:L/PR:N/UI:N); impact is a parser crash only, so C:N/I:N/A:H, scope unchanged.
Primary rating from Vendor (CNA).
CVSS VectorVendor
Lifecycle Timeline
4Description PRE-NVD
Articles & Coverage 2
Executive ViewAI
Apache Neethi, the WS-Policy engine embedded in many Java SOAP stacks including Axis2 and CXF, can be driven into a thread-stack exhaustion crash by a single crafted policy document, and a vendor fix is already available in version 3.2.4. The exposure is availability-only and is limited to services that actually accept policy content from clients or peers, so internet-facing or partner-facing WS-* endpoints built on these frameworks are the primary concern, while services that only process locally configured policy are largely unaffected. Leadership should care because a successful attack can take down SOAP endpoints that business partners and internal systems depend on, and the remediation is a low-cost dependency upgrade.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Denial of service in Apache Neethi before 3.2.4 allows unauthenticated remote attackers to exhaust server CPU and memory
Heap exhaustion in Apache Neethi versions before 3.2.4 lets unauthenticated remote attackers exhaust server memory by su
Denial of service in Apache Neethi before 3.2.4 lets unauthenticated remote attackers pin CPU for extended periods by su
Denial of service in Apache Neethi (org.apache.neethi:neethi) before 3.2.4 allows a malicious or compromised remote poli
EUVD-2026-83885
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB