π‘οΈ 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
feat(lint): add lane-independence footgun heuristic and bla lint-lanes (#40.1)
qybaihe70b4a3f029a6
diff --git a/src/cli.ts b/src/cli.tsindex 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 checkaudit <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 shieldverify <target> [original] Verify Counter-REA defense invariants & token amplificationbenchmark Run the 14-target Counter-REA Showcase Benchmark suite@@ -371,6 +373,29 @@ export async function runCli(argv: readonly string[] = process.argv.slice(2)): Preturn 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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);+ });+});