sycommon-python-lib 0.2.8a3__py3-none-any.whl → 0.2.8a4__py3-none-any.whl

sycommon/middleware/sandbox_gateway.py

@@ -0,0 +1,542 @@
+"""沙箱出网收口网关（egress gateway）。
+
+嵌入沙箱服务端进程内的 aiohttp.web 反向代理。子进程的所有出网请求指向本网关
+（child env 的 SYT_BASE_URL/HTTPS_PROXY = http://127.0.0.1:<port>），网关做四件事：
+
+  1. 按「目标 host → 凭据形态」注入正确凭据（SYT 用 Authorization Bearer +
+     X-Sy-Api-Authz；OA 系用 SYU-Token + SYU-Url 改写；企微 gettoken 用
+     URL query 的 corpid/corpsecret；内网服务无鉴权透传）。
+  2. 复用 skill_wl_check.match 做 path 白名单校验，不在白名单 → 403。
+  3. 删子进程自带的凭据头（Authorization/SYU-Token/X-Sy-Api-Authz），由网关
+     重新注入正确值（防子进程塞脏值/旧值）。
+  4. 审计：每个请求记录 user/host/path/状态码/字节量。
+
+子进程 → 网关走 HTTP（loopback 明文），网关 → 真上游才用 HTTPS。这样网关能
+看到并改写请求头；若走 HTTPS CONNECT 隧道则端到端加密、网关无法注入凭据。
+
+凭据来源：主进程通过 POST /v1/sandbox/credentials 推送（out-of-band，不进子进程
+env、不进命令串），存进本模块的内存凭据表 CredentialStore。
+
+local 模式（每用户独立容器）：单用户单端口，凭据表只有一个条目，无绑定问题。
+shared 模式（多用户共享）：per-user 临时端口，凭据表按 user_id 索引。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+from typing import Optional
+from urllib.parse import urlparse, urlunparse, urlencode, parse_qsl
+
+from aiohttp import web, ClientSession, ClientTimeout
+
+from sycommon.logging.kafka_log import SYLogger
+
+
+# ============== 凭据存储 ==============
+
+# 子进程自带、必须剥离的凭据头（小写）。网关重新注入正确值，防脏值。
+_INBOUND_CRED_HEADERS = {
+    "authorization", "syu-token", "syu-url", "x-sy-api-authz",
+    "x-host-name",
+}
+
+
+class CredentialStore:
+    """线程安全（单事件循环内）的 per-user 凭据表。
+
+    刷新用「整体替换 dict 引用」（store[uid] = new_dict），不原地 mutate，
+    故正在处理的请求 snapshot 的旧 dict 不受刷新影响（无半截态竞态）。
+    """
+
+    def __init__(self) -> None:
+        # user_id -> creds dict。creds dict 形如：
+        #   {"SYT_TOKEN": ..., "SYT_API_AUTHZ": ..., "SYT_BASE_URL": <真上游>,
+        #    "SYT_X_HOST_NAME": ..., "WECOM_CORP_ID": ..., "WECOM_CORP_SECRET": ...,
+        #    "allowlist": [...]}
+        self._creds: dict[str, dict] = {}
+        self._lock = asyncio.Lock()
+
+    async def set(self, user_id: str, creds: dict) -> None:
+        async with self._lock:
+            self._creds[user_id] = dict(creds)  # 拷贝，隔离调用方后续 mutate
+
+    async def delete(self, user_id: str) -> bool:
+        async with self._lock:
+            return self._creds.pop(user_id, None) is not None
+
+    def get(self, user_id: str) -> Optional[dict]:
+        """同步读（请求处理热路径，锁外读 dict 引用——整体替换保证一致性）。"""
+        return self._creds.get(user_id)
+
+    def any_user(self) -> Optional[str]:
+        """local 模式单用户时取唯一 user_id（凭据表只有一个条目）。"""
+        for uid in self._creds:
+            return uid
+        return None
+
+
+# ============== host → 凭据形态路由表 ==============
+
+def _match_syt_upstream(host: str, syt_base_url: str) -> bool:
+    """请求目标 host 是否是 SYT 网关上游（syapi / cloudapi-*）。"""
+    if not syt_base_url:
+        return False
+    try:
+        syt_host = (urlparse(syt_base_url).hostname or "").lower()
+    except Exception:
+        return False
+    return host == syt_host or fnmatch.fnmatch(host, "*.syitservice.com") \
+        and ("cloudapi" in host or host == syt_host)
+
+
+def _is_oa_backend(host: str) -> bool:
+    """OA-workorder/xinghan/yealink 等 MCP 后端（带 SYU-Token + SYU-Url）。"""
+    return host in ("ai.syitservice.com",) or host.endswith(".syitservice.com")
+
+
+def _is_wecom(host: str) -> bool:
+    return host in ("qyapi.weixin.qq.com",)
+
+
+def _is_internal_passthrough(host: str) -> bool:
+    """无鉴权的内网服务（OCR / 合同比对），仅靠白名单放行，透传。"""
+    return host.startswith("10.") or host in (
+        "contract-compare.syitservice.com", "newocr-test.syitservice.com",
+    )
+
+
+def _strip_cred_headers(headers) -> dict:
+    """剥离请求里的凭据头，返回干净的普通 dict（非凭据头透传）。"""
+    out = {}
+    for k, v in headers.items():
+        if k.lower() not in _INBOUND_CRED_HEADERS:
+            out[k] = v
+    return out
+
+
+def _apply_credentials(method: str, target_url: str, headers: dict,
+                       creds: dict) -> tuple[str, dict]:
+    """按目标 host/path 改写 URL（query 注入）+ 注入凭据头。返回 (url, headers)。
+
+    网关→真上游的请求构造在此完成。host 路由表见模块 docstring。
+    """
+    host = (urlparse(target_url).hostname or "").lower()
+
+    # --- SYT 网关：Bearer + X-Sy-Api-Authz + X-Host-Name ---
+    if _match_syt_upstream(host, creds.get("SYT_BASE_URL", "")):
+        token = creds.get("SYT_TOKEN", "")
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        authz = creds.get("SYT_API_AUTHZ", "")
+        if authz:
+            headers["X-Sy-Api-Authz"] = authz
+        x_host = creds.get("SYT_X_HOST_NAME", "")
+        if x_host:
+            headers["X-Host-Name"] = x_host
+        return target_url, headers
+
+    # --- 企微 gettoken：corpid/corpsecret 在 URL query ---
+    if _is_wecom(host):
+        corp_id = creds.get("WECOM_CORP_ID", "")
+        corp_secret = creds.get("WECOM_CORP_SECRET", "")
+        if corp_id and corp_secret and "/cgi-bin/gettoken" in target_url:
+            parsed = urlparse(target_url)
+            q = dict(parse_qsl(parsed.query))
+            q.setdefault("corpid", corp_id)
+            q.setdefault("corpsecret", corp_secret)
+            target_url = urlunparse(parsed._replace(query=urlencode(q)))
+        return target_url, headers
+
+    # --- OA MCP 后端：SYU-Token + SYU-Url（改写为真上游 base）---
+    if _is_oa_backend(host):
+        token = creds.get("SYT_TOKEN", "")
+        syt_base = (creds.get("SYT_BASE_URL") or "").rstrip("/")
+        if token:
+            headers["SYU-Token"] = token
+        # SYU-Url 必须指向真上游云平台（后端靠它反查校验 token），
+        # 而非子进程 SYT_BASE_URL（那是网关地址）。这里改写回真上游。
+        if syt_base:
+            headers["SYU-Url"] = f"{syt_base}/oauth/loadUser"
+        return target_url, headers
+
+    # --- 内网服务：无鉴权透传 ---
+    return target_url, headers
+
+
+# ============== 白名单（host 级,来源沙箱 dataId EgressPolicy）==============
+
+def _check_allowlist(target_url: str, creds: dict,
+                     skill_scope: str = "") -> Optional[str]:
+    """返回 None 表示放行，返回 str 表示拒绝原因。
+
+    白名单来源改为沙箱自身 dataId 的 EgressPolicy(viaGateway+directAllow 的
+    host 全集):目标 host 不在集合内 → 403。这与 iptables 硬墙的 DROP 对齐
+    (墙放行 directAllow 的直连,网关放行全部允许 host——child 两路都进得来,
+    但名单外两头都拒)。
+
+    向后兼容:凭据包里仍可带 allowlist(path 级,主进程推送)——配了则叠加
+    path 级校验(host 先过 EgressPolicy,再过 path)。
+
+    按技能 scope 分级(用户决策):
+      system / shengye-platform 技能 → 全管制:名单外 host 一律 403
+        (host 须在 EgressPolicy 集合内,与原 SkillApiWhitelist fail-closed 对齐)
+      user 技能 / 普通(无技能)命令 → 只管制 SYT_BASE_URL 同域名 + viaGateway
+        (星瀚/OA),其余放行(defaultMode=allow 语义)
+    scope 由 /execute 从命令提取 skills/<scope>/ 注入 child env
+    SANDBOX_SKILL_SCOPE,库层重写随 X-Skill-Scope 头传来;缺省按 user 宽松。
+    """
+    try:
+        p = urlparse(target_url)
+        host = (p.hostname or "").lower()
+    except Exception:
+        return "URL 解析失败"
+    if not host:
+        return "URL 无 host"
+
+    # 真上游(凭据包 SYT_BASE_URL,主进程按环境解析)——SYT 管制判定的锚点:
+    # 与它同域名的 host 自动纳入管制/放行集合,换环境无需改配置。
+    syt_base = (creds.get("SYT_BASE_URL") or "").strip()
+    policy = None
+    allowed: list = []
+    try:
+        from sycommon.config.EgressPolicyConfig import EgressPolicyConfig
+        policy = EgressPolicyConfig.from_config()
+        allowed = policy.allowed_hosts(syt_base)
+    except Exception as e:
+        # 读配置失败 → fail-open(不设限,凭据注入仍有效)。policy 保持 None,
+        # 下游用 allow_mode 时需判空(修审核 P1-5:原实现 policy 未绑定致 500)。
+        SYLogger.warning(f"[EgressGateway] EgressPolicy 读取失败,按未配置处理: {e}")
+
+    # 技能 scope:system/shengye-platform → 全管制;其余(user/普通) → 宽松
+    strict_scope = skill_scope in ("system", "shengye-platform")
+
+    if strict_scope:
+        # 全管制:名单外 host 一律拒(defaultMode 不豁免)
+        if allowed and not EgressPolicyConfig._host_match(host, allowed):
+            return f"目标 host 不在出网策略内: {host}"
+    else:
+        # user/普通:defaultMode='allow' → 名单外放行;'drop' → 拒
+        # (policy 为 None=配置读取失败 → 按 allow 宽松,修审核 P1-5)
+        allow_mode = (policy.defaultMode if policy else "allow") or "allow"
+        allow_mode = allow_mode.lower() != "drop"
+        if not allow_mode and allowed and not EgressPolicyConfig._host_match(host, allowed):
+            return f"目标 host 不在出网策略内: {host}"
+
+    # 叠加 path 级(凭据包 allowlist,可选)
+    allowlist = creds.get("allowlist")
+    if allowlist and not _url_allowed(target_url, allowlist):
+        return f"URL 不在白名单内: {target_url}"
+    return None
+
+
+def _url_allowed(url: str, allowlist: list[str]) -> bool:
+    """与 skill_wl_check._is_allowed 同构的 path 级前缀匹配（不依赖 env）。"""
+    try:
+        p = urlparse(url if "://" in url else "http://" + str(url))
+    except Exception:
+        return False
+    req_scheme = (p.scheme or "").lower()
+    req_host = (p.hostname or "").lower()
+    req_port = p.port
+    req_path = (p.path or "").rstrip("/")
+    for entry in allowlist:
+        entry = (entry or "").strip().rstrip("/")
+        if not entry:
+            continue
+        if entry.startswith(("http://", "https://")):
+            e = urlparse(entry)
+            epfx = (e.path or "").rstrip("/")
+            pfx_match = (epfx == "" or req_path == epfx
+                         or req_path.startswith(epfx + "/"))
+            if not pfx_match:
+                continue
+            if (e.scheme or "").lower() != req_scheme or (e.hostname or "").lower() != req_host:
+                continue
+            if e.port is not None and req_port not in (None, e.port):
+                continue
+            return True
+        else:
+            # 纯 path 前缀（无 host）
+            if not entry.startswith("/"):
+                entry = "/" + entry
+            if req_path == entry or req_path.startswith(entry + "/"):
+                return True
+    return False
+
+
+def _sanitize_url(url: str) -> str:
+    """抹掉 URL 里的敏感 query 参数(审计日志脱敏,审核 P1-7)。
+
+    corpsecret/token/secret/key/password 等参数值替换为 ***。
+    """
+    if not url or "?" not in url:
+        return url
+    base, _, qs = url.partition("?")
+    sensitive = ("secret", "token", "key", "password", "passwd", "credential")
+    kept = []
+    for pair in qs.split("&"):
+        k = pair.split("=", 1)[0].lower()
+        if any(s in k for s in sensitive):
+            kept.append(f"{pair.split('=', 1)[0]}=***")
+        else:
+            kept.append(pair)
+    return f"{base}?{'&'.join(kept)}"
+
+
+# ============== aiohttp.web 反向代理 ==============
+
+def _is_loopback_or_private(hostport: str) -> bool:
+    """上游 host(或 host:port)是否指向回环/私有地址段(SSRF 防护)。
+
+    域名先解析再判定(域名可能解析到内网 IP)。包含:
+      127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, ::1, localhost
+    """
+    import ipaddress
+    import socket as _socket
+    host = (hostport or "").strip()
+    if not host:
+        return True
+    # 剥端口(单冒号;IPv6 字面量 [::1]:port 形态)
+    if host.startswith("["):
+        host = host.split("]")[0].lstrip("[")
+    elif host.count(":") == 1:
+        host = host.split(":")[0]
+    hl = host.lower()
+    if hl in ("localhost", "::1"):
+        return True
+    try:
+        ipaddress.ip_address(hl)
+        ips = [hl]
+    except ValueError:
+        try:
+            infos = _socket.getaddrinfo(hl, None)
+            ips = list({i[4][0] for i in infos})
+        except Exception:
+            return True  # 解析失败按内网处理(保守拒绝)
+    for ip in ips:
+        try:
+            addr = ipaddress.ip_address(ip)
+            if (addr.is_loopback or addr.is_private or addr.is_link_local
+                    or addr.is_reserved):
+                return True
+        except ValueError:
+            continue
+    return False
+
+
+# 转发时跳过的 hop-by-hop / 网关自身头（模块级，供 _proxy 与响应透传共用）。
+_HOP_BY_HOP = frozenset((
+    "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
+    "te", "trailers", "transfer-encoding", "upgrade", "host", "content-length",
+))
+
+
+class EgressGateway:
+    """嵌入沙箱服务端进程的出网网关。监听 127.0.0.1，单端口（local 模式单用户）。"""
+
+    # 响应透传时复用模块级 _HOP_BY_HOP（旧类属性保留兼容）。
+    _HOP_BY_HOP = _HOP_BY_HOP
+
+    def __init__(self, store: CredentialStore, port: int = 0,
+                 bind: str = "127.0.0.1") -> None:
+        self._store = store
+        self._requested_port = port  # 0 = OS 分配
+        self._bind = bind
+        self._actual_port: Optional[int] = None
+        self._runner: Optional[web.AppRunner] = None
+        self._site: Optional[web.TCPSite] = None
+        self._client: Optional[ClientSession] = None
+
+    @property
+    def port(self) -> Optional[int]:
+        return self._actual_port
+
+    @property
+    def base_url(self) -> str:
+        """供 child env 注入的网关地址（子进程 SYT_BASE_URL 指向它）。"""
+        p = self._actual_port
+        return f"http://{self._bind}:{p}" if p else ""
+
+    async def start(self) -> int:
+        app = web.Application(client_max_size=100 * 1024 * 1024)
+        app.router.add_route("*", "/{tail:.*}", self._proxy)
+        self._runner = web.AppRunner(app, access_log=None)
+        await self._runner.setup()
+        self._site = web.TCPSite(self._runner, self._bind, self._requested_port)
+        await self._site.start()
+        # 取实际监听端口（requested_port=0 时由 OS 分配）
+        sockets = self._site._server.sockets
+        self._actual_port = sockets[0].getsockname()[1] if sockets else self._requested_port
+        # 连接池：网关→真上游
+        self._client = ClientSession(
+            timeout=ClientTimeout(total=300),
+            headers={"Connection": "keep-alive"},
+        )
+        SYLogger.info(f"[EgressGateway] 监听 {self._bind}:{self._actual_port}")
+        return self._actual_port
+
+    async def stop(self) -> None:
+        if self._client is not None:
+            await self._client.close()
+            self._client = None
+        if self._runner is not None:
+            await self._runner.cleanup()
+            self._runner = None
+        SYLogger.info("[EgressGateway] 已停止")
+
+    def _resolve_user(self, request: web.Request) -> Optional[dict]:
+        """local 模式：凭据表唯一条目即该容器用户。shared 模式留待扩展。"""
+        return self._store.any_user() and self._store.get(self._store.any_user())
+
+    async def _proxy(self, request: web.Request) -> web.StreamResponse:
+        # SSRF 防护(审核 P0-2):拒绝 CONNECT(网关不做隧道),拒绝把上游指向
+        # 本机/回环/私有地址——否则子进程可经网关打沙箱自身的无鉴权 API
+        # (/v1/sandbox/execute 任意 user_id 跨用户读写)或造成网关自递归。
+        if request.method == "CONNECT":
+            SYLogger.warning("[EgressGateway] 拒绝 CONNECT(网关非隧道代理)")
+            return web.Response(status=405, text="gateway: CONNECT not supported")
+
+        creds = self._resolve_user(request)
+        if creds is None:
+            # 无凭据：local 模式下凭据未推送/已清除。503 让子进程脚本明确报错。
+            SYLogger.warning("[EgressGateway] 无凭据，拒绝（/credentials 未推送或已清除）")
+            return web.Response(status=503, text="gateway: no credentials provisioned")
+
+        # 子进程以网关为 origin（SYT_BASE_URL=http://127.0.0.1:port）发请求，
+        # 但真实目标 host 通过特殊头 X-Upstream-Host 传入（库层重写时设置），
+        # 或：子进程直接用 http://<真host>/ 绝对路径（含真 host），网关按 host 路由。
+        # 约定：子进程发的 URL 形如 http://127.0.0.1:port/<path>，真 host 由
+        # X-Upstream-Host 携带；若缺省则取 SYT 上游（兼容直接拼 SYT_BASE_URL 的脚本）。
+        upstream_host = request.headers.get("X-Upstream-Host", "").strip()
+        syt_base = (creds.get("SYT_BASE_URL") or "").rstrip("/")
+        if upstream_host:
+            # SSRF 防护:上游 host 禁止指向回环/本机/私有网段(本机服务含沙箱
+            # 自身 API,免鉴权,打穿即跨用户任意执行)。非回环的 10.x/172.16-31.x/
+            # 192.168.x 内网目标按 EgressPolicy 判定(directAllow 命中才放)。
+            if _is_loopback_or_private(upstream_host):
+                SYLogger.warning(
+                    f"[EgressGateway] 拒绝内网/回环上游(SSRF 防护): {upstream_host}")
+                return web.Response(status=403, text="gateway: upstream host not allowed")
+            scheme = "https"
+            target_url = f"{scheme}://{upstream_host}{request.path_qs}"
+        elif syt_base:
+            target_url = f"{syt_base}{request.path_qs}"
+        else:
+            return web.Response(status=502, text="gateway: no upstream resolvable")
+
+        # 技能 scope(审核 P0-3 修正:命令级注册,/execute 在 spawn 前设置,
+        # 子进程不参与传递——无法伪造/降级。请求头 X-Skill-Scope 仅作展示
+        # 覆盖不再信任,以注册值为准)
+        skill_scope = get_active_scope()
+
+        # 白名单校验(按技能 scope 分级)
+        deny = _check_allowlist(target_url, creds, skill_scope)
+        if deny is not None:
+            SYLogger.info(
+                f"[EgressGateway] 白名单拒绝: {target_url} (scope={skill_scope or 'user'})")
+            return web.Response(status=403, text=f"gateway: blocked by allowlist")
+
+        # 剥离子进程自带凭据头 + 透传其余（跳 hop-by-hop + X-Upstream-Host/X-Skill-Scope）
+        fwd_headers: dict = {}
+        for k, v in request.headers.items():
+            kl = k.lower()
+            if kl in _HOP_BY_HOP or kl in _INBOUND_CRED_HEADERS \
+                    or kl == "x-upstream-host" or kl == "x-skill-scope":
+                continue
+            fwd_headers[k] = v
+
+        # 注入凭据头 / 改写 URL（query 注入）
+        target_url, fwd_headers = _apply_credentials(
+            request.method, target_url, fwd_headers, creds)
+
+        # 读请求体（上传场景）
+        body = await request.read() if request.can_read_body else None
+
+        # 审计：入口。注意用【脱敏 URL】——target_url 此时可能已含注入的
+        # corpsecret 等敏感 query(企微 gettoken),原样落日志即凭据泄漏
+        # (审核 P1-7)。_sanitize_url 抹掉敏感 query 参数。
+        user = self._store.any_user() or "?"
+        SYLogger.info(
+            f"[EgressGateway] -> {request.method} {_sanitize_url(target_url)} "
+            f"(user={user}, scope={skill_scope or 'user'})")
+
+        # 转发（流式响应）
+        try:
+            assert self._client is not None
+            async with self._client.request(
+                request.method, target_url, headers=fwd_headers,
+                data=body, allow_redirects=False,
+            ) as upstream:
+                resp = web.StreamResponse(
+                    status=upstream.status, reason=upstream.reason)
+                # 透传响应头（跳 hop-by-hop）
+                for k, v in upstream.headers.items():
+                    if k.lower() in self._HOP_BY_HOP:
+                        continue
+                    resp.headers[k] = v
+                await resp.prepare(request)
+                bytes_out = 0
+                async for chunk in upstream.content.iter_any():
+                    await resp.write(chunk)
+                    bytes_out += len(chunk)
+                await resp.write_eof()
+                SYLogger.info(
+                    f"[EgressGateway] <- {upstream.status} {_sanitize_url(target_url)} "
+                    f"({bytes_out}B, user={user})")
+                return resp
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            SYLogger.error(f"[EgressGateway] 转发失败 {_sanitize_url(target_url)}: {e}")
+            return web.Response(status=502, text=f"gateway: upstream error: {e}")
+
+
+# ============== 命令级 scope(审核 P0-3:不经子进程,不可伪造) ==============
+# /execute 在 spawn 子进程【之前】把本条命令的技能 scope 注册到这里;
+# 网关 _proxy 按注册值分级——子进程无法通过改 env/不发头来降级,因为它
+# 根本不参与传递。值生命周期与命令执行对齐:execute 开始设、结束清。
+# 多用户并发(local 单用户)下按最近一次注册执行(同一命令的子进程内,
+# 请求都发生在该命令运行期间,时序成立)。
+_active_scope: str = "user"
+
+
+def set_active_scope(scope: str) -> None:
+    """/execute 开始时注册本命令的 scope(system/shengye-platform/user)。"""
+    global _active_scope
+    _active_scope = (scope or "user").strip().lower() or "user"
+
+
+def get_active_scope() -> str:
+    """网关取当前命令的 scope。"""
+    return _active_scope
+
+
+# ============== 模块级单例（供 services.py lifespan 启动）==============
+
+_store = CredentialStore()
+_gateway: Optional[EgressGateway] = None
+
+
+async def start_gateway(port: int = 0) -> int:
+    """启动网关 listener，返回实际端口。services.py combined_lifespan 调用。"""
+    global _gateway
+    if _gateway is not None:
+        return _gateway.port or port
+    _gateway = EgressGateway(_store, port=port)
+    return await _gateway.start()
+
+
+async def stop_gateway() -> None:
+    global _gateway
+    if _gateway is not None:
+        await _gateway.stop()
+        _gateway = None
+
+
+def gateway_base_url() -> str:
+    return _gateway.base_url if _gateway else ""
+
+
+def credential_store() -> CredentialStore:
+    return _store

sycommon/models/sandbox.py

@@ -4,7 +4,7 @@
 用于沙箱服务的 Pydantic 模型定义
 """
 
