luau-obfuscator 1.0.0 → 1.0.2

package/src/passes/Vmify.ts

@@ -0,0 +1,87 @@
+import type { Program, Statement, Expression } from "luau-parser"
+import { luauparser } from "luau-parser"
+import { VmCompiler, DEFAULT_BUILTIN_GLOBALS } from "./vmify/compiler"
+import { serializeProto } from "./vmify/serialize"
+import { buildVmRuntimeSource } from "./vmify/runtime"
+import { createOpcodeMap } from "./vmify/opcodes"
+import { generateVmNames } from "./vmify/names"
+import {
+    localStatement, identifier, call, table, namedField, returnStatement, vararg,
+    vmStructuralNumbers,
+} from "./nodeFactory"
+import { transformExpressions } from "./walk"
+
+/** 파싱된 서브트리(런타임 인터프리터 소스) 안의 모든 NumberLiteral을 vmStructuralNumbers로
+ *  표시한다 — 인터프리터 자신의 +1/-1/패딩 같은 구현 디테일 상수는 사용자 데이터가 아닌데,
+ *  수십 개 opcode 핸들러에 반복 등장해서 EncryptNumbers/NumbersToExpressions/ConstantArray가
+ *  건드리면 곱셈적으로 부풀어 오른다. */
+function markRuntimeNumbersAsStructural(body: { statements: Statement[] }): void {
+    transformExpressions({ body } as Program, (expr) => {
+        if (expr.type === "NumberLiteral") vmStructuralNumbers.add(expr)
+        return undefined
+    })
+}
+
+export interface VmifyOptions {
+    /**
+     * VM 밖에서 값을 그대로 참조해야 하는 전역 이름 목록(GETGLOBAL/SETGLOBAL 대상).
+     * Luau엔 getfenv가 없어서 "임의의 전역 읽기"를 흉내낼 수 없기 때문에,
+     * 여기 나열된 이름들만 브리지 테이블에 실제 값으로 미리 채워 넣는다.
+     * 나열되지 않은 전역을 참조하면 컴파일은 되지만 런타임에 nil이 나온다 — 실사용 전
+     * 반드시 프로그램에서 실제로 쓰는 전역 이름을 전부 이 목록에 채워야 함(TODO: 컴파일러가
+     * ScopeAnalysis.globalsByName을 이용해 자동으로 목록을 뽑아주도록 개선 가능).
+     */
+    builtinGlobals?: readonly string[]
+    /**
+     * opcode 번호 셔플 + 전역/필드 이름 무작위화에 쓸 난수 생성기. 지정하지 않으면
+     * Math.random. 재현 가능한 빌드가 필요하면(테스트 등) 시드 고정 PRNG를 넘길 것.
+     */
+    random?: () => number
+}
+
+/**
+ * program 전체를 바이트코드로 컴파일하고, program.body를 다음 구조로 치환한다:
+ *
+ *   local <globals> = { print = print, game = game, ... }
+ *   <런타임 인터프리터 함수 정의 — 식별자/opcode 번호는 매 빌드 무작위>
+ *   local <protoRoot> = { ...직렬화된 바이트코드... }
+ *   return <execute>(<protoRoot>, {}, ...)
+ *
+ * opcode 번호(opcodes.ts:createOpcodeMap)와 전역/필드 이름(names.ts:generateVmNames)을
+ * 매 빌드 새로 뽑기 때문에, 컴파일된 청크와 런타임 인터프리터가 산출물마다 구조적으로
+ * 달라진다 — "이 VM은 opcode 6이 GETGLOBAL이다" 같은 지식이 다음 빌드에는 안 통함.
+ *
+ * 주의: 이 패스는 pipeline.ts상 반드시 "가장 먼저"(StripTypes 다음) 실행돼야 한다 —
+ * 컴파일이 끝나면 원본 statement/expression 노드 대부분이 바이트코드 숫자로 바뀌어
+ * 사라지므로, 이후 패스(RenameVariables, EncryptStrings 등)가 손댈 원본 AST가 없다.
+ */
+export function runVmify(program: Program, options: VmifyOptions): void {
+    const globalNames = options.builtinGlobals ?? DEFAULT_BUILTIN_GLOBALS
+    const random = options.random ?? Math.random
+
+    const opcodeMap = createOpcodeMap(random)
+    const names = generateVmNames(random)
+
+    const compiler = new VmCompiler(program, globalNames, opcodeMap)
+    const topProto = compiler.compile()
+
+    const globalsTable = table(
+        globalNames.map((name) => namedField(name, identifier(name))),
+    )
+
+    const runtimeSource = buildVmRuntimeSource(names, opcodeMap)
+    const runtimeProgram = luauparser.parse(runtimeSource)
+    const runtimeStatements: Statement[] = runtimeProgram.body.statements
+    markRuntimeNumbersAsStructural(runtimeProgram.body)
+
+    const protoLiteral = serializeProto(topProto, names)
+
+    const newBody: Statement[] = [
+        localStatement(names.globals, globalsTable),
+        ...runtimeStatements,
+        localStatement(names.protoRoot, protoLiteral),
+        returnStatement([call(identifier(names.execute), [identifier(names.protoRoot), table([]), vararg()])]),
+    ]
+
+    program.body.statements = newBody
+}

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/nodeFactory.ts

