simple-javascript-obf 0.1.1

package/src/plugins/vm/encoding.js

@@ -0,0 +1,252 @@
+const crypto = require("crypto");
+const { concatKeys, streamXor } = require("../../utils/stream");
+
+function xorBytes(bytes, maskBytes) {
+  const mask = Uint8Array.from(maskBytes);
+  const out = Uint8Array.from(bytes);
+  for (let i = 0; i < out.length; i += 1) {
+    out[i] = out[i] ^ mask[i % mask.length];
+  }
+  return out;
+}
+
+function encodeBytecode(code, rng) {
+  const keyLength = rng.int(5, 12);
+  const keyBytes = Array.from({ length: keyLength }, () => rng.int(0, 255));
+  const bytes = new Uint8Array(code.length * 4);
+  for (let i = 0; i < code.length; i += 1) {
+    const value = code[i] >>> 0;
+    const offset = i * 4;
+    bytes[offset] = value & 255;
+    bytes[offset + 1] = (value >>> 8) & 255;
+    bytes[offset + 2] = (value >>> 16) & 255;
+    bytes[offset + 3] = (value >>> 24) & 255;
+  }
+  const encrypted = streamXor(bytes, keyBytes);
+  const encoded = encodeBytes(encrypted, rng);
+  const parts = splitPayload(encoded.encoded, rng);
+  const order = Array.from({ length: parts.length }, (_, i) => i);
+  rng.shuffle(order);
+  const shuffled = order.map((idx) => parts[idx]);
+  const alphabetInfo = splitSecret(Buffer.from(encoded.alphabet, "utf8"), rng);
+  const byteLength = encoded.length >>> 0;
+  const paramBytes = Uint8Array.from([
+    encoded.xor & 255,
+    encoded.rot & 255,
+    byteLength & 255,
+    (byteLength >>> 8) & 255,
+    (byteLength >>> 16) & 255,
+    (byteLength >>> 24) & 255,
+    0,
+    0,
+  ]);
+  const paramInfo = splitSecret(paramBytes, rng);
+  const keyInfo = splitSecret(keyBytes, rng);
+  return {
+    parts: shuffled,
+    order,
+    alphabetMasked: alphabetInfo.masked,
+    alphabetMask: alphabetInfo.mask,
+    alphabetOrder: alphabetInfo.order,
+    alphabetOrderMask: alphabetInfo.orderMask,
+    paramMasked: paramInfo.masked,
+    paramMask: paramInfo.mask,
+    paramOrder: paramInfo.order,
+    paramOrderMask: paramInfo.orderMask,
+    keyMasked: keyInfo.masked,
+    keyMask: keyInfo.mask,
+    keyOrder: keyInfo.order,
+    keyOrderMask: keyInfo.orderMask,
+  };
+}
+
+function encodeConstPool(consts, rng) {
+  const keyLength = rng.int(5, 12);
+  const keyBytes = Array.from({ length: keyLength }, () => rng.int(0, 255));
+  const maskLength = rng.int(4, 10);
+  const maskBytes = Array.from({ length: maskLength }, () => rng.int(0, 255));
+  const entries = consts.map((value) => {
+    if (value === undefined) return ["u", 0];
+    if (value === null) return ["l", 0];
+    if (typeof value === "boolean") return ["b", value ? 1 : 0];
+    if (typeof value === "number") {
+      const num =
+        Number.isNaN(value) ? "NaN" : Object.is(value, -0) ? "-0" : String(value);
+      return ["n", num];
+    }
+    if (typeof value === "string") return ["s", value];
+    return ["u", 0];
+  });
+  const json = JSON.stringify(entries);
+  const bytes = Buffer.from(json, "utf8");
+  const encrypted = streamXor(bytes, keyBytes);
+  const masked = xorBytes(encrypted, maskBytes);
+  const encoded = encodeBytes(masked, rng);
+  const parts = splitPayload(encoded.encoded, rng);
+  const order = Array.from({ length: parts.length }, (_, i) => i);
+  rng.shuffle(order);
+  const shuffled = order.map((idx) => parts[idx]);
+  const alphabetInfo = splitSecret(Buffer.from(encoded.alphabet, "utf8"), rng);
+  const byteLength = encoded.length >>> 0;
+  const paramBytes = Uint8Array.from([
+    encoded.xor & 255,
+    encoded.rot & 255,
+    byteLength & 255,
+    (byteLength >>> 8) & 255,
+    (byteLength >>> 16) & 255,
+    (byteLength >>> 24) & 255,
+    0,
+    0,
+  ]);
+  const paramInfo = splitSecret(paramBytes, rng);
+  const keyInfo = splitSecret(keyBytes, rng);
+  const maskInfo = splitSecret(maskBytes, rng);
+  return {
+    parts: shuffled,
+    order,
+    alphabetMasked: alphabetInfo.masked,
+    alphabetMask: alphabetInfo.mask,
+    alphabetOrder: alphabetInfo.order,
+    alphabetOrderMask: alphabetInfo.orderMask,
+    paramMasked: paramInfo.masked,
+    paramMask: paramInfo.mask,
+    paramOrder: paramInfo.order,
+    paramOrderMask: paramInfo.orderMask,
+    keyMasked: keyInfo.masked,
+    keyMask: keyInfo.mask,
+    keyOrder: keyInfo.order,
+    keyOrderMask: keyInfo.orderMask,
+    maskMasked: maskInfo.masked,
+    maskMask: maskInfo.mask,
+    maskOrder: maskInfo.order,
+    maskOrderMask: maskInfo.orderMask,
+  };
+}
+
+function splitPayload(payload, rng) {
+  const parts = [];
+  let index = 0;
+  while (index < payload.length) {
+    const size = rng.int(12, 42);
+    parts.push(payload.slice(index, index + size));
+    index += size;
+  }
+  return parts.length ? parts : [payload];
+}
+
+function buildAlphabet(rng) {
+  const pool =
+    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
+  const chars = pool.split("");
+  rng.shuffle(chars);
+  return chars.join("");
+}
+
+function encodeBytes(bytes, rng) {
+  const alphabet = buildAlphabet(rng);
+  const xor = rng.int(1, 63);
+  const rot = rng.int(0, 63);
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    const triple = (b0 << 16) | (b1 << 8) | b2;
+    for (let j = 0; j < 4; j += 1) {
+      const sextet = (triple >> (18 - j * 6)) & 63;
+      const mixed = ((sextet + rot) & 63) ^ xor;
+      out += alphabet[mixed];
+    }
+  }
+  return {
+    alphabet,
+    xor,
+    rot,
+    encoded: out,
+    length: bytes.length,
+  };
+}
+
+function splitSecret(bytes, rng) {
+  const order = Array.from({ length: bytes.length }, (_, i) => i);
+  rng.shuffle(order);
+  const masked = [];
+  const mask = [];
+  for (let i = 0; i < order.length; i += 1) {
+    const value = bytes[order[i]];
+    const m = rng.int(0, 255);
+    masked.push(value ^ m);
+    mask.push(m);
+  }
+  const orderMask = rng.int(1, 255);
+  const orderEnc = order.map((idx) => idx ^ orderMask);
+  return {
+    masked,
+    mask,
+    order: orderEnc,
+    orderMask,
+  };
+}
+
+function encodeOpcodeTable(opcodeDecode, rng) {
+  const length = opcodeDecode.length;
+  const keyBytes = crypto.randomBytes(12);
+  const ivBytes = crypto.randomBytes(8);
+  const tag = crypto.randomBytes(10);
+  const fullKey = concatKeys(keyBytes, ivBytes, tag);
+  const input = Buffer.from(Uint8Array.from(opcodeDecode));
+  const ciphertext = streamXor(input, fullKey);
+  const encoded = encodeBytes(ciphertext, rng);
+  const parts = splitPayload(encoded.encoded, rng);
+  const order = Array.from({ length: parts.length }, (_, i) => i);
+  rng.shuffle(order);
+  const shuffled = order.map((idx) => parts[idx]);
+  const keyInfo = splitSecret(keyBytes, rng);
+  const ivInfo = splitSecret(ivBytes, rng);
+  const tagInfo = splitSecret(tag, rng);
+  const alphabetInfo = splitSecret(Buffer.from(encoded.alphabet, "utf8"), rng);
+  const cipherLength = encoded.length >>> 0;
+  const opsLength = length >>> 0;
+  const paramBytes = Uint8Array.from([
+    encoded.xor & 255,
+    encoded.rot & 255,
+    cipherLength & 255,
+    (cipherLength >>> 8) & 255,
+    (cipherLength >>> 16) & 255,
+    (cipherLength >>> 24) & 255,
+    opsLength & 255,
+    (opsLength >>> 8) & 255,
+  ]);
+  const paramInfo = splitSecret(paramBytes, rng);
+  return {
+    parts: shuffled,
+    order,
+    alphabetMasked: alphabetInfo.masked,
+    alphabetMask: alphabetInfo.mask,
+    alphabetOrder: alphabetInfo.order,
+    alphabetOrderMask: alphabetInfo.orderMask,
+    paramMasked: paramInfo.masked,
+    paramMask: paramInfo.mask,
+    paramOrder: paramInfo.order,
+    paramOrderMask: paramInfo.orderMask,
+    keyMasked: keyInfo.masked,
+    keyMask: keyInfo.mask,
+    keyOrder: keyInfo.order,
+    keyOrderMask: keyInfo.orderMask,
+    ivMasked: ivInfo.masked,
+    ivMask: ivInfo.mask,
+    ivOrder: ivInfo.order,
+    ivOrderMask: ivInfo.orderMask,
+    tagMasked: tagInfo.masked,
+    tagMask: tagInfo.mask,
+    tagOrder: tagInfo.order,
+    tagOrderMask: tagInfo.orderMask,
+  };
+}
+
+module.exports = {
+  encodeBytecode,
+  encodeConstPool,
+  encodeOpcodeTable,
+  splitPayload,
+};