-from typing import Optional
+from typing import Optional, Dict, Any
 from pydantic import BaseModel
 
 
@@ -24,6 +24,31 @@ class ExecuteResponse(BaseModel):
     truncated: bool = False
 
 
+# ============== 出网收口凭据推送（out-of-band）==============
+# 主进程把凭据推给沙箱网关（不进子进程 env、不进命令串）。网关按目标 host 注入。
+# 详见 sycommon/middleware/sandbox_gateway.py。
+
+class CredentialPushRequest(BaseModel):
+    """向沙箱网关推送凭据的请求体。
+
+    creds 是扁平 key-value（不嵌套），形如：
+      {"SYT_TOKEN": ..., "SYT_API_AUTHZ": ...,
+       "SYT_BASE_URL": <真上游,非网关地址>, "SYT_X_HOST_NAME": ...,
+       "WECOM_CORP_ID": ..., "WECOM_CORP_SECRET": ...,
+       "WECOM_DOC_BOT_ID": ..., "WECOM_DOC_BOT_SECRET": ...,
+       "allowlist": [<path前缀或完整URL>, ...]}
+    user_id 用于 shared 模式 per-user 绑定；local 模式凭据表仅一条目。
+    """
+    user_id: str
+    creds: Dict[str, Any] = {}
+
+
+class CredentialPushResponse(BaseModel):
+    """凭据推送响应。gateway_base_url 是网关地址（子进程 SYT_BASE_URL 应指向它）。"""
+    user_id: str
+    gateway_base_url: str
+
+
 # ============== 文件操作 ==============
 
 class UploadRequest(BaseModel):

