Script 'mail_helper' called by obssrc
Hello community,

here is the log from the commit of package axis for openSUSE:Factory checked in 
at 2026-11-17 17:21:22
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/axis (Old)
 and      /work/SRC/openSUSE:Factory/.axis.new.1251 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "axis"

Tue Nov 17 17:21:22 2026 rev:44 rq:1398162 version:1.4

Changes:
--------
--- /work/SRC/openSUSE:Factory/axis/axis.changes        2025-09-05 
21:44:28.939600865 +0200
+++ /work/SRC/openSUSE:Factory/.axis.new.1251/axis.changes      2026-11-17 
17:24:05.516982922 +0100
@@ -1,0 +2,8 @@
+Tue Nov 17 13:04:13 UTC 2026 - Fridrich Strba <[email protected]>
+
+- Added patch:
+  * axis-CVE-2026-90436.patch
+    + Upstream fix for bsc#1290492 (CVE-2026-90436): Remote code
+      execution via insecure deserialization of SOAP fault messages
+
+-------------------------------------------------------------------

New:
----
  axis-CVE-2026-90436.patch

----------(New B)----------
  New:- Added patch:
  * axis-CVE-2026-90436.patch
    + Upstream fix for bsc#1290492 (CVE-2026-90436): Remote code
----------(New E)----------

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ axis.spec ++++++
--- /var/tmp/diff_new_pack.eNz4CB/_old  2026-11-17 17:24:06.619029838 +0100
+++ /var/tmp/diff_new_pack.eNz4CB/_new  2026-11-17 17:24:06.621029923 +0100
@@ -54,6 +54,8 @@
 Patch10:        unimplemented-saaj13-methods.patch
 # PATCH-FIX-UPSTREAM bsc#1218605 CVE-2023-51441 SSRF when untrusted input is 
passed to the service admin HTTP API
 Patch11:        axis-CVE-2023-51441.patch
+# PATCH-FIX-UPSTREAM bsc#1290492 CVE-2026-90436 Remote code execution via 
insecure deserialization of SOAP fault messages 
+Patch12:        axis-CVE-2026-90436.patch
 BuildRequires:  ant
 BuildRequires:  ant-jdepend
 BuildRequires:  antlr
@@ -108,6 +110,7 @@
 %patch -P 9 -p1
 %patch -P 10 -p1
 %patch -P 11 -p1
+%patch -P 12 -p1
 
 # Remove provided binaries
 find . "(" -name "*.jar" -o -name "*.zip" -o -name "*.class" ")" -delete

++++++ _scmsync.obsinfo ++++++
--- /var/tmp/diff_new_pack.eNz4CB/_old  2026-11-17 17:24:06.658031498 +0100
+++ /var/tmp/diff_new_pack.eNz4CB/_new  2026-11-17 17:24:06.662031669 +0100
@@ -1,6 +1,6 @@
-mtime: 1757055172
-commit: aaea55b336abee83de88d55c238efbbeab0cc55c782bee3bdcbb8a2136ce07d8
-url: https://src.opensuse.org/java-packages/axis.git
-revision: aaea55b336abee83de88d55c238efbbeab0cc55c782bee3bdcbb8a2136ce07d8
+mtime: 1794920757
+commit: 21ab3d4cc29a4a6e69d7b1abd32223f962001675ddd64ea92ce30c14ee86fd39
+url: https://src.opensuse.org/java-packages/axis
+revision: 21ab3d4cc29a4a6e69d7b1abd32223f962001675ddd64ea92ce30c14ee86fd39
 projectscmsync: https://src.opensuse.org/java-packages/_ObsPrj
 

++++++ axis-CVE-2026-90436.patch ++++++
--- axis-1_4/src/org/apache/axis/message/SOAPFaultBuilder.java  2026-11-17 
13:55:32.302649008 +0100
+++ axis-1_4/src/org/apache/axis/message/SOAPFaultBuilder.java  2026-11-17 
14:00:59.255082517 +0100
@@ -161,6 +161,12 @@
                         // We need to create the exception,
                         // passing the data to the constructor.
                         Class argClass = ConvertWrapper(faultData.getClass());
+                        // 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(
@@ -170,6 +176,7 @@
                             // Don't do anything here, since a problem above 
means
                             // we'll just fall through and use a plain 
AxisFault.
                         }
+                        }
                         if (f == null && faultData instanceof Exception) {
                             f = AxisFault.makeFault((Exception)faultData);    
                         }
--- axis-1_4/src/org/apache/axis/message/SOAPFaultDetailsBuilder.java   
2026-11-17 13:55:32.303629314 +0100
+++ axis-1_4/src/org/apache/axis/message/SOAPFaultDetailsBuilder.java   
2026-11-17 14:00:59.255249021 +0100
@@ -28,6 +28,8 @@
 import org.apache.axis.soap.SOAPConstants;
 import org.apache.axis.utils.ClassUtils;
 import org.apache.axis.utils.Messages;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
 
@@ -42,6 +44,9 @@
  */
 public class SOAPFaultDetailsBuilder extends SOAPHandler implements Callback
 {
+    protected static Log log =
+            LogFactory.getLog(SOAPFaultDetailsBuilder.class.getName());
+
     protected SOAPFaultBuilder builder;
     
     public SOAPFaultDetailsBuilder(SOAPFaultBuilder builder) {
@@ -180,8 +185,19 @@
         } else if ("exceptionName".equals(hint)) {
             String faultClassName = (String) value;
             try {
-                Class faultClass = ClassUtils.forName(faultClassName);
+                // The class name here comes straight from the inbound message
+                // and is therefore untrusted. Load it without initializing it
+                // (so no static initializer runs) and only accept it if it is
+                // an AxisFault subtype. This prevents an unauthenticated 
caller
+                // from loading and instantiating arbitrary classpath classes
+                // via a <detail><exceptionName> element.
+                Class faultClass = ClassUtils.forName(faultClassName, false);
+                if (AxisFault.class.isAssignableFrom(faultClass)) {
                 builder.setFaultClass(faultClass);
+                } else if (log.isDebugEnabled()) {
+                    log.debug("Ignoring fault exceptionName '" + faultClassName
+                            + "': not an org.apache.axis.AxisFault subtype");
+                }
             } catch (ClassNotFoundException e) {
                 // Just create an AxisFault, no custom exception
             }
--- axis-1_4/src/org/apache/axis/utils/ClassUtils.java  2026-11-17 
13:55:32.299344444 +0100
+++ axis-1_4/src/org/apache/axis/utils/ClassUtils.java  2026-11-17 
14:00:59.255409714 +0100
@@ -97,7 +97,23 @@
      */
     public static Class forName(String className)
             throws ClassNotFoundException {
-        return loadClass(className);
+        return loadClass(className, true);
+    }
+
+    /**
+     * Use this method instead of Class.forName when the class should be
+     * located but not necessarily initialized. Passing <code>false</code>
+     * avoids running the named class's static initializer, which is
+     * important when the class name comes from untrusted input.
+     *
+     * @param className Class name
+     * @param initialize whether to initialize the class
+     * @return java class
+     * @throws ClassNotFoundException if the class is not found
+     */
+    public static Class forName(String className, boolean initialize)
+            throws ClassNotFoundException {
+        return loadClass(className, initialize);
     }
 
     /**
@@ -117,6 +133,7 @@
         // Create final vars for doPrivileged block
         final String className = _className;
         final ClassLoader loader = _loader;
+        final boolean initialize = init;
         try {
             // Get the class within a doPrivleged block
             Object ret = 
@@ -124,7 +141,7 @@
                     new PrivilegedAction() {
                         public Object run() {
                             try {
-                                return Class.forName(className, true, loader);
+                                return Class.forName(className, initialize, 
loader);
                             } catch (Throwable e) {
                                 return e;
                             }
@@ -139,7 +156,7 @@
                 throw new ClassNotFoundException(_className);
             }
         } catch (ClassNotFoundException cnfe) {
-            return loadClass(className);
+            return loadClass(className, init);
         }
     }
 
@@ -148,13 +165,15 @@
      * getDefaultClassLoader().forName
      *
      * @param _className Class name
+     * @param initialize whether to initialize the class
      * @return java class
      * @throws ClassNotFoundException if the class is not found
      */
-    private static Class loadClass(String _className)
+    private static Class loadClass(String _className, boolean initialize)
             throws ClassNotFoundException {
         // Create final vars for doPrivileged block
         final String className = _className;
+        final boolean init = initialize;
 
         // Get the class within a doPrivleged block
         Object ret = 
@@ -174,13 +193,13 @@
                                 // Try the context class loader
                                 ClassLoader classLoader =
                                     
Thread.currentThread().getContextClassLoader();
-                                return Class.forName(className, true, 
classLoader);
+                                return Class.forName(className, init, 
classLoader);
                             } catch (ClassNotFoundException cnfe2) {
                                 try {
                                     // Try the classloader that loaded this 
class.
                                     ClassLoader classLoader =
                                         ClassUtils.class.getClassLoader();
-                                    return Class.forName(className, true, 
classLoader);
+                                    return Class.forName(className, init, 
classLoader);
                                 } catch (ClassNotFoundException cnfe3) {
                                     // Try the default class loader.
                                     try {
--- axis-1_4/src/test/java/test/faults/FaultGadgetProbe.java    1970-01-01 
01:00:00.000000000 +0100
+++ axis-1_4/src/test/java/test/faults/FaultGadgetProbe.java    2026-11-17 
14:00:59.255690068 +0100
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package test.faults;
+
+/**
+ * A stand-in for a dangerous "gadget" class (e.g. Spring's
+ * ClassPathXmlApplicationContext) named by an inbound SOAP fault's
+ * &lt;exceptionName&gt; element. It records whether its static initializer
+ * runs (i.e. the class was loaded with initialization) and whether its
+ * String constructor is invoked. It is deliberately not an AxisFault, so a
+ * correctly hardened deserializer must never load-and-initialize or
+ * construct it. See {@link TestFaultClassInstantiation}.
+ */
+public class FaultGadgetProbe {
+    static {
+        FaultGadgetState.staticInitRan = true;
+    }
+
+    public FaultGadgetProbe(String url) {
+        FaultGadgetState.constructorRan = true;
+    }
+}
--- axis-1_4/src/test/java/test/faults/FaultGadgetState.java    1970-01-01 
01:00:00.000000000 +0100
+++ axis-1_4/src/test/java/test/faults/FaultGadgetState.java    2026-11-17 
14:00:59.255771290 +0100
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package test.faults;
+
+/**
+ * Holder for the {@link FaultGadgetProbe} instrumentation flags. Kept in a
+ * separate class so that a test can inspect the flags without itself
+ * triggering initialization of {@link FaultGadgetProbe} (which would run the
+ * probe's static initializer and defeat the point of the check).
+ */
+public class FaultGadgetState {
+    public static volatile boolean staticInitRan = false;
+    public static volatile boolean constructorRan = false;
+
+    public static void reset() {
+        staticInitRan = false;
+        constructorRan = false;
+    }
+}
--- axis-1_4/src/test/java/test/faults/TestFaultClassInstantiation.java 
1970-01-01 01:00:00.000000000 +0100
+++ axis-1_4/src/test/java/test/faults/TestFaultClassInstantiation.java 
2026-11-17 14:00:59.255907503 +0100
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package test.faults;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import org.apache.axis.AxisFault;
+import org.apache.axis.Message;
+import org.apache.axis.MessageContext;
+import org.apache.axis.message.SOAPBodyElement;
+import org.apache.axis.message.SOAPEnvelope;
+import org.apache.axis.message.SOAPFault;
+import org.apache.axis.server.AxisServer;
+
+/**
+ * Security regression test: an inbound SOAP &lt;Fault&gt; whose
+ * &lt;detail&gt; carries an &lt;exceptionName&gt; naming an arbitrary
+ * (non-fault) class must not cause that class to be loaded-and-initialized
+ * or constructed. This is the shape of the unauthenticated
+ * class-instantiation / RCE reported against Axis 1.x's fault deserializer
+ * (analogous to CVE-2023-46604 in Apache ActiveMQ).
+ */
+public class TestFaultClassInstantiation extends TestCase {
+
+    public TestFaultClassInstantiation(String name) {
+        super(name);
+    }
+
+    public static Test suite() {
+        return new TestSuite(TestFaultClassInstantiation.class);
+    }
+
+    public void testExceptionNameDoesNotInstantiateArbitraryClass()
+            throws Exception {
+        FaultGadgetState.reset();
+
+        // Note: the class named in <exceptionName> is referenced only as a
+        // string here, so the JVM does not load it on our behalf; the only
+        // way it can be touched is via the fault deserialization path.
+        String gadget = "test.faults.FaultGadgetProbe";
+        String messageText =
+              "<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\">http://attacker.example/payload</data>"
+            + "        <exceptionName>" + gadget + "</exceptionName>"
+            + "      </detail>"
+            + "    </soap:Fault>"
+            + "  </soap:Body>"
+            + "</soap:Envelope>";
+
+        AxisServer server = new AxisServer();
+        Message message = new Message(messageText);
+        message.setMessageContext(new MessageContext(server));
+
+        SOAPEnvelope envelope = (SOAPEnvelope) message.getSOAPEnvelope();
+        SOAPBodyElement respBody = envelope.getFirstBody();
+        assertTrue("respBody should be a SOAPFault",
+                   respBody instanceof SOAPFault);
+
+        // Force fault materialization (defensive; getFirstBody already 
parses).
+        AxisFault aFault = ((SOAPFault) respBody).getFault();
+
+        assertFalse("gadget constructor must not be invoked",
+                    FaultGadgetState.constructorRan);
+        assertFalse("gadget class must not be initialized (no static init)",
+                    FaultGadgetState.staticInitRan);
+
+        // The fault must still deserialize gracefully as a plain AxisFault.
+        assertNotNull("Fault should still be produced", aFault);
+    }
+
+    public void testLegitimateAxisFaultSubtypeStillDeserializes()
+            throws Exception {
+        // A genuine AxisFault subtype named via <exceptionName> must still
+        // work, so the hardening does not break the legitimate feature.
+        String faultClass = "org.apache.axis.AxisFault";
+        String messageText =
+              "<soap:Envelope"
+            + " xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\";>"
+            + "  <soap:Body>"
+            + "    <soap:Fault>"
+            + "      <faultcode>Some.Code</faultcode>"
+            + "      <faultstring>boom</faultstring>"
+            + "      <detail>"
+            + "        <exceptionName>" + faultClass + "</exceptionName>"
+            + "      </detail>"
+            + "    </soap:Fault>"
+            + "  </soap:Body>"
+            + "</soap:Envelope>";
+
+        AxisServer server = new AxisServer();
+        Message message = new Message(messageText);
+        message.setMessageContext(new MessageContext(server));
+
+        SOAPEnvelope envelope = (SOAPEnvelope) message.getSOAPEnvelope();
+        SOAPBodyElement respBody = envelope.getFirstBody();
+        AxisFault aFault = ((SOAPFault) respBody).getFault();
+
+        assertNotNull("Fault should be produced", aFault);
+        assertEquals("faultString should round-trip",
+                     "boom", aFault.getFaultString());
+    }
+}

++++++ build.specials.obscpio ++++++

++++++ build.specials.obscpio ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/.gitignore new/.gitignore
--- old/.gitignore      1970-01-01 01:00:00.000000000 +0100
+++ new/.gitignore      2026-11-17 14:05:57.000000000 +0100
@@ -0,0 +1 @@
+.osc

Reply via email to