π‘οΈ 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-seal): detect plaintext/reversible seal commitment sidecars
qybaihe98a5ffbbb221
diff --git a/src/engine/seal-commitment-lint.ts b/src/engine/seal-commitment-lint.tsnew file mode 100644index 0000000..7b77e9a--- /dev/null+++ b/src/engine/seal-commitment-lint.ts@@ -0,0 +1,376 @@+/**+ * Plaintext seal sidecar / reversible public-commitment lint (red-blue round-2).+ *+ * Detects entitlement/seal JSON that ships salts + rounds + a short public+ * `revision` (custom reversible ARX/Feistel shape) and/or certificate ciphertext+ * as an offline oracle package. One-way digests (SHA-256 / HMAC / blake, β¦)+ * without invertible ARX parameters pass.+ *+ * Findings: reversible shapes are severity **"error"**; bare plaintext seal+ * packaging without a reversible digest is **"warning"**. Bankrupt harden+ * refuses error findings unless `allowPlaintextSeal` is set.+ *+ * DEFENSIVE ONLY β no inversion / crack advice.+ */++import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";+import { basename, join, resolve } from "node:path";++export const SEAL_COMMITMENT_SCHEMA = "bla-seal-commitment-lint/v1" as const;++export type SealCommitmentFindingId =+ | "plaintext-seal-sidecar"+ | "reversible-public-commitment"+ | "seal-offline-oracle-package";++export type SealCommitmentSeverity = "warning" | "error";++export interface SealCommitmentFinding {+ readonly id: SealCommitmentFindingId;+ readonly severity: SealCommitmentSeverity;+ readonly summary: string;+ readonly evidence: string;+}++export interface SealCommitmentReport {+ readonly schema: typeof SEAL_COMMITMENT_SCHEMA;+ readonly path: string;+ readonly findings: readonly SealCommitmentFinding[];+ /** True when any finding is present. */+ readonly looksExposed: boolean;+ /** True when bankrupt harden should refuse (error findings). */+ readonly shouldRefuseBankrupt: boolean;+ readonly oneLineAdvice: string;+}++const ONE_WAY_ALGO =+ /^(?:sha-?256|sha-?384|sha-?512|sha-?3(?:-?(?:256|384|512))?|hmac(?:-?sha-?(?:256|512))?|blake2?b?(?:-?\d+)?|argon2id?|scrypt|pbkdf2)$/i;++const SEAL_NAME =+ /^(?:seal|license-seal|entitlement-seal|catalog-seal)(?:\.[\w-]+)*\.json$/i;++const SKIP_DIR_NAMES = new Set([+ "node_modules",+ ".git",+ ".hg",+ ".svn",+ ".bla-hardened",+ "coverage",+ ".next",+ ".turbo",+ "vendor",+ "__pycache__",+]);++const MAX_WALK_DEPTH = 6;+const MAX_SEAL_FILES = 32;+const MAX_JSON_BYTES = 400_000;++function finding(+ id: SealCommitmentFindingId,+ severity: SealCommitmentSeverity,+ summary: string,+ evidence: string,+): SealCommitmentFinding {+ return {+ id,+ severity,+ summary,+ evidence: evidence.slice(0, 160),+ };+}++function isPlainObject(value: unknown): value is Record<string, unknown> {+ return typeof value === "object" && value !== null && !Array.isArray(value);+}++function asString(value: unknown): string | undefined {+ return typeof value === "string" && value.length > 0 ? value : undefined;+}++function asNumber(value: unknown): number | undefined {+ return typeof value === "number" && Number.isFinite(value) ? value : undefined;+}++function looksLikeSealFileName(fileName: string): boolean {+ const base = basename(fileName);+ if (SEAL_NAME.test(base)) return true;+ if (base.toLowerCase() === "seal.json") return true;+ if (/\.seal\.json$/i.test(base)) return true;+ return false;+}++function declaredOneWay(algorithm: string | undefined): boolean {+ if (!algorithm) return false;+ const trimmed = algorithm.trim();+ if (ONE_WAY_ALGO.test(trimmed)) return true;+ // Allow "sha256:" / "hmac-sha256:" prefixes on digest fields.+ if (ONE_WAY_ALGO.test(trimmed.replace(/:.*$/, ""))) return true;+ return false;+}++function isSha256Hex(value: string): boolean {+ return /^[0-9a-f]{64}$/i.test(value);+}++function isSha512Hex(value: string): boolean {+ return /^[0-9a-f]{128}$/i.test(value);+}++function hasInvertibleArxParams(obj: Record<string, unknown>): boolean {+ const rounds = asNumber(obj.rounds) ?? asNumber(obj.roundCount);+ const salt =+ asNumber(obj.scheduleSalt) ??+ asNumber(obj.schedule_salt) ??+ asNumber(obj.arxSalt) ??+ asNumber(obj.arx_salt);+ // Numeric public salt + round count is the classic invertible-ARX footgun shape.+ return rounds !== undefined && rounds >= 2 && salt !== undefined;+}++function revisionField(obj: Record<string, unknown>): string | undefined {+ return (+ asString(obj.revision) ??+ asString(obj.commitment) ??+ asString(obj.digest) ??+ asString(obj.expectedDigest) ??+ asString(obj.publicDigest)+ );+}++function looksSealShaped(obj: Record<string, unknown>, fileName: string): boolean {+ if (looksLikeSealFileName(fileName)) return true;+ const schema = asString(obj.schema) ?? asString(obj.$schema) ?? "";+ if (/seal|entitlement|license/i.test(schema)) return true;+ const keys = Object.keys(obj);+ const hit =+ keys.includes("revision") ||+ keys.includes("commitment") ||+ keys.includes("certificateCipherHex") ||+ keys.includes("certificate_cipher_hex");+ const saltish =+ keys.includes("scheduleSalt") ||+ keys.includes("schedule_salt") ||+ keys.includes("rounds");+ return hit && saltish;+}++/**+ * Lint a UTF-8 JSON (or JSON-ish) seal/catalog body.+ */+export function lintSealCommitmentSource(+ source: string,+ options: { readonly path?: string } = {},+): SealCommitmentReport {+ const pathLabel = options.path ?? "<memory>";+ const findings: SealCommitmentFinding[] = [];+ const text = source.length > MAX_JSON_BYTES ? source.slice(0, MAX_JSON_BYTES) : source;++ let parsed: unknown;+ try {+ parsed = JSON.parse(text);+ } catch {+ return {+ schema: SEAL_COMMITMENT_SCHEMA,+ path: pathLabel,+ findings: [],+ looksExposed: false,+ shouldRefuseBankrupt: false,+ oneLineAdvice: "Not JSON β seal-commitment lint skipped.",+ };+ }++ if (!isPlainObject(parsed)) {+ return {+ schema: SEAL_COMMITMENT_SCHEMA,+ path: pathLabel,+ findings: [],+ looksExposed: false,+ shouldRefuseBankrupt: false,+ oneLineAdvice: "JSON root is not an object β seal-commitment lint skipped.",+ };+ }++ if (!looksSealShaped(parsed, pathLabel)) {+ return {+ schema: SEAL_COMMITMENT_SCHEMA,+ path: pathLabel,+ findings: [],+ looksExposed: false,+ shouldRefuseBankrupt: false,+ oneLineAdvice: "No seal/entitlement sidecar shape detected.",+ };+ }++ const algorithm =+ asString(parsed.algorithm) ??+ asString(parsed.digestAlgorithm) ??+ asString(parsed.hash) ??+ asString(parsed.kdf);+ const revision = revisionField(parsed);+ const oneWay = declaredOneWay(algorithm);+ const invertible = hasInvertibleArxParams(parsed);+ const cipher =+ asString(parsed.certificateCipherHex) ??+ asString(parsed.certificate_cipher_hex) ??+ asString(parsed.certificateCipher) ??+ asString(parsed.cipherHex);++ // Plaintext seal sidecar sitting on disk is always an exposure signal.+ if (looksLikeSealFileName(pathLabel) || /seal|entitlement/i.test(asString(parsed.schema) ?? "")) {+ findings.push(+ finding(+ "plaintext-seal-sidecar",+ invertible || Boolean(cipher) ? "error" : "warning",+ "Plaintext seal/entitlement JSON sidecar β harden does not encrypt JSON carriers; prefer omit, encrypt, or bind under self-seal.",+ `keys=${Object.keys(parsed).slice(0, 12).join(",")}`,+ ),+ );+ }++ if (revision && invertible && !oneWay) {+ const shortCustom =+ !isSha256Hex(revision) && !isSha512Hex(revision) && /^[0-9a-f]+$/i.test(revision);+ // Even a 64-hex revision with scheduleSalt+rounds and no one-way algo is suspicious+ // (could be truncated custom ARX); treat as reversible when ARX params present.+ findings.push(+ finding(+ "reversible-public-commitment",+ "error",+ shortCustom+ ? "Public revision/commitment with scheduleSalt+rounds looks like a reversible ARX digest β prefer SHA-256/HMAC (one-way)."+ : "Public commitment paired with numeric scheduleSalt+rounds without a declared one-way algorithm β treat as reversible-commitment footgun.",+ `revision=${revision.slice(0, 20)}β¦ rounds/salt present algorithm=${algorithm ?? "none"}`,+ ),+ );+ }++ if (cipher && revision && (invertible || !oneWay)) {+ findings.push(+ finding(+ "seal-offline-oracle-package",+ "error",+ "Seal packages revision/commitment together with certificate ciphertext in cleartext β offline oracle / forge surface.",+ `cipherLen=${cipher.length} revisionLen=${revision.length}`,+ ),+ );+ }++ // Deduplicate by id (keep highest severity).+ const byId = new Map<SealCommitmentFindingId, SealCommitmentFinding>();+ for (const f of findings) {+ const prev = byId.get(f.id);+ if (!prev || (prev.severity === "warning" && f.severity === "error")) {+ byId.set(f.id, f);+ }+ }+ const deduped = [...byId.values()];+ const shouldRefuseBankrupt = deduped.some((f) => f.severity === "error");++ return {+ schema: SEAL_COMMITMENT_SCHEMA,+ path: pathLabel,+ findings: deduped,+ looksExposed: deduped.length > 0,+ shouldRefuseBankrupt,+ oneLineAdvice:+ deduped.length === 0+ ? "No reversible seal-commitment footgun detected (heuristic)."+ : shouldRefuseBankrupt+ ? "ERROR: Plaintext/reversible seal sidecar. Use one-way digests; omit or encrypt seal JSON. Bankrupt harden refuses unless allowPlaintextSeal / --allow-plaintext-seal / allow_plaintext_seal. Defensive guidance only."+ : "WARNING: Seal-shaped JSON is plaintext beside the artifact β encrypt, omit, or bind under self-seal.",+ };+}++/**+ * Read a path and lint it as a seal/commitment sidecar.+ */+export function lintSealCommitmentFile(filePath: string): SealCommitmentReport {+ const abs = resolve(filePath);+ if (!existsSync(abs)) {+ throw new Error(`seal-commitment target not found: ${abs}`);+ }+ const source = readFileSync(abs, "utf8");+ return lintSealCommitmentSource(source, { path: abs });+}++function walkSealCandidates(+ dir: string,+ depth: number,+ out: string[],+): void {+ if (out.length >= MAX_SEAL_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_SEAL_FILES) return;+ if (entry.isDirectory()) {+ if (SKIP_DIR_NAMES.has(entry.name) || entry.name.startsWith(".")) continue;+ walkSealCandidates(join(dir, entry.name), depth + 1, out);+ continue;+ }+ if (!entry.isFile()) continue;+ if (!looksLikeSealFileName(entry.name)) continue;+ out.push(join(dir, entry.name));+ }+}++/**+ * Discover seal-named JSON files under a project/build directory and lint each.+ */+export function discoverAndLintSealSidecars(+ directory: string,+): readonly SealCommitmentReport[] {+ const abs = resolve(directory);+ if (!existsSync(abs)) {+ throw new Error(`Path not found: ${abs}`);+ }+ const st = statSync(abs);+ if (st.isFile()) {+ return [lintSealCommitmentFile(abs)];+ }+ const candidates: string[] = [];+ walkSealCandidates(abs, 0, candidates);+ // Also check common build output folder names one level down even if skipped+ // as deep roots β seal.json often sits next to dist artifacts at project root.+ return candidates.map((p) => lintSealCommitmentFile(p));+}++/**+ * Immediate-directory sibling seal files next to a protect target.+ */+export function findSiblingSealSidecars(directory: string): readonly string[] {+ const abs = resolve(directory);+ if (!existsSync(abs) || !statSync(abs).isDirectory()) return [];+ let entries;+ try {+ entries = readdirSync(abs, { withFileTypes: true });+ } catch {+ return [];+ }+ return entries+ .filter((e) => e.isFile() && looksLikeSealFileName(e.name))+ .map((e) => join(abs, e.name));+}++export function sealCommitmentRefuseMessage(+ report: SealCommitmentReport,+ filePath: string,+): string {+ const ids = report.findings.filter((f) => f.severity === "error").map((f) => f.id).join(", ");+ return (+ `Refusing bankrupt harden/protect: plaintext/reversible seal sidecar at ${filePath}` ++ (ids ? ` [${ids}]` : "") ++ `. Use one-way SHA-256/HMAC commitments; omit or encrypt seal JSON. ` ++ `To override (lab fixture only), pass allowPlaintextSeal / --allow-plaintext-seal / allow_plaintext_seal:true.`+ );+}++/** Whether bankrupt intensity should enforce seal-sidecar refusal. */+export function intensityEnforcesSealRefusal(intensity: string): boolean {+ return intensity === "bankrupt";+}diff --git a/src/index.ts b/src/index.tsindex 1e8081c..fd63b85 100644--- a/src/index.ts+++ b/src/index.ts@@ -291,6 +291,19 @@ export {type LaneIndependenceFindingId,type LaneIndependenceSeverity,} from "./engine/lane-independence-lint.js";+export {+ lintSealCommitmentSource,+ lintSealCommitmentFile,+ discoverAndLintSealSidecars,+ findSiblingSealSidecars,+ sealCommitmentRefuseMessage,+ intensityEnforcesSealRefusal,+ SEAL_COMMITMENT_SCHEMA,+ type SealCommitmentFinding,+ type SealCommitmentReport,+ type SealCommitmentFindingId,+ type SealCommitmentSeverity,+} from "./engine/seal-commitment-lint.js";export {parseWasmExportSectionPayload,renameWasmExports,diff --git a/tests/seal-commitment-lint.test.ts b/tests/seal-commitment-lint.test.tsnew file mode 100644index 0000000..7943226--- /dev/null+++ b/tests/seal-commitment-lint.test.ts@@ -0,0 +1,116 @@+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, readFileSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { afterEach, describe, expect, it } from "vitest";+import {+ lintSealCommitmentSource,+ lintSealCommitmentFile,+ discoverAndLintSealSidecars,+ findSiblingSealSidecars,+ sealCommitmentRefuseMessage,+ intensityEnforcesSealRefusal,+ SEAL_COMMITMENT_SCHEMA,+} from "../src/engine/seal-commitment-lint.js";++const dirs: string[] = [];+afterEach(() => {+ for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true });+});++/** Round-2 seal shape (reversible ARX + cipher package). */+const ROUND2_SEAL = {+ schema: "bla-redblue-r2-seal/v1",+ product: "round-2-product-chained-entitlement",+ seed: "bla-redblue-r2-product-gate-2026-11",+ rounds: 28,+ scheduleSalt: 1374179543,+ revision: "7f325fec37206b637a224e9630b67c4a",+ panelToken: "f805ed0c2a763bc5",+ certificateCipherHex:+ "0cd3dfe5e342eb542a3666d6e706ede34c58416b00bb853921b9c82397ff716237",+ certificateSha256:+ "b38091d4a394ded9012846e8d4b647083b260beb6ee5ad1e42265fe6f107c660",+};++const ONE_WAY_SEAL = {+ schema: "bla-entitlement-seal/v1",+ algorithm: "sha256",+ revision: "b38091d4a394ded9012846e8d4b647083b260beb6ee5ad1e42265fe6f107c660",+ product: "ok-product",+};++describe("seal-commitment lint (red-blue round-2)", () => {+ it("flags round-2 reversible ARX seal.json as error + refuse", () => {+ const report = lintSealCommitmentSource(JSON.stringify(ROUND2_SEAL, null, 2), {+ path: "/tmp/seal.json",+ });+ expect(report.schema).toBe(SEAL_COMMITMENT_SCHEMA);+ expect(report.looksExposed).toBe(true);+ expect(report.shouldRefuseBankrupt).toBe(true);+ const ids = report.findings.map((f) => f.id);+ expect(ids).toContain("reversible-public-commitment");+ expect(ids).toContain("seal-offline-oracle-package");+ expect(report.findings.every((f) => f.severity === "error" || f.id === "plaintext-seal-sidecar")).toBe(+ true,+ );+ expect(report.findings.some((f) => f.severity === "error")).toBe(true);+ });++ it("passes one-way SHA-256 seal without invertible ARX params", () => {+ const report = lintSealCommitmentSource(JSON.stringify(ONE_WAY_SEAL), {+ path: "/tmp/seal.json",+ });+ expect(report.shouldRefuseBankrupt).toBe(false);+ expect(report.findings.some((f) => f.id === "reversible-public-commitment")).toBe(false);+ expect(report.findings.some((f) => f.id === "seal-offline-oracle-package")).toBe(false);+ // Filename still yields a plaintext-sidecar warning (not refuse).+ expect(report.findings.some((f) => f.id === "plaintext-seal-sidecar" && f.severity === "warning")).toBe(+ true,+ );+ });++ it("discovers seal.json under a project tree", () => {+ const root = mkdtempSync(join(tmpdir(), "bla-seal-disc-"));+ dirs.push(root);+ mkdirSync(join(root, "dist"));+ writeFileSync(join(root, "dist", "seal.json"), JSON.stringify(ROUND2_SEAL), "utf8");+ writeFileSync(join(root, "dist", "app.js"), "export const x = 1;\n", "utf8");+ const reports = discoverAndLintSealSidecars(root);+ expect(reports.length).toBeGreaterThanOrEqual(1);+ expect(reports.some((r) => r.shouldRefuseBankrupt)).toBe(true);+ });++ it("finds sibling seal next to a protect target", () => {+ const root = mkdtempSync(join(tmpdir(), "bla-seal-sib-"));+ dirs.push(root);+ writeFileSync(join(root, "license.cjs"), "console.log(1)\n", "utf8");+ writeFileSync(join(root, "app.seal.json"), JSON.stringify(ROUND2_SEAL), "utf8");+ const sibs = findSiblingSealSidecars(root);+ expect(sibs.some((p) => p.endsWith("app.seal.json"))).toBe(true);+ const report = lintSealCommitmentFile(sibs[0]!);+ expect(report.shouldRefuseBankrupt).toBe(true);+ });++ it("refuse message names the allow flag", () => {+ const report = lintSealCommitmentSource(JSON.stringify(ROUND2_SEAL), {+ path: "/tmp/seal.json",+ });+ expect(sealCommitmentRefuseMessage(report, "/tmp/seal.json")).toMatch(+ /allowPlaintextSeal|allow-plaintext-seal/i,+ );+ expect(intensityEnforcesSealRefusal("bankrupt")).toBe(true);+ expect(intensityEnforcesSealRefusal("balanced")).toBe(false);+ });++ it("lints the round-2 hardened seal fixture when present", () => {+ const fixture = "/workspace/bla-redblue/round-2/hardened/seal.json";+ try {+ readFileSync(fixture, "utf8");+ } catch {+ return; // fixture absent on some runners β unit cases above still cover shape+ }+ const report = lintSealCommitmentFile(fixture);+ expect(report.shouldRefuseBankrupt).toBe(true);+ expect(report.findings.some((f) => f.id === "reversible-public-commitment")).toBe(true);+ });+});