luau-obfuscator 1.0.1 → 1.0.2

package/package.json

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

package/scripts/test.js

@@ -1,16 +1,24 @@
 import fs from 'fs'
 import { obfuscate } from '../dist/index.js'
+import path from 'path'
 
-const exampleScript = fs.readFileSync('./scripts/example.luau', 'utf-8')
-const obfuscated = obfuscate(exampleScript, {
-    Minify: {active: false},
-    
-})
-fs.writeFileSync('./generated/final.luau', obfuscated)
+const smokedir = path.join(process.cwd(), "smoketest")
 
-const smoketest = fs.readFileSync('./scripts/smoketest.luau', 'utf-8')
-const smoketestobfuscated = obfuscate(smoketest, {
-    Minify: {active: false},
-    
-})
-fs.writeFileSync('./generated/smoketest.luau', smoketestobfuscated)
+const GENERATE_DIR = path.join(process.cwd(), "generated")
+
+fs.rmSync(GENERATE_DIR, { recursive: true, force: true });
+fs.mkdirSync(GENERATE_DIR, { recursive: true });
+
+
+for(const filename of fs.readdirSync(smokedir)) {
+    const content = fs.readFileSync(path.join(smokedir, filename), 'utf-8')
+    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}`)
+}

package/src/passes/ConstantArray.ts

@@ -1,7 +1,8 @@
 import type { Program, TableField } from "luau-parser"
 import { transformExpressions } from "./walk"
 import {
-    stringLiteral, numberLiteral, index as indexExpr, identifier, table, localStatement,
+    stringLiteral, numberLiteral, vmNumberLiteral, index as indexExpr, identifier, table, localStatement,
+    vmStructuralNumbers,
 } from "./nodeFactory"
 
 export interface ConstantArrayOptions {
@@ -41,7 +42,7 @@ export function runConstantArray(program: Program, options: ConstantArrayOptions
                 seen.add(k)
                 order.push({ kind: "string", value: expr.value })
             }
-        } else if (expr.type === "NumberLiteral") {
+        } else if (expr.type === "NumberLiteral" && !vmStructuralNumbers.has(expr)) {
             const k = keyOf("number", expr.value)
             if (!seen.has(k)) {
                 seen.add(k)
@@ -70,11 +71,11 @@ export function runConstantArray(program: Program, options: ConstantArrayOptions
     transformExpressions(program, (expr) => {
         if (expr.type === "StringLiteral") {
             const idx = indexOf.get(keyOf("string", expr.value))!
-            return indexExpr(identifier(arrayName), numberLiteral(idx))
+            return indexExpr(identifier(arrayName), vmNumberLiteral(idx))
         }
-        if (expr.type === "NumberLiteral") {
+        if (expr.type === "NumberLiteral" && !vmStructuralNumbers.has(expr)) {
             const idx = indexOf.get(keyOf("number", expr.value))!
-            return indexExpr(identifier(arrayName), numberLiteral(idx))
+            return indexExpr(identifier(arrayName), vmNumberLiteral(idx))
         }
         return undefined
     })

package/src/passes/EncryptNumbers.ts

@@ -3,7 +3,7 @@ import { transformExpressions } from "./walk"
 import {
     identifier, numberLiteral, call, member,
     localFunctionStatement, functionParam, functionBody, block, returnStatement,
-    localStatement, binary,
+    localStatement, binary, vmStructuralNumbers,
 } from "./nodeFactory"
 
 export interface EncryptNumbersOptions {}
@@ -96,6 +96,7 @@ export function runEncryptNumbers(program: Program, _options: EncryptNumbersOpti
 
     transformExpressions(program, (expr: Expression) => {
         if (expr.type !== "NumberLiteral") return
+        if (vmStructuralNumbers.has(expr)) return
         if (!isEncryptable(expr.value)) return
 
         used = true

package/src/passes/EncryptStrings.ts

@@ -1,7 +1,7 @@
 import type { Program, Expression } from "luau-parser"
 import { transformExpressions } from "./walk"
 import {
-    identifier, numberLiteral, call, member, index, table, positionalField,
+    identifier, vmNumberLiteral, call, member, index, table, positionalField,
     localFunctionStatement, functionParam, functionBody, block, localStatement,
     assignmentStatement, numericForStatement, returnStatement, unary, binary,
 } from "./nodeFactory"
@@ -57,15 +57,15 @@ function obfuscatedNumber(value: number): Expression {
     const variant = randomInt(0, 2)
     if (variant === 0) {
         const a = randomInt(0, value)
-        return binary("+", numberLiteral(a), numberLiteral(value - a))
+        return binary("+", vmNumberLiteral(a), vmNumberLiteral(value - a))
     }
     if (variant === 1) {
         const a = randomInt(0, 0xFFFFFF)
-        return binary("-", numberLiteral(value + a), numberLiteral(a))
+        return binary("-", vmNumberLiteral(value + a), vmNumberLiteral(a))
     }
     const a = randomInt(0, 0xFFFFFF)
     const b = (value ^ a) >>> 0
-    return call(member(identifier("bit32"), "bxor"), [numberLiteral(a), numberLiteral(b)])
+    return call(member(identifier("bit32"), "bxor"), [vmNumberLiteral(a), vmNumberLiteral(b)])
 }
 
 /**
@@ -92,17 +92,17 @@ function buildDecoderStatement(name: string) {
 
     const idxExpr = binary(
         "+",
-        binary("%", binary("-", identifier(iVar), numberLiteral(1)), identifier(nKeysVar)),
-        numberLiteral(1),
+        binary("%", binary("-", identifier(iVar), vmNumberLiteral(1)), identifier(nKeysVar)),
+        vmNumberLiteral(1),
     )
     const keyByte = index(identifier(keysParam), idxExpr)
     const mixed = call(member(identifier("bit32"), "band"), [
-        call(member(identifier("bit32"), "lrotate"), [keyByte, binary("%", identifier(iVar), numberLiteral(8))]),
-        numberLiteral(0xFF),
+        call(member(identifier("bit32"), "lrotate"), [keyByte, binary("%", identifier(iVar), vmNumberLiteral(8))]),
+        vmNumberLiteral(0xFF),
     ])
     const posByte = call(member(identifier("bit32"), "band"), [
         binary("*", identifier(iVar), identifier(multParam)),
-        numberLiteral(0xFF),
+        vmNumberLiteral(0xFF),
     ])
     const keystream = call(member(identifier("bit32"), "bxor"), [mixed, posByte])
     const finalByte = call(member(identifier("bit32"), "bxor"), [
@@ -115,7 +115,7 @@ function buildDecoderStatement(name: string) {
         localStatement(outVar, table([])),
         numericForStatement(
             iVar,
-            numberLiteral(1),
+            vmNumberLiteral(1),
             unary("#", identifier(dataParam)),
             block([
                 assignmentStatement(
@@ -150,7 +150,7 @@ export function runEncryptStrings(program: Program, _options: EncryptStringsOpti
         const plainBytes = toUtf8Bytes(expr.value)
         const cipherBytes = plainBytes.map((b, idx) => b ^ keystreamByte(keys, mult, idx + 1))
 
-        const dataTable = table(cipherBytes.map((b) => positionalField(numberLiteral(b))))
+        const dataTable = table(cipherBytes.map((b) => positionalField(vmNumberLiteral(b))))
         const keysTable = table(keys.map((k) => positionalField(obfuscatedNumber(k))))
         const multExpr = obfuscatedNumber(mult)
 

package/src/passes/NumbersToExpressions.ts

@@ -4,7 +4,7 @@ import {
     numberLiteral, binary, paren, identifier, call, index, table, positionalField,
     localStatement, localFunctionStatement, functionParam, functionBody, functionExpression,
     block, assignmentStatement, numericForStatement, whileStatement, ifStatement, ifClause,
-    returnStatement, unary,
+    returnStatement, unary, vmStructuralNumbers,
 } from "./nodeFactory"
 
 export interface NumbersToExpressionsOptions {
@@ -252,6 +252,9 @@ export function runNumbersToExpressions(program: Program, options: NumbersToExpr
 
     transformExpressions(program, (expr) => {
         if (expr.type !== "NumberLiteral") return
+        // Vmify가 만든 op/a/b/c 같은 내부 메타데이터는 건드리지 않는다
+        // (개수가 코드 크기에 비례해 폭증하고, 로직은 이미 Vmify가 구조적으로 숨긴 값).
+        if (vmStructuralNumbers.has(expr)) return
 
         // 루프/재귀 조립은 정수 배분(합이 정확히 일치)에 의존하므로 정수에만 적용하고,
         // 실수/범위를 벗어난 값은 기존 산술식 위장으로 처리한다.

package/src/passes/StringsToExpressions.ts

@@ -53,13 +53,24 @@ function stringCharCall(bytes: number[]): Expression {
     return call(member(identifier("string"), "char"), bytes.map(numberLiteral))
 }
 
-/** 기존 방식: 청크를 소스에 보이는 순서 그대로 ".."로 이어붙임. */
+/**
+ * 청크를 소스에 보이는 순서 그대로 ".."로 이어붙인다.
+ *
+ * 예전에는 왼쪽으로만 쌓는 선형 체인(`(((a..b)..c)..d)...`)이었는데, 이러면
+ * depth == chunks.length라서 큰 문자열 리터럴(수백만 바이트) 하나만 있어도
+ * 표현식 중첩 깊이가 수백만까지 치솟는다. 이 트랜스파일러 자체의 스택뿐 아니라
+ * 실제 Luau/Lua 컴파일러도 문법 중첩 레벨에 제한(대략 200선)이 있어서, 그 한계를
+ * 넘는 순간 우리 쪽이 아니라 Roblox/Luau 파서에서 컴파일이 실패한다.
+ * 그래서 균형 이진 트리로 묶어 depth를 O(log n)으로 낮춘다 — 결합 순서만 바뀔 뿐
+ * ".."는 결합법칙이 성립하므로 결과 문자열은 동일하다.
+ */
 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]))
+    function build(lo: number, hi: number): Expression {
+        if (hi - lo === 1) return stringCharCall(chunks[lo])
+        const mid = lo + Math.floor((hi - lo) / 2)
+        return binary("..", build(lo, mid), build(mid, hi))
     }
-    return expr
+    return build(0, chunks.length)
 }
 
 /** [0, n)의 무작위 순열 (Fisher-Yates) */
@@ -199,6 +210,14 @@ function pickControlFlowStrategy(): ControlFlowStrategy {
     return Math.random() < 0.5 ? "forLoop" : "recursive"
 }
 
+// 바이트 단위로 쪼개면 청크 하나당 AST 노드(CallExpression+MemberExpression+인자들)가
+// 하나씩 생긴다. 수 MB짜리 문자열 리터럴(예: 임베드된 데이터 블롭)을 5~10바이트 청크로
+// 쪼개면 수십~수백만 개 노드가 나와서 이 트랜스파일러 자체가 OOM으로 죽는다.
+// 그 크기의 문자열은 바이트 단위로 흩뿌려봐야 어차피 노출 표면이 커서 난독화 효과도
+// 떨어지므로, 청크 개수가 이 상한을 넘으면 통째로 하나의 string.char(...)/원본 리터럴로
+// 두고 건드리지 않는다 (EncryptStrings 등 다른 패스가 필요하면 별도로 암호화하면 됨).
+const MAX_CHUNKS_PER_STRING = 20000
+
 export function runStringsToExpressions(program: Program, options: StringsToExpressionsOptions): void {
     const controlFlowProbability = options.controlFlowProbability ?? CONTROL_FLOW_PROBABILITY_DEFAULT
 
@@ -207,6 +226,11 @@ export function runStringsToExpressions(program: Program, options: StringsToExpr
         if (expr.value.length === 0) return
 
         const bytes = toUtf8Bytes(expr.value)
+
+        // 너무 큰 문자열은 청크 단위 폭발을 피하기 위해 손대지 않는다.
+        const estimatedChunks = Math.ceil(bytes.length / Math.max(1, options.min))
+        if (estimatedChunks > MAX_CHUNKS_PER_STRING) return
+
         const chunks = splitByteChunks(bytes, options.min, options.max)
 
         // 청크가 하나뿐이면 순서를 흩뜨려도 얻는 게 없으니 그냥 원래 방식대로.

package/src/passes/Vmify.ts

@@ -1,4 +1,4 @@
-import type { Program, Statement } from "luau-parser"
+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"
@@ -7,7 +7,20 @@ 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 {
     /**
@@ -59,6 +72,7 @@ export function runVmify(program: Program, options: VmifyOptions): void {
     const runtimeSource = buildVmRuntimeSource(names, opcodeMap)
     const runtimeProgram = luauparser.parse(runtimeSource)
     const runtimeStatements: Statement[] = runtimeProgram.body.statements
+    markRuntimeNumbersAsStructural(runtimeProgram.body)
 
     const protoLiteral = serializeProto(topProto, names)
 
@@ -70,4 +84,4 @@ export function runVmify(program: Program, options: VmifyOptions): void {
     ]
 
     program.body.statements = newBody
-}
+}

package/src/passes/nodeFactory.ts

@@ -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,

package/src/passes/vmify/chunk.ts

@@ -21,6 +21,8 @@ export interface Proto {
     maxRegs: number
     code: Instr[]
     consts: ConstValue[]
+    /** consts 배열과 별도로 유지하는 value -> index 조회용 인덱스 (interning을 O(1)로). */
+    constIndex: Map<ConstValue, number>
     /** 이 함수가 캡처하는 upvalue들이 "부모" 기준 어디서 오는지. */
     upvalDescs: UpvalDesc[]
     /** 중첩 함수 표현식들. CLOSURE 명령의 B는 이 배열의 인덱스. */
@@ -35,6 +37,7 @@ export function createProto(id: number): Proto {
         maxRegs: 0,
         code: [],
         consts: [],
+        constIndex: new Map(),
         upvalDescs: [],
         protos: [],
     }
@@ -42,9 +45,10 @@ export function createProto(id: number): Proto {
 
 /** 상수 풀에 값 추가(중복 제거) 후 인덱스 반환. */
 export function internConst(proto: Proto, value: ConstValue): number {
-    for (let i = 0; i < proto.consts.length; i++) {
-        if (proto.consts[i] === value) return i
-    }
+    const existing = proto.constIndex.get(value)
+    if (existing !== undefined) return existing
     proto.consts.push(value)
-    return proto.consts.length - 1
-}
+    const idx = proto.consts.length - 1
+    proto.constIndex.set(value, idx)
+    return idx
+}

package/src/passes/vmify/names.ts

@@ -31,12 +31,7 @@ export interface VmNames {
     varargs: string
     nVarargs: string
     multiTop: string
-    // Instr 테이블 필드 (serialize.ts가 찍고 runtime.ts가 읽음)
-    op: string
-    a: string
-    b: string
-    c: string
-    // Proto 테이블 필드
+    // Proto 테이블 필드 (인스트럭션 자체는 이제 [op,a,b,c] 위치 기반 테이블이라 이름이 필요 없음)
     numParams: string
     hasVarargs: string
     maxRegs: string
@@ -71,8 +66,7 @@ export function generateVmNames(random: () => number = Math.random): VmNames {
         frame: id(),
         R: id(), K: id(), code: id(), protos: id(), upvals: id(), varargs: id(),
         nVarargs: id(), multiTop: id(),
-        op: id(), a: id(), b: id(), c: id(),
         numParams: id(), hasVarargs: id(), maxRegs: id(), consts: id(), upvalDescs: id(),
         kind: id(), index: id(),
     }
-}
+}