luau-obfuscator 1.0.0

package/src/passes/InsertJunk.ts

@@ -0,0 +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)
+}

package/src/passes/Minify.ts

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

package/src/passes/NumbersToExpressions.ts

@@ -0,0 +1,86 @@
+import type { Program, Expression } from "luau-parser"
+import { transformExpressions } from "./walk"
+import { numberLiteral, binary, paren } from "./nodeFactory"
+
+export interface NumbersToExpressionsOptions {
+    /** 랜덤 보조항의 최소 절댓값 */
+    min: number
+    /** 랜덤 보조항의 최대 절댓값 */
+    max: number
+}
+
+const MAX_DEPTH = 1
+const NEST_PROBABILITY = 0.35
+
+function randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+function randSign(): 1 | -1 {
+    return Math.random() < 0.5 ? 1 : -1
+}
+
+type Strategy = "add" | "sub" | "mul"
+
+/** value를 min~max 범위 정수로 나눌 수 있으면 mul도 후보에 추가 */
+function pickStrategy(value: number, min: number, max: number): Strategy {
+    const candidates: Strategy[] = ["add", "sub"]
+    if (value !== 0) {
+        for (let a = min; a <= max; a++) {
+            if (a !== 0 && value % a === 0) {
+                candidates.push("mul")
+                break
+            }
+        }
+    }
+    return candidates[randomInt(0, candidates.length - 1)]
+}
+
+/** 확률적으로 피연산자를 리터럴 대신 한 단계 더 중첩된 식으로 치환 */
+function operand(n: number, min: number, max: number, depth: number): Expression {
+    if (depth < MAX_DEPTH && Math.random() < NEST_PROBABILITY) {
+        return buildNumberExpr(n, min, max, depth + 1)
+    }
+    return numberLiteral(n)
+}
+
+function buildNumberExpr(value: number, min: number, max: number, depth = 0): Expression {
+    const strategy = pickStrategy(value, min, max)
+    let inner: Expression
+
+    switch (strategy) {
+        case "add": {
+            const a = randomInt(min, max) * randSign()
+            const b = value - a
+            inner = binary("+", operand(a, min, max, depth), operand(b, min, max, depth))
+            break
+        }
+        case "sub": {
+            const a = randomInt(min, max) * randSign()
+            const b = a - value
+            inner = binary("-", operand(a, min, max, depth), operand(b, min, max, depth))
+            break
+        }
+        case "mul": {
+            let a = 1
+            for (let cand = min; cand <= max; cand++) {
+                if (cand !== 0 && value % cand === 0) {
+                    a = cand
+                    break
+                }
+            }
+            const b = value / a
+            inner = binary("*", operand(a, min, max, depth), operand(b, min, max, depth))
+            break
+        }
+    }
+
+    return paren(inner)
+}
+
+export function runNumbersToExpressions(program: Program, options: NumbersToExpressionsOptions): void {
+    transformExpressions(program, (expr) => {
+        if (expr.type !== "NumberLiteral") return
+        return buildNumberExpr(expr.value, options.min, options.max)
+    })
+}

package/src/passes/RenameVariables.ts

@@ -0,0 +1,32 @@
+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)}`
+}
+
+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()
+        binding.name = newName
+
+        if (binding.declarationNode) {
+            binding.declarationNode.name = newName
+        }
+        for (const ref of binding.references) {
+            ref.name = newName
+        }
+    }
+}

package/src/passes/StringsToExpressions.ts

@@ -0,0 +1,56 @@
+import type { Program, Expression } from "luau-parser"
+import { transformExpressions } from "./walk"
+import { numberLiteral, binary, call, member, identifier } from "./nodeFactory"
+
+export interface StringsToExpressionsOptions {
+    /** 청크 하나에 들어가는 바이트 개수 최소값 */
+    min: number
+    /** 청크 하나에 들어가는 바이트 개수 최대값 */
+    max: number
+}
+
+function randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+/** Luau 소스는 UTF-8 바이트 스트림이므로 charCodeAt이 아니라 실제 UTF-8 바이트로 변환.
+ *  Buffer(Node 전용) 대신 표준 TextEncoder 사용 — 브라우저/번들러 환경에서도 동작. */
+function toUtf8Bytes(value: string): number[] {
+    return Array.from(new TextEncoder().encode(value))
+}
+
+function splitByteChunks(bytes: number[], min: number, max: number): number[][] {
+    const chunks: number[][] = []
+    let i = 0
+    while (i < bytes.length) {
+        const size = Math.max(1, randomInt(min, max))
+        chunks.push(bytes.slice(i, i + size))
+        i += size
+    }
+    return chunks.length > 0 ? chunks : [bytes]
+}
+
+function stringCharCall(bytes: number[]): Expression {
+    // string.char(b1, b2, ...) — 원문 텍스트가 소스에 전혀 남지 않음
+    return call(member(identifier("string"), "char"), bytes.map(numberLiteral))
+}
+
+function buildConcatChain(chunks: number[][]): Expression {
+    let expr: Expression = stringCharCall(chunks[0])
+    for (let i = 1; i < chunks.length; i++) {
+        expr = binary("..", expr, stringCharCall(chunks[i]))
+    }
+    return expr
+}
+
+export function runStringsToExpressions(program: Program, options: StringsToExpressionsOptions): void {
+    transformExpressions(program, (expr) => {
+        if (expr.type !== "StringLiteral") return
+        if (expr.value.length === 0) return
+
+        const bytes = toUtf8Bytes(expr.value)
+        const chunks = splitByteChunks(bytes, options.min, options.max)
+
+        return buildConcatChain(chunks)
+    })
+}

package/src/passes/StripTypes.ts

@@ -0,0 +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
+    }
+}

package/src/passes/WrapInFunction.ts

@@ -0,0 +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])])
+}