Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach Axis 1.x SOAP endpoint
-
DeliverySend SOAP Fault with detail/exceptionName
-
ExploitAxis loads named classpath class
-
ExecutionStatic initializer / String constructor runs
-
ImpactGadget triggers code execution
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V15 - Secure Coding and Architecture Reflection safety, class allowlisting
|
| Exploitation Conditions | No authentication is required: the CVSS vector is PR:N and the vendor confirms the fault is parsed while the engine resolves the target service, before any per-service authentication handler chain runs, so service-level auth handlers do NOT protect against it. The concrete prerequisite for full code execution is that a usable 'gadget' class - one whose static initializer or single-String constructor performs exploitable actions - must already be present on the Axis application's classpath; mere class loading always runs the named class's static initializer, while the String-constructor path additionally requires a String <data> element in the fault. Limiting factors: the attack surface requires the Axis 1.x engine to parse an attacker-influenced inbound SOAP fault, and the impact ceiling is governed by what classes the deployment ships, so environments without a suitable gadget may see class loading/static-init side effects but not reliable RCE. Applies to all Apache Axis 1.x versions through 1.4 (EOL); only a source-code patch is available. |
| Impact | Signals conflict and should be weighed carefully. CVSS is 9.8 with vector AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H, and the mechanism is confirmed by the vendor commit diff: an inbound SOAP <Fault> carrying <detail><exceptionName> causes Axis to load an attacker-named class (running its static initializer) and, when a String <data> element is present, instantiate it via its String constructor before any AxisFault type check or per-service authentication handler runs - a genuine unauthenticated, pre-auth remote primitive (CWE-470, unsafe reflection). Against that high severity, the real-world exploitation signals are modest: EPSS is only 0.57% (47th percentile), the vulnerability is NOT in CISA KEV, no public exploit or PoC is present in the input, and vuln.today's decision label is 'monitor' rather than act_now/emergency. The low EPSS despite a 9.8 is consistent with a critical-but-not-yet-widely-weaponized issue, likely because full RCE is contingent on a suitable gadget class already being on the application's classpath - a precondition the attacker does not directly control. Net: a legitimately critical, pre-authentication flaw in an EOL product that warrants prioritized remediation of exposed internet-facing Axis 1.x endpoints, but current telemetry indicates it is not yet under broad active exploitation, so it reads as high-priority-to-patch rather than an active-incident emergency. |
| Exploit ScenarioDerived | An attacker sends a crafted SOAP response/fault to a reachable Apache Axis 1.x endpoint (or coerces Axis into parsing an attacker-controlled SOAP fault) whose <detail><exceptionName> names a class present on the server's classpath, with a String <data> element supplying constructor input. Axis loads the class - running its static initializer - and instantiates it via its String constructor before the AxisFault type check, so if a usable gadget class exists on the classpath this yields remote code execution without authentication. No public exploit code is identified in the provided data; the mechanism is confirmed from the vendor patch, and real-world impact depends on which classes are on the target's classpath. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Nov 10, 2026
Unauthenticated remote class instantiation in Apache Axis 1.x (every release through 1.4, an end-of-life line) can escalate to remote code execution when the engine parses an attacker-supplied SOAP fault: a <detail><exceptionName> element names a class that Axis loads from the application classpath, running its static initializer, and if a String <data> element is also present Axis reflectively invokes the matching String constructor before ever checking that the object is an AxisFault. Because fault parsing happens while the engine resolves the target service, before any per-service handler chain executes, authentication handlers configured on a service do not protect against it. No CISA KEV entry and no public exploit identified at time of analysis; EPSS is 0.57% (47th percentile) and the priority label is monitor, with real-world impact capped by whether a usable gadget class (one whose static initializer or single-String constructor does something exploitable) already ships on the deployment's classpath.
Earlier versions of this analysis (1)
Unauthenticated remote class instantiation in Apache Axis 1.x (all versions through 1.4) allows an attacker to name an arbitrary class in a SOAP <Fault><detail><exceptionName> element; Axis loads that class - running its static initializer - and, when a String <data> element is also present, instantiates it through its String constructor before ever checking that the result is an AxisFault. Because the fault is parsed while the engine is still resolving the target service, per-service authentication handlers have not yet run, so services that rely on handler-chain authentication are not protected. Escalation to full remote code execution is conditional on a suitable gadget class already being present on the application's classpath; without one, the impact is limited to forced class loading and instantiation, and the high attack complexity reflects that classpath dependency. Axis 1.x is end-of-life and the project does not intend to ship a fixed 1.x release, so remediation means building with the referenced source patch or migrating to another SOAP engine; the issue is rated act_now.
RemediationAI
There is no vendor-released Axis 1.x version to upgrade to and none is planned; the vendor's primary recommendation is to migrate off the EOL engine to a maintained SOAP stack such as Apache Axis 2/Java (or another supported engine), which removes the vulnerable fault-parsing code path entirely but requires application and client rework. The alternative is to build Axis 1.x from source with the upstream fix commit 41f3b4e8d04e310ca81f86b92630ab2c11d608bd applied (https://github.com/apache/axis-axis1-java/commit/41f3b4e8d04e310ca81f86b92630ab2c11d608bd), which gates fault class loading and construction on AxisFault.class.isAssignableFrom and loads classes without initialization; this means maintaining a private fork, since no official artifact carries the patch. Note that adding or tightening per-service authentication handlers is not a mitigation here, because the fault is parsed during service resolution before those handler chains run. Reducing the set of gadget-like classes on the Axis application's classpath lowers the achievable impact but does not close the unsafe reflection path itself, so it should be treated only as a stopgap alongside migration or the patched build.
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 Axis 1.x is the legacy Java SOAP engine, now EOL, and the flaw is CWE-470, use of externally-controlled input to select classes or code (unsafe reflection). In SOAPFaultDetailsBuilder, the exceptionName value taken from the inbound <detail> element was passed to ClassUtils.forName -> Class.forName with initialization enabled, meaning an attacker-chosen class name was loaded and its static initializer ran purely as a side effect of parsing. SOAPFaultBuilder then looked up the single-String constructor and invoked newInstance(...) with attacker-supplied fault data before the result was cast to AxisFault, so the constructor executed prior to any type check. The upstream commit 41f3b4e8d04e310ca81f86b92630ab2c11d608bd fixes all three sites: it adds a ClassUtils.forName(String, boolean) overload so classes can be located without initialization, requires AxisFault.class.isAssignableFrom(faultClass) before the class is recorded or reflectively constructed, and logs and ignores non-AxisFault names. Reachability requires the deployment to expose an Axis 1.x endpoint that will parse an inbound SOAP fault; the trigger is the fault message itself, and the ceiling on impact is set by what classes the application happens to ship.
Know when Java 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:H/I:H/A:H
Pre-auth, network-reachable, no user interaction (AV:N/AC:L/PR:N/UI:N); vendor confirms class load/instantiation before auth, and classpath-gadget RCE yields C:H/I:H/A:H.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
4DescriptionCVE.org
UNSUPPORTED WHEN ASSIGNED Deserialization of an inbound SOAP fault in Apache Axis 1.x allows unauthenticated remote class instantiation. When a SOAP <Fault> carries a <detail><exceptionName> element, Axis loads the named class and, if a String <data> element is also present, instantiates it through its String constructor before checking that it is an AxisFault. Loading alone runs the class's static initializer. With a suitable class on the application's classpath this leads to remote code execution. The fault is parsed while the engine resolves the target service, before any per-service handler chain runs, so authentication handlers configured on a service do not protect against it. This affects all Apache Axis 1.x versions through 1.4.
As Axis 1 has been EOL we recommend you migrate to a different SOAP engine, such as Apache Axis 2/Java. Alternatively you could use a build of Axis with the patch from https://github.com/apache/axis-axis1-java/commit/41f3b4e8d04e310ca81f86b92630ab2c11d608bd applied. The Apache Axis project does not expect to create an Axis 1.x release fixing this problem.
Articles & Coverage 4
Technical POC Analysis
The bug is CWE-470, unsafe reflection on attacker-controlled class names.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
CVE-2026-90436 is a critical unauthenticated remote code execution vulnerability in Apache Axis 1.x, an end-of-life SOAP engine that may still underpin legacy integrations and services. Successful exploitation allows an attacker to execute arbitrary code on the host, potentially compromising sensitive data and business operations, and should concern leadership because any affected system is at risk without authentication.
Apply vendor patch.
Threat Model
5 threats: Elevation of Privilege, Denial of Service, Tampering and 2 more
5-step attack chain with trust boundaries and controls
Full threat model - attack chain, trust boundaries, controls per stage and evidence - is part of the Pro and Business plans.
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
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
EUVD-2026-118323
GHSA-988f-c54m-f8jj
NVD
CVE.org
CISA KEV
EPSS
VulDB
Exploit-DB