79% vs 51%: independent neobanks lag on app security. Read the report

Deep Dive

Deep Dive

Apache Axis 1.x SOAP Fault RCE, Exploited (CVE-2026-90436)

Apache Axis 1.x loads and instantiates the class named in an unauthenticated SOAP fault, enabling RCE; migrate or apply the fix.

TL;DR

  • An unauthenticated SOAP fault can name any class on the server's classpath. Apache Axis 1.x loads that class and calls its String constructor before checking that it is an AxisFault.
  • Every Axis 1.x release through 1.4 is affected. The project is end-of-life and will not publish a fixed release.
  • CISA's Vulnrichment record scores CVE-2026-90436 CVSS v3.1 9.8 Critical, and CISA added it to the Known Exploited Vulnerabilities catalog on 2026-11-18, with a federal due date of 2026-11-21.
  • Migrate to a maintained SOAP engine, or build Axis 1.x with commit 41f3b4e applied. "How do I fix it?" gives both paths.

Am I affected?

All of these conditions must hold for a system to be exposed to remote code execution:

  • An Apache Axis 1.x runtime is on the classpath of a service reachable over the network. The Maven coordinates are axis:axis and org.apache.axis:axis, and every release through 1.4 is affected.
  • The Axis servlet or a service endpoint parses inbound SOAP requests. A front end that rejects SOAP faults before Axis sees them removes the path.
  • A class on the same classpath performs a dangerous action in its static initializer or in a String constructor. Without such a class, the request can still load and construct an attacker-named class, which can crash the process.
Branch Affected versions Fixed version
Apache Axis 1.x All releases through 1.4 No release. Build with commit 41f3b4e8 or migrate to a maintained SOAP engine

Axis 1.4, the last release, was published on 2006-05-31. Apache marked Axis 1 end-of-life and says it does not expect to create a 1.x release for this flaw. The patch commit was authored on 2026-07-12. libraries.io lists 97 packages and 31 repositories that depend on axis:axis, a count that excludes the proprietary applications that bundle the JAR.

Check the dependency in each build and in the deployed application:

# Maven
mvn dependency:tree -Dincludes=axis:axis,org.apache.axis:axis

# Gradle
./gradlew dependencyInsight --dependency axis --configuration runtimeClasspath

# A deployed WAR or EAR
unzip -l /path/to/application.war | grep -Ei 'WEB-INF/lib/axis[^/]*\.jar'

For a running container, inspect the image rather than a fresh pull:

docker exec <container> find / -name 'axis*.jar' 2>/dev/null

A direct dependency is easy to see. A transitive one appears only in the resolved tree, and a JAR copied into an application server's lib directory appears in neither. Search both the build output and the deployed artifacts.

How do I fix it?

The complete fix is to remove Axis 1.x from the classpath. Apache recommends migrating to Apache Axis 2/Java or another maintained SOAP engine. That is the only path that does not depend on building an unsupported branch.

  1. Inventory every service that resolves axis:axis or org.apache.axis:axis, including application servers and vendor products that bundle the JAR.
  2. Migrate those services to a supported SOAP engine. Axis 2/Java is the project's own recommendation, but any maintained engine removes this parser.
  3. If a service cannot move yet, build Axis 1.x from the patched commit and replace the runtime JAR. The project builds with Maven:
git clone https://github.com/apache/axis-axis1-java.git
cd axis-axis1-java
git checkout 41f3b4e8d04e310ca81f86b92630ab2c11d608bd
mvn -pl axis-rt-core -am -DskipTests package
  1. Deploy the rebuilt axis-rt-core JAR with the rest of the Axis 1.x runtime, then retest the SOAP services. A patch to one module does not remove other copies of Axis that a vendor product may load from its own directory.

Apache publishes no configuration workaround. Blocking <detail> elements at a reverse proxy or web application firewall reduces the exposure, but it is a filter in front of a parser that still accepts the element. Treat the filter as a stopgap, not as a fix.

What is the root cause?

Axis 1.x trusts the class name in a SOAP fault's <exceptionName> element and loads it with initialization before it checks the class type. Two code paths combine: one loads the class, and the other calls a constructor on it.