@@ -5,7 +5,7 @@ import type {
     LocalStatement, LocalFunctionStatement, FunctionBody, FunctionParameter,
     TypedIdentifier, Block, Statement, AssignmentStatement, NumericForStatement,
     ReturnStatement, DoStatement, IfStatement, IfClause, VarargExpression,
-    FunctionExpression,
+    FunctionExpression, BooleanLiteral, NilLiteral, WhileStatement,
 } from "luau-parser"
 
 /** 합성 노드는 실제 소스 위치가 없으므로 0으로 채움(printer는 구조만 봄). */
@@ -27,6 +27,25 @@ export function numberLiteral(value: number): NumberLiteral {
     return { type: "NumberLiteral", value, raw: String(value), line: POS, column: POS }
 }
 
+/**
+ * Vmify가 인스트럭션 op/a/b/c, numParams, maxRegs 같은 "VM 구조 메타데이터"용으로
+ * 찍어내는 숫자는 이 표시를 달아 만든다. 이런 값은 원본 소스에 쓰인 상수가 아니라
+ * Vmify 자신이 만들어낸, 개수가 코드 크기에 비례해 수천~수만 개까지 불어날 수 있는
+ * 내부 값이고, 로직 자체는 이미 Vmify 컴파일로 구조적으로 숨겨져 있다.
+ * NumbersToExpressions/EncryptNumbers 같은 뒤쪽 패스가 이 값들까지 하나하나
+ * for-loop/재귀 함수/디코더 호출로 부풀리면, 두 패스가 곱셈적으로 상호작용해
+ * 출력이 기하급수적으로 커진다 (실측: 4400줄 샘플에서 Vmify+NumbersToExpressions만
+ * 켜면 0.9MB가 아니라 7.7MB가 나옴). 그래서 이 표시가 붙은 노드는 뒤쪽 숫자
+ * 난독화 패스들이 건드리지 않고 그대로 둔다.
+ */
+export const vmStructuralNumbers = new WeakSet<NumberLiteral>()
+
+export function vmNumberLiteral(value: number): NumberLiteral {
+    const node = numberLiteral(value)
+    vmStructuralNumbers.add(node)
+    return node
+}
+
 export function binary(
     operator: BinaryExpression["operator"],
     left: Expression,
@@ -67,6 +86,18 @@ export function positionalField(value: Expression): TableField {
     return { type: "TableFieldPositional", value }
 }
 
+export function namedField(name: string, value: Expression): TableField {
+    return { type: "TableFieldNamed", name: identifier(name), value }
+}
+
+export function booleanLiteral(value: boolean): BooleanLiteral {
+    return { type: "BooleanLiteral", value, line: POS, column: POS }
+}
+
+export function nilLiteral(): NilLiteral {
+    return { type: "NilLiteral", line: POS, column: POS }
+}
+
 export function localStatement(name: string, init: Expression): LocalStatement {
     return {
         type: "LocalStatement",
@@ -138,6 +169,10 @@ export function ifStatement(clauses: IfClause[], alternate?: Block): IfStatement
     return { type: "IfStatement", clauses, alternate, line: POS, column: POS }
 }
 
+export function whileStatement(condition: Expression, body: Block): WhileStatement {
+    return { type: "WhileStatement", condition, body, line: POS, column: POS }
+}
+
 export function vararg(): VarargExpression {
     return { type: "VarargExpression", line: POS, column: POS }
 }

package/src/passes/vmify/chunk.ts

@@ -0,0 +1,54 @@
+import type { Instr } from "./opcodes"
+
+/** 상수 풀에 들어갈 수 있는 값. */
+export type ConstValue = string | number | boolean | null
+
+/**
+ * upvalue 하나가 부모 함수 기준으로 어디서 오는지.
+ * - "local": 부모 함수의 레지스터(박스)를 그대로 캡처
+ * - "upval": 부모 함수 자신의 upvalue를 한 단계 더 전달(중첩 클로저)
+ */
+export interface UpvalDesc {
+    kind: "local" | "upval"
+    index: number
+}
+
+/** 함수 하나(최상위 청크 포함)에 대응하는 컴파일 결과. Lua의 Proto와 동일한 역할. */
+export interface Proto {
+    id: number
+    numParams: number
+    hasVarargs: boolean
+    maxRegs: number
+    code: Instr[]
+    consts: ConstValue[]
+    /** consts 배열과 별도로 유지하는 value -> index 조회용 인덱스 (interning을 O(1)로). */
+    constIndex: Map<ConstValue, number>
+    /** 이 함수가 캡처하는 upvalue들이 "부모" 기준 어디서 오는지. */
+    upvalDescs: UpvalDesc[]
+    /** 중첩 함수 표현식들. CLOSURE 명령의 B는 이 배열의 인덱스. */
+    protos: Proto[]
+}
+
+export function createProto(id: number): Proto {
+    return {
+        id,
+        numParams: 0,
+        hasVarargs: false,
+        maxRegs: 0,
+        code: [],
+        consts: [],
+        constIndex: new Map(),
+        upvalDescs: [],
+        protos: [],
+    }
+}
+
+/** 상수 풀에 값 추가(중복 제거) 후 인덱스 반환. */
+export function internConst(proto: Proto, value: ConstValue): number {
+    const existing = proto.constIndex.get(value)
+    if (existing !== undefined) return existing
+    proto.consts.push(value)
+    const idx = proto.consts.length - 1
+    proto.constIndex.set(value, idx)
+    return idx
+}