79 % contre 51 % : les néobanques indépendantes en retard sur la sécurité des applications. Lire le rapport

Analyse approfondie

Analyse approfondie

Apache Axis 1.x : RCE par défaut SOAP, exploitée (CVE-2026-90436)

Apache Axis 1.x charge et instancie la classe nommée dans un défaut SOAP non authentifié, ce qui permet une RCE ; migrez ou appliquez le correctif.

En bref

  • Un défaut SOAP non authentifié peut nommer n'importe quelle classe présente dans le classpath du serveur. Apache Axis 1.x charge cette classe et appelle son constructeur de type String avant de vérifier qu'il s'agit d'un AxisFault.
  • Toutes les versions d'Axis 1.x jusqu'à 1.4 sont concernées. Le projet est en fin de vie et ne publiera pas de version corrigée.
  • Le record Vulnrichment de la CISA attribue à CVE-2026-90436 un score CVSS v3.1 de 9,8 Critique, et la CISA l'a ajoutée au catalogue des vulnérabilités exploitées le 2026-11-18, avec une échéance fédérale au 2026-11-21.
  • Migrez vers un moteur SOAP maintenu, ou compilez Axis 1.x avec le commit 41f3b4e appliqué. La section « Comment corriger ? » décrit les deux voies.

Suis-je concerné ?

Toutes ces conditions doivent être réunies pour qu'un système soit exposé à une exécution de code à distance :

  • Un runtime Apache Axis 1.x se trouve dans le classpath d'un service joignable par le réseau. Les coordonnées Maven sont axis:axis et org.apache.axis:axis, et toutes les versions jusqu'à 1.4 sont concernées.
  • La servlet Axis ou un point de terminaison de service analyse les requêtes SOAP entrantes. Un frontal qui rejette les défauts SOAP avant qu'Axis ne les voie supprime le chemin d'attaque.
  • Une classe du même classpath effectue une action dangereuse dans son initialiseur statique ou dans un constructeur de type String. Sans une telle classe, la requête peut tout de même charger et construire une classe nommée par l'attaquant, ce qui peut faire planter le processus.
Branche Versions concernées Version corrigée
Apache Axis 1.x Toutes les versions jusqu'à 1.4 Aucune version. Compilez avec le commit 41f3b4e8 ou migrez vers un moteur SOAP maintenu

La version 1.4, la dernière, est sortie le 2006-05-31. Apache a classé Axis 1 en fin de vie et indique qu'il ne prévoit pas de publier une version 1.x pour cette faille. Le commit de correction a été écrit le 2026-07-12. libraries.io recense 97 paquets et 31 dépôts qui dépendent de axis:axis, un décompte qui exclut les applications propriétaires qui embarquent le JAR.

Vérifiez la dépendance dans chaque build et dans l'application déployée :

# 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'

Pour un conteneur en cours d'exécution, inspectez l'image plutôt qu'une image fraîchement tirée :

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

Une dépendance directe est facile à voir. Une dépendance transitive n'apparaît que dans l'arbre résolu, et un JAR copié dans le répertoire lib d'un serveur d'applications n'apparaît ni dans l'un ni dans l'autre. Cherchez dans la sortie du build et dans les artefacts déployés.

Comment corriger ?

La correction complète consiste à retirer Axis 1.x du classpath. Apache recommande de migrer vers Apache Axis 2/Java ou vers un autre moteur SOAP maintenu. C'est la seule voie qui ne dépend pas de la compilation d'une branche sans support.

  1. Inventoriez chaque service qui résout axis:axis ou org.apache.axis:axis, y compris les serveurs d'applications et les produits éditeurs qui embarquent le JAR.
  2. Migrez ces services vers un moteur SOAP pris en charge. Axis 2/Java est la recommandation du projet, mais tout moteur maintenu supprime cet analyseur.
  3. Si un service ne peut pas migrer tout de suite, compilez Axis 1.x depuis le commit corrigé et remplacez le JAR du runtime. Le projet se compile avec 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. Déployez le JAR axis-rt-core reconstruit avec le reste du runtime Axis 1.x, puis retestez les services SOAP. Un correctif sur un module ne supprime pas les autres copies d'Axis qu'un produit éditeur peut charger depuis son propre répertoire.

Apache ne publie aucun contournement de configuration. Bloquer les éléments <detail> sur un reverse proxy ou un pare-feu applicatif réduit l'exposition, mais il s'agit d'un filtre devant un analyseur qui accepte toujours l'élément. Traitez ce filtre comme une mesure provisoire, pas comme un correctif.

