luau-obfuscator 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luau-obfuscator",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "luau obfuscator for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/scripts/test.js

@@ -15,10 +15,8 @@ for(const filename of fs.readdirSync(smokedir)) {
     const timeStart = performance.now()
     const obfuscated = obfuscate(content, {
         Minify: {active: false},
-        NumbersToExpressions: {active: false},
-        StringsToExpressions: {active: false}
     })
     const timeEnd = performance.now()
     fs.writeFileSync(path.join(GENERATE_DIR, `${filename}`), obfuscated)
-    console.log(`obfuscating ${filename} took ${(timeEnd - timeStart) / 1000}s, length: ${content.length} -> ${obfuscated.length}`)
+    console.log(`obfuscating ${filename} took ${(timeEnd - timeStart) / 1000}s, length: ${content.length} -> ${obfuscated.length} (x${obfuscated.length / content.length})`)
 }

package/src/passes/StringsToExpressions.ts

@@ -1,7 +1,7 @@
 import type { Program, Expression, Statement } from "luau-parser"
 import { transformExpressions } from "./walk"
 import {
-    numberLiteral, binary, call, member, identifier, table, positionalField, index,
+    vmNumberLiteral, binary, call, member, identifier, table, positionalField, index,
     localStatement, localFunctionStatement, functionParam, functionBody, functionExpression,
     block, ifStatement, ifClause, returnStatement, paren, unary, stringLiteral,
     numericForStatement, assignmentStatement,
@@ -50,7 +50,7 @@ function splitByteChunks(bytes: number[], min: number, max: number): number[][]
 
 function stringCharCall(bytes: number[]): Expression {
     // string.char(b1, b2, ...) — 원문 텍스트가 소스에 전혀 남지 않음
-    return call(member(identifier("string"), "char"), bytes.map(numberLiteral))
+    return call(member(identifier("string"), "char"), bytes.map(vmNumberLiteral))
 }
 
 /**
@@ -107,7 +107,7 @@ function buildShuffledTables(chunks: number[][]): { storeVar: string; orderVar:
     for (let slot = 0; slot < n; slot++) {
         order[storageOrder[slot]] = slot + 1
     }
-    const orderFields = order.map((slot) => positionalField(numberLiteral(slot)))
+    const orderFields = order.map((slot) => positionalField(vmNumberLiteral(slot)))
 
     return {
         storeVar,
@@ -140,7 +140,7 @@ function buildForLoopStringExpr(chunks: number[][]): Expression {
         localStatement(accVar, stringLiteral("")),
         numericForStatement(
             iVar,
-            numberLiteral(1),
+            vmNumberLiteral(1),
             unary("#", identifier(orderVar)),
             block([
                 assignmentStatement(
@@ -187,7 +187,7 @@ function buildRecursiveStringExpr(chunks: number[][]): Expression {
         ]),
         returnStatement([
             call(identifier(recName), [
-                binary("+", identifier(iParam), numberLiteral(1)),
+                binary("+", identifier(iParam), vmNumberLiteral(1)),
                 binary(
                     "..",
                     identifier(accParam),
@@ -200,7 +200,7 @@ function buildRecursiveStringExpr(chunks: number[][]): Expression {
     return iife([
         ...stmts,
         localFunctionStatement(recName, functionBody([functionParam(iParam), functionParam(accParam)], body)),
-        returnStatement([call(identifier(recName), [numberLiteral(1), stringLiteral("")])]),
+        returnStatement([call(identifier(recName), [vmNumberLiteral(1), stringLiteral("")])]),
     ])
 }
 

package/src/passes/Vmify.ts

@@ -24,12 +24,12 @@ function markRuntimeNumbersAsStructural(body: { statements: Statement[] }): void
 
 export interface VmifyOptions {
     /**
-     * VM 밖에서 값을 그대로 참조해야 하는 전역 이름 목록(GETGLOBAL/SETGLOBAL 대상).
-     * Luau엔 getfenv가 없어서 "임의의 전역 읽기"를 흉내낼 수 없기 때문에,
-     * 여기 나열된 이름들만 브리지 테이블에 실제 값으로 미리 채워 넣는다.
-     * 나열되지 않은 전역을 참조하면 컴파일은 되지만 런타임에 nil이 나온다 — 실사용 전
-     * 반드시 프로그램에서 실제로 쓰는 전역 이름을 전부 이 목록에 채워야 함(TODO: 컴파일러가
-     * ScopeAnalysis.globalsByName을 이용해 자동으로 목록을 뽑아주도록 개선 가능).
+     * 스코프 분석에 미리 등록해둘 전역 이름 시드 목록. 여기 없는 이름이라도 프로그램에서
+     * 실제로 참조되면(로컬/파라미터/업밸류로 안 풀리는 식별자는 전부) 스코프 분석이
+     * 자동으로 전역으로 잡아내므로, 브릿지 테이블은 이 옵션이 아니라
+     * VmCompiler.getUsedGlobalNames()(실제 사용된 전역 전체)로 만든다 — 옛날엔 이 목록에
+     * 없는 이름을 쓰면 컴파일은 되는데 GETGLOBAL이 조용히 nil을 반환해서
+     * "attempt to call a nil value"로 터졌었음.
      */
     builtinGlobals?: readonly string[]
     /**
@@ -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
 }
 
 /**
@@ -56,25 +63,31 @@ export interface VmifyOptions {
  * 사라지므로, 이후 패스(RenameVariables, EncryptStrings 등)가 손댈 원본 AST가 없다.
  */
 export function runVmify(program: Program, options: VmifyOptions): void {
-    const globalNames = options.builtinGlobals ?? DEFAULT_BUILTIN_GLOBALS
+    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, globalNames, opcodeMap)
+    const compiler = new VmCompiler(program, builtinGlobals, opcodeMap, debug)
     const topProto = compiler.compile()
 
+    // builtinGlobals(시드 목록)가 아니라 실제로 프로그램이 참조한 전역 전체로 브릿지를
+    // 만든다 — game/task 같은 시드 목록에 없는 Roblox API나 실행기 전역을 스크립트가
+    // 쓰더라도 스코프 분석이 이미 전역으로 잡아뒀으므로 여기서 다 커버된다.
+    const usedGlobalNames = compiler.getUsedGlobalNames()
+
     const globalsTable = table(
-        globalNames.map((name) => namedField(name, identifier(name))),
+        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/vmify/compiler.ts

@@ -33,6 +33,8 @@ interface FuncState {
     upvalIndexByBinding: Map<BindingId, number>
     breakPatchStack: number[][]
     continuePatchStack: number[][]
+    /** debug 빌드에서 emit()이 인스트럭션에 박아넣을 "현재 컴파일 중인 소스 줄". */
+    curLine?: number
 }
 
 export class VmCompiler {
@@ -42,10 +44,29 @@ export class VmCompiler {
     private protoIdCounter = 0
     private declToBinding = new Map<object, BindingId>()
 
+    /**
+     * 실제로 프로그램이 참조하는 모든 전역 이름(사전 등록된 builtinGlobals +
+     * 스코프 분석이 자동으로 찾아낸, 로컬/파라미터/업밸류로 안 풀리는 나머지 식별자
+     * 전부)을 돌려준다. Vmify.ts가 이 목록으로 브릿지 테이블(globals)을 만든다.
+     *
+     * 예전엔 호출자가 넘긴 builtinGlobals 목록만 브릿지에 넣었는데, 그 목록에
+     * 없는 전역(예: Roblox API나 실행기 전용 전역을 다 못 채운 경우)을 참조하면
+     * 컴파일은 성공하지만 GETGLOBAL이 조용히 nil을 반환해서 "attempt to call a
+     * nil value"로 터진다 — 게다가 원인이 VM 디스패치 쪽 스택에서만 보여서
+     * "opcode 매핑이 깨졌나?" 하고 엉뚱한 곳을 의심하게 만든다. analyzeScopes는
+     * 어차피 로컬/업밸류로 못 푸는 식별자를 전부 global 바인딩으로 잡아두므로,
+     * builtinGlobals에 없던 이름도 여기 globalsByName에는 다 들어있다 —
+     * 하드코딩된 허용목록 대신 이걸 그대로 쓰면 커버리지 문제 자체가 사라진다.
+     */
+    getUsedGlobalNames(): string[] {
+        return Array.from(this.analysis.globalsByName.keys())
+    }
+
     constructor(
         private program: Program,
         builtinGlobals: readonly string[] = DEFAULT_BUILTIN_GLOBALS,
         private opcodeMap?: OpcodeMap,
+        private debug = false,
     ) {
         this.analysis = luauparser.analyzeScopes(program, { builtinGlobals })
         this.enclosing = buildEnclosingFunctionMap(program)
@@ -97,10 +118,34 @@ export class VmCompiler {
         // 물리 번호로 바꿔서 저장한다. 직접 VmCompiler를 쓰는 테스트/디버깅 코드가
         // opcodeMap 없이 호출할 수도 있으니 없으면 항등(그대로) 매핑으로 폴백.
         const physicalOp = this.opcodeMap ? this.opcodeMap[op] : op
-        state.proto.code.push({ op: physicalOp, a, b, c, comment } as Instr)
+        state.proto.code.push({ op: physicalOp, a, b, c, comment, dbgLine: this.debug ? state.curLine : undefined } as Instr)
         return state.proto.code.length - 1
     }
 
+    /** debug 빌드: 방금 emit한 CALL 인스트럭션에 "호출 대상 표현식 문자열"과 그 소스 줄을
+     *  박아넣는다(런타임이 non-callable을 잡았을 때 사람이 읽을 위치를 찍게). */
+    private stampCall(state: FuncState, idx: number, callExpr: Expression, calleeExpr: Expression): void {
+        if (!this.debug) return
+        const instr = state.proto.code[idx]
+        instr.dbgName = this.describeExpr(calleeExpr)
+        const line = (calleeExpr as { line?: { start: number } }).line ?? (callExpr as { line?: { start: number } }).line
+        if (line) instr.dbgLine = line.start
+    }
+
+    /** 표현식을 사람이 읽을 짧은 문자열로. 위치 추적용이라 완벽할 필요는 없음. */
+    private describeExpr(e: Expression): string {
+        switch (e.type) {
+            case "Identifier": return e.name
+            case "MemberExpression": return `${this.describeExpr(e.object)}.${e.property.name}`
+            case "MethodCallExpression": return `${this.describeExpr(e.object)}:${e.method.name}(...)`
+            case "IndexExpression": return `${this.describeExpr(e.object)}[...]`
+            case "CallExpression": return `${this.describeExpr(e.callee)}(...)`
+            case "ParenthesizedExpression": return `(${this.describeExpr(e.expression)})`
+            case "StringLiteral": return `"${String(e.value).slice(0, 20)}"`
+            default: return `<${e.type}>`
+        }
+    }
+
     private konst(state: FuncState, value: ConstValue): number {
         return internConst(state.proto, value)
     }
@@ -201,6 +246,7 @@ export class VmCompiler {
     }
 
     private compileStatement(stmt: Statement, state: FuncState): void {
+        if (this.debug && (stmt as { line?: { start: number } }).line) state.curLine = (stmt as { line: { start: number } }).line.start
         switch (stmt.type) {
             case "LocalStatement": {
                 // 순서 중요: 로컬(및 캡처된 것의 박스)을 "먼저" 선언해서 레지스터를 확정한 뒤에
@@ -235,11 +281,39 @@ export class VmCompiler {
                 return
             }
             case "AssignmentStatement": {
-                const valueRegs = stmt.values.map((e) => this.compileExpr(e, state))
-                stmt.targets.forEach((target, i) => {
-                    const srcReg = valueRegs[i] ?? valueRegs[valueRegs.length - 1]
-                    this.compileAssignTarget(target, srcReg, state)
-                })
+                // LocalStatement와 동일한 다중값 규칙을 따라야 한다: 우변의 "마지막" 식이
+                // Call/MethodCall/Vararg면 남는 대상 개수만큼 펼쳐야 하고(`a, b = f()` →
+                // a=1번째, b=2번째 반환값), 그 외엔 각자 1개씩. 예전 구현은 각 값을 따로
+                // compileExpr해서 대상 개수보다 값이 적으면 "마지막 값 하나를 재사용"했는데,
+                // 그 바람에 `Tools, Manager = Nova.Create()`에서 Manager가 2번째 반환값이
+                // 아니라 Tools(1번째)를 그대로 받아 "attempt to call a nil value"로 터졌다.
+                //
+                // 모든 우변을 먼저 연속 레지스터 블록(base..)에 계산한 뒤 대상에 대입한다 —
+                // 이 순서라야 `a, b = b, a`(스왑)처럼 대입 전에 우변을 전부 평가하는
+                // Lua 의미가 보존된다.
+                const targets = stmt.targets
+                const values = stmt.values
+                const base = state.regs.top()
+                if (values.length > 0) {
+                    for (let i = 0; i < values.length - 1; i++) {
+                        this.compileExprTo(values[i], state, base + i)
+                    }
+                    const lastIdx = values.length - 1
+                    const remaining = Math.max(targets.length - lastIdx, 1)
+                    this.compileExprMultiInto(values[lastIdx], state, base + lastIdx, remaining)
+                }
+                // 값보다 대상이 많으면 나머지 대상은 nil.
+                const produced = values.length === 0 ? 0 : (values.length - 1) + Math.max(targets.length - (values.length - 1), 1)
+                for (let i = produced; i < targets.length; i++) {
+                    this.emit(state, Opcode.LOADNIL, base + i, base + i, 0)
+                }
+                // 대입: 대상 프리픽스(테이블/키) 평가용 임시가 아직 안 쓴 값 슬롯을 덮지
+                // 않도록, 매 대입 전에 freereg를 값 블록 위(base+targets.length)로 올려둔다.
+                for (let i = 0; i < targets.length; i++) {
+                    state.regs.freeTemp(base + targets.length)
+                    this.compileAssignTarget(targets[i], base + i, state)
+                }
+                state.regs.freeTemp(base)
                 return
             }
             case "CompoundAssignmentStatement":
@@ -617,7 +691,7 @@ export class VmCompiler {
         // CallExpression과 동일한 이유로 top()을 미리 캐싱하지 않고 callee의 반환값을 base로 씀.
         const base = this.compileExpr(callExpr.callee, state)
         this.compileArgsContiguous(callExpr.arguments, state, base + 1)
-        this.emit(state, Opcode.CALL, base, callExpr.arguments.length + 1, wantCount + 1)
+        this.stampCall(state, this.emit(state, Opcode.CALL, base, callExpr.arguments.length + 1, wantCount + 1), callExpr, callExpr.callee)
         return base
     }
 
@@ -676,7 +750,7 @@ export class VmCompiler {
         if (expr.type === "CallExpression") {
             const calleeReg = this.compileExpr(expr.callee, state)
             const b = this.compileCallArgsAndGetB(expr.arguments, state, calleeReg + 1)
-            this.emit(state, Opcode.CALL, calleeReg, b, wantCount + 1)
+            this.stampCall(state, this.emit(state, Opcode.CALL, calleeReg, b, wantCount + 1), expr, expr.callee)
             for (let i = 0; i < wantCount; i++) {
                 if (calleeReg + i !== base + i) this.emit(state, Opcode.MOVE, base + i, calleeReg + i, 0)
             }
@@ -691,7 +765,7 @@ export class VmCompiler {
             state.regs.allocTemp()
             const argB = this.compileCallArgsAndGetB(expr.arguments, state, fnSlot + 2)
             const b = argB === 0 ? 0 : expr.arguments.length + 2
-            this.emit(state, Opcode.CALL, fnSlot, b, wantCount + 1)
+            this.stampCall(state, this.emit(state, Opcode.CALL, fnSlot, b, wantCount + 1), expr, expr)
             for (let i = 0; i < wantCount; i++) {
                 if (fnSlot + i !== base + i) this.emit(state, Opcode.MOVE, base + i, fnSlot + i, 0)
             }
@@ -722,7 +796,7 @@ export class VmCompiler {
             if (calleeReg !== base) this.emit(state, Opcode.MOVE, base, calleeReg, 0)
             state.regs.freeTemp(base + 1)
             const b = this.compileCallArgsAndGetB(expr.arguments, state, base + 1)
-            this.emit(state, Opcode.CALL, base, b, 0)
+            this.stampCall(state, this.emit(state, Opcode.CALL, base, b, 0), expr, expr.callee)
             return
         }
         if (expr.type === "MethodCallExpression") {
@@ -738,7 +812,7 @@ export class VmCompiler {
             state.regs.freeTemp(base + 2)
             const argB = this.compileCallArgsAndGetB(expr.arguments, state, base + 2)
             const b = argB === 0 ? 0 : expr.arguments.length + 2
-            this.emit(state, Opcode.CALL, base, b, 0)
+            this.stampCall(state, this.emit(state, Opcode.CALL, base, b, 0), expr, expr)
             return
         }
         if (expr.type === "VarargExpression") {
@@ -767,6 +841,7 @@ export class VmCompiler {
     }
 
     private compileExpr(expr: Expression, state: FuncState, discard = false): number {
+        if (this.debug && (expr as { line?: { start: number } }).line) state.curLine = (expr as { line: { start: number } }).line.start
         switch (expr.type) {
             case "NilLiteral": {
                 const r = state.regs.allocTemp()
@@ -896,7 +971,8 @@ export class VmCompiler {
                 // 쓴 임시 레지스터 때문에 함수 값 자체는 그 다음 슬롯에 옴).
                 const base = this.compileExpr(expr.callee, state)
                 const b = this.compileCallArgsAndGetB(expr.arguments, state, base + 1)
-                this.emit(state, Opcode.CALL, base, b, discard ? 1 : 2)
+                const callIdx = this.emit(state, Opcode.CALL, base, b, discard ? 1 : 2)
+                this.stampCall(state, callIdx, expr, expr.callee)
                 state.regs.freeTemp(base + (discard ? 0 : 1))
                 return base
             }
@@ -910,7 +986,8 @@ export class VmCompiler {
                 // self가 항상 고정으로 하나 더 붙으므로: 열려있으면(0) 그대로 0(런타임이
                 // multiTop까지 다 잡아줌, self도 그 범위 안에 포함됨), 아니면 +1(self 몫).
                 const b = argB === 0 ? 0 : expr.arguments.length + 2
-                this.emit(state, Opcode.CALL, fnSlot, b, discard ? 1 : 2)
+                const callIdx = this.emit(state, Opcode.CALL, fnSlot, b, discard ? 1 : 2)
+                this.stampCall(state, callIdx, expr, expr)
                 state.regs.freeTemp(fnSlot + (discard ? 0 : 1))
                 return fnSlot
             }

package/src/passes/vmify/opcodes.ts

@@ -50,6 +50,10 @@ export interface Instr {
     c: number
     /** JMP/EQ/LT/LE/TEST/CALL 등에서 사람이 읽을 디버깅용 주석. 런타임엔 안 쓰임. */
     comment?: string
+    /** debug 빌드에서만: 이 인스트럭션이 나온 원본 소스(입력 .luau) 줄 번호. */
+    dbgLine?: number
+    /** debug 빌드에서만: CALL이면 호출 대상 표현식을 사람이 읽을 문자열로(예: "print", "obj:method"). */
+    dbgName?: string
 }
 
 /** RK 인코딩 헬퍼: 상수는 음수(-idx-1), 레지스터는 그대로 양수. */