jsguardian 1.2.0

package/ai-callgraph-poison.js

@@ -0,0 +1,331 @@
+"use strict";
+// ============================================================================
+// Layer 3e — Callgraph Poison  (AI context-window flood)
+//
+// CONCEPT:
+//   Existing AI confusion layers (3/3b/3c) use instruction *text* — directive
+//   strings, legal notices, honeypot comments.  A model that ignores policy
+//   strings (many do) bypasses them trivially.
+//
+//   This layer attacks a different surface: **call-graph tracing cost**.
+//   AI models spend a fixed token budget tracing call graphs to understand
+//   what a function does.  We inject N seeded-random functions that form
+//   mutual-recursion clusters — directed cycles with fake base-case guards.
+//
+//   The model must trace each function to determine whether the recursion
+//   terminates (it never does, because the base-case constant is never
+//   reachable from outside), but that conclusion requires evaluating every
+//   call edge in the cluster.  With 120–200 functions across 20–35 clusters,
+//   and 10% cross-cluster edges creating a weakly-connected tangle, the
+//   effective tracing cost is O(N × cluster_size) — exhausting context
+//   budgets before the model reaches real protected functions.
+//
+// PROPERTIES:
+//   - Zero instruction text: no "STOP", "HONEYPOT", or policy strings.
+//     Purely numeric arithmetic (XOR/AND/OR/shift/add) — looks like real
+//     obfuscated hash/cipher logic.
+//   - Seeded-random structure: every build produces different function names,
+//     parameter counts, body arithmetic constants, and cluster topology.
+//   - CNE-transparent: the `__cpn_*` names are renamed to `_0x...` by
+//     cneObfuscate → applyFullRename.  MBA and string-cipher also run over
+//     the numeric constants.  In the final output the functions are
+//     indistinguishable from real VM/cipher helpers.
+//   - Dead code: never called from user code, no module.exports assignment.
+//     `require(obfFile)` still exports exactly the same functions as before.
+//   - Scatter-injected: functions are `splice()`d at random positions in the
+//     AST body, not clumped at the end.  The model cannot find real user
+//     functions by skipping a block at the top or bottom.
+//
+// TOPOLOGIES (4, randomly selected per cluster):
+//   linear:    A→B→C→A  (size 3–5, simple cycle)
+//   hub-spoke: hub→[A,B,C]; each spoke→hub  (size 3–6)
+//   diamond:   A→B,C; B→D; C→D; D→A  (size 4, branching)
+//   pseudo:    linear + every fn has `if(arg===<impossible_const>)return arg`
+//
+// CROSS-CLUSTER EDGES:
+//   10% of functions additionally call one function from a different cluster,
+//   merging the clusters into a weakly-connected tangle.
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCallgraphPoison = applyCallgraphPoison;
+// ---------------------------------------------------------------------------
+// Name generation — per-build seeded, identical format to CNE output names.
+// Using _0x prefix directly means:
+//   (a) CNE applyFullRename skips them (matches /^_0x[0-9a-f]{4,}/) — correct,
+//       they’re already in the right format.
+//   (b) No __cpn_ fingerprint remains in the output at all.
+//   (c) In the final output they are indistinguishable from real VM/cipher helpers.
+// Format mirrors makeNameGen in cne.ts: _0x + 4 hex + 2 hex = _0xXXXXXX.
+// ---------------------------------------------------------------------------
+function poisonName(rng, idx) {
+    const h = (rng.int32() ^ Math.imul(idx + 1, 0x9e3779b9)) >>> 0;
+    const part1 = (h & 0xffff).toString(16).padStart(4, "0");
+    const part2 = ((h >>> 16) & 0xff).toString(16).padStart(2, "0");
+    return `_0x${part1}${part2}`;
+}
+// ---------------------------------------------------------------------------
+// Arithmetic expression generators — all produce valid JS numeric expressions.
+// Use seeded-random constants so every build is structurally different.
+// ---------------------------------------------------------------------------
+function randConst(rng) {
+    const c = (rng.int32() >>> 0) & 0xffff;
+    return `0x${c.toString(16)}`;
+}
+function randOp(rng, a, b) {
+    const ops = [
+        `(${a} ^ ${randConst(rng)})`,
+        `(${a} & ${randConst(rng)})`,
+        `(${a} | ${randConst(rng)})`,
+        `((${a} + ${randConst(rng)}) | 0)`,
+        `(${a} >>> ${1 + (rng.int32() & 0xf)})`,
+        `(~${a} & ${randConst(rng)})`,
+        `((${a} ^ ${b}) & ${randConst(rng)})`,
+        `((${a} + ${b}) >>> ${1 + (rng.int32() & 0x7)})`,
+    ];
+    return ops[Math.floor(rng.next() * ops.length)];
+}
+// ---------------------------------------------------------------------------
+// Function body source builder.
+// paramNames: the function's own parameters
+// callTargets: 1–2 peer function names to tail-call
+// fakeBaseConst: large random hex constant for the impossible base-case guard
+// includePseudo: if true, add the impossible base-case if statement
+// ---------------------------------------------------------------------------
+function buildFunctionBody(fnName, paramNames, callTargets, fakeBaseConst, includePseudo, rng) {
+    const p0 = paramNames[0] ?? "a";
+    const p1 = paramNames[1] ?? "b";
+    const lines = [];
+    lines.push(`function ${fnName}(${paramNames.join(", ")}) {`);
+    // Fake base case — the constant is random and large, never passed externally.
+    if (includePseudo || rng.next() < 0.55) {
+        // Return one of the params (random choice) to look plausible
+        const retParam = paramNames[Math.floor(rng.next() * paramNames.length)] ?? "a";
+        lines.push(`  if (${p0} === ${fakeBaseConst}) return ${retParam};`);
+    }
+    // 0–2 intermediate variable assignments that look like cipher rounds.
+    const numVars = Math.floor(rng.next() * 3); // 0..2
+    const varNames = [];
+    for (let i = 0; i < numVars; i++) {
+        const v = `_${(rng.int32() >>> 0 & 0xfff).toString(16)}`;
+        varNames.push(v);
+        // operands: mix params and previously assigned vars
+        const sources = [...paramNames, ...varNames.slice(0, -1)];
+        const src0 = sources[Math.floor(rng.next() * sources.length)];
+        const src1 = sources[Math.floor(rng.next() * sources.length)];
+        lines.push(`  var ${v} = ${randOp(rng, src0, src1)};`);
+    }
+    // Build call arguments — use vars + params, mixed with small constants
+    const allSources = [...paramNames, ...varNames];
+    const buildArg = () => {
+        const base = allSources[Math.floor(rng.next() * allSources.length)] ?? p0;
+        if (rng.next() < 0.35)
+            return `(${base} & 0xff)`;
+        if (rng.next() < 0.35)
+            return `(${base} ^ ${randConst(rng)})`;
+        return base;
+    };
+    // Tail call — return the result of calling a peer
+    const target0 = callTargets[0];
+    if (callTargets.length >= 2 && rng.next() < 0.35) {
+        // Diamond/branching: two peers, pick one based on a runtime expression
+        const target1 = callTargets[1];
+        const pred = `(${p0} & 1)`;
+        const args0 = paramNames.map(() => buildArg()).join(", ");
+        const args1 = paramNames.map(() => buildArg()).join(", ");
+        lines.push(`  return (${pred}) ? ${target0}(${args0}) : ${target1}(${args1});`);
+    }
+    else {
+        const args = paramNames.map(() => buildArg()).join(", ");
+        lines.push(`  return ${target0}(${args});`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Topology builders — return an array of {name, src} pairs for one cluster
+// ---------------------------------------------------------------------------
+function buildLinearCluster(names, rng, pseudo) {
+    // A→B→C→...→A
+    const result = [];
+    for (let i = 0; i < names.length; i++) {
+        const fn = names[i];
+        const next = names[(i + 1) % names.length];
+        const pcount = 1 + Math.floor(rng.next() * 3); // 1..3
+        const params = Array.from({ length: pcount }, (_, k) => ["a", "b", "c"][k] ?? `p${k}`);
+        const fakeBase = `0x${((rng.int32() >>> 0) | 0x80000000).toString(16)}`;
+        const src = buildFunctionBody(fn, params, [next], fakeBase, pseudo, rng);
+        result.push({ name: fn, src });
+    }
+    return result;
+}
+function buildHubSpokeCluster(names, rng, pseudo) {
+    // names[0] = hub, names[1..] = spokes
+    const hub = names[0];
+    const spokes = names.slice(1);
+    const result = [];
+    // Hub calls a random spoke each time (runtime-selected by bitmask)
+    const pcount = 1 + Math.floor(rng.next() * 3);
+    const hubParams = Array.from({ length: pcount }, (_, k) => ["a", "b", "c"][k] ?? `p${k}`);
+    const fakeBase = `0x${((rng.int32() >>> 0) | 0x80000000).toString(16)}`;
+    // Hub body: calls the spoke chosen by (a & (spokes.length-1))
+    // We generate it manually since it needs dynamic dispatch
+    const hubLines = [
+        `function ${hub}(${hubParams.join(", ")}) {`,
+        `  if (${hubParams[0]} === ${fakeBase}) return ${hubParams[0]};`,
+        `  switch (${hubParams[0]} & ${spokes.length - 1}) {`,
+    ];
+    spokes.forEach((spoke, si) => {
+        const args = hubParams.map(p => `(${p} ^ 0x${(rng.int32() & 0xff).toString(16)})`).join(", ");
+        hubLines.push(`    case ${si}: return ${spoke}(${args});`);
+    });
+    hubLines.push(`    default: return ${spokes[0]}(${hubParams.join(", ")});`);
+    hubLines.push(`  }`);
+    hubLines.push(`}`);
+    result.push({ name: hub, src: hubLines.join("\n") });
+    // Each spoke calls hub back
+    for (const spoke of spokes) {
+        const sp = 1 + Math.floor(rng.next() * 3);
+        const spokeParams = Array.from({ length: sp }, (_, k) => ["a", "b", "c"][k] ?? `p${k}`);
+        const fb = `0x${((rng.int32() >>> 0) | 0x80000000).toString(16)}`;
+        const src = buildFunctionBody(spoke, spokeParams, [hub], fb, pseudo, rng);
+        result.push({ name: spoke, src });
+    }
+    return result;
+}
+function buildDiamondCluster(names, rng, pseudo) {
+    // A→B,C; B→D; C→D; D→A  (padded for larger clusters)
+    // For size > 4 we use: A→B,C; B→D; C→E; D→A; E→A
+    const result = [];
+    for (let i = 0; i < names.length; i++) {
+        const fn = names[i];
+        const pcount = 1 + Math.floor(rng.next() * 3);
+        const params = Array.from({ length: pcount }, (_, k) => ["a", "b", "c"][k] ?? `p${k}`);
+        const fakeBase = `0x${((rng.int32() >>> 0) | 0x80000000).toString(16)}`;
+        // Each fn calls next and, 50% of the time, the one two steps ahead
+        const next0 = names[(i + 1) % names.length];
+        const next1 = names[(i + 2) % names.length];
+        const targets = rng.next() < 0.5 ? [next0, next1] : [next0];
+        const src = buildFunctionBody(fn, params, targets, fakeBase, pseudo, rng);
+        result.push({ name: fn, src });
+    }
+    return result;
+}
+function buildCluster(names, rng) {
+    if (names.length < 2)
+        return []; // need at least 2
+    const pseudo = rng.next() < 0.5; // half clusters have explicit pseudo-base-case
+    const topo = Math.floor(rng.next() * 4);
+    switch (topo) {
+        case 0: return buildLinearCluster(names, rng, pseudo);
+        case 1: return buildHubSpokeCluster(names, rng, pseudo);
+        case 2: return buildDiamondCluster(names, rng, pseudo);
+        default: return buildLinearCluster(names, rng, true); // pseudo forced
+    }
+}
+// ---------------------------------------------------------------------------
+// Cross-cluster edge injection — rewrites the return statement of one function
+// to sometimes call into a sibling cluster.  We do this by appending an extra
+// "else" call that is reached when the main cluster detects a specific bit.
+// Actually simpler: we add a helper function whose source calls across clusters.
+// We don't want to rewrite already-generated source, so we generate a small
+// "bridge" function that calls one fn from each of two clusters.
+// ---------------------------------------------------------------------------
+function buildBridgeFn(bridgeName, srcFn, dstFn, rng) {
+    const pcount = 1 + Math.floor(rng.next() * 2);
+    const params = Array.from({ length: pcount }, (_, k) => ["a", "b"][k] ?? `p${k}`);
+    const fakeBase = `0x${((rng.int32() >>> 0) | 0x80000000).toString(16)}`;
+    const lines = [
+        `function ${bridgeName}(${params.join(", ")}) {`,
+        `  if (${params[0]} === ${fakeBase}) return ${params[0]};`,
+        `  return (${params[0]} & 1) ? ${srcFn}(${params.join(", ")}) : ${dstFn}(${params.join(", ")});`,
+        `}`,
+    ];
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+/**
+ * Inject `count` seeded-random mutual-recursion functions into the AST body,
+ * scattered at random positions.  Functions form directed cycles (clusters)
+ * with 10% cross-cluster bridge functions for a tangle effect.
+ *
+ * The injected functions are dead code — never called from user code.
+ * `module.exports` is unchanged.  All existing roundtrip tests still pass.
+ *
+ * After CNE `applyFullRename`, the `__cpn_*` names become `_0x...` and are
+ * indistinguishable from real VM/cipher helpers.  MBA also runs over the
+ * numeric constants.
+ */
+function applyCallgraphPoison(ast, _t, parse, rng, count) {
+    if (count <= 0)
+        return;
+    // ── 1. Generate all names ─────────────────────────────────────────────────
+    // Reserve ~10% of names for bridge functions (cross-cluster edges).
+    const bridgeCount = Math.max(1, Math.floor(count * 0.10));
+    const clusterCount = count - bridgeCount;
+    const clusterNames = [];
+    for (let i = 0; i < clusterCount; i++) {
+        clusterNames.push(poisonName(rng, i));
+    }
+    const bridgeNames = [];
+    for (let i = 0; i < bridgeCount; i++) {
+        bridgeNames.push(poisonName(rng, clusterCount + i));
+    }
+    // ── 2. Assign cluster members ──────────────────────────────────────────────
+    const clusters = [];
+    let ci = 0;
+    while (ci < clusterNames.length) {
+        const size = 3 + Math.floor(rng.next() * 5); // 3..7
+        clusters.push(clusterNames.slice(ci, ci + Math.min(size, clusterNames.length - ci)));
+        ci += size;
+    }
+    // ── 3. Build function sources ──────────────────────────────────────────────
+    const allEntries = [];
+    for (const cluster of clusters) {
+        if (cluster.length < 2)
+            continue; // skip singletons
+        const entries = buildCluster(cluster, rng);
+        allEntries.push(...entries);
+    }
+    // ── 4. Cross-cluster bridges ───────────────────────────────────────────────
+    if (clusters.length >= 2) {
+        for (let bi = 0; bi < bridgeNames.length; bi++) {
+            const ci0 = Math.floor(rng.next() * clusters.length);
+            let ci1 = Math.floor(rng.next() * clusters.length);
+            if (ci1 === ci0)
+                ci1 = (ci0 + 1) % clusters.length;
+            const srcFn = clusters[ci0][Math.floor(rng.next() * clusters[ci0].length)];
+            const dstFn = clusters[ci1][Math.floor(rng.next() * clusters[ci1].length)];
+            if (!srcFn || !dstFn)
+                continue;
+            const src = buildBridgeFn(bridgeNames[bi], srcFn, dstFn, rng);
+            allEntries.push({ name: bridgeNames[bi], src });
+        }
+    }
+    // ── 5. Parse each function and inject into AST at a random position ────────
+    const body = ast.program.body;
+    for (const entry of allEntries) {
+        let fnNode;
+        try {
+            const mini = parse(entry.src, {
+                sourceType: "module",
+                allowReturnOutsideFunction: true,
+                errorRecovery: false,
+            });
+            fnNode = mini.program.body[0];
+            if (!fnNode)
+                continue;
+        }
+        catch {
+            // If source generation produced invalid JS (shouldn't happen), skip.
+            continue;
+        }
+        // Mark the FunctionDeclaration node __obf to prevent VM virtualization
+        // but leave inner body nodes unmarked so MBA/string-cipher/CNE can run.
+        fnNode.__obf = true;
+        // Scatter at a random position in the current body.
+        const pos = Math.floor(rng.next() * (body.length + 1));
+        body.splice(pos, 0, fnNode);
+    }
+}