本地脱敏代理：让免费 AI 编程服务安全可控

免费 AI 编码服务器很实用，但有一个结构性代价：Prompt 会离开你的机器。对于需要处理凭证、内部路径或客户数据的团队来说，这一点就足以阻止他们使用。解决方案不是放弃免费层，而是把敏感信息在离开笔记本之前过滤掉。

本文构建了一个本地代理，位于 IDE 和任何 OpenAI 兼容端点之间。它扫描外发请求、删除敏感模式，然后转发清理后的 Prompt。这个代理大约 150 行 Python 代码，只使用标准库加 httpx，可以通过自定义规则扩展。

声明：本文是 MonkeyCode 产品推广的一部分。

为什么不选 VPN 或沙箱而是脱敏代理

VPN 加密连接但不改变载荷。沙箱限制模型能做什么，但不限制 Prompt 包含什么。防止敏感数据到达第三方服务器的唯一方法是在传输前将其移除。

MonkeyCode 的免费服务器和 1000 万 token 配额（截至 2026-08-25；依赖此配额前请查看最新文档）使免费层很有吸引力。脱敏代理使那些本来拒绝向托管端点发送代码的团队也能接受使用。

代理监听 localhost:8080，接受发往 /chat/completions 的 POST 请求，并重写 messages 数组。每条消息都会经过一条脱敏规则链。规则链可配置且按顺序执行：先替换密钥，再截断长上下文，然后应用自定义模式。

import json
import re
import threading
from http.server import BaseHTTPRequestHandler, HTTPServer

import httpx

class RedactionProxy:
    def __init__(self, upstream_url, api_key, rules=None):
        self.upstream = upstream_url
        self.api_key = api_key
        self.rules = rules or default_rules()
        self.client = httpx.Client(
            base_url=upstream_url,
            headers={"Authorization": f"Bearer {api_key}"},
            timeout=120,
        )

    def redact(self, text):
        for rule in self.rules:
            text = rule(text)
        return text

    def forward(self, payload):
        for message in payload.get("messages", []):
            if message.get("role") == "user":
                message["content"] = self.redact(message["content"])
        return self.client.post("/chat/completions", json=payload)

def default_rules():
    return [
        # AWS access key
        lambda t: re.sub(r"AKIA[0-9A-Z]{16}", "AKIA_REDACTED", t),
        # GitHub token
        lambda t: re.sub(r"gh[pousr]_[0-9A-Za-z]{36,255}", "GH_REDACTED", t),
        # Private IP addresses
        lambda t: re.sub(r"\b(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\.\d{1,3}\.\d{1,3}\b", "IP_REDACTED", t),
        # Absolute home paths
        lambda t: re.sub(r"/home/[a-zA-Z0-9_]+/", "/home/USER/", t),
        # Long hex strings (possible API keys)
        lambda t: re.sub(r"\b[0-9a-fA-F]{32,}\b", "HEX_REDACTED", t),
    ]

代理处理器是一个很薄的 HTTP 层，解析入站请求、调用 forward、返回上游响应原文。

class ProxyHandler(BaseHTTPRequestHandler):
    proxy = None

    def do_POST(self):
        length = int(self.headers.get("Content-Length", 0))
        body = self.rfile.read(length)
        payload = json.loads(body)

        try:
            response = self.proxy.forward(payload)
            self.send_response(response.status_code)
            self.send_header("Content-Type", "application/json")
            self.end_headers()
            self.wfile.write(response.content)
        except Exception as exc:
            self.send_response(502)
            self.send_header("Content-Type", "application/json")
            self.end_headers()
            self.wfile.write(json.dumps({"error": str(exc)}).encode())

    def log_message(self, format, *args):
        # Silence default logging; add your own if needed
        pass

def run(proxy, port=8080):
    ProxyHandler.proxy = proxy
    server = HTTPServer(("127.0.0.1", port), ProxyHandler)
    print(f"Redaction proxy listening on http://127.0.0.1:{port}")
    server.serve_forever()

用环境变量启动代理：

export UPSTREAM_URL="https://your-free-endpoint.example/v1"
export API_KEY="your-key"
python redaction_proxy.py

然后将任何 OpenAI 兼容客户端指向 http://127.0.0.1:8080 而不是真实端点。IDE 或脚本看到的是正常 API，代理在背后做过滤。

用真实请求测试代理

创建一个小的测试脚本，发送包含假 AWS 密钥和内部 IP 的 Prompt，然后验证上游收到的是已脱敏内容。测试可以针对本地模拟服务器运行以避免消耗 token。

import json
import unittest
from unittest.mock import patch

from redaction_proxy import RedactionProxy

class TestRedaction(unittest.TestCase):
    def setUp(self):
        self.proxy = RedactionProxy("http://mock", "test-key")

    def test_aws_key_redacted(self):
        text = "Key: AKIAIOSFODNN7EXAMPLE"
        result = self.proxy.redact(text)
        self.assertNotIn("AKIAIOSFODNN7EXAMPLE", result)
        self.assertIn("AKIA_REDACTED", result)

    def test_private_ip_redacted(self):
        text = "Server at 192.168.1.10 is down"
        result = self.proxy.redact(text)
        self.assertNotIn("192.168.1.10", result)
        self.assertIn("IP_REDACTED", result)

    def test_forward_calls_upstream(self):
        with patch.object(self.proxy.client, "post") as mock_post:
            mock_post.return_value.status_code = 200
            mock_post.return_value.content = b'{"ok": true}'
            payload = {"messages": [{"role": "user", "content": "Hello"}]}
            self.proxy.forward(payload)
            sent_payload = mock_post.call_args[1]["json"]
            self.assertEqual(sent_payload["messages"][0]["content"], "Hello")

if __name__ == "__main__":
    unittest.main()

单元测试确认了两个属性：脱敏改变了内容，forward 保留了请求结构。更高级的集成测试可以启动一个本地 HTTP 服务器并断言收到的具体 body。

代理的局限性

正则表达式不是语义分析。不匹配任何模式的硬编码数据库密码会直接通过。短于 32 字符的 Base64 编码密钥也能存活。代理也无法删除隐藏在代码结构中的信息，比如变量名为 password 且字面值为某个值。

有严格数据驻留要求的团队不应依赖脱敏代理。如果合同禁止向第三方发送任何代码，代理就不是合规工具，而是风险降低。唯一安全的选择是完全自托管模型。

性能也是代价。每个请求都要经过 Python 正则评估。对于短 Prompt 开销可以忽略，但对于 10000 token 的 diff，会增加几十毫秒。这通常可以接受，但高吞吐量的 CI 流水线应该在采用代理前做基准测试。

谁应该使用这个模式

想尝试免费托管服务器但代码库中有内部 IP 或占位符密钥的团队。

使用 AI 助手做个人项目、想避免泄露个人 token 的开发者。

正在评估 MonkeyCode 免费层（或任何免费层）并需要对离开网络的内容有轻度审计跟踪的团队。

代理不是数据丢失防护策略的替代品。它是一个实用层，使免费层可用于更广泛的任务。

免费 AI 编码服务器是一个合理的基础设施选择，但需要一个边界。本地脱敏代理就是这个边界：保持托管端点的便利性，同时剥离永远不该离开笔记本的部分。本文的代码是一个起点；规则链是每个团队特定敏感信息所在之处。

MonkeyCode 的免费服务器和 1000 万 token 配额（截至 2026-08-25）在这样的代理背后运行良好。当配额用完时，代理可以指向不同的上游而不必更改 IDE 配置。过滤器保持不变，端点可以切换，代码保持更安全。

MonkeyCode 提供可以运行此工作流的免费模型。