The first path is SOAPFaultDetailsBuilder.setValue() at axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultDetailsBuilder.java lines 180 to 188 of the 1.4 source:

} else if ("exceptionName".equals(hint)) {
    String faultClassName = (String) value;
    try {
        Class faultClass = ClassUtils.forName(faultClassName);
        builder.setFaultClass(faultClass);
    } catch (ClassNotFoundException e) {
        // Just create an AxisFault, no custom exception
    }
}

faultClassName comes straight from the request body. ClassUtils.forName(String) calls loadClass(), which calls Class.forName(className, true, loader) at ClassUtils.java line 88. The true initializes the class, so its static initializer runs as soon as the element is parsed. No type check happens at this point.

The second path is SOAPFaultBuilder.createFault() at SOAPFaultBuilder.java lines 162 to 175. When the fault also carries a <data> element, Axis reflectively calls the named class's String constructor with the attacker's string:

Class argClass = ConvertWrapper(faultData.getClass());
try {
    Constructor con =
            faultClass.getConstructor(
                    new Class[] { argClass });
    f = (AxisFault) con.newInstance(new Object[] { faultData });
} catch(Exception e){
    // Don't do anything here, since a problem above means
    // we'll just fall through and use a plain AxisFault.
}

The (AxisFault) cast runs after newInstance() has already constructed the object. If the class is not an AxisFault, the cast throws ClassCastException, the empty catch swallows it, and execution continues with a plain fault. The isAssignableFrom check that could have stopped the construction is at line 181, after the constructor call.

The fault is parsed while the engine resolves the target service, before any per-service handler chain runs. Authentication handlers configured on a service therefore do not see the request first.

How is it exploited?

An unauthenticated attacker sends a SOAP fault whose <detail> names a class already present on the target's classpath. The class is loaded and initialized during parsing, and if a <data> element is present its String constructor is called with attacker-controlled input.

The public regression test in the fix commit builds the request in this shape:

<soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
    <soap:Fault>
      <faultcode>x</faultcode>
      <faultstring>x</faultstring>
      <detail>
        <data xsi:type="xsd:string">attacker-controlled string</data>
        <exceptionName>class.on.the.classpath</exceptionName>
      </detail>
    </soap:Fault>
  </soap:Body>
</soap:Envelope>
  1. The attacker chooses a class that exists in the target application or its libraries. The fix commit names Spring's ClassPathXmlApplicationContext, the gadget used in CVE-2023-46604, as an example.
  2. The attacker sends the fault to a reachable Axis endpoint. The request does not need a valid operation, a session, or credentials.
  3. SOAPFaultDetailsBuilder.setValue() loads the class with Class.forName(..., true, ...). A static initializer runs at this step.
  4. If a <data> element is present, SOAPFaultBuilder.createFault() calls the class's String constructor with the supplied string.
  5. The AxisFault check runs only after the constructor, so a class that is not a fault type has already executed its code. The resulting cast error is swallowed.
  6. Code that runs in the static initializer or constructor executes in the Axis process with that process's privileges.

The advisory publishes no proof of concept, and the CVE record links none. The fix commit includes a regression test with a harmless probe class that records whether its static initializer and constructor ran. CISA's SSVC assessment records exploitation as active and automatable.

How does the attack flow?

An unauthenticated SOAP fault names a class, Axis loads and constructs it before the AxisFault check, and any code in that class runs in the server process.

