🛡️ 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(shields): EVM Solidity terminal metadata CBOR shield
qybaihe9e4721837bc4
diff --git a/src/shields/formats/evm-bytecode.ts b/src/shields/formats/evm-bytecode.tsnew file mode 100644index 0000000..61c95ab--- /dev/null+++ b/src/shields/formats/evm-bytecode.ts@@ -0,0 +1,160 @@+import { REA_INTERNAL_LIMITS } from "../../identity.js";+import { SeededPrng } from "../../core/prng.js";+import type { ProtectionIntensity } from "../../core/types.js";+import { buildCanaryAndDiagnosticPayloads } from "../deception/format-payloads.js";++function cborHeader(major: number, length: number): Buffer {+ if (length < 24) return Buffer.from([(major << 5) | length]);+ if (length < 256) return Buffer.from([(major << 5) | 24, length]);+ if (length < 65536) {+ const b = Buffer.alloc(3);+ b[0] = (major << 5) | 25;+ b.writeUInt16BE(length, 1);+ return b;+ }+ const b = Buffer.alloc(5);+ b[0] = (major << 5) | 26;+ b.writeUInt32BE(length, 1);+ return b;+}++function cborText(value: string): Buffer {+ const body = Buffer.from(value, "utf8");+ return Buffer.concat([cborHeader(3, body.length), body]);+}++function cborBytes(value: Buffer): Buffer {+ return Buffer.concat([cborHeader(2, value.length), value]);+}++function cborMap(entries: readonly (readonly [Buffer, Buffer])[]): Buffer {+ return Buffer.concat([+ cborHeader(5, entries.length),+ ...entries.flatMap(([k, v]) => [k, v]),+ ]);+}++/** Build Solidity terminal metadata CBOR + 2-byte big-endian length trailer. */+export function buildSolidityMetadataTrailer(+ entries: readonly (readonly [string, string | Buffer])[],+): Buffer {+ const encoded = cborMap(+ entries.map(([key, value]) => [+ cborText(key),+ typeof value === "string" ? cborText(value) : cborBytes(value),+ ]),+ );+ if (encoded.length > 0xffff) {+ throw new Error("Solidity metadata CBOR exceeds uint16 length");+ }+ const len = Buffer.alloc(2);+ len.writeUInt16BE(encoded.length);+ return Buffer.concat([encoded, len]);+}++export interface EvmBytecodeInspection {+ readonly byteLength: number;+ readonly hasSolidityMetadata: boolean;+ readonly metadataBytes: number;+ readonly blaProtected: boolean;+}++export function inspectEvmBytecode(bytes: Buffer): EvmBytecodeInspection {+ let hasSolidityMetadata = false;+ let metadataBytes = 0;+ if (bytes.length >= 3) {+ const length = bytes[bytes.length - 2]! * 256 + bytes[bytes.length - 1]!;+ const offset = bytes.length - 2 - length;+ if (length > 0 && offset >= 0 && bytes[offset]! >> 5 === 5) {+ hasSolidityMetadata = true;+ metadataBytes = length;+ }+ }+ const text = bytes.toString("utf8");+ return {+ byteLength: bytes.length,+ hasSolidityMetadata,+ metadataBytes,+ blaProtected:+ text.includes("[BLA-EVM-SHIELD]") || text.includes("bla_evm_canary"),+ };+}++/**+ * Strips a prior terminal Solidity metadata CBOR (if present) so a fresh+ * adversarial trailer can be appended without nesting length suffixes.+ */+function stripTerminalMetadata(bytes: Buffer): Buffer {+ if (bytes.length < 3) return bytes;+ const length = bytes[bytes.length - 2]! * 256 + bytes[bytes.length - 1]!;+ const offset = bytes.length - 2 - length;+ if (length > 0 && offset >= 0 && bytes[offset]! >> 5 === 5) {+ return bytes.subarray(0, offset);+ }+ return bytes;+}++/**+ * Protects EVM contract bytecode by appending Solidity-compatible terminal+ * CBOR metadata packed with canary/diagnostic strings. Optional bankrupt+ * padding inserts JUMPDEST filler before the metadata (runtime-equivalent for+ * contracts that never fall through into the padding).+ */+export function protectEvmBytecodeBuffer(+ input: Buffer,+ options: {+ readonly intensity?: ProtectionIntensity;+ readonly seed?: string;+ } = {},+): {+ readonly buffer: Buffer;+ readonly metadataBytes: number;+ readonly canaryTokensEmbedded: number;+ readonly diagnosticsEmbedded: number;+ readonly paddingBytes: number;+ readonly approachesInputBudget: boolean;+} {+ const intensity = options.intensity ?? "balanced";+ const prng = new SeededPrng(options.seed ?? "bla-evm-shield");+ const deception = buildCanaryAndDiagnosticPayloads(prng, intensity);++ const base = stripTerminalMetadata(input.length > 0 ? input : Buffer.from([0x00]));++ const metaEntries: [string, string | Buffer][] = [+ ["solc", Buffer.from([0x00, 0x08, 0x1e])], // 0.8.30+ ["bla", "[BLA-EVM-SHIELD]"],+ ["bla_evm_canary", prng.hex(16)],+ ];+ for (const rec of deception.textRecords.slice(0, 12)) {+ const key = `bla_${metaEntries.length}`;+ metaEntries.push([key, rec.slice(0, 200)]);+ }++ const metadata = buildSolidityMetadataTrailer(metaEntries);++ let padding = Buffer.alloc(0);+ if (intensity === "bankrupt" || intensity === "maximum") {+ // Approach — do not fully consume — the 4 MiB inputBytes ceiling.+ const target =+ intensity === "bankrupt"+ ? Math.min(+ REA_INTERNAL_LIMITS.EVM_INPUT_BYTES - 64 * 1024,+ base.length + metadata.length + 256 * 1024,+ )+ : base.length + metadata.length + 16 * 1024;+ const need = Math.max(0, target - base.length - metadata.length);+ // 0x5b = JUMPDEST; inert when never jumped to.+ padding = Buffer.alloc(need, 0x5b);+ }++ const buffer = Buffer.concat([base, padding, metadata]);+ return {+ buffer,+ metadataBytes: metadata.length - 2,+ canaryTokensEmbedded: deception.canary.syntheticCanaryTokens.length,+ diagnosticsEmbedded: deception.diagnostics.diagnosticsInjected.length,+ paddingBytes: padding.length,+ approachesInputBudget:+ buffer.length > REA_INTERNAL_LIMITS.EVM_INPUT_BYTES / 2,+ };+}