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.

Red/Blue round-10 · Blue

qybaihe6babe00af90a
diff --git a/.agents/skills/blind-llm-agents/SKILL.md b/.agents/skills/blind-llm-agents/SKILL.md
index 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 invent
new 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, or
attack 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.ts
index 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.ts
index 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);
+ });
+});