luau-obfuscator 1.0.0 → 1.0.1

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, 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, names: VmNames): Expression {
+    const fields: TableField[] = proto.code.map((instr) =>
+        positionalField(
+            table([
+                namedField(names.op, numberLiteral(instr.op as number)),
+                namedField(names.a, numberLiteral(instr.a)),
+                namedField(names.b, numberLiteral(instr.b)),
+                namedField(names.c, numberLiteral(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, numberLiteral(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, numberLiteral(proto.numParams)),
+        namedField(names.hasVarargs, booleanLiteral(proto.hasVarargs)),
+        namedField(names.maxRegs, numberLiteral(proto.maxRegs)),
+        namedField(names.code, serializeInstrs(proto, names)),
+        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/pipeline.ts

@@ -10,10 +10,12 @@ 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",
@@ -22,7 +24,6 @@ export const PASS_ORDER: (keyof ObfuscateConfig)[] = [
     "EncryptStrings",
     "EncryptNumbers",
     "InsertJunk",
-    "Vmify",
     "WrapInFunction",
     "Minify",
 ]
@@ -37,6 +38,7 @@ 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 {

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",
 });