NullWire-MCP

👀 看看效果有何不同

 You send        Authorization: Bearer sk-live-51Hk3...
 Your AI sees    Authorization: Bearer [REDACTED_TOKEN#a1b2c3]

 Request #1      Bearer [REDACTED_TOKEN#a1b2c3]
 Request #2      Bearer [REDACTED_TOKEN#a1b2c3]   ◄── same token, reused ✔
 Request #3      Bearer [REDACTED_TOKEN#7f09de]   ◄── different token, it rotated ✔

盲目地用 [REDACTED] 替换内容能保护你，却会让 AI 无法调试身份验证错误。NullWire 保留每个秘密的身份，并丢弃它的值。

⚡ 60 秒快速开始

# 1. install (Go 1.23+), or grab a prebuilt binary from Releases
go install github.com/VoxNode-ux/nullwire-mcp@latest

# 2. register it with your AI client (Claude Code shown; Cursor/Windsurf/Desktop configs below)
claude mcp add nullwire -- nullwire-mcp -port 8080 -target https://api.example.com

# 3. point your app at the proxy instead of the real API
curl http://127.0.0.1:8080/v1/orders -H "Authorization: Bearer $MY_TOKEN"

然后直接向你的 Agent 提问：

“为什么 /v1/orders 返回 401？比较最近 5 个请求的身份验证标头。” “请求 3 和 4 使用了相同的令牌，还是令牌轮换了？” “给我一条 curl 命令，用于重放失败的调用。”

你的应用始终会收到真实、未经修改的响应。只有 Agent 看到的内容会经过脱敏。

🔥 为什么要做这个项目

让 AI Agent 读取你的网络流量时，典型的流量捕获代理会把所有内容交给它：实时 Bearer 令牌、会话 Cookie、内部 IP。所有内容都会进入云端大模型的上下文窗口，而且往往还会写入留在磁盘上的捕获文件。

盲目地用 [REDACTED] 替换内容可以阻止泄露，却也会让调试变得不可能。NullWire-MCP 会在内存中脱敏所有秘密，并将其替换为每个进程独有的确定性加盐标签：Agent 能保留每个秘密的身份，却永远看不到它的值。

标签的计算方式为 SHA-256(nonce ‖ secret)[:6]。nonce 是启动时从 crypto/rand 生成的 32 个随机字节，仅保存在内存中，进程退出后便会消失。请参阅安全性深入解析，了解这为何重要。

🧭 工作原理

flowchart LR
    APP["Your app / curl / SDK"] -->|"plain HTTP to 127.0.0.1"| PROXY["NullWire proxy<br/>loopback only"]
    PROXY -->|"original request, untouched"| UP["Upstream API<br/>http or https"]
    UP -->|"original response"| PROXY
    PROXY -->|"original response, untouched"| APP
    PROXY -.->|"async copy"| DLP["DLP scrubber<br/>regex, then SHA-256 tag"]
    DLP --> RING[("RAM ring<br/>50 flows")]
    RING -->|"MCP over stdio<br/>scrubbed data only"| AGENT["AI agent<br/>Claude · Cursor · Windsurf"]

两条路径，一条规则：**真实字节发送给你的应用，只有经过脱敏的副本才会发送给 AI。**任何内容都不会写入磁盘。

╔══ [1] LOCAL APP / CLI ══════════════════════════════════════╗
║ curl · SDK · browser · your service                         ║▒
║ speaks plain HTTP to 127.0.0.1:8080                         ║▒
╚═════════════════════════════════════════════════════════════╝▒
 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
                               │
                               ▼  plain HTTP, loopback only
╔══ [2] NULLWIRE PROXY  127.0.0.1:8080 ═══════════════════════╗
║ bound with net.Listen(tcp4) + IsLoopback() check            ║▒
║ forward mode : absolute URL  (curl -x)                      ║▒
║ reverse mode : -target flag / X-Target-URL header           ║▒
║ guards : DNS-rebind 403 · self-loop 508 · CONNECT 501       ║▒
╚═════════════════════════════════════════════════════════════╝▒
 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
                               │
                               ▼  io.TeeReader split
               ┌───────────────┴────────────────┐
               ▼                                ▼
╔══ [3a] ROUNDTRIP ══════════╗   ╔══ [3b] DLP SCRUBBER ═══════╗
║ http.Transport (isolated)  ║▒  ║ async copy, capped at 64KB ║▒
║ Accept-Encoding stripped   ║▒  ║ regex scrub, THEN truncate ║▒
║ Host = upstream host       ║▒  ║ SHA-256(nonce|secret)[:6]  ║▒
║ bytes forwarded untouched  ║▒  ║ 32-byte crypto/rand nonce  ║▒
╚════════════════════════════╝▒  ╚════════════════════════════╝▒
 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒   ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
               │                                │
               ▼                                ▼
┌── UPSTREAM API ────────────┐   ╔══ [4] RAM RING ════════════╗
│ http:// or https://        │▒  ║ 50 slots · sync.RWMutex    ║▒
│ TLS handled by Go, no MITM │▒  ║ req 8KB / resp 16KB max    ║▒
└────────────────────────────┘▒  ║ newest-first reads         ║▒
 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒  ║ disk writes: none          ║▒
               │                 ╚════════════════════════════╝▒
◄──┘ original response            ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
    returns to the app                          │
                                                ▼
╔══ [5] JSON-RPC 2.0 MCP (2026-07-28 + legacy) ═══════════════╗
║ initialize · discover · ping · tools/list · call            ║▒
║ inspect_traffic · export_sanitized_curl · clear_ram_buffer  ║▒
║ notifications → zero bytes written                          ║▒
╚═════════════════════════════════════════════════════════════╝▒
 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
               │                                │
               ▼                                ▼
╔══ STDOUT ▓▓▓ ══════════════╗   ┌── STDERR ░░░ ──────────────┐
║ one compact JSON line      ║▒  │ ANSI status bar,           │▒
║ per frame, ends in \n      ║▒  │ banners, errors            │▒
║ NOTHING else, ever         ║▒  │ (human telemetry)          │▒
╚════════════════════════════╝▒  └────────────────────────────┘▒
 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒   ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
               │                                │
               ▼                                ▼
╔══ AI AGENT (MCP) ══════════╗   ┌── HUMAN ───────────────────┐
║ Claude Code · Desktop      ║▒  │ you, in a terminal         │▒
║ Cursor · Windsurf          ║▒  └────────────────────────────┘▒
╚════════════════════════════╝▒   ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
 ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒

⚡ [NullWire-MCP] Proxy 127.0.0.1:8080 | RAM Ring: 14/50 | Scrubbed: 9 Tokens, 4 Cookies, 6 IPs | Disk: 0B

_{右侧列描述的是一类通用工具：通过 MITM 代理捕获流量并将其交给大模型。这并非针对任何特定产品的说法。我们尚未发布启动基准测试；启动这一行描述的是架构。}

🚀 30 秒安装

选项 A：go install（Go 1.23+）

go install github.com/VoxNode-ux/nullwire-mcp@latest

选项 B：预编译静态二进制文件，通过 GitHub Releases 中的 SHA256SUMS.txt 校验：

# Linux example (swap the file name for your platform)
BASE=https://github.com/VoxNode-ux/nullwire-mcp/releases/latest/download
curl -LO "$BASE/nullwire-linux-amd64"
curl -LO "$BASE/SHA256SUMS.txt"
grep ' nullwire-linux-amd64$' SHA256SUMS.txt | sha256sum -c -     # macOS: shasum -a 256 -c -
chmod +x nullwire-linux-amd64
sudo mv nullwire-linux-amd64 /usr/local/bin/nullwire-mcp

# Windows (PowerShell)
Get-FileHash .\nullwire-windows-amd64.exe -Algorithm SHA256   # compare with SHA256SUMS.txt

选项 C：从源代码构建

git clone https://github.com/VoxNode-ux/nullwire-mcp && cd nullwire-mcp
CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o nullwire-mcp .

标志

不使用 AI 客户端，直接试用

只要标准输入保持打开，MCP 端就会持续运行。因此，快速演示时，可以定时向它发送请求：

( sleep 2
  echo '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"inspect_traffic","arguments":{"limit":5}}}'
  sleep 1 ) | nullwire-mcp -port 8080 &

sleep 1
curl -s -x http://127.0.0.1:8080 http://example.com/ \
  -H 'Authorization: Bearer my_secret_token_123' \
  -H 'Cookie: sid=my_secret_cookie' \
  -H 'X-Forwarded-For: 198.51.100.1' > /dev/null
wait

你会在标准错误输出中看到实时状态栏，在标准输出中看到流量，其中的标头会显示为 Bearer [REDACTED_TOKEN#…]、[REDACTED_COOKIE#…] 和 [REDACTED_IP#…]。

接入 AI 客户端

客户端会将 nullwire-mcp 作为子进程启动，并通过标准输入输出进行 JSON-RPC 通信。然后，你的应用将流量发送到 127.0.0.1:8080。（配置文件的位置会随客户端版本变化；如果下方路径已过时，请查阅客户端文档。）

Claude Code CLI

claude mcp add nullwire -- nullwire-mcp -port 8080 -target https://api.example.com

Claude Desktop（claude_desktop_config.json）

{
  "mcpServers": {
    "nullwire": {
      "command": "nullwire-mcp",
      "args": ["-port", "8080", "-target", "https://api.example.com"]
    }
  }
}

Cursor（~/.cursor/mcp.json，或项目中的 .cursor/mcp.json）

{
  "mcpServers": {
    "nullwire": {
      "command": "nullwire-mcp",
      "args": ["-port", "8080", "-target", "https://api.example.com"]
    }
  }
}

Windsurf（~/.codeium/windsurf/mcp_config.json）

{
  "mcpServers": {
    "nullwire": {
      "command": "nullwire-mcp",
      "args": ["-port", "8080", "-target", "https://api.example.com"]
    }
  }
}

如果只使用正向代理模式或每个请求的 X-Target-URL 标头，请省略 -target。

🔀 两种捕获模式

模式 1：正向代理（纯 HTTP）

通过代理发送完整 URL。请求会原样转发，经过清理的副本则会进入环形缓冲区。

curl -x http://127.0.0.1:8080 http://httpbin.org/headers

# or for any app that honours the standard variable
HTTP_PROXY=http://127.0.0.1:8080 ./my-service

HTTPS_PROXY 会使客户端发送 CONNECT 请求；按设计，此类请求会收到 501 响应。请参阅明确的适用范围。对于 HTTPS，请使用模式 2。

模式 2：反向网关（HTTPS 上游，无 MITM 证书）

通过纯 HTTP 与 NullWire 通信；NullWire 使用 Go 的常规证书验证，通过 TLS 与真实服务端通信。无需在信任存储中安装任何内容。

# Fixed upstream for the whole session
nullwire-mcp -target https://api.github.com
curl http://127.0.0.1:8080/users/octocat

# Or choose the upstream per request (the header is removed before forwarding)
curl -H 'X-Target-URL: https://httpbin.org' http://127.0.0.1:8080/anything?api_key=hunter2hunter2

只需更改基础 URL，即可将 SDK 指向该网关：

export OPENAI_BASE_URL=http://127.0.0.1:8080/v1   # with: nullwire-mcp -target https://api.openai.com

上游 Host 标头会设为目标主机，因此虚拟主机和 TLS SNI 均可正常工作。

🧰 MCP 工具参考

这三个工具都返回 {"resultType":"complete","content":[{"type":"text","text":"…"}],"isError":false}。工具级问题（例如未知的流 ID）会将 isError 设为 true，而不会导致 RPC 失败。

inspect_traffic

最近的脱敏流量，按时间倒序排列。

{
  "name": "inspect_traffic",
  "inputSchema": {
    "type": "object",
    "properties": {
      "limit":      { "type": "integer", "default": 10, "minimum": 1, "maximum": 50 },
      "method":     { "type": "string",  "description": "HTTP method filter, case-insensitive" },
      "url_filter": { "type": "string",  "description": "Substring of the scrubbed URL, case-insensitive" }
    },
    "additionalProperties": false
  }
}

结果文本示例：

{
  "ring_size": 3,
  "ring_capacity": 50,
  "returned": 1,
  "scrubbed_totals": { "tokens": 5, "cookies": 1, "ips": 1 },
  "flows": [
    {
      "id": 3,
      "timestamp": "2026-10-25T14:03:11Z",
      "method": "POST",
      "url": "http://[REDACTED_IP#98f1a2]:9000/v1/orders?api_key=[REDACTED_TOKEN#3c9a1e]",
      "request_headers": {
        "Authorization": "Bearer [REDACTED_TOKEN#a1b2c3]",
        "Content-Type": "application/json",
        "Cookie": "[REDACTED_COOKIE#d4e5f6]"
      },
      "request_body": "{\"item\":\"widget\",\"client_secret\":\"[REDACTED_TOKEN#5b7e20]\"}",
      "status_code": 401,
      "response_headers": { "Content-Type": "application/json" },
      "response_body": "{\"error\":\"token expired\"}",
      "latency_ms": 42,
      "redaction_count": 5
    }
  ]
}

export_sanitized_curl

为单个流量重建可运行的 POSIX curl 命令。每个脱敏标签都会变为环境变量占位符，并附带注释图例，将每个占位符映射回其替换的标签，方便你了解每个位置对应哪个真实值。

{
  "name": "export_sanitized_curl",
  "inputSchema": {
    "type": "object",
    "properties": {
      "flow_id": { "type": "integer", "minimum": 1, "description": "An id returned by inspect_traffic" }
    },
    "required": ["flow_id"],
    "additionalProperties": false
  }
}

上方流量 3 的结果文本示例：

# Replay of flow 3 (2026-10-25T14:03:11Z)
# Set these environment variables first (distinct tags share one placeholder):
# export NULLWIRE_IP=...   # was [REDACTED_IP#98f1a2]
# export NULLWIRE_AUTH_TOKEN=...   # was [REDACTED_TOKEN#3c9a1e]
# export NULLWIRE_AUTH_TOKEN=...   # was [REDACTED_TOKEN#5b7e20]
# export NULLWIRE_AUTH_TOKEN=...   # was [REDACTED_TOKEN#a1b2c3]
# export NULLWIRE_COOKIE=...   # was [REDACTED_COOKIE#d4e5f6]
curl -X 'POST' 'http://'"$NULLWIRE_IP"':9000/v1/orders?api_key='"$NULLWIRE_AUTH_TOKEN" \
  -H 'Authorization: Bearer '"$NULLWIRE_AUTH_TOKEN" \
  -H 'Content-Type: application/json' \
  -H 'Cookie: '"$NULLWIRE_COOKIE" \
  --data-raw '{"item":"widget","client_secret":"'"$NULLWIRE_AUTH_TOKEN"'"}'

逐跳标头、Host、Content-Length 和 Accept-Encoding 会被省略，以便由 curl 自行设置。对于已截断或经过编码的请求正文，会显示 # WARNING: 行，而不会静默重放不完整的内容。

clear_ram_buffer

将全部 50 个槽位清零并重置脱敏计数器。流 ID 会持续递增，因此旧 ID 永远不会指向新流量。不接受任何参数（{"type":"object","properties":{},"additionalProperties":false}）。

🛡️ 安全与协议工程深入解析

以下各项均在 main.go 中实现，并由 main_test.go 测试。

会清理的内容

⚖️ 诚实说明范围与已知限制

我们宁愿由我们来告诉你，也不希望你在生产环境中才发现。

• HTTP CONNECT 会返回 501 Not Implemented，这是有意为之。 通过 CONNECT 检查 HTTPS 意味着要对 TLS 实施中间人攻击，这就需要生成根 CA，并将其加入操作系统或浏览器的信任存储。这会涉及密钥材料并污染密钥链，与零足迹工具的目标背道而驰。反向网关无需这些操作就能提供同样的可见性：将应用指向 http://127.0.0.1:8080，让 NullWire 处理到上游的 TLS。
• 不支持 WebSocket / Upgrade 透传。 Upgrade 和 Connection 会被视为逐跳标头并移除，因此升级后的协议无法通过代理运行。支持普通请求/响应和流式响应（例如 SSE）。
• Android / Termux： Android 上的静态 Go 二进制文件没有 DNS 解析器配置，因此上游主机名解析会失败，并出现 502 … lookup … connection refused。请在 termux-chroot 中运行（pkg install proot），它会提供解析器。Linux 桌面、macOS、Windows 和 FreeBSD 预计不受影响。
• 脱敏基于模式，并非万能。 它可以识别上表中的格式。如果密钥采用我们无法识别的格式、出现在我们不了解的字段中，或跨越正文边界被拆分，就可能漏过。请把脱敏器视为可靠的安全带，而非保证，并使用你自己的流量进行测试。目前尚未对 IPv6 地址进行脱敏。看起来像 IPv4 地址、实际并非地址的字符串（某些版本号）可能会被误报并脱敏。
• 标签为 24 位。 六个十六进制字符足以区分 50 槽缓冲区中的少量密钥，但理论上仍可能发生冲突。标签用于关联，而非识别。
• 正文长度有限。 每个正文只会捕获前 64 KB，存储的正文会截断至 8 KB / 16 KB。带有 Content-Encoding（例如 gzip）的响应会以简短占位内容存储，而不会解码。NullWire 会从转发的请求中移除 Accept-Encoding，因此大多数服务会返回未压缩内容，但它无法强制服务这么做。
• “仅驻留内存”意味着程序永远不会写入文件。 状态栏中的 Disk: 0B 是设计约束（源代码不执行文件 I/O），而非测量所得的计数。操作系统仍可能将内存页换出到磁盘或写入崩溃转储；NullWire 无法控制这些行为。
• 环形缓冲区是临时的。 进程退出时，最近的 50 个流量记录会消失。这正是设计目的。
• 你的应用会看到原始流量。 NullWire 保护的是 AI Agent 看到的内容，而不是你的本地应用看到的内容。它并不是应用本身的安全边界。
• 协议支持范围以文档所述为准。 支持 2026-07-28 / 2025-11-25 / 2024-11-05 规范中的初始化、发现、ping、tools/list 和 tools/call。资源、提示词和采样尚未实现，调用时会返回 -32601。
• 发布的二进制文件未签名。 请使用 SHA256SUMS.txt 验证。在 macOS 上，你可能需要运行 xattr -d com.apple.quarantine ./nullwire-darwin-arm64。

🧪 测试平台

🟡 模拟运行表示在 QEMU 下运行，而非在真实硬件上运行。每次运行的完整日志可通过 docs/test-results.md 和 Actions 选项卡查看。

✅ 验证与测试

go vet ./...
go test -v ./...
go test -v -race ./...      # the race detector needs cgo (gcc/clang) on most platforms

测试套件仅使用标准库（net/http/httptest），涵盖：

• 确定性标记：相同的密钥共用一个标签，不同的密钥使用不同标签，不会泄漏任何内容，127.0.0.1 会保留。
• 环形缓冲区绕回淘汰，以及使用单调递增 ID 的 Clear()。
• 完整的反向网关往返流程：移除 Accept-Encoding、将令牌清理后存入环形缓冲区，并导出有效的脱敏 curl。
• MCP 分发：server/discover、initialize、ping、tools/list、tools/call、错误代码，以及通知的标准输出字节数为零。

CI（.github/workflows/release.yml）运行 go vet 和 go test -race，为 9 个目标交叉编译静态 CGO_ENABLED=0 二进制文件（Linux amd64/arm64/armv7/riscv64、macOS amd64/arm64、Windows amd64/arm64、FreeBSD amd64），并在 v* 标签下发布这些文件及 SHA256SUMS.txt。

❓ 常见问题

🤝 参与贡献

欢迎提交问题和 PR。请阅读 CONTRIBUTING.md，了解基本规则、测试命令和 PR 检查清单。安全问题请通过 SECURITY.md 报告，不要提交到公开问题区。

📄 许可证

MIT © 2026 VoxNode-ux