dsh-crossterm 0.8.1 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # dsh-crossterm 变更记录
 
+## 0.8.3 — 2026-10-19
+
+### 已归档会话只备份一次，卡片把备份拆成「已归档 / 活跃中」
+
+- **归档清单**：DSH 把已归档会话记在 `<DSH_HOME>/storages/workspace.json` 的 `global.archivedSessionIds`（本机 24 个）。
+  新增 `readArchivedIds(dshHome)` 读它，读不到就当没有归档（不让备份停摆）。
+- **归档会话备份一次就别再备**：`backupSessions()` 把会话分成「已归档 / 活跃中」两类，
+  归档会话第一次传完在 `backup-state.json` 里记 `archived: true`，之后每轮直接跳过、连大小都不比；
+  万一归档文件事后被写大（理论上不会），仍然补传一次再回到跳过。
+- **计数进状态**：每轮写 `state.lastRun = {at, archivedTotal, activeTotal, archivedDone, activeDone}`；
+  `backupSummary()` 带出 `archived / active / archivedBackedUp / activeBackedUp`。
+- **卡片**：「会话备份」行显示 `已归档 24/24 · 活跃中 9/9 · 43.1 MB · 上次 2 分钟前`。
+- **修**：`loadState()` 原来会把不认识的字段丢掉，导致 `lastRun` 存不进总结；改成保留未知字段。
+- 探针 `F:\dsh\001X\crossterm-work\probe-archived-backup.mjs` **16 PASS**（首轮分类、次轮全跳过、归档变大补一次、清单缺失回落活跃）；
+  `probe-cloud-home` 42、`probe-security-080` 21、`probe-relay-082` 7 回归通过。
+- **要不要跟着动手：不用**（纯备份策略与显示）。
+
+## 0.8.2 — 2026-10-19
+
+### 复测反馈：F7 只修一半、A6、F14、F16
+
+- **F7/F8 只修一半**：跳过判断用文件名（`state.processed[name]`）、投递记录写信封 id（`state.processed[mailId]`），
+  同一个 id 换两个文件名会被投两次；归档失败时下一轮会重复投递。
+  改为 `state.seen[name] = mailId` 记录「文件名 → 信封 id」，跳过判断统一看这张表 + 已投递表；
+  发现同 id 的第二个文件时直接把它归档到 `done/`，不再投第二次。
+- **A6（安全）DNS rebinding**：`GET /crossterm/api/token` 是先取令牌再用的引导接口，同源 GET 不带 `Origin`，
+  rebound 页面的 `Host` 是攻击者域名却能拿到令牌，令牌防线被绕过。
+  现在所有 `/crossterm/api/*`（含 token 路由）都要求 `Host` 是 `127.0.0.1` / `localhost` / `[::1]`，否则 403。
+- **F14 收件人解析**：`to` 写设备名（`yoce-c-4fb38e`）或写错名字时，原实现一律「留件」，信在对方 inbox 里每 20 秒重试。
+  现在按 会话名/短号 → `session-<uuid>` → 最近活跃会话 依次回退，并把回退原因写进正文；
+  只有本机一个会话都没有时才留件。
+- **F16 死信**：失败原来每轮都重下重投。现在按 20s / 1m / 5m / 15m / 1h 退避，连续 8 次移进
+  `<设备目录>/dead/` 并记 `parked`，不再无限重试；签名无效的信件直接退避 1 小时。
+
+- 探针：`probe-relay-082.mjs` 7 项全 PASS（同 id 两文件名只投一次、重复副本归档、失败退避、退避期内不重投、8 次进 dead）。
+- 要不要跟着动手：**要** —— 收信方升级到 0.8.2 才能吃到「设备名/写错名字」的回退与死信退避。
+
 ## 0.8.1 — 2026-10-19
 
 ### 从旧版升到 0.8.0 时，签名密钥可能一直生成不出来

package/README.md

@@ -28,25 +28,23 @@ A 终端看不到 B 终端里有哪个会话、在干什么，也没法把一条
 > `locatePkgJson()` 对子路径行返回 undefined），而插件页顶部标题与这一行共用同一份 `locale/zh.json` 的 meta，
 > 所以它单独做总开关，标题带「（总开关）」；卡片头用 `shortTitle` 显示短名「跨端互通」。
 
-**本版更新（0.8.1）**
+**本版更新（0.8.3）**
 
