qq-bot-roost 0.9.7 → 0.9.9

package/src/tarball.js

@@ -34,18 +34,32 @@ export function parseTar(buf) {
   let off = 0;
 
   while (off + 512 <= buf.length) {
+    /** 本轮起点：用来判断「有没有真的往前走」，见下面的 next 检查 */
+    const start = off;
     const header = buf.subarray(off, off + 512);
     // 全零块 = 结束
     if (header.every((b) => b === 0)) break;
 
-    const readStr = (start, len) => {
-      const slice = header.subarray(start, start + len);
+    /**
+     * 参数叫 `pos` 而不是 `start`：外层那个 `start` 是「本轮在 buf 里的起点」，
+     * 两者含义完全不同，同名遮蔽会让人以为能互相引用。
+     */
+    const readStr = (pos, len) => {
+      const slice = header.subarray(pos, pos + len);
       const end = slice.indexOf(0);
       return slice.subarray(0, end === -1 ? len : end).toString('utf8');
     };
 
     const name = readStr(0, 100);
-    const size = parseInt(readStr(124, 12).trim(), 8) || 0;
+    /**
+     * size 必须夹到非负。
+     *
+     * 八进制字段里出现 `-` 时 `parseInt` 会给出负数，后面
+     * `Math.ceil(size / 512) * 512` 就是负的，游标「前进 512 又倒退 512」
+     * 原地打转——而这个循环每轮都 push 一条条目，于是**内存直接爆掉**。
+     * 一个几十字节的畸形 tar 就能把机器人打死（2026-10-31 用 fuzz 撞出来的）。
+     */
+    const size = Math.max(0, parseInt(readStr(124, 12).trim(), 8) || 0);
     const type = String.fromCharCode(header[156]) || '0';
     // ustar 前缀，长路径会用它
     const prefix = readStr(345, 155);
@@ -53,7 +67,21 @@ export function parseTar(buf) {
 
     off += 512;
     const content = buf.subarray(off, off + size);
-    off += Math.ceil(size / 512) * 512;
+    /**
+     * 游标必须严格前进。即使 size 已经夹到非负，这里再兜一道：
+     * 畸形头导致的任何「原地踏步」都会变成死循环 + 内存爆炸，
+     * 而正常的 tar 每轮至少前进 512 字节，不可能触发。
+     */
+    const next = off + Math.ceil(size / 512) * 512;
+    /**
+     * 和**本轮起点**比，不是和 `off` 比。
+     *
+     * `size = 0`（目录条目）时 `next` 正好等于 `off`，拿 `off` 比会把
+     * 正常的空条目误判成「没前进」而提前结束——第一版就是这么写的，
+     * 结果一个含目录的正常 tar 只解析出第一条。
+     */
+    if (next <= start) break;
+    off = next;
 
     if (type === '5') entries.push({ name: fullName, dir: true });
     else if (type === '0' || type === '\0') entries.push({ name: fullName, dir: false, content });

package/src/trace.js

@@ -0,0 +1,28 @@
+/**
+ * 链路追踪 id
+ * ===========
+ *
+ * 一条消息要穿过四段：QQ 事件 → Roost 内核 → ai-chat 插件 → dsh-roost → 模型。
+ * 出问题时现在只能翻四个日志文件对时间戳——用户说「刚才那条没回」，
+ * 根本不知道该看哪一段。
+ *
+ * 这里生成一个短 id，进站时打上，每段日志都带着它，面板也能按它串起来。
+ *
+ * 为什么不是 UUID：要能在日志里一眼扫到、能手打、能贴进群里问。
+ * 时间前缀（36 进制）让同一秒内的 id 也有序，后面 6 位十六进制够区分。
+ * 碰撞概率：同一毫秒内 1/1677 万，对一个群聊机器人足够。
+ */
+import crypto from 'node:crypto';
+
+/**
+ * @returns {string} 形如 `m3k9x2a1f3c4`
+ */
+export function newTraceId() {
+  return `${Date.now().toString(36)}${crypto.randomBytes(3).toString('hex')}`;
+}
+
+/** 日志前缀：统一成 `[trace:xxxx]`，方便 grep */
+export function traceTag(id) {
+  const t = String(id ?? '').trim();
+  return t ? `[trace:${t}]` : '';
+}

package/src/trust.js

@@ -0,0 +1,264 @@
+/**
+ * 供应链信任：签名与验签
+ * ======================
+ *
+ * 为什么需要它：`index.json` 里的 `sha256` 和索引本身同仓同源，能改索引的人
+ * 顺手就能把哈希一起改了，校验照过。哈希只证明「内容和这份清单一致」，
+ * 不证明「这份清单是作者发的」——后者需要**独立于业务仓的密钥**。
+ *
+ * 所以这里只做一件事：**用一把离线私钥给清单签名，用内置公钥验签**。
+ * 哈希仍然保留（它挡的是传输篡改和内容漂移），两者职责不同。
+ *
+ * 设计取舍：
+ *   · 签的是**规范化后的 JSON**，不是原始字节。镜像站可能重新序列化
+ *     （缩进、键序、末尾换行），签字节会被这些无关差异搞挂。
+ *   · 规范化规则必须稳定且可复现：键排序、无空白、数组保序。
+ *   · 信封格式 `{alg, keyId, sig}`，也接受裸 base64，方便手工签。
+ *   · **没有公钥 = unavailable，不是通过也不是拒绝**。调用方必须显式决定
+ *     怎么处理，不能让「没配公钥」悄悄变成放行。
+ */
+
+import crypto from 'node:crypto';
+
+/** 发版时填进来的内置公钥（PEM 或 32 字节 base64）。留空 = 本版不启用验签。 */
+export const EMBEDDED_PUBKEY = 'bqmZDZi/gnW7FppqKCOa5Zvc1XUvT/vw7fiiHR2hcIo=';
+
+/**
+ * 内置强制开关。
+ *
+ * **发版时把它改成 `true`，所有没显式配置的用户就默认开启强制验签**——
+ * 这就是「后续一个更新就能马上打开」的那个开关。
+ *
+ * 为什么不在这次直接开：签名文件还没铺到索引里，现在开会让所有安装失败。
+ * 顺序必须是「先发签名 → 再开开关」。
+ *
+ * 优先级（见 `resolveTrust`）：
+ *   配置 `security.trust.enforce` > 环境变量 `ROOST_TRUST_ENFORCE` > 本常量
+ */
+export const EMBEDDED_ENFORCE = false;
+
+/**
+ * **发版时保持 false。** 签名链路是 beta：
+ *   · `index.json.sig` 还没跟着一次正式发版走完流程
+ *   · 现在打开会让没签名的插件装不上
+ * 等发版验证过一轮，再决定是否默认开启（或继续让用户自己在面板里开）。
+ */
+
+/**
+ * 规范化：键排序 + 无空白 + 数组保序。
+ *
+ * 不能直接用 `JSON.stringify(data)`——它按插入顺序输出键，
+ * 同一个对象经过一次 parse/stringify 往返就可能换序。
+ *
+ * @param {unknown} v
+ * @returns {string}
+ */
+export function canonicalize(v) {
+  if (v === undefined) throw new Error('canonicalize 不接受 undefined');
+  if (v === null || typeof v !== 'object') return JSON.stringify(v);
+  if (Array.isArray(v)) return `[${v.map((x) => canonicalize(x)).join(',')}]`;
+  const keys = Object.keys(v).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(v[k])}`).join(',')}}`;
+}
+
+/**
+ * 文本规范化：CRLF → LF，去掉末尾空白。
+ *
+ * 为什么需要：`SHA256SUMS` 这类纯文本文件会被 git 的 `eol` 属性和编辑器改写
+ * 换行符。签原始字节的话，Windows 检出一次签名就失效了。
+ *
+ * 注意：JSON 不走这里，走 `canonicalize`。
+ *
+ * @param {string} s
+ */
+export function normalizeText(s) {
+  return String(s ?? '').replace(/\r\n/g, '\n').replace(/\s+$/, '');
+}
+
+/**
+ * 把 PEM / 裸 base64 / JWK 统一成 KeyObject。
+ *
+ * @param {string} text
+ * @returns {import('node:crypto').KeyObject|null}
+ */
+export function publicKeyFrom(text) {
+  const t = String(text ?? '').trim();
+  if (!t) return null;
+  try {
+    if (t.includes('BEGIN PUBLIC KEY')) return crypto.createPublicKey(t);
+    const raw = Buffer.from(t, 'base64');
+    if (raw.length !== 32) return null;
+    return crypto.createPublicKey({
+      key: { kty: 'OKP', crv: 'Ed25519', x: raw.toString('base64url') },
+      format: 'jwk',
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 签名。Ed25519 的算法参数是 `null`（不是 'sha256'）。
+ *
+ * @param {string} text 已规范化的内容
+ * @param {string} privateKeyPem
+ * @returns {string} base64 签名
+ */
+export function signText(text, privateKeyPem) {
+  const key = crypto.createPrivateKey(privateKeyPem);
+  return crypto.sign(null, Buffer.from(text, 'utf8'), key).toString('base64');
+}
+
+/**
+ * 验签。任何异常都返回 false —— 验签失败的原因不该抛给上层，
+ * 上层只需要「过 / 不过」和一句能看懂的话。
+ *
+ * @param {string} text
+ * @param {string} sigB64
+ * @param {string} publicKeyPem
+ * @returns {boolean}
+ */
+export function verifyText(text, sigB64, publicKeyPem) {
+  try {
+    const key = typeof publicKeyPem === 'string' ? publicKeyFrom(publicKeyPem) : publicKeyPem;
+    if (!key) return false;
+    return crypto.verify(null, Buffer.from(text, 'utf8'), key, Buffer.from(String(sigB64), 'base64'));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 解析签名信封。接受 `{alg,keyId,sig}` 或裸 base64。
+ *
+ * @param {string} raw
+ * @returns {{alg:string, keyId:string, sig:string}|null}
+ */
+export function parseSig(raw) {
+  const t = String(raw ?? '').trim();
+  if (!t) return null;
+  if (t.startsWith('{')) {
+    try {
+      const o = JSON.parse(t);
+      if (!o || typeof o.sig !== 'string' || !o.sig) return null;
+      return { alg: String(o.alg ?? ''), keyId: String(o.keyId ?? ''), sig: o.sig };
+    } catch {
+      return null;
+    }
+  }
+  return { alg: 'ed25519', keyId: '', sig: t };
+}
+
+/**
+ * 从配置解析信任策略。
+ *
+ * `security.trust = { pubkey, enforce, allowUnsigned: [] }`
+ * 也接受直接传 trust 对象（测试用）。
+ *
+ * @param {object} cfg
+ */
+export function resolveTrust(cfg = {}) {
+  const t = cfg?.security?.trust ?? cfg ?? {};
+
+  /**
+   * 优先级：配置（面板开关）> 环境变量 > 内置常量。
+   *
+   * **配置必须最后生效**：面板上的开关是用户能看见的唯一入口，
+   * 如果环境变量能压过它，就会出现「我明明关了它还拦」这种查不出来的怪事。
+   * 环境变量只作为没写配置时的兜底（排查、临时灰度）。
+   */
+  let enforce = EMBEDDED_ENFORCE;
+  const env = String(process.env.ROOST_TRUST_ENFORCE ?? '').trim().toLowerCase();
+  if (env === '1' || env === 'true') enforce = true;
+  else if (env === '0' || env === 'false') enforce = false;
+  if (t.enforce !== undefined) enforce = t.enforce === true;
+
+  return {
+    pubkey: String(t.pubkey ?? '') || EMBEDDED_PUBKEY,
+    enforce,
+    allowUnsigned: Array.isArray(t.allowUnsigned) ? t.allowUnsigned.map(String) : [],
+    /** 额外声明为「官方源」的地址（自建代理 / 镜像用），默认只认 market.js 里的官方地址 */
+    officialUrls: Array.isArray(t.officialUrls) ? t.officialUrls.map(String) : [],
+  };
+}
+
+/**
+ * 公钥能不能用。
+ *
+ * 面板要拿它区分「没配」和「配错了」——这两种都让开关不起作用，
+ * 但用户的修法完全不同：一个是去配，一个是去改。
+ *
+ * @param {string} pubkey
+ */
+export function pubkeyUsable(pubkey) {
+  return Boolean(publicKeyFrom(pubkey));
+}
+
+/**
+ * 校验一份清单。
+ *
+ * 返回的 `status` 有五种，调用方必须显式处理每一种：
+ *   ok          签名有效
+ *   unsigned    有公钥、没签名文件
+ *   bad         签名存在但不匹配（内容被改过 / 用错密钥）
+ *   invalid     配了公钥但解析不了（**不是「没配」**，强制时必须拦）
+ *   unavailable 没配公钥，本版无法验签
+ *
+ * @param {{data:unknown, sigText?:string, trust:object, kind?:string}} o
+ */
+export function checkTrust({ data, sigText, trust, kind = '清单' }) {
+  if (!trust?.pubkey) return { status: 'unavailable', why: `没有配置信任公钥，${kind}未验签` };
+  /**
+   * 配了但解析不了 → `invalid`，不能并进 `unavailable`。
+   *
+   * 并进去的后果很严重：用户把公钥粘错一个字符、打开强制开关，然后
+   * **一切照常放行**——他以为受保护了，实际什么都没验。这类「安全开关
+   * 看起来开着、其实没生效」比没有开关更危险，所以必须单独一个状态。
+   */
+  if (!publicKeyFrom(trust.pubkey)) {
+    return { status: 'invalid', why: '信任公钥无法解析（应为 PEM 或 32 字节 base64）' };
+  }
+
+  const env = parseSig(sigText);
+  if (!env) return { status: 'unsigned', why: `${kind}没有签名文件` };
+  if (env.alg && env.alg !== 'ed25519') return { status: 'bad', why: `不支持的签名算法：${env.alg}` };
+
+  const ok = verifyText(canonicalize(data), env.sig, trust.pubkey);
+  if (!ok) return { status: 'bad', why: `${kind}的签名与内容不匹配` };
+  return { status: 'ok', keyId: env.keyId };
+}
+
+/**
+ * 该不该拦。
+ *
+ * 返回 `null` = 放行；返回字符串 = 拦截理由。
+ *
+ * **只对官方源强制**。理由：手写插件不走市场索引（`loader.js` 只扫 `plugins/`
+ * 目录，完全不碰验签），所以「用户自己写插件」这条路从来不受影响；
+ * 而用户自己填的 `plugins.marketUrl` 属于他自己的信任决定——他信那个仓库，
+ * 我们没资格替他拦。签名要防的是「官方渠道被悄悄换掉」，不是「用户自己的源」。
+ *
+ * `unavailable` **永远放行**：没配公钥就拦，等于让所有没升级配置的用户
+ * 一次性断掉，那不是安全，是事故。
+ *
+ * @param {object} trust
+ * @param {string} status
+ * @param {string} [id]
+ * @param {{official?: boolean}} [opts]
+ * @returns {string|null}
+ */
+export function blockReason(trust, status, id = '', opts = {}) {
+  if (!trust?.enforce) return null;
+  if (opts.official === false) return null;
+  if (status === 'ok' || status === 'unavailable') return null;
+  /**
+   * 配错公钥必须拦：否则「开关开着、实际没验」，用户以为受保护了。
+   * 这条不能算进 `unavailable`——那个是「没配」，放行是有意的。
+   */
+  if (status === 'invalid') {
+    return '信任公钥无法解析，强制校验无法生效（检查 security.trust.pubkey，或等内置公钥的版本）';
+  }
+  if (status === 'unsigned' && trust.allowUnsigned.includes(String(id))) return null;
+  if (status === 'bad') return '签名校验失败：内容与签名不一致（可能被篡改，或用错了密钥）';
+  return `没有签名，且不在 allowUnsigned 白名单里（${id || '该项'}）`;
+}

package/src/updater.js

@@ -23,6 +23,8 @@ import { fetchGiteeTree, detectGiteeRef, giteeRawUrl } from './gitee.js';
 import { hashDir } from './hashdir.js';
 import { CODE_ENTRIES, PROTECTED_ENTRIES as PROTECTED } from './update-scope.js';
 import { ROOT } from './config.js';
+import { loadGlobalConfig } from './config.js';
+import { checkTrust, resolveTrust, normalizeText, blockReason } from './trust.js';
 
 const log = createLogger('update');
 
@@ -108,9 +110,9 @@ async function updatedButNotRestarted() {
  * 两个源都试：GitHub raw（经下载源改写）和 Gitee raw。任何一边拿到都行，
  * 因为指纹是「代码内容」的，与从哪个源下载无关。
  *
- * @returns {Promise<Map<string,string>>} 版本号 → 64 位十六进制
+ * @returns {Promise<{map: Map<string,string>, trust: object}>} 版本号 → 64 位十六进制，以及验签结论
  */
-async function fetchSumsMap() {
+async function fetchSums() {
   const urls = [
     `https://raw.githubusercontent.com/${REPO}/master/SHA256SUMS`,
     `https://gitee.com/${REPO}/raw/master/SHA256SUMS`,
@@ -128,12 +130,40 @@ async function fetchSumsMap() {
         const m = /^([a-f0-9]{64})\s+v?([0-9][\w.+-]*)$/i.exec(line.trim());
         if (m) map.set(m[2].replace(/^v/i, ''), m[1].toLowerCase());
       }
-      if (map.size) return map;
+      if (!map.size) continue;
+
+      /**
+       * 验签。指纹和代码同仓，只验指纹等于「让被篡改的清单自己证明自己」——
+       * 必须由独立密钥签过的 `SHA256SUMS.sig` 背书。
+       *
+       * 本版只记录结论、不阻断（`enforce` 还没接进来）；`bad` 要打 error，
+       * 因为它意味着「清单内容和签名对不上」，比「没签名」严重得多。
+       */
+      let sigText = '';
+      try {
+        const sres = await fetchViaMirror(`${u}.sig`, {
+          headers: { 'User-Agent': 'qq-bot-roost-updater' },
+          signal: AbortSignal.timeout(8000),
+        });
+        if (sres.ok) sigText = await sres.text();
+      } catch {
+        // 拿不到签名文件不是网络错误，继续按「未签名」处理
+      }
+      const trust = checkTrust({
+        data: normalizeText(text),
+        sigText,
+        trust: resolveTrust({}),
+        kind: 'SHA256SUMS',
+      });
+      if (trust.status === 'bad' || trust.status === 'invalid') log.error(trust.why);
+      else if (trust.status === 'ok') log.info('SHA256SUMS 签名校验通过');
+
+      return { map, trust };
     } catch {
       // 换下一个源
     }
   }
-  return new Map();
+  return { map: new Map(), trust: { status: 'unavailable', why: '没有拿到 SHA256SUMS' } };
 }
 
 /**
@@ -142,10 +172,10 @@ async function fetchSumsMap() {
  */
 async function fetchTreeSha256(version) {
   try {
-    const map = await fetchSumsMap();
-    return map.get(String(version).replace(/^v/, '')) ?? null;
+    const { map, trust } = await fetchSums();
+    return { sha: map.get(String(version).replace(/^v/, '')) ?? null, trust };
   } catch {
-    return null;
+    return { sha: null, trust: { status: 'unavailable', why: '查询指纹失败' } };
   }
 }
 
@@ -153,7 +183,11 @@ export async function checkUpdate() {
   const needsRestart = await updatedButNotRestarted();
   const r = await checkUpdateCore();
   // 有新版本才值得多跑一次网络请求
-  if (r?.ok && r.hasUpdate) r.treeSha256 = await fetchTreeSha256(r.latest);
+  if (r?.ok && r.hasUpdate) {
+    const info = await fetchTreeSha256(r.latest);
+    r.treeSha256 = info.sha;
+    r.sumsTrust = info.trust;
+  }
   return { ...r, needsRestart };
 }
 
@@ -477,6 +511,22 @@ async function applyUpdateOnce(info) {
   if (!rel.hasUpdate) throw new Error(`已经是最新版本 ${cur}`);
   if (!rel.tarball) throw new Error('没有可下载的包');
 
+  /**
+   * 签名闸门：和插件市场共用面板上那个开关。
+   *
+   * 为什么放在下载之前：被拒的时候用户什么都没损失，不用先下一份再删。
+   * `rel.sumsTrust` 是 `checkUpdate()` 拉 `SHA256SUMS` 时顺手算出来的，
+   * 没拿到就当 `unavailable`（没配公钥 / 网络问题），按「不拦」处理。
+   */
+  const trustCfg = resolveTrust(await loadGlobalConfig().catch(() => ({})));
+  const trustWhy = blockReason(trustCfg, rel.sumsTrust?.status || 'unavailable', '', { official: true });
+  if (trustWhy) {
+    throw new Error(
+      `自更新被拒绝：${trustWhy}\n` +
+        '你的代码没有任何改动。可以到 GitHub Releases 手动下载安装，或先在设置里关掉「插件来源校验」。',
+    );
+  }
+
   const stamp = new Date().toISOString().replace(/[:.]/g, '-');
   const workDir = path.join(ROOT, 'data', `.update-${stamp}`);
   const backupDir = path.join(ROOT, 'data', 'backups', `${cur}-${stamp}`);

package/src/web/server.js

@@ -16,6 +16,7 @@ import {
   mergeWithInstalled,
   detectUpdates,
   compareVersion,
+  isOfficialSource,
 } from '../plugin/market.js';
 import {
   checkUpdate as checkFrameworkUpdate,
@@ -32,6 +33,7 @@ import { onMessage as onBusMessage } from '../message-bus.js';
 import { handleQqCall, capabilityPayload } from './qq-call.js';
 import { runDoctor, summarize } from '../doctor.js';
 import { createBindTask, pollBindResult } from '../qq/qrlogin.js';
+import { resolveTrust, blockReason, pubkeyUsable } from '../trust.js';
 import { toSvg as qrToSvg } from '../qq/qrsvg.js';
 import {
   PRESETS,
@@ -851,7 +853,7 @@ export async function startWebServer({
 
     const out = { at: Date.now(), updates: [], error: '' };
     try {
-      const idx = await fetchIndex(globalCfg.plugins?.marketUrl || undefined);
+      const idx = await fetchIndex(globalCfg.plugins?.marketUrl || undefined, { trust: resolveTrust(globalCfg) });
       const localVers = await r.plugins.localVersions();
       out.updates = detectUpdates(idx.plugins, localVers).map((u) => ({
         id: u.id,
@@ -1336,6 +1338,7 @@ export async function startWebServer({
 
         // 配置读取（隐藏密钥）
         if (pathname === '/api/config' && req.method === 'GET') {
+          const trust = resolveTrust(globalCfg);
           return json(res, 200, {
             ...cfg,
             // webui 和 logLevel 是**全局**设置（config/bot.json），所有机器人共用，
@@ -1348,6 +1351,19 @@ export async function startWebServer({
               accessKeySet: Boolean(globalCfg.webui?.accessKey),
             },
             logLevel: globalCfg.logLevel ?? 'info',
+            /**
+             * 插件来源校验（全局设置）。只回「开没开」和「有没有公钥」——
+             * 公钥本身是公开的，但配置里可能是整段 PEM，回显没意义还占地方。
+             * `pubkeySet: false` 时面板要提示「开关不起作用」。
+             */
+            security: {
+              trust: {
+                enforce: trust.enforce,
+                pubkeySet: Boolean(trust.pubkey),
+                // 「配了但解析不了」和「没配」要分开：前者开开关等于没开
+                pubkeyValid: pubkeyUsable(trust.pubkey),
+              },
+            },
             appSecret: cfg.appSecret ? '********' : '',
             appSecretSet: Boolean(cfg.appSecret),
           });
@@ -1409,6 +1425,21 @@ export async function startWebServer({
             await saveGlobalConfig?.(globalCfg).catch(() => {});
             configureMirror(globalCfg);
           }
+          /**
+           * 插件来源校验开关（全局，默认关）。
+           *
+           * 只接受布尔值：面板传字符串 "false" 时如果按真值判断，会把「关」
+           * 读成「开」——这类错误在安全开关上代价最大，所以这里严格比类型。
+           *
+           * 立即生效，不需要重启：`resolveTrust` 每次调用都现读 `globalCfg`。
+           */
+          if (body.security?.trust && typeof body.security.trust.enforce === 'boolean') {
+            globalCfg.security = {
+              ...(globalCfg.security ?? {}),
+              trust: { ...(globalCfg.security?.trust ?? {}), enforce: body.security.trust.enforce },
+            };
+            await saveGlobalConfig?.(globalCfg).catch(() => {});
+          }
           if (body.whitelist && typeof body.whitelist === 'object') {
             cfg.whitelist = {
               enabled: Boolean(body.whitelist.enabled),
@@ -1948,7 +1979,7 @@ export async function startWebServer({
         if (pathname === '/api/market' && req.method === 'GET') {
           const url2 = url.searchParams.get('source') || globalCfg.plugins?.marketUrl || undefined;
           try {
-            const idx = await fetchIndex(url2);
+            const idx = await fetchIndex(url2, { trust: resolveTrust(globalCfg) });
             const installedIds = new Set(plugins.loaded.keys());
             // 目录里存在但没加载成功的也算「已装」
             try {
@@ -1970,6 +2001,8 @@ export async function startWebServer({
                 latest: u.latest,
               })),
               localVersions: localVers,
+              // 索引签名状态：ok / unsigned / bad / unavailable（面板可据此提示）
+              trust: idx?._trust?.status || 'unavailable',
               // 网络挂了用的是本地缓存，面板要提示用户「这是旧数据」
               stale: idx.stale === true,
               staleAge: idx.staleAge || '',
@@ -1986,10 +2019,19 @@ export async function startWebServer({
           if (!id) return json(res, 400, { error: '缺少插件 id' });
           try {
             const src = globalCfg.plugins?.marketUrl || undefined;
-            const idx = await fetchIndex(src);
+            const idx = await fetchIndex(src, { trust: resolveTrust(globalCfg) });
             const entry = idx.plugins.find((p) => p.id === id);
             if (!entry) return json(res, 404, { error: `市场里没有 ${id}` });
 
+            /**
+             * 信任闸。**只对官方源生效**：手写插件走 `plugins/` 目录，根本不经过
+             * 市场索引；用户自己填的市场源是他自己的信任决定，不拦。
+             * 本版 `enforce` 默认 false，所以这里恒放行。
+             */
+            const official = isOfficialSource(src, globalCfg);
+            const trustWhy = blockReason(resolveTrust(globalCfg), idx?._trust?.status || 'unavailable', id, { official });
+            if (trustWhy) return json(res, 403, { error: trustWhy });
+
             /**
              * 下载 + 解包期间要挂起插件热重载。
              *
@@ -2614,10 +2656,19 @@ export async function startWebServer({
           let repo = null;
           try {
             const src = globalCfg.plugins?.marketUrl || undefined;
-            const idx = await fetchIndex(src);
+            const idx = await fetchIndex(src, { trust: resolveTrust(globalCfg) });
             const entry = idx.plugins.find((p) => p.id === id);
             if (!entry) return json(res, 404, { error: `市场里没有 ${id}` });
 
+            /**
+             * 信任闸。**只对官方源生效**：手写插件走 `plugins/` 目录，根本不经过
+             * 市场索引；用户自己填的市场源是他自己的信任决定，不拦。
+             * 本版 `enforce` 默认 false，所以这里恒放行。
+             */
+            const official = isOfficialSource(src, globalCfg);
+            const trustWhy = blockReason(resolveTrust(globalCfg), idx?._trust?.status || 'unavailable', id, { official });
+            if (trustWhy) return json(res, 403, { error: trustWhy });
+
             const localVers = await plugins.localVersions();
             const cur = localVers[id];
             if (!cur) return json(res, 400, { error: `本地没装 ${id}，先用「安装」` });