🛡️ 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-11 · Red
qybaihe9dd2ba8a12ce
diff --git a/.agents/skills/blind-llm-agents/SKILL.md b/.agents/skills/blind-llm-agents/SKILL.mdindex 1c40909..d98dcd8 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.19"+ version: "1.5.20"---# 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+10+11):** 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. Round-10 **red (NO PRIZE)**: arity-2 alias **spread held** (unlock wrong-key return `0` indistinguishable from stub idx; not all aliases = unlock); R8–R9 crypto surfaces (SHA-256 KDF, commitment-outside-XOR, rand rounds/pad3, seal-XOR-KP, sidecar, self-seal, lanes clean) still **held**; host FLAG+cert is a correct but impractical online oracle. Residual — bankrupt rename preserves cleartext **export order**, so “unlock first among arity-2” still makes first arity-2 the unlock body (RE shortcut, not key recovery): prefer **shuffle export order** independently of alias-index spread while host keeps probing all arity-2 + cert. No new bankrupt refuse lint (no prize packaging footgun). Round-11 product pattern: keep R8–R10 crypto + arity-2 alias spread + host arity/FLAG/certificate contract; **independently shuffle WASM export-section order** (seed-derived at maximum/bankrupt, after rename + decoy append) so “first arity-2” is **not** a stable pointer to the unlock body — host must keep probing all arity-2 candidates + `sha256===certificateSha256` (never rely on export order). Cleartext fixtures should also avoid advertising unlock-first export order. Honesty: full WASM RE + online/SMT vs commitment remains the P2 surface; gates still do not claim white-box secrecy. No new bankrupt refuse lint.+**Principles (red-blue round-1+2+3+4+5+6+7+7b+8+9+10+11):** 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. Round-10 **red (NO PRIZE)**: arity-2 alias **spread held** (unlock wrong-key return `0` indistinguishable from stub idx; not all aliases = unlock); R8–R9 crypto surfaces (SHA-256 KDF, commitment-outside-XOR, rand rounds/pad3, seal-XOR-KP, sidecar, self-seal, lanes clean) still **held**; host FLAG+cert is a correct but impractical online oracle. Residual — bankrupt rename preserves cleartext **export order**, so “unlock first among arity-2” still makes first arity-2 the unlock body (RE shortcut, not key recovery): prefer **shuffle export order** independently of alias-index spread while host keeps probing all arity-2 + cert. No new bankrupt refuse lint (no prize packaging footgun). Round-11 product pattern: keep R8–R10 crypto + arity-2 alias spread + host arity/FLAG/certificate contract; **independently shuffle WASM export-section order** (seed-derived at maximum/bankrupt, after rename + decoy append) so “first arity-2” is **not** a stable pointer to the unlock body — host must keep probing all arity-2 candidates + `sha256===certificateSha256` (never rely on export order). Cleartext fixtures should also avoid advertising unlock-first export order. Honesty: full WASM RE + online/SMT vs commitment remains the P2 surface; gates still do not claim white-box secrecy. No new bankrupt refuse lint. Round-11 **red (NO PRIZE)**: independent export-order shuffle **held** — first func export / first arity-2 is **not** unlock body (lab: unlock export-order position ≫ 0); alias spread + R8–R10 crypto (SHA-256 KDF, commitment-outside-XOR, rand rounds/pad3, seal-XOR-KP, sidecar, self-seal, lanes clean) still **held**; host FLAG+cert oracle 500Ă— → 0 prize; shuffle not predictable without `--seed` (absent from artifacts). Residual — P2 full WASM RE + online/SMT vs commitment only; optional P3 unlock stably at func idx 0 (body index, not export order). No new bankrupt refuse lint (no prize packaging footgun).## Prerequisites (once)