🛡️ BLA (Blind LLM Agents) — Adversarial defense shield that protects binaries, Electron apps, JS bundles, Python, and WebAssembly against AI reverse-engineering agents like REA. Poison -> Exhaust -> Hallucinate.
JavaScript adversarial-aiclaude-codecursorelectron-securityllm-securitymcpmcp-serverobfuscationreverse-engineeringwebassembly
test(sidecar): digest/inject/protect strip⇒fail contracts
qybaihecf2300d17bd6
diff --git a/tests/sidecar-binding-digest.test.ts b/tests/sidecar-binding-digest.test.tsnew file mode 100644index 0000000..38cb612--- /dev/null+++ b/tests/sidecar-binding-digest.test.ts@@ -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);+ });+});diff --git a/tests/sidecar-entangle-protect.test.ts b/tests/sidecar-entangle-protect.test.tsnew file mode 100644index 0000000..38d3fbd--- /dev/null+++ b/tests/sidecar-entangle-protect.test.ts@@ -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);+ });+});diff --git a/tests/sidecar-js-inject.test.ts b/tests/sidecar-js-inject.test.tsnew file mode 100644index 0000000..2642ce6--- /dev/null+++ b/tests/sidecar-js-inject.test.ts@@ -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 });+ }+ });+});