webfuscator 0.9.4

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "webfuscator",
+  "version": "0.9.4",
+  "description": "JavaScript obfuscator built on Babel",
+  "keywords": [
+    "babel",
+    "code-protection",
+    "javascript",
+    "mangler",
+    "minifier",
+    "obfuscation",
+    "obfuscator"
+  ],
+  "homepage": "https://github.com/esoware/webfuscator#readme",
+  "bugs": {
+    "url": "https://github.com/esoware/webfuscator/issues"
+  },
+  "license": "MIT",
+  "author": "Esoware",
+  "contentPolicy": {
+    "class": "dual-use"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/esoware/webfuscator.git"
+  },
+  "files": [
+    "DISCLOSURE",
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "prepublishOnly": "pnpm check",
+    "prepare": "pnpm run build",
+    "build": "node --eval \"require('node:fs').rmSync('dist', { force: true, recursive: true })\" && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "lint": "oxlint src tests",
+    "lint:fix": "oxlint --fix src tests",
+    "format": "oxfmt \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "oxfmt --check \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "knip": "knip",
+    "test": "vitest run",
+    "check": "pnpm run typecheck && pnpm run lint && pnpm run format:check && pnpm run knip && pnpm run test"
+  },
+  "dependencies": {
+    "@babel/generator": "^8.0.0",
+    "@babel/parser": "^8.0.4",
+    "@babel/traverse": "^8.0.4",
+    "@babel/types": "^8.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "knip": "^6.32.2",
+    "oxfmt": "^0.64.0",
+    "oxlint": "^1.79.0",
+    "tsc-alias": "^1.9.2",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  },
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "packageManager": "pnpm@11.22.0"
+}

package/src/analysis/constant.ts

