Skip to main content

Apache Axis 1.x CVE-2026-90436

| EUVDEUVD-2026-118323 CRITICAL
Use of Externally-Controlled Input to Select Classes or Code ('Unsafe Reflection') (CWE-470)
2026-11-06 apache GHSA-988f-c54m-f8jj
9.8
CVSS 3.1 · Vendor: apache
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach Axis 1.x SOAP endpoint
  2. Delivery
    Send SOAP Fault with detail/exceptionName
  3. Exploit
    Axis loads named classpath class
  4. Execution
    Static initializer / String constructor runs
  5. Impact
    Gadget 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.

Monitor Track and reassess. Why: Vendor states no customer action required.
Exploited in the wild (CISA KEV) Patch available 0.6% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv2 – 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)
v1 Nov 06, 2026 - 16:06

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

Apache Axis 1.x (EOL) 0 ≤1.4
Apache Axis 1.x (EOL) aac718c6035435d96b39d6aebb9c078a13af7cc8 <41f3b4e8d04e310ca81f86b92630ab2c11d608bd

Affected Packages

euvd apache_axis_1_x_eol no fix

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

Vendor (apache) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 9.8 CRITICAL

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (apache).

CVSS VectorVendor: apache

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
Added to CISA KEV
Nov 18, 2026 - 19:48 CISA
Analysis Updated
Nov 10, 2026 - 19:43 vuln.today
v2 - CVSS changed
CVSS changed
Nov 10, 2026 - 19:38 NVD
9.8 (CRITICAL)
CVE Published
Nov 06, 2026 - 15:37 cve.org
CRITICAL

DescriptionCVE.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.

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

Threat Score
5.0/10
Composite threat intelligence
EPSS Score
0.6%
Top 53% exploitable
Prevalence
Medium
legacy Java SOAP engine, still embedded in many older enterprise applications
Exploit
POC
Public exploit code exists
Data Quality
8 sources
Confidence: High

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.

SignalValue
Severity CRITICAL
CISA KEV Yes
Public POC Yes
EPSS 0.6%
Patch available Yes
Active threat Yes
Deciding rule
Vendor states no customer action required
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Active
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

120
Low Medium High Critical
KEV: +50
EPSS: +1
CVSS: +49
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

More in Java

View all
CVE-2012-4681 CRITICAL POC
9.8 Aug 28

Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m

CVE-2015-7450 CRITICAL POC
9.8 Jan 02

Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti

CVE-2013-2465 CRITICAL POC
9.8 Jun 18

Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent

CVE-2011-3544 CRITICAL POC
9.8 Oct 19

Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug

CVE-2010-1871 HIGH POC
8.8 Aug 05

JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to

CVE-2012-1723 CRITICAL POC
9.8 Jun 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up

CVE-2013-0422 CRITICAL POC
9.8 Jan 10

Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using

CVE-2012-0507 CRITICAL POC
9.8 Jun 07

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up

CVE-2015-4852 CRITICAL POC
9.8 Nov 18

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

CVE-2012-5076 CRITICAL POC
9.8 Oct 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow

CVE-2017-3066 CRITICAL POC
9.8 Apr 27

Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla

CVE-2012-0391 CRITICAL POC
9.8 Jan 08

The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy