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(2.0): unified packaging-gates pipeline (bla lint / bla_lint)

qybaihefd49dd1c059b
diff --git a/src/cli.ts b/src/cli.ts
index 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 check
audit <target> Pre-flight REA exposure & vulnerability scan
+ lint [dir] DEFAULT packaging gate scan (all R1–R7 refuse lints + lanes/panel); exit 2 on refuse
lint-lanes <file> Heuristic ERROR if gate code looks lane-independent (issue #40.1); exit 2
lint-wasm-params <file> Heuristic ERROR if WASM embeds clear R3PARM/R3CIPH/R2SEAL-class carriers; exit 2
lint-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)): P
return 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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);
+ });
+});