Skip to content

armgit / bla

Public Imported from GitHub
0

🛡️ 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.

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

qybaihecf2300d17bd6
diff --git a/tests/sidecar-binding-digest.test.ts b/tests/sidecar-binding-digest.test.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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 });
+ }
+ });
+});