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(core): cover detector, prng, identifiers, sarif, llm-directives, reporter and python

DeryFerd1114712ac80f
diff --git a/tests/core-domain.test.ts b/tests/core-domain.test.ts
new file mode 100644
index 0000000..7ebc5ff
--- /dev/null
+++ b/tests/core-domain.test.ts
@@ -0,0 +1,176 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { detectArtifactFormat } from "../src/core/detector.js";
+import { SeededPrng } from "../src/core/prng.js";
+import { buildSarifReport } from "../src/core/sarif.js";
+import { auditTarget } from "../src/engine/auditor.js";
+import { areLlmDirectivesEnabled, withLlmDirectives } from "../src/core/llm-directives.js";
+import {
+ assertNoForbiddenMarkers,
+ realisticIdentifier,
+ realisticIdentifierBatch,
+} from "../src/core/identifiers.js";
+import { formatBanner, formatAuditReport } from "../src/ui/reporter.js";
+import { findPythonPrologueInsertionOffset, protectPythonSource } from "../src/shields/formats/python.js";
+
+describe("core domain modules previously without dedicated tests", () => {
+ describe("detector", () => {
+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bla-detector-"));
+ afterEach(() => {
+ fs.rmSync(dir, { recursive: true, force: true });
+ });
+ it("routes extension-only and magic-byte targets to the right format", () => {
+ const py = path.join(dir, "app.py");
+ const wasm = path.join(dir, "core.wasm");
+ const sqlite = path.join(dir, "db.sqlite");
+ const missing = path.join(dir, "nope.xyz");
+ fs.writeFileSync(py, "x = 1\n", "utf8");
+ fs.writeFileSync(wasm, Buffer.from([0x00, 0x61, 0x73, 0x6d]), "utf8");
+ fs.writeFileSync(sqlite, Buffer.from("SQLite format 3\0"), "utf8");
+ fs.mkdirSync(path.join(dir, "sub"));
+
+ expect(detectArtifactFormat(py)).toBe("python-source");
+ expect(detectArtifactFormat(wasm)).toBe("wasm");
+ expect(detectArtifactFormat(sqlite)).toBe("sqlite");
+ expect(detectArtifactFormat(missing)).toBe("unknown");
+ expect(detectArtifactFormat(path.join(dir, "sub"))).toBe("directory");
+ });
+ });
+
+ describe("SeededPrng", () => {
+ it("is deterministic per seed and diverges across seeds", () => {
+ const a = new SeededPrng("seed-one");
+ const b = new SeededPrng("seed-one");
+ const c = new SeededPrng("seed-two");
+
+ const seqA = Array.from({ length: 5 }, () => a.nextUint32());
+ expect(Array.from({ length: 5 }, () => b.nextUint32())).toEqual(seqA);
+ const seqC = Array.from({ length: 5 }, () => c.nextUint32());
+ expect(seqC).not.toEqual(seqA);
+
+ for (let i = 0; i < 1000; i++) {
+ expect(a.nextInt(0, 0)).toBe(0);
+ const rolled = a.nextInt(1, 6);
+ expect(rolled).toBeGreaterThanOrEqual(1);
+ expect(rolled).toBeLessThanOrEqual(6);
+ }
+ expect(a.nextInt(5, 5)).toBe(5);
+ });
+
+ it("picks members, shuffles without loss, and hex is fixed-length", () => {
+ const p = new SeededPrng("pick");
+ expect(p.pick(["a", "b", "c"])).toMatch(/^[abc]$/);
+ const items = [1, 2, 3, 4, 5];
+ expect(p.shuffle(items).sort()).toEqual(items);
+ expect(p.shuffle(items)).not.toEqual(items); // overwhelmingly likely
+ expect(p.hex(4)).toMatch(/^[0-9a-f]{4}$/);
+ });
+ });
+
+ describe("identifiers", () => {
+ const prng = new SeededPrng("ident");
+
+ it("renders a valid identifier with hint sanitization", () => {
+ const id = realisticIdentifier(prng, {
+ style: "camel",
+ hint: "customer-def! Weird",
+ });
+ expect(id).toMatch(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
+ // hint specials are stripped
+ expect(id).toContain("customerdef");
+ expect(id).not.toContain("!");
+ });
+
+ it("draws unique batches", () => {
+ const batch = realisticIdentifierBatch(new SeededPrng("batch"), 25, {
+ style: "snake",
+ });
+ expect(batch.length).toBe(25);
+ expect(new Set(batch).size).toBe(25);
+ });
+
+ it("rejects forbidden emitted markers", () => {
+ expect(() => assertNoForbiddenMarkers("safe_customer_def")).not.toThrow();
+ expect(() => assertNoForbiddenMarkers("nope _bla x")).toThrow();
+ expect(() => assertNoForbiddenMarkers("nope __bla x")).toThrow();
+ // legacy greppable placeholder is also forbidden
+ expect(() => assertNoForbiddenMarkers("clean $00_AAA")).toThrow();
+ });
+ });
+
+ describe("sarif", () => {
+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bla-sarif-"));
+ afterEach(() => {
+ fs.rmSync(dir, { recursive: true, force: true });
+ });
+ it("builds a valid SARIF 2.1.0 document for an audit report", () => {
+ const target = path.join(dir, "mod.js");
+ fs.writeFileSync(target, "export const magic = 414141;\n", "utf8");
+ const report = auditTarget(target);
+ const sarif = buildSarifReport(report);
+
+ expect(sarif.version).toBe("2.1.0");
+ expect(Array.isArray(sarif.runs)).toBe(true);
+ expect(sarif.runs[0].tool.driver.name).toBeDefined();
+ expect(Array.isArray(sarif.runs[0].results)).toBe(true);
+ expect(typeof sarif.runs[0].tool.driver.version).toBe("string");
+ });
+ });
+
+ describe("llm-directives", () => {
+ it("defaults OFF and restores stack on nested scope exit", () => {
+ expect(areLlmDirectivesEnabled()).toBe(false);
+
+ withLlmDirectives(true, () => {
+ expect(areLlmDirectivesEnabled()).toBe(true);
+ withLlmDirectives(false, () => {
+ expect(areLlmDirectivesEnabled()).toBe(false);
+ });
+ expect(areLlmDirectivesEnabled()).toBe(true);
+ });
+ expect(areLlmDirectivesEnabled()).toBe(false);
+ });
+ });
+
+ describe("reporter", () => {
+ it("formats banner and audit report without throwing", () => {
+ const banner = formatBanner();
+ expect(typeof banner).toBe("string");
+ expect(banner.length).toBeGreaterThan(0);
+
+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bla-report-"));
+ const target = path.join(dir, "x.py");
+ fs.writeFileSync(target, "x = 1\n", "utf8");
+ const report = auditTarget(target);
+ const text = formatAuditReport(report);
+ expect(typeof text).toBe("string");
+ expect(text.length).toBeGreaterThan(0);
+ fs.rmSync(dir, { recursive: true, force: true });
+ });
+ });
+
+ describe("python", () => {
+ const source =
+ '"""Module docstring."""\nfrom __future__ import annotations\nx = 1\ndef f(): return x\n';
+
+ it("finds prologue insertion offset after docstring and future imports", () => {
+ const analysis = findPythonPrologueInsertionOffset(source);
+ expect(analysis.hasDocstring).toBe(true);
+ expect(analysis.futureImports.length).toBeGreaterThanOrEqual(1);
+ expect(analysis.futureImports.join("\n")).toContain("annotations");
+ expect(analysis.insertOffset).toBeGreaterThan(0);
+ expect(analysis.insertOffset).toBeLessThan(source.length);
+ });
+
+ it("protects source deterministically per seed and keeps customer code", () => {
+ const a = protectPythonSource(source, { seed: "py-one" });
+ const b = protectPythonSource(source, { seed: "py-one" });
+ expect(a.code).toContain("x = 1");
+ expect(a.code).toContain("def f(): return x");
+ expect(a.decoyFunctionsInjected).toBeGreaterThanOrEqual(0);
+ expect(b.code).toBe(a.code);
+ });
+ });
+});