Quelle est la cause racine ?

Axis 1.x fait confiance au nom de classe contenu dans l'élément <exceptionName> d'un défaut SOAP et le charge avec initialisation avant de vérifier le type de la classe. Deux chemins de code se combinent : l'un charge la classe, l'autre appelle un constructeur sur celle-ci.

Le premier chemin est SOAPFaultDetailsBuilder.setValue(), dans axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultDetailsBuilder.java, lignes 180 à 188 de la source 1.4 :

} 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 vient directement du corps de la requête. ClassUtils.forName(String) appelle loadClass(), qui appelle Class.forName(className, true, loader) à la ligne 88 de ClassUtils.java. Le true initialise la classe, donc son initialiseur statique s'exécute dès l'analyse de l'élément. Aucune vérification de type n'a lieu à ce stade.

Le second chemin est SOAPFaultBuilder.createFault(), dans SOAPFaultBuilder.java, lignes 162 à 175. Lorsque le défaut porte aussi un élément <data>, Axis appelle par réflexion le constructeur de type String de la classe nommée, avec la chaîne de l'attaquant :

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

Le transtypage (AxisFault) intervient après que newInstance() a déjà construit l'objet. Si la classe n'est pas un AxisFault, le transtypage lève ClassCastException, le bloc catch vide l'avale, et l'exécution continue avec un défaut simple. La vérification isAssignableFrom qui aurait pu arrêter la construction se trouve à la ligne 181, après l'appel du constructeur.

Le défaut est analysé pendant que le moteur résout le service cible, avant l'exécution de toute chaîne de gestionnaires propre au service. Les gestionnaires d'authentification configurés sur un service ne voient donc pas la requête en premier.

Comment la faille est-elle exploitée ?

Un attaquant non authentifié envoie un défaut SOAP dont l'élément <detail> nomme une classe déjà présente dans le classpath de la cible. La classe est chargée et initialisée pendant l'analyse, et si un élément <data> est présent, son constructeur de type String est appelé avec une entrée contrôlée par l'attaquant.

Le test de régression public du commit de correction construit la requête de cette forme :

<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. L'attaquant choisit une classe présente dans l'application cible ou dans ses bibliothèques. Le commit de correction cite ClassPathXmlApplicationContext de Spring, le gadget utilisé dans CVE-2023-46604, comme exemple.
  2. L'attaquant envoie le défaut à un point de terminaison Axis joignable. La requête n'a besoin ni d'une opération valide, ni d'une session, ni d'identifiants.
  3. SOAPFaultDetailsBuilder.setValue() charge la classe avec Class.forName(..., true, ...). Un initialiseur statique s'exécute à cette étape.
  4. Si un élément <data> est présent, SOAPFaultBuilder.createFault() appelle le constructeur de type String de la classe avec la chaîne fournie.
  5. La vérification AxisFault n'a lieu qu'après le constructeur, donc une classe qui n'est pas un type de défaut a déjà exécuté son code. L'erreur de transtypage qui suit est avalée.
  6. Le code exécuté dans l'initialiseur statique ou le constructeur s'exécute dans le processus Axis avec les privilèges de ce processus.

L'avis ne publie aucune preuve de concept, et le record CVE n'en lie aucune. Le commit de correction contient un test de régression avec une classe sonde inoffensive qui enregistre si son initialiseur statique et son constructeur se sont exécutés. L'évaluation SSVC de la CISA classe l'exploitation comme active et automatisable.

Comment se déroule l'attaque ?

Un défaut SOAP non authentifié nomme une classe, Axis la charge et la construit avant la vérification AxisFault, et le code de cette classe s'exécute dans le processus du serveur.

