🛡️ 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(verify): add defenseScore honesty module with soft-caps for known gaps
qybaiheef7b70ac482d
diff --git a/src/engine/defense-score-honesty.ts b/src/engine/defense-score-honesty.tsnew file mode 100644index 0000000..94f2ae0--- /dev/null+++ b/src/engine/defense-score-honesty.ts@@ -0,0 +1,132 @@+/**+ * Defense-score honesty helpers (issue #40.6).+ *+ * `defenseScore` measures Counter-REA gate pass-rate + exposure drop only.+ * It is NOT a claim of cryptographic preimage hardness. When known product+ * gaps still apply to the artifact under verification, annotate and soft-cap+ * the reported score so agents do not treat a high gate score as "unbreakable".+ *+ * Defensive only — no crack / RE advice.+ */++import type { ArtifactFormat } from "../core/types.js";++export const DEFENSE_SCORE_DISCLAIMER =+ "Score scope: Counter-REA gates + exposure drop — not a preimage-hardness claim (see issue #40)." as const;++export type DefenseScoreGapId =+ | "wasm-export-rename-pending"+ | "self-seal-not-enabled"+ | "numeric-template-hygiene-partial";++export interface DefenseScoreGap {+ readonly id: DefenseScoreGapId;+ readonly summary: string;+ /** Soft upper bound while this gap applies. */+ readonly scoreCap: number;+}++export interface DefenseScoreHonestyInput {+ readonly detectedFormat: ArtifactFormat;+ /** True when protect/harden ran with selfSeal / self_seal opt-in. */+ readonly selfSealEnabled?: boolean;+ /** True when WASM public-ABI rename pass actually rewrote non-ABI exports. */+ readonly wasmExportRenameApplied?: boolean;+ /** True when remaining BLA-injected templates still hardcode classic golden constants. */+ readonly numericTemplateLeakKnown?: boolean;+}++export interface DefenseScoreHonesty {+ readonly rawScore: number;+ readonly cappedScore: number;+ readonly gaps: readonly DefenseScoreGap[];+ readonly disclaimer: typeof DEFENSE_SCORE_DISCLAIMER;+ readonly appliedCap: number | null;+}++const WASM_FORMATS: ReadonlySet<ArtifactFormat> = new Set(["wasm"]);+const JS_LIKE: ReadonlySet<ArtifactFormat> = new Set([+ "javascript",+ "typescript",+ "html-bundle",+ "electron-asar",+]);++/**+ * Known product gaps that should annotate / soft-cap a raw gate score.+ * Caps are intentionally soft (still allow high Counter-REA scores) so the+ * metric remains useful while staying honest about missing hardness layers.+ */+export function collectDefenseScoreGaps(+ input: DefenseScoreHonestyInput,+): readonly DefenseScoreGap[] {+ const gaps: DefenseScoreGap[] = [];++ if (WASM_FORMATS.has(input.detectedFormat) && input.wasmExportRenameApplied !== true) {+ gaps.push({+ id: "wasm-export-rename-pending",+ summary:+ "WASM export rename / semantic preservation not applied; public ABI names still match the input surface (issue #40.3).",+ scoreCap: 88,+ });+ }++ if (JS_LIKE.has(input.detectedFormat) && input.selfSealEnabled !== true) {+ gaps.push({+ id: "self-seal-not-enabled",+ summary:+ "Opt-in self-seal / sibling-module integrity binding was not enabled for this JS/Node target (issue #40.5).",+ scoreCap: 92,+ });+ }++ if (input.numericTemplateLeakKnown === true) {+ gaps.push({+ id: "numeric-template-hygiene-partial",+ summary:+ "Known BLA-injected shield templates may still emit classic golden-ratio numeric probes bit-identically (issue #40.2).",+ scoreCap: 90,+ });+ }++ return Object.freeze(gaps);+}++/**+ * Apply soft caps from known gaps. Returns the min of rawScore and every+ * applicable gap scoreCap (never raises the score).+ */+export function applyDefenseScoreHonesty(+ rawScore: number,+ input: DefenseScoreHonestyInput,+): DefenseScoreHonesty {+ const clampedRaw = Math.max(0, Math.min(100, Math.round(rawScore)));+ const gaps = collectDefenseScoreGaps(input);+ let capped = clampedRaw;+ let appliedCap: number | null = null;+ for (const gap of gaps) {+ if (capped > gap.scoreCap) {+ capped = gap.scoreCap;+ appliedCap = gap.scoreCap;+ }+ }+ return {+ rawScore: clampedRaw,+ cappedScore: capped,+ gaps,+ disclaimer: DEFENSE_SCORE_DISCLAIMER,+ appliedCap,+ };+}++/** One-line SEAL / reporter annotation when gaps apply. */+export function formatDefenseScoreGapAnnotation(+ honesty: DefenseScoreHonesty,+): string | null {+ if (honesty.gaps.length === 0) return null;+ const ids = honesty.gaps.map((g) => g.id).join(", ");+ if (honesty.appliedCap !== null) {+ return `Honesty cap applied (raw ${honesty.rawScore} → ${honesty.cappedScore}): ${ids}`;+ }+ return `Honesty annotations (no cap hit): ${ids}`;+}