@mrrisega/dsh-remote 0.6.18-beta.3 → 0.6.18-beta.5

package/clients/dsh-remote/mobile-adapter.mjs

@@ -1238,7 +1238,11 @@ const SCRIPT = `(() => {
            · 失败（reject）/超时（>20s）/亚毫秒（同一帧内的缓存命中）都不进样本：
              前者不是网络耗时，后者会算出 0ms 这种"谎言"；
            · **无样本时显示「测速中…」而不是 0ms** —— 0ms 会让人以为网络飞快。
-         分档：≤120ms 顺畅 / ≤300ms 一般 / >300ms 较慢（移动网络下这三档比较贴合体感）。 */
+         分档（2026-09-27 业主口径调整）：≤500ms 顺畅 / ≤1000ms 正常 / ≤2000ms 偏慢 / >2000ms 很慢。
+         为什么放宽：这是个**文本窗口**的远程操作界面（看输出、敲字、点按钮），
+         对往返延迟本来就宽容 —— 业主原话「500ms 以内的延迟都不叫事，1000ms 使用起来也是正常流畅的」。
+         旧的 120/300 分档是照"网页首屏"的体感定的，会把大量正常可用的移动网络误报成"较慢"，
+         反而让用户以为哪里坏了。 */
       const RTT_KEEP = 8, RTT_MAX_MS = 20000;
       const rttSamples = [];
       const rttEl = fab.querySelector('[data-role="rtt"]');
@@ -1249,8 +1253,10 @@ const SCRIPT = `(() => {
         const mid = s.length >> 1;
         return s.length % 2 ? s[mid] : Math.round((s[mid - 1] + s[mid]) / 2);
       };
-      const rttGrade = (ms) => (ms <= 120 ? "ok" : ms <= 300 ? "mid" : "bad");
-      const rttLabel = (g) => (g === "ok" ? "顺畅" : g === "mid" ? "一般" : "较慢");
+      /* 分档（2026-09-27 按业主口径放宽）：文本窗口的远程操作，500ms 内都算顺畅、1000ms 内正常流畅。
+         ok=顺畅 / mid=正常 / slow=偏慢 / bad=很慢 —— 颜色只用于区分，**不把"正常"渲染成告警色**。 */
+      const rttGrade = (ms) => (ms <= 500 ? "ok" : ms <= 1000 ? "mid" : ms <= 2000 ? "slow" : "bad");
+      const rttLabel = (g) => (g === "ok" ? "顺畅" : g === "mid" ? "正常" : g === "slow" ? "偏慢" : "很慢");
       const FAB_TITLE_BASE = "远程控制：字号 / 网络延迟 / 加密状态 / 返回设备列表（可拖动移动位置）";
       const renderRtt = () => {
         try {

package/clients/dsh-remote/test/mobile-adapter-guards.test.mjs

@@ -641,6 +641,31 @@ test("遮罩点击：只关左抽屉，不碰第三列", () => {
   // （不要求"清掉" —— 我们连碰都不该碰第三列。）
 });
 
+test("★ ③ CSS 打底：JS 没跑（或中途挂了）时，页面必须是官方原样、绝不被困住", () => {
+  // 这是「③ 纯 CSS 打底」唯一可被机器验证的硬性质：
+  //   适配层的**所有**劫持（把官方列改成浮层/移出屏外/隐藏/拦截点击）都必须挂在
+  //   我们自己 add 的 `dsh-ma-*` 类上 —— 那些类只有 JS 跑起来才会有。
+  //   于是"JS 没执行/中途抛错"⇒ 一个劫持类都不存在 ⇒ 页面就是官方原样。
+  //   反过来，任何**不依赖我们类名**就去 translate/隐藏官方内容列的规则，都是"JS 挂了也会困住用户"的地雷。
+  const { css } = injected();
+  const code = String(css).replace(/\/\*[\s\S]*?\*\//g, "");
+  const OFFICIAL = /pI_x6G_|hHd-Xa_|VOzbGW_|YDXeBa_|_2ctAZa_|P3OORG_|wSkVaW_|uV2eYG_/;
+  const HIJACK = /(transform\s*:\s*[^;]*translate|visibility\s*:\s*hidden|display\s*:\s*none|pointer-events\s*:\s*none|translateX\s*\()/;
+  const bad = [];
+  for (const chunk of code.split("}")) {
+    const i = chunk.lastIndexOf("{");
+    if (i < 0) continue;
+    const sel = chunk.slice(0, i).replace(/\s+/g, " ").trim();
+    const body = chunk.slice(i);
+    if (!OFFICIAL.test(sel)) continue;        // 只关心"碰官方元素"的规则
+    if (/dsh-ma-/.test(sel)) continue;        // 有我们的类做闸门 ⇒ JS 不跑就不会生效
+    if (/::/.test(sel)) continue;             // 伪元素（如 ::-webkit-scrollbar）困不住人，不算劫持
+    if (HIJACK.test(body)) bad.push(sel.slice(0, 120));
+  }
+  assert.deepEqual(bad, [],
+    "★ 这些规则没有 dsh-ma-* 闸门却会移动/隐藏/拦截官方元素 —— JS 一旦不跑，用户就被困住了");
+});
+
 test("★ 源码契约：适配层代码里不许再出现任何「驱动第三列」的符号（去注释后扫）", () => {
   const src = readFileSync(ADAPTER, "utf8");
   // 只看**代码**：STYLE 是模板字符串、注释也是文本，直接扫会命中"历史说明"

package/clients/dsh-remote/test/mobile-adapter-runtime.test.mjs

@@ -509,12 +509,30 @@ test("网络延迟：只在**已有**的 fetch 包装里采样，成功样本显
   assert.equal(calls.length, 1, "适配层不得额外发探测请求（只包装、不加请求）");
   assert.equal(rtt.hidden, false, "有成功样本后角标应出现");
   assert.match(String(rtt.textContent), /^\d+ms$/, `角标应是「<数字>ms」，实际:${rtt.textContent}`);
-  assert.ok(["ok", "mid", "bad"].includes(rtt.getAttribute("data-rtt")), "角标应带分档（ok/mid/bad）供 CSS 上色");
+  assert.ok(["ok", "mid", "slow", "bad"].includes(rtt.getAttribute("data-rtt")), "角标应带分档（ok/mid/slow/bad）供 CSS 上色");
   assert.equal(rtt.hidden === false, true);
   // 菜单里的那一行也要跟着更新（同一个 renderRtt）
   const menu = findMenu(env);
   const net = menu.querySelector(".dsh-ma-menu-net");
-  assert.ok(["ok", "mid", "bad"].includes(net.getAttribute("data-rtt")), "菜单行也应按同一分档着色");
+  assert.ok(["ok", "mid", "slow", "bad"].includes(net.getAttribute("data-rtt")), "菜单行也应按同一分档着色");
+});
+
+test("网络延迟分档：500ms 以内=顺畅、1000ms 以内=正常（远程文本窗口的判定尺度，不得再苛）", async () => {
+  // 用户 2026-09-27 明确：这类远程访问的文本窗口，500ms 以内不叫事，1000ms 用起来也正常流畅。
+  // 这条锁把「顺畅/正常/偏慢/很慢」的边界钉死，防止以后再被改苛。
+  const cases = [[5, "ok"], [600, "mid"], [1500, "slow"], [2600, "bad"]];
+  for (const [delay, want] of cases) {
+    const env = harness({
+      width: 390,
+      fetchImpl: async () => { await new Promise((r) => setTimeout(r, delay)); return { status: 200, ok: true }; },
+    });
+    runAdapter(env);
+    const rtt = findFab(env).querySelector('[data-role="rtt"]');
+    await env.win.fetch("/api/session/list");
+    await new Promise((r) => setTimeout(r, 10));
+    assert.equal(rtt.getAttribute("data-rtt"), want,
+      `≈${delay}ms 应判为 ${want}，实际 ${rtt.getAttribute("data-rtt")}（显示 ${rtt.textContent}）`);
+  }
 });
 
 test("网络延迟：无样本 / 失败请求绝不显示 0ms（显示「测速中…」是唯一正确的空态）", async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.18-beta.3",
+  "version": "0.6.18-beta.5",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",

package/packages/dsh-remote-web/lib/client.js

@@ -1167,12 +1167,14 @@ window.__ModuleLoader__.load({
     /**
      * 延迟 → 人话。
      * 🔒 无样本时必须说「测速中…」而**不是 0ms**：0ms 是句谎话（这个页面根本还没量过），
-     *    而"测速中"如实表达了"还没有样本"。分档：≤120 顺畅 / ≤300 一般 / >300 较慢。
+     *    而"测速中"如实表达了"还没有样本"。
+     *    分档（2026-09-27 按业主口径放宽）：≤500 顺畅 / ≤1000 正常 / ≤2000 偏慢 / >2000 很慢 ——
+     *    文本窗口的远程操作，500ms 内都算顺畅、1000ms 内正常流畅；旧 120/300 会把正常网络误报成"较慢"。
      */
     function netLatText() {
       if (!netLat.samples) return "测速中…";
       var ms = Math.max(1, Math.round(netLat.ms));
-      var tone = ms <= 120 ? "顺畅" : ms <= 300 ? "一般" : "较慢";
+      var tone = ms <= 500 ? "顺畅" : ms <= 1000 ? "正常" : ms <= 2000 ? "偏慢" : "很慢";
       return "网络延迟 " + ms + "ms · " + tone;
     }
 

package/packages/dsh-remote-web/lib/index.js

@@ -2884,13 +2884,45 @@ async function feedbackAuthToken(relayDir) {
   else fbTokenCache = { token: "", exp: 0 };
   return t;
 }
+/**
+ * 把「请求路径后缀」安全地拼到上游基址上（2026-09-27 安全审计 S4-C0）。
+ *
+ * ⚠️ 为什么不能只 `new URL(suffix, base)`：`suffix` 来自**请求路径**，而
+ *    `new URL("//evil.com/x", base)` 是**协议相对 URL** —— origin 直接跳到 evil.com。
+ *    实测逃逸形态是**三斜杠**：请求 `/dsh-remote/feedback///evil.com/collect`，
+ *    路由前缀匹配通过（pathname 原样保留三斜杠），旧代码只 `replace(/^\//,"")` 剥掉一个，
+ *    于是剩下 `//evil.com/collect` → 解析成 `https://evil.com/collect`，
+ *    而 proxyFeedback 会**自动带上本机账号 JWT + 真实手机号 + device_id** ——
+ *    攻击者凭这个 JWT 就能签发设备访问密钥、配对到自己手机上 = 用户电脑被完整接管。
+ *    两斜杠/`%2f`/`..` 都被限制在中继域内，**唯独三斜杠会逃逸**。
+ *
+ * 两道断言（不是二选一，缺一不可）：
+ *   ① origin 必须与基址一致 → 挡住协议相对/绝对 URL 逃逸；
+ *   ② pathname 必须以基址路径为前缀 → 挡住 `..` 逃出基址路径（如 /relay-api/ → /api/）。
+ * 任何一条不过就抛，调用方按 4xx/5xx 处理，**绝不在这种情况下把凭据发出去**。
+ */
+export function safeUpstreamUrl(base, suffix) {
+  const b = new URL(base);
+  const u = new URL(String(suffix == null ? "" : suffix).replace(/^\/+/, ""), b);
+  if (u.origin !== b.origin) throw new Error(`上游地址逃逸(origin): ${u.origin} ≠ ${b.origin}`);
+  const prefix = b.pathname.endsWith("/") ? b.pathname : `${b.pathname}/`;
+  if (!u.pathname.startsWith(prefix)) throw new Error(`上游路径逃逸(path): ${u.pathname} 不在 ${prefix} 之下`);
+  return u;
+}
+
 async function proxyFeedback(relayDir, req, res, pathname) {
   const cfg = loadConfig(relayDir);
   const api = feedbackApiOf(cfg);
   const suffix = pathname.replace(/^\/dsh-remote\/feedback/, "") || "/";
-  // 相对路径解析：保留基址的路径前缀（如 /relay-api），避免 new URL 绝对路径吞掉 base path
+  // 相对路径解析：保留基址的路径前缀（如 /relay-api），避免 new URL 绝对路径吞掉 base path。
+  // 必须走 safeUpstreamUrl：拼错的/恶意的后缀会带着账号 JWT 跑到别的域去（S4-C0）。
   const base = api.endsWith("/") ? api : `${api}/`;
-  const url = new URL(suffix.replace(/^\//, ""), base);
+  let url;
+  try {
+    url = safeUpstreamUrl(base, suffix);
+  } catch (e) {
+    return sendJson(res, 400, { ok: false, error: `非法的反馈接口路径: ${e.message}` });
+  }
   const headers = {
     "x-dsh-device": cfg.device_id || "",
     "x-dsh-client": `dsh-remote-web/${PLUGIN_VERSION}`,
@@ -5654,6 +5686,78 @@ async function sendWeChatProxy(relayDir, res, routePath, init) {
   return sendJson(res, r.status, { ok: false, code: r.code, error: r.error });
 }
 
+// ============================================================
+// 本地宿主路由的跨站防护（2026-09-27 安全审计）
+//
+// 背景：本插件把 /dsh-remote/* 注册在**本机** dsh web 上，这一层没有任何鉴权
+//   （设计如此：桌面端面板与页面同源，靠"只有本机能访问"来保证安全）。
+//   但"只有本机能访问"不等于"同源" —— 浏览器里任何网页都能向 127.0.0.1:3080 发请求：
+//     · 经典 CSRF：evil.com 表单/fetch(no-cors) POST /dsh-remote/self/uninstall、/config
+//     · DNS rebinding：把 evil.com 解析到 127.0.0.1，浏览器视为同源，于是能**读到**
+//       /dsh-remote/diag/bundle（诊断包，含本机路径与配置）与
+//       /dsh-remote/access-key（能签发设备访问密钥 = 拿到这台电脑的远程控制权）
+//   这些路由里有卸载插件、改配置、重启 harness、签发访问密钥，必须挡住。
+//
+// 判据（两条独立）：
+//   ① Host 白名单：只认 loopback authority。rebinding 时 Host 是攻击者域名 → 拒；
+//   ② Origin / Sec-Fetch-Site：带 Origin 且与 Host 不同源 → 拒；sec-fetch-site: cross-site → 拒。
+//
+// 为什么不会误伤手机端：隧道请求由 dsh-bridge 剥掉 host/origin/sec-fetch-*
+//   （clients/dsh-remote/dsh-bridge.mjs 的 STRIP_REQ_HEADERS），再由 undici 补上
+//   Host: 127.0.0.1:<port>。所以隧道流量天然过 ①、且不带 Origin 而过 ②。
+//
+// 逃生舱：DSH_REMOTE_LOCAL_GUARD=0 关闭整层；
+//   DSH_REMOTE_TRUSTED_HOSTS=a.com,b（放在 dsh web 前面的反向代理需要它）。
+// ============================================================
+const LOOPBACK_HOST_RE = /^(127\.0\.0\.1|localhost|\[::1\]|::1)(:\d+)?$/i;
+/**
+ * 私网 / 链路本地 / mDNS 的 authority。
+ *
+ * 为什么必须放行：本插件**自己**会把 dsh web 绑到 `0.0.0.0`（见 `cordis.patch.yml` 里那段
+ * `remote-web-ui lan-bind block`）——「局域网直连」是产品功能（同一 Wi-Fi 下的平板/手机直连），
+ * 只认 loopback 会把它整个挡死。真机验收时就是这么发现的。
+ *
+ * 放行它们**不等于**放开安全边界：
+ *   · DNS rebinding 仍被挡：攻击者页面把 evil.com 指到本机时，请求头里的 Host 是 **evil.com**
+ *     （浏览器按 URL 里的主机名发 Host，不看它解析到哪个 IP）→ 仍然命中 bad-host；
+ *   · CSRF 仍被挡：跨站请求的 Origin 与 Host 必然不同源 → 命中 origin-mismatch（下面 ②）；
+ *   · 唯一多让出来的是「Host 恰好是私网 IP 字面量」的请求，而它只可能来自**同源页面**
+ *     （也就是本机自己服务的那个页面），不构成新的攻击面。
+ */
+const PRIVATE_HOST_RE = new RegExp(
+  "^(?:" + [
+    "10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}",
+    "192\\.168\\.\\d{1,3}\\.\\d{1,3}",
+    "172\\.(?:1[6-9]|2\\d|3[01])\\.\\d{1,3}\\.\\d{1,3}",
+    "169\\.254\\.\\d{1,3}\\.\\d{1,3}",
+    "[a-z0-9][a-z0-9-]*\\.local",
+    "\\[(?:fe80|fc|fd)[0-9a-f:]*\\]"
+  ].join("|") + ")(:\\d+)?$",
+  "i"
+);
+const LOCAL_GUARD_LOGGED = new Map(); // reason -> 上次告警时间（同一原因 60s 只报一次，避免刷日志）
+
+/** 只读地判断一个请求是否来自"本机同源页面"。返回 null=放行，否则返回拒绝原因。
+ *  导出仅为可测（见 test/local-route-guard.test.mjs）。 */
+export function localRequestBlocked(req) {
+  if (String(process.env.DSH_REMOTE_LOCAL_GUARD || "") === "0") return null;
+  const extra = String(process.env.DSH_REMOTE_TRUSTED_HOSTS || "")
+    .split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const headers = (req && req.headers) || {};
+  const host = String(headers.host || "").trim().toLowerCase();
+  if (!host) return "missing-host";
+  if (!LOOPBACK_HOST_RE.test(host) && !PRIVATE_HOST_RE.test(host) && !extra.includes(host)) return "bad-host";
+  const origin = String(headers.origin || "").trim().toLowerCase();
+  // Origin: null（file:// 或 sandbox iframe）不在这里判，交给下面的 sec-fetch-site
+  if (origin && origin !== "null") {
+    let oh = "";
+    try { oh = new URL(origin).host.toLowerCase(); } catch { return "bad-origin"; }
+    if (oh !== host && !extra.includes(oh)) return "origin-mismatch";
+  }
+  if (String(headers["sec-fetch-site"] || "").trim().toLowerCase() === "cross-site") return "cross-site";
+  return null;
+}
+
 function registerRoutes(ctx, relayDir) {
   // 本插件所在 profile(由插件自身文件位置推导,覆盖市场 git 安装与本地 include 两种形态)
   let profileDir = join(homedir(), ".dsh", "profiles", "web");
@@ -6390,6 +6494,21 @@ function registerRoutes(ctx, relayDir) {
           res.end();
           return;
         }
+        // 跨站防护：详见 localRequestBlocked 的注释（DNS rebinding / CSRF）
+        const blocked = localRequestBlocked(req);
+        if (blocked) {
+          const now = Date.now();
+          const last = LOCAL_GUARD_LOGGED.get(blocked) || 0;
+          if (now - last > 60_000) {
+            LOCAL_GUARD_LOGGED.set(blocked, now);
+            ctx.logger?.warn?.(
+              `dsh-remote-web: 已拦截跨站请求 ${route.method} ${route.path}（${blocked}）` +
+              ` host=${req.headers?.host || "-"} origin=${req.headers?.origin || "-"}`
+            );
+          }
+          sendJson(res, 403, { ok: false, error: "forbidden", reason: blocked });
+          return;
+        }
         Promise.resolve(route.handler(req, res)).catch((e) => {
           ctx.logger?.warn?.(`dsh-remote-web: ${route.method} ${route.path} failed: ${e?.stack || e}`);
           if (!res.headersSent) sendJson(res, 500, { ok: false, error: String(e?.message || e) });

package/packages/dsh-remote-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.18-beta.3",
+  "version": "0.6.18-beta.5",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

package/packages/dsh-remote-web/runtime/clients/dsh-remote/mobile-adapter.mjs

@@ -1238,7 +1238,11 @@ const SCRIPT = `(() => {
            · 失败（reject）/超时（>20s）/亚毫秒（同一帧内的缓存命中）都不进样本：
              前者不是网络耗时，后者会算出 0ms 这种"谎言"；
            · **无样本时显示「测速中…」而不是 0ms** —— 0ms 会让人以为网络飞快。
-         分档：≤120ms 顺畅 / ≤300ms 一般 / >300ms 较慢（移动网络下这三档比较贴合体感）。 */
+         分档（2026-09-27 业主口径调整）：≤500ms 顺畅 / ≤1000ms 正常 / ≤2000ms 偏慢 / >2000ms 很慢。
+         为什么放宽：这是个**文本窗口**的远程操作界面（看输出、敲字、点按钮），
+         对往返延迟本来就宽容 —— 业主原话「500ms 以内的延迟都不叫事，1000ms 使用起来也是正常流畅的」。
+         旧的 120/300 分档是照"网页首屏"的体感定的，会把大量正常可用的移动网络误报成"较慢"，
+         反而让用户以为哪里坏了。 */
       const RTT_KEEP = 8, RTT_MAX_MS = 20000;
       const rttSamples = [];
       const rttEl = fab.querySelector('[data-role="rtt"]');
@@ -1249,8 +1253,10 @@ const SCRIPT = `(() => {
         const mid = s.length >> 1;
         return s.length % 2 ? s[mid] : Math.round((s[mid - 1] + s[mid]) / 2);
       };
-      const rttGrade = (ms) => (ms <= 120 ? "ok" : ms <= 300 ? "mid" : "bad");
-      const rttLabel = (g) => (g === "ok" ? "顺畅" : g === "mid" ? "一般" : "较慢");
+      /* 分档（2026-09-27 按业主口径放宽）：文本窗口的远程操作，500ms 内都算顺畅、1000ms 内正常流畅。
+         ok=顺畅 / mid=正常 / slow=偏慢 / bad=很慢 —— 颜色只用于区分，**不把"正常"渲染成告警色**。 */
+      const rttGrade = (ms) => (ms <= 500 ? "ok" : ms <= 1000 ? "mid" : ms <= 2000 ? "slow" : "bad");
+      const rttLabel = (g) => (g === "ok" ? "顺畅" : g === "mid" ? "正常" : g === "slow" ? "偏慢" : "很慢");
       const FAB_TITLE_BASE = "远程控制：字号 / 网络延迟 / 加密状态 / 返回设备列表（可拖动移动位置）";
       const renderRtt = () => {
         try {

package/packages/dsh-remote-web/test/local-route-guard.test.mjs

@@ -0,0 +1,101 @@
+/**
+ * 本地宿主路由的跨站防护（2026-09-27 安全审计）
+ *
+ * 为什么需要这层：/dsh-remote/* 全部注册在本机 dsh web 上且**没有鉴权**，
+ * 靠"只有本机能访问"来保证安全。但浏览器里任何网页都能向 127.0.0.1:3080 发请求：
+ *   · 经典 CSRF —— evil.com 表单 POST /dsh-remote/self/uninstall
+ *   · DNS rebinding —— evil.com 解析到 127.0.0.1 后浏览器视为同源，
+ *     于是能**读到** /dsh-remote/diag/bundle 与 /dsh-remote/access-key（可签发设备密钥）
+ * 这两条都能直达"控制用户电脑"，所以判据必须被测试钉死。
+ *
+ * 同时钉住"不误伤手机"：隧道请求被 bridge 剥掉 host/origin/sec-fetch-*，
+ * undici 补上 Host: 127.0.0.1:<port> —— 形态与第一条用例完全一致。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { localRequestBlocked } from "../lib/index.js";
+
+const HERE = new URL("../lib/index.js", import.meta.url);
+
+/** 造一个只有 headers 的伪请求（守卫是纯函数，只看这几个头）。 */
+const req = (headers) => ({ headers });
+
+test("守卫放行：手机隧道形态（Host=loopback、无 Origin、无 sec-fetch）", () => {
+  // 这正是 dsh-bridge 转发到 127.0.0.1:3080 之后本机看到的形态
+  assert.equal(localRequestBlocked(req({ host: "127.0.0.1:3080" })), null);
+  assert.equal(localRequestBlocked(req({ host: "localhost:3080" })), null);
+  assert.equal(localRequestBlocked(req({ host: "[::1]:3080" })), null);
+  // 桌面端面板：同源 fetch，Origin 与 Host 一致
+  assert.equal(localRequestBlocked(req({ host: "127.0.0.1:3080", origin: "http://127.0.0.1:3080" })), null);
+  assert.equal(localRequestBlocked(req({ host: "127.0.0.1:3080", "sec-fetch-site": "same-origin" })), null);
+});
+
+test("守卫放行：局域网直连（插件自己 lan-bind 到 0.0.0.0，这是产品功能，不能一刀切挡掉）", () => {
+  // 2026-09-27 真机验收时发现：只认 loopback 会把「同一 Wi-Fi 下直连」整个挡死
+  for (const host of ["172.16.27.98:3080", "192.168.1.30:3080", "10.0.0.5:3080", "mac.local:3080"]) {
+    assert.equal(localRequestBlocked(req({ host })), null, `${host} 是私网/mDNS，应放行`);
+  }
+  // 但打这些地址的**跨站**请求仍必须拒（CSRF 与 Host 白名单是两条独立判据）
+  assert.equal(
+    localRequestBlocked(req({ host: "172.16.27.98:3080", origin: "http://evil.com" })),
+    "origin-mismatch",
+    "局域网地址上的跨站 POST 同样要挡"
+  );
+});
+
+test("DNS rebinding 必拒：Host 不是 loopback（即使 Origin 与该 Host 自洽）", () => {
+  // rebinding 的形态：页面来源与目标都是 evil.com，Origin/Host 互相自洽 —— 只有 Host 白名单能挡
+  assert.equal(localRequestBlocked(req({ host: "evil.com", origin: "http://evil.com" })), "bad-host");
+  assert.equal(localRequestBlocked(req({ host: "evil.com:3080" })), "bad-host");
+  assert.equal(localRequestBlocked(req({ host: "127.0.0.1.evil.com" })), "bad-host");
+  assert.equal(localRequestBlocked(req({ host: "172.16.27.98.evil.com" })), "bad-host", "私网前缀伪装也要拒");
+  assert.equal(localRequestBlocked(req({ host: "8.8.8.8:3080" })), "bad-host", "公网 IP 字面量不在白名单");
+  assert.equal(localRequestBlocked(req({})), "missing-host");
+});
+
+test("CSRF 必拒：Origin 与 Host 不同源 / Sec-Fetch-Site= cross-site", () => {
+  assert.equal(
+    localRequestBlocked(req({ host: "127.0.0.1:3080", origin: "http://evil.com" })),
+    "origin-mismatch"
+  );
+  assert.equal(
+    localRequestBlocked(req({ host: "127.0.0.1:3080", origin: "https://n.risegao.cn" })),
+    "origin-mismatch"
+  );
+  assert.equal(
+    localRequestBlocked(req({ host: "127.0.0.1:3080", "sec-fetch-site": "cross-site" })),
+    "cross-site"
+  );
+});
+
+test("逃生舱：DSH_REMOTE_LOCAL_GUARD=0 全关、DSH_REMOTE_TRUSTED_HOSTS 追加反代域名", () => {
+  const saved = { g: process.env.DSH_REMOTE_LOCAL_GUARD, h: process.env.DSH_REMOTE_TRUSTED_HOSTS };
+  try {
+    process.env.DSH_REMOTE_LOCAL_GUARD = "0";
+    assert.equal(localRequestBlocked(req({ host: "evil.com" })), null, "关掉后必须完全放行（排障用）");
+    delete process.env.DSH_REMOTE_LOCAL_GUARD;
+    process.env.DSH_REMOTE_TRUSTED_HOSTS = "dsh.example.com";
+    assert.equal(localRequestBlocked(req({ host: "dsh.example.com" })), null, "反代域名应被信任");
+    assert.equal(
+      localRequestBlocked(req({ host: "dsh.example.com", origin: "http://dsh.example.com" })),
+      null
+    );
+    assert.equal(localRequestBlocked(req({ host: "evil.com" })), "bad-host", "白名单外仍然拒");
+  } finally {
+    if (saved.g === undefined) delete process.env.DSH_REMOTE_LOCAL_GUARD; else process.env.DSH_REMOTE_LOCAL_GUARD = saved.g;
+    if (saved.h === undefined) delete process.env.DSH_REMOTE_TRUSTED_HOSTS; else process.env.DSH_REMOTE_TRUSTED_HOSTS = saved.h;
+  }
+});
+
+test("源码契约：守卫必须在路由分发处真的被调用（纯函数单测挡不住'忘了接上'）", async () => {
+  const src = await readFile(HERE, "utf8");
+  assert.match(src, /const blocked = localRequestBlocked\(req\)/,
+    "路由分发处必须调用 localRequestBlocked(req)");
+  assert.match(src, /sendJson\(res, 403, \{ ok: false, error: "forbidden", reason: blocked \}\)/,
+    "被拦的请求必须回 403 且带上原因（便于排查误伤）");
+  // 拦截必须发生在 handler 之前：否则副作用已经产生
+  const guardAt = src.indexOf("const blocked = localRequestBlocked(req)");
+  const callAt = src.indexOf("Promise.resolve(route.handler(req, res))");
+  assert.ok(guardAt > 0 && callAt > guardAt, "守卫必须在 handler 调用之前");
+});

package/packages/dsh-remote-web/test/upstream-url-guard.test.mjs

@@ -0,0 +1,49 @@
+/**
+ * 上游代理地址拼接的安全契约（2026-09-27 安全审计 S4-C0）
+ *
+ * 漏洞形态：`/dsh-remote/feedback` 是**前缀路由**，后缀直接来自请求路径，
+ * 旧代码只剥一个前导斜杠就交给 `new URL()`：
+ *   pathname = "/dsh-remote/feedback///evil.com/collect"
+ *   suffix   = "///evil.com/collect" → 剥一个 → "//evil.com/collect"  ← 协议相对 URL！
+ *   new URL("//evil.com/collect", "https://n.risegao.cn:13443/relay-api/") = https://evil.com/collect
+ * 而 proxyFeedback 在没有 Authorization 时会**自动附加本机账号 JWT + 真实手机号 + device_id**
+ * —— 一条 GET（`<img>` 即可触发）就把账号凭据送到攻击者主机，凭它能签发设备访问密钥、
+ * 配对到攻击者手机 = 用户电脑被完整接管。两斜杠/`%2f`/`..` 都被限制在中继域内，唯独三斜杠逃逸。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { safeUpstreamUrl } from "../lib/index.js";
+
+const BASE = "https://n.risegao.cn:13443/relay-api/";
+const ORIGIN = new URL(BASE).origin;
+
+test("正常后缀：拼在基址路径之下，域名与路径前缀都不变", () => {
+  assert.equal(safeUpstreamUrl(BASE, "/").href, BASE);
+  assert.equal(safeUpstreamUrl(BASE, "/api/feedback").href, `${BASE}api/feedback`);
+  assert.equal(safeUpstreamUrl(BASE, "api/feedback?x=1").href, `${BASE}api/feedback?x=1`);
+  // 基址没有路径前缀时（自建反馈服务）也应正常
+  assert.equal(safeUpstreamUrl("https://fb.example.com", "/api/x").href, "https://fb.example.com/api/x");
+});
+
+test("🔴 逃逸形态：三斜杠 / 两斜杠绝不换域（降级为基址下的路径段）", () => {
+  for (const suffix of ["///evil.com/collect", "//evil.com/x", "/////evil.com/y"]) {
+    const u = safeUpstreamUrl(BASE, suffix);
+    assert.equal(u.origin, ORIGIN, `${suffix} 不得逃到别的域，实际 ${u.origin}`);
+    assert.ok(u.pathname.startsWith("/relay-api/"), `${suffix} 必须仍在基址路径下，实际 ${u.pathname}`);
+  }
+});
+
+test("🔴 逃逸形态：绝对 URL 与 .. 路径穿越必须抛错（而不是把凭据发出去）", () => {
+  assert.throws(() => safeUpstreamUrl(BASE, "https://evil.com/x"), /origin/);
+  assert.throws(() => safeUpstreamUrl("https://h/relay-api/", "/../admin/api/users"), /path/);
+  assert.throws(() => safeUpstreamUrl("https://h/relay-api/", "/%2e%2e/admin"), /path/);
+  assert.throws(() => safeUpstreamUrl("https://h/relay-api/", "/a/../../b"), /path/);
+});
+
+test("源码契约：proxyFeedback 必须走 safeUpstreamUrl（不得再裸 new URL(suffix)）", async () => {
+  const src = await readFile(new URL("../lib/index.js", import.meta.url), "utf8");
+  assert.ok(!/new URL\(suffix\.replace/.test(src),
+    "不得再出现 `new URL(suffix.replace(/^\\//, \"\"), base)` —— 那正是 S4-C0 的漏洞写法");
+  assert.match(src, /url = safeUpstreamUrl\(base, suffix\)/, "proxyFeedback 必须调用 safeUpstreamUrl");
+});