@@ -0,0 +1,310 @@
+import type { Binding, NodePath, Scope } from '@babel/traverse'
+import * as t from '@babel/types'
+
+import {
+  declarationReaches,
+  initializerReaches,
+  readCrossesFunctionBoundary,
+} from 'src/analysis/document-order'
+import { isSideEffectFree } from 'src/analysis/purity'
+import { enclosingScopeHasDirectEval, isInsideWith } from 'src/utils/ast'
+
+export type Evaluation = { known: true; value: unknown } | { known: false }
+
+const UNKNOWN: Evaluation = { known: false }
+
+// Regexp, function, and class values are known only to be truthy. Identity,
+// contents, coercion, and `typeof` remain unknown.
+const OPAQUE_TRUTHY = Symbol('opaque-truthy')
+
+export function isOpaque(value: unknown): boolean {
+  return value === OPAQUE_TRUTHY
+}
+
+interface Env {
+  scope: Scope | undefined
+  seen: Set<Binding>
+  // Use the binding path while recursing so later declarations still hit TDZ.
+  referencePath: NodePath | undefined
+}
+
+type Evaluator = (node: t.Node, env: Env) => Evaluation
+
+const EVALUATORS: Partial<Record<t.Node['type'], Evaluator>> = {
+  NumericLiteral: (node) => ({ known: true, value: (node as t.NumericLiteral).value }),
+  StringLiteral: (node) => ({ known: true, value: (node as t.StringLiteral).value }),
+  BooleanLiteral: (node) => ({ known: true, value: (node as t.BooleanLiteral).value }),
+  NullLiteral: () => ({ known: true, value: null }),
+  BigIntLiteral: (node) => {
+    try {
+      return { known: true, value: BigInt((node as t.BigIntLiteral).value) }
+    } catch {
+      return UNKNOWN
+    }
+  },
+  RegExpLiteral: () => ({ known: true, value: OPAQUE_TRUTHY }),
+  TemplateLiteral: (node) => {
+    const template = node as t.TemplateLiteral
+    if (template.expressions.length > 0) {
+      return UNKNOWN
+    }
+    const [quasi] = template.quasis
+    return { known: true, value: quasi?.value.cooked ?? quasi?.value.raw ?? '' }
+  },
+  UnaryExpression: evaluateUnary,
+  BinaryExpression: evaluateBinary,
+  LogicalExpression: evaluateLogical,
+  ConditionalExpression: evaluateConditional,
+  Identifier: evaluateIdentifier,
+}
+
+export function evaluateConstant(
+  node: t.Node,
+  scope?: Scope,
+  referencePath?: NodePath,
+): Evaluation {
+  return run(node, { scope, seen: new Set(), referencePath })
+}
+
+function run(node: t.Node, env: Env): Evaluation {
+  const evaluator = EVALUATORS[node.type]
+  return evaluator ? evaluator(node, env) : UNKNOWN
+}
+
+function evaluateUnary(node: t.Node, env: Env): Evaluation {
+  const unary = node as t.UnaryExpression
+  if (unary.operator === 'void') {
+    return isSideEffectFree(unary.argument, env.scope, env.referencePath)
+      ? { known: true, value: undefined }
+      : UNKNOWN
+  }
+  if (unary.operator === 'delete' || unary.operator === 'throw') {
+    return UNKNOWN
+  }
+  const argument = run(unary.argument, env)
+  if (!argument.known) {
+    return UNKNOWN
+  }
+  return applyUnary(unary.operator, argument.value)
+}
+
+function evaluateBinary(node: t.Node, env: Env): Evaluation {
+  const binary = node as t.BinaryExpression
+  if (binary.operator === 'in' || binary.operator === 'instanceof') {
+    return UNKNOWN
+  }
+  if (!t.isExpression(binary.left)) {
+    return UNKNOWN
+  }
+  const left = run(binary.left, env)
+  if (!left.known) {
+    return UNKNOWN
+  }
+  const right = run(binary.right, env)
+  if (!right.known) {
+    return UNKNOWN
+  }
+  return applyBinary(binary.operator, left.value, right.value)
+}
+
+function evaluateLogical(node: t.Node, env: Env): Evaluation {
+  const logical = node as t.LogicalExpression
+  const left = run(logical.left, env)
+  if (!left.known) {
+    return UNKNOWN
+  }
+  if (logical.operator === '&&') {
+    return left.value ? run(logical.right, env) : left
+  }
+  if (logical.operator === '||') {
+    return left.value ? left : run(logical.right, env)
+  }
+  if (logical.operator === '??') {
+    return left.value === null || left.value === undefined ? run(logical.right, env) : left
+  }
+  return UNKNOWN
+}
+
+function evaluateConditional(node: t.Node, env: Env): Evaluation {
+  const conditional = node as t.ConditionalExpression
+  const test = run(conditional.test, env)
+  if (!test.known) {
+    return UNKNOWN
+  }
+  return run(test.value ? conditional.consequent : conditional.alternate, env)
+}
+
+function evaluateIdentifier(node: t.Node, env: Env): Evaluation {
+  const identifier = node as t.Identifier
+
+  if (!env.scope) {
+    return UNKNOWN
+  }
+
+  // `with` and direct `eval` can redirect names outside Babel's scope table.
+  if (
+    env.referencePath &&
+    (isInsideWith(env.referencePath) || enclosingScopeHasDirectEval(env.referencePath))
+  ) {
+    return UNKNOWN
+  }
+  const binding = env.scope.getBinding(identifier.name)
+
+  // Only an unbound `undefined` names the immutable global property.
+  if (identifier.name === 'undefined') {
+    return binding ? UNKNOWN : { known: true, value: undefined }
+  }
+
+  if (!binding || env.seen.has(binding)) {
+    return UNKNOWN
+  }
+
+  if (t.isFunctionDeclaration(binding.path.node)) {
+    return binding.constant ? { known: true, value: OPAQUE_TRUTHY } : UNKNOWN
+  }
+  if (t.isClassDeclaration(binding.path.node)) {
+    if (!binding.constant) {
+      return UNKNOWN
+    }
+    // A nested function can read the class before its declaration runs.
+    if (readCrossesFunctionBoundary(binding, env.referencePath)) {
+      return UNKNOWN
+    }
+    return declarationReaches(binding.path, env.referencePath)
+      ? { known: true, value: OPAQUE_TRUTHY }
+      : UNKNOWN
+  }
+
+  if (binding.kind === 'var' || binding.kind === 'let' || binding.kind === 'const') {
+    const declarator = binding.path.node
+    if (!t.isVariableDeclarator(declarator) || !declarator.init) {
+      return UNKNOWN
+    }
+    if (!t.isIdentifier(declarator.id) || declarator.id.name !== identifier.name) {
+      return UNKNOWN
+    }
+    // A nested function can read the binding before its initializer runs.
+    if (readCrossesFunctionBoundary(binding, env.referencePath)) {
+      return UNKNOWN
+    }
+    // A preceding `var` initializer may still sit on an untaken branch.
+    if (!initializerReaches(binding.path, env.referencePath)) {
+      return UNKNOWN
+    }
+    // Babel counts a looped `var` initializer as its own constant violation.
+    if (
+      !binding.constant &&
+      !(
+        binding.constantViolations.length === 1 &&
+        binding.constantViolations[0]!.node === declarator
+      )
+    ) {
+      return UNKNOWN
+    }
+    return run(declarator.init, {
+      scope: binding.scope,
+      seen: new Set([...env.seen, binding]),
+      referencePath: binding.path,
+    })
+  }
+
+  return UNKNOWN
+}
+
+function applyUnary(op: t.UnaryExpression['operator'], value: unknown): Evaluation {
+  if (isOpaque(value)) {
+    // Only truthiness is known for an opaque object.
+    return op === '!' ? { known: true, value: false } : UNKNOWN
+  }
+  // `+bigint` throws TypeError; folding it would erase the throw.
+  if (op === '+' && typeof value === 'bigint') {
+    return UNKNOWN
+  }
+  try {
+    switch (op) {
+      case '!':
+        return { known: true, value: !value }
+      case '+':
+        return { known: true, value: Number(value as number) }
+      case '-':
+        return { known: true, value: -(value as number) }
+      case '~':
+        return { known: true, value: ~(value as number) }
+      case 'typeof':
+        return { known: true, value: typeof value }
+    }
+  } catch {
+    return UNKNOWN
+  }
+  return UNKNOWN
+}
+
+function applyBinary(
+  op: t.BinaryExpression['operator'],
+  left: unknown,
+  right: unknown,
+): Evaluation {
+  // Binary operators observe more than an opaque object's truthiness.
+  if (isOpaque(left) || isOpaque(right)) {
+    return UNKNOWN
+  }
+  if (op === '===') {
+    return { known: true, value: left === right }
+  }
+  if (op === '!==') {
+    return { known: true, value: left !== right }
+  }
+  if (op === '==') {
+    return { known: true, value: looseEquals(left, right) }
+  }
+  if (op === '!=') {
+    return { known: true, value: !looseEquals(left, right) }
+  }
+
+  const a = left as number
+  const b = right as number
+  try {
+    switch (op) {
+      case '+':
+        return { known: true, value: a + b }
+      case '-':
+        return { known: true, value: a - b }
+      case '*':
+        return { known: true, value: a * b }
+      case '/':
+        return { known: true, value: a / b }
+      case '%':
+        return { known: true, value: a % b }
+      case '**':
+        return { known: true, value: a ** b }
+      case '&':
+        return { known: true, value: a & b }
+      case '|':
+        return { known: true, value: a | b }
+      case '^':
+        return { known: true, value: a ^ b }
+      case '<<':
+        return { known: true, value: a << b }
+      case '>>':
+        return { known: true, value: a >> b }
+      case '>>>':
+        return { known: true, value: a >>> b }
+      case '<':
+        return { known: true, value: a < b }
+      case '<=':
+        return { known: true, value: a <= b }
+      case '>':
+        return { known: true, value: a > b }
+      case '>=':
+        return { known: true, value: a >= b }
+    }
+  } catch {
+    return UNKNOWN
+  }
+  return UNKNOWN
+}
+
+function looseEquals(left: unknown, right: unknown): boolean {
+  // oxlint-disable-next-line eqeqeq
+  return (left as object) == (right as object)
+}

