luau-obfuscator 1.0.0 → 1.0.2

package/src/passes/vmify/scope-walk.ts

@@ -0,0 +1,175 @@
+import type {
+    Program, Block, Statement, Expression, FunctionBody, Identifier,
+} from "luau-parser"
+
+/** 함수 하나(최상위 프로그램 포함)를 가리키는 식별용 토큰. 객체 identity만 씀. */
+export type FuncMarker = { readonly tag: "top" } | { readonly tag: "fn"; readonly node: FunctionBody }
+
+export interface EnclosingFunctionMap {
+    /** 식별자 사용/선언 노드 하나가 어느 함수 안에 있는지. */
+    ownerOf: Map<object, FuncMarker>
+    /** 함수 마커 -> 그 함수를 감싸는 바깥 함수 마커(최상위는 undefined). */
+    parentOf: Map<FuncMarker, FuncMarker | undefined>
+    topMarker: FuncMarker
+}
+
+/**
+ * analyzeScopes()가 주는 건 "이 식별자가 어떤 binding을 가리키는가"까지고,
+ * "그 식별자가 물리적으로 어느 함수 몸통 안에 있는가"는 안 알려주기 때문에
+ * upvalue 캡처를 판단하려면 이 정보를 직접 한 번 더 walk해서 구해야 한다.
+ * (binding 선언 위치의 함수 != 어떤 참조 위치의 함수 라면 그 참조는 upvalue를 필요로 함)
+ */
+export function buildEnclosingFunctionMap(program: Program): EnclosingFunctionMap {
+    const ownerOf = new Map<object, FuncMarker>()
+    const parentOf = new Map<FuncMarker, FuncMarker | undefined>()
+    const topMarker: FuncMarker = { tag: "top" }
+    parentOf.set(topMarker, undefined)
+
+    function mark(node: object, fn: FuncMarker): void {
+        ownerOf.set(node, fn)
+    }
+
+    function walkBlock(block: Block, fn: FuncMarker): void {
+        for (const stmt of block.statements) walkStatement(stmt, fn)
+    }
+
+    function walkFunctionBody(fb: FunctionBody, parent: FuncMarker): void {
+        const self: FuncMarker = { tag: "fn", node: fb }
+        parentOf.set(self, parent)
+        mark(fb, self)
+        for (const p of fb.params) mark(p, self)
+        walkBlock(fb.body, self)
+    }
+
+    function walkExpr(expr: Expression, fn: FuncMarker): void {
+        mark(expr, fn)
+        switch (expr.type) {
+            case "Identifier":
+                mark(expr, fn)
+                break
+            case "InterpolatedStringExpression":
+                for (const part of expr.parts) if (part.kind === "expression") walkExpr(part.expression, fn)
+                break
+            case "FunctionExpression":
+                walkFunctionBody(expr.func, fn)
+                break
+            case "TableExpression":
+                for (const field of expr.fields) {
+                    if (field.type === "TableFieldPositional") walkExpr(field.value, fn)
+                    else if (field.type === "TableFieldNamed") walkExpr(field.value, fn)
+                    else {
+                        walkExpr(field.key, fn)
+                        walkExpr(field.value, fn)
+                    }
+                }
+                break
+            case "BinaryExpression":
+                walkExpr(expr.left, fn)
+                walkExpr(expr.right, fn)
+                break
+            case "UnaryExpression":
+                walkExpr(expr.argument, fn)
+                break
+            case "MemberExpression":
+                walkExpr(expr.object, fn)
+                break
+            case "IndexExpression":
+                walkExpr(expr.object, fn)
+                walkExpr(expr.index, fn)
+                break
+            case "CallExpression":
+                walkExpr(expr.callee, fn)
+                for (const a of expr.arguments) walkExpr(a, fn)
+                break
+            case "MethodCallExpression":
+                walkExpr(expr.object, fn)
+                for (const a of expr.arguments) walkExpr(a, fn)
+                break
+            case "ParenthesizedExpression":
+            case "TypeAssertionExpression":
+                walkExpr(expr.expression, fn)
+                break
+            case "IfElseExpression":
+                for (const c of expr.clauses) {
+                    walkExpr(c.condition, fn)
+                    walkExpr(c.body, fn)
+                }
+                walkExpr(expr.alternate, fn)
+                break
+        }
+    }
+
+    function walkStatement(stmt: Statement, fn: FuncMarker): void {
+        mark(stmt, fn)
+        switch (stmt.type) {
+            case "LocalStatement":
+                for (const n of stmt.names) mark(n, fn)
+                for (const e of stmt.init) walkExpr(e, fn)
+                return
+            case "LocalFunctionStatement":
+                mark(stmt.name, fn)
+                walkFunctionBody(stmt.func, fn)
+                return
+            case "FunctionDeclarationStatement":
+                mark(stmt.target.base, fn)
+                walkFunctionBody(stmt.func, fn)
+                return
+            case "AssignmentStatement":
+                for (const t of stmt.targets) walkExpr(t, fn)
+                for (const v of stmt.values) walkExpr(v, fn)
+                return
+            case "CompoundAssignmentStatement":
+                walkExpr(stmt.target, fn)
+                walkExpr(stmt.value, fn)
+                return
+            case "CallStatement":
+                walkExpr(stmt.expression, fn)
+                return
+            case "DoStatement":
+                walkBlock(stmt.body, fn)
+                return
+            case "WhileStatement":
+                walkExpr(stmt.condition, fn)
+                walkBlock(stmt.body, fn)
+                return
+            case "RepeatStatement":
+                walkBlock(stmt.body, fn)
+                walkExpr(stmt.condition, fn)
+                return
+            case "IfStatement":
+                for (const c of stmt.clauses) {
+                    walkExpr(c.condition, fn)
+                    walkBlock(c.body, fn)
+                }
+                if (stmt.alternate) walkBlock(stmt.alternate, fn)
+                return
+            case "NumericForStatement":
+                mark(stmt.variable, fn)
+                walkExpr(stmt.start, fn)
+                walkExpr(stmt.end, fn)
+                if (stmt.step) walkExpr(stmt.step, fn)
+                walkBlock(stmt.body, fn)
+                return
+            case "GenericForStatement":
+                for (const v of stmt.variables) mark(v, fn)
+                for (const it of stmt.iterators) walkExpr(it, fn)
+                walkBlock(stmt.body, fn)
+                return
+            case "ReturnStatement":
+                for (const a of stmt.arguments) walkExpr(a, fn)
+                return
+            default:
+                return
+        }
+    }
+
+    walkBlock(program.body, topMarker)
+    return { ownerOf, parentOf, topMarker }
+}
+
+/** Identifier 참조 하나가 속한 함수를 찾는다(선언/참조 둘 다 이 맵에 들어있음). */
+export function ownerFunctionOf(map: EnclosingFunctionMap, node: object): FuncMarker {
+    const fn = map.ownerOf.get(node)
+    if (!fn) throw new Error("scope-walk: node was not visited — walker/compiler are out of sync")
+    return fn
+}

