@oj-module/cli 0.2.29 → 0.2.42

package/templates/tests/lifecycle/preflight.spec.ts

@@ -49,6 +49,9 @@ interface RuleCase {
 const RULES: RuleCase[] = [
 	{ rule: "name 白名单（大写拒绝）", clause: "C2-01", keyword: "name", mutate: (m) => { m.name = "Demo"; } },
 	{ rule: "name 保留名（market，R9）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "market"; } },
+	{ rule: "name 保留名（oj，REG-CS7）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "oj"; } },
+	{ rule: "name 保留名（ojm，REG-CS7）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "ojm"; } },
+	{ rule: "name 保留名（registry，REG-CS7）", clause: "C2-01", keyword: "保留名", mutate: (m) => { m.name = "registry"; } },
 	{ rule: "version 禁 +（oj 相容排除，附录 B-1）", clause: "C2-02", keyword: "version", mutate: (m) => { m.version = "1.0.0+build.5"; } },
 	{
 		rule: "方案名已被已装方案占用（拒装）",
@@ -103,6 +106,27 @@ describe("preflight 规则表（每规则一拒例 + 一过例）", () => {
 	}
 });
 
+describe("rEG-CS7 保留名（安装期 reserved_name 终止态，红队 F5）", () => {
+	it("name=oj/ojm/registry → 预检拒且 code=reserved_name，解压前即拒（stage 1 早于 download/extract）", async () => {
+		for (const bad of ["oj", "ojm", "registry"]) {
+			const m = structuredClone(VALID);
+			m.name = bad;
+			const r = await preflight(ctx({ manifest: m }));
+			expect(r.ok).toBe(false);
+			expect(r.code).toBe("reserved_name");
+			expect(r.retryable).toBe(false);
+			expect(r.message).toContain("为保留名");
+		}
+	});
+
+	it("真实第一方方案名（oj-registry）安装预检不被误伤", async () => {
+		const m = structuredClone(VALID);
+		m.name = "oj-registry";
+		const r = await preflight(ctx({ manifest: m }));
+		expect(r.code === "reserved_name").toBe(false);
+	});
+});
+
 describe("preflight · C2-09 peerRuntime 范围算子语义", () => {
 	it("过例：^ 同主版本且 ≥（宿主 0.1.80 满足 ^0.1.0）", async () => {
 		const m = structuredClone(VALID);
@@ -181,6 +205,34 @@ describe("preflight · C2-11 peerPlatform 范围算子语义（^ 遵循 0.x 口
 		expect(r.message).toContain("C2-11");
 	});
 
+	// REG-R9 / 红队 F4：升 0.2.0 后声明 ^0.1.x 的存量包全部装不上。笼统回「不满足」会让人
+	// 去改方案版本/代码，真正要改的只有那一行 range——所以文案必须是可执行的迁移指令。
+	it("拒例（F4 升版反噬）：host 0.2.x + ^0.1.x → 给出「改成 >=0.1.0」的专属迁移提示", async () => {
+		const m = structuredClone(VALID);
+		m.peerPlatform = "^0.1.0";
+		const r = await preflight(ctx({ manifest: m, hostApiVersion: "0.2.0" }));
+		expect(r.ok).toBe(false);
+		expect(r.message).toContain("C2-11");
+		expect(r.message).toContain(">=0.1.0");
+		// 要说清「不是本方案的问题」，否则发布方会去翻自己的代码
+		expect(r.message).toContain("不是本方案的问题");
+		expect(r.message).toContain("这一条要改的是声明，不是代码");
+		// 基线带 prerelease 时提示里只出现核心段（别把 -rc.1 拼进建议的 range 里）
+		m.peerPlatform = "^0.1.0-rc.1";
+		const r2 = await preflight(ctx({ manifest: m, hostApiVersion: "0.2.0" }));
+		expect(r2.message).toContain(">=0.1.0");
+		expect(r2.message).not.toContain(">=0.1.0-rc.1");
+	});
+
+	it("拒例（不该给迁移提示）：host 0.1.x + ^0.2.0 是「包要求更高版本」，不是升版反噬", async () => {
+		const m = structuredClone(VALID);
+		m.peerPlatform = "^0.2.0";
+		const r = await preflight(ctx({ manifest: m, hostApiVersion: "0.1.80" }));
+		expect(r.ok).toBe(false);
+		expect(r.message).toContain("需升级宿主平台模块");
+		expect(r.message).not.toContain("改成「>=0.2.0」");
+	});
+
 	it("过例：0.x 口径——^0.2.0 兼容 0.2.5（minor 相同，patch 更高）", async () => {
 		const m = structuredClone(VALID);
 		m.peerPlatform = "^0.2.0";

package/templates/tests/lifecycle/sig-fixtures.spec.ts

@@ -20,8 +20,9 @@ const KEY_ID = /^[a-z][a-z0-9-]*\.[a-z0-9-]+$/;
 const gen = (await import(GEN)) as {
 	FIXTURE_NAME: string
 	FIXTURE_VERSION: string
+	FIXTURE_REGISTRY_ID: string
 	CANON: string
-	canonicalString: (name: string, version: string, sha256: string) => string
+	canonicalString: (registryId: string, name: string, version: string, sha256: string) => string
 	fingerprintOf: (publicKeyHex: string) => string
 	generate: (outDir: string) => { sha256: string, canonical: string, paths: Record<string, string> }
 };
@@ -29,6 +30,7 @@ const gen = (await import(GEN)) as {
 describe("签名链夹具 · templates 面可达性与再生一致性（P2-0）", () => {
 	const name = gen.FIXTURE_NAME;
 	const version = gen.FIXTURE_VERSION;
+	const registryId = gen.FIXTURE_REGISTRY_ID;
 	const tgzPath = path.join(SIG_DIR, `${name}-${version}.tgz`);
 	const tgz = readFileSync(tgzPath);
 	const sha256 = createHash("sha256").update(tgz).digest("hex");
@@ -38,6 +40,7 @@ describe("签名链夹具 · templates 面可达性与再生一致性（P2-0）"
 			const sig = JSON.parse(readFileSync(`${tgzPath}${suffix}`, "utf8")) as Record<string, string>;
 			expect(sig.alg).toBe("Ed25519");
 			expect(sig.canon).toBe(gen.CANON);
+			expect(sig.registry_id).toBe(registryId);
 			expect(sig.public_key).toMatch(HEX64);
 			expect(sig.value).toMatch(STD_B64);
 			expect(sig.value).not.toMatch(/[-_]/);
@@ -46,8 +49,8 @@ describe("签名链夹具 · templates 面可达性与再生一致性（P2-0）"
 	});
 
 	it("规范串与指纹从 templates 面计算与提交产物一致（三同一的夹具侧）", () => {
-		const canonical = gen.canonicalString(name, version, sha256);
-		expect(canonical).toBe(`${name}@${version}:${sha256}`);
+		const canonical = gen.canonicalString(registryId, name, version, sha256);
+		expect(canonical).toBe(`${registryId}:${name}@${version}:${sha256}`);
 		const sig = JSON.parse(readFileSync(`${tgzPath}.sig`, "utf8")) as { public_key: string };
 		expect(gen.fingerprintOf(sig.public_key)).toMatch(HEX64);
 	});
@@ -56,7 +59,7 @@ describe("签名链夹具 · templates 面可达性与再生一致性（P2-0）"
 		const out = path.join(os.tmpdir(), `ojm-sig-fixtures-tpl-${process.pid}`);
 		const r = gen.generate(out);
 		expect(r.sha256).toBe(sha256);
-		expect(r.canonical).toBe(`${name}@${version}:${sha256}`);
+		expect(r.canonical).toBe(`${registryId}:${name}@${version}:${sha256}`);
 		expect(readFileSync(r.paths.tgz).equals(tgz)).toBe(true);
 		expect(readFileSync(r.paths.good, "utf8")).toBe(readFileSync(`${tgzPath}.sig`, "utf8"));
 		expect(readFileSync(r.paths.bad, "utf8")).toBe(readFileSync(`${tgzPath}.bad.sig`, "utf8"));

package/templates/tests/lifecycle/source-seq.spec.ts

@@ -0,0 +1,55 @@
+// BDD：源代次水位（REG-CS2 防回放）——站点按源记住「见过的最大 seq」，回退即拒。
+//
+// 表 `reg_source_seq` 由 _platform 0014 迁移建；夹具直读真实迁移文件，与迁移零漂移。
+// 四条负向是 G7 的重点：水位写坏 / 表不存在 / 值非法都必须**拒**，不能静默当「第一次见」——
+// 静默重置等于把「防回放」降级成「每次都当第一次见」，攻击者先破坏状态再回放即可穿透。
+import { beforeEach, describe, expect, it } from "vitest";
+import { guardAndRecordSourceSeq, readSourceSeq, SOURCE_SEQ_TABLE } from "../../src/_platform/api/_lifecycle/source-seq";
+import { installDb } from "../fixture";
+
+const SRC = "https://cdn.example.com/solutions";
+
+let dbo: any;
+
+beforeEach(() => {
+	dbo = installDb();
+});
+
+describe("given 站点第一次见某个源 When 拉到它的索引", () => {
+	it("then 记录水位并放行（prev = null）", async () => {
+		expect(await readSourceSeq(SRC)).toBeNull();
+		expect(await guardAndRecordSourceSeq(SRC, 3)).toEqual({ ok: true, prev: null });
+		expect(await readSourceSeq(SRC)).toBe(3);
+	});
+});
+
+describe("given 同一代重复拉取 When 再判一次", () => {
+	it("then 幂等放行，且不改写水位（不误伤正常重复请求）", async () => {
+		await guardAndRecordSourceSeq(SRC, 5);
+		expect(await guardAndRecordSourceSeq(SRC, 5)).toEqual({ ok: true, prev: 5 });
+		expect(await readSourceSeq(SRC)).toBe(5);
+	});
+});
+
+describe("given 源返回更旧的代次 When 判水位", () => {
+	it("then 拒 index_stale，且不把水位拉低（回放改不了水位）", async () => {
+		await guardAndRecordSourceSeq(SRC, 7);
+		expect(await guardAndRecordSourceSeq(SRC, 3)).toEqual({ ok: false, code: "index_stale", prev: 7 });
+		expect(await readSourceSeq(SRC)).toBe(7);
+	});
+});
+
+describe("given 水位被写成非法值 When 判水位", () => {
+	it("then 按 index_state_corrupt 拒（不静默重置成「没见过」）", async () => {
+		dbo.prepare(`INSERT INTO ${SOURCE_SEQ_TABLE} (source_url, max_seq, updated_at) VALUES (?, ?, ?)`).run(SRC, 0, 1);
+		expect(await readSourceSeq(SRC)).toBe("corrupt");
+		expect(await guardAndRecordSourceSeq(SRC, 9)).toEqual({ ok: false, code: "index_state_corrupt", prev: null });
+	});
+});
+
+describe("given 水位表不存在（站点未 migrate）When 判水位", () => {
+	it("then 按 index_state_corrupt 拒（fail-closed，不悄悄放行）", async () => {
+		dbo.exec(`DROP TABLE ${SOURCE_SEQ_TABLE}`);
+		expect(await guardAndRecordSourceSeq(SRC, 1)).toEqual({ ok: false, code: "index_state_corrupt", prev: null });
+	});
+});

package/templates/tests/lifecycle/steps-fs.spec.ts

@@ -266,6 +266,41 @@ describe("download（stage=downloading，S1-2.3 fetch→fs.writeFile）", () =>
 		expect(r.message).toContain("C2-29");
 		expect(calls).toBe(0);
 	});
+
+	// ── REG-CS8 下载闸（红队 F1）：先比对索引声明的 archive.size，超限直接拒——不发请求、不读入内存 ──
+	it("rEG-CS8 package_too_large：声明体积超限，fetch 零调用（源头堵死「先中毒后验毒」）", async () => {
+		const over = 50 * 1024 * 1024 + 1;
+		let calls = 0;
+		const r = await download(dlCtx({
+			manifest: manifest({ file: FILE, sha256: shaOf(BYTES), size: over }),
+			fetch: async () => {
+				calls++;
+				return { ok: true, status: 200, arrayBuffer: async () => new ArrayBuffer(0) };
+			},
+		}));
+		expect(r.ok).toBe(false);
+		expect(r.retryable).toBe(false);
+		expect(r.code).toBe("package_too_large");
+		expect(r.message).toContain("REG-CS8");
+		expect(calls).toBe(0); // 关键：超限时 fetch 未被调用
+	});
+
+	it("rEG-CS8 边界：声明体积恰等于上限（50MB）放行，照常下载（fetch 收到等长字节，P2-11 通过）", async () => {
+		const atLimit = 50 * 1024 * 1024;
+		const big = new Uint8Array(atLimit);
+		const r = await download(dlCtx({
+			manifest: manifest({ file: FILE, sha256: shaOf(BYTES), size: atLimit }),
+			fetch: async () => ({ ok: true, status: 200, arrayBuffer: async () => big.slice().buffer as ArrayBuffer }),
+		}));
+		expect(r.ok).toBe(true);
+	});
+
+	it("rEG-CS8 边界：声明体积超 1 字节即拒（package_too_large 严格不等）", async () => {
+		const over = 50 * 1024 * 1024 + 1;
+		const r = await download(dlCtx({ manifest: manifest({ file: FILE, sha256: shaOf(BYTES), size: over }) }));
+		expect(r.ok).toBe(false);
+		expect(r.code).toBe("package_too_large");
+	});
 });
 
 describe("verify（stage=verifying，C2-29 sha256 fail-closed + P2-3 六码验签）", () => {
@@ -335,18 +370,40 @@ describe("verify（stage=verifying，C2-29 sha256 fail-closed + P2-3 六码验
 		const badNs = await verify(vfCtx({ manifest: manifest({ ...manifest().archive, signature: { ...good, key_id: "default" } }) }));
 		expect(badNs).toMatchObject({ ok: false, code: "sig_key", retryable: false });
 
-		// sig_format：public_key 非 64hex / value 含 -（base64url 特征字符）/ canon 非 v1
+		// sig_format：public_key 非 64hex / value 含 -（base64url 特征字符）
 		const badKey = await verify(vfCtx({ manifest: manifest({ ...manifest().archive, signature: { ...good, public_key: "abc" } }) }));
 		expect(badKey).toMatchObject({ ok: false, code: "sig_format" });
 		const b64url = await verify(vfCtx({ manifest: manifest({ ...manifest().archive, signature: { ...good, value: `${good.value.slice(0, 10)}-${good.value.slice(11)}` } }) }));
 		expect(b64url).toMatchObject({ ok: false, code: "sig_format" });
-		const badCanon = await verify(vfCtx({ manifest: manifest({ ...manifest().archive, signature: { ...good, canon: "v2" } }) }));
-		expect(badCanon).toMatchObject({ ok: false, code: "sig_format" });
+		// canon_stale：v1 旧规范串（REG-CS3 不兼容旧 ojm 签的 .sig，一律逼重签）
+		const staleCanon = await verify(vfCtx({ manifest: manifest({ ...manifest().archive, signature: { ...good, canon: "v1" } }) }));
+		expect(staleCanon).toMatchObject({ ok: false, code: "canon_stale" });
 
-		// tampered：value 首字符翻转（仍是合法标准 base64）
+		// signature_mismatch：value 首字符翻转（仍是合法标准 base64）
 		const tamperedValue = (good.value[0] === "A" ? "B" : "A") + good.value.slice(1);
 		const tampered = await verify(vfCtx({ manifest: manifest({ ...manifest().archive, signature: { ...good, value: tamperedValue } }) }));
-		expect(tampered).toMatchObject({ ok: false, code: "tampered", retryable: false });
+		expect(tampered).toMatchObject({ ok: false, code: "signature_mismatch", retryable: false });
+	});
+
+	it("rEG-CS3 canon_mismatch：包归属 registry 与本站不符（跨仓重放拒装）", async () => {
+		await seed();
+		const good = signedArchiveFor(BYTES, "demo-solution", "0.1.0").sig;
+		// 本站身份 oj-registry，但包是 test.registry 签发的 → 跨仓重放
+		const r = await verify(vfCtx({
+			registryId: "oj-registry",
+			manifest: manifest({ ...manifest().archive, signature: good }),
+		}));
+		expect(r).toMatchObject({ ok: false, code: "canon_mismatch" });
+		expect(r.message).toContain("oj-registry");
+		// 同身份则放行（回归：归属一致不误伤）
+		const okSame = await verify(vfCtx({
+			registryId: "test.registry",
+			manifest: manifest({ ...manifest().archive, signature: good }),
+		}));
+		expect(okSame).toMatchObject({ ok: true });
+		// 未配置 registryId = 跳过跨仓比对（仅验签完整性，向后兼容）
+		const okUnset = await verify(vfCtx({ manifest: manifest({ ...manifest().archive, signature: good }) }));
+		expect(okUnset).toMatchObject({ ok: true });
 	});
 
 	it("sig_key：已信任 key_id 但包内公钥与库绑定不一致（首次绑定不可改族）", async () => {
@@ -370,7 +427,7 @@ describe("verify（stage=verifying，C2-29 sha256 fail-closed + P2-3 六码验
 		expect(await fsp.readdir(staging)).toEqual([FILE]);
 	});
 
-	it("双层语义分码：验签面抛错 → sig_format（上游 verifyEd25519: 前缀）；返回 false → tampered", async () => {
+	it("双层语义分码：验签面抛错 → sig_format（上游 verifyEd25519: 前缀）；返回 false → signature_mismatch", async () => {
 		await seed();
 		const throwing = await verify(vfCtx({
 			verifyEd25519: () => { throw new Error("verifyEd25519: signature not base64"); },
@@ -378,7 +435,7 @@ describe("verify（stage=verifying，C2-29 sha256 fail-closed + P2-3 六码验
 		expect(throwing).toMatchObject({ ok: false, code: "sig_format" });
 		expect(throwing.message).toContain("verifyEd25519: ");
 		const falseFace = await verify(vfCtx({ verifyEd25519: () => false }));
-		expect(falseFace).toMatchObject({ ok: false, code: "tampered" });
+		expect(falseFace).toMatchObject({ ok: false, code: "signature_mismatch" });
 	});
 
 	it("原语/信任库不可得：验签面缺失或 trustPath 缺失 → fail-closed 拒装（无静默跳过）", async () => {
@@ -506,6 +563,108 @@ describe("extract（stage=extracting，R1 list→validate→extract 三步）",
 	});
 });
 
+// ── REG-CS8 体积闸（红队 F1）：解压前复用同一份清单累加，零额外 tar、零解压前即拒；解压后复核兜底 ──
+describe("extract REG-CS8 体积闸（清单口径，复用 list 输出，零额外 IO）", () => {
+	it("entry_too_large：单条目未压缩 > 50MB → 拒，code=entry_too_large，零解压（exec 仅 1 次列表）", async () => {
+		const big = 50 * 1024 * 1024 + 1;
+		const exec = recordingExec(async () => ({
+			code: 0,
+			stdout: [
+				"drwxr-xr-x  0 ever staff    0 10 17 12:00 demo-solution-0.1.0/",
+				`-rw-r--r--  0 ever staff   ${big} 10 17 12:00 demo-solution-0.1.0/bomb`,
+			].join("\n"),
+			stderr: "",
+		}));
+		await fsp.mkdir(staging, { recursive: true });
+		const r = await extract(exCtx({ exec }));
+		expect(r.ok).toBe(false);
+		expect(r.retryable).toBe(false);
+		expect(r.code).toBe("entry_too_large");
+		expect(r.message).toContain("REG-CS8");
+		expect(exec.calls.length).toBe(1); // 复用清单，未触发第二次 tar（extract）
+		expect(await fsp.readdir(staging)).toEqual([]); // 零落盘
+	});
+
+	it("unpacked_too_large：未压缩总体积 > 200MB（单条目安全）→ 拒，code=unpacked_too_large，零解压", async () => {
+		const safe = 40 * 1024 * 1024;
+		const n = Math.ceil((200 * 1024 * 1024 + 1) / safe);
+		const lines: string[] = [];
+		for (let i = 0; i < n; i++)
+			lines.push(`-rw-r--r--  0 ever staff   ${safe} 10 17 12:00 demo-solution-0.1.0/f${i}`);
+		const exec = recordingExec(async () => ({ code: 0, stdout: lines.join("\n"), stderr: "" }));
+		await fsp.mkdir(staging, { recursive: true });
+		const r = await extract(exCtx({ exec }));
+		expect(r.ok).toBe(false);
+		expect(r.retryable).toBe(false);
+		expect(r.code).toBe("unpacked_too_large");
+		expect(exec.calls.length).toBe(1);
+	});
+
+	it("too_many_entries：条目数 > 5000 → 拒，code=too_many_entries，零解压", async () => {
+		const n = 5000 + 1;
+		const lines: string[] = [];
+		for (let i = 0; i < n; i++)
+			lines.push(`-rw-r--r--  0 ever staff    1 10 17 12:00 demo-solution-0.1.0/f${i}`);
+		const exec = recordingExec(async () => ({ code: 0, stdout: lines.join("\n"), stderr: "" }));
+		await fsp.mkdir(staging, { recursive: true });
+		const r = await extract(exCtx({ exec }));
+		expect(r.ok).toBe(false);
+		expect(r.retryable).toBe(false);
+		expect(r.code).toBe("too_many_entries");
+		expect(exec.calls.length).toBe(1);
+	});
+
+	it("合法清单（成员数/总体积/单条目均安全）→ 越过体积闸，继续到 extract 步（exec.calls===2）", async () => {
+		// 真实系统 tar 解压此合法清单（list 成功→volume 通过→extract 真解压）
+		const realExec = realTarExec();
+		await fsp.mkdir(staging, { recursive: true });
+		const pkg = join(root, "pkg", "demo-solution-0.1.0");
+		await fsp.mkdir(join(pkg, "src"), { recursive: true });
+		await fsp.writeFile(join(pkg, "manifest.yaml"), "name: demo-solution\n");
+		await fsp.writeFile(join(pkg, "src", "entry.js"), "export default {};\n");
+		const tgz = join(staging, FILE);
+		await execFileP("tar", ["-czf", tgz, "-C", join(root, "pkg"), "demo-solution-0.1.0"]);
+		// 用真实 tar 回放同一 tgz 的 list/extract：list 输出即上面构造的合法形态
+		const r = await extract(exCtx({ exec: realExec }));
+		expect(r.ok).toBe(true);
+		expect(realExec.calls.length).toBe(2); // list + extract 各一次，体积闸未重复跑 tar
+	});
+});
+
+describe("extract REG-CS8 解压后复核（清单瞒报兜底：实际磁盘占用 > 200MB → 拒）", () => {
+	it("清单口径小（通过 volume 闸）但 stat 面报告实际占用超大 → 解压后复核拒，code=unpacked_too_large", async () => {
+		// 注入 stat 面：一切文件都报 1GB（模拟解压炸弹绕过清单口径）；list 给一份小清单骗过 volume 闸
+		const hugeStat: FsFace = {
+			...nodeFsFace(),
+			stat: async () => ({ size: 1024 * 1024 * 1024 }),
+		};
+		g.fs = hugeStat;
+		await fsp.mkdir(staging, { recursive: true });
+		await fsp.writeFile(join(staging, "manifest.yaml"), "name: demo-solution\n"); // 复核须读到的真实小文件
+		const exec = recordingExec(async argv => argv[1] === "-xzf"
+			? { code: 0, stdout: "", stderr: "" } // 解压步：no-op（不真解压，靠 stat 面模拟实际占用）
+			: { code: 0, stdout: "-rw-r--r--  0 ever staff    1 10 17 12:00 demo-solution-0.1.0/manifest.yaml", stderr: "" });
+		const r = await extract(exCtx({ exec }));
+		expect(r.ok).toBe(false);
+		expect(r.retryable).toBe(false);
+		expect(r.code).toBe("unpacked_too_large");
+		expect(r.message).toContain("REG-CS8");
+		expect(r.message).toContain("瞒报");
+	});
+
+	it("stat 面缺失 → 复核降级跳过（清单口径已先拦，不误杀正常包）", async () => {
+		// nodeFsFace 无 stat：recheck 应 ok 跳过；用真实小包验证不误杀
+		await fsp.mkdir(staging, { recursive: true });
+		const pkg = join(root, "pkg2", "demo-solution-0.1.0");
+		await fsp.mkdir(pkg, { recursive: true });
+		await fsp.writeFile(join(pkg, "manifest.yaml"), "name: demo-solution\n");
+		const tgz = join(staging, FILE);
+		await execFileP("tar", ["-czf", tgz, "-C", join(root, "pkg2"), "demo-solution-0.1.0"]);
+		const r = await extract(exCtx({ exec: realTarExec() }));
+		expect(r.ok).toBe(true); // 无 stat 面正常包照常通过（复核跳过而非失败）
+	});
+});
+
 // B-11/C2-31 安装期复核：包内 api/<name>-<version>/manifest.yaml 是 oj 原生清单（desc 必填，
 // serve 装配 parse_one 消费面），与 C2 Form A 的 summary 字段由构建期映射（ojm build --bundle
 // 写入并核对）；安装期只验不写——写等于掩盖上游不一致（映射被篡改的包必须拒装）。

package/templates/tests/lifecycle/tgz-guard.spec.ts

@@ -4,7 +4,8 @@
 // 拒绝：绝对路径、任何 `..` 段、l/h 条目、空成员名、反斜杠路径；`./` 前缀相对合法。
 import { describe, expect, it } from "vitest";
 
-import { validateTarListing } from "../../src/_platform/api/_lifecycle/tgz-guard";
+import { MAX_ENTRIES, MAX_PACKAGE_BYTES, MAX_SINGLE_ENTRY_BYTES, MAX_UNPACKED_BYTES } from "../../src/_platform/api/_lifecycle/limits";
+import { accumulateTarVolume, checkTarVolumeLimits, extractTarEntrySize, validateTarListing } from "../../src/_platform/api/_lifecycle/tgz-guard";
 
 describe("validateTarListing（R1）", () => {
 	it("正常成员列表通过", () => {
@@ -101,3 +102,134 @@ describe("validateTarListing（R1）", () => {
 		])).toEqual({ ok: false, offender: "/abs" });
 	});
 });
+
+// ── REG-CS8 体积闸门（红队 F1）：复用同一份 tar 清单累加，不额外跑一次 tar ──
+
+describe("extractTarEntrySize（REG-CS8 跨实现形态稳健解析）", () => {
+	it("gNU 月日形（-rw-r--r-- … SIZE 10 17 12:00 name）解析出 size", () => {
+		expect(extractTarEntrySize("-rw-r--r--  0 ever staff   42 10 17 12:00 wiki-0.2.0/src/manifest.yaml")).toBe(42);
+	});
+
+	it("gNU-ISO 形（-rw-r--r-- … SIZE 2026-10-17 12:00 name）解析出 size", () => {
+		expect(extractTarEntrySize("-rw-r--r--  0 ever staff   42 2026-10-17 12:00 wiki-0.2.0/src/manifest.yaml")).toBe(42);
+	});
+
+	it("bSD 形（-rw-r--r-- … SIZE Mon DD HH:MM name）解析出 size", () => {
+		expect(extractTarEntrySize("-rw-r--r--  0 ever staff   42 Oct 17 12:00 wiki-0.2.0/src/manifest.yaml")).toBe(42);
+	});
+
+	it("目录行（size=0）解析为 0，不影响体积判定", () => {
+		expect(extractTarEntrySize("drwxr-xr-x  0 ever staff    0 10 17 12:00 wiki-0.2.0/")).toBe(0);
+	});
+
+	it("畸形行（无日期组）回退 0，不抛错", () => {
+		expect(extractTarEntrySize("-rw-r--r--  0 ever staff")).toBe(0);
+	});
+
+	it("gNU 旧 mtime 形（省略时刻，只剩 ISO 日期）解析出 size，不漏体积闸门", () => {
+		expect(extractTarEntrySize("-rw-r--r--  0 ever staff   42 2026-10-17 wiki-0.2.0/src/manifest.yaml")).toBe(42);
+	});
+
+	it("bSD 旧 mtime 形（省略时刻，年份替代）解析出 size，不漏体积闸门", () => {
+		expect(extractTarEntrySize("-rw-r--r--  0 ever staff   42 Oct 17 2023 wiki-0.2.0/src/manifest.yaml")).toBe(42);
+	});
+
+	it("旧 mtime 大单条目仍命中 entry_too_large（REG-CS8 不漏）", () => {
+		const big = MAX_SINGLE_ENTRY_BYTES + 1;
+		const r = checkTarVolumeLimits([
+			`-rw-r--r--  0 ever staff   ${big} 2026-10-17 wiki-0.2.0/bomb`,
+		]);
+		expect(r.ok).toBe(false);
+		if (!r.ok)
+			expect(r.code).toBe("entry_too_large");
+	});
+});
+
+describe("accumulateTarVolume（REG-CS8 累加统计）", () => {
+	it("累加条目数/未压缩总体积/单条目最大体积", () => {
+		const v = accumulateTarVolume([
+			"drwxr-xr-x  0 ever staff    0 10 17 12:00 wiki-0.2.0/",
+			"-rw-r--r--  0 ever staff   10 10 17 12:00 wiki-0.2.0/a",
+			"-rw-r--r--  0 ever staff   30 10 17 12:00 wiki-0.2.0/b",
+		]);
+		expect(v).toEqual({ entries: 3, totalUncompressed: 40, maxEntry: 30 });
+	});
+
+	it("空行/退化行跳过不计数", () => {
+		const v = accumulateTarVolume(["", "   ", "-rw-r--r--  0 ever staff    7 10 17 12:00 wiki-0.2.0/x"]);
+		expect(v).toEqual({ entries: 1, totalUncompressed: 7, maxEntry: 7 });
+	});
+});
+
+describe("checkTarVolumeLimits（REG-CS8 三闸：条目数 → 总体积 → 单条目，先罚整体再罚单点）", () => {
+	it("合法清单通过，并回传 volume", () => {
+		const lines = [
+			"drwxr-xr-x  0 ever staff    0 10 17 12:00 wiki-0.2.0/",
+			"-rw-r--r--  0 ever staff   42 10 17 12:00 wiki-0.2.0/src/manifest.yaml",
+		];
+		const r = checkTarVolumeLimits(lines);
+		expect(r.ok).toBe(true);
+		if (r.ok)
+			expect(r.volume).toEqual({ entries: 2, totalUncompressed: 42, maxEntry: 42 });
+	});
+
+	it("too_many_entries：条目数 > 上限（MAX_ENTRIES）即拒", () => {
+		const lines: string[] = [];
+		for (let i = 0; i < MAX_ENTRIES + 1; i++)
+			lines.push(`-rw-r--r--  0 ever staff    1 10 17 12:00 wiki-0.2.0/f${i}`);
+		const r = checkTarVolumeLimits(lines);
+		expect(r.ok).toBe(false);
+		if (!r.ok) {
+			expect(r.code).toBe("too_many_entries");
+			expect(r.offender).toContain(String(MAX_ENTRIES + 1));
+		}
+	});
+
+	it("unpacked_too_large：未压缩总体积 > 上限（MAX_UNPACKED_BYTES）即拒", () => {
+		// 单条目均 < 上限（40MB），靠总和越界——确认命中「总体积闸」而非「单条目闸」
+		const safe = 40 * 1024 * 1024;
+		const n = Math.ceil((MAX_UNPACKED_BYTES + 1) / safe);
+		const lines: string[] = [];
+		for (let i = 0; i < n; i++)
+			lines.push(`-rw-r--r--  0 ever staff   ${safe} 10 17 12:00 wiki-0.2.0/f${i}`);
+		const r = checkTarVolumeLimits(lines);
+		expect(r.ok).toBe(false);
+		if (!r.ok) {
+			expect(r.code).toBe("unpacked_too_large");
+			expect(r.volume.entries).toBe(n);
+		}
+	});
+
+	it("entry_too_large：单条目未压缩体积 > 上限（MAX_SINGLE_ENTRY_BYTES）即拒", () => {
+		const big = MAX_SINGLE_ENTRY_BYTES + 1;
+		const r = checkTarVolumeLimits([
+			"drwxr-xr-x  0 ever staff    0 10 17 12:00 wiki-0.2.0/",
+			`-rw-r--r--  0 ever staff   ${big} 10 17 12:00 wiki-0.2.0/bomb`,
+		]);
+		expect(r.ok).toBe(false);
+		if (!r.ok) {
+			expect(r.code).toBe("entry_too_large");
+			expect(r.offender).toContain(String(big));
+		}
+	});
+
+	it("三闸序位：条目数越界先于总体积/单条目（批量伪造清单优先罚整体维度）", () => {
+		// 同一条清单既条目数越界、又单条目越界——应报 too_many_entries（先罚整体）
+		const lines: string[] = [];
+		for (let i = 0; i < MAX_ENTRIES + 1; i++)
+			lines.push(`-rw-r--r--  0 ever staff   ${MAX_SINGLE_ENTRY_BYTES + 1} 10 17 12:00 wiki-0.2.0/f${i}`);
+		const r = checkTarVolumeLimits(lines);
+		expect(r.ok).toBe(false);
+		if (!r.ok)
+			expect(r.code).toBe("too_many_entries");
+	});
+});
+
+describe("体积上限常量（REG-CS8，Q13 拍板数值，全仓单源）", () => {
+	it("四常数口径与需求一致（50MB/200MB/5000/50MB）", () => {
+		expect(MAX_PACKAGE_BYTES).toBe(50 * 1024 * 1024);
+		expect(MAX_UNPACKED_BYTES).toBe(200 * 1024 * 1024);
+		expect(MAX_ENTRIES).toBe(5000);
+		expect(MAX_SINGLE_ENTRY_BYTES).toBe(50 * 1024 * 1024);
+	});
+});

package/templates/tests/lifecycle/verify-checks.spec.ts

@@ -54,17 +54,27 @@ describe("SSRF 钉①：探测 URL 永不出站（probeUrlOf）", () => {
 	});
 });
 
-// ============ SSRF 钉②：siteOrigin header 清洗 ============
-describe("SSRF 钉②：siteOrigin 清洗 x-forwarded-proto", () => {
+// ============ SSRF 钉②：siteOrigin 只信配置的 canonical_origin，绝不读请求头（REG-CS6）============
+describe("SSRF 钉②：siteOrigin 只信配置的 canonical_origin，绝不读请求头", () => {
 	afterEach(() => {
 		g.http = undefined;
 	});
-	it("取首个且去空白", () => {
-		g.http = { headers: { "host": "h", "x-forwarded-proto": " https , http " } };
-		expect(siteOrigin()).toEqual({ proto: "https", host: "h" });
+	it("合法 origin → {proto,host}（协议小写化）", () => {
+		expect(siteOrigin("https://Example.com:8080")).toEqual({ proto: "https", host: "Example.com:8080" });
+		expect(siteOrigin("http://h")).toEqual({ proto: "http", host: "h" });
 	});
-	it("无 host → null（非请求上下文跳过探针）", () => {
-		g.http = { headers: {} };
+	it("缺省/空/非法 → null（不补全、不回落请求头）", () => {
+		expect(siteOrigin()).toBeNull();
+		expect(siteOrigin(null)).toBeNull();
+		expect(siteOrigin("")).toBeNull();
+		expect(siteOrigin("not-a-url")).toBeNull();
+		expect(siteOrigin("ftp://x")).toBeNull();
+	});
+	it("伪造 Host/x-forwarded-proto 头完全不被采用——只认入参 canonical_origin", () => {
+		g.http = { headers: { "host": "169.254.169.254", "x-forwarded-proto": "http" } };
+		// 入参给出真实 origin → 用真实 origin；请求头里的恶意 host 被无视
+		expect(siteOrigin("https://real.example.com")).toEqual({ proto: "https", host: "real.example.com" });
+		// 入参缺失 → 即便请求头伪造了 host 也不猜、不回落，返回 null
 		expect(siteOrigin()).toBeNull();
 	});
 });
@@ -270,18 +280,20 @@ afterEach(async () => {
 });
 
 function setHttp(over: Record<string, unknown>) {
-	g.http = { user: { id: 1 }, query: { name: "demo" }, headers: { host: "localhost:9778" }, ...over };
+	// 默认伪造一个与 canonical_origin 不同的 Host 头（REG-CS6：探针补全绝不读请求头 Host，
+	// 即便此处 host 是攻击者的恶意值，出站 URL 也只认配置的 canonical_origin）
+	g.http = { user: { id: 1 }, query: { name: "demo" }, headers: { host: "forged.attacker.invalid" }, ...over };
 	g.json = {
 		ok: (data: unknown) => { last = { status: 200, data }; },
 		fail: (status: number, msg: string) => { last = { status, msg }; },
 	};
 }
 
-function makeEnv() {
+function makeEnv(overrides: Record<string, unknown> = {}) {
 	// modulesJsonPath 钉进临时目录（readFile 失败 → 不打 web 项）：默认值 `dist/web/modules.json`
 	// 是相对 cwd 的，会把模板本机构建产物卷进用例，全绿用例随「模板 build 过没有」摇摆。
 	// P4-2 两条 integrity 用例显式覆盖它。
-	return { ...solutionsEnv(), sharedRoot: root, statePath: join(root, "state.yaml"), modulesJsonPath: join(root, "modules.json") };
+	return { ...solutionsEnv(), sharedRoot: root, statePath: join(root, "state.yaml"), modulesJsonPath: join(root, "modules.json"), ...overrides };
 }
 
 describe("深检端点门（admin 域）", () => {
@@ -307,22 +319,24 @@ describe("深检端点编排（四项）", () => {
 		dbo.prepare("INSERT INTO sys_solution_route (path, module, category, \"order\", title_key, required_permission, enabled, deprecated) VALUES (?,?,?,?,?,?,?,0)").run("/api/demo", "demo", "main", 200, "demo:menu", null, 1);
 		// trusted 状态：无 trust 项、无检查项 → 干净报告（checks=[]）
 		await fsp.writeFile(join(root, "state.yaml"), "solutions:\n  demo:\n    version: \"0.1.0\"\n    enabled: true\n    installedAt: 0\n    trust_state: trusted\n");
+		// REG-CS6：探针补全用配置的 canonical_origin（不读请求头 Host）
 		setHttp({});
-		await createSolutionsApi(makeEnv()).verify.post();
+		await createSolutionsApi(makeEnv({ canonicalOrigin: "http://localhost:9778" })).verify.post();
 		expect(last?.status).toBe(200);
 		const data = last?.data as { ok: boolean, checks: unknown[], advise: string[] };
 		expect(data.ok).toBe(true);
 		expect(data.checks).toEqual([]);
 		expect(data.advise).toEqual([]);
-		// 探针用同源绝对 URL（SSRF 钉①②）
+		// 探针按 canonical_origin 补全为同源绝对 URL（SSRF 钉①②）
 		expect(fetchCalls[0]).toBe("http://localhost:9778/api/demo");
 	});
 
 	it("路由 404 → routes error 项，ok=false", async () => {
 		dbo.prepare("INSERT INTO sys_solution_route (path, module, category, \"order\", title_key, required_permission, enabled, deprecated) VALUES (?,?,?,?,?,?,?,0)").run("/api/demo", "demo", "main", 200, "demo:menu", null, 1);
 		g.fetch = statusFetch(404);
+		// REG-CS6：探针需配置 canonical_origin 才会真正出站（缺配置则跳过 info 项）
 		setHttp({});
-		await createSolutionsApi(makeEnv()).verify.post();
+		await createSolutionsApi(makeEnv({ canonicalOrigin: "http://localhost:9778" })).verify.post();
 		const data = last?.data as { ok: boolean, checks: Array<{ id: string, severity: string }> };
 		expect(data.ok).toBe(false);
 		expect(data.checks.some(c => c.id === "routes" && c.severity === "error")).toBe(true);

package/templates/tests/lifecycle/verify-report.spec.ts

@@ -129,7 +129,9 @@ function setHttp(over: Record<string, unknown> = {}) {
 function makeEnv() {
 	// modulesJsonPath 同 verify-checks.spec：钉进临时目录（缺文件 → 跳过 web 项），
 	// 不吃模板本机 `dist/web/modules.json`。
-	return { ...solutionsEnv(), sharedRoot: root, statePath: join(root, "state.yaml"), modulesJsonPath: join(root, "modules.json"), verifyReportsDir: reportsDir };
+	// REG-CS6：深检路由可达性探针需配置 canonical_origin 才会真正出站（缺配置则跳过并打 info 项，
+	// 会让「全绿无检查项」类断言多出一项）。此处注入固定 origin + okFetch(200) → 探针通过不打项。
+	return { ...solutionsEnv(), sharedRoot: root, statePath: join(root, "state.yaml"), modulesJsonPath: join(root, "modules.json"), verifyReportsDir: reportsDir, canonicalOrigin: "http://localhost:9778" };
 }
 
 async function insertRoute(perm: string | null) {