test(sidecar): digest/inject/protect strip⇒fail contracts

Deterministic digest, alter/strip/retag divergence, order sensitivity,
runtime intact vs stripped/altered fail-closed, softFold, and
protectTarget flag on/off wiring.
This commit is contained in:
qybaihe
2026-11-06 02:38:43 +08:00
committed by qybaihe
parent cba64d0663
commit cf2300d17b
3 changed files with 349 additions and 0 deletions
+101
View File
@@ -0,0 +1,101 @@
import { describe, expect, it } from "vitest";
import {
computeSidecarBindingDigest,
} from "../src/shields/runtime/sidecar-entangle.js";
describe("computeSidecarBindingDigest", () => {
it("is deterministic for identical entry + sidecars + seedTag", () => {
const entry = {
pathLabel: "main.js",
bytes: new TextEncoder().encode("module.exports = 1;\n"),
};
const sidecars = [
{
pathLabel: "main.js.bla-sidecar",
bytes: new TextEncoder().encode("chaff-a"),
},
{
pathLabel: "assets.chaff",
bytes: new TextEncoder().encode("chaff-b"),
},
];
const a = computeSidecarBindingDigest(entry, sidecars, "test-seed");
const b = computeSidecarBindingDigest(entry, sidecars, "test-seed");
expect(a.hex).toBe(b.hex);
expect(a.hex).toMatch(/^[0-9a-f]{64}$/);
expect(a.u32).toBe(parseInt(a.hex.slice(0, 8), 16) >>> 0);
expect(a.u32).toBeGreaterThan(0);
});
it("sidecars mode ignores entry body changes (preamble-safe)", () => {
const sib = {
pathLabel: "sib.js",
bytes: new TextEncoder().encode("sidecar-bytes"),
};
const a = computeSidecarBindingDigest(
{ pathLabel: "main.js", bytes: new TextEncoder().encode("v1") },
[sib],
"v1",
"sidecars",
);
const b = computeSidecarBindingDigest(
{ pathLabel: "main.js", bytes: new TextEncoder().encode("v1-WITH-PREAMBLE") },
[sib],
"v1",
"sidecars",
);
expect(a.hex).toBe(b.hex);
});
it("full mode includes entry body", () => {
const sib = {
pathLabel: "sib.js",
bytes: new TextEncoder().encode("sidecar-bytes"),
};
const a = computeSidecarBindingDigest(
{ pathLabel: "main.js", bytes: new TextEncoder().encode("v1") },
[sib],
"v1",
"full",
);
const b = computeSidecarBindingDigest(
{ pathLabel: "main.js", bytes: new TextEncoder().encode("v2") },
[sib],
"v1",
"full",
);
expect(a.hex).not.toBe(b.hex);
});
it("changes when a sidecar is stripped or altered (strip⇒fail contract)", () => {
const entry = {
pathLabel: "main.js",
bytes: new TextEncoder().encode("ok"),
};
const sidecar = {
pathLabel: "sib.js",
bytes: new TextEncoder().encode("sidecar-bytes"),
};
const base = computeSidecarBindingDigest(entry, [sidecar], "v1");
const stripped = computeSidecarBindingDigest(entry, [], "v1");
const altered = computeSidecarBindingDigest(
entry,
[{ ...sidecar, bytes: new TextEncoder().encode("TAMPERED") }],
"v1",
);
expect(stripped.hex).not.toBe(base.hex);
expect(altered.hex).not.toBe(base.hex);
expect(stripped.u32).not.toBe(base.u32);
expect(altered.u32).not.toBe(base.u32);
});
it("changes when seedTag differs", () => {
const entry = {
pathLabel: "e.js",
bytes: new Uint8Array([1, 2, 3]),
};
const a = computeSidecarBindingDigest(entry, [], "tag-a");
const b = computeSidecarBindingDigest(entry, [], "tag-b");
expect(a.hex).not.toBe(b.hex);
});
});
+92
View File
@@ -0,0 +1,92 @@
import { describe, expect, it } from "vitest";
import {
mkdtempSync,
writeFileSync,
rmSync,
readFileSync,
} from "node:fs";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { createRequire } from "node:module";
import { protectTarget } from "../src/engine/protector.js";
import { computeSidecarBindingDigest } from "../src/shields/runtime/sidecar-entangle.js";
const enc = (s: string) => new TextEncoder().encode(s);
describe("sidecar entangle protectTarget wiring", () => {
it("flag off leaves entry free of strip⇒fail preamble", () => {
const dir = mkdtempSync(join(tmpdir(), "bla-sidecar-off-"));
try {
const entry = join(dir, "main.js");
const sib = join(dir, "sib.js");
writeFileSync(entry, "module.exports = { v: 1 };\n", "utf8");
writeFileSync(sib, "sidecar\n", "utf8");
const out = join(dir, "main.out.js");
const res = protectTarget({
inputPath: entry,
outputPath: out,
intensity: "balanced",
seed: "off-test",
honeySourceMaps: false,
sidecarEntangle: false,
sidecarEntanglePaths: ["sib.js"],
});
expect(res.sidecarEntangle).toBeUndefined();
const code = readFileSync(out, "utf8");
expect(code).not.toContain("integrity binding mismatch");
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("flag on writes binding; intact load works; strip fails closed", () => {
const dir = mkdtempSync(join(tmpdir(), "bla-sidecar-on-"));
try {
const entry = join(dir, "main.js");
const sib = join(dir, "sib.js");
const entrySrc = "module.exports = { v: 99 };\n";
const sibSrc = "sidecar-bytes-v1\n";
writeFileSync(entry, entrySrc, "utf8");
writeFileSync(sib, sibSrc, "utf8");
const out = join(dir, "main.out.js");
// protect writes next to output; sidecar path resolved from output dir
writeFileSync(join(dir, "sib-for-out.js"), sibSrc, "utf8");
const res = protectTarget({
inputPath: entry,
outputPath: out,
intensity: "balanced",
seed: "on-test-seed",
honeySourceMaps: false,
sidecarEntangle: true,
sidecarEntanglePaths: ["sib-for-out.js"],
});
expect(res.sidecarEntangle).toBe(true);
const code = readFileSync(out, "utf8");
expect(code).toContain("node:crypto");
expect(code).toContain("integrity binding mismatch");
const req = createRequire(join(dir, "pkg.json"));
const loaded = req(out) as { v: number };
expect(loaded.v).toBe(99);
rmSync(join(dir, "sib-for-out.js"));
delete req.cache[out];
expect(() => req(out)).toThrow(/integrity binding mismatch/);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("digest is order-sensitive across sidecars", () => {
const entry = { pathLabel: "main.js", bytes: enc("x") };
const fwd = computeSidecarBindingDigest(entry, [
{ pathLabel: "a", bytes: enc("A") },
{ pathLabel: "b", bytes: enc("B") },
]).hex;
const rev = computeSidecarBindingDigest(entry, [
{ pathLabel: "b", bytes: enc("B") },
{ pathLabel: "a", bytes: enc("A") },
]).hex;
expect(fwd).not.toBe(rev);
});
});
+156
View File
@@ -0,0 +1,156 @@
import { describe, expect, it } from "vitest";
import { mkdtempSync, writeFileSync, rmSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { tmpdir } from "node:os";
import { createRequire } from "node:module";
import {
bindSidecarEntanglement,
computeSidecarBindingDigest,
generateSidecarJsPreamble,
SIDECAR_ENTANGLE_SCHEMA,
} from "../src/shields/runtime/sidecar-entangle.js";
describe("sidecar JS inject strip⇒fail (vertical slice)", () => {
it("generateSidecarJsPreamble rejects non-hex expected digests", () => {
expect(() =>
generateSidecarJsPreamble({
entryPath: "main.js",
sidecarPaths: ["sib.js"],
expectedHex: "deadbeef",
}),
).toThrow(/64-char/);
});
it("bindSidecarEntanglement returns status bound with inject + digest", () => {
const entryBytes = new TextEncoder().encode("module.exports = { ok: true };\n");
const sibBytes = new TextEncoder().encode("sidecar-payload\n");
const bound = bindSidecarEntanglement({
entryPath: "main.js",
sidecarPaths: ["sib.js"],
seedTag: "inject-test-v1",
entryBytes,
sidecarBytes: [sibBytes],
});
expect(bound.plan.schema).toBe(SIDECAR_ENTANGLE_SCHEMA);
expect(bound.plan.status).toBe("bound");
expect(bound.inject.preamble).toContain("node:crypto");
expect(bound.inject.expectedHex).toBe(bound.digest.hex);
expect(bound.inject.softFold).toBe(false);
expect(bound.code.startsWith(bound.inject.preamble)).toBe(true);
});
it("runtime: intact sidecars pass; stripped sidecar fails closed", () => {
const dir = mkdtempSync(join(tmpdir(), "bla-sidecar-inject-"));
try {
const entryPath = "main.js";
const sibName = "sib.js";
const entrySrc = "module.exports = { value: 42 };\n";
const sibSrc = "module.exports = 'sidecar';\n";
writeFileSync(join(dir, sibName), sibSrc, "utf8");
const digest = computeSidecarBindingDigest(
{ pathLabel: entryPath, bytes: new TextEncoder().encode(entrySrc) },
[{ pathLabel: sibName, bytes: new TextEncoder().encode(sibSrc) }],
"rt-v1",
);
const inject = generateSidecarJsPreamble({
entryPath,
sidecarPaths: [sibName],
seedTag: "rt-v1",
expectedHex: digest.hex,
softFold: false,
});
// Write entry WITH preamble prepended — sidecars-mode digest still matches.
const protectedEntry = `${inject.preamble}\n${entrySrc}`;
writeFileSync(join(dir, entryPath), protectedEntry, "utf8");
const req = createRequire(join(dir, "pkg.json"));
const loaded = req(join(dir, entryPath)) as { value: number };
expect(loaded.value).toBe(42);
// Strip sidecar → next load must throw.
rmSync(join(dir, sibName));
expect(() => {
// Bust require cache
const abs = join(dir, entryPath);
delete req.cache[abs];
req(abs);
}).toThrow(/integrity binding mismatch/);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("runtime: altered sidecar fails closed", () => {
const dir = mkdtempSync(join(tmpdir(), "bla-sidecar-alter-"));
try {
const entryPath = "main.js";
const sibName = "sib.js";
const entrySrc = "module.exports = { value: 7 };\n";
const sibSrc = "original-sidecar\n";
writeFileSync(join(dir, sibName), sibSrc, "utf8");
const digest = computeSidecarBindingDigest(
{ pathLabel: entryPath, bytes: new TextEncoder().encode(entrySrc) },
[{ pathLabel: sibName, bytes: new TextEncoder().encode(sibSrc) }],
"alter-v1",
);
const inject = generateSidecarJsPreamble({
entryPath,
sidecarPaths: [sibName],
seedTag: "alter-v1",
expectedHex: digest.hex,
});
writeFileSync(join(dir, entryPath), `${inject.preamble}\n${entrySrc}`, "utf8");
const req = createRequire(join(dir, "pkg.json"));
expect((req(join(dir, entryPath)) as { value: number }).value).toBe(7);
writeFileSync(join(dir, sibName), "TAMPERED\n", "utf8");
const abs = join(dir, entryPath);
delete req.cache[abs];
expect(() => req(abs)).toThrow(/integrity binding mismatch/);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
it("softFold flips digest u32 instead of throwing when sidecar missing", () => {
const dir = mkdtempSync(join(tmpdir(), "bla-sidecar-soft-"));
try {
const entryPath = "main.js";
const sibName = "sib.js";
const entrySrc =
"module.exports = { d: (typeof __blaSidecarDigest === 'number' ? __blaSidecarDigest : 0) };\n";
// softFold preamble assigns binding as IIFE return — capture via rewrite:
const digest = computeSidecarBindingDigest(
{ pathLabel: entryPath, bytes: new TextEncoder().encode("x") },
[{ pathLabel: sibName, bytes: new TextEncoder().encode("y") }],
"soft-v1",
);
const inject = generateSidecarJsPreamble({
entryPath,
sidecarPaths: [sibName],
seedTag: "soft-v1",
expectedHex: digest.hex,
softFold: true,
bindingName: "__blaSidecarDigest",
});
// Capture IIFE return into the binding name for the module scope.
const preambleAssign = `var __blaSidecarDigest = ${inject.preamble}\n`;
writeFileSync(
join(dir, entryPath),
`${preambleAssign}module.exports = { d: __blaSidecarDigest };\n`,
"utf8",
);
// No sidecar written → softFold should set flipped/zero digest, not throw.
const req = createRequire(join(dir, "pkg.json"));
const out = req(join(dir, entryPath)) as { d: number };
expect(typeof out.d).toBe("number");
expect(out.d).not.toBe(digest.u32);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
});