package/src/plugins/vm/index.js

@@ -0,0 +1,366 @@
+const { OPCODES } = require("./constants");
+const { buildOpcodeMapping } = require("./mapping");
+const {
+  encodeBytecode,
+  encodeConstPool,
+  encodeOpcodeTable,
+} = require("./encoding");
+const { buildVmRuntime } = require("./runtime");
+const { VmCompiler } = require("./compiler");
+const { makeLiteral } = require("./ast-utils");
+const {
+  canVirtualize,
+  collectLocals,
+  normalizeFunction,
+  rewriteClosureRefs,
+} = require("./normalize");
+const { compileStatement } = require("./emit");
+
+function createMiniVmInfo(rng) {
+  const pool = Array.from({ length: 256 }, (_, i) => i);
+  rng.shuffle(pool);
+  const mask = rng.int(1, 255);
+  const ops = pool.slice(0, 4).map((value) => value ^ mask);
+  return { mask, ops };
+}
+
+function buildMiniVmProgram(ops, blocks) {
+  const [opPush, opRebuild, opToStr, opStore] = ops;
+  const program = [];
+  for (const block of blocks) {
+    for (const idx of block.pool) {
+      program.push(opPush, idx);
+    }
+    program.push(opRebuild);
+    if (block.toString === true) {
+      program.push(opToStr);
+    }
+    program.push(opStore, block.store);
+  }
+  return program;
+}
+
+function shouldVirtualize(fnPath, options) {
+  if (options.all) {
+    return true;
+  }
+  const name = fnPath.node.id ? fnPath.node.id.name : null;
+  if (name && options.include && options.include.includes(name)) {
+    return true;
+  }
+  const comments = fnPath.node.leadingComments || [];
+  return comments.some((c) => c.value.includes("@vm"));
+}
+
+function applyVmToFunction(fnPath, ctx, runtimeIds) {
+  if (!canVirtualize(fnPath, ctx)) {
+    return false;
+  }
+  if (!normalizeFunction(fnPath, ctx)) {
+    return false;
+  }
+
+  const envId = ctx.t.identifier(ctx.nameGen.next());
+  const envThisKey = `__vm_this_${ctx.rng.int(1, 1e9)}`;
+  const envArgsKey = `__vm_args_${ctx.rng.int(1, 1e9)}`;
+  const envNewTargetKey = `__vm_new_target_${ctx.rng.int(1, 1e9)}`;
+
+  rewriteClosureRefs(fnPath, ctx, envId, envThisKey, envArgsKey);
+
+  const locals = collectLocals(fnPath);
+  const opcodeMapping = buildOpcodeMapping(ctx);
+  const compiler = new VmCompiler(ctx, locals, opcodeMapping);
+  const state = {
+    ctx,
+    locals,
+    breakLabel: null,
+    continueLabel: null,
+    isAsync: fnPath.node.async,
+    newTargetKey: envNewTargetKey,
+    withStack: [],
+  };
+
+  for (const stmt of fnPath.node.body.body) {
+    if (!compileStatement(stmt, compiler, state)) {
+      return false;
+    }
+  }
+
+  compiler.emit(OPCODES.PUSH_CONST, compiler.addConst(undefined));
+  compiler.emit(OPCODES.RETURN);
+
+  const codeId = ctx.t.identifier(ctx.nameGen.next());
+  const constId = ctx.t.identifier(ctx.nameGen.next());
+  const useBytecodeEncrypt = ctx.options.vm.bytecodeEncrypt !== false;
+  const useConstEncrypt = ctx.options.vm.constsEncrypt !== false;
+  const makeNumArray = (values) =>
+    ctx.t.arrayExpression(values.map((value) => ctx.t.numericLiteral(value)));
+  const makeStrArray = (values) =>
+    ctx.t.arrayExpression(values.map((value) => ctx.t.stringLiteral(value)));
+  const makePool = (values) =>
+    ctx.t.arrayExpression(
+      values.map((value) =>
+        Array.isArray(value)
+          ? makeNumArray(value)
+          : ctx.t.numericLiteral(value)
+      )
+    );
+  let codeInit = ctx.t.arrayExpression(
+    compiler.code.map((n) => ctx.t.numericLiteral(n))
+  );
+  if (useBytecodeEncrypt && runtimeIds.bytecodeDecodeName) {
+    const meta = encodeBytecode(compiler.code, ctx.rng);
+    const partsExpr = makeStrArray(meta.parts);
+    const orderExpr = makeNumArray(meta.order);
+    const poolExpr = makePool([
+      meta.alphabetMasked,
+      meta.alphabetMask,
+      meta.alphabetOrder,
+      meta.alphabetOrderMask,
+      meta.paramMasked,
+      meta.paramMask,
+      meta.paramOrder,
+      meta.paramOrderMask,
+      meta.keyMasked,
+      meta.keyMask,
+      meta.keyOrder,
+      meta.keyOrderMask,
+    ]);
+    codeInit = ctx.t.callExpression(
+      ctx.t.identifier(runtimeIds.bytecodeDecodeName),
+      [partsExpr, orderExpr, poolExpr]
+    );
+  }
+  let constInit = ctx.t.arrayExpression(
+    compiler.consts.map((value) => makeLiteral(ctx.t, value))
+  );
+  if (useConstEncrypt && runtimeIds.constDecodeName) {
+    const meta = encodeConstPool(compiler.consts, ctx.rng);
+    const payloadExpr = makeStrArray(meta.parts);
+    const orderExpr = makeNumArray(meta.order);
+    const poolExpr = makePool([
+      meta.alphabetMasked,
+      meta.alphabetMask,
+      meta.alphabetOrder,
+      meta.alphabetOrderMask,
+      meta.paramMasked,
+      meta.paramMask,
+      meta.paramOrder,
+      meta.paramOrderMask,
+      meta.keyMasked,
+      meta.keyMask,
+      meta.keyOrder,
+      meta.keyOrderMask,
+      meta.maskMasked,
+      meta.maskMask,
+      meta.maskOrder,
+      meta.maskOrderMask,
+    ]);
+    constInit = ctx.t.callExpression(
+      ctx.t.identifier(runtimeIds.constDecodeName),
+      [payloadExpr, orderExpr, poolExpr]
+    );
+  }
+
+  const envProperties = [];
+  for (const name of locals) {
+    const key = ctx.t.isValidIdentifier(name)
+      ? ctx.t.identifier(name)
+      : ctx.t.stringLiteral(name);
+    const value = fnPath.node.params.some(
+      (p) => p.type === "Identifier" && p.name === name
+    )
+      ? ctx.t.identifier(name)
+      : ctx.t.identifier("undefined");
+    envProperties.push(ctx.t.objectProperty(key, value));
+  }
+  envProperties.push(
+    ctx.t.objectProperty(
+      ctx.t.stringLiteral(envThisKey),
+      ctx.t.thisExpression()
+    )
+  );
+  envProperties.push(
+    ctx.t.objectProperty(
+      ctx.t.stringLiteral(envArgsKey),
+      ctx.t.identifier("arguments")
+    )
+  );
+  envProperties.push(
+    ctx.t.objectProperty(
+      ctx.t.stringLiteral(envNewTargetKey),
+      ctx.t.metaProperty(ctx.t.identifier("new"), ctx.t.identifier("target"))
+    )
+  );
+
+  const execId = fnPath.node.async
+    ? runtimeIds.execAsyncName
+    : runtimeIds.execName;
+
+  const newBody = ctx.t.blockStatement([
+    ctx.t.variableDeclaration("const", [
+      ctx.t.variableDeclarator(codeId, codeInit),
+    ]),
+    ctx.t.variableDeclaration("const", [
+      ctx.t.variableDeclarator(constId, constInit),
+    ]),
+    ctx.t.variableDeclaration("const", [
+      ctx.t.variableDeclarator(envId, ctx.t.objectExpression(envProperties)),
+    ]),
+    ctx.t.returnStatement(
+      ctx.t.callExpression(ctx.t.identifier(execId), [
+        codeId,
+        constId,
+        envId,
+        ctx.t.thisExpression(),
+      ])
+    ),
+  ]);
+
+  fnPath.get("body").replaceWith(newBody);
+  return true;
+}
+
+function ensureRuntime(programPath, ctx) {
+  if (ctx.state.vmRuntime) {
+    return ctx.state.vmRuntime;
+  }
+  const execName = ctx.nameGen.next();
+  const execAsyncName = ctx.nameGen.next();
+  const opsName = ctx.nameGen.next();
+  const opsLookupName = ctx.nameGen.next();
+  const globalsName = ctx.nameGen.next();
+  const makeFuncName = ctx.nameGen.next();
+  const maskName = ctx.nameGen.next();
+  const opcodeB64Name = ctx.nameGen.next();
+  const miniVmName = ctx.nameGen.next();
+  const bytecodeEnabled = ctx.options.vm.bytecodeEncrypt !== false;
+  const bytecodeDecodeName = bytecodeEnabled ? ctx.nameGen.next() : null;
+  const bytecodeCacheName = bytecodeEnabled ? ctx.nameGen.next() : null;
+  const bytecodeB64Name = bytecodeEnabled ? ctx.nameGen.next() : null;
+  const bytecodeRc4Name = bytecodeEnabled ? ctx.nameGen.next() : null;
+  const constsEnabled = ctx.options.vm.constsEncrypt !== false;
+  const constDecodeName = constsEnabled ? ctx.nameGen.next() : null;
+  const constCacheName = constsEnabled ? ctx.nameGen.next() : null;
+  const constB64Name = constsEnabled ? ctx.nameGen.next() : null;
+  const constRc4Name = constsEnabled ? ctx.nameGen.next() : null;
+  const constUtf8Name = constsEnabled ? ctx.nameGen.next() : null;
+  const opcodeMapping = buildOpcodeMapping(ctx);
+  const opcodeInfo = encodeOpcodeTable(opcodeMapping.decode, ctx.rng);
+  const miniVmInfo = createMiniVmInfo(ctx.rng);
+  const miniVmPrograms = {
+    opcode: buildMiniVmProgram(miniVmInfo.ops, [
+      { pool: [0, 1, 2, 3], toString: true, store: 0 },
+      { pool: [4, 5, 6, 7], store: 1 },
+      { pool: [8, 9, 10, 11], store: 2 },
+      { pool: [12, 13, 14, 15], store: 3 },
+      { pool: [16, 17, 18, 19], store: 4 },
+    ]),
+    bytecode: buildMiniVmProgram(miniVmInfo.ops, [
+      { pool: [0, 1, 2, 3], toString: true, store: 0 },
+      { pool: [4, 5, 6, 7], store: 1 },
+      { pool: [8, 9, 10, 11], store: 2 },
+    ]),
+    consts: buildMiniVmProgram(miniVmInfo.ops, [
+      { pool: [0, 1, 2, 3], toString: true, store: 0 },
+      { pool: [4, 5, 6, 7], store: 1 },
+      { pool: [8, 9, 10, 11], store: 2 },
+      { pool: [12, 13, 14, 15], store: 3 },
+    ]),
+  };
+  const runtime = buildVmRuntime(
+    {
+      execName,
+      execAsyncName,
+      opsName,
+      opsLookupName,
+      globalsName,
+      makeFuncName,
+      maskName,
+      opcodeB64Name,
+      miniVmName,
+      bytecodeDecodeName,
+      bytecodeCacheName,
+      bytecodeB64Name,
+      bytecodeRc4Name,
+      constDecodeName,
+      constCacheName,
+      constB64Name,
+      constRc4Name,
+      constUtf8Name,
+    },
+    opcodeInfo,
+    opcodeMapping.mask,
+    miniVmInfo,
+    miniVmPrograms
+  );
+  const body = programPath.node.body;
+  let index = 0;
+  while (index < body.length) {
+    const stmt = body[index];
+    if (stmt.type === "ExpressionStatement" && stmt.directive) {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  body.splice(index, 0, ...runtime);
+  ctx.state.vmRuntime = {
+    execName,
+    execAsyncName,
+    opsName,
+    opsLookupName,
+    globalsName,
+    makeFuncName,
+    maskName,
+    opcodeB64Name,
+    miniVmName,
+    bytecodeDecodeName,
+    bytecodeCacheName,
+    bytecodeB64Name,
+    bytecodeRc4Name,
+    constDecodeName,
+    constCacheName,
+    constB64Name,
+    constRc4Name,
+    constUtf8Name,
+  };
+  ctx.state.vmRuntimeMeta = {
+    programPath,
+    index,
+    size: runtime.length,
+  };
+  return ctx.state.vmRuntime;
+}
+
+function vmPlugin(ast, ctx) {
+  const { traverse, options } = ctx;
+  let applied = false;
+  traverse(ast, {
+    Program(path) {
+      let runtimeIds = null;
+      path.traverse({
+        Function(fnPath) {
+          if (!shouldVirtualize(fnPath, options.vm)) {
+            return;
+          }
+          if (!runtimeIds) {
+            runtimeIds = ensureRuntime(path, ctx);
+          }
+          const didApply = applyVmToFunction(fnPath, ctx, runtimeIds);
+          if (didApply) {
+            applied = true;
+          }
+        },
+      });
+      if (!applied && ctx.state.vmRuntimeMeta) {
+        const { programPath, index, size } = ctx.state.vmRuntimeMeta;
+        programPath.node.body.splice(index, size);
+        ctx.state.vmRuntime = null;
+        ctx.state.vmRuntimeMeta = null;
+      }
+    },
+  });
+}
+
+module.exports = vmPlugin;

package/src/plugins/vm/mapping.js

@@ -0,0 +1,24 @@
+const { OPCODE_NAMES } = require("./constants");
+
+function buildOpcodeMapping(ctx) {
+  if (ctx.state.vmOpcodeMapping) {
+    return ctx.state.vmOpcodeMapping;
+  }
+  const count = OPCODE_NAMES.length;
+  const base = Array.from({ length: count }, (_, i) => i);
+  const shuffled = base.slice();
+  if (ctx.options.vm.opcodeShuffle) {
+    ctx.rng.shuffle(shuffled);
+  }
+  const encode = new Array(count);
+  const decode = new Array(count);
+  for (let i = 0; i < count; i += 1) {
+    encode[i] = shuffled[i];
+    decode[shuffled[i]] = i;
+  }
+  const mask = ctx.rng.int(1, 255);
+  ctx.state.vmOpcodeMapping = { encode, decode, mask };
+  return ctx.state.vmOpcodeMapping;
+}
+
+module.exports = { buildOpcodeMapping };