flowchart LR A["SOAP fault with
exceptionName and data"] --> B["Resolve target service
before handler chain"] B --> C["Load named class
static initializer runs"] C --> D["Call String constructor
with attacker data"] D --> E{"AxisFault subtype?"} E -->|"No"| F["Cast fails, error swallowed
code already ran"] E -->|"Yes"| G["Normal custom fault"]

What can an attacker do?

An attacker can run code in the Axis process without authentication when a suitable class is on the classpath. CISA's SSVC assessment records the technical impact as total.

  • Remote code execution as the user that runs the Axis servlet or application server. That user can usually read the application's configuration, database credentials, and signing keys.
  • Class loading and construction even without a usable gadget. A class whose static initializer or constructor fails, blocks, or allocates heavily can crash or stall the service.
  • Reach into every application that shares the classpath, including libraries a vendor bundled with the server.

The code-execution impact requires a class whose static initializer or String constructor performs an action the attacker wants. The class-loading impact needs only a class name. A service that exposes Axis but has no usable gadget is still exposed to denial of service and to any future gadget added to its dependencies.

Why does the fix work?

The fix adds an AxisFault type check before the class is initialized or constructed, and it makes the class loader honor a non-initializing load. Genuine AxisFault subclasses still deserialize.

--- a/axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultBuilder.java
+++ b/axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultBuilder.java
@@ -162,14 +162,21 @@ private void createFault() {
                         Class argClass = ConvertWrapper(faultData.getClass());
-                        try {
-                            Constructor con =
-                                    faultClass.getConstructor(
-                                            new Class[] { argClass });
-                            f = (AxisFault) con.newInstance(new Object[] { faultData });
-                        } catch(Exception e){
-                            // Don't do anything here, since a problem above means
-                            // we'll just fall through and use a plain AxisFault.
+                        // Only construct genuine AxisFault subtypes: the
+                        // constructor runs before the (AxisFault) cast below,
+                        // so reflectively constructing an arbitrary class here
+                        // would let an unauthenticated caller execute its
+                        // constructor with attacker-controlled data.
+                        if (AxisFault.class.isAssignableFrom(faultClass)) {
+                            try {
+                                Constructor con =
+                                        faultClass.getConstructor(
+                                                new Class[] { argClass });
+                                f = (AxisFault) con.newInstance(new Object[] { faultData });
+                            } catch(Exception e){
+                                // Don't do anything here, since a problem above means
+                                // we'll just fall through and use a plain AxisFault.
+                            }
                         }

SOAPFaultDetailsBuilder.setValue() now loads the class with ClassUtils.forName(faultClassName, false) and accepts it only when AxisFault.class.isAssignableFrom(faultClass) is true. The false reaches Class.forName(className, false, loader), so a static initializer does not run during the type check. A non-fault class is ignored and a plain AxisFault is produced.

ClassUtils gained a two-argument forName and now passes the initialize flag through its three-argument overload. Before the change, that overload ignored its init parameter and always called Class.forName(className, true, loader).

The regression test sends the same SOAP shape against a probe class and asserts that neither its static initializer nor its constructor ran. A second test sends a genuine org.apache.axis.AxisFault and asserts that the fault string still round-trips. The fix is complete for the parser paths it touches, but Axis 1.x has no further security support, so a new flaw will not be fixed.

How do I check if I was compromised?

Apache publishes no indicators of compromise for this flaw. CISA added it to KEV because exploitation is known, but neither the vendor advisory nor the KEV record names a victim, an IP address, or a payload.

Check the places where a SOAP body or a rejected request would be recorded:

# WAF or reverse-proxy logs that retain request bodies
grep -Ril 'exceptionName' /var/log/waf /var/log/nginx /var/log/httpd 2>/dev/null

# SOAP fault bodies in application or gateway logs
grep -Ril '<soap:Fault' /var/log 2>/dev/null

# Unexpected class-loading or verifier errors around Axis
grep -Ril 'ClassCastException\|ClassNotFoundException' /var/log 2>/dev/null

A hit on exceptionName in a stored request body is a lead, not proof, because legitimate SOAP faults can carry the element. A hit in a packet capture or a body-logging gateway is stronger.

The parser swallows the cast failure, and Axis does not log the class name by default. An attempt that did not reach a usable gadget can therefore leave no trace beyond the request log. If the service has no request-body logging and no WAF in front of it, absence of evidence is not evidence that no attempt reached it.

Timeline

  • 2006-05-31: Apache Axis 1.4 is released, the last 1.x release.
  • 2026-07-12: Robert Lazarski authors commit 41f3b4e8, which hardens the fault deserializer.
  • 2026-11-06: Apache publishes the advisory and CVE-2026-90436.
  • 2026-11-17: CISA's SSVC assessment records exploitation as active and automatable.
  • 2026-11-18: CISA adds CVE-2026-90436 to the Known Exploited Vulnerabilities catalog.
  • 2026-11-21: Federal remediation due date for the KEV entry.

Timeline of CVE-2026-90436: the 2006 Axis 1.4 release, the July 2026 patch commit, the November 2026 advisory, the CISA exploitation assessment, the KEV addition and the federal due date
Figure 1: From the patch commit to a CISA KEV due date took 129 days. Source: Apache advisory, CVE record and CISA KEV catalog, checked November 20, 2026.

FAQ

Is Apache Axis 1.x still supported?

No. Apache marked Axis 1 end-of-life, and the advisory says the project does not expect to create a 1.x release for this flaw. Services that still run Axis 1.x need a migration or a locally built patch.

Does an authentication handler on my service block the attack?

No. Axis parses the fault while it resolves the target service, before the per-service handler chain runs. An authentication handler on the service never sees the request that triggers the class load.

Is there a public exploit?

No public exploit code is linked from the advisory or the CVE record. CISA's SSVC assessment records active exploitation, so a working exploit exists outside the public record. The fix commit includes a regression test that demonstrates the class load and constructor call with a harmless probe.

Which Axis 2 versions are affected?

None by this CVE. CVE-2026-90436 is in the Axis 1.x fault deserializer, and the advisory scopes it to Axis 1.x through 1.4. Axis 2/Java is the migration target Apache recommends.

Can I keep Axis 1.x and block the fault element at my proxy?

You can reduce exposure, but Apache publishes no workaround. A proxy rule that rejects <detail> or <exceptionName> in SOAP faults is a stopgap in front of a parser that still accepts the element. Apply the patch or migrate.

Does the patch break custom SOAP faults?

No. Genuine subclasses of org.apache.axis.AxisFault still load and deserialize, and the fix commit adds a regression test for that case. Only classes that are not AxisFault subtypes are ignored.

Find exposed Apache Axis services with Ostorlab

Ostorlab's attack surface discovery inventories internet-facing hosts and services so you can find the SOAP endpoints and application servers that still expose Axis 1.x before the KEV deadline.

References

  • Apache Software Foundation, "CVE-2026-90436: Apache Axis 1.x (EOL): unauthenticated remote class instantiation via SOAP fault exceptionName": https://lists.apache.org/thread/8slf0j9gz35z56t0glt5h0ncwlbn4bdz (checked November 20, 2026)
  • CVE Program, CVE-2026-90436, including the CISA Vulnrichment CVSS v3.1 9.8 score and SSVC assessment: https://www.cve.org/CVERecord?id=CVE-2026-90436 (checked November 20, 2026)
  • Apache Axis, fix commit 41f3b4e8d04e310ca81f86b92630ab2c11d608bd: https://github.com/apache/axis-axis1-java/commit/41f3b4e8d04e310ca81f86b92630ab2c11d608bd (checked November 20, 2026)
  • Apache Axis, vulnerable source at the parent of the fix, SOAPFaultBuilder.java: https://github.com/apache/axis-axis1-java/blob/f19d6dfae6c1a4be379a5693d9ef3bdb6b959630/axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultBuilder.java (checked November 20, 2026)
  • Apache Axis, vulnerable source at the parent of the fix, SOAPFaultDetailsBuilder.java: https://github.com/apache/axis-axis1-java/blob/f19d6dfae6c1a4be379a5693d9ef3bdb6b959630/axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultDetailsBuilder.java (checked November 20, 2026)
  • Apache Axis, vulnerable source at the parent of the fix, ClassUtils.java: https://github.com/apache/axis-axis1-java/blob/f19d6dfae6c1a4be379a5693d9ef3bdb6b959630/axis-rt-core/src/main/java/org/apache/axis/utils/ClassUtils.java (checked November 20, 2026)
  • CISA Known Exploited Vulnerabilities catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (checked November 20, 2026)
  • libraries.io, axis:axis dependency counts: https://libraries.io/maven/axis:axis (checked November 20, 2026)
  • Maven Central, axis:axis:1.4: https://central.sonatype.com/artifact/axis/axis/1.4 (checked November 20, 2026)
  • oss-security, "CVE-2026-90436: Apache Axis 1.x (EOL)" announcement: https://www.openwall.com/lists/oss-security/2026/11/06/12 (checked November 20, 2026)