flowchart LR A["Défaut SOAP avec
exceptionName et data"] --> B["Résolution du service cible
avant la chaîne de gestionnaires"] B --> C["Chargement de la classe nommée
l'initialiseur statique s'exécute"] C --> D["Appel du constructeur String
avec les données de l'attaquant"] D --> E{"Sous-type d'AxisFault ?"} E -->|"Non"| F["Le transtypage échoue, erreur avalée
le code s'est déjà exécuté"] E -->|"Oui"| G["Défaut personnalisé normal"]

Que peut faire un attaquant ?

Un attaquant peut exécuter du code dans le processus Axis sans authentification lorsqu'une classe adaptée se trouve dans le classpath. L'évaluation SSVC de la CISA classe l'impact technique comme total.

  • Exécution de code à distance avec l'utilisateur qui fait tourner la servlet Axis ou le serveur d'applications. Cet utilisateur peut généralement lire la configuration de l'application, les identifiants de base de données et les clés de signature.
  • Chargement et construction de classes même sans gadget utilisable. Une classe dont l'initialiseur statique ou le constructeur échoue, bloque ou alloue beaucoup peut faire planter ou bloquer le service.
  • Accès à toutes les applications qui partagent le classpath, y compris les bibliothèques embarquées par un éditeur dans le serveur.

L'impact d'exécution de code exige une classe dont l'initialiseur statique ou le constructeur String effectue une action voulue par l'attaquant. L'impact de chargement de classe ne demande qu'un nom de classe. Un service qui expose Axis sans gadget utilisable reste exposé à un déni de service et à tout gadget futur ajouté à ses dépendances.

Pourquoi le correctif fonctionne-t-il ?

Le correctif ajoute une vérification du type AxisFault avant l'initialisation ou la construction de la classe, et il fait respecter le chargement sans initialisation par le chargeur de classes. Les véritables sous-classes d'AxisFault se désérialisent toujours.

--- 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() charge désormais la classe avec ClassUtils.forName(faultClassName, false) et ne l'accepte que si AxisFault.class.isAssignableFrom(faultClass) est vrai. Le false arrive jusqu'à Class.forName(className, false, loader), donc un initialiseur statique ne s'exécute pas pendant la vérification de type. Une classe qui n'est pas un défaut est ignorée et un AxisFault simple est produit.

ClassUtils gagne une méthode forName à deux arguments et transmet maintenant l'indicateur initialize à sa surcharge à trois arguments. Avant le changement, cette surcharge ignorait son paramètre init et appelait toujours Class.forName(className, true, loader).

Le test de régression envoie la même forme SOAP contre une classe sonde et vérifie que ni son initialiseur statique ni son constructeur ne se sont exécutés. Un second test envoie un véritable org.apache.axis.AxisFault et vérifie que la chaîne de défaut effectue toujours l'aller-retour. Le correctif est complet pour les chemins d'analyse qu'il touche. Axis 1.x n'a plus de support de sécurité, donc une nouvelle faille ne sera pas corrigée.

Comment vérifier si j'ai été compromis ?

Apache ne publie aucun indicateur de compromission pour cette faille. La CISA a ajouté la faille au catalogue KEV parce que l'exploitation est connue. Ni l'avis de l'éditeur ni le record KEV ne nomment une victime, une adresse IP ou une charge utile.

Vérifiez les endroits où un corps SOAP ou une requête rejetée serait enregistré :

# 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

Une occurrence de exceptionName dans un corps de requête conservé est une piste, pas une preuve, car des défauts SOAP légitimes peuvent porter l'élément. Une occurrence dans une capture de paquets ou une passerelle qui journalise les corps est plus solide.

L'analyseur avale l'échec de transtypage, et Axis ne journalise pas le nom de classe par défaut. Une tentative qui n'a pas atteint de gadget utilisable peut donc ne laisser aucune trace au-delà du journal de requêtes. Si le service ne journalise pas les corps de requête et n'a pas de WAF devant lui, l'absence de preuve n'est pas la preuve qu'aucune tentative ne l'a atteint.

Chronologie

  • 2006-05-31 : Apache Axis 1.4 sort, la dernière version 1.x.
  • 2026-07-12 : Robert Lazarski écrit le commit 41f3b4e8, qui durcit le désérialiseur de défauts.
  • 2026-11-06 : Apache publie l'avis et CVE-2026-90436.
  • 2026-11-17 : L'évaluation SSVC de la CISA classe l'exploitation comme active et automatisable.
  • 2026-11-18 : La CISA ajoute CVE-2026-90436 au catalogue des vulnérabilités exploitées.
  • 2026-11-21 : Échéance fédérale de remédiation pour l'entrée KEV.

Chronologie de CVE-2026-90436 : la sortie d'Axis 1.4 en 2006, le commit de correction de juillet 2026, l'avis de novembre 2026, l'évaluation d'exploitation de la CISA, l'ajout au KEV et l'échéance fédérale
Figure 1 : Du commit de correction à l'échéance KEV de la CISA, 129 jours se sont écoulés. Source : avis Apache, record CVE et catalogue KEV de la CISA, vérifiés le 20 novembre 2026.

FAQ

Apache Axis 1.x est-il encore pris en charge ?

Non. Apache a classé Axis 1 en fin de vie, et l'avis indique que le projet ne prévoit pas de publier une version 1.x pour cette faille. Les services qui tournent encore sous Axis 1.x doivent migrer ou appliquer un correctif compilé localement.

Un gestionnaire d'authentification sur mon service bloque-t-il l'attaque ?

Non. Axis analyse le défaut pendant qu'il résout le service cible, avant l'exécution de la chaîne de gestionnaires propre au service. Un gestionnaire d'authentification sur le service ne voit jamais la requête qui déclenche le chargement de classe.

Existe-t-il un exploit public ?

Aucun code d'exploit public n'est lié depuis l'avis ou le record CVE. L'évaluation SSVC de la CISA classe l'exploitation comme active, donc un exploit fonctionnel existe hors du domaine public. Le commit de correction contient un test de régression qui démontre le chargement de classe et l'appel du constructeur avec une sonde inoffensive.

Quelles versions d'Axis 2 sont concernées ?

Aucune par ce CVE. CVE-2026-90436 se trouve dans le désérialiseur de défauts d'Axis 1.x, et l'avis le limite à Axis 1.x jusqu'à 1.4. Axis 2/Java est la cible de migration recommandée par Apache.

Puis-je garder Axis 1.x et bloquer l'élément de défaut sur mon proxy ?

Vous pouvez réduire l'exposition, mais Apache ne publie aucun contournement. Une règle de proxy qui rejette <detail> ou <exceptionName> dans les défauts SOAP est une mesure provisoire devant un analyseur qui accepte toujours l'élément. Appliquez le correctif ou migrez.

Le correctif casse-t-il les défauts SOAP personnalisés ?

Non. Les véritables sous-classes de org.apache.axis.AxisFault se chargent et se désérialisent toujours, et le commit de correction ajoute un test de régression pour ce cas. Seules les classes qui ne sont pas des sous-types d'AxisFault sont ignorées.

Trouver les services Apache Axis exposés avec Ostorlab

La découverte de surface d'attaque d'Ostorlab inventorie les hôtes et services exposés à Internet. Elle aide à trouver les points de terminaison SOAP et les serveurs d'applications qui exposent encore Axis 1.x avant l'échéance KEV.

Références

  • 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 (vérifié le 20 novembre 2026)
  • CVE Program, CVE-2026-90436, avec le score CVSS v3.1 9.8 et l'évaluation SSVC du Vulnrichment de la CISA : https://www.cve.org/CVERecord?id=CVE-2026-90436 (vérifié le 20 novembre 2026)
  • Apache Axis, commit de correction 41f3b4e8d04e310ca81f86b92630ab2c11d608bd : https://github.com/apache/axis-axis1-java/commit/41f3b4e8d04e310ca81f86b92630ab2c11d608bd (vérifié le 20 novembre 2026)
  • Apache Axis, source vulnérable au parent du correctif, SOAPFaultBuilder.java : https://github.com/apache/axis-axis1-java/blob/f19d6dfae6c1a4be379a5693d9ef3bdb6b959630/axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultBuilder.java (vérifié le 20 novembre 2026)
  • Apache Axis, source vulnérable au parent du correctif, SOAPFaultDetailsBuilder.java : https://github.com/apache/axis-axis1-java/blob/f19d6dfae6c1a4be379a5693d9ef3bdb6b959630/axis-rt-core/src/main/java/org/apache/axis/message/SOAPFaultDetailsBuilder.java (vérifié le 20 novembre 2026)
  • Apache Axis, source vulnérable au parent du correctif, ClassUtils.java : https://github.com/apache/axis-axis1-java/blob/f19d6dfae6c1a4be379a5693d9ef3bdb6b959630/axis-rt-core/src/main/java/org/apache/axis/utils/ClassUtils.java (vérifié le 20 novembre 2026)
  • Catalogue des vulnérabilités exploitées de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)
  • libraries.io, nombres de dépendances de axis:axis : https://libraries.io/maven/axis:axis (vérifié le 20 novembre 2026)
  • Maven Central, axis:axis:1.4 : https://central.sonatype.com/artifact/axis/axis/1.4 (vérifié le 20 novembre 2026)
  • oss-security, annonce « CVE-2026-90436: Apache Axis 1.x (EOL) » : https://www.openwall.com/lists/oss-security/2026/11/06/12 (vérifié le 20 novembre 2026)