memshell-party-cli 0.3.4 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memshell-party-cli",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Command-line client and MCP server for MemShellParty (party.mem.mk) — generate Java memory shells and probes from the terminal.",
   "keywords": [
     "memshell",

package/skills/memshell-party/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: memshell-party
-description: Generate Java memory shells and probe shells with MemShellParty (the `memparty` CLI or its MCP tools), verify deployed shells with `memparty connect`, run commands on them with `memparty exec`, and transfer files with `memparty upload`/`memparty download`. Use when the user wants to build a Java web memory-shell payload (Godzilla / Behinder / AntSword / Command / Suo5 / NeoreGeorg / Proxy / Custom), probe a target middleware, test that a Godzilla / Behinder / suo5 shell is alive, execute commands on a Godzilla / Behinder shell, or move files through one — for authorized security testing, red-team engagements, or research only.
+description: Generate Java memory shells and probe shells with MemShellParty (the `memparty` CLI or its MCP tools), verify deployed shells with `memparty connect`, run commands on them with `memparty exec`, and transfer files with `memparty upload`/`memparty download`. Includes the `mimic` site-mimicking protocol: the agent hand-writes a site profile (`memparty profile init`) so shell traffic blends into real business pages. Use when the user wants to build a Java web memory-shell payload (Godzilla / Behinder / AntSword / Command / Suo5 / NeoreGeorg / Proxy / Custom), probe a target middleware, test that a Godzilla / Behinder / suo5 shell is alive, execute commands on a Godzilla / Behinder shell, or move files through one — for authorized security testing, red-team engagements, or research only.
 ---
 
 # MemShellParty skill
@@ -220,6 +220,178 @@ Over MCP these are the `download_file` (`remotePath`, optional `localPath`, `for
 `upload_file` (`localPath`, `remotePath`) tools, plus the usual connection fields. The local
 paths are on the machine running the MCP server.
 
+## Site-mimicking traffic (mimic protocol)
+
+`mimic` is a demo protocol that shapes shell traffic after the target site's own pages:
+requests are browser-style form POSTs; responses are real site pages with the ciphertext
+hidden in a per-shell-unique JS variable (`var Re<md5(pass+key)[0:5]>_config="..."`).
+**You write the site profile — the CLI does not crawl.** That is the point: you can judge
+which page makes believable cover; a regex crawler cannot.
+
+### Workflow
+
+1. **Read the site yourself.** Fetch the homepage and 2-3 representative pages (plus the 404
+   page). Note the page structure, `<title>` style, link paths, Content-Type — and judge what
+   the site's **dominant traffic** looks like: a content site serves mostly HTML documents,
+   an SPA serves mostly JSON XHR, an admin console serves mostly form POSTs.
+2. **Match the dominant traffic first.** Blending in is a statistics game: your requests
+   should be the same *shape* as what the site already serves all day. Today mimic speaks
+   HTML pages only — so on a content site mimic the high-traffic documents (homepage, list
+   pages); on an SPA/API site an HTML skin is the wrong shape (a JSON envelope skin is the
+   planned follow-up), and forcing it makes you *more* visible, not less.
+3. **Scaffold + hand-write the profile:**
+
+   ```bash
+   memparty profile init acme --site http://target:8080
+   ```
+
+   This writes a skeleton to `~/.memparty/profiles/acme.json`. Now **edit that file with your
+   own file tools** — the CLI has no "fill" command; the content is your judgment, not a
+   command's output. Fill in:
+   - `templates`: **one or more** cover pages — the server rotates among them per response,
+     so the traffic doesn't repeat one page's length/hash. 2-4 pages is plenty; pick
+     **high-traffic, self-contained** ones (the pages real users fetch all the time), and
+     paste each HTML **verbatim** — do not "improve" it, real bytes are the whole point.
+     Each entry keeps its own `title` and `contentType`.
+   - With `--dynamic-path`, also probe what the site returns for a **random** path
+     (`curl -i <site>/<random>`): some consoles answer 200 with the login page for *every*
+     unknown path instead of a 404. Your templates should match that default response —
+     a 200 answer from the shell then mirrors the site's own behavior exactly.
+   - `paths`: the site's real path vocabulary, weighted toward the hot prefixes real traffic
+     hits (nav links, sitemap entries — not dead corners), e.g. `["/api/", "/news/", "/app/"]` —
+     first-level dirs, same origin only. Used for `--dynamic-path`.
+   - `request` (optional but recommended): the request's form shape — **one object or an
+     array the client rotates among** (with optional `weight`). `secretField` is the field
+     that carries the ciphertext; `secretIn` is where it rides: `"body"` (default, a form
+     field), `"query"` (a URL parameter) or `"header"`; `fields` are decoys. **Model it on
+     a real form the site already receives** — e.g. a console login POST. Value placeholders:
+     `{{hex:N}}` (N hex), `{{b64:N}}` (N base64url), `{{uuid}}`, `{{ts}}` (unix seconds),
+     `{{int:A:B}}`. Never ship the default `pass=<cipher>` single-field body — a lone
+     `pass=` parameter is a textbook webshell signature.
+4. **Use it:**
+
+   ```bash
+   memparty connect -u http://target/ -t mimic --pass <pass> --key <key> \
+     --profile acme --dynamic-path
+   memparty exec acme/mimic --cmd "whoami"   # profile rides along in the saved target
+   ```
+
+### Worked example
+
+Target: a company portal at `http://192.0.2.1:8080` — a classic content site (HTML
+documents dominate; no SPA).
+
+1. Fetch `/` and two linked pages. Observations: every page shares the same header/footer;
+   `/news/` is linked from the nav and returns a short self-contained list page; the nav
+   links are `/products/`, `/news/`, `/about/`; everything is `text/html; charset=utf-8`.
+2. `memparty profile init acme --site http://192.0.2.1:8080`.
+3. Edit `~/.memparty/profiles/acme.json` so it reads (template shortened here for display —
+   the real file must contain the page's FULL verbatim HTML):
+
+   ```json
+   {
+     "name": "acme",
+     "site": "http://192.0.2.1:8080",
+     "createdAt": "2026-07-19T08:00:00.000Z",
+     "templates": [
+       {
+         "title": "新闻动态 - ACME 科技",
+         "template": "<!DOCTYPE html>\n<html lang=\"zh-CN\">\n<head>...full verbatim HTML...</html>",
+         "contentType": "text/html; charset=utf-8"
+       },
+       {
+         "title": "产品中心 - ACME 科技",
+         "template": "<!DOCTYPE html>\n<html lang=\"zh-CN\">\n<head>...another page...</html>",
+         "contentType": "text/html; charset=utf-8"
+       }
+     ],
+     "paths": ["/products/", "/news/", "/about/"],
+     "request": {
+       "secretField": "verCode",
+       "fields": [
+         {"name": "csrftoken", "value": "{{hex:32}}"},
+         {"name": "j_username", "value": "admin"},
+         {"name": "j_password", "value": "{{hex:24}}"},
+         {"name": "agreement", "value": "on"}
+       ]
+     }
+   }
+   ```
+
+   Why these choices: `/news/` over the homepage — equally high-traffic but no carousel
+   JS/images, so no missing sub-request waterfall; two templates so consecutive responses
+   differ in length and bytes; `paths` are exactly the nav links real users click, not
+   guessed words; the `request` block mirrors the site's own login form, so the shell POST
+   is indistinguishable from someone signing in. (Templates shortened here for display —
+   the real file must contain each page's FULL verbatim HTML. A legacy single
+   `template`/`title`/`contentType` triple still loads, it just can't rotate.)
+4. Verify it parses, then connect:
+
+   ```bash
+   memparty profile show acme      # schema check happens here too
+   memparty connect -u http://192.0.2.1:8080/ -t mimic --pass s3cr3t --key k3y \
+     --profile acme --dynamic-path
+   # OK   mimic http://192.0.2.1:8080/
+   #      round-trip ok (profile=acme; dynamic path http://192.0.2.1:8080/news/x7q2mzab)
+   ```
+
+### What mimic handles vs. what you decide
+
+- Automatic: AES/ECB (key = md5(key)[0:16]), per-shell derived response delimiters,
+  form-body encoding, browser-consistent request headers, credential round-trip on `connect`.
+- Yours: the template page, the path vocabulary, the request pacing. Filter/listener-type
+  memory shells answer on any path, which is what makes `--dynamic-path` legitimate — for a
+  fixed-URL shell just omit the flag.
+- Limits: exec only (no upload/download); request timing/method mix is fixed, so pace your
+  commands like a patient human.
+
+### Server side (Java filter memshell)
+
+The reference server is a servlet Filter, not a JSP — the repo keeps it in
+`scratch/mimic-java/`:
+
+- `mimic/MimicFilter.java` — the protocol server: mapped to `/*` at chain position 0, it
+  answers any form POST whose carrier (one of the profile's secretFields, baked in by the
+  generator — form field, URL parameter or header) decrypts, and passes everything else
+  through. Two rules keep it invisible: **detection uses `getParameter()`/`getHeader()` only
+  and never reads the body stream** (a second filter shell behind it keeps working), and
+  **an undecryptable value means chain-through, not a cover page** — so a legit form that
+  happens to use the same field name (e.g. the console's own login POST with `verCode`) is
+  never hijacked.
+- `mimic/MimicInject.java` — the registration injector (adapted from MemShellParty's
+  TongWeb injector): its `<clinit>` embeds the filter's class bytes (gzip+base64), defines
+  them in the webapp classloader, and registers the filter into every running context.
+- `../gen-mimic-filter.mjs` — the generator: reads the profile from
+  `~/.memparty/profiles/`, embeds **all** its templates (the filter picks one at random per
+  response — that's the rotation), and emits `MimicFilter<V>.class` + `MimicInject<V>.class`
+  (`javac --release 8`). Swap templates, re-run, re-inject. **Pass a fresh version suffix
+  on every re-injection** (`node gen-mimic-filter.mjs V3`): a running JVM can't re-define a
+  class, and the injector skips registration when the filter name already exists.
+
+Deployment needs any channel that can `defineClass` + instantiate in the target JVM (a
+deserialization RCE, an agent loader, another shell that evaluates scripts, …). The filter
+is memory-resident and dies on restart — same as any memory shell.
+
+Two deployment truths learned on a real TongWeb console:
+
+- **Dynamic path is conditional on the target app's own filters.** The console's
+  loginfilter answers `/console/*` itself (except `/console/service`), so `--dynamic-path`
+  fails there even with the filter on `/*` — probe before relying on it, fall back to the
+  fixed working path.
+- The cover page must be one the target actually serves; a beautiful but foreign template
+  is a fingerprint.
+
+### Reality check before relying on it
+
+Run `memparty demo` once and read the printed request URL and response: the traffic should
+be indistinguishable from a normal page view at a glance. Two ways it still stands out:
+
+- **Missing sub-requests**: if your template page has assets (CSS/JS/images) a real browser
+  would fetch, a NDR notices their absence — prefer self-contained pages.
+- **Volume mismatch**: signature devices look at bodies, but statistical detection looks at
+  baselines — hitting a rarely-used path shape (or HTML on an API site) deviates from it.
+  That is why the dominant-traffic rule above outranks everything else.
+
 ## Step 7 — Save targets, switch by name
 
 Flag soup gets old fast. Save each working shell into a **project** (a named group of shells