luau-obfuscator 1.0.0

package/src/passes/nodeFactory.ts

@@ -0,0 +1,143 @@
+import type {
+    Identifier, StringLiteral, NumberLiteral, BinaryExpression, UnaryExpression,
+    CallExpression, MemberExpression, IndexExpression,
+    ParenthesizedExpression, Expression, TableExpression, TableField,
+    LocalStatement, LocalFunctionStatement, FunctionBody, FunctionParameter,
+    TypedIdentifier, Block, Statement, AssignmentStatement, NumericForStatement,
+    ReturnStatement, DoStatement, IfStatement, IfClause, VarargExpression,
+    FunctionExpression,
+} from "luau-parser"
+
+/** 합성 노드는 실제 소스 위치가 없으므로 0으로 채움(printer는 구조만 봄). */
+const POS = { start: 0, end: 0 }
+
+export function identifier(name: string): Identifier {
+    return { type: "Identifier", name, line: POS, column: POS }
+}
+
+export function typedIdentifier(name: string): TypedIdentifier {
+    return { type: "TypedIdentifier", name, line: POS, column: POS }
+}
+
+export function stringLiteral(value: string): StringLiteral {
+    return { type: "StringLiteral", value, raw: JSON.stringify(value), line: POS, column: POS }
+}
+
+export function numberLiteral(value: number): NumberLiteral {
+    return { type: "NumberLiteral", value, raw: String(value), line: POS, column: POS }
+}
+
+export function binary(
+    operator: BinaryExpression["operator"],
+    left: Expression,
+    right: Expression,
+): BinaryExpression {
+    return { type: "BinaryExpression", operator, left, right, line: POS, column: POS }
+}
+
+export function unary(operator: UnaryExpression["operator"], argument: Expression): UnaryExpression {
+    return { type: "UnaryExpression", operator, argument, line: POS, column: POS }
+}
+
+export function call(callee: Expression, args: Expression[]): CallExpression {
+    return { type: "CallExpression", callee, arguments: args, line: POS, column: POS }
+}
+
+export function member(object: Expression, property: string): MemberExpression {
+    return { type: "MemberExpression", object, property: identifier(property), line: POS, column: POS }
+}
+
+export function index(object: Expression, key: Expression): IndexExpression {
+    return { type: "IndexExpression", object, index: key, line: POS, column: POS }
+}
+
+export function paren(expression: Expression): ParenthesizedExpression {
+    return { type: "ParenthesizedExpression", expression, line: POS, column: POS }
+}
+
+export function table(fields: TableField[]): TableExpression {
+    return { type: "TableExpression", fields, line: POS, column: POS }
+}
+
+export function computedField(key: Expression, value: Expression): TableField {
+    return { type: "TableFieldComputed", key, value }
+}
+
+export function positionalField(value: Expression): TableField {
+    return { type: "TableFieldPositional", value }
+}
+
+export function localStatement(name: string, init: Expression): LocalStatement {
+    return {
+        type: "LocalStatement",
+        names: [typedIdentifier(name)],
+        init: [init],
+        line: POS,
+        column: POS,
+    }
+}
+
+export function block(statements: Statement[]): Block {
+    return { type: "Block", statements, line: POS, column: POS }
+}
+
+export function assignmentStatement(targets: Expression[], values: Expression[]): AssignmentStatement {
+    return { type: "AssignmentStatement", targets, values, line: POS, column: POS }
+}
+
+export function returnStatement(args: Expression[]): ReturnStatement {
+    return { type: "ReturnStatement", arguments: args, line: POS, column: POS }
+}
+
+export function numericForStatement(
+    variableName: string,
+    start: Expression,
+    end: Expression,
+    body: Block,
+): NumericForStatement {
+    return {
+        type: "NumericForStatement",
+        variable: typedIdentifier(variableName),
+        start,
+        end,
+        body,
+        line: POS,
+        column: POS,
+    }
+}
+
+export function functionParam(name: string): FunctionParameter {
+    return { type: "FunctionParameter", name, line: POS, column: POS }
+}
+
+export function functionBody(params: FunctionParameter[], body: Block, hasVarargs = false): FunctionBody {
+    return {
+        type: "FunctionBody", generics: [], params, hasVarargs, body, line: POS, column: POS,
+    }
+}
+
+export function functionExpression(func: FunctionBody): FunctionExpression {
+    return { type: "FunctionExpression", func, line: POS, column: POS }
+}
+
+export function localFunctionStatement(name: string, func: FunctionBody): LocalFunctionStatement {
+    return {
+        type: "LocalFunctionStatement", name: identifier(name), func, line: POS, column: POS,
+    }
+}
+
+export function doStatement(body: Block): DoStatement {
+    return { type: "DoStatement", body, line: POS, column: POS }
+}
+
+export function ifClause(condition: Expression, body: Block): IfClause {
+    return { type: "IfClause", condition, body, line: POS, column: POS }
+}
+
+export function ifStatement(clauses: IfClause[], alternate?: Block): IfStatement {
+    return { type: "IfStatement", clauses, alternate, line: POS, column: POS }
+}
+
+export function vararg(): VarargExpression {
+    return { type: "VarargExpression", line: POS, column: POS }
+}