sycommon/services.py

@@ -264,7 +264,6 @@ class Services(metaclass=SingletonMeta):
             sandbox_cleanup_task = None
 
             try:
-                # 注册 asyncio 异常处理器（需在事件循环运行后）
                 try:
                     from sycommon.logging.kafka_log import KafkaLogger
                     loop = asyncio.get_running_loop()
@@ -344,6 +343,23 @@ class Services(metaclass=SingletonMeta):
                     # fire-and-forget：不阻塞启动，失败只记日志。
                     asyncio.create_task(cleanup_all_pip_tmp_residue_async())
                     logging.info("沙箱 tmp pip 残留启动清理任务已触发")
+                    # 出网收口网关：嵌入进程内的反向代理，子进程所有出网经此网关。
+                    # 主进程通过 /v1/sandbox/credentials 推送凭据（out-of-band），
+                    # 网关按目标 host 注入；子进程 env 零密钥。端口由 OS 分配，
+                    # 启动后 gateway_base_url() 供 /execute 构造子进程 SYT_BASE_URL。
+                    try:
+                        from sycommon.middleware.sandbox_gateway import start_gateway
+                        from sycommon.middleware.egress_wall import (
+                            setup_egress_wall_async, teardown_egress_wall_async)
+                        from sycommon.middleware.sandbox import CHILD_DROP_UID
+                        gw_port = await start_gateway()
+                        logging.info(f"沙箱出网网关已启动: port={gw_port}")
+                        # 网关起来后配 iptables 硬墙：只允许 child uid 连网关+DNS，其余 DROP。
+                        # node/裸socket/任意二进制绕不过。无 NET_ADMIN 时降级告警不阻断。
+                        await setup_egress_wall_async(
+                            CHILD_DROP_UID, gw_port, "127.0.0.1")
+                    except Exception as e:
+                        logging.error(f"沙箱出网网关启动失败: {e}", exc_info=True)
 
                 # 6. 初始化 MCP Server（路由已全部注册，可安全读取 OpenAPI schema）
                 if instance._enable_mcp_server:
@@ -375,6 +391,18 @@ class Services(metaclass=SingletonMeta):
                         pass
                     logging.info("沙箱后台清理任务已取消")
 
+                # 关闭出网收口网关 + iptables 硬墙
+                if instance._enable_sandbox:
+                    try:
+                        from sycommon.middleware.sandbox_gateway import stop_gateway
+                        from sycommon.middleware.egress_wall import teardown_egress_wall_async
+                        from sycommon.middleware.sandbox import CHILD_DROP_UID
+                        await teardown_egress_wall_async(CHILD_DROP_UID)
+                        await stop_gateway()
+                        logging.info("沙箱出网网关与硬墙已停止")
+                    except Exception as e:
+                        logging.debug(f"沙箱出网网关停止异常: {e}")
+
                 # 关闭 MCP Server
                 if instance._enable_mcp_server:
                     try:

{sycommon_python_lib-0.2.8a3.dist-info → sycommon_python_lib-0.2.8a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.8a3
+Version: 0.2.8a4
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown