🛡️ 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(2.0): unified packaging-gates pipeline (bla lint / bla_lint)
qybaihefd49dd1c059b
diff --git a/src/cli.ts b/src/cli.tsindex 9d6d832..e41f34c 100644--- a/src/cli.ts+++ b/src/cli.ts@@ -19,6 +19,10 @@ import { lintJsAesUnwrapFile } from "./engine/js-aes-unwrap-lint.js";import { lintJsWasmHydrateDumpFile } from "./engine/js-wasm-hydrate-dump-lint.js";import { lintWasmXorMaskSidecarFile } from "./engine/wasm-xor-mask-sidecar-lint.js";import { lintWasmSealXorKnownPlaintextFile } from "./engine/wasm-seal-xor-known-plaintext-lint.js";+import {+ scanPackagingGates,+ formatPackagingGatesReport,+} from "./engine/packaging-gates.js";import { runShowcaseBenchmark } from "./engine/benchmark.js";import {emitCompileTimeNativeHeader,@@ -58,6 +62,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 [dir] DEFAULT packaging gate scan (all R1–R7 refuse lints + lanes/panel); exit 2 on refuselint-lanes <file> Heuristic ERROR if gate code looks lane-independent (issue #40.1); exit 2lint-wasm-params <file> Heuristic ERROR if WASM embeds clear R3PARM/R3CIPH/R2SEAL-class carriers; exit 2lint-panel-derive <file> Heuristic ERROR if stable __vaultPanelDerive_* / deriveLocal oracle remains; exit 2@@ -523,6 +528,41 @@ export async function runCli(argv: readonly string[] = process.argv.slice(2)): Preturn report.overallSuccess ? 0 : 2;}+ case "lint": {+ const target = parsed.positionals[0] ?? ".";+ const report = scanPackagingGates({+ directory: resolve(target),+ intensity: (parsed.intensity as "stealth" | "balanced" | "maximum" | "bankrupt") ?? "bankrupt",+ allowPlaintextSeal: parsed.allowPlaintextSeal,+ allowWasmClearParamCarriers: parsed.allowWasmClearParamCarriers,+ allowJsAesUnwrap: parsed.allowJsAesUnwrap,+ allowJsWasmHydrateDump: parsed.allowJsWasmHydrateDump,+ allowWasmXorMaskSidecar: parsed.allowWasmXorMaskSidecar,+ allowWasmSealXorKnownPlaintext: parsed.allowWasmSealXorKnownPlaintext,+ allowLaneIndependentGates: parsed.allowLaneIndependentGates,+ allowPanelOfflineOracle: parsed.allowPanelOfflineOracle,+ allowStablePanelDeriveAbi: parsed.allowStablePanelDeriveAbi,+ includeProtectTimeGates: true,+ });+ if (parsed.json) {+ // Strip heavy details.details raw blobs for CLI JSON by default — keep findings/blocking.+ const { details: _details, ...compact } = report;+ console.log(JSON.stringify({ ...compact, detailCounts: {+ seals: report.details.seals.length,+ wasmParams: report.details.wasmParams.length,+ jsAes: report.details.jsAes.length,+ jsHydrateDump: report.details.jsHydrateDump.length,+ wasmXorMask: report.details.wasmXorMask.length,+ wasmSealXor: report.details.wasmSealXor.length,+ lanes: report.details.lanes.length,+ panelDerive: report.details.panelDerive.length,+ } }, null, 2));+ } else {+ console.log(formatPackagingGatesReport(report));+ }+ return report.shouldRefuseBankrupt ? 2 : 0;+ }+case "lint-lanes": {const target = parsed.positionals[0];if (!target) {diff --git a/src/core/types.ts b/src/core/types.tsindex 3c63742..87c92d3 100644--- a/src/core/types.ts+++ b/src/core/types.ts@@ -248,6 +248,10 @@ export interface ProtectionResult {readonly selfSeal?: boolean;/** Present when WASM export rename actually rewrote at least one non-preserved export (#40.3). */readonly wasmExportRenameApplied?: boolean;+ /** Present when WASM export-section order was seed-shuffled (red-blue round-11). */+ readonly wasmExportOrderShuffled?: boolean;+ /** Count of long-name decoy export aliases injected (red-blue round-10/12 hygiene). */+ readonly wasmExportDecoysInjected?: number;readonly seed: string;readonly originalSha256: string;readonly protectedSha256: string;diff --git a/src/engine/harden.ts b/src/engine/harden.tsindex 70a90bc..032e807 100644--- a/src/engine/harden.ts+++ b/src/engine/harden.ts@@ -14,35 +14,26 @@ import {type OneClickDefenseReport,} from "./defender.js";import {- discoverAndLintSealSidecars,- intensityEnforcesSealRefusal,sealCommitmentRefuseMessage,} from "./seal-commitment-lint.js";import {- discoverAndLintWasmParamCarriers,- intensityEnforcesWasmParamRefusal,wasmParamCarrierRefuseMessage,} from "./wasm-param-carrier-lint.js";import {- discoverAndLintJsAesUnwrap,- intensityEnforcesJsAesUnwrapRefusal,jsAesUnwrapRefuseMessage,} from "./js-aes-unwrap-lint.js";import {- discoverAndLintJsWasmHydrateDump,- intensityEnforcesJsWasmHydrateDumpRefusal,jsWasmHydrateDumpRefuseMessage,} from "./js-wasm-hydrate-dump-lint.js";import {- discoverAndLintWasmXorMaskSidecars,- intensityEnforcesWasmXorMaskSidecarRefusal,wasmXorMaskSidecarRefuseMessage,} from "./wasm-xor-mask-sidecar-lint.js";import {- discoverAndLintWasmSealXorKnownPlaintext,- intensityEnforcesWasmSealXorKnownPlaintextRefusal,wasmSealXorKnownPlaintextRefuseMessage,} from "./wasm-seal-xor-known-plaintext-lint.js";+import {+ evaluateHardenProjectPackagingBlocks,+} from "./packaging-gates.js";import {computeHardenRunId,HARDEN_SUMMARY_FILE_NAME,@@ -381,41 +372,22 @@ export function hardenProject(const discovery = discoverHardenTargets(absDir, { maxArtifacts });const discovered = discovery.artifacts;- const sealReports = discoverAndLintSealSidecars(absDir);- const blockingSeals =- intensityEnforcesSealRefusal(intensity) && options.allowPlaintextSeal !== true- ? sealReports.filter((r) => r.shouldRefuseBankrupt)- : [];- const wasmParmReports = discoverAndLintWasmParamCarriers(absDir);- const blockingWasmParms =- intensityEnforcesWasmParamRefusal(intensity) &&- options.allowWasmClearParamCarriers !== true- ? wasmParmReports.filter((r) => r.shouldRefuseBankrupt)- : [];- const jsAesReports = discoverAndLintJsAesUnwrap(absDir);- const blockingJsAes =- intensityEnforcesJsAesUnwrapRefusal(intensity) &&- options.allowJsAesUnwrap !== true- ? jsAesReports.filter((r) => r.shouldRefuseBankrupt)- : [];- const jsHydrateDumpReports = discoverAndLintJsWasmHydrateDump(absDir);- const blockingJsHydrateDump =- intensityEnforcesJsWasmHydrateDumpRefusal(intensity) &&- options.allowJsWasmHydrateDump !== true- ? jsHydrateDumpReports.filter((r) => r.shouldRefuseBankrupt)- : [];- const wasmXorMaskReports = discoverAndLintWasmXorMaskSidecars(absDir);- const blockingWasmXorMask =- intensityEnforcesWasmXorMaskSidecarRefusal(intensity) &&- options.allowWasmXorMaskSidecar !== true- ? wasmXorMaskReports.filter((r) => r.shouldRefuseBankrupt)- : [];- const wasmSealXorReports = discoverAndLintWasmSealXorKnownPlaintext(absDir);- const blockingWasmSealXor =- intensityEnforcesWasmSealXorKnownPlaintextRefusal(intensity) &&- options.allowWasmSealXorKnownPlaintext !== true- ? wasmSealXorReports.filter((r) => r.shouldRefuseBankrupt)- : [];+ const packagingBlocks = evaluateHardenProjectPackagingBlocks({+ directory: absDir,+ intensity,+ allowPlaintextSeal: options.allowPlaintextSeal,+ allowWasmClearParamCarriers: options.allowWasmClearParamCarriers,+ allowJsAesUnwrap: options.allowJsAesUnwrap,+ allowJsWasmHydrateDump: options.allowJsWasmHydrateDump,+ allowWasmXorMaskSidecar: options.allowWasmXorMaskSidecar,+ allowWasmSealXorKnownPlaintext: options.allowWasmSealXorKnownPlaintext,+ });+ const blockingSeals = packagingBlocks.blockingSeals;+ const blockingWasmParms = packagingBlocks.blockingWasmParms;+ const blockingJsAes = packagingBlocks.blockingJsAes;+ const blockingJsHydrateDump = packagingBlocks.blockingJsHydrateDump;+ const blockingWasmXorMask = packagingBlocks.blockingWasmXorMask;+ const blockingWasmSealXor = packagingBlocks.blockingWasmSealXor;const outputRoot = resolve(options.outputDirectory ??(statSync(absDir).isDirectory()diff --git a/src/engine/lane-independence-lint.ts b/src/engine/lane-independence-lint.tsindex 6a60e20..9449d10 100644--- a/src/engine/lane-independence-lint.ts+++ b/src/engine/lane-independence-lint.ts@@ -11,6 +11,10 @@* This does NOT give reverse-engineering advice.*/++import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";+import { join, resolve } from "node:path";+export const LANE_INDEPENDENCE_SCHEMA = "bla-lane-independence-lint/v1" as const;export type LaneIndependenceFindingId =@@ -161,3 +165,74 @@ export function laneIndependenceRefuseMessage(`pass allowLaneIndependentGates / --allow-lane-independent / allow_lane_independent:true.`);}++const SKIP_DIR_NAMES = new Set([+ "node_modules",+ ".git",+ ".hg",+ ".svn",+ ".bla-hardened",+ "coverage",+ ".turbo",+ ".cache",+ "__pycache__",+ ".venv",+ "venv",+]);++const JS_EXT = /\.(?:[cm]?[jt]s|tsx?)$/i;+const MAX_JS_FILES = 64;+const MAX_WALK_DEPTH = 8;++function walkJsGateCandidates(dir: string, depth: number, out: string[]): void {+ if (out.length >= MAX_JS_FILES || depth > MAX_WALK_DEPTH) return;+ let entries;+ try {+ entries = readdirSync(dir, { withFileTypes: true });+ } catch {+ return;+ }+ for (const entry of entries) {+ if (out.length >= MAX_JS_FILES) return;+ if (entry.isDirectory()) {+ if (SKIP_DIR_NAMES.has(entry.name) || entry.name.startsWith(".")) continue;+ walkJsGateCandidates(join(dir, entry.name), depth + 1, out);+ continue;+ }+ if (!entry.isFile()) continue;+ if (!JS_EXT.test(entry.name)) continue;+ out.push(join(dir, entry.name));+ }+}++/** File wrapper matching other packaging lints. */+export function lintLaneIndependenceFile(filePath: string): LaneIndependenceReport & {+ readonly path: string;+} {+ const abs = resolve(filePath);+ if (!existsSync(abs)) {+ throw new Error(`lane-independence target not found: ${abs}`);+ }+ const report = lintLaneIndependence(readFileSync(abs, "utf8"));+ return { ...report, path: abs };+}++/**+ * Discover JS/TS under a directory and lint each for lane-independence footguns.+ * Used by unified `bla lint` / packaging-gates (protect still refuses per-file).+ */+export function discoverAndLintLaneIndependence(+ directory: string,+): ReadonlyArray<LaneIndependenceReport & { readonly path: string }> {+ const abs = resolve(directory);+ if (!existsSync(abs)) {+ throw new Error(`Path not found: ${abs}`);+ }+ const st = statSync(abs);+ if (st.isFile()) {+ return [lintLaneIndependenceFile(abs)];+ }+ const candidates: string[] = [];+ walkJsGateCandidates(abs, 0, candidates);+ return candidates.map((p) => lintLaneIndependenceFile(p));+}diff --git a/src/engine/packaging-gates.ts b/src/engine/packaging-gates.tsnew file mode 100644index 0000000..9f6076a--- /dev/null+++ b/src/engine/packaging-gates.ts@@ -0,0 +1,478 @@+/**+ * Unified packaging-footgun gate pipeline (red-blue R1–R12 → BLA 2.0).+ *+ * Aggregates every bankrupt refuse lint that harden already runs at project+ * level, plus advisory lane / panel-derive discovery (protect still refuses+ * those per-file). Agents call this via `bla lint` / MCP `bla_lint` instead of+ * eight separate tools.+ *+ * Honesty: gates close *packaging* footguns. They do **not** claim white-box+ * secrecy against full WASM RE / online guessing / SMT (R8–R12 residual).+ */++import { basename, relative, resolve, sep } from "node:path";+import type { ProtectionIntensity } from "../core/types.js";+import {+ discoverAndLintSealSidecars,+ intensityEnforcesSealRefusal,+ sealCommitmentRefuseMessage,+ type SealCommitmentReport,+} from "./seal-commitment-lint.js";+import {+ discoverAndLintWasmParamCarriers,+ intensityEnforcesWasmParamRefusal,+ wasmParamCarrierRefuseMessage,+ type WasmParamCarrierReport,+} from "./wasm-param-carrier-lint.js";+import {+ discoverAndLintJsAesUnwrap,+ intensityEnforcesJsAesUnwrapRefusal,+ jsAesUnwrapRefuseMessage,+ type JsAesUnwrapReport,+} from "./js-aes-unwrap-lint.js";+import {+ discoverAndLintJsWasmHydrateDump,+ intensityEnforcesJsWasmHydrateDumpRefusal,+ jsWasmHydrateDumpRefuseMessage,+ type JsWasmHydrateDumpReport,+} from "./js-wasm-hydrate-dump-lint.js";+import {+ discoverAndLintWasmXorMaskSidecars,+ intensityEnforcesWasmXorMaskSidecarRefusal,+ wasmXorMaskSidecarRefuseMessage,+ type WasmXorMaskSidecarReport,+} from "./wasm-xor-mask-sidecar-lint.js";+import {+ discoverAndLintWasmSealXorKnownPlaintext,+ intensityEnforcesWasmSealXorKnownPlaintextRefusal,+ wasmSealXorKnownPlaintextRefuseMessage,+ type WasmSealXorKnownPlaintextReport,+} from "./wasm-seal-xor-known-plaintext-lint.js";+import {+ discoverAndLintLaneIndependence,+ laneIndependenceRefuseMessage,+ type LaneIndependenceReport,+} from "./lane-independence-lint.js";+import {+ discoverAndLintPanelDerive,+ intensityEnforcesPanelOracleRefusal,+ panelDeriveRefuseMessage,+ type PanelDeriveAbiReport,+} from "./panel-derive-abi-lint.js";++export const PACKAGING_GATES_SCHEMA = "bla-packaging-gates/v1" as const;++export type PackagingGateId =+ | "seal-commitment"+ | "wasm-param-carrier"+ | "js-aes-unwrap"+ | "js-wasm-hydrate-dump"+ | "wasm-xor-mask-sidecar"+ | "wasm-seal-xor-known-plaintext"+ | "lane-independence"+ | "panel-derive";++export interface PackagingGateFinding {+ readonly gate: PackagingGateId;+ readonly path: string;+ readonly relativePath: string;+ readonly shouldRefuseBankrupt: boolean;+ readonly refuseMessage?: string;+ readonly oneLineAdvice: string;+ readonly findingCount: number;+}++export interface PackagingGatesAllowOptions {+ readonly allowPlaintextSeal?: boolean;+ readonly allowWasmClearParamCarriers?: boolean;+ readonly allowJsAesUnwrap?: boolean;+ readonly allowJsWasmHydrateDump?: boolean;+ readonly allowWasmXorMaskSidecar?: boolean;+ readonly allowWasmSealXorKnownPlaintext?: boolean;+ readonly allowLaneIndependentGates?: boolean;+ readonly allowPanelOfflineOracle?: boolean;+ readonly allowStablePanelDeriveAbi?: boolean;+}++export interface PackagingGatesScanOptions extends PackagingGatesAllowOptions {+ readonly directory: string;+ /** Intensity used to decide which findings refuse bankrupt (default bankrupt). */+ readonly intensity?: ProtectionIntensity;+ /**+ * When true (default), also scan JS/HTML for lane-independence + panel-derive.+ * Harden project-level refuse historically used the six carrier/JS/WASM gates+ * only — lanes/panel stay protect-time unless includeProtectTimeGates.+ */+ readonly includeProtectTimeGates?: boolean;+}++export interface PackagingGatesReport {+ readonly schema: typeof PACKAGING_GATES_SCHEMA;+ readonly directory: string;+ readonly intensity: ProtectionIntensity;+ readonly findings: readonly PackagingGateFinding[];+ /** Findings that would refuse bankrupt/maximum under current allow flags. */+ readonly blocking: readonly PackagingGateFinding[];+ readonly shouldRefuseBankrupt: boolean;+ readonly gateCounts: Readonly<Record<PackagingGateId, number>>;+ readonly oneLineAdvice: string;+ readonly honestyNote: string;+ /** Raw per-gate reports for agents that need detail. */+ readonly details: {+ readonly seals: readonly SealCommitmentReport[];+ readonly wasmParams: readonly WasmParamCarrierReport[];+ readonly jsAes: readonly JsAesUnwrapReport[];+ readonly jsHydrateDump: readonly JsWasmHydrateDumpReport[];+ readonly wasmXorMask: readonly WasmXorMaskSidecarReport[];+ readonly wasmSealXor: readonly WasmSealXorKnownPlaintextReport[];+ readonly lanes: ReadonlyArray<LaneIndependenceReport & { readonly path: string }>;+ readonly panelDerive: readonly PanelDeriveAbiReport[];+ };+}++const HONESTY_NOTE =+ "Packaging gates close shipping footguns (R1–R7 refuse + R8–R12 engine hygiene). " ++ "They do not claim white-box secrecy against full WASM RE / online guessing / SMT.";++function relPath(absDir: string, filePath: string): string {+ return (relative(absDir, filePath) || basename(filePath)).split(sep).join("/");+}++function emptyCounts(): Record<PackagingGateId, number> {+ return {+ "seal-commitment": 0,+ "wasm-param-carrier": 0,+ "js-aes-unwrap": 0,+ "js-wasm-hydrate-dump": 0,+ "wasm-xor-mask-sidecar": 0,+ "wasm-seal-xor-known-plaintext": 0,+ "lane-independence": 0,+ "panel-derive": 0,+ };+}++/**+ * Scan a project (or file) for every packaging footgun lint.+ * Read-only — never writes.+ */+export function scanPackagingGates(+ options: PackagingGatesScanOptions,+): PackagingGatesReport {+ const absDir = resolve(options.directory);+ const intensity: ProtectionIntensity = options.intensity ?? "bankrupt";+ const includeProtectTime = options.includeProtectTimeGates !== false;++ const seals = discoverAndLintSealSidecars(absDir);+ const wasmParams = discoverAndLintWasmParamCarriers(absDir);+ const jsAes = discoverAndLintJsAesUnwrap(absDir);+ const jsHydrateDump = discoverAndLintJsWasmHydrateDump(absDir);+ const wasmXorMask = discoverAndLintWasmXorMaskSidecars(absDir);+ const wasmSealXor = discoverAndLintWasmSealXorKnownPlaintext(absDir);+ const lanes = includeProtectTime+ ? discoverAndLintLaneIndependence(absDir)+ : [];+ const panelDerive = includeProtectTime+ ? discoverAndLintPanelDerive(absDir)+ : [];++ const findings: PackagingGateFinding[] = [];+ const counts = emptyCounts();++ for (const r of seals) {+ if (r.findings.length === 0 && !r.shouldRefuseBankrupt) continue;+ counts["seal-commitment"] += 1;+ findings.push({+ gate: "seal-commitment",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: r.shouldRefuseBankrupt,+ refuseMessage: r.shouldRefuseBankrupt+ ? sealCommitmentRefuseMessage(r, r.path)+ : undefined,+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }+ for (const r of wasmParams) {+ if (r.findings.length === 0 && !r.shouldRefuseBankrupt) continue;+ counts["wasm-param-carrier"] += 1;+ findings.push({+ gate: "wasm-param-carrier",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: r.shouldRefuseBankrupt,+ refuseMessage: r.shouldRefuseBankrupt+ ? wasmParamCarrierRefuseMessage(r, r.path)+ : undefined,+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }+ for (const r of jsAes) {+ if (r.findings.length === 0 && !r.shouldRefuseBankrupt) continue;+ counts["js-aes-unwrap"] += 1;+ findings.push({+ gate: "js-aes-unwrap",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: r.shouldRefuseBankrupt,+ refuseMessage: r.shouldRefuseBankrupt+ ? jsAesUnwrapRefuseMessage(r, r.path)+ : undefined,+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }+ for (const r of jsHydrateDump) {+ if (r.findings.length === 0 && !r.shouldRefuseBankrupt) continue;+ counts["js-wasm-hydrate-dump"] += 1;+ findings.push({+ gate: "js-wasm-hydrate-dump",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: r.shouldRefuseBankrupt,+ refuseMessage: r.shouldRefuseBankrupt+ ? jsWasmHydrateDumpRefuseMessage(r, r.path)+ : undefined,+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }+ for (const r of wasmXorMask) {+ if (r.findings.length === 0 && !r.shouldRefuseBankrupt) continue;+ counts["wasm-xor-mask-sidecar"] += 1;+ findings.push({+ gate: "wasm-xor-mask-sidecar",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: r.shouldRefuseBankrupt,+ refuseMessage: r.shouldRefuseBankrupt+ ? wasmXorMaskSidecarRefuseMessage(r, r.path)+ : undefined,+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }+ for (const r of wasmSealXor) {+ if (r.findings.length === 0 && !r.shouldRefuseBankrupt) continue;+ counts["wasm-seal-xor-known-plaintext"] += 1;+ findings.push({+ gate: "wasm-seal-xor-known-plaintext",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: r.shouldRefuseBankrupt,+ refuseMessage: r.shouldRefuseBankrupt+ ? wasmSealXorKnownPlaintextRefuseMessage(r, r.path)+ : undefined,+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }+ for (const r of lanes) {+ if (!r.looksLaneIndependent) continue;+ counts["lane-independence"] += 1;+ findings.push({+ gate: "lane-independence",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: true,+ refuseMessage: laneIndependenceRefuseMessage(r, r.path),+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }+ for (const r of panelDerive) {+ const refuse =+ r.shouldRefuseBankrupt ||+ (r.stableSymbols.length > 0 || r.localDeriveSymbols.length > 0);+ if (r.findings.length === 0 && !refuse) continue;+ counts["panel-derive"] += 1;+ findings.push({+ gate: "panel-derive",+ path: r.path,+ relativePath: relPath(absDir, r.path),+ shouldRefuseBankrupt: r.shouldRefuseBankrupt,+ refuseMessage:+ r.shouldRefuseBankrupt || r.stableSymbols.length > 0+ ? panelDeriveRefuseMessage(r, r.path)+ : undefined,+ oneLineAdvice: r.oneLineAdvice,+ findingCount: r.findings.length,+ });+ }++ const blocking = filterBlockingFindings(findings, intensity, options);++ const oneLineAdvice =+ blocking.length === 0+ ? findings.length === 0+ ? "No packaging footgun findings (heuristic). Gates ≠ white-box secrecy."+ : `Packaging scan: ${findings.length} finding(s), none refuse under current intensity/allows.`+ : `ERROR: ${blocking.length} packaging gate(s) would refuse bankrupt harden. Fix or pass the matching --allow-* / allow_* flag (lab only).`;++ return {+ schema: PACKAGING_GATES_SCHEMA,+ directory: absDir,+ intensity,+ findings,+ blocking,+ shouldRefuseBankrupt: blocking.length > 0,+ gateCounts: counts,+ oneLineAdvice,+ honestyNote: HONESTY_NOTE,+ details: {+ seals,+ wasmParams,+ jsAes,+ jsHydrateDump,+ wasmXorMask,+ wasmSealXor,+ lanes,+ panelDerive,+ },+ };+}++function filterBlockingFindings(+ findings: readonly PackagingGateFinding[],+ intensity: ProtectionIntensity,+ allow: PackagingGatesAllowOptions,+): PackagingGateFinding[] {+ return findings.filter((f) => {+ if (!f.shouldRefuseBankrupt && f.gate !== "lane-independence") {+ // panel stable-ABI rewrite is not a harden project-level refuse today+ return false;+ }+ switch (f.gate) {+ case "seal-commitment":+ return intensityEnforcesSealRefusal(intensity) && allow.allowPlaintextSeal !== true;+ case "wasm-param-carrier":+ return (+ intensityEnforcesWasmParamRefusal(intensity) &&+ allow.allowWasmClearParamCarriers !== true+ );+ case "js-aes-unwrap":+ return (+ intensityEnforcesJsAesUnwrapRefusal(intensity) &&+ allow.allowJsAesUnwrap !== true+ );+ case "js-wasm-hydrate-dump":+ return (+ intensityEnforcesJsWasmHydrateDumpRefusal(intensity) &&+ allow.allowJsWasmHydrateDump !== true+ );+ case "wasm-xor-mask-sidecar":+ return (+ intensityEnforcesWasmXorMaskSidecarRefusal(intensity) &&+ allow.allowWasmXorMaskSidecar !== true+ );+ case "wasm-seal-xor-known-plaintext":+ return (+ intensityEnforcesWasmSealXorKnownPlaintextRefusal(intensity) &&+ allow.allowWasmSealXorKnownPlaintext !== true+ );+ case "lane-independence":+ // Project-level lint reports lanes; harden project refuse historically+ // left lanes to protect-time. Blocking list for `bla lint` treats them+ // as refuse-worthy so agents see the same footgun before harden.+ return allow.allowLaneIndependentGates !== true && f.shouldRefuseBankrupt;+ case "panel-derive":+ return (+ intensityEnforcesPanelOracleRefusal(intensity) &&+ allow.allowPanelOfflineOracle !== true &&+ f.shouldRefuseBankrupt+ );+ default:+ return false;+ }+ });+}++/**+ * Subset of packaging gates that hardenProject historically refuses at+ * project scope (excludes lane/panel — those remain protect-time).+ */+export function evaluateHardenProjectPackagingBlocks(+ options: PackagingGatesScanOptions,+): {+ readonly report: PackagingGatesReport;+ readonly blockingSeals: readonly SealCommitmentReport[];+ readonly blockingWasmParms: readonly WasmParamCarrierReport[];+ readonly blockingJsAes: readonly JsAesUnwrapReport[];+ readonly blockingJsHydrateDump: readonly JsWasmHydrateDumpReport[];+ readonly blockingWasmXorMask: readonly WasmXorMaskSidecarReport[];+ readonly blockingWasmSealXor: readonly WasmSealXorKnownPlaintextReport[];+} {+ // Harden project-level: do not include protect-time gates in the scan used+ // for the early refuse path (preserves prior semantics).+ const report = scanPackagingGates({+ ...options,+ includeProtectTimeGates: false,+ });+ const intensity: ProtectionIntensity = options.intensity ?? "bankrupt";+ const blockingSeals =+ intensityEnforcesSealRefusal(intensity) && options.allowPlaintextSeal !== true+ ? report.details.seals.filter((r) => r.shouldRefuseBankrupt)+ : [];+ const blockingWasmParms =+ intensityEnforcesWasmParamRefusal(intensity) &&+ options.allowWasmClearParamCarriers !== true+ ? report.details.wasmParams.filter((r) => r.shouldRefuseBankrupt)+ : [];+ const blockingJsAes =+ intensityEnforcesJsAesUnwrapRefusal(intensity) &&+ options.allowJsAesUnwrap !== true+ ? report.details.jsAes.filter((r) => r.shouldRefuseBankrupt)+ : [];+ const blockingJsHydrateDump =+ intensityEnforcesJsWasmHydrateDumpRefusal(intensity) &&+ options.allowJsWasmHydrateDump !== true+ ? report.details.jsHydrateDump.filter((r) => r.shouldRefuseBankrupt)+ : [];+ const blockingWasmXorMask =+ intensityEnforcesWasmXorMaskSidecarRefusal(intensity) &&+ options.allowWasmXorMaskSidecar !== true+ ? report.details.wasmXorMask.filter((r) => r.shouldRefuseBankrupt)+ : [];+ const blockingWasmSealXor =+ intensityEnforcesWasmSealXorKnownPlaintextRefusal(intensity) &&+ options.allowWasmSealXorKnownPlaintext !== true+ ? report.details.wasmSealXor.filter((r) => r.shouldRefuseBankrupt)+ : [];+ return {+ report,+ blockingSeals,+ blockingWasmParms,+ blockingJsAes,+ blockingJsHydrateDump,+ blockingWasmXorMask,+ blockingWasmSealXor,+ };+}++/** Human-readable CLI/MCP text for a packaging-gates report. */+export function formatPackagingGatesReport(report: PackagingGatesReport): string {+ const lines: string[] = [+ `BLA packaging gates — ${report.directory}`,+ report.oneLineAdvice,+ report.honestyNote,+ ];+ if (report.findings.length === 0) {+ lines.push(" (no findings)");+ return lines.join("\n");+ }+ for (const f of report.findings) {+ const tag = f.shouldRefuseBankrupt ? "refuse" : "info";+ lines.push(+ ` [${tag}] ${f.gate} · ${f.relativePath} · ${f.findingCount} finding(s)`,+ );+ lines.push(` ${f.oneLineAdvice}`);+ }+ if (report.blocking.length > 0) {+ lines.push(`blocking (${report.blocking.length}):`);+ for (const b of report.blocking) {+ lines.push(` - ${b.gate} · ${b.relativePath}`);+ }+ }+ return lines.join("\n");+}diff --git a/src/engine/panel-derive-abi-lint.ts b/src/engine/panel-derive-abi-lint.tsindex deb2454..82d6a58 100644--- a/src/engine/panel-derive-abi-lint.ts+++ b/src/engine/panel-derive-abi-lint.ts@@ -21,8 +21,8 @@*/import { createHash } from "node:crypto";-import { existsSync, readFileSync } from "node:fs";-import { dirname, resolve } from "node:path";+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";+import { dirname, join, resolve } from "node:path";import { findSiblingSealSidecars } from "./seal-commitment-lint.js";export const PANEL_DERIVE_ABI_SCHEMA = "bla-panel-derive-abi-lint/v1" as const;@@ -322,3 +322,62 @@ export function intensityRewritesPanelDerive(intensity: string): boolean {export function intensityEnforcesPanelOracleRefusal(intensity: string): boolean {return intensity === "bankrupt";}++const PANEL_SKIP_DIRS = new Set([+ "node_modules",+ ".git",+ ".hg",+ ".svn",+ ".bla-hardened",+ "coverage",+ ".turbo",+ ".cache",+ "__pycache__",+ ".venv",+ "venv",+]);++const PANEL_JS_EXT = /\.(?:[cm]?[jt]s|tsx?|html?)$/i;+const PANEL_MAX_FILES = 64;+const PANEL_MAX_DEPTH = 8;++function walkPanelCandidates(dir: string, depth: number, out: string[]): void {+ if (out.length >= PANEL_MAX_FILES || depth > PANEL_MAX_DEPTH) return;+ let entries;+ try {+ entries = readdirSync(dir, { withFileTypes: true });+ } catch {+ return;+ }+ for (const entry of entries) {+ if (out.length >= PANEL_MAX_FILES) return;+ if (entry.isDirectory()) {+ if (PANEL_SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;+ walkPanelCandidates(join(dir, entry.name), depth + 1, out);+ continue;+ }+ if (!entry.isFile()) continue;+ if (!PANEL_JS_EXT.test(entry.name)) continue;+ out.push(join(dir, entry.name));+ }+}++/**+ * Discover JS/TS/HTML under a directory and lint each for panel-derive footguns.+ * Used by unified `bla lint` / packaging-gates.+ */+export function discoverAndLintPanelDerive(+ directory: string,+): readonly PanelDeriveAbiReport[] {+ const abs = resolve(directory);+ if (!existsSync(abs)) {+ throw new Error(`Path not found: ${abs}`);+ }+ const st = statSync(abs);+ if (st.isFile()) {+ return [lintPanelDeriveAbiFile(abs)];+ }+ const candidates: string[] = [];+ walkPanelCandidates(abs, 0, candidates);+ return candidates.map((p) => lintPanelDeriveAbiFile(p));+}diff --git a/src/engine/protector.ts b/src/engine/protector.tsindex f561340..84173e2 100644--- a/src/engine/protector.ts+++ b/src/engine/protector.ts@@ -306,6 +306,8 @@ function protectTargetInner(options: ProtectionOptions): ProtectionResult {let honeySourceMapsGenerated = 0;let binarySectionsPatched = 0;let wasmExportsRenamed = 0;+ let wasmExportOrderShuffled = false;+ let wasmExportDecoysInjected = 0;/** Inline `<script>` bodies whose AST shield threw and were shipped unchanged. */let inlineScriptsFailed = 0;const counteredVectors = new Set<ReaAttackVectorId>();@@ -638,6 +640,8 @@ function protectTargetInner(options: ProtectionOptions): ProtectionResult {chaffPayloadsEmbedded = res.chaffPayloadsEmbedded;binarySectionsPatched = res.customSectionsAdded;wasmExportsRenamed = res.exportsRenamed.length;+ wasmExportOrderShuffled = res.exportsOrderShuffled === true;+ wasmExportDecoysInjected = res.exportDecoysInjected;counteredVectors.add("wasm-wat-interface");counteredVectors.add("obligation-ledger-cloning");} else if (format === "python-source") {@@ -927,6 +931,10 @@ function protectTargetInner(options: ProtectionOptions): ProtectionResult {...(options.weaveDecoys === true ? { weaveDecoys: true as const } : {}),...(options.selfSeal === true ? { selfSeal: true as const } : {}),...(wasmExportsRenamed > 0 ? { wasmExportRenameApplied: true as const } : {}),+ ...(wasmExportOrderShuffled ? { wasmExportOrderShuffled: true as const } : {}),+ ...(wasmExportDecoysInjected > 0+ ? { wasmExportDecoysInjected }+ : {}),seed,originalSha256: beforeAudit.sha256,protectedSha256: afterAudit.sha256,diff --git a/src/index.ts b/src/index.tsindex 5ecbb98..c2efb12 100644--- a/src/index.ts+++ b/src/index.ts@@ -283,6 +283,8 @@ export {export {lintLaneIndependence,+ lintLaneIndependenceFile,+ discoverAndLintLaneIndependence,LANE_INDEPENDENCE_SCHEMA,formatSupportsLaneIndependenceLint,laneIndependenceRefuseMessage,@@ -291,6 +293,17 @@ export {type LaneIndependenceFindingId,type LaneIndependenceSeverity,} from "./engine/lane-independence-lint.js";+export {+ scanPackagingGates,+ evaluateHardenProjectPackagingBlocks,+ formatPackagingGatesReport,+ PACKAGING_GATES_SCHEMA,+ type PackagingGateId,+ type PackagingGateFinding,+ type PackagingGatesReport,+ type PackagingGatesScanOptions,+ type PackagingGatesAllowOptions,+} from "./engine/packaging-gates.js";export {lintSealCommitmentSource,lintSealCommitmentFile,@@ -346,6 +359,7 @@ export {export {lintPanelDeriveAbiSource,lintPanelDeriveAbiFile,+ discoverAndLintPanelDerive,rewriteStablePanelDeriveSymbols,panelDeriveSeedRoot,panelDeriveReplacementName,diff --git a/src/mcp/server.ts b/src/mcp/server.tsindex 263d831..daf34f9 100644--- a/src/mcp/server.ts+++ b/src/mcp/server.ts@@ -41,6 +41,10 @@ import {lintWasmSealXorKnownPlaintextFile,type WasmSealXorKnownPlaintextReport,} from "../engine/wasm-seal-xor-known-plaintext-lint.js";+import {+ scanPackagingGates,+ type PackagingGatesReport,+} from "../engine/packaging-gates.js";import {computeArtifactRunId,readHardenRunSummary,@@ -663,6 +667,58 @@ export const BLA_MCP_TOOLS: readonly McpToolDefinition[] = Object.freeze([additionalProperties: false,},},+ {+ name: "bla_lint",+ description:+ "DEFAULT packaging-footgun gate scan for a project directory (or file). Runs every R1–R7 bankrupt refuse lint plus lane-independence and panel-derive discovery in one call — same engines as the individual bla_lint_* tools / `bla lint`. Returns bla-packaging-gates/v1 with findings, blocking, and honestyNote. Writes nothing. Prefer this over calling eight separate lints when reviewing an entitlement tree before harden.",+ inputSchema: {+ type: "object",+ properties: {+ directory: {+ type: "string",+ description: "Project directory or file to scan (default: cwd)",+ },+ intensity: {+ type: "string",+ enum: ["stealth", "balanced", "maximum", "bankrupt"],+ description: "Intensity used to decide refuse (default: bankrupt)",+ },+ allow_plaintext_seal: {+ type: "boolean",+ description: "Treat plaintext/reversible seal as non-blocking (lab only)",+ },+ allow_wasm_clear_params: {+ type: "boolean",+ description: "Treat clear WASM param carriers as non-blocking (lab only)",+ },+ allow_js_aes_unwrap: {+ type: "boolean",+ description: "Treat JS AES unwrap footgun as non-blocking (lab only)",+ },+ allow_js_wasm_hydrate_dump: {+ type: "boolean",+ description: "Treat JS←WASM hydrate dump as non-blocking (lab only)",+ },+ allow_wasm_xor_mask_sidecar: {+ type: "boolean",+ description: "Treat WASM XOR-mask sidecar as non-blocking (lab only)",+ },+ allow_wasm_seal_xor_known_plaintext: {+ type: "boolean",+ description: "Treat seal.revision XOR KP as non-blocking (lab only)",+ },+ allow_lane_independent: {+ type: "boolean",+ description: "Treat lane-independent gates as non-blocking (lab only)",+ },+ allow_panel_offline_oracle: {+ type: "boolean",+ description: "Treat panel offline oracle as non-blocking (lab only)",+ },+ },+ additionalProperties: false,+ },+ },{name: "bla_lint_lanes",description:@@ -1128,6 +1184,45 @@ function verifyHonestyOptions(args: Record<string, unknown>): VerifyTargetOption};}+function runPackagingGatesLint(args: Record<string, unknown>): PackagingGatesReport {+ const directory =+ typeof args.directory === "string" && args.directory.length > 0+ ? resolvePath(args.directory)+ : process.cwd();+ const intensity =+ args.intensity === "stealth" ||+ args.intensity === "balanced" ||+ args.intensity === "maximum" ||+ args.intensity === "bankrupt"+ ? args.intensity+ : "bankrupt";+ return scanPackagingGates({+ directory,+ intensity,+ includeProtectTimeGates: true,+ ...(args.allow_plaintext_seal === true ? { allowPlaintextSeal: true } : {}),+ ...(args.allow_wasm_clear_params === true+ ? { allowWasmClearParamCarriers: true }+ : {}),+ ...(args.allow_js_aes_unwrap === true ? { allowJsAesUnwrap: true } : {}),+ ...(args.allow_js_wasm_hydrate_dump === true+ ? { allowJsWasmHydrateDump: true }+ : {}),+ ...(args.allow_wasm_xor_mask_sidecar === true+ ? { allowWasmXorMaskSidecar: true }+ : {}),+ ...(args.allow_wasm_seal_xor_known_plaintext === true+ ? { allowWasmSealXorKnownPlaintext: true }+ : {}),+ ...(args.allow_lane_independent === true+ ? { allowLaneIndependentGates: true }+ : {}),+ ...(args.allow_panel_offline_oracle === true+ ? { allowPanelOfflineOracle: true }+ : {}),+ });+}+function runLintLanes(args: Record<string, unknown>): LaneIndependenceReport {const abs = resolvePath(args.path as string);if (!existsSync(abs)) {@@ -1780,6 +1875,23 @@ export async function handleMcpRequest(? { maxTargets: args.max_targets }: {}),});+ } else if (name === "bla_lint") {+ const full = runPackagingGatesLint(args);+ const { details, ...compact } = full;+ payload = {+ ...compact,+ detailCounts: {+ seals: details.seals.length,+ wasmParams: details.wasmParams.length,+ jsAes: details.jsAes.length,+ jsHydrateDump: details.jsHydrateDump.length,+ wasmXorMask: details.wasmXorMask.length,+ wasmSealXor: details.wasmSealXor.length,+ lanes: details.lanes.length,+ panelDerive: details.panelDerive.length,+ },+ };+ refused = full.shouldRefuseBankrupt;} else if (name === "bla_lint_lanes") {payload = runLintLanes(args);} else if (name === "bla_lint_seal") {diff --git a/tests/mcp-engine-capability-parity.test.ts b/tests/mcp-engine-capability-parity.test.tsindex 7ba54d7..173989d 100644--- a/tests/mcp-engine-capability-parity.test.ts+++ b/tests/mcp-engine-capability-parity.test.ts@@ -30,6 +30,7 @@ const EXPECTED_MCP_ENGINE_CAPABILITIES: ReadonlyArray<{"allow_panel_offline_oracle","allow_js_wasm_hydrate_dump","allow_wasm_xor_mask_sidecar",+ "allow_wasm_seal_xor_known_plaintext","seed","dry_run","max_artifacts",@@ -60,6 +61,7 @@ const EXPECTED_MCP_ENGINE_CAPABILITIES: ReadonlyArray<{"allow_panel_offline_oracle","allow_js_wasm_hydrate_dump","allow_wasm_xor_mask_sidecar",+ "allow_wasm_seal_xor_known_plaintext","seed","in_place","confirm_overwrite",@@ -82,6 +84,7 @@ const EXPECTED_MCP_ENGINE_CAPABILITIES: ReadonlyArray<{"allow_panel_offline_oracle","allow_js_wasm_hydrate_dump","allow_wasm_xor_mask_sidecar",+ "allow_wasm_seal_xor_known_plaintext","seed","llm_directives","in_place",@@ -101,6 +104,21 @@ const EXPECTED_MCP_ENGINE_CAPABILITIES: ReadonlyArray<{"run_id",],},+ {+ tool: "bla_lint",+ params: [+ "directory",+ "intensity",+ "allow_plaintext_seal",+ "allow_wasm_clear_params",+ "allow_js_aes_unwrap",+ "allow_js_wasm_hydrate_dump",+ "allow_wasm_xor_mask_sidecar",+ "allow_wasm_seal_xor_known_plaintext",+ "allow_lane_independent",+ "allow_panel_offline_oracle",+ ],+ },{tool: "bla_lint_lanes",params: ["path"],diff --git a/tests/packaging-gates.test.ts b/tests/packaging-gates.test.tsnew file mode 100644index 0000000..1ab1472--- /dev/null+++ b/tests/packaging-gates.test.ts@@ -0,0 +1,71 @@+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { describe, expect, it } from "vitest";+import {+ PACKAGING_GATES_SCHEMA,+ evaluateHardenProjectPackagingBlocks,+ formatPackagingGatesReport,+ scanPackagingGates,+} from "../src/engine/packaging-gates.js";+import { buildTestWasmWithXorMaskSidecar } from "../src/engine/wasm-xor-mask-sidecar-lint.js";++describe("packaging-gates (unified R1–R7 scan)", () => {+ it("reports clean on an empty project tree", () => {+ const dir = mkdtempSync(join(tmpdir(), "bla-pg-clean-"));+ const report = scanPackagingGates({ directory: dir, intensity: "bankrupt" });+ expect(report.schema).toBe(PACKAGING_GATES_SCHEMA);+ expect(report.shouldRefuseBankrupt).toBe(false);+ expect(report.findings).toEqual([]);+ expect(report.honestyNote.length).toBeGreaterThan(20);+ expect(formatPackagingGatesReport(report)).toContain("no findings");+ });++ it("refuses bankrupt when a WASM XOR-mask sidecar is present", () => {+ const dir = mkdtempSync(join(tmpdir(), "bla-pg-xor-"));+ writeFileSync(join(dir, "core.wasm"), buildTestWasmWithXorMaskSidecar());+ const report = scanPackagingGates({ directory: dir, intensity: "bankrupt" });+ expect(report.shouldRefuseBankrupt).toBe(true);+ expect(report.blocking.some((b) => b.gate === "wasm-xor-mask-sidecar")).toBe(+ true,+ );+ const blocks = evaluateHardenProjectPackagingBlocks({+ directory: dir,+ intensity: "bankrupt",+ });+ expect(blocks.blockingWasmXorMask.length).toBeGreaterThan(0);+ });++ it("allow_wasm_xor_mask_sidecar clears project-level refuse", () => {+ const dir = mkdtempSync(join(tmpdir(), "bla-pg-allow-"));+ writeFileSync(join(dir, "core.wasm"), buildTestWasmWithXorMaskSidecar());+ const blocks = evaluateHardenProjectPackagingBlocks({+ directory: dir,+ intensity: "bankrupt",+ allowWasmXorMaskSidecar: true,+ });+ expect(blocks.blockingWasmXorMask).toEqual([]);+ });++ it("surfaces lane-independence when includeProtectTimeGates", () => {+ const dir = mkdtempSync(join(tmpdir(), "bla-pg-lane-"));+ mkdirSync(dir, { recursive: true });+ writeFileSync(+ join(dir, "gate.js"),+ `+const lanes = [0x41, 0x42, 0x43, 0x44, 0x45];+function check(key) {+ return key.split("").every((ch, i) => ch.charCodeAt(0) === lanes[i]);+}+module.exports = { check };+`,+ );+ const report = scanPackagingGates({+ directory: dir,+ intensity: "bankrupt",+ includeProtectTimeGates: true,+ });+ expect(report.findings.some((f) => f.gate === "lane-independence")).toBe(true);+ expect(report.shouldRefuseBankrupt).toBe(true);+ });+});