Apache Axis CVE-2026-90436 in CISA KEV: Patch and Rotate. CVE-2026-90436 lets a crafted SOAP fault run code in Apache Axis 1.x before any login, and CISA lists it as exploited. Retire Axis, rotate secrets, move logins.
CVE-2026-90436 is an unsafe reflection flaw in Apache Axis 1.x, through version 1.4, that lets an unauthenticated SOAP request make Axis load a class the attacker names, and CISA added it to its Known Exploited Vulnerabilities catalog on 2026-11-18, so it is being exploited now (CISA KEV catalog, NVD). Axis 1.x is end of life and the project’s advisory says it does not expect to ship a fixed 1.x release (oss-security advisory), so retire or isolate those SOAP services, rotate the credentials and client secrets they hold, and move their logins to a supported OpenID Connect (OIDC) provider.
This post is for the Java platform, security and IAM engineers who run, or inherited, the old SOAP services nobody wants to touch. Axis 1 shows up in internal billing and partner integrations, in vendor products that bundled it years ago, and in services that check a username and password for some other system. We start with what the flaw is and how to find it, then cover what you can do at the edge while you work on a replacement, and then the part most advisories skip: which secrets a compromised Axis service exposes, the order to rotate them in, and how to move its logins to OIDC on Keycloak.
What is CVE-2026-90436?
The advisory, posted to the oss-security list by the Apache Axis project on 6 November 2026, is titled “Apache Axis 1.x (EOL): unauthenticated remote class instantiation via SOAP fault exceptionName” and rates it critical (oss-security, 6 November 2026). It credits José Apari-Pantigozo from OKIOK as the finder (oss-security). NVD lists a CVSS 3.1 base score of 9.8 (vector AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H: network access, low complexity, no privileges or user interaction, and high impact on confidentiality, integrity and availability), and classifies it as CWE-470, the use of externally controlled input to select classes or code, which is what “unsafe reflection” means (NVD, CVE-2026-90436, NVD API record).
CISA lists it as “Apache Axis Unsafe Reflection Vulnerability”, added on 2026-11-18 with a due date of 2026-11-21 for the federal agencies the catalog binds, and it notes that the product may be end of life and that users are advised to “discontinue use and/or transition to a supported version” (CISA KEV catalog). The catalog entry also asks for forensic triage, which tells you CISA expects you to look for a past compromise, not only to close the hole.
The NVD record carries the unsupported-when-assigned tag, and its description opens with “UNSUPPORTED WHEN ASSIGNED” (NVD API record), which marks a flaw in a product its maintainer no longer supports. The description says it “affects all Apache Axis 1.x versions through 1.4”, and the record names the Maven packages axis:axis and org.apache.axis:axis as affected up to 1.4 (NVD, CVE-2026-90436, NVD API record). Apache Axis2 is a separate codebase, described by its project as “the successor to the widely used Apache Axis SOAP stack” (Apache Axis2/Java), and the advisory mentions it only as an engine to migrate to, not as affected (oss-security).
How does the exploit work?
We keep this at the level of the mechanism and the signs to look for, without a working request. A SOAP fault is the XML error message a SOAP service returns, and it can carry a detail element with extra information. According to the advisory, when Axis 1.x deserializes an inbound Fault that has a detail element containing exceptionName, it loads the class named there, and if a string data element is also present, it calls that class’s constructor with the string, before checking that the class is an AxisFault at all (oss-security). The advisory adds that “Loading alone runs the class’s static initializer” (oss-security), so with a suitable class on the application’s classpath (a “gadget”, in exploit terms), the result is remote code execution.
Any client can send the message (1). Axis parses the fault while it is still working out which service the request is for, and loads the named class, which can run code (2). The authentication handler configured on the service comes later and never sees the request (3).
Two details make this worse than an ordinary bug in one service. The advisory says 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” (oss-security). A service that requires a password is therefore just as exposed as an open one. And the fix commit gives a ready-made gadget as its example: “Spring’s ClassPathXmlApplicationContext, the CVE-2023-46604 gadget” (Axis commit 41f3b4e). Spring sits on the classpath of a great many Java web applications, so you should assume a working gadget is available to the attacker unless you have checked otherwise.
Why is there no upstream patch?
The last Axis 1 release, 1.4 Final, was announced in a news item dated “April 22, 2006” (Apache Axis). The advisory states that “The Apache Axis project does not expect to create an Axis 1.x release fixing this problem” and recommends migrating “to a different SOAP engine, such as Apache Axis 2/Java” (oss-security). The project did publish a source fix, commit 41f3b4e (Axis commit 41f3b4e), and the advisory names “a build of Axis with the patch” as the alternative (oss-security).
The commit message says the fault deserializer now “loads the <exceptionName> class without initializing it” and “only accepts it if it is an org.apache.axis.AxisFault subtype”, and that in the fault builder “a non-fault class is never constructed” (Axis commit 41f3b4e). Building your own patched Axis jar from it is a reasonable stopgap, but you then own an unmaintained SOAP engine, with whatever its next flaw turns out to be. We would treat the patched build as a way to buy a few weeks while the service is replaced.
How do I find Axis 1.x across my estate?
Axis 1 hides in three places: as a jar in a web application’s WEB-INF/lib, as a dependency in a build file, and copied inside a “fat” jar or a vendor product where its file name is gone. The Axis install guide lists the jars an Axis 1 application carries, “axis.jar, commons-discovery.jar, commons-logging.jar, jaxrpc.jar, saaj.jar” (Axis installation guide), so jaxrpc.jar next to axis.jar is a good sign you have found Axis 1 rather than Axis2.
# 1. Jars on disk, including versioned names such as axis-1.4.jar
find / -xdev \( -name 'axis*.jar' -o -name 'jaxrpc*.jar' \) 2>/dev/null
# 2. Axis 1 classes copied into other jars, wars and ears (shaded or bundled)
find / -xdev \( -name '*.jar' -o -name '*.war' -o -name '*.ear' \) 2>/dev/null |
while read -r f; do
unzip -l "$f" 2>/dev/null | grep -q 'org/apache/axis/message/SOAPFaultBuilder' && echo "$f"
done
# 3. Build files: Maven and Gradle dependency trees
mvn -q dependency:tree -Dincludes=axis:axis,org.apache.axis:axis
gradle dependencies | grep -E 'axis:axis|org.apache.axis:axis'
A software bill of materials or a software composition analysis tool, if you have one, answers the same question faster: search it for the two Maven coordinates above. Container images need the same search, because an old base image or a vendor image can carry Axis without any of your build files naming it.
Then find the endpoints, because a jar on disk is only exploitable where something listens. The install guide shows the usual paths: the web application at /axis/, services under /axis/services/, the AxisServlet at /axis/servlet/AxisServlet, .jws files, the happyaxis.jsp check page and the AdminService (Axis installation guide). The Axis security guide notes that these “are all in well known locations under the webapp” (Axis security guide), and so they are easy for scanners too. Search your load balancer, reverse proxy and web server access logs for those paths, and for requests with a SOAPAction header, to find live endpoints, including ones with a renamed context path.
What can I do at the edge until the service is gone?
The advisory gives no filtering advice, so these are compensating controls we would use, not a vendor workaround. They lower the risk while you migrate, and none of them replaces removing Axis 1.
- Take it off the internet. Most Axis services only ever talked to a few partners or internal callers. Restrict the endpoints to those source addresses at the firewall or load balancer, or put them behind mutual TLS, so an anonymous client cannot reach the parser at all.
- Block the trigger at the proxy or WAF. In a normal request and response service, clients send requests and the server returns faults, so a request body that contains a SOAP
Faultelement, or anexceptionNameelement, is unusual. A rule that rejects inbound requests to Axis paths carrying either is a reasonable filter, but test it against your real traffic first, and remember that XML can be written in more than one way, so a filter slows an attacker down but cannot be relied on to stop every variant. - Close the extras. Block
happyaxis.jsp, theAdminServiceand.jwspaths from outside, and, as the security guide’s section “Stop AxisServlet listing services” says, “set the Axis global configuration property axis.enableListQuery to false” (Axis security guide). The user guide warns that enabling remote administration “may give unauthorized parties access to your machine” (Axis user guide), so check thatenableRemoteAdminis not set to true inserver-config.wsdd. - Limit what the process can do. Block outbound connections from the Axis host except to the systems it really calls, and run it as a user that cannot write to its own application directory. That will not stop code from running, but it makes a gadget that downloads its next stage fail, and it makes the follow-up harder.
How do I tell whether it was exploited?
CISA’s request for forensic triage is reason enough to look, even if you close the endpoint today (CISA KEV catalog). These are the signs we would check:
- In request logs or captured bodies: requests to Axis endpoints whose body contains
FaultandexceptionName, especially naming a class that is not anAxisFaultsubtype, such as a Spring or other framework class. Most access logs do not keep bodies, so check whether your WAF, API gateway or proxy captured them. - In application logs: fault parsing errors, class loading or
ClassNotFoundExceptionmessages naming unexpected classes, and exceptions from constructors you never call. - On the host: child processes of the Java process, such as shells,
curlorwget; outbound connections from the JVM to addresses it never talks to; and new or changed files in the web application,/tmpand the application server’s directories.
A clean log does not prove a clean host, because a successful attempt does not have to leave an error behind. If you find any of the host signs, rebuild the server from a known good image rather than cleaning it in place, and do every rotation in the next section, not only the first steps.
Patched on the day, not on your next maintenance window
Keycloak 26.7.2 fixed CVE-2026-18963, an account takeover through password reset. Skycloak had it available for auto-upgrade and told customers the same day upstream shipped it. Self-hosted teams schedule that work themselves.
Which credentials does a compromised Axis service expose?
Code that runs inside the Axis JVM can read anything the application can read, and these services tend to have accumulated a lot over the years. The table below lists what we would expect to find on a typical one; check your own service’s configuration for each row.
| What the service holds | Where it usually lives | What an attacker can do with it |
|---|---|---|
| OAuth or OIDC client secrets, when the service calls an API protected by Keycloak | Properties files, environment variables, JNDI resources | Get tokens as that client, with every scope and role it has |
| Service account passwords for downstream SOAP or HTTP calls, often HTTP basic credentials | Properties files, server-config.wsdd parameters, code |
Call those downstream systems as this service |
Users and passwords for Axis’s own example handlers, in a users.lst file |
The WEB-INF directory: for the simple authorization handlers, the install guide says to “copy the corresponding users.lst file into the WEB-INF directory” (Axis installation guide) |
Sign in to the service, and to anything else those passwords are reused on |
| LDAP bind credentials or database passwords, when the service checks logins itself | Data source and directory configuration in the application server | Read or change the user store, including password hashes |
| Java keystores and their passwords: the TLS key, client certificates, WS-Security signing keys | .jks or .p12 files and the passwords that open them |
Impersonate the service to its partners or sign messages as it |
| Passwords and session tokens of users who signed in through it | Memory, logs and the requests the service handles | Sign in as those users while the passwords stay valid |
The last two rows matter most when the service is part of a login flow, for example a SOAP authenticate operation that other applications call with a username and password. In that case the attacker sees every password that crosses the service from the moment the code runs.
In what order should I rotate?
Rotate after the endpoint is closed, patched or gone, not before, because a new secret on a still-exposed host is just a new secret to steal. Then work from the secrets that give the widest access to the narrowest.
- Client secrets in Keycloak. For each Keycloak client whose secret the service held, regenerate it through the Admin Console’s “Regenerate Secret” function in the client’s credentials tab, which the guide names as one way to rotate a secret (Keycloak, client secret rotation), and deploy the new value to the replacement or to the isolated service. If you use a rotation policy (see our post on client secret rotation in Keycloak 26.8), remember that during an incident the old secret is the one the attacker has, so keep any period in which it still works as short as you can.
- Directory and database credentials. Change the LDAP bind password and database passwords the service used, and if Keycloak federates the same directory, update the bind credential in Keycloak’s configuration for that directory at the same time, so logins keep working.
- Service account passwords for downstream systems. Change each one on the system that owns it, and remove any account that only the retired service used.
- Keystores. Issue new TLS and signing keys with new private keys, revoke the old certificates, and tell partners that pin your certificate or verify your WS-Security signatures.
- Sessions and tokens. If users signed in through the service or the attacker could have taken tokens, revoke them in Keycloak. The guide’s “Revoking active sessions” section says that “If your system is compromised, you can revoke all active sessions and access tokens” (Keycloak, Server Administration Guide), and include offline tokens, since the guide says “an offline token never expires and is not subject to the SSO Session Idle timeout” (Keycloak, offline access).
- User passwords. If the service handled logins and you found signs of compromise, require a password reset for the users who signed in through it during the exposure window.
After rotating, if you save events in Keycloak, review them for the rotated clients: the guide lists a CLIENT_LOGIN_ERROR event type, and its logged events carry an ipAddress field (Keycloak, Server Administration Guide). Look for errors and for callers at addresses that are not your services, since a caller still using the old secret is one you have not yet updated, or one you do not know about.
How do I move the service’s logins to OIDC?
The lasting fix is to stop doing authentication inside an end of life SOAP stack. OpenID Connect is, in the words of its specification, “a simple identity layer on top of the OAuth 2.0 protocol” (OpenID Connect Core 1.0): an identity provider such as Keycloak signs users in, and applications receive signed tokens instead of handling passwords. How you get there depends on who is logging in.
Service-to-service calls. Where other systems call the SOAP service with a shared username and password, give each caller its own client in Keycloak with client authentication and its service account turned on; the guide says “Each OIDC client has a built-in service account” and to “Use this service account to obtain an access token” (Keycloak, service accounts). The callers then send those tokens as bearer tokens. The replacement service, whether it is Axis2, Apache CXF or a REST rewrite, then validates the token’s signature, issuer, expiry and audience. For a recent case in another Java framework, see our post on the Apache CXF JWT audience flaw.
End-user logins. Where applications send users’ passwords to a SOAP authenticate operation, move those applications to the OIDC authorization code flow. In OIDC, “The OP authenticates the End-User” (OpenID Connect Core 1.0), where the OP (OpenID Provider) is Keycloak, so users type their password into Keycloak rather than into the application. The users still live in the old store, so you have to decide whether Keycloak keeps authenticating them against it through user storage federation, for example its LDAP provider (Keycloak, user storage federation), or you move them over. Our post on federating or migrating legacy users is about that choice. Federation lets you switch the login flow first and move the users later, which suits a deadline like this one.
Plan the move service by service: inventory the callers from the access logs, create their clients, run the new endpoint beside the old one, move callers over, and then switch the Axis endpoint off for good. Old Axis services often run on equally old Java runtimes, so check the JDK on the replacement hosts too, and keep it patched. Our post on Java4Shell and patching the JDK covers a recent flaw in the Java runtime itself.
Have we seen this pattern before?
Yes, and recently: our post on the Apache mod_http2 flaw, CVE-2026-119618 is a related case from another Apache component. Here there is no release to upgrade to, so the plan ends with the Axis service removed.
Frequently asked questions
Is CVE-2026-90436 being exploited?
Yes. CISA added it to the Known Exploited Vulnerabilities catalog on 2026-11-18, and the catalog only lists flaws with evidence of exploitation in the wild (CISA KEV catalog).
Which versions of Apache Axis are affected?
The NVD description says it “affects all Apache Axis 1.x versions through 1.4”, and the record names the axis:axis and org.apache.axis:axis Maven packages up to 1.4 (NVD, NVD API record). The advisory says the project does not expect to release a fixed 1.x version, and points to a build with the source fix in commit 41f3b4e applied as the alternative (oss-security).
Is Apache Axis2 affected by CVE-2026-90436?
The advisory does not name Axis2 as affected; it recommends Axis2/Java as the engine to migrate to (oss-security). Axis2 is a separate codebase, so check it against its own advisories.
Does authentication on my Axis service protect it?
No. The advisory says the fault is parsed before any per-service handler chain runs, so authentication handlers configured on a service do not protect against it (oss-security). Only network controls in front of Axis, or removing it, keep an anonymous request away from the parser.
Do I need to rotate secrets if I closed the endpoint quickly?
For an internet-facing Axis service, we would rotate its client secrets and service account passwords anyway, because they are cheap to change and the logs rarely prove that nothing happened. Keystores and user passwords can wait for evidence of compromise.
What to do next
Inventory your Axis 1.x services today: search for the jars and the Maven coordinates, then find which of them have live endpoints. Restrict or block those endpoints at the edge, look for the signs of exploitation above, and rotate the client secrets, directory and database credentials, service account passwords and keystores the services held, in that order, then revoke sessions and tokens. Then plan each service’s move to a supported OIDC login on Keycloak, with client credentials for system callers and the authorization code flow for users.
If you would rather not run the Keycloak side of that move yourself, Skycloak’s managed Keycloak hosting runs and patches the Keycloak clusters for you, so your team can focus on retiring the old services.
Sources
- NVD, CVE-2026-90436, retrieved 2026-11-21, https://nvd.nist.gov/vuln/detail/CVE-2026-90436
- NVD, CVE API record for CVE-2026-90436, retrieved 2026-11-21, https://services.nvd.nist.gov/rest/json/cves/2.0?cveId=CVE-2026-90436
- CISA, Known Exploited Vulnerabilities catalog, CVE-2026-90436, checked 2026-11-21, https://www.cisa.gov/known-exploited-vulnerabilities-catalog?field_cve=CVE-2026-90436
- oss-security, “CVE-2026-90436: Apache Axis 1.x (EOL): unauthenticated remote class instantiation via SOAP fault exceptionName”, 6 November 2026, https://www.openwall.com/lists/oss-security/2026/11/06/12
- Apache Axis, commit 41f3b4e, “Prevent arbitrary class instantiation from SOAP fault exceptionName”, https://github.com/apache/axis-axis1-java/commit/41f3b4e8d04e310ca81f86b92630ab2c11d608bd
- Apache Axis, project page, retrieved 2026-11-21, https://axis.apache.org/axis/
- Apache Axis, installation guide, retrieved 2026-11-21, https://axis.apache.org/axis/java/install.html
- Apache Axis, security guide, retrieved 2026-11-21, https://axis.apache.org/axis/java/security.html
- Apache Axis, user guide, retrieved 2026-11-21, https://axis.apache.org/axis/java/user-guide.html
- Apache Axis2/Java, project page, retrieved 2026-11-21, https://axis.apache.org/axis2/java/core/
- OpenID Foundation, OpenID Connect Core 1.0, https://openid.net/specs/openid-connect-core-1_0.html
- Keycloak, documentation, https://www.keycloak.org/documentation
- Keycloak, Server Administration Guide, https://www.keycloak.org/docs/latest/server_admin/index.html (sections “Confidential client credentials”, “Revoking active sessions”, “Offline access” and “Service accounts”)




