luau-obfuscator 1.0.3 → 1.0.5

package/src/passes/StripTypes.ts

@@ -1,192 +1,192 @@
-import type {
-    Program, Block, Statement, Expression, FunctionBody,
-} from "luau-parser"
-
-/**
- * 파이프라인 맨 앞에서 실행되어야 하는 패스.
- *
- * 이후 패스들(GlobalMapping, RenameVariables 등)은 값 트리만 순회하고
- * `typeof(x)`, `x :: T` 같은 타입 노드 내부의 expression은 건드리지 않는다.
- * 타입을 나중까지 들고 있으면 값 쪽 식별자는 바뀌는데 타입 쪽 참조는 원래
- * 이름 그대로 남아 출력물이 타입체크 불가능한 상태가 된다
- * (`typeof(runtimeValue)`가 obfuscate 이후에도 원본 이름을 참조하는 것이 그 예).
- *
- * 그래서 타입 정보 자체를 파이프라인 시작 시점에 전부 지워서 이 클래스의
- * 버그를 원천 차단한다:
- *  - TypeAliasStatement / ExportTypeAliasStatement 문 자체를 블록에서 제거
- *  - TypedIdentifier / FunctionParameter 의 typeAnnotation 제거
- *  - FunctionBody 의 generics / varargTypeAnnotation / returnType 제거
- *  - `expr :: T` (TypeAssertionExpression) 은 T를 버리고 expr로 치환
- */
-export function runStripTypes(program: Program): void {
-    stripBlock(program.body)
-}
-
-function stripBlock(block: Block): void {
-    const kept: Statement[] = []
-    for (const stmt of block.statements) {
-        if (stmt.type === "TypeAliasStatement" || stmt.type === "ExportTypeAliasStatement") {
-            continue
-        }
-        stripStatement(stmt)
-        kept.push(stmt)
-    }
-    block.statements = kept
-}
-
-function stripFunctionBody(func: FunctionBody): void {
-    func.generics = []
-    for (const param of func.params) delete param.typeAnnotation
-    delete func.varargTypeAnnotation
-    delete func.returnType
-    stripBlock(func.body)
-}
-
-function stripStatement(stmt: Statement): void {
-    switch (stmt.type) {
-        case "LocalStatement":
-            for (const name of stmt.names) delete name.typeAnnotation
-            for (let i = 0; i < stmt.init.length; i++) stmt.init[i] = stripExpr(stmt.init[i])
-            return
-
-        case "LocalFunctionStatement":
-            stripFunctionBody(stmt.func)
-            return
-
-        case "FunctionDeclarationStatement":
-            stripFunctionBody(stmt.func)
-            return
-
-        case "AssignmentStatement":
-            for (let i = 0; i < stmt.targets.length; i++) stmt.targets[i] = stripExpr(stmt.targets[i])
-            for (let i = 0; i < stmt.values.length; i++) stmt.values[i] = stripExpr(stmt.values[i])
-            return
-
-        case "CompoundAssignmentStatement":
-            stmt.target = stripExpr(stmt.target)
-            stmt.value = stripExpr(stmt.value)
-            return
-
-        case "CallStatement":
-            stmt.expression = stripExpr(stmt.expression) as typeof stmt.expression
-            return
-
-        case "DoStatement":
-            stripBlock(stmt.body)
-            return
-
-        case "WhileStatement":
-            stmt.condition = stripExpr(stmt.condition)
-            stripBlock(stmt.body)
-            return
-
-        case "RepeatStatement":
-            stripBlock(stmt.body)
-            stmt.condition = stripExpr(stmt.condition)
-            return
-
-        case "IfStatement":
-            for (const clause of stmt.clauses) {
-                clause.condition = stripExpr(clause.condition)
-                stripBlock(clause.body)
-            }
-            if (stmt.alternate) stripBlock(stmt.alternate)
-            return
-
-        case "NumericForStatement":
-            delete stmt.variable.typeAnnotation
-            stmt.start = stripExpr(stmt.start)
-            stmt.end = stripExpr(stmt.end)
-            if (stmt.step) stmt.step = stripExpr(stmt.step)
-            stripBlock(stmt.body)
-            return
-
-        case "GenericForStatement":
-            for (const v of stmt.variables) delete v.typeAnnotation
-            for (let i = 0; i < stmt.iterators.length; i++) stmt.iterators[i] = stripExpr(stmt.iterators[i])
-            stripBlock(stmt.body)
-            return
-
-        case "ReturnStatement":
-            for (let i = 0; i < stmt.arguments.length; i++) stmt.arguments[i] = stripExpr(stmt.arguments[i])
-            return
-
-        case "BreakStatement":
-        case "ContinueStatement":
-            return
-    }
-}
-
-function stripExpr(expr: Expression): Expression {
-    switch (expr.type) {
-        case "InterpolatedStringExpression":
-            for (const part of expr.parts) {
-                if (part.kind === "expression") part.expression = stripExpr(part.expression)
-            }
-            return expr
-
-        case "FunctionExpression":
-            stripFunctionBody(expr.func)
-            return expr
-
-        case "TableExpression":
-            for (const field of expr.fields) {
-                if (field.type === "TableFieldPositional") {
-                    field.value = stripExpr(field.value)
-                } else if (field.type === "TableFieldNamed") {
-                    field.value = stripExpr(field.value)
-                } else if (field.type === "TableFieldComputed") {
-                    field.key = stripExpr(field.key)
-                    field.value = stripExpr(field.value)
-                }
-            }
-            return expr
-
-        case "BinaryExpression":
-            expr.left = stripExpr(expr.left)
-            expr.right = stripExpr(expr.right)
-            return expr
-
-        case "UnaryExpression":
-            expr.argument = stripExpr(expr.argument)
-            return expr
-
-        case "MemberExpression":
-            expr.object = stripExpr(expr.object)
-            return expr
-
-        case "IndexExpression":
-            expr.object = stripExpr(expr.object)
-            expr.index = stripExpr(expr.index)
-            return expr
-
-        case "CallExpression":
-            expr.callee = stripExpr(expr.callee)
-            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
-            return expr
-
-        case "MethodCallExpression":
-            expr.object = stripExpr(expr.object)
-            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
-            return expr
-
-        case "ParenthesizedExpression":
-            expr.expression = stripExpr(expr.expression)
-            return expr
-
-        case "TypeAssertionExpression":
-            // `expr :: T` -> T를 버리고 expr만 남김 (괄호로 감싸서 우선순위 보존)
-            return stripExpr(expr.expression)
-
-        case "IfElseExpression":
-            for (const clause of expr.clauses) {
-                clause.condition = stripExpr(clause.condition)
-                clause.body = stripExpr(clause.body)
-            }
-            expr.alternate = stripExpr(expr.alternate)
-            return expr
-
-        default:
-            return expr
-    }
+import type {
+    Program, Block, Statement, Expression, FunctionBody,
+} from "luau-parser"
+
+/**
+ * 파이프라인 맨 앞에서 실행되어야 하는 패스.
+ *
+ * 이후 패스들(GlobalMapping, RenameVariables 등)은 값 트리만 순회하고
+ * `typeof(x)`, `x :: T` 같은 타입 노드 내부의 expression은 건드리지 않는다.
+ * 타입을 나중까지 들고 있으면 값 쪽 식별자는 바뀌는데 타입 쪽 참조는 원래
+ * 이름 그대로 남아 출력물이 타입체크 불가능한 상태가 된다
+ * (`typeof(runtimeValue)`가 obfuscate 이후에도 원본 이름을 참조하는 것이 그 예).
+ *
+ * 그래서 타입 정보 자체를 파이프라인 시작 시점에 전부 지워서 이 클래스의
+ * 버그를 원천 차단한다:
+ *  - TypeAliasStatement / ExportTypeAliasStatement 문 자체를 블록에서 제거
+ *  - TypedIdentifier / FunctionParameter 의 typeAnnotation 제거
+ *  - FunctionBody 의 generics / varargTypeAnnotation / returnType 제거
+ *  - `expr :: T` (TypeAssertionExpression) 은 T를 버리고 expr로 치환
+ */
+export function runStripTypes(program: Program): void {
+    stripBlock(program.body)
+}
+
+function stripBlock(block: Block): void {
+    const kept: Statement[] = []
+    for (const stmt of block.statements) {
+        if (stmt.type === "TypeAliasStatement" || stmt.type === "ExportTypeAliasStatement") {
+            continue
+        }
+        stripStatement(stmt)
+        kept.push(stmt)
+    }
+    block.statements = kept
+}
+
+function stripFunctionBody(func: FunctionBody): void {
+    func.generics = []
+    for (const param of func.params) delete param.typeAnnotation
+    delete func.varargTypeAnnotation
+    delete func.returnType
+    stripBlock(func.body)
+}
+
+function stripStatement(stmt: Statement): void {
+    switch (stmt.type) {
+        case "LocalStatement":
+            for (const name of stmt.names) delete name.typeAnnotation
+            for (let i = 0; i < stmt.init.length; i++) stmt.init[i] = stripExpr(stmt.init[i])
+            return
+
+        case "LocalFunctionStatement":
+            stripFunctionBody(stmt.func)
+            return
+
+        case "FunctionDeclarationStatement":
+            stripFunctionBody(stmt.func)
+            return
+
+        case "AssignmentStatement":
+            for (let i = 0; i < stmt.targets.length; i++) stmt.targets[i] = stripExpr(stmt.targets[i])
+            for (let i = 0; i < stmt.values.length; i++) stmt.values[i] = stripExpr(stmt.values[i])
+            return
+
+        case "CompoundAssignmentStatement":
+            stmt.target = stripExpr(stmt.target)
+            stmt.value = stripExpr(stmt.value)
+            return
+
+        case "CallStatement":
+            stmt.expression = stripExpr(stmt.expression) as typeof stmt.expression
+            return
+
+        case "DoStatement":
+            stripBlock(stmt.body)
+            return
+
+        case "WhileStatement":
+            stmt.condition = stripExpr(stmt.condition)
+            stripBlock(stmt.body)
+            return
+
+        case "RepeatStatement":
+            stripBlock(stmt.body)
+            stmt.condition = stripExpr(stmt.condition)
+            return
+
+        case "IfStatement":
+            for (const clause of stmt.clauses) {
+                clause.condition = stripExpr(clause.condition)
+                stripBlock(clause.body)
+            }
+            if (stmt.alternate) stripBlock(stmt.alternate)
+            return
+
+        case "NumericForStatement":
+            delete stmt.variable.typeAnnotation
+            stmt.start = stripExpr(stmt.start)
+            stmt.end = stripExpr(stmt.end)
+            if (stmt.step) stmt.step = stripExpr(stmt.step)
+            stripBlock(stmt.body)
+            return
+
+        case "GenericForStatement":
+            for (const v of stmt.variables) delete v.typeAnnotation
+            for (let i = 0; i < stmt.iterators.length; i++) stmt.iterators[i] = stripExpr(stmt.iterators[i])
+            stripBlock(stmt.body)
+            return
+
+        case "ReturnStatement":
+            for (let i = 0; i < stmt.arguments.length; i++) stmt.arguments[i] = stripExpr(stmt.arguments[i])
+            return
+
+        case "BreakStatement":
+        case "ContinueStatement":
+            return
+    }
+}
+
+function stripExpr(expr: Expression): Expression {
+    switch (expr.type) {
+        case "InterpolatedStringExpression":
+            for (const part of expr.parts) {
+                if (part.kind === "expression") part.expression = stripExpr(part.expression)
+            }
+            return expr
+
+        case "FunctionExpression":
+            stripFunctionBody(expr.func)
+            return expr
+
+        case "TableExpression":
+            for (const field of expr.fields) {
+                if (field.type === "TableFieldPositional") {
+                    field.value = stripExpr(field.value)
+                } else if (field.type === "TableFieldNamed") {
+                    field.value = stripExpr(field.value)
+                } else if (field.type === "TableFieldComputed") {
+                    field.key = stripExpr(field.key)
+                    field.value = stripExpr(field.value)
+                }
+            }
+            return expr
+
+        case "BinaryExpression":
+            expr.left = stripExpr(expr.left)
+            expr.right = stripExpr(expr.right)
+            return expr
+
+        case "UnaryExpression":
+            expr.argument = stripExpr(expr.argument)
+            return expr
+
+        case "MemberExpression":
+            expr.object = stripExpr(expr.object)
+            return expr
+
+        case "IndexExpression":
+            expr.object = stripExpr(expr.object)
+            expr.index = stripExpr(expr.index)
+            return expr
+
+        case "CallExpression":
+            expr.callee = stripExpr(expr.callee)
+            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
+            return expr
+
+        case "MethodCallExpression":
+            expr.object = stripExpr(expr.object)
+            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
+            return expr
+
+        case "ParenthesizedExpression":
+            expr.expression = stripExpr(expr.expression)
+            return expr
+
+        case "TypeAssertionExpression":
+            // `expr :: T` -> T를 버리고 expr만 남김 (괄호로 감싸서 우선순위 보존)
+            return stripExpr(expr.expression)
+
+        case "IfElseExpression":
+            for (const clause of expr.clauses) {
+                clause.condition = stripExpr(clause.condition)
+                clause.body = stripExpr(clause.body)
+            }
+            expr.alternate = stripExpr(expr.alternate)
+            return expr
+
+        default:
+            return expr
+    }
 }

package/src/passes/Vmify.ts

@@ -37,6 +37,13 @@ export interface VmifyOptions {
      * Math.random. 재현 가능한 빌드가 필요하면(테스트 등) 시드 고정 PRNG를 넘길 것.
      */
     random?: () => number
+    /**
+     * 디버그 빌드. 켜면 각 인스트럭션에 원본 소스 줄 번호를, CALL에는 호출 대상 이름을
+     * 함께 직렬화하고, 런타임 CALL 핸들러가 non-callable 값을 부르려 할 때 그냥
+     * "attempt to call a nil value"가 아니라 "[vmdebug] ... '대상이름' (source line N)"으로
+     * 원본 위치를 찍어준다. 산출물이 조금 커지고 VM 시그니처가 노출되므로 진단용으로만 쓸 것.
+     */
+    debug?: boolean
 }
 
 /**
@@ -59,10 +66,11 @@ export function runVmify(program: Program, options: VmifyOptions): void {
     const builtinGlobals = options.builtinGlobals ?? DEFAULT_BUILTIN_GLOBALS
     const random = options.random ?? Math.random
 
+    const debug = options.debug ?? false
     const opcodeMap = createOpcodeMap(random)
     const names = generateVmNames(random)
 
-    const compiler = new VmCompiler(program, builtinGlobals, opcodeMap)
+    const compiler = new VmCompiler(program, builtinGlobals, opcodeMap, debug)
     const topProto = compiler.compile()
 
     // builtinGlobals(시드 목록)가 아니라 실제로 프로그램이 참조한 전역 전체로 브릿지를
@@ -74,12 +82,12 @@ export function runVmify(program: Program, options: VmifyOptions): void {
         usedGlobalNames.map((name) => namedField(name, identifier(name))),
     )
 
-    const runtimeSource = buildVmRuntimeSource(names, opcodeMap)
+    const runtimeSource = buildVmRuntimeSource(names, opcodeMap, debug)
     const runtimeProgram = luauparser.parse(runtimeSource)
     const runtimeStatements: Statement[] = runtimeProgram.body.statements
     markRuntimeNumbersAsStructural(runtimeProgram.body)
 
-    const protoLiteral = serializeProto(topProto, names)
+    const protoLiteral = serializeProto(topProto, names, debug)
 
     const newBody: Statement[] = [
         localStatement(names.globals, globalsTable),

package/src/passes/WrapInFunction.ts

@@ -1,32 +1,32 @@
-import type { Program } from "luau-parser"
-import {
-    block, functionBody, functionExpression, paren, call, vararg, returnStatement,
-} from "./nodeFactory"
-
-export interface WrapInFunctionOptions {}
-
-/**
- * 전체 프로그램을:
- *   return (function(...)
- *       <원래 코드>
- *   end)(...)
- * 로 감쌈.
- *
- * - `return`을 쓰는 이유: Script/LocalScript에서는 top-level return이 그냥 청크를
- *   조기 종료시킬 뿐 무해하고, ModuleScript라면 IIFE의 결과값이 그대로 require()
- *   호출자에게 전달돼야 하므로 필요함. 즉 스크립트 종류를 가리지 않고 안전.
- * - `...`을 파라미터로 받아서 다시 그대로 넘겨주는 이유: 원본 청크가 최상위에서
- *   `...`(스크립트 인자)을 참조하는 경우를 대비. 그냥 지워버리면 그런 코드가
- *   깨짐.
- *
- * 반드시 파이프라인 맨 마지막 근처에서 실행돼야 함 — 이 패스 이후에 실행되는
- * 다른 패스가 top-level 스코프를 순회/변형한다면 이미 감싸인 함수 내부까지
- * 안 보고 지나칠 수 있음.
- */
-export function runWrapInFunction(program: Program, _options: WrapInFunctionOptions): void {
-    const innerBody = program.body
-    const wrapper = functionExpression(functionBody([], innerBody, true))
-    const iife = call(paren(wrapper), [vararg()])
-
-    program.body = block([returnStatement([iife])])
+import type { Program } from "luau-parser"
+import {
+    block, functionBody, functionExpression, paren, call, vararg, returnStatement,
+} from "./nodeFactory"
+
+export interface WrapInFunctionOptions {}
+
+/**
+ * 전체 프로그램을:
+ *   return (function(...)
+ *       <원래 코드>
+ *   end)(...)
+ * 로 감쌈.
+ *
+ * - `return`을 쓰는 이유: Script/LocalScript에서는 top-level return이 그냥 청크를
+ *   조기 종료시킬 뿐 무해하고, ModuleScript라면 IIFE의 결과값이 그대로 require()
+ *   호출자에게 전달돼야 하므로 필요함. 즉 스크립트 종류를 가리지 않고 안전.
+ * - `...`을 파라미터로 받아서 다시 그대로 넘겨주는 이유: 원본 청크가 최상위에서
+ *   `...`(스크립트 인자)을 참조하는 경우를 대비. 그냥 지워버리면 그런 코드가
+ *   깨짐.
+ *
+ * 반드시 파이프라인 맨 마지막 근처에서 실행돼야 함 — 이 패스 이후에 실행되는
+ * 다른 패스가 top-level 스코프를 순회/변형한다면 이미 감싸인 함수 내부까지
+ * 안 보고 지나칠 수 있음.
+ */
+export function runWrapInFunction(program: Program, _options: WrapInFunctionOptions): void {
+    const innerBody = program.body
+    const wrapper = functionExpression(functionBody([], innerBody, true))
+    const iife = call(paren(wrapper), [vararg()])
+
+    program.body = block([returnStatement([iife])])
 }