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

sycommon/middleware/sandbox.py

@@ -60,6 +60,7 @@ from sycommon.models.sandbox import (
     ExecuteStreamRequest,
     PortForwardRequest, PortForwardResponse,
     WatchRequest, WatchEvent, WatchResponse,
+    CredentialPushRequest, CredentialPushResponse,
 )
 
 
@@ -581,6 +582,102 @@ def resolve_sandbox_path(path: str, workspace: str) -> str:
 _SUBPROCESS_NEW_SESSION = platform.system() != "Windows"
 
 
+# 技能 scope 提取:命令里出现的 skills/<scope>/<技能>/ 路径 → scope。
+# 用于按技能目录分级出网策略:
+#   system / shengye-platform → 全管制(名单外 DROP)
+#   user                     → 只管制 SYT/星瀚/OA,其余放行
+# 多个 scope 同时出现(极少)取最严(system/shengye-platform 优先)。
+_SKILL_SCOPE_RE = None  # 延迟编译
+
+
+def _extract_skill_scope(command: str) -> str:
+    """从命令字符串提取技能 scope:'system' | 'shengye-platform' | 'user' | ''。
+
+    匹配 skills/<scope>/<技能名>/ 形态;同严优先:system > shengye-platform > user。
+    命令不含技能路径 → ''(按 user 宽松策略处理,不误伤普通命令)。
+    """
+    global _SKILL_SCOPE_RE
+    if _SKILL_SCOPE_RE is None:
+        import re
+        _SKILL_SCOPE_RE = re.compile(
+            r'(?<![\w])skills/(system|shengye-platform|user)/[A-Za-z0-9_\-]+(?:/|$)')
+    found = set(_SKILL_SCOPE_RE.findall(command or ""))
+    # 严格优先:任一 system/shengye-platform 出现即按其处理
+    if "system" in found or "shengye-platform" in found:
+        return "system"  # 两者策略一致(全管制),归并为 system 语义
+    if "user" in found:
+        return "user"
+    return ""
+
+
+# 出网收口：child 子进程降权到的固定非特权 uid。
+# 收口硬墙（iptables OUTPUT DROP -m owner --uid-owner）按此 uid 区分 child 与
+# 沙箱服务进程——服务进程连 Nacos/Redis/MinIO 用别的 uid，不受 child 规则影响；
+# child 降为该 uid 后既改不了 iptables（无 CAP_NET_ADMIN），又被 owner-match 锁死出网。
+# 65534 = Linux "nobody"，公认的非特权 uid。
+CHILD_DROP_UID = int(os.environ.get("SANDBOX_CHILD_UID", "65534"))
+
+
+def _preexec_drop_privileges():
+    """preexec_fn：fork 后、exec 前把 child 降到非特权 uid（仅 Linux）。
+
+    在 start_new_session（新会话/进程组）之后、exec 之前执行。降权使 child：
+      1. 无 CAP_NET_ADMIN → 改不了 iptables 规则（硬墙不可被 child 自清）。
+      2. 与服务进程 uid 不同 → iptables owner-match 能精确只锁 child 出网。
+    降权后 child 仍需能写自己的工作区目录，故 workspace 在 aensure_subdirs 后
+    会 chown 给该 uid（见 _chown_workspace_for_child）。
+    """
+    if platform.system() == "Windows":
+        return
+    try:
+        uid = CHILD_DROP_UID
+        # 保留 gid 为 uid 同值（nobody:nobody），彻底非特权。
+        os.setgid(uid)
+        os.setuid(uid)
+    except Exception as e:
+        # 降权失败（如非 root 运行沙箱服务、或 uid 不存在）：不阻断执行，
+        # 但记录——此时 child 仍为服务进程 uid，iptables owner-match 会连带影响
+        # 服务进程（需运维确保沙箱服务以 root 起、child 可降权）。
+        SYLogger.warning(f"[Sandbox Server] child 降权失败(uid={CHILD_DROP_UID}): {e}")
+
+
+async def _chown_workspace_for_child(workspace: str):
+    """把用户工作区 chown 给 child uid，使降权后的 child 能读写自己的文件。
+
+    必须在 spawn child 之前完成，否则降权后的 child 因无写权限报错。
+    幂等：已是该 uid 时不重复 chown。
+    """
+    if platform.system() == "Windows":
+        return
+
+    def _chown():
+        uid = CHILD_DROP_UID
+        try:
+            import pwd
+            # 确认 uid 存在（nobody 通常存在）；不存在则不 chown，靠降权失败兜底。
+            try:
+                pwd.getpwuid(uid)
+            except KeyError:
+                SYLogger.warning(f"[Sandbox Server] uid={uid} 不存在，跳过 chown（child 降权将失败并保留服务 uid）")
+                return
+            # 递归 chown 工作区（顶层 + 子目录/文件），使降权 child 可读写。
+            for root, dirs, files in os.walk(workspace):
+                try:
+                    os.chown(root, uid, uid)
+                except OSError:
+                    pass
+                for name in dirs + files:
+                    p = os.path.join(root, name)
+                    try:
+                        os.chown(p, uid, uid)
+                    except OSError:
+                        pass
+        except Exception as e:
+            SYLogger.warning(f"[Sandbox Server] chown 工作区失败: {e}")
+
+    await asyncio.to_thread(_chown)
+
+
 @functools.lru_cache(maxsize=1)
 def _grep_supports_null_separator() -> bool:
     """探测系统 grep 是否为 GNU 语义的 `-Z`（文件名后 NUL 分隔）。
@@ -792,6 +889,41 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
             type="remote",
         )
 
+    # ============== 出网收口凭据推送（out-of-band）==============
+    # 主进程把凭据推给沙箱内嵌网关。凭据【绝不】进子进程 env、不进命令串；
+    # 子进程 SYT_BASE_URL 指向网关，请求经网关时按目标 host 注入正确凭据。
+    # 详见 sandbox_gateway.py。local 模式单用户；shared 模式按 user_id 绑定。
+
+    @sandbox_router.post("/credentials", response_model=CredentialPushResponse)
+    async def push_credentials(req: CredentialPushRequest):
+        """推送凭据（覆盖该 user_id）。返回网关地址，主进程据此构造子进程 SYT_BASE_URL。"""
+        from sycommon.middleware.sandbox_gateway import credential_store, gateway_base_url
+        await credential_store().set(req.user_id, req.creds)
+        SYLogger.info(
+            f"[Sandbox Server] 凭据已推送: user={req.user_id}, "
+            f"keys={list(req.creds.keys())}")
+        return CredentialPushResponse(
+            user_id=req.user_id, gateway_base_url=gateway_base_url())
+
+    @sandbox_router.put("/credentials", response_model=CredentialPushResponse)
+    async def refresh_credentials(req: CredentialPushRequest):
+        """刷新凭据（token 更新）。语义同 POST（整体替换该 user_id 的凭据）。"""
+        from sycommon.middleware.sandbox_gateway import credential_store, gateway_base_url
+        await credential_store().set(req.user_id, req.creds)
+        SYLogger.info(
+            f"[Sandbox Server] 凭据已刷新: user={req.user_id}, "
+            f"keys={list(req.creds.keys())}")
+        return CredentialPushResponse(
+            user_id=req.user_id, gateway_base_url=gateway_base_url())
+
+    @sandbox_router.delete("/credentials")
+    async def delete_credentials(user_id: str):
+        """清除该 user_id 的凭据（token 失效/登出）。返回 {deleted: bool}。"""
+        from sycommon.middleware.sandbox_gateway import credential_store
+        deleted = await credential_store().delete(user_id)
+        SYLogger.info(f"[Sandbox Server] 凭据清除: user={user_id}, deleted={deleted}")
+        return {"deleted": deleted}
+
     @sandbox_router.post("/execute", response_model=ExecuteResponse)
     async def execute(req: ExecuteRequest):
         """执行 shell 命令"""
@@ -807,6 +939,8 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
             f"[Sandbox Server] 执行命令: {req.command} (user={req.user_id}, timeout={req.timeout}s)")
 
         await aensure_subdirs(workspace)
+        # 降权前置：把工作区 chown 给 child uid，使降权后的 child 能读写自己的文件。
+        await _chown_workspace_for_child(workspace)
 
         # 使用统一初始化脚本
         init_script = _build_init_script(workspace)
@@ -821,12 +955,50 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
         # 构建跨平台执行命令
         full_command, _ = _build_execute_command(init_script, translated_command)
 
-        # 设置环境变量
-        env = os.environ.copy()
+        # 设置环境变量：**白名单构造，不 os.environ.copy()**。
+        # 收口目标：子进程 env 零密钥（SYT_TOKEN / SYT_API_AUTHZ / WECOM_* 一律不进 env）。
+        # 凭据由沙箱网关在请求时按目标 host 注入（见 sandbox_gateway.py），
+        # 主进程经 /v1/sandbox/credentials 推送给网关（out-of-band）。
+        # 故这里只给子进程：PATH 等运行必需项 + 临时目录 + 沙箱根 + 网关地址。
+        env = {}
+        # 运行必需的非敏感 env 白名单（PATH/HOME/LANG 等），其余丢弃以防泄漏服务端密钥。
+        for k in ("PATH", "HOME", "LANG", "LC_ALL", "LC_CTYPE", "TZ",
+                  "PYTHONPATH", "PYTHONUNBUFFERED", "PYTHONDONTWRITEBYTECODE"):
+            v = os.environ.get(k)
+            if v is not None:
+                env[k] = v
         env["TMPDIR"] = os.path.join(workspace, "tmp")
         env["TEMP"] = os.path.join(workspace, "tmp")
         env["TMP"] = os.path.join(workspace, "tmp")
         env["SANDBOX_ROOT"] = workspace
+        # 出网网关：子进程 SYT_BASE_URL 指向网关（http://127.0.0.1:port），
+        # HTTPS_PROXY 让 requests/httpx/curl/wget 自动走网关。node/裸 socket 不读
+        # proxy 的运行时，由后续 seccomp 硬墙兜底（只放行网关 host:port）。
+        from sycommon.middleware.sandbox_gateway import gateway_base_url
+        gw = gateway_base_url()
+        if gw:
+            env["SYT_BASE_URL"] = gw
+            # ⚠️ 审核修正(P0-1):不再设 HTTP_PROXY/HTTPS_PROXY。网关不支持
+            # CONNECT 隧道,设了反而把所有硬编码 https:// 的技能(OA/星瀚/亿联/
+            # 企微)打成 404 tunnel 错误。SYT 流量本来就经 SYT_BASE_URL 指向网关;
+            # 其他域名按 EgressPolicy(defaultMode=allow)直连即可。
+            env["NO_PROXY"] = "*"
+            # 技能 scope(system/shengye-platform/user):网关据此分级出网策略。
+            # 命令级权威注入(审核 P0-3):env 只写 scope 供脚本读取展示;
+            # 真正的分级判定在网关侧按【本命令的 scope】执行——见下方
+            # _gateway_scope 注册(每次 /execute 前把 scope 告知网关,
+            # 子进程无法伪造/降级,因为它根本不经子进程)。
+            scope = _extract_skill_scope(req.command)
+            if scope:
+                env["SANDBOX_SKILL_SCOPE"] = scope
+            try:
+                from sycommon.middleware import sandbox_gateway as _sgw
+                _sgw.set_active_scope(scope or "user")
+            except Exception as _se:
+                SYLogger.warning(f"[Sandbox Server] 网关 scope 注册失败(降级user): {_se}")
+        else:
+            # 网关未启动（降级）：仍尽量保持环境可用，但记警告。
+            SYLogger.warning("[Sandbox Server] 出网网关未就绪，子进程将无法经收口出网")
 
         try:
             # 使用 asyncio.create_subprocess_shell 异步执行命令，避免阻塞事件循环
@@ -841,6 +1013,7 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
                 cwd=workspace,
                 env=env,
                 start_new_session=_SUBPROCESS_NEW_SESSION,
+                preexec_fn=_preexec_drop_privileges if platform.system() != "Windows" else None,
             )
 
             try:
@@ -900,6 +1073,14 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
                 exit_code=1,
                 truncated=False
             )
+        finally:
+            # 命令结束:清除命令级 scope 注册(下一条命令重新注册;
+            # 防止残留 scope 影响后续普通命令的网关分级)
+            try:
+                from sycommon.middleware import sandbox_gateway as _sgw
+                _sgw.set_active_scope("user")
+            except Exception:
+                pass
 
     @sandbox_router.post("/ls")  # response_model 不固定：dict(error)/list[FileInfo]
     async def ls_info(req: LsRequest):