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 + * <exceptionName> 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 <Fault> whose + * <detail> carries an <exceptionName> 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