package/src/passes/walk.ts

@@ -0,0 +1,173 @@
+import type {
+    Program, Block, Statement, Expression, FunctionBody,
+} from "luau-parser"
+
+export type ExpressionVisitor = (expr: Expression) => Expression | undefined | void
+
+function visitArray(arr: Expression[], visitor: ExpressionVisitor): void {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = mapExpression(arr[i], visitor)
+    }
+}
+
+export function mapExpression(expr: Expression, visitor: ExpressionVisitor): Expression {
+    switch (expr.type) {
+        case "InterpolatedStringExpression":
+            for (const part of expr.parts) {
+                if (part.kind === "expression") {
+                    part.expression = mapExpression(part.expression, visitor)
+                }
+            }
+            break
+
+        case "FunctionExpression":
+            walkFunctionBody(expr.func, visitor)
+            break
+
+        case "TableExpression":
+            for (const field of expr.fields) {
+                if (field.type === "TableFieldPositional") {
+                    field.value = mapExpression(field.value, visitor)
+                } else if (field.type === "TableFieldNamed") {
+                    field.value = mapExpression(field.value, visitor)
+                } else if (field.type === "TableFieldComputed") {
+                    field.key = mapExpression(field.key, visitor)
+                    field.value = mapExpression(field.value, visitor)
+                }
+            }
+            break
+
+        case "BinaryExpression":
+            expr.left = mapExpression(expr.left, visitor)
+            expr.right = mapExpression(expr.right, visitor)
+            break
+
+        case "UnaryExpression":
+            expr.argument = mapExpression(expr.argument, visitor)
+            break
+
+        case "MemberExpression":
+            expr.object = mapExpression(expr.object, visitor)
+            break
+
+        case "IndexExpression":
+            expr.object = mapExpression(expr.object, visitor)
+            expr.index = mapExpression(expr.index, visitor)
+            break
+
+        case "CallExpression":
+            expr.callee = mapExpression(expr.callee, visitor)
+            visitArray(expr.arguments, visitor)
+            break
+
+        case "MethodCallExpression":
+            expr.object = mapExpression(expr.object, visitor)
+            visitArray(expr.arguments, visitor)
+            break
+
+        case "ParenthesizedExpression":
+            expr.expression = mapExpression(expr.expression, visitor)
+            break
+
+        case "TypeAssertionExpression":
+            expr.expression = mapExpression(expr.expression, visitor)
+            break
+
+        case "IfElseExpression":
+            for (const clause of expr.clauses) {
+                clause.condition = mapExpression(clause.condition, visitor)
+                clause.body = mapExpression(clause.body, visitor)
+            }
+            expr.alternate = mapExpression(expr.alternate, visitor)
+            break
+    }
+
+    return visitor(expr) ?? expr
+}
+
+function walkFunctionBody(func: FunctionBody, visitor: ExpressionVisitor): void {
+    walkBlock(func.body, visitor)
+}
+
+function walkBlock(block: Block, visitor: ExpressionVisitor): void {
+    for (const stmt of block.statements) walkStatement(stmt, visitor)
+}
+
+function walkStatement(stmt: Statement, visitor: ExpressionVisitor): void {
+    switch (stmt.type) {
+        case "LocalStatement":
+            visitArray(stmt.init, visitor)
+            return
+
+        case "LocalFunctionStatement":
+            walkFunctionBody(stmt.func, visitor)
+            return
+
+        case "FunctionDeclarationStatement":
+            walkFunctionBody(stmt.func, visitor)
+            return
+
+        case "AssignmentStatement":
+            visitArray(stmt.targets, visitor)
+            visitArray(stmt.values, visitor)
+            return
+
+        case "CompoundAssignmentStatement":
+            stmt.target = mapExpression(stmt.target, visitor)
+            stmt.value = mapExpression(stmt.value, visitor)
+            return
+
+        case "CallStatement":
+            stmt.expression = mapExpression(stmt.expression, visitor) as typeof stmt.expression
+            return
+
+        case "DoStatement":
+            walkBlock(stmt.body, visitor)
+            return
+
+        case "WhileStatement":
+            stmt.condition = mapExpression(stmt.condition, visitor)
+            walkBlock(stmt.body, visitor)
+            return
+
+        case "RepeatStatement":
+            walkBlock(stmt.body, visitor)
+            stmt.condition = mapExpression(stmt.condition, visitor)
+            return
+
+        case "IfStatement":
+            for (const clause of stmt.clauses) {
+                clause.condition = mapExpression(clause.condition, visitor)
+                walkBlock(clause.body, visitor)
+            }
+            if (stmt.alternate) walkBlock(stmt.alternate, visitor)
+            return
+
+        case "NumericForStatement":
+            stmt.start = mapExpression(stmt.start, visitor)
+            stmt.end = mapExpression(stmt.end, visitor)
+            if (stmt.step) stmt.step = mapExpression(stmt.step, visitor)
+            walkBlock(stmt.body, visitor)
+            return
+
+        case "GenericForStatement":
+            visitArray(stmt.iterators, visitor)
+            walkBlock(stmt.body, visitor)
+            return
+
+        case "ReturnStatement":
+            visitArray(stmt.arguments, visitor)
+            return
+
+        case "BreakStatement":
+        case "ContinueStatement":
+        case "TypeAliasStatement":
+        case "ExportTypeAliasStatement":
+            return
+    }
+}
+
+/** Program 전체를 순회하며 모든 Expression 노드에 visitor를 적용(제자리 변형). */
+export function transformExpressions(program: Program, visitor: ExpressionVisitor): void {
+    walkBlock(program.body, visitor)
+}

