🛡️ 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
Red/Blue round-10 · Blue
qybaihe6babe00af90a
diff --git a/.agents/skills/blind-llm-agents/SKILL.md b/.agents/skills/blind-llm-agents/SKILL.mdindex 7edfd97..7b610e6 100644--- a/.agents/skills/blind-llm-agents/SKILL.md+++ b/.agents/skills/blind-llm-agents/SKILL.md@@ -7,7 +7,7 @@ description: >Agents). Prefer this skill as the guide; call existing MCP tools / CLI — do not inventnew MCP tools. Default verb: bla_harden. Refuse crack/RE of third-party software.metadata:- version: "1.5.16"+ version: "1.5.17"---# BLA: Blind LLM Agents@@ -24,7 +24,7 @@ model misjudgment on proprietary logic, or **one-click / ä¸€é”®ĺŠ ĺ›ş** a build.Defensive only: protect **their own** artifacts. Refuse crack, RE, bypass PoCs, orattack playbooks against software they do not own.-**Principles (red-blue round-1+2+3+4+5+6+7+7b+8+9):** do not ship a stable public WASM ABI without an explicit `wasm_preserve_exports` list; do not leave JS-side independent lane tables — prefer whole-key chained mixing (`bla_lint_lanes` / harden refuse). **Do not** place plaintext seal/catalog JSON (`revision`, salts, certificate ciphertext) beside hardened outputs. Public compare targets must be **one-way** (SHA-256/HMAC/etc.); reversible ARX/Feistel digests as public `revision` are a key-recovery footgun (round-2 break — **closed in round-3** when seal is digests-only). Enforce with `bla_lint_seal` / `bla lint-seal`; bankrupt harden **refuses** unless `allow_plaintext_seal` / `--allow-plaintext-seal`. Round-3 residual **gates**: `bla_lint_wasm_params` / `bla lint-wasm-params` — bankrupt refuses clear `R2SEAL`/`R3PARM`/`R3CIPH`-class carriers unless `allow_wasm_clear_params`; `bla_lint_panel_derive` — maximum/bankrupt **rewrites** `__vaultPanelDerive_*` to `_blaPd_*` unless `allow_stable_panel_derive`; bankrupt harden sets `selfSealRecommended` for multi-artifact trees (never auto for single-file) — prefer **`self_seal`**. Round-4 gates: `bla_lint_js_aes_unwrap` / `bla lint-js-aes-unwrap` — bankrupt **refuses** JS wrap-key + `create*iv` + fixed sealed hdr (e.g. `d17ea004`) unless `allow_js_aes_unwrap` (gate only — **not** white-box AES; prefer in-WASM unwrap). `bla_lint_panel_derive` flags `deriveLocal` (rewritten to `_blaPdLocal_*`) and **refuses** `deriveLocal` + plaintext `panelTokenSha256` offline-oracle packaging unless `allow_panel_offline_oracle` (rename is not a crypto fix — scrub digests / avoid derive UI). `self_seal` embeds **expected sibling SHA-256 hard-fail** when siblings exist at protect time (harden processes JS last); opaque-seed entanglement alone does **not** gate entitlement control flow. Round-5 gates: `bla_lint_js_wasm_hydrate_dump` / `bla lint-js-wasm-hydrate-dump` — bankrupt **refuses** JS that copies salt/rounds/cipher from `WebAssembly.Memory` after hydrate/instantiate unless `allow_js_wasm_hydrate_dump` (host memory dump needs **no** Node `create*iv`; export rename alone does not close this — prefer keep ARX+certify **inside** WASM so params never re-enter JS). Round-6 product pattern: export `unlock(keyPtr,keyLen)->outLen` (or equivalent) so ARX+compare+decrypt stay in WASM; JS only writes key bytes and reads the result — do **not** call hydrate then decode salt/rounds/cipher in JS (closes the round-5 host memory-dump residual under bankrupt defaults). Honesty: WASM reverse-engineering of the unlock body remains a theoretical surface; gates do not claim white-box secrecy. Round-6 **break residual**: do **not** store a plaintext XOR mask adjacent to a masked entitlement pack (`salt||rounds||expected-words||cipher`) in WASM data — static unmask needs no key; combined with invertible ARX expected-state compare this recovers the prize (`bla_lint_wasm_xor_mask_sidecar` / `bla lint-wasm-xor-mask-sidecar`; bankrupt refuses unless `allow_wasm_xor_mask_sidecar`). Prefer key-dependent unmask and **one-way** commitments inside WASM (not reversible expected words). Round-7 product pattern: keep unlock-in-WASM; derive the XOR mask from the key inside `unlock` (do **not** embed a plaintext mask beside the blob); store a SHA-256 commitment of the ARX state for compare (not invertible expected words). Round-7 **break residual**: do **not** place public `seal.revision` (or other public digests) as plaintext under a repeating XOR mask in WASM data — `revision` XOR `masked[8..40)` recovers the mask with no key; combined with an algebraically weak key-dependent mask KDF this recovers the prize (`bla_lint_wasm_seal_xor_known_plaintext` / `bla lint-wasm-seal-xor-known-plaintext`; bankrupt refuses unless `allow_wasm_seal_xor_known_plaintext`). Prefer a one-way mask KDF (e.g. SHA-256(key||i)) and keep public digests **out** of the masked plaintext prefix (or bind revision differently). Round-8 product pattern: derive the XOR mask with a **one-way** KDF such as `SHA-256(key[16])` (never an algebraically invertible byte mix); put an entropy/random pad — **not** `seal.revision` — in the masked pack prefix; keep the SHA-256 ARX commitment in a **separate clear data segment** (or otherwise outside the XOR-masked layout) so public digests cannot serve as XOR known-plaintext. Honesty: full WASM reverse-engineering of unlock can still recover algorithms; gates close packaging footguns, not white-box secrecy. Round-8 **red (NO PRIZE)**: SHA-256(key) mask KDF + commitment-outside-XOR **held** against the round-7 seal.revision XOR known-plaintext oracle and algebraic mask invert; residuals — structural KP of fixed rounds/zero pad3 leaks only a few mask bytes; arity-2 decoy aliases; bankrupt JS decoys may false-positive `bla_lint_lanes` on hardened *output*; online guessing after full WASM RE remains a theoretical surface (not a packaging refuse gate). Round-9 product pattern: keep R8 SHA-256(key) mask KDF + commitment-outside-XOR; **randomize pack header `pad3`** and avoid fixed `rounds` immediates (seed-derived rounds in-range) so structural KP cannot leak `mask[4..7]`; emit bankrupt shadow-heap decoy shares/words in **non-lane-array shapes** (CSV→map / 2+2 concat) so re-linting hardened output does not false-positive `bla_lint_lanes`; host probes all arity-2 exports for FLAG{-shaped results. Honesty: full WASM RE + online guessing remain theoretical; never embed harden `--seed` in artifacts. Round-9 **red (NO PRIZE)**: rand rounds/pad3 **closes** R8 structural KP; hardened `bla_lint_lanes` clean; R7 seal-XOR-KP / R6 sidecar / SHA-256 KDF invert / self-seal still **held**. Residuals — full WASM RE + online guess vs commitment (P2); arity-2 alias forest (~251 unlock aliases + garbage first-hit decoy) mitigated by host FLAG-shape probe (P3); JS honeypot/canary ≠WASM unlock (P3). No new bankrupt refuse lint (no prize packaging footgun under hard rules).+**Principles (red-blue round-1+2+3+4+5+6+7+7b+8+9+10):** do not ship a stable public WASM ABI without an explicit `wasm_preserve_exports` list; do not leave JS-side independent lane tables — prefer whole-key chained mixing (`bla_lint_lanes` / harden refuse). **Do not** place plaintext seal/catalog JSON (`revision`, salts, certificate ciphertext) beside hardened outputs. Public compare targets must be **one-way** (SHA-256/HMAC/etc.); reversible ARX/Feistel digests as public `revision` are a key-recovery footgun (round-2 break — **closed in round-3** when seal is digests-only). Enforce with `bla_lint_seal` / `bla lint-seal`; bankrupt harden **refuses** unless `allow_plaintext_seal` / `--allow-plaintext-seal`. Round-3 residual **gates**: `bla_lint_wasm_params` / `bla lint-wasm-params` — bankrupt refuses clear `R2SEAL`/`R3PARM`/`R3CIPH`-class carriers unless `allow_wasm_clear_params`; `bla_lint_panel_derive` — maximum/bankrupt **rewrites** `__vaultPanelDerive_*` to `_blaPd_*` unless `allow_stable_panel_derive`; bankrupt harden sets `selfSealRecommended` for multi-artifact trees (never auto for single-file) — prefer **`self_seal`**. Round-4 gates: `bla_lint_js_aes_unwrap` / `bla lint-js-aes-unwrap` — bankrupt **refuses** JS wrap-key + `create*iv` + fixed sealed hdr (e.g. `d17ea004`) unless `allow_js_aes_unwrap` (gate only — **not** white-box AES; prefer in-WASM unwrap). `bla_lint_panel_derive` flags `deriveLocal` (rewritten to `_blaPdLocal_*`) and **refuses** `deriveLocal` + plaintext `panelTokenSha256` offline-oracle packaging unless `allow_panel_offline_oracle` (rename is not a crypto fix — scrub digests / avoid derive UI). `self_seal` embeds **expected sibling SHA-256 hard-fail** when siblings exist at protect time (harden processes JS last); opaque-seed entanglement alone does **not** gate entitlement control flow. Round-5 gates: `bla_lint_js_wasm_hydrate_dump` / `bla lint-js-wasm-hydrate-dump` — bankrupt **refuses** JS that copies salt/rounds/cipher from `WebAssembly.Memory` after hydrate/instantiate unless `allow_js_wasm_hydrate_dump` (host memory dump needs **no** Node `create*iv`; export rename alone does not close this — prefer keep ARX+certify **inside** WASM so params never re-enter JS). Round-6 product pattern: export `unlock(keyPtr,keyLen)->outLen` (or equivalent) so ARX+compare+decrypt stay in WASM; JS only writes key bytes and reads the result — do **not** call hydrate then decode salt/rounds/cipher in JS (closes the round-5 host memory-dump residual under bankrupt defaults). Honesty: WASM reverse-engineering of the unlock body remains a theoretical surface; gates do not claim white-box secrecy. Round-6 **break residual**: do **not** store a plaintext XOR mask adjacent to a masked entitlement pack (`salt||rounds||expected-words||cipher`) in WASM data — static unmask needs no key; combined with invertible ARX expected-state compare this recovers the prize (`bla_lint_wasm_xor_mask_sidecar` / `bla lint-wasm-xor-mask-sidecar`; bankrupt refuses unless `allow_wasm_xor_mask_sidecar`). Prefer key-dependent unmask and **one-way** commitments inside WASM (not reversible expected words). Round-7 product pattern: keep unlock-in-WASM; derive the XOR mask from the key inside `unlock` (do **not** embed a plaintext mask beside the blob); store a SHA-256 commitment of the ARX state for compare (not invertible expected words). Round-7 **break residual**: do **not** place public `seal.revision` (or other public digests) as plaintext under a repeating XOR mask in WASM data — `revision` XOR `masked[8..40)` recovers the mask with no key; combined with an algebraically weak key-dependent mask KDF this recovers the prize (`bla_lint_wasm_seal_xor_known_plaintext` / `bla lint-wasm-seal-xor-known-plaintext`; bankrupt refuses unless `allow_wasm_seal_xor_known_plaintext`). Prefer a one-way mask KDF (e.g. SHA-256(key||i)) and keep public digests **out** of the masked plaintext prefix (or bind revision differently). Round-8 product pattern: derive the XOR mask with a **one-way** KDF such as `SHA-256(key[16])` (never an algebraically invertible byte mix); put an entropy/random pad — **not** `seal.revision` — in the masked pack prefix; keep the SHA-256 ARX commitment in a **separate clear data segment** (or otherwise outside the XOR-masked layout) so public digests cannot serve as XOR known-plaintext. Honesty: full WASM reverse-engineering of unlock can still recover algorithms; gates close packaging footguns, not white-box secrecy. Round-8 **red (NO PRIZE)**: SHA-256(key) mask KDF + commitment-outside-XOR **held** against the round-7 seal.revision XOR known-plaintext oracle and algebraic mask invert; residuals — structural KP of fixed rounds/zero pad3 leaks only a few mask bytes; arity-2 decoy aliases; bankrupt JS decoys may false-positive `bla_lint_lanes` on hardened *output*; online guessing after full WASM RE remains a theoretical surface (not a packaging refuse gate). Round-9 product pattern: keep R8 SHA-256(key) mask KDF + commitment-outside-XOR; **randomize pack header `pad3`** and avoid fixed `rounds` immediates (seed-derived rounds in-range) so structural KP cannot leak `mask[4..7]`; emit bankrupt shadow-heap decoy shares/words in **non-lane-array shapes** (CSV→map / 2+2 concat) so re-linting hardened output does not false-positive `bla_lint_lanes`; host probes all arity-2 exports for FLAG{-shaped results. Honesty: full WASM RE + online guessing remain theoretical; never embed harden `--seed` in artifacts. Round-9 **red (NO PRIZE)**: rand rounds/pad3 **closes** R8 structural KP; hardened `bla_lint_lanes` clean; R7 seal-XOR-KP / R6 sidecar / SHA-256 KDF invert / self-seal still **held**. Residuals — full WASM RE + online guess vs commitment (P2); arity-2 alias forest (~251 unlock aliases + garbage first-hit decoy) mitigated by host FLAG-shape probe (P3); JS honeypot/canary ≠WASM unlock (P3). No new bankrupt refuse lint (no prize packaging footgun under hard rules). Round-10 product pattern: keep R8–R9 crypto (SHA-256(key) mask KDF, commitment outside XOR, seed-derived rounds/pad3, entropy≠revision); **arity-2 hygiene** — bankrupt long-name decoy aliases are **spread across exported function indices** (not piled onto funcIndex 0 / unlock); cleartext exports put the real unlock **first among arity-2** so renamed first-hit is not a mandatory garbage pitfall, while names still rename under bankrupt (no stable plaintext ABI without `wasm_preserve_exports`); host resolves by **type/arity `(i32,i32)->i32` + `FLAG{…}` shape + `sha256(result)===seal.certificateSha256`** (not bare export name). Honesty: **JS honeypot/canary keys short-circuit in the host** and print an `UNLOCKED?` decoy that does **not** call WASM unlock and will **not** match `certificateSha256` if verified — distinct from product unlock (document; not a packaging refuse). Gates still do **not** claim white-box secrecy; P2 residual remains full WASM RE + online/SMT vs commitment.## Prerequisites (once)diff --git a/src/shields/formats/wasm.ts b/src/shields/formats/wasm.tsindex e384507..9ad9ee2 100644--- a/src/shields/formats/wasm.ts+++ b/src/shields/formats/wasm.ts@@ -209,12 +209,53 @@ function appendDecoyExports(]);}+/**+ * Collect unique function-export indices from a WASM binary (kind 0 only).+ * Used so bankrupt decoy aliases can be spread across real stubs + unlock+ * instead of all aliasing funcIndex 0 (red/blue round-10 arity-2 hygiene).+ */+function collectExportedFuncIndices(bytes: Buffer): number[] {+ if (+ bytes.length < 8 ||+ bytes[0] !== 0x00 ||+ bytes[1] !== 0x61 ||+ bytes[2] !== 0x73 ||+ bytes[3] !== 0x6d+ ) {+ return [];+ }+ let offset = 8;+ while (offset < bytes.length) {+ const sectionId = bytes[offset++]!;+ const { value: sectionSize, nextOffset } = decodeUnsignedLeb128(bytes, offset);+ const sectionEnd = nextOffset + sectionSize;+ if (sectionEnd > bytes.length) break;+ if (sectionId === 7) {+ const payload = bytes.subarray(nextOffset, sectionEnd);+ const entries = parseWasmExportSectionPayload(payload);+ const seen = new Set<number>();+ const out: number[] = [];+ for (const e of entries) {+ if (e.kind !== 0) continue;+ if (seen.has(e.index)) continue;+ seen.add(e.index);+ out.push(e.index);+ }+ return out;+ }+ offset = sectionEnd;+ }+ return [];+}+function planWasmExportNameDecoys(prng: SeededPrng,intensity: ProtectionIntensity,- funcIndex: number,+ funcIndices: readonly number[],): readonly { readonly name: string; readonly funcIndex: number }[] {// bankrupt: ~250 Ă— ~12 KiB names → Wabt interface charge ≫ 32 MiB.+ // Round-10: spread aliases across exported function indices (stubs + unlock)+ // so ~all-250 do not concentrate on funcIndex 0 / the real unlock body.const count =intensity === "stealth"? 0@@ -225,12 +266,14 @@ function planWasmExportNameDecoys(: 250;const namePad = intensity === "bankrupt" ? 12_000 : intensity === "maximum" ? 48 : 16;const tag = prng.hex(4);+ const indices =+ funcIndices.length > 0 ? prng.shuffle([...new Set(funcIndices)]) : [0];const out: { name: string; funcIndex: number }[] = [];for (let i = 0; i < count; i++) {const pad = "e".repeat(namePad);out.push({name: `enclave_export_${tag}_${i}_${pad}`,- funcIndex,+ funcIndex: indices[i % indices.length]!,});}return out;@@ -417,7 +460,12 @@ export function protectWasmBinary(// At bankrupt intensity, densify the export section with long-name aliases of// existing funcs so REA's real Wabt→WasmInterfaceBudget path trips (custom// sections alone do not expand the typed interface inventory).- const decoyExports = planWasmExportNameDecoys(prng, intensity, 0);+ // Round-10: spread aliases across all exported function indices (not only 0).+ const decoyExports = planWasmExportNameDecoys(+ prng,+ intensity,+ collectExportedFuncIndices(bytes),+ );const keptChunks: Buffer[] = [bytes.subarray(0, 8)];let offset = 8;let exportDecoysInjected = 0;diff --git a/tests/wasm-export-rename.test.ts b/tests/wasm-export-rename.test.tsindex 27e4a20..f5952c7 100644--- a/tests/wasm-export-rename.test.ts+++ b/tests/wasm-export-rename.test.ts@@ -110,3 +110,65 @@ describe("WASM export rename / semantic preservation (#40.3)", () => {expect(inspectWasmBinary(res.buffer).exportNames).toContain("compute_score");});});++describe("WASM export decoy arity-2 hygiene (red/blue round-10)", () => {+ /** Two func exports (idx 0 junk, idx 1 real) + memory — decoys must not all alias 0. */+ function fixtureTwoFuncs(): Buffer {+ // types: (i32)->i32, (i32,i32)->i32; funcs type0+type1; mem; exports junk/unlock/memory+ // junk returns 0; unlock returns a+b+ return Buffer.from([+ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0c, 0x02, 0x60, 0x01, 0x7f, 0x01, 0x7f,+ 0x60, 0x02, 0x7f, 0x7f, 0x01, 0x7f, 0x03, 0x03, 0x02, 0x00, 0x01, 0x05, 0x03, 0x01, 0x00, 0x01,+ 0x07, 0x1a, 0x03, 0x04, 0x6a, 0x75, 0x6e, 0x6b, 0x00, 0x00, 0x06, 0x75, 0x6e, 0x6c, 0x6f, 0x63,+ 0x6b, 0x00, 0x01, 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x02, 0x00, 0x0a, 0x0e, 0x02, 0x04,+ 0x00, 0x41, 0x00, 0x0b, 0x07, 0x00, 0x20, 0x00, 0x20, 0x01, 0x6a, 0x0b,+ ]);+ }++ it("bankrupt decoy aliases spread across exported function indices", () => {+ const raw = fixtureTwoFuncs();+ expect(WebAssembly.validate(new Uint8Array(raw))).toBe(true);+ const res = protectWasmBinary(raw, {+ intensity: "bankrupt",+ seed: "r10-arity2-hygiene-spread",+ // keep names so we can map decoy→index via parse of protected export section+ preserveExports: ["junk", "unlock", "memory"],+ });+ expect(res.exportDecoysInjected).toBe(250);+ expect(WebAssembly.validate(new Uint8Array(res.buffer))).toBe(true);++ // Locate export section payload and count decoy aliases per func index.+ const bytes = res.buffer;+ let offset = 8;+ let decoyIdx0 = 0;+ let decoyIdx1 = 0;+ while (offset < bytes.length) {+ const sectionId = bytes[offset++]!;+ let size = 0;+ let shift = 0;+ while (true) {+ const b = bytes[offset++]!;+ size |= (b & 0x7f) << shift;+ if ((b & 0x80) === 0) break;+ shift += 7;+ }+ const sectionEnd = offset + size;+ if (sectionId === 7) {+ const payload = bytes.subarray(offset, sectionEnd);+ const entries = parseWasmExportSectionPayload(payload);+ for (const e of entries) {+ if (e.kind !== 0) continue;+ if (!e.name.startsWith("enclave_export_")) continue;+ if (e.index === 0) decoyIdx0++;+ else if (e.index === 1) decoyIdx1++;+ }+ break;+ }+ offset = sectionEnd;+ }+ expect(decoyIdx0 + decoyIdx1).toBe(250);+ // Hygiene: both indices get a non-trivial share (not 250/0 pile-on).+ expect(decoyIdx0).toBeGreaterThan(40);+ expect(decoyIdx1).toBeGreaterThan(40);+ });+});