luau-obfuscator 1.0.0 → 1.0.2

package/src/passes/InsertJunk.ts

@@ -1,185 +1,185 @@
-import type {
-    Program, Block, Statement, Expression,
-} from "luau-parser"
-import {
-    identifier, numberLiteral, binary, localStatement, doStatement, block,
-    ifStatement, ifClause,
-} from "./nodeFactory"
-
-export interface InsertJunkOptions {
-    /** 기존 statement 하나 앞에 junk를 끼워넣을 확률 (0~1) */
-    probability: number
-    /** 블록 하나당 최대 삽입 개수 */
-    maxPerBlock: number
-}
-
-function randomInt(min: number, max: number): number {
-    return Math.floor(Math.random() * (max - min + 1)) + min
-}
-
-function randomName(): string {
-    return "_" + globalThis.crypto.randomUUID().replace(/-/g, "")
-}
-
-function junkNumberExpr(): Expression {
-    const op = Math.random() < 0.5 ? "+" : "*"
-    return binary(op, numberLiteral(randomInt(1, 999)), numberLiteral(randomInt(1, 999)))
-}
-
-/**
- * 실행돼도 관찰 가능한 부작용이 전혀 없는 더미 statement 하나를 만듦.
- * - 매번 새 랜덤 이름을 쓰므로 다른 변수와 충돌하지 않음
- * - if 분기 조건이 실제로 참/거짓 어느 쪽이어도 몸통이 쓸모없는 local 선언뿐이라
- *   상관없음 (opaque predicate를 엄밀하게 항상 거짓으로 만들 필요가 없음)
- */
-function buildJunkStatement(): Statement {
-    const variants: Array<() => Statement> = [
-        () => localStatement(randomName(), junkNumberExpr()),
-        () => doStatement(block([localStatement(randomName(), junkNumberExpr())])),
-        () => ifStatement([
-            ifClause(
-                binary("==", numberLiteral(randomInt(1, 999)), numberLiteral(randomInt(1, 999))),
-                block([localStatement(randomName(), junkNumberExpr())]),
-            ),
-        ]),
-    ]
-    return variants[randomInt(0, variants.length - 1)]()
-}
-
-export function runInsertJunk(program: Program, options: InsertJunkOptions): void {
-    function processExpr(expr: Expression): void {
-        switch (expr.type) {
-            case "InterpolatedStringExpression":
-                for (const part of expr.parts) {
-                    if (part.kind === "expression") processExpr(part.expression)
-                }
-                return
-            case "FunctionExpression":
-                processBlock(expr.func.body)
-                return
-            case "TableExpression":
-                for (const field of expr.fields) {
-                    if (field.type === "TableFieldPositional") processExpr(field.value)
-                    else if (field.type === "TableFieldNamed") processExpr(field.value)
-                    else { processExpr(field.key); processExpr(field.value) }
-                }
-                return
-            case "BinaryExpression":
-                processExpr(expr.left)
-                processExpr(expr.right)
-                return
-            case "UnaryExpression":
-                processExpr(expr.argument)
-                return
-            case "MemberExpression":
-                processExpr(expr.object)
-                return
-            case "IndexExpression":
-                processExpr(expr.object)
-                processExpr(expr.index)
-                return
-            case "CallExpression":
-                processExpr(expr.callee)
-                expr.arguments.forEach(processExpr)
-                return
-            case "MethodCallExpression":
-                processExpr(expr.object)
-                expr.arguments.forEach(processExpr)
-                return
-            case "ParenthesizedExpression":
-                processExpr(expr.expression)
-                return
-            case "TypeAssertionExpression":
-                processExpr(expr.expression)
-                return
-            case "IfElseExpression":
-                for (const clause of expr.clauses) {
-                    processExpr(clause.condition)
-                    processExpr(clause.body)
-                }
-                processExpr(expr.alternate)
-                return
-            default:
-                return
-        }
-    }
-
-    function processStatement(stmt: Statement): void {
-        switch (stmt.type) {
-            case "LocalStatement":
-                stmt.init.forEach(processExpr)
-                return
-            case "LocalFunctionStatement":
-                processBlock(stmt.func.body)
-                return
-            case "FunctionDeclarationStatement":
-                processBlock(stmt.func.body)
-                return
-            case "AssignmentStatement":
-                stmt.targets.forEach(processExpr)
-                stmt.values.forEach(processExpr)
-                return
-            case "CompoundAssignmentStatement":
-                processExpr(stmt.target)
-                processExpr(stmt.value)
-                return
-            case "CallStatement":
-                processExpr(stmt.expression)
-                return
-            case "DoStatement":
-                processBlock(stmt.body)
-                return
-            case "WhileStatement":
-                processExpr(stmt.condition)
-                processBlock(stmt.body)
-                return
-            case "RepeatStatement":
-                processBlock(stmt.body)
-                processExpr(stmt.condition)
-                return
-            case "IfStatement":
-                for (const clause of stmt.clauses) {
-                    processExpr(clause.condition)
-                    processBlock(clause.body)
-                }
-                if (stmt.alternate) processBlock(stmt.alternate)
-                return
-            case "NumericForStatement":
-                processExpr(stmt.start)
-                processExpr(stmt.end)
-                if (stmt.step) processExpr(stmt.step)
-                processBlock(stmt.body)
-                return
-            case "GenericForStatement":
-                stmt.iterators.forEach(processExpr)
-                processBlock(stmt.body)
-                return
-            case "ReturnStatement":
-                stmt.arguments.forEach(processExpr)
-                return
-            default:
-                return
-        }
-    }
-
-    /** 자식 블록들부터 먼저 처리한 뒤(재귀 무한 방지 — 새로 끼워넣는 junk는
-     *  다시 처리하지 않음), 현재 블록에 junk를 끼워넣음. junk는 기존 statement
-     *  "앞"에만 넣으므로 return/break/continue(항상 블록 맨 끝에만 올 수 있음)
-     *  뒤에 잘못 삽입될 일이 없음. */
-    function processBlock(blk: Block): void {
-        for (const stmt of blk.statements) processStatement(stmt)
-
-        const result: Statement[] = []
-        let inserted = 0
-        for (const stmt of blk.statements) {
-            if (inserted < options.maxPerBlock && Math.random() < options.probability) {
-                result.push(buildJunkStatement())
-                inserted++
-            }
-            result.push(stmt)
-        }
-        blk.statements = result
-    }
-
-    processBlock(program.body)
+import type {
+    Program, Block, Statement, Expression,
+} from "luau-parser"
+import {
+    identifier, numberLiteral, binary, localStatement, doStatement, block,
+    ifStatement, ifClause,
+} from "./nodeFactory"
+
+export interface InsertJunkOptions {
+    /** 기존 statement 하나 앞에 junk를 끼워넣을 확률 (0~1) */
+    probability: number
+    /** 블록 하나당 최대 삽입 개수 */
+    maxPerBlock: number
+}
+
+function randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+function randomName(): string {
+    return "_" + globalThis.crypto.randomUUID().replace(/-/g, "")
+}
+
+function junkNumberExpr(): Expression {
+    const op = Math.random() < 0.5 ? "+" : "*"
+    return binary(op, numberLiteral(randomInt(1, 999)), numberLiteral(randomInt(1, 999)))
+}
+
+/**
+ * 실행돼도 관찰 가능한 부작용이 전혀 없는 더미 statement 하나를 만듦.
+ * - 매번 새 랜덤 이름을 쓰므로 다른 변수와 충돌하지 않음
+ * - if 분기 조건이 실제로 참/거짓 어느 쪽이어도 몸통이 쓸모없는 local 선언뿐이라
+ *   상관없음 (opaque predicate를 엄밀하게 항상 거짓으로 만들 필요가 없음)
+ */
+function buildJunkStatement(): Statement {
+    const variants: Array<() => Statement> = [
+        () => localStatement(randomName(), junkNumberExpr()),
+        () => doStatement(block([localStatement(randomName(), junkNumberExpr())])),
+        () => ifStatement([
+            ifClause(
+                binary("==", numberLiteral(randomInt(1, 999)), numberLiteral(randomInt(1, 999))),
+                block([localStatement(randomName(), junkNumberExpr())]),
+            ),
+        ]),
+    ]
+    return variants[randomInt(0, variants.length - 1)]()
+}
+
+export function runInsertJunk(program: Program, options: InsertJunkOptions): void {
+    function processExpr(expr: Expression): void {
+        switch (expr.type) {
+            case "InterpolatedStringExpression":
+                for (const part of expr.parts) {
+                    if (part.kind === "expression") processExpr(part.expression)
+                }
+                return
+            case "FunctionExpression":
+                processBlock(expr.func.body)
+                return
+            case "TableExpression":
+                for (const field of expr.fields) {
+                    if (field.type === "TableFieldPositional") processExpr(field.value)
+                    else if (field.type === "TableFieldNamed") processExpr(field.value)
+                    else { processExpr(field.key); processExpr(field.value) }
+                }
+                return
+            case "BinaryExpression":
+                processExpr(expr.left)
+                processExpr(expr.right)
+                return
+            case "UnaryExpression":
+                processExpr(expr.argument)
+                return
+            case "MemberExpression":
+                processExpr(expr.object)
+                return
+            case "IndexExpression":
+                processExpr(expr.object)
+                processExpr(expr.index)
+                return
+            case "CallExpression":
+                processExpr(expr.callee)
+                expr.arguments.forEach(processExpr)
+                return
+            case "MethodCallExpression":
+                processExpr(expr.object)
+                expr.arguments.forEach(processExpr)
+                return
+            case "ParenthesizedExpression":
+                processExpr(expr.expression)
+                return
+            case "TypeAssertionExpression":
+                processExpr(expr.expression)
+                return
+            case "IfElseExpression":
+                for (const clause of expr.clauses) {
+                    processExpr(clause.condition)
+                    processExpr(clause.body)
+                }
+                processExpr(expr.alternate)
+                return
+            default:
+                return
+        }
+    }
+
+    function processStatement(stmt: Statement): void {
+        switch (stmt.type) {
+            case "LocalStatement":
+                stmt.init.forEach(processExpr)
+                return
+            case "LocalFunctionStatement":
+                processBlock(stmt.func.body)
+                return
+            case "FunctionDeclarationStatement":
+                processBlock(stmt.func.body)
+                return
+            case "AssignmentStatement":
+                stmt.targets.forEach(processExpr)
+                stmt.values.forEach(processExpr)
+                return
+            case "CompoundAssignmentStatement":
+                processExpr(stmt.target)
+                processExpr(stmt.value)
+                return
+            case "CallStatement":
+                processExpr(stmt.expression)
+                return
+            case "DoStatement":
+                processBlock(stmt.body)
+                return
+            case "WhileStatement":
+                processExpr(stmt.condition)
+                processBlock(stmt.body)
+                return
+            case "RepeatStatement":
+                processBlock(stmt.body)
+                processExpr(stmt.condition)
+                return
+            case "IfStatement":
+                for (const clause of stmt.clauses) {
+                    processExpr(clause.condition)
+                    processBlock(clause.body)
+                }
+                if (stmt.alternate) processBlock(stmt.alternate)
+                return
+            case "NumericForStatement":
+                processExpr(stmt.start)
+                processExpr(stmt.end)
+                if (stmt.step) processExpr(stmt.step)
+                processBlock(stmt.body)
+                return
+            case "GenericForStatement":
+                stmt.iterators.forEach(processExpr)
+                processBlock(stmt.body)
+                return
+            case "ReturnStatement":
+                stmt.arguments.forEach(processExpr)
+                return
+            default:
+                return
+        }
+    }
+
+    /** 자식 블록들부터 먼저 처리한 뒤(재귀 무한 방지 — 새로 끼워넣는 junk는
+     *  다시 처리하지 않음), 현재 블록에 junk를 끼워넣음. junk는 기존 statement
+     *  "앞"에만 넣으므로 return/break/continue(항상 블록 맨 끝에만 올 수 있음)
+     *  뒤에 잘못 삽입될 일이 없음. */
+    function processBlock(blk: Block): void {
+        for (const stmt of blk.statements) processStatement(stmt)
+
+        const result: Statement[] = []
+        let inserted = 0
+        for (const stmt of blk.statements) {
+            if (inserted < options.maxPerBlock && Math.random() < options.probability) {
+                result.push(buildJunkStatement())
+                inserted++
+            }
+            result.push(stmt)
+        }
+        blk.statements = result
+    }
+
+    processBlock(program.body)
 }

package/src/passes/Minify.ts

@@ -1,6 +1,6 @@
-export function minifyPrinted(code: string): string {
-    return code
-        .replace(/\r\n|\r|\n/g, " ")
-        .replace(/[ \t]+/g, " ")
-        .trim()
+export function minifyPrinted(code: string): string {
+    return code
+        .replace(/\r\n|\r|\n/g, " ")
+        .replace(/[ \t]+/g, " ")
+        .trim()
 }

package/src/passes/NumbersToExpressions.ts

@@ -1,25 +1,48 @@
-import type { Program, Expression } from "luau-parser"
+import type { Program, Expression, Statement } from "luau-parser"
 import { transformExpressions } from "./walk"
-import { numberLiteral, binary, paren } from "./nodeFactory"
+import {
+    numberLiteral, binary, paren, identifier, call, index, table, positionalField,
+    localStatement, localFunctionStatement, functionParam, functionBody, functionExpression,
+    block, assignmentStatement, numericForStatement, whileStatement, ifStatement, ifClause,
+    returnStatement, unary, vmStructuralNumbers,
+} from "./nodeFactory"
 
 export interface NumbersToExpressionsOptions {
     /** 랜덤 보조항의 최소 절댓값 */
     min: number
     /** 랜덤 보조항의 최대 절댓값 */
     max: number
+    /**
+     * 0~1. 정수 리터럴을 순수 산술식(depth 얕은 a+b 형태) 대신
+     * for/while 루프나 재귀 함수 호출로 "런타임에 조립"할 확률.
+     * 단순 트리 순회형 상수 접기(constant folding)는 문(statement)/제어흐름을
+     * 해석하지 못하므로 이 경로로 만든 값은 그런 도구로는 복원되지 않는다.
+     * 기본값 0.35.
+     */
+    controlFlowProbability?: number
 }
 
 const MAX_DEPTH = 1
 const NEST_PROBABILITY = 0.35
+const CONTROL_FLOW_PROBABILITY_DEFAULT = 0.35
 
 function randomInt(min: number, max: number): number {
     return Math.floor(Math.random() * (max - min + 1)) + min
 }
 
+function randomName(): string {
+    return "_" + globalThis.crypto.randomUUID().replace(/-/g, "")
+}
+
 function randSign(): 1 | -1 {
     return Math.random() < 0.5 ? 1 : -1
 }
 
+/** (function() ... end)() — 문(statement)들을 하나의 표현식으로 감싸는 즉시실행 함수. */
+function iife(statements: Statement[]): Expression {
+    return call(paren(functionExpression(functionBody([], block(statements)))), [])
+}
+
 type Strategy = "add" | "sub" | "mul"
 
 /** value를 min~max 범위 정수로 나눌 수 있으면 mul도 후보에 추가 */
@@ -44,6 +67,7 @@ function operand(n: number, min: number, max: number, depth: number): Expression
     return numberLiteral(n)
 }
 
+/** 얕은 산술식(a+b, a-b, a*b) 하나로 값을 위장 — 기존 방식, 가벼운 기본 경로로 유지. */
 function buildNumberExpr(value: number, min: number, max: number, depth = 0): Expression {
     const strategy = pickStrategy(value, min, max)
     let inner: Expression
@@ -78,9 +102,166 @@ function buildNumberExpr(value: number, min: number, max: number, depth = 0): Ex
     return paren(inner)
 }
 
+/** n개의 정수 조각(합이 정확히 value)으로 분할. 마지막 조각은 나머지를 정확히 채운다. */
+function randomPartition(value: number, n: number, min: number, max: number): number[] {
+    const parts: number[] = []
+    let remaining = value
+    for (let i = 0; i < n - 1; i++) {
+        const part = randomInt(min, max) * randSign()
+        parts.push(part)
+        remaining -= part
+    }
+    parts.push(remaining)
+    return parts
+}
+
+/**
+ *   (function()
+ *       local steps = { s1, s2, ..., sn }
+ *       local acc = 0
+ *       for i = 1, #steps do
+ *           acc = acc + steps[i]
+ *       end
+ *       return acc
+ *   end)()
+ */
+function buildForLoopNumberExpr(value: number, min: number, max: number): Expression {
+    const n = randomInt(3, 6)
+    const steps = randomPartition(value, n, min, max)
+
+    const accVar = randomName()
+    const stepsVar = randomName()
+    const iVar = randomName()
+
+    const stmts: Statement[] = [
+        localStatement(stepsVar, table(steps.map((s) => positionalField(numberLiteral(s))))),
+        localStatement(accVar, numberLiteral(0)),
+        numericForStatement(
+            iVar,
+            numberLiteral(1),
+            unary("#", identifier(stepsVar)),
+            block([
+                assignmentStatement(
+                    [identifier(accVar)],
+                    [binary("+", identifier(accVar), index(identifier(stepsVar), identifier(iVar)))],
+                ),
+            ]),
+        ),
+        returnStatement([identifier(accVar)]),
+    ]
+
+    return iife(stmts)
+}
+
+/**
+ *   (function()
+ *       local acc = BASE
+ *       local n = N
+ *       while n > 0 do
+ *           acc = acc + STEP
+ *           n = n - 1
+ *       end
+ *       return acc
+ *   end)()
+ */
+function buildWhileLoopNumberExpr(value: number, min: number, max: number): Expression {
+    const n = randomInt(3, 6)
+    const step = randomInt(min, max) * randSign()
+    const base = value - n * step
+
+    const accVar = randomName()
+    const nVar = randomName()
+
+    const stmts: Statement[] = [
+        localStatement(accVar, numberLiteral(base)),
+        localStatement(nVar, numberLiteral(n)),
+        whileStatement(
+            binary(">", identifier(nVar), numberLiteral(0)),
+            block([
+                assignmentStatement([identifier(accVar)], [binary("+", identifier(accVar), numberLiteral(step))]),
+                assignmentStatement([identifier(nVar)], [binary("-", identifier(nVar), numberLiteral(1))]),
+            ]),
+        ),
+        returnStatement([identifier(accVar)]),
+    ]
+
+    return iife(stmts)
+}
+
+/**
+ *   (function()
+ *       local function <rec>(n)
+ *           if n <= 0 then
+ *               return BASE
+ *           end
+ *           return STEP + <rec>(n - 1)
+ *       end
+ *       return <rec>(N)
+ *   end)()
+ */
+function buildRecursiveNumberExpr(value: number, min: number, max: number): Expression {
+    const n = randomInt(3, 6)
+    const step = randomInt(min, max) * randSign()
+    const base = value - n * step
+
+    const recName = randomName()
+    const nParam = randomName()
+
+    const body = block([
+        ifStatement([
+            ifClause(
+                binary("<=", identifier(nParam), numberLiteral(0)),
+                block([returnStatement([numberLiteral(base)])]),
+            ),
+        ]),
+        returnStatement([
+            binary(
+                "+",
+                numberLiteral(step),
+                call(identifier(recName), [binary("-", identifier(nParam), numberLiteral(1))]),
+            ),
+        ]),
+    ])
+
+    return iife([
+        localFunctionStatement(recName, functionBody([functionParam(nParam)], body)),
+        returnStatement([call(identifier(recName), [numberLiteral(n)])]),
+    ])
+}
+
+type ControlFlowStrategy = "forLoop" | "whileLoop" | "recursive"
+
+function pickControlFlowStrategy(): ControlFlowStrategy {
+    const options: ControlFlowStrategy[] = ["forLoop", "whileLoop", "recursive"]
+    return options[randomInt(0, options.length - 1)]
+}
+
+function buildControlFlowNumberExpr(value: number, min: number, max: number): Expression {
+    switch (pickControlFlowStrategy()) {
+        case "forLoop":
+            return buildForLoopNumberExpr(value, min, max)
+        case "whileLoop":
+            return buildWhileLoopNumberExpr(value, min, max)
+        case "recursive":
+            return buildRecursiveNumberExpr(value, min, max)
+    }
+}
+
 export function runNumbersToExpressions(program: Program, options: NumbersToExpressionsOptions): void {
+    const controlFlowProbability = options.controlFlowProbability ?? CONTROL_FLOW_PROBABILITY_DEFAULT
+
     transformExpressions(program, (expr) => {
         if (expr.type !== "NumberLiteral") return
+        // Vmify가 만든 op/a/b/c 같은 내부 메타데이터는 건드리지 않는다
+        // (개수가 코드 크기에 비례해 폭증하고, 로직은 이미 Vmify가 구조적으로 숨긴 값).
+        if (vmStructuralNumbers.has(expr)) return
+
+        // 루프/재귀 조립은 정수 배분(합이 정확히 일치)에 의존하므로 정수에만 적용하고,
+        // 실수/범위를 벗어난 값은 기존 산술식 위장으로 처리한다.
+        if (Number.isInteger(expr.value) && Math.random() < controlFlowProbability) {
+            return buildControlFlowNumberExpr(expr.value, options.min, options.max)
+        }
+
         return buildNumberExpr(expr.value, options.min, options.max)
     })
 }

package/src/passes/RenameVariables.ts

@@ -2,24 +2,17 @@ import type { Program } from "luau-parser"
 import { analyzeScopes, isGlobal } from "luau-parser"
 
 export interface RenameVariablesOptions {
-    random?: () => string
-}
-
-let counter = 0
-function defaultRandomName(): string {
-    counter += 1
-    return `_l${counter.toString(36)}`
+    random: () => string
 }
 
 export function runRenameVariables(program: Program, options: RenameVariablesOptions): void {
     const analysis = analyzeScopes(program)
-    const makeName = options.random ?? defaultRandomName
 
     for (const binding of analysis.bindings.values()) {
         if (isGlobal(binding)) continue
         if (binding.kind === "self") continue
 
-        const newName = makeName()
+        const newName = options.random()
         binding.name = newName
 
         if (binding.declarationNode) {