package/src/passes/vmify/serialize.ts

@@ -0,0 +1,68 @@
+import type { Expression, TableField } from "luau-parser"
+import type { Proto, ConstValue } from "./chunk"
+import { Opcode } from "./opcodes"
+import type { VmNames } from "./names"
+import {
+    table, positionalField, namedField, numberLiteral, vmNumberLiteral, stringLiteral, booleanLiteral, nilLiteral,
+} from "../nodeFactory"
+
+/** proto.consts[]를 Luau 배열 리터럴로: { [1] = v1, [2] = v2, ... } (1-based는 그대로 유지) */
+function serializeConsts(consts: ConstValue[]): Expression {
+    const fields: TableField[] = consts.map((v) => positionalField(serializeConstValue(v)))
+    return table(fields)
+}
+
+function serializeConstValue(v: ConstValue): Expression {
+    if (v === null) return nilLiteral()
+    if (typeof v === "string") return stringLiteral(v)
+    if (typeof v === "number") return numberLiteral(v)
+    return booleanLiteral(v)
+}
+
+/**
+ * Instr/Proto를 Luau 테이블 리터럴로 찍을 때 쓰는 필드 키는 고정 문자열("op","a","b","c",
+ * "numParams", ...)이 아니라 names(names.ts)에서 빌드마다 새로 뽑은 이름을 쓴다 —
+ * 이 키 이름이 고정이면 산출물에서 `{op=6, a=0, ...}` 같은 패턴만 grep해도 VM 청크
+ * 테이블을 바로 찾아낼 수 있기 때문. runtime.ts가 같은 names로 instr.<key>를 읽으므로
+ * 반드시 컴파일 시점에 쓴 것과 동일한 VmNames 인스턴스를 넘겨야 한다.
+ */
+function serializeInstrs(proto: Proto): Expression {
+    const fields: TableField[] = proto.code.map((instr) =>
+        positionalField(
+            table([
+                positionalField(vmNumberLiteral(instr.op as number)),
+                positionalField(vmNumberLiteral(instr.a)),
+                positionalField(vmNumberLiteral(instr.b)),
+                positionalField(vmNumberLiteral(instr.c)),
+            ]),
+        ))
+    return table(fields)
+}
+
+function serializeUpvalDescs(proto: Proto, names: VmNames): Expression {
+    const fields: TableField[] = proto.upvalDescs.map((d) =>
+        positionalField(
+            table([
+                namedField(names.kind, stringLiteral(d.kind)),
+                namedField(names.index, vmNumberLiteral(d.index)),
+            ]),
+        ))
+    return table(fields)
+}
+
+/** Proto 하나를 { numParams=.., hasVarargs=.., maxRegs=.., code={...}, consts={...}, upvalDescs={...}, protos={...} }로
+ *  (필드 키는 전부 names에서 온 무작위 이름). */
+export function serializeProto(proto: Proto, names: VmNames): Expression {
+    const fields: TableField[] = [
+        namedField(names.numParams, vmNumberLiteral(proto.numParams)),
+        namedField(names.hasVarargs, booleanLiteral(proto.hasVarargs)),
+        namedField(names.maxRegs, vmNumberLiteral(proto.maxRegs)),
+        namedField(names.code, serializeInstrs(proto)),
+        namedField(names.consts, serializeConsts(proto.consts)),
+        namedField(names.upvalDescs, serializeUpvalDescs(proto, names)),
+        namedField(names.protos, table(proto.protos.map((p) => positionalField(serializeProto(p, names))))),
+    ]
+    return table(fields)
+}
+
+export { Opcode }

package/src/passes/walk.ts

@@ -10,79 +10,177 @@ function visitArray(arr: Expression[], visitor: ExpressionVisitor): void {
     }
 }
 
-export function mapExpression(expr: Expression, visitor: ExpressionVisitor): Expression {
+interface ChildAccessor {
+    get(): Expression
+    set(v: Expression): void
+}
+
+/**
+ * expr의 "자식 Expression"들에 대한 getter/setter 목록을 반환한다.
+ * (FunctionExpression은 별도 처리하므로 여기서는 빈 배열을 반환한다.)
+ */
+function getExpressionChildren(expr: Expression): ChildAccessor[] {
     switch (expr.type) {
-        case "InterpolatedStringExpression":
+        case "InterpolatedStringExpression": {
+            const children: ChildAccessor[] = []
             for (const part of expr.parts) {
                 if (part.kind === "expression") {
-                    part.expression = mapExpression(part.expression, visitor)
+                    children.push({
+                        get: () => part.expression,
+                        set: (v) => { part.expression = v },
+                    })
                 }
             }
-            break
+            return children
+        }
 
         case "FunctionExpression":
-            walkFunctionBody(expr.func, visitor)
-            break
+            return []
 
-        case "TableExpression":
+        case "TableExpression": {
+            const children: ChildAccessor[] = []
             for (const field of expr.fields) {
                 if (field.type === "TableFieldPositional") {
-                    field.value = mapExpression(field.value, visitor)
+                    children.push({ get: () => field.value, set: (v) => { field.value = v } })
                 } else if (field.type === "TableFieldNamed") {
-                    field.value = mapExpression(field.value, visitor)
+                    children.push({ get: () => field.value, set: (v) => { field.value = v } })
                 } else if (field.type === "TableFieldComputed") {
-                    field.key = mapExpression(field.key, visitor)
-                    field.value = mapExpression(field.value, visitor)
+                    children.push({ get: () => field.key, set: (v) => { field.key = v } })
+                    children.push({ get: () => field.value, set: (v) => { field.value = v } })
                 }
             }
-            break
+            return children
+        }
 
         case "BinaryExpression":
-            expr.left = mapExpression(expr.left, visitor)
-            expr.right = mapExpression(expr.right, visitor)
-            break
+            return [
+                { get: () => expr.left, set: (v) => { expr.left = v } },
+                { get: () => expr.right, set: (v) => { expr.right = v } },
+            ]
 
         case "UnaryExpression":
-            expr.argument = mapExpression(expr.argument, visitor)
-            break
+            return [{ get: () => expr.argument, set: (v) => { expr.argument = v } }]
 
         case "MemberExpression":
-            expr.object = mapExpression(expr.object, visitor)
-            break
+            return [{ get: () => expr.object, set: (v) => { expr.object = v } }]
 
         case "IndexExpression":
-            expr.object = mapExpression(expr.object, visitor)
-            expr.index = mapExpression(expr.index, visitor)
-            break
-
-        case "CallExpression":
-            expr.callee = mapExpression(expr.callee, visitor)
-            visitArray(expr.arguments, visitor)
-            break
-
-        case "MethodCallExpression":
-            expr.object = mapExpression(expr.object, visitor)
-            visitArray(expr.arguments, visitor)
-            break
+            return [
+                { get: () => expr.object, set: (v) => { expr.object = v } },
+                { get: () => expr.index, set: (v) => { expr.index = v } },
+            ]
+
+        case "CallExpression": {
+            const children: ChildAccessor[] = [
+                { get: () => expr.callee, set: (v) => { expr.callee = v } },
+            ]
+            for (let i = 0; i < expr.arguments.length; i++) {
+                const idx = i
+                children.push({
+                    get: () => expr.arguments[idx],
+                    set: (v) => { expr.arguments[idx] = v },
+                })
+            }
+            return children
+        }
+
+        case "MethodCallExpression": {
+            const children: ChildAccessor[] = [
+                { get: () => expr.object, set: (v) => { expr.object = v } },
+            ]
+            for (let i = 0; i < expr.arguments.length; i++) {
+                const idx = i
+                children.push({
+                    get: () => expr.arguments[idx],
+                    set: (v) => { expr.arguments[idx] = v },
+                })
+            }
+            return children
+        }
 
         case "ParenthesizedExpression":
-            expr.expression = mapExpression(expr.expression, visitor)
-            break
+            return [{ get: () => expr.expression, set: (v) => { expr.expression = v } }]
 
         case "TypeAssertionExpression":
-            expr.expression = mapExpression(expr.expression, visitor)
-            break
+            return [{ get: () => expr.expression, set: (v) => { expr.expression = v } }]
 
-        case "IfElseExpression":
+        case "IfElseExpression": {
+            const children: ChildAccessor[] = []
             for (const clause of expr.clauses) {
-                clause.condition = mapExpression(clause.condition, visitor)
-                clause.body = mapExpression(clause.body, visitor)
+                children.push({ get: () => clause.condition, set: (v) => { clause.condition = v } })
+                children.push({ get: () => clause.body, set: (v) => { clause.body = v } })
+            }
+            children.push({ get: () => expr.alternate, set: (v) => { expr.alternate = v } })
+            return children
+        }
+
+        default:
+            return []
+    }
+}
+
+interface WalkFrame {
+    expr: Expression
+    children: ChildAccessor[]
+    index: number
+    setInParent: ((v: Expression) => void) | null
+}
+
+/**
+ * Expression 트리를 후위순회(post-order)로 변형한다.
+ *
+ * 원래는 재귀 함수였지만, 문자열/숫자 난독화 패스가 만들어내는 매우 깊은
+ * BinaryExpression 체인(예: 수천 개의 `..` concat)을 순회할 때 네이티브
+ * 콜스택이 트리 깊이만큼 쌓여 "Maximum call stack size exceeded"가
+ * 발생했다. 그래서 재귀 대신 힙에 할당되는 명시적 스택을 사용해
+ * 트리 깊이와 무관하게 동작하도록 구현했다.
+ */
+export function mapExpression(root: Expression, visitor: ExpressionVisitor): Expression {
+    // FunctionExpression은 본문(statement 트리)을 별도로 순회해야 하므로 특별 취급한다.
+    // 함수 중첩 깊이는 보통 얕아서(재귀해도 안전) 그대로 재귀를 사용한다.
+    if (root.type === "FunctionExpression") {
+        walkFunctionBody(root.func, visitor)
+        return visitor(root) ?? root
+    }
+
+    let result: Expression = root
+    const stack: WalkFrame[] = [{
+        expr: root,
+        children: getExpressionChildren(root),
+        index: 0,
+        setInParent: (v) => { result = v },
+    }]
+
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1]
+
+        if (frame.index < frame.children.length) {
+            const child = frame.children[frame.index]
+            frame.index++
+            const childExpr = child.get()
+
+            if (childExpr.type === "FunctionExpression") {
+                walkFunctionBody(childExpr.func, visitor)
+                child.set(visitor(childExpr) ?? childExpr)
+                continue
             }
-            expr.alternate = mapExpression(expr.alternate, visitor)
-            break
+
+            stack.push({
+                expr: childExpr,
+                children: getExpressionChildren(childExpr),
+                index: 0,
+                setInParent: child.set,
+            })
+            continue
+        }
+
+        // 모든 자식 처리가 끝났으면 visitor를 실행하고, 부모에 반영한 뒤 pop한다.
+        const finished = visitor(frame.expr) ?? frame.expr
+        frame.setInParent?.(finished)
+        stack.pop()
     }
 
-    return visitor(expr) ?? expr
+    return result
 }
 
 function walkFunctionBody(func: FunctionBody, visitor: ExpressionVisitor): void {
@@ -170,4 +268,4 @@ function walkStatement(stmt: Statement, visitor: ExpressionVisitor): void {
 /** Program 전체를 순회하며 모든 Expression 노드에 visitor를 적용(제자리 변형). */
 export function transformExpressions(program: Program, visitor: ExpressionVisitor): void {
     walkBlock(program.body, visitor)
-}
+}

package/src/pipeline.ts

@@ -10,19 +10,20 @@ import { runEncryptStrings } from "./passes/EncryptStrings"
 import { runEncryptNumbers } from "./passes/EncryptNumbers"
 import { runInsertJunk } from "./passes/InsertJunk"
 import { runWrapInFunction } from "./passes/WrapInFunction"
+import { runVmify } from "./passes/Vmify"
 
 type PassFn = (program: Program, options: any) => void
 
 export const PASS_ORDER: (keyof ObfuscateConfig)[] = [
+    "Vmify",
     "GlobalMapping",
-    "StringsToExpressions",
-    "NumbersToExpressions",
     "RenameVariables",
     "ConstantArray",
+    "StringsToExpressions",
+    "NumbersToExpressions",
     "EncryptStrings",
     "EncryptNumbers",
     "InsertJunk",
-    "Vmify",
     "WrapInFunction",
     "Minify",
 ]
@@ -37,12 +38,10 @@ export const PASS_MAP: Partial<Record<keyof ObfuscateConfig, PassFn>> = {
     EncryptNumbers: runEncryptNumbers,
     InsertJunk: runInsertJunk,
     WrapInFunction: runWrapInFunction,
+    Vmify: runVmify,
 }
 
 export function runPipeline(program: Program, config: ObfuscateConfig): void {
-    // 타입 주석/별칭은 값 트리와 독립적으로 원본 이름을 참조하고 있어서
-    // (예: typeof(x)) 어떤 pass보다도 먼저 지워야 함. 끄면 무조건 깨지므로
-    // config로 조절 가능한 옵션이 아니라 파이프라인 진입 시 항상 실행.
     runStripTypes(program)
 
     for (const key of PASS_ORDER) {

package/tsconfig.json

@@ -1,21 +1,21 @@
-{
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "ESNext",
-        "lib": ["ESNext", "DOM", "DOM.Iterable"],
-        "declaration": false,
-        "declarationMap": false,
-        "sourceMap": false,
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "moduleResolution": "bundler",
-        "allowSyntheticDefaultImports": true,
-        "esModuleInterop": true,
-        "forceConsistentCasingInFileNames": true,
-        "strict": true,
-        "skipLibCheck": true,
-        "stripInternal": true,
-    },
-    "include": ["src/**/*"],
-    "exclude": ["node_modules", "dist"]
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "lib": ["ESNext", "DOM", "DOM.Iterable"],
+        "declaration": false,
+        "declarationMap": false,
+        "sourceMap": false,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "moduleResolution": "bundler",
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "stripInternal": true,
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
 }

package/tsup.config.ts

@@ -1,10 +1,10 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-    entry: ["src/index.ts"],
-    format: ["esm", "cjs"],
-    dts: true,
-    clean: true,
-    sourcemap: false,
-    target: "esnext",
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+    entry: ["src/index.ts"],
+    format: ["esm", "cjs"],
+    dts: true,
+    clean: true,
+    sourcemap: false,
+    target: "esnext",
 });