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.

feat(lint): add lane-independence footgun heuristic and bla lint-lanes (#40.1)

qybaihe70b4a3f029a6
diff --git a/src/cli.ts b/src/cli.ts
index 38198e6..678e32d 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,5 +1,5 @@
#!/usr/bin/env node
-import { writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
import { resolve } from "node:path";
import { BLA_IDENTITY } from "./identity.js";
import { initBlaConfig, loadBlaConfig, resolveProjectSeed } from "./core/config.js";
@@ -11,6 +11,7 @@ import { protectTarget } from "./engine/protector.js";
import { verifyTarget } from "./engine/verifier.js";
import { defendTarget } from "./engine/defender.js";
import { formatHardenProjectReport, hardenProject } from "./engine/harden.js";
+import { lintLaneIndependence } from "./engine/lane-independence-lint.js";
import { runShowcaseBenchmark } from "./engine/benchmark.js";
import {
emitCompileTimeNativeHeader,
@@ -50,6 +51,7 @@ Commands:
defend <target> One-click full Counter-REA pipeline (inspect -> audit -> bankrupt protect -> verify)
inspect-release <target> Read-only local source-map & symbol exposure check
audit <target> Pre-flight REA exposure & vulnerability scan
+ lint-lanes <file> Heuristic warn if gate code looks lane-independent (issue #40.1)
protect <target> Inject multi-layer Counter-REA adversarial shield
verify <target> [original] Verify Counter-REA defense invariants & token amplification
benchmark Run the 14-target Counter-REA Showcase Benchmark suite
@@ -371,6 +373,29 @@ export async function runCli(argv: readonly string[] = process.argv.slice(2)): P
return report.overallSuccess ? 0 : 2;
}
+ case "lint-lanes": {
+ const target = parsed.positionals[0];
+ if (!target) {
+ console.error("Error: Missing <file> path for `bla lint-lanes <file>`.");
+ return 1;
+ }
+ const source = readFileSync(resolve(target), "utf8");
+ const report = lintLaneIndependence(source);
+ if (parsed.json) {
+ console.log(JSON.stringify(report, null, 2));
+ } else {
+ console.log(`BLA lane-independence lint β€” ${resolve(target)}`);
+ console.log(report.oneLineAdvice);
+ for (const f of report.findings) {
+ console.log(` [${f.severity}] ${f.id}: ${f.summary}`);
+ if (f.evidence) console.log(` evidence: ${f.evidence}`);
+ }
+ if (report.findings.length === 0) {
+ console.log(" (no findings)");
+ }
+ }
+ return report.looksLaneIndependent ? 2 : 0;
+ }
case "audit": {
const loaded = loadBlaConfig(process.cwd(), parsed.configPath);
const target = parsed.positionals[0] ?? loaded.config.input;
diff --git a/src/engine/lane-independence-lint.ts b/src/engine/lane-independence-lint.ts
new file mode 100644
index 0000000..ee7f6d1
--- /dev/null
+++ b/src/engine/lane-independence-lint.ts
@@ -0,0 +1,97 @@
+/**
+ * Lane-independence footgun lint (issue #40.1).
+ *
+ * Heuristic, defensive-only warning when customer gate code looks like
+ * independent per-lane checks (e.g. an array of single-byte compares combined
+ * with a shallow AND/OR reduction). Meridian / good designs use chained
+ * whole-key mixing so no per-lane oracle exists.
+ *
+ * This does NOT give reverse-engineering advice. It only flags a structural
+ * pattern that historically collapses search cost.
+ */
+
+export const LANE_INDEPENDENCE_SCHEMA = "bla-lane-independence-lint/v1" as const;
+
+export type LaneIndependenceFindingId =
+ | "per-lane-byte-compare-array"
+ | "independent-lane-and-reduce"
+ | "indexed-lane-oracle-loop";
+
+export interface LaneIndependenceFinding {
+ readonly id: LaneIndependenceFindingId;
+ readonly severity: "warn";
+ readonly summary: string;
+ readonly evidence: string;
+}
+
+export interface LaneIndependenceReport {
+ readonly schema: typeof LANE_INDEPENDENCE_SCHEMA;
+ readonly findings: readonly LaneIndependenceFinding[];
+ readonly looksLaneIndependent: boolean;
+ readonly oneLineAdvice: string;
+}
+
+const BYTE_COMPARE_ARRAY =
+ /\[\s*(?:0x[0-9a-fA-F]+|\d+)\s*(?:,\s*(?:0x[0-9a-fA-F]+|\d+)\s*){3,}\]/;
+
+const LANE_AND_REDUCE =
+ /(?:lanes?|bytes?|parts?|chunks?)\s*(?:\.every\s*\(|\.all\s*\(|\.reduce\s*\([^)]*(?:&&|\band\b))/i;
+
+/** `.every` / `.all` near a lanes[i]-style indexed compare β€” independent checks. */
+const EVERY_INDEXED_LANE =
+ /\.every\s*\([\s\S]{0,200}(?:lanes?|targets?|expect)\s*\[\s*[\w$]+\s*\]/i;
+
+const INDEXED_ORACLE =
+ /for\s*\(\s*(?:let|var|const)\s+\w+\s*=\s*0[^)]*\)\s*\{[^}]{0,200}(?:key|input|guess)\s*\[\s*\w+\s*\][^}]{0,120}===\s*(?:target|expect|lane|ref)/i;
+
+/**
+ * Scan UTF-8 source (JS/TS/Python-like) for lane-independence footguns.
+ * Returns findings with severity "warn" only β€” never fails closed.
+ */
+export function lintLaneIndependence(source: string): LaneIndependenceReport {
+ const findings: LaneIndependenceFinding[] = [];
+ const text = source.length > 400_000 ? source.slice(0, 400_000) : source;
+
+ if (BYTE_COMPARE_ARRAY.test(text) && /(?:key|guess|input|lane)/i.test(text)) {
+ const m = text.match(BYTE_COMPARE_ARRAY);
+ findings.push({
+ id: "per-lane-byte-compare-array",
+ severity: "warn",
+ summary:
+ "Literal multi-byte compare table near key/guess identifiers β€” may allow independent per-lane probes.",
+ evidence: (m?.[0] ?? "").slice(0, 80),
+ });
+ }
+
+ if (LANE_AND_REDUCE.test(text) || EVERY_INDEXED_LANE.test(text)) {
+ const m = text.match(LANE_AND_REDUCE) ?? text.match(EVERY_INDEXED_LANE);
+ findings.push({
+ id: "independent-lane-and-reduce",
+ severity: "warn",
+ summary:
+ "Lane/byte collection reduced with every/all/AND β€” suggests independent lane checks without whole-key mixing.",
+ evidence: (m?.[0] ?? "").slice(0, 80),
+ });
+ }
+
+ if (INDEXED_ORACLE.test(text)) {
+ const m = text.match(INDEXED_ORACLE);
+ findings.push({
+ id: "indexed-lane-oracle-loop",
+ severity: "warn",
+ summary:
+ "Indexed loop comparing key[i] to a per-lane target β€” classic independent-lane oracle shape.",
+ evidence: (m?.[0] ?? "").slice(0, 120),
+ });
+ }
+
+ return {
+ schema: LANE_INDEPENDENCE_SCHEMA,
+ findings,
+ looksLaneIndependent: findings.length > 0,
+ oneLineAdvice:
+ findings.length === 0
+ ? "No lane-independence footgun pattern detected (heuristic)."
+ : "Prefer whole-key chained mixing (no per-lane oracle). See issue #40.1 / Meridian DESIGN β€” defensive guidance only.",
+ };
+}
diff --git a/tests/lane-independence-lint.test.ts b/tests/lane-independence-lint.test.ts
new file mode 100644
index 0000000..6c1120b
--- /dev/null
+++ b/tests/lane-independence-lint.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { lintLaneIndependence } from "../src/engine/lane-independence-lint.js";
+
+describe("lane-independence footgun lint (#40.1)", () => {
+ it("stays quiet on chained whole-key mixing (Meridian-like)", () => {
+ const src = `
+ function activate(key) {
+ let a = pack(key.slice(0,5)), b = pack(key.slice(5,10));
+ let c = pack(key.slice(10,15)), d = pack(key.slice(15,20));
+ for (let r = 0; r < 24; r++) {
+ a = (a + b) | 0; b = rotl(b ^ a, 7);
+ c = (c + d) | 0; d = rotl(d ^ c, 9);
+ a ^= c; b ^= d;
+ }
+ return hex(a,b,c,d) === catalog.revision;
+ }
+ `;
+ const report = lintLaneIndependence(src);
+ expect(report.looksLaneIndependent).toBe(false);
+ expect(report.findings).toHaveLength(0);
+ });
+
+ it("warns on per-lane byte compare table + key identifiers", () => {
+ const src = `
+ const lanes = [0x41, 0x42, 0x43, 0x44, 0x45];
+ function check(key) {
+ return key.split("").every((ch, i) => ch.charCodeAt(0) === lanes[i]);
+ }
+ `;
+ const report = lintLaneIndependence(src);
+ expect(report.looksLaneIndependent).toBe(true);
+ expect(report.findings.some((f) => f.id === "per-lane-byte-compare-array")).toBe(true);
+ expect(report.findings.some((f) => f.id === "independent-lane-and-reduce")).toBe(true);
+ expect(report.oneLineAdvice).toMatch(/whole-key chained mixing/i);
+
+ const explicit = lintLaneIndependence(`
+ const lanes = [1,2,3,4];
+ const ok = lanes.every((b) => b > 0);
+ `);
+ expect(explicit.findings.some((f) => f.id === "independent-lane-and-reduce")).toBe(true);
+ });
+
+ it("warns on indexed lane oracle loops", () => {
+ const src = `
+ for (let i = 0; i < 16; i++) {
+ if (key[i] === target[i]) ok++;
+ }
+ `;
+ const report = lintLaneIndependence(src);
+ expect(report.findings.some((f) => f.id === "indexed-lane-oracle-loop")).toBe(true);
+ });
+});