-- **补一个升级边角**：从旧版升上来时布局缓存里没有签名密钥，原来会一直不生成（验签暂时形同虚设）；
-  现在检测到没有密钥就重算一遍并写进 `_account.json`。装上即可，无需额外操作。
+- **已归档会话不再反复备份**：备份前先读 DSH 的归档清单（`storages/workspace.json`），
+  归档会话第一次传完就标记，之后每轮直接跳过（本机 24 个已归档、9 个活跃中）。
+- **卡片细分**：「会话备份」行改成 `已归档 24/24 · 活跃中 9/9 · 43.1 MB · 上次 …`，
+  一眼看出哪类备份完了。
+- **活跃会话照旧增量**：从 `_session.json` 的水位往后传，不会重传整份。
 
-**上一版（0.8.0）— 安全加固（来源：辅助机复核报告）**
+**上一版（0.8.2）**
 
-- **附件名只认纯文件名**：以前信封里的附件名带 `..\..\` 能写到收件箱外面，现在一律取 basename 并校验最终路径仍在目标目录内。
-- **本地接口要令牌**：写操作（更新/备份/检查更新/云同步开关/配置云盘）要带 `x-crossterm-token`（`<busDir>\http-token`，0600），
-  带外站 `Origin` 的请求 403 —— 防网页 CSRF。卡片自动取令牌，不用手动配。
-- **云端信封带 HMAC-SHA256 签名**：密钥 `relaySecret` 自动生成在 `_account.json`，收信侧验签，签名缺失或不符就留件不收。
-- **入站限额**：信封 >512 KB 跳过、附件最多 20 个、单附件 >64 MB 拒收；信封自带的云端路径不再采信。
-- **投递顺序修正**：按信封 id 去重、先归档 `done/` 成功再记已处理。
-- **要跟着动手**：账号生成 `relaySecret` 后，<0.8.0 设备发的未签名信封会被拒收；请把所有设备升到 ≥0.8.0。
+- 死信按 20s / 1m / 5m / 15m / 1h 退避，8 次后进 `dead/`；收件人写设备名会回退「最近活跃会话」；
+  同一个信封不会投两次；`/crossterm/api/*` 要求本机回环 `Host`。
 
-**更早（0.7.6）**
+**更早（0.8.1 / 0.8.0）**
 
-- 跨设备邮件末尾不再重复给两条回复提示，只留一条。
-- 邮件格式契约补第 4 条硬规则：**尾行只给一次**。
+- 0.8.1：旧布局缓存缺签名密钥时会重算并补写 `relaySecret`。
+- 0.8.0 安全加固：附件名净化 + 越界校验、写接口要 `x-crossterm-token`、信封 HMAC 签名、入站限额、按 id 去重。
 
 ## 一、安装与卸载
 

package/client/client.js

@@ -197,7 +197,11 @@ window.__ModuleLoader__.load({
 		function backupText(backup) {
 			if (!backup || !backup.files) return "还没有备份（会在开云同步后自动开始）";
 			const when = backup.lastAt ? agoText(backup.lastAt) : "未知";
-			return `${backup.files} 个会话 · ${sizeText(backup.bytes)} · 上次 ${when}`;
+			const parts = [];
+			if (typeof backup.archived === "number") parts.push(`已归档 ${Number(backup.archivedBackedUp || 0)}/${backup.archived}`);
+			if (typeof backup.active === "number") parts.push(`活跃中 ${Number(backup.activeBackedUp || 0)}/${backup.active}`);
+			const head = parts.length ? parts.join(" · ") : `${backup.files} 个会话`;
+			return `${head} · ${sizeText(backup.bytes)} · 上次 ${when}`;
 		}
 
 		function Card() {

package/lib/bus.js

@@ -22,7 +22,7 @@ import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
 
-export const VERSION = '0.8.1'
+export const VERSION = '0.8.3'
 
 /** DSH 的家目录：与宿主其它状态（sessions / profiles）同一个根，多终端天然共享 */
 export function dshHome() {

package/lib/cloud/home.js

@@ -94,6 +94,7 @@ export function createCloudHome({ cfg, device, deviceInfo, pan, busDir, deliver,
         pan,
         layout,
         sessionsRoot,
+        dshHome: home,
         tmpDir: path.join(root, 'tmp'),
         stateFile: backupState,
         log: (line) => log('backup: ' + line),

package/lib/cloud/relay.js

@@ -13,9 +13,9 @@ const nowIso = () => new Date().toISOString()
 function loadState(file) {
   try {
     const j = JSON.parse(fs.readFileSync(file, 'utf8'))
-    return { at: j.at || 0, processed: j.processed || {}, failed: j.failed || {}, sent: j.sent || [] }
+    return { at: j.at || 0, processed: j.processed || {}, seen: j.seen || {}, failed: j.failed || {}, sent: j.sent || [] }
   } catch {
-    return { at: 0, processed: {}, failed: {}, sent: [] }
+    return { at: 0, processed: {}, seen: {}, failed: {}, sent: [] }
   }
 }
 
@@ -169,7 +169,14 @@ export function createRelay({ pan, getLayout, localDir, stateFile, deliver, getS
           log(stats.lastError)
           continue
         }
-        if (state.processed[name]) continue
+        // 0.8.2 F7：跳过判断统一用「文件名 → 信封 id」表（seen），投递记录统一用信封 id。
+        if (state.seen[name] || state.processed[name]) continue
+        const prevFail = state.failed[name]
+        if (prevFail && Number(prevFail.nextAt || 0) > Date.now()) {
+          // 0.8.2 F16：退避期内不再下载/重投
+          stats.pending += 1
+          continue
+        }
         const localJson = path.join(incomingDir, name)
         let envelope
         try {
@@ -182,6 +189,21 @@ export function createRelay({ pan, getLayout, localDir, stateFile, deliver, getS
           continue
         }
         const mailId = envelope.id || path.basename(name, '.json')
+        if (state.processed[mailId]) {
+          // 0.8.2 F7：同一个信封换了文件名又出现 —— 已经投过，把这个副本归档掉，不再投第二次
+          try {
+            await pan.mkdir(layout.paths.doneDir)
+            await pan.put(localJson, `${layout.paths.doneDir}/${name}`)
+            await pan.rm(`${layout.paths.inboxDir}/${name}`)
+            state.seen[name] = mailId
+            delete state.failed[name]
+            saveState(stateFile, { ...state, at: Date.now() })
+            log(`中转站：${name} 与已投递的 ${mailId} 同一个信封，已归档不重投`)
+          } catch (e) {
+            log(`中转站：${name} 重复信封归档失败：${(e && e.message) || String(e)}`)
+          }
+          continue
+        }
         // 0.8.0 F3：有账号密钥就要求签名对得上，否则拒收（防伪造发件人 / 提示注入）
         const secret = await secretNow()
         if (secret) {
@@ -189,7 +211,9 @@ export function createRelay({ pan, getLayout, localDir, stateFile, deliver, getS
             stats.failed += 1
             stats.lastError = `信封签名无效，已拒收：${name}`
             log(stats.lastError)
-            state.failed[mailId] = { at: nowIso(), reason: '签名无效', tries: Number(state.failed?.[mailId]?.tries || 0) + 1 }
+            const prevSig = state.failed[name] || {}
+            const sigTries = Number(prevSig.tries || 0) + 1
+            state.failed[name] = { at: nowIso(), mailId, reason: '签名无效', tries: sigTries, nextAt: Date.now() + 3600000 }
             saveState(stateFile, { ...state, at: Date.now() })
             continue
           }
@@ -223,12 +247,35 @@ export function createRelay({ pan, getLayout, localDir, stateFile, deliver, getS
             log(`归档 ${name} 失败：${(e && e.message) || String(e)}`)
           }
           state.processed[mailId] = { at: nowIso(), name, mailId, archived, sessionId: result.sessionId || '', to: String(envelope.to) }
+          state.seen[name] = mailId
+          delete state.failed[name]
           log(`中转站投递 ${mailId} → ${result.sessionId || String(envelope.to)}`)
         } else {
           stats.pending += 1
-          const key = `${name}`
-          state.failed[key] = { at: nowIso(), reason: (result && result.reason) || '投递失败', tries: Number(state.failed?.[key]?.tries || 0) + 1 }
-          log(`中转站留件 ${name}：${(result && result.reason) || '投递失败'}`)
+          // 0.8.2 F16：失败按 20s/1m/5m/15m/1h 退避，连续 8 次移进 dead/，不再每 20 秒重下重投
+          const prev = state.failed[name] || {}
+          const tries = Number(prev.tries || 0) + 1
+          const delays = [20000, 60000, 300000, 900000, 3600000]
+          state.failed[name] = {
+            at: nowIso(),
+            mailId,
+            reason: (result && result.reason) || '投递失败',
+            tries,
+            nextAt: Date.now() + delays[Math.min(tries - 1, delays.length - 1)],
+          }
+          log(`中转站留件 ${name}（第 ${tries} 次）：${(result && result.reason) || '投递失败'}`)
+          if (tries >= 8) {
+            try {
+              const deadDir = `${layout.paths.deviceRoot}/dead`
+              await pan.mkdir(deadDir)
+              await pan.put(localJson, `${deadDir}/${name}`)
+              await pan.rm(`${layout.paths.inboxDir}/${name}`)
+              state.failed[name].parked = true
+              log(`中转站：${name} 连续失败 ${tries} 次，已移入 dead/`)
+            } catch (e) {
+              log(`中转站：${name} 移入 dead 失败：${(e && e.message) || String(e)}`)
+            }
+          }
         }
         saveState(stateFile, { ...state, at: Date.now() })
       }

package/lib/cloud/session-backup.js

@@ -12,7 +12,8 @@ const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest('hex')
 function loadState(file) {
   try {
     const j = JSON.parse(fs.readFileSync(file, 'utf8'))
-    return { at: j.at || 0, sessions: j.sessions || {}, attachments: j.attachments || {} }
+    // 保留未知字段（lastRun 等），否则总结里的归档/活跃计数会被丢掉
+    return { ...j, at: j.at || 0, sessions: j.sessions || {}, attachments: j.attachments || {} }
   } catch {
     return { at: 0, sessions: {}, attachments: {} }
   }
@@ -25,8 +26,22 @@ function saveState(file, state) {
   } catch { /* ignore */ }
 }
 
+/**
+ * 已归档会话 id：DSH 存在 <DSH_HOME>/storages/workspace.json 的 global.archivedSessionIds。
+ * 读不到就当没有归档（不让备份因为读不到清单而停摆）。
+ */
+export function readArchivedIds(dshHome) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(dshHome, 'storages', 'workspace.json'), 'utf8'))
+    const ids = (j && j.global && j.global.archivedSessionIds) || []
+    return new Set(ids.filter((x) => typeof x === 'string' && x))
+  } catch {
+    return new Set()
+  }
+}
+
 /** 列出 <sessionsRoot>/<workspaceKey>/<sessionId>/session.v4.jsonl.zstd */
-export function listTranscripts(sessionsRoot) {
+export function listTranscripts(sessionsRoot, archivedSet) {
   const out = []
   let wsKeys = []
   try { wsKeys = fs.readdirSync(sessionsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) } catch { return out }
@@ -43,7 +58,7 @@ export function listTranscripts(sessionsRoot) {
       const full = path.join(dir, file)
       let st = null
       try { st = fs.statSync(full) } catch { continue }
-      out.push({ sessionId: id, workspaceKey: ws, dir, file: full, size: st.size, mtimeMs: st.mtimeMs })
+      out.push({ sessionId: id, workspaceKey: ws, dir, file: full, size: st.size, mtimeMs: st.mtimeMs, archived: Boolean(archivedSet && archivedSet.has(id)) })
     }
   }
   return out
@@ -76,19 +91,38 @@ function pickName(names, sessionId) {
  * @param {Function} [opts.log]
  * @param {number} [opts.maxSessions] 单轮最多处理多少个会话
  * @param {object} [opts.names] sessionId → { name, cwd }
+ * @param {string} [opts.dshHome] 用来读 storages/workspace.json 里的已归档会话清单
  */
-export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateFile, log = () => {}, maxSessions = 40, names = {} }) {
+export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateFile, log = () => {}, maxSessions = 40, names = {}, dshHome = '' }) {
   const state = loadState(stateFile)
   const remoteRoot = layout.paths.sessionDir
-  const all = listTranscripts(sessionsRoot)
-  const result = { ok: true, total: all.length, uploaded: 0, skipped: 0, bytes: 0, sessions: [], error: '' }
+  const archivedSet = dshHome ? readArchivedIds(dshHome) : new Set()
+  const all = listTranscripts(sessionsRoot, archivedSet)
+  const archivedAll = all.filter((x) => x.archived)
+  const activeAll = all.filter((x) => !x.archived)
+  const result = {
+    ok: true, total: all.length, uploaded: 0, skipped: 0, bytes: 0, sessions: [], error: '',
+    archived: { total: archivedAll.length, uploaded: 0, skipped: 0, done: archivedAll.filter((x) => state.sessions[x.sessionId] && state.sessions[x.sessionId].archived).length },
+    active: { total: activeAll.length, uploaded: 0, skipped: 0 },
+  }
   fs.mkdirSync(tmpDir, { recursive: true })
   let handled = 0
 
   for (const item of all) {
     if (handled >= maxSessions) break
     const prev = state.sessions[item.sessionId] || { bytes: 0, parts: 0 }
-    if (prev.bytes === item.size) { result.skipped += 1; continue }
+    // 已归档：备份过就不再备份（归档会话不会再写，重复上传纯属浪费云盘空间）
+    if (item.archived && prev.archived && prev.bytes === item.size) {
+      result.skipped += 1
+      result.archived.skipped += 1
+      continue
+    }
+    if (prev.bytes === item.size) {
+      result.skipped += 1
+      if (item.archived) result.archived.skipped += 1
+      else result.active.skipped += 1
+      continue
+    }
     handled += 1
     try {
       const remoteDir = `${remoteRoot}/${item.sessionId}`
@@ -121,10 +155,15 @@ export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateF
         note: 'bytes = 已备份到的字节位置；下次只传 bytes 之后的新内容',
       }
       await pan.putBuffer(Buffer.from(JSON.stringify(marker, null, 2), 'utf8'), `${remoteDir}/_session.json`)
-      state.sessions[item.sessionId] = { bytes: item.size, parts: chunks.length, chunks, name: marker.name, cwd: marker.cwd, updatedAt: marker.updatedAt, fs_id: up.fs_id }
+      state.sessions[item.sessionId] = {
+        bytes: item.size, parts: chunks.length, chunks, name: marker.name, cwd: marker.cwd,
+        updatedAt: marker.updatedAt, fs_id: up.fs_id, archived: Boolean(item.archived),
+      }
       result.uploaded += 1
       result.bytes += buf.length
-      result.sessions.push({ sessionId: item.sessionId, name: marker.name, bytes: buf.length, from, part: name })
+      if (item.archived) result.archived.uploaded += 1
+      else result.active.uploaded += 1
+      result.sessions.push({ sessionId: item.sessionId, name: marker.name, bytes: buf.length, from, part: name, archived: Boolean(item.archived) })
       saveState(stateFile, { ...state, at: Date.now() })
     } catch (e) {
       result.ok = false
@@ -133,6 +172,14 @@ export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateF
       break
     }
   }
+  const archivedDone = archivedAll.filter((x) => state.sessions[x.sessionId] && state.sessions[x.sessionId].archived).length
+  state.lastRun = {
+    at: Date.now(),
+    archivedTotal: archivedAll.length,
+    activeTotal: activeAll.length,
+    archivedDone,
+    activeDone: Math.max(0, Object.keys(state.sessions).length - archivedDone),
+  }
   saveState(stateFile, { ...state, at: Date.now() })
   return result
 }
@@ -186,12 +233,20 @@ export async function backupAttachments({ pan, layout, objectsRoot, stateFile, l
 export function backupSummary(stateFile) {
   const state = loadState(stateFile)
   const sessions = Object.values(state.sessions)
+  const run = state.lastRun || {}
+  const archivedBackedUp = Number(run.archivedDone || 0)
+  const activeBackedUp = Number(run.activeDone || 0)
   return {
     at: state.at || 0,
     lastAt: state.at || 0,
     sessions: sessions.length,
     files: sessions.length,
     lastCount: sessions.length,
+    archived: Number(run.archivedTotal || 0),
+    active: Number(run.activeTotal || 0),
+    archivedBackedUp,
+    activeBackedUp,
+    archivedUntouched: sessions.filter((s) => s.archived).length,
     bytes: sessions.reduce((a, s) => a + Number(s.bytes || 0), 0),
     attachments: Object.keys(state.attachments).length,
     attachmentBytes: Object.values(state.attachments).reduce((a, s) => a + Number(s.size || 0), 0),

package/lib/index.js

@@ -830,17 +830,33 @@ class CrossTerm {
 
   /** 中转站投递：把云端收件箱里的一封信投进本机对应会话（按收件人会话名） */
   async relayDeliver({ to, envelope = {}, files = [] }) {
-    let targets = (Array.isArray(to) ? to : String(to || '').split(/[,，;；\s]+/))
+    const rawTargets = (Array.isArray(to) ? to : String(to || '').split(/[,，;；\s]+/))
       .map((s) => String(s || '').trim())
       .filter(Boolean)
+    // 0.8.2 F14：收件人可能是会话名、短号、session-<uuid>，也可能是「设备名」（别的设备只写设备不写会话）。
+    // 能解析的照常投；一个都解析不出来就退回「最近活跃会话」，别让信在 inbox 里每 20 秒重试到天荒地老。
+    const resolvable = (raw) => {
+      // 必须真的在本机会话表里 —— resolveSessionId 找不到时会「原样返回」，只看返回值会把设备名当会话
+      const list = this.sessions()
+      const hit = list.find((s) => s.id === raw)
+      if (hit) return true
+      const byName = this.resolveByName(raw)
+      return Boolean(byName && list.some((s) => s.id === byName))
+    }
+    const unknown = rawTargets.filter((t) => !resolvable(t))
+    let targets = rawTargets.filter(resolvable)
     let fallbackNote = ''
     if (!targets.length) {
-      // 信封里没写收件人（例如别的设备直接 term_send 到本机、没指会话）→ 投给最近活跃会话
       const list = this.sessions()
       const latest = list.find((s) => s && s.active) || list[0]
-      if (!latest) return { ok: false, reason: '信封里没有收件人，本机也没有可投递的会话' }
+      if (!latest) return { ok: false, reason: `收件人「${rawTargets.join('、') || '空'}」在本机找不到会话，本机也没有可投递的会话` }
       targets = [latest.name || latest.short]
-      fallbackNote = `（信封没写收件人，按「最近活跃会话」投给「${targets[0]}」）`
+      const what = rawTargets.length ? `收件人「${rawTargets.join('、')}」不是本机会话名` : '信封没写收件人'
+      const selfNames = [this.nodeId, this.name, os.hostname()].map((v) => String(v || '').trim().toLowerCase())
+      const deviceHint = rawTargets.some((t) => selfNames.includes(String(t).trim().toLowerCase())) ? '（写的是本机设备名）' : ''
+      fallbackNote = `（${what}${deviceHint}，按「最近活跃会话」投给「${targets[0]}」）`
+    } else if (unknown.length) {
+      fallbackNote = `（收件人「${unknown.join('、')}」没匹配到会话，已投给能匹配的 ${targets.length} 个）`
     }
     const controller = this.sessionController()
     if (!controller || typeof controller.prompt !== 'function') {

package/lib/web.js

@@ -62,7 +62,19 @@ function ensureHttpToken(cfg, log = () => {}) {
 }
 
 /** 跨站 Origin 一律拒；令牌对得上才放行（同源页面可先 GET /crossterm/api/token 取令牌） */
+const LOOPBACK_HOST = /^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/i
+
+/** A6：Host 必须是本机回环地址，挡住 DNS rebinding（rebound 页面的 Host 会是攻击者域名） */
+function isLoopbackHost(host) {
+  return LOOPBACK_HOST.test(String(host || '').trim())
+}
+
 function checkHttp(req, res, cfg) {
+  if (!isLoopbackHost(req.headers && req.headers.host)) {
+    // 0.8.2 A6：只接受本机 Host
+    json(res, 403, { ok: false, error: '只接受本机访问（Host 必须是 127.0.0.1 / localhost）' })
+    return false
+  }
   const origin = String((req.headers && req.headers.origin) || '')
   if (origin && !LOOPBACK_ORIGIN.test(origin)) {
     json(res, 403, { ok: false, message: '拒绝跨站请求' })
@@ -510,8 +522,9 @@ export function registerWeb(ctx, term, log) {
             path: '/crossterm/api/token',
             handler: (req, res) => {
               const origin = String((req.headers && req.headers.origin) || '')
-              if (origin && !LOOPBACK_ORIGIN.test(origin)) {
-                json(res, 403, { ok: false, message: '拒绝跨站请求' })
+              // 0.8.2 A6：同源 GET 不带 Origin，DNS rebinding 时 Host 会是攻击者域名 —— 必须挡 Host
+              if (!isLoopbackHost(req.headers && req.headers.host) || (origin && !LOOPBACK_ORIGIN.test(origin))) {
+                json(res, 403, { ok: false, message: '只接受本机同源请求' })
                 return
               }
               json(res, 200, { ok: true, token: ensureHttpToken(term.cfg, log) })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crossterm",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "跨端互通：同一 DSH 账号下的会话、终端、设备之间互通 —— 特征码链、内联邮件、云端中转站与自动备份",
   "type": "module",
   "main": "./lib/index.js",