luau-obfuscator 1.0.5 → 1.0.7

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/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])])
 }

package/src/passes/vmify/compiler.ts

@@ -642,6 +642,12 @@ export class VmCompiler {
             }
         }
 
+        // Luau 제네릭 반복은 iterator 표현식이 함수가 아니라 테이블일 수 있다
+        // (플레인 테이블 → array-then-hash 순회, __iter 메타메서드 → 그 결과). base가
+        // 함수가 아니면 루프 진입 전에 한 번 정규화한다 — 안 하면 아래 CALL이 테이블을
+        // 호출하려다 "attempt to call a table value"로 터진다.
+        this.emit(state, Opcode.NORMITER, base, 0, 0, "normalize-generic-iter")
+
         const loopStart = state.proto.code.length
         const nVars = stmt.variables.length
         const callBase = state.regs.top()

package/src/passes/vmify/names.ts

@@ -20,6 +20,9 @@ export interface VmNames {
     dispatch: string
     /** local function __vm_rk(frame, x) */
     rk: string
+    /** local function __vm_tableIter(t) — 제네릭 for가 플레인 테이블을 순회할 때 쓰는
+     *  array-then-hash 이터레이터 클로저 팩토리 (NORMITER opcode에서 사용) */
+    tableIter: string
     /** __vm_execute/핸들러의 frame 파라미터 이름 */
     frame: string
     // frame 테이블 필드
@@ -63,6 +66,7 @@ export function generateVmNames(random: () => number = Math.random): VmNames {
     const id = makeIdGenerator(random)
     return {
         globals: id(), protoRoot: id(), execute: id(), handlers: id(), dispatch: id(), rk: id(),
+        tableIter: id(),
         frame: id(),
         R: id(), K: id(), code: id(), protos: id(), upvals: id(), varargs: id(),
         nVarargs: id(), multiTop: id(),

package/src/passes/vmify/opcodes.ts

@@ -41,6 +41,10 @@ export enum Opcode {
                  //   생성자 마지막 필드가 Call/MethodCall/Vararg로 다중값을 낼 때 씀 (`{f()}`, `{...}`)
     IDIV,        // R[A] = RK(B) // RK(C)  (Luau 바닥 나눗셈 연산자, 뒤에 추가되어 기존 opcode
                  //   번호를 안 건드림 — enum 중간에 끼워넣으면 runtime.ts의 숫자 인덱스가 전부 밀림)
+    NORMITER,    // 제네릭 for 진입 시 R[A..A+2] 이터레이터 3-튜플을 정규화. R[A]가 함수가
+                 //   아니라 테이블이면(플레인 테이블 or __iter 메타메서드) Luau 제네릭 반복
+                 //   의미대로 (fn, state, ctrl)로 바꿔준다. 안 하면 뒤의 CALL이 테이블을
+                 //   호출하려다 "attempt to call a table value"로 터짐. (enum 끝에 추가)
 }
 
 export interface Instr {

package/src/passes/vmify/runtime.ts

@@ -60,6 +60,34 @@ local function ${N.rk}(${N.frame}, x)
     end
 end
 
+-- 플레인 테이블에 대한 Luau 제네릭 반복(for k, v in t) 이터레이터.
+-- 배열부(1..경계)를 순서대로 먼저, 그다음 해시부(이미 낸 정수 키는 건너뜀)를 낸다.
+-- 상태를 클로저에 담으므로 (fn, state, ctrl) 중 state/ctrl은 안 쓴다.
+local function ${N.tableIter}(t)
+    local i = 0
+    local arrayDone = false
+    local hk = nil
+    return function()
+        if not arrayDone then
+            i = i + 1
+            local v = t[i]
+            if v ~= nil then
+                return i, v
+            end
+            arrayDone = true
+        end
+        local k, v = next(t, hk)
+        while k ~= nil do
+            if type(k) ~= "number" or k ~= math.floor(k) or k < 1 or k >= i then
+                hk = k
+                return k, v
+            end
+            k, v = next(t, k)
+        end
+        return nil
+    end
+end
+
 -- MOVE
 ${N.handlers}[${op(Opcode.MOVE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]]
@@ -261,6 +289,30 @@ ${N.handlers}[${op(Opcode.RETURN)}] = function(${N.frame}, pc, instr)
     return table.pack(table.unpack(${N.frame}.${N.R}, a, a + b - 2))
 end
 
+-- NORMITER: 제네릭 for 진입 시 이터레이터 3-튜플(R[A..A+2])을 정규화.
+-- R[A]가 함수면 그대로 두고(pairs/ipairs/커스텀 이터레이터), 테이블이면 __iter
+-- 메타메서드가 있으면 그걸 호출해 (fn,state,ctrl)로, 없으면 array-then-hash
+-- 클로저 이터레이터로 바꾼다. 이후 CALL 핸들러가 함수를 정상 호출하게 된다.
+${N.handlers}[${op(Opcode.NORMITER)}] = function(${N.frame}, pc, instr)
+    local a = instr[2]
+    local it = ${N.frame}.${N.R}[a]
+    if type(it) ~= "function" then
+        local mt = getmetatable(it)
+        local customIter = mt and rawget(mt, "__iter")
+        if customIter ~= nil then
+            local f, s, c = customIter(it)
+            ${N.frame}.${N.R}[a] = f
+            ${N.frame}.${N.R}[a + 1] = s
+            ${N.frame}.${N.R}[a + 2] = c
+        elseif type(it) == "table" then
+            ${N.frame}.${N.R}[a] = ${N.tableIter}(it)
+            ${N.frame}.${N.R}[a + 1] = nil
+            ${N.frame}.${N.R}[a + 2] = nil
+        end
+    end
+    return pc + 1
+end
+
 -- FORPREP
 ${N.handlers}[${op(Opcode.FORPREP)}] = function(${N.frame}, pc, instr)
     local a = instr[2]

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