SOAPFaultDetailsBuilder.setValue runs ClassUtils.forName on an attacker-controlled string from the request body, then SOAPFaultBuilder.createFault reflectively invokes the resulting class's String constructor, and the surrounding catch (Exception) swallows the ClassCastException when the result turns out not to be an AxisFault. That is the whole vulnerability. The code has looked like this since October 1, 2002. The fix commit landed on July 12, 2026. The CVE caught up on November 6.
CVE-2026-90436: Apache Axis Ran the Attacker's Constructor Before the Auth Handler. The Fix Commit Was 117 Days Older Than the CVE.
vendor
patterns
cve
proof of concept
- seclists.org/oss-sec/2026/q4/546
- fixedbyreboot/CVE-2026-90436-POC%20(%E2%98%850)
- dinosn/axis-cve-2026-90436-lab-poc%20(%E2%98%851)
- infosec.exchange/@DailyCyberSecurity/117639416211276406
- evenomn/CVE-2026-90436%20(%E2%98%850)
- infosec.exchange/@thecybermind/117642681242085402
- infosec.exchange/@thecybermind/117642673705153770
The constructor runs before the cast
The vulnerable path is two methods long. In SOAPFaultDetailsBuilder.setValue, the handler for the exceptionName element reads an attacker-controlled string from a SOAP <Fault><detail> child and hands it to ClassUtils.forName:
} 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
}
}ClassUtils.forName(name) is the three-argument Class.forName(name, true, loader), the initialize=true overload. Static initializers run on load. The comment says "Just create an AxisFault". The code performs no type check at all.
SOAPFaultBuilder.createFault then takes that faultClass and invokes a constructor on it:
Constructor con = faultClass.getConstructor(new Class[]{faultData.getClass()});
Object o = con.newInstance(new Object[]{faultData});
if (o instanceof AxisFault) {
f = (AxisFault) o;
}The constructor runs before the instanceof check. The whole block is inside catch (Exception), so if getConstructor throws NoSuchMethodException, or newInstance throws anything at all including the gadget throwing on purpose, the server swallows it and continues. The reflected constructor's side effects persist. That is the primitive: unauthenticated new AttackerNamedClass(attackerString) for any public class on the server's classpath with a public String constructor.
The ordering rule is a state machine quirk. The <detail> SAX handler walks children in document order. A <data xsi:type="xsd:string"> element before <exceptionName> populates faultData as a String and the subsequent exceptionName overwrites faultClass. Reversed order, with <exceptionName> first, triggers the string path for the <data> handler and faultClass ends up as java.lang.String, which reduces the exploit to new String("ATTACKER-REORDER-xxxx"). The dinosn lab poc.py runs both orders as probes 1 and 3 and confirms only the first produces a marker file.
Pre-auth because the envelope is parsed before the handler chain
Axis's per-service security is a <requestFlow><handler/></requestFlow> block in server-config.wsdd. The fixedbyreboot lab wires a LabAuthHandler onto a SecureService and the handler does throw new AxisFault("Client.Unauthenticated", ...) on every invocation. The attacker's response is still Client.Unauthenticated. The marker file is still on disk.
The reason is in AxisServer.invoke around line 258:
// This is a kludge. We should be able to get the message's SOAPEnvelope
// without forcing a parse. But right now we need to.
msgContext.getRequestMessage().getSOAPEnvelope().getFirstBody();That call fires the full SAX parse. BodyBuilder.onStartChild constructs a SOAPFaultBuilder for any envelope-namespaced <Fault> regardless of whether the message is a request or a response. The gadget runs inside the SAX callbacks, before AxisServer.invoke reaches h.invoke(msgContext) where handlers like LabAuthHandler would run. The comment calls it a kludge. It has been a kludge long enough for the kludge to acquire a CVE number.
The same code path handles dispatch when no service resolves: SAX parses the envelope so Axis can figure out where to route it. The dinosn lab confirms exploitation against /axis/services/DoesNotExist. The attack surface is any URL the servlet answers.
What you can construct with it
Reflection calls getConstructor(String.class) exactly. ProcessBuilder(String...) is a varargs signature and does not match. The constructor must be literally X(String) and the class must be public with a public <init>(Ljava/lang/String;)V. The dinosn lab enumerated every such class on a stock Axis 1.4 + Tomcat 9 + JDK 8 classpath: 87 in WEB-INF/lib, 92 in Tomcat lib/, 862 in rt.jar. None of the thousand-plus are exec-capable. The closest stock primitives are java.io.FileWriter(String) for arbitrary file create and truncate, demonstrated in the lab; java.io.File*Stream/Reader for open-and-discard existence oracles; and org.apache.log4j.helpers.SyslogWriter(String) for a DNS lookup out-of-band oracle.
RCE requires an application-supplied gadget. The one everyone reaches for is Spring's ClassPathXmlApplicationContext(String), the same gadget as CVE-2023-46604 in ActiveMQ. The attacker hosts a Spring bean definition XML with a ProcessBuilder bean and init-method="start", passes the URL as the constructor argument, and the Spring context loader on the target fetches and parses it, which instantiates and starts the bean. The constructor argument is a URL. The content behind the URL is a command. The pattern has a name: content is command. CVE-2023-46604 was a nearly identical shape in a different product; the gadget still lands.
Confluence Data Center ships Spring. Atlassian's advisory (CONFSERVER-104610) lists 1.x through 9.x vulnerable when "Remote API (XML-RPC & SOAP)" is enabled, fixed in 9.2.28, removed entirely in 10.x. N-able N-central ships the same primitive through a different embedding, fixed in 2026.4 HF3. Rapid7 MDR reports in-the-wild exploitation starting around November 13 against both products.
The git log is the timeline
The vulnerable setValue method was committed by Tom Jordahl on October 1, 2002, in commit a943148c2, with the same four lines of unchecked ClassUtils.forName that 41f3b4e8 eventually patched. It shipped in Axis 1.0 and did not change through 1.4. Axis went end-of-life in 2006.
The fix commit is 41f3b4e8 on July 12, 2026. It changes two things. In SOAPFaultDetailsBuilder.setValue, ClassUtils.forName(faultClassName) becomes ClassUtils.forName(faultClassName, false, ...) with a non-initializing load and an AxisFault.class.isAssignableFrom(faultClass) check that drops classes that are not AxisFault subtypes. In SOAPFaultBuilder.createFault, an isAssignableFrom gate precedes the reflective constructor branch. Both the initializing-load primitive and the arbitrary-constructor primitive close.
The commit message named the bug class. The CVE assignment came 117 days later: July 12 to November 6, with July 12 counted as day zero. The oss-security post is dated November 6. Rapid7 reports first in-the-wild exploitation on November 13. The patch was public on a git mirror for seventeen weeks before anyone had a CVE to search for. The pattern has a name: release lag disclosure.
Axis 1.x is EOL. There will be no fixed release. The primitive has been on the wire of every Axis deployment since Axis 1.0 shipped. It took twenty-three years and seven months from Tom Jordahl's commit to Atlassian's advisory. It took four months from the public patch to the CVE.
The patch is four months older than the CVE. The primitive is twenty-three years older than the patch.