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.

fix(js): strengthen opaque-predicate seed to ~28-bit PRNG material (#40.4)

qybaihe4aa9e05cea81
diff --git a/src/shields/javascript/ast-shield.ts b/src/shields/javascript/ast-shield.ts
index 1848f70..3416178 100644
--- a/src/shields/javascript/ast-shield.ts
+++ b/src/shields/javascript/ast-shield.ts
@@ -1099,10 +1099,13 @@ export function transformJavaScriptWithBlaShield(
selfSealEnabled = true;
selfSealBindingName = seal.bindingName;
}
- // Deterministic opaque-predicate seed (issue #40): never hrtime/Date.now.
- // Keep the low bit entangled with cognitive-armor digest so tamper flips seed parity.
+ // Deterministic opaque-predicate seed (issue #40.4): never hrtime/Date.now/bit0-only.
+ // Draw ~28 bits of PRNG material (two draws xor'd) so weak hrtime/bit0 patterns
+ // cannot be guessed; keep low bit free for cognitive-armor entanglement.
// When self-seal is on, also fold the integrity digest into the seed material.
- const opaqueSeedBase = (prng.nextInt(1, 0x1ffff) << 2) & 0x7fffc;
+ const opaqueSeedHi = prng.nextUint32() >>> 0;
+ const opaqueSeedLo = prng.nextUint32() >>> 0;
+ const opaqueSeedBase = ((opaqueSeedHi ^ (opaqueSeedLo << 1)) & 0xfffffffe) >>> 0;
const selfSealFold =
selfSealEnabled && selfSealBindingName
? ` ^ ((${selfSealBindingName} >>> 0) & 0xfffffffe)`
diff --git a/src/shields/tarpit/opaque-predicates.ts b/src/shields/tarpit/opaque-predicates.ts
index 057dd31..4f0c0c8 100644
--- a/src/shields/tarpit/opaque-predicates.ts
+++ b/src/shields/tarpit/opaque-predicates.ts
@@ -41,3 +41,20 @@ export function generatePythonOpaqueFalseExpression(prng: SeededPrng, seedVar =
const k = prng.nextInt(3, 97);
return `(((7 * ((${seedVar} | ${k}) ** 2) - 1) & 0xFFFFFFFF) == (((${seedVar} ^ ${k + 3}) ** 2) & 0xFFFFFFFF) and ((${seedVar} * (${seedVar} + 1)) & 1) == 1)`;
}
+
+/**
+ * Recommended opaque-seed binding strength (issue #40.4).
+ * Callers should draw >= 28 bits of PRNG material and reserve bit0 for
+ * integrity entanglement — never Date.now / hrtime / constant bit0.
+ */
+export function recommendOpaqueSeedBinding(): {
+ readonly minEntropyBits: number;
+ readonly forbid: readonly string[];
+ readonly reserveLowBitForIntegrity: boolean;
+} {
+ return {
+ minEntropyBits: 28,
+ forbid: ["Date.now", "performance.now", "process.hrtime", "Math.random"],
+ reserveLowBitForIntegrity: true,
+ };
+}
diff --git a/tests/opaque-seed-strength.test.ts b/tests/opaque-seed-strength.test.ts
new file mode 100644
index 0000000..152e6bd
--- /dev/null
+++ b/tests/opaque-seed-strength.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { transformJavaScriptWithBlaShield } from "../src/shields/javascript/ast-shield.js";
+import { recommendOpaqueSeedBinding } from "../src/shields/tarpit/opaque-predicates.js";
+
+describe("opaque-predicate seed strength (#40.4)", () => {
+ it("recommendOpaqueSeedBinding forbids hrtime/Date.now and asks for >=28 bits", () => {
+ const rec = recommendOpaqueSeedBinding();
+ expect(rec.minEntropyBits).toBeGreaterThanOrEqual(28);
+ expect(rec.reserveLowBitForIntegrity).toBe(true);
+ expect(rec.forbid).toEqual(
+ expect.arrayContaining(["Date.now", "process.hrtime", "Math.random"]),
+ );
+ });
+
+ it("AST shield opaque seed is a wide deterministic integer, not hrtime/bit0-only", () => {
+ const src = "export function f(n){ return n + 1; }\n";
+ const out = transformJavaScriptWithBlaShield(src, {
+ intensity: "balanced",
+ seed: "opaque-strength-1",
+ });
+ expect(out.code).not.toMatch(/hrtime/);
+ expect(out.code).not.toMatch(/Date\.now\s*\(/);
+ expect(out.code).not.toMatch(/performance\.now\s*\(/);
+ // Opaque seed is a wide deterministic integer OR'd with integrity bit (not 0/1-only).
+ const seedLit = out.code.match(
+ /const\s+\w+\s*=\s*(?:\(\()?(\d{3,})\s*(?:\)|\|)/,
+ );
+ expect(seedLit).toBeTruthy();
+ const n = Number(seedLit![1]);
+ expect(n).toBeGreaterThan(0xff);
+ // Deterministic across runs
+ const out2 = transformJavaScriptWithBlaShield(src, {
+ intensity: "balanced",
+ seed: "opaque-strength-1",
+ });
+ expect(out2.code).toBe(out.code);
+ });
+});