package/src/pipeline.ts

@@ -0,0 +1,58 @@
+import type { Program } from "luau-parser"
+import type { ObfuscateConfig } from "./config"
+import { runStripTypes } from "./passes/StripTypes"
+import { runStringsToExpressions } from "./passes/StringsToExpressions"
+import { runNumbersToExpressions } from "./passes/NumbersToExpressions"
+import { runRenameVariables } from "./passes/RenameVariables"
+import { runGlobalMapping } from "./passes/GlobalMapping"
+import { runConstantArray } from "./passes/ConstantArray"
+import { runEncryptStrings } from "./passes/EncryptStrings"
+import { runEncryptNumbers } from "./passes/EncryptNumbers"
+import { runInsertJunk } from "./passes/InsertJunk"
+import { runWrapInFunction } from "./passes/WrapInFunction"
+
+type PassFn = (program: Program, options: any) => void
+
+export const PASS_ORDER: (keyof ObfuscateConfig)[] = [
+    "GlobalMapping",
+    "StringsToExpressions",
+    "NumbersToExpressions",
+    "RenameVariables",
+    "ConstantArray",
+    "EncryptStrings",
+    "EncryptNumbers",
+    "InsertJunk",
+    "Vmify",
+    "WrapInFunction",
+    "Minify",
+]
+
+export const PASS_MAP: Partial<Record<keyof ObfuscateConfig, PassFn>> = {
+    GlobalMapping: runGlobalMapping,
+    StringsToExpressions: runStringsToExpressions,
+    NumbersToExpressions: runNumbersToExpressions,
+    RenameVariables: runRenameVariables,
+    ConstantArray: runConstantArray,
+    EncryptStrings: runEncryptStrings,
+    EncryptNumbers: runEncryptNumbers,
+    InsertJunk: runInsertJunk,
+    WrapInFunction: runWrapInFunction,
+}
+
+export function runPipeline(program: Program, config: ObfuscateConfig): void {
+    // 타입 주석/별칭은 값 트리와 독립적으로 원본 이름을 참조하고 있어서
+    // (예: typeof(x)) 어떤 pass보다도 먼저 지워야 함. 끄면 무조건 깨지므로
+    // config로 조절 가능한 옵션이 아니라 파이프라인 진입 시 항상 실행.
+    runStripTypes(program)
+
+    for (const key of PASS_ORDER) {
+        const feature = config[key]
+        if (!feature.active) continue
+
+        const pass = PASS_MAP[key]
+        if (!pass) continue
+
+        const { active, ...options } = feature as { active: true } & Record<string, unknown>
+        pass(program, options)
+    }
+}

package/tsconfig.json

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

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+    entry: ["src/index.ts"],
+    format: ["esm", "cjs"],
+    dts: true,
+    clean: true,
+    sourcemap: false,
+    target: "esnext",
+});