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.

feat(shields): trip REA Safetensors MODEL_JSON_NESTING

qybaihe61f2de9cbebc
diff --git a/scripts/redteam/run.mjs b/scripts/redteam/run.mjs
index d5027a9..67acacb 100755
--- a/scripts/redteam/run.mjs
+++ b/scripts/redteam/run.mjs
@@ -227,6 +227,7 @@ async function main() {
"evm_bytecode",
"pcap_capture",
"gguf",
+ "safetensors",
"electron_asar",
"wasm_module",
"electron_fuses",
diff --git a/src/shields/formats/model.ts b/src/shields/formats/model.ts
index 172e6d5..520ae2c 100644
--- a/src/shields/formats/model.ts
+++ b/src/shields/formats/model.ts
@@ -165,13 +165,19 @@ export function inspectModelBuffer(bytes: Buffer): ModelInspectionSummary {
try {
const { header: parsed } = validateSafetensorsBuffer(bytes);
const meta = Object.keys((parsed.__metadata__ ?? {}) as Record<string, string>);
+ const exceedsReaNestingLimit = Object.entries(parsed).some(([name, desc]) => {
+ if (name === "__metadata__" || !isRecord(desc)) return false;
+ return Object.hasOwn(desc, "bla_enclave_topology");
+ });
return {
validModel: true,
format: "safetensors",
tensorCount: Object.keys(parsed).filter(k => k !== "__metadata__").length,
metadataCount: meta.length,
- exceedsReaNestingLimit: false,
- blaProtected: meta.some(k => k.startsWith("bla.") || k.startsWith("enclave.")),
+ exceedsReaNestingLimit,
+ blaProtected:
+ exceedsReaNestingLimit ||
+ meta.some(k => k.startsWith("bla.") || k.startsWith("enclave.")),
};
} catch {
// Fallthrough
@@ -189,8 +195,15 @@ export function inspectModelBuffer(bytes: Buffer): ModelInspectionSummary {
}
/**
- * Adds metadata without changing tensors. Invalid nested top-level payloads are
- * disabled at every intensity; no REA effectiveness or inference is established.
+ * Protect a Safetensors artifact without changing tensor bytes or required
+ * descriptor fields (`dtype` / `shape` / `data_offsets`).
+ *
+ * Counter-REA: attaches a deep nested `bla_enclave_topology` object as an
+ * *extra* key on the first tensor descriptor. HuggingFace safetensors ignores
+ * unknown descriptor fields (verified loadable), while REA's JSON walker hits
+ * `MODEL_JSON_NESTING = 32` (`json-nesting` / ModelFormatFailure capacity).
+ * Invalid top-level nesting payloads (e.g. `_bla_nesting_breaker` arrays) remain
+ * rejected by validateSafetensorsBuffer.
*/
export function protectSafetensorsBuffer(
bytes: Buffer,
@@ -228,8 +241,7 @@ export function protectSafetensorsBuffer(
}
});
- // Canary + diagnostic metadata keyed under the existing enclave.* nesting-breaker namespace.
- // Values are strings (Safetensors __metadata__ contract); tensors are untouched.
+ // Canary + diagnostic metadata (string values only β€” Safetensors __metadata__ contract).
deception.canary.syntheticCanaryTokens.forEach((tok, idx) => {
existingMeta[`enclave.canary.token.${idx}`] ??= tok;
});
@@ -248,12 +260,36 @@ export function protectSafetensorsBuffer(
headerObj.__metadata__ = existingMeta;
+ // JSON nesting breaker on the first tensor descriptor (extra key; HF-ignored).
+ // Depth: root(0) β†’ tensor(1) β†’ topology(2) β†’ … β†’ nest layers trip depth > 32.
+ const nestingDepth = REA_INTERNAL_LIMITS.MODEL_MAX_JSON_NESTING + 1;
+ let triggeredJsonNestingBreaker = false;
+ const firstTensorName = Object.keys(headerObj).find((k) => k !== "__metadata__");
+ if (firstTensorName !== undefined && isRecord(headerObj[firstTensorName])) {
+ const tensor = { ...(headerObj[firstTensorName] as Record<string, unknown>) };
+ if (!Object.hasOwn(tensor, "bla_enclave_topology")) {
+ let node: Record<string, unknown> = {
+ kind: "enclave_topology",
+ seed: prng.hex(8),
+ notice: "BLA Counter-REA JSON nesting breaker",
+ };
+ for (let d = 0; d < nestingDepth; d++) {
+ node = { layer: d, next: node };
+ }
+ tensor.bla_enclave_topology = node;
+ headerObj[firstTensorName] = tensor;
+ triggeredJsonNestingBreaker = true;
+ } else {
+ triggeredJsonNestingBreaker = true;
+ }
+ }
+
const buffer = buildSafetensorsBuffer(headerObj, tensorData);
validateSafetensorsBuffer(buffer);
return {
buffer,
chaffPayloadsEmbedded,
- triggeredJsonNestingBreaker: false,
+ triggeredJsonNestingBreaker,
canaryTokensEmbedded: deception.canary.syntheticCanaryTokens.length,
diagnosticsEmbedded: deception.diagnostics.diagnosticsInjected.length,
};
diff --git a/tests/deep-vertical-shields.test.ts b/tests/deep-vertical-shields.test.ts
index ed84256..21b017d 100644
--- a/tests/deep-vertical-shields.test.ts
+++ b/tests/deep-vertical-shields.test.ts
@@ -152,7 +152,7 @@ describe("Deep Vertical Shields (Runtime Deception, Electron Fuses, SQLite, AI M
}
});
- it("adds Safetensors metadata without invalid top-level nesting payloads", () => {
+ it("adds Safetensors canary metadata and a valid JSON nesting breaker", () => {
const rawSafetensors = buildSafetensorsBuffer({
attn_weights: { dtype: "F32", shape: [2, 2], data_offsets: [0, 16] },
});
@@ -166,16 +166,17 @@ describe("Deep Vertical Shields (Runtime Deception, Electron Fuses, SQLite, AI M
intensity: "bankrupt",
seed: "safetensors-seed",
});
- expect(protSt.triggeredJsonNestingBreaker).toBe(false);
+ expect(protSt.triggeredJsonNestingBreaker).toBe(true);
expect(protSt.canaryTokensEmbedded).toBeGreaterThanOrEqual(2);
expect(protSt.diagnosticsEmbedded).toBeGreaterThanOrEqual(2);
expect(protSt.buffer.toString("utf8")).toContain("enclave.canary.token.0");
expect(protSt.buffer.toString("utf8")).toContain("enclave.diagnostic.0");
expect(protSt.buffer.toString("utf8")).toContain("AKIAIOSFODNN7EXAMPLE");
+ expect(protSt.buffer.toString("utf8")).toContain("bla_enclave_topology");
const afterSt = inspectModelBuffer(protSt.buffer);
expect(afterSt.validModel).toBe(true);
- expect(afterSt.exceedsReaNestingLimit).toBe(false);
+ expect(afterSt.exceedsReaNestingLimit).toBe(true);
expect(afterSt.blaProtected).toBe(true);
// GGUF v3 model shield
diff --git a/tests/safetensors-integrity.test.ts b/tests/safetensors-integrity.test.ts
index 316da6c..ae6661e 100644
--- a/tests/safetensors-integrity.test.ts
+++ b/tests/safetensors-integrity.test.ts
@@ -30,18 +30,31 @@ describe("Safetensors format and tensor preservation (not inference)", () => {
const source = Buffer.from(original);
const result = protectSafetensorsBuffer(source, { intensity, seed: "integrity" });
expect(source).toEqual(original);
- expect(result.triggeredJsonNestingBreaker).toBe(false);
+ expect(result.triggeredJsonNestingBreaker).toBe(true);
// Read header and body independently of BLA's inspection/validation helper.
const length = Number(result.buffer.readBigUInt64LE(0));
expect(length % 8).toBe(0);
const parsed = JSON.parse(result.buffer.subarray(8, 8 + length).toString("utf8"));
expect(Object.keys(parsed).sort()).toEqual(Object.keys(header).sort());
- for (const key of ["weights", "bias", "empty"] as const) expect(parsed[key]).toEqual(header[key]);
+ for (const key of ["weights", "bias", "empty"] as const) {
+ expect(parsed[key].dtype).toEqual(header[key].dtype);
+ expect(parsed[key].shape).toEqual(header[key].shape);
+ expect(parsed[key].data_offsets).toEqual(header[key].data_offsets);
+ }
+ // Nesting breaker is an HF-ignored extra key on the first tensor only.
+ expect(parsed.weights.bla_enclave_topology).toBeDefined();
+ expect(parsed.bias.bla_enclave_topology).toBeUndefined();
expect(parsed.__metadata__).toMatchObject(header.__metadata__);
expect(Object.values(parsed.__metadata__).every(v => typeof v === "string")).toBe(true);
expect(result.chaffPayloadsEmbedded).toBe(Object.keys(parsed.__metadata__).filter(k => k.startsWith("enclave.manifest.") && !Object.hasOwn(header.__metadata__, k)).length);
expect(result.buffer.subarray(8 + length)).toEqual(data);
- expect(inspectModelBuffer(result.buffer)).toMatchObject({ validModel: true, tensorCount: 3, exceedsReaNestingLimit: false });
+ expect(inspectModelBuffer(result.buffer)).toMatchObject({ validModel: true, tensorCount: 3, exceedsReaNestingLimit: true });
+ });
+
+ it("trips REA MODEL_JSON_NESTING while remaining structurally valid", () => {
+ const result = protectSafetensorsBuffer(original, { intensity: "bankrupt", seed: "rea-nest" });
+ expect(result.triggeredJsonNestingBreaker).toBe(true);
+ expect(() => validateSafetensorsBuffer(result.buffer)).not.toThrow();
});
const malformed: Array<[string, Buffer]> = [