package/src/analysis/document-order.ts

@@ -0,0 +1,141 @@
+import type { Binding, NodePath } from '@babel/traverse'
+import * as t from '@babel/types'
+
+// AST ancestry gives cloned and synthesized nodes an order when offsets cannot.
+export function declarationReaches(
+  bindingPath: NodePath,
+  referencePath: NodePath | undefined,
+): boolean {
+  if (!referencePath) {
+    return true
+  }
+  if (!bothPathsOrdered(bindingPath, referencePath)) {
+    return false
+  }
+  return precedesInAncestry(bindingPath, ancestry(referencePath))
+}
+
+// Detached paths and a path compared with itself prove no useful ordering.
+function bothPathsOrdered(bindingPath: NodePath, referencePath: NodePath): boolean {
+  return bindingPath !== referencePath && bindingPath.node != null && referencePath.node != null
+}
+
+function precedesInAncestry(bindingPath: NodePath, referenceAncestry: NodePath[]): boolean {
+  const bindingAncestry = ancestry(bindingPath)
+  let i = bindingAncestry.length - 1
+  let j = referenceAncestry.length - 1
+  while (i >= 0 && j >= 0 && bindingAncestry[i] === referenceAncestry[j]) {
+    i--
+    j--
+  }
+  if (i < 0) {
+    return true
+  }
+  if (j < 0) {
+    return false
+  }
+  return siblingPrecedes(bindingAncestry[i]!, referenceAncestry[j]!)
+}
+
+// A declaration inside one of these statements may not run before an outside
+// reference, even when it appears first.
+const CONDITIONAL_CONTAINERS = new Set<t.Node['type']>([
+  'IfStatement',
+  'SwitchStatement',
+  'SwitchCase',
+  'ForStatement',
+  'ForInStatement',
+  'ForOfStatement',
+  'WhileStatement',
+  'DoWhileStatement',
+  'TryStatement',
+  'ConditionalExpression',
+  'LogicalExpression',
+  // A labeled block can exit before a later declaration.
+  'LabeledStatement',
+])
+
+// No branch may separate the initializer from the reference while walking to
+// their nearest shared ancestor.
+export function initializerReaches(
+  bindingPath: NodePath,
+  referencePath: NodePath | undefined,
+): boolean {
+  if (!referencePath) {
+    return true
+  }
+  if (!bothPathsOrdered(bindingPath, referencePath)) {
+    return false
+  }
+  const referenceAncestry = ancestry(referencePath)
+  if (!precedesInAncestry(bindingPath, referenceAncestry)) {
+    return false
+  }
+  const referenceAncestors = new Set<NodePath>(referenceAncestry)
+  let current: NodePath | null = bindingPath.parentPath
+  while (current && !referenceAncestors.has(current)) {
+    // A detached ancestor invalidates the remaining path chain.
+    if (!current.node) {
+      return false
+    }
+    if (CONDITIONAL_CONTAINERS.has(current.node.type)) {
+      return false
+    }
+    current = current.parentPath
+  }
+  return true
+}
+
+// A nested function may run before the declaration, defeating document order.
+export function readCrossesFunctionBoundary(
+  binding: Binding,
+  referencePath: NodePath | undefined,
+): boolean {
+  if (!referencePath) {
+    return false
+  }
+  const bindingBlock = binding.scope.block
+  let current: NodePath | null = referencePath.parentPath
+  while (current) {
+    if (current.node === bindingBlock) {
+      return false
+    }
+    if (current.isFunction()) {
+      return true
+    }
+    current = current.parentPath
+  }
+  return false
+}
+
+function ancestry(path: NodePath): NodePath[] {
+  const chain: NodePath[] = []
+  let current: NodePath | null = path
+  while (current) {
+    chain.push(current)
+    current = current.parentPath
+  }
+  return chain
+}
+
+function siblingPrecedes(left: NodePath, right: NodePath): boolean {
+  if (left.listKey && left.listKey === right.listKey) {
+    return (left.key as number) < (right.key as number)
+  }
+  const parent = left.parentPath?.node
+  if (!parent) {
+    return false
+  }
+  const slotLeft = (left.listKey ?? left.key) as string
+  const slotRight = (right.listKey ?? right.key) as string
+  const keys = (t.VISITOR_KEYS as Record<string, string[]>)[parent.type]
+  if (!keys) {
+    return false
+  }
+  const indexLeft = keys.indexOf(slotLeft)
+  const indexRight = keys.indexOf(slotRight)
+  if (indexLeft === -1 || indexRight === -1) {
+    return false
+  }
+  return indexLeft < indexRight
+}