luau-obfuscator 1.0.0 → 1.0.2

package/src/passes/EncryptStrings.ts

@@ -1,83 +1,163 @@
-import type { Program, Expression } from "luau-parser"
-import { transformExpressions } from "./walk"
-import {
-    identifier, numberLiteral, call, member, index, table, positionalField,
-    localFunctionStatement, functionParam, functionBody, block, localStatement,
-    assignmentStatement, numericForStatement, returnStatement, unary,
-} from "./nodeFactory"
-
-export interface EncryptStringsOptions {}
-
-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, "")
-}
-
-/** Luau 소스는 UTF-8 바이트 스트림이므로 charCodeAt이 아니라 실제 UTF-8 바이트로 변환. */
-function toUtf8Bytes(value: string): number[] {
-    return Array.from(new TextEncoder().encode(value))
-}
-
-/**
- * 런타임 디코더를 조립:
- *   local function <name>(data, key)
- *       local out = {}
- *       for i = 1, #data do
- *           out[i] = string.char(bit32.bxor(data[i], key))
- *       end
- *       return table.concat(out)
- *   end
- */
-function buildDecoderStatement(name: string) {
-    const dataParam = randomName()
-    const keyParam = randomName()
-    const outVar = randomName()
-    const iVar = randomName()
-
-    const body = block([
-        localStatement(outVar, table([])),
-        numericForStatement(
-            iVar,
-            numberLiteral(1),
-            unary("#", identifier(dataParam)),
-            block([
-                assignmentStatement(
-                    [index(identifier(outVar), identifier(iVar))],
-                    [call(member(identifier("string"), "char"), [
-                        call(member(identifier("bit32"), "bxor"), [
-                            index(identifier(dataParam), identifier(iVar)),
-                            identifier(keyParam),
-                        ]),
-                    ])],
-                ),
-            ]),
-        ),
-        returnStatement([call(member(identifier("table"), "concat"), [identifier(outVar)])]),
-    ])
-
-    return localFunctionStatement(name, functionBody([functionParam(dataParam), functionParam(keyParam)], body))
-}
-
-export function runEncryptStrings(program: Program, _options: EncryptStringsOptions): void {
-    const decoderName = randomName()
-    let used = false
-
-    transformExpressions(program, (expr: Expression) => {
-        if (expr.type !== "StringLiteral") return
-        if (expr.value.length === 0) return
-
-        used = true
-        const key = randomInt(1, 255)
-        const bytes = toUtf8Bytes(expr.value).map((b) => b ^ key)
-        const dataTable = table(bytes.map((b) => positionalField(numberLiteral(b))))
-
-        return call(identifier(decoderName), [dataTable, numberLiteral(key)])
-    })
-
-    if (!used) return
-
-    program.body.statements.unshift(buildDecoderStatement(decoderName))
+import type { Program, Expression } from "luau-parser"
+import { transformExpressions } from "./walk"
+import {
+    identifier, vmNumberLiteral, call, member, index, table, positionalField,
+    localFunctionStatement, functionParam, functionBody, block, localStatement,
+    assignmentStatement, numericForStatement, returnStatement, unary, binary,
+} from "./nodeFactory"
+
+export interface EncryptStringsOptions {}
+
+const MIN_KEY_LEN = 4
+const MAX_KEY_LEN = 12
+
+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, "")
+}
+
+/** Luau 소스는 UTF-8 바이트 스트림이므로 charCodeAt이 아니라 실제 UTF-8 바이트로 변환. */
+function toUtf8Bytes(value: string): number[] {
+    return Array.from(new TextEncoder().encode(value))
+}
+
+/** bit32.lrotate(x, disp)와 동일한 32비트 좌회전. disp는 0~31 범위로 정규화. */
+function lrotate32(x: number, disp: number): number {
+    const d = ((disp % 32) + 32) % 32
+    const xu = x >>> 0
+    if (d === 0) return xu
+    return ((xu << d) | (xu >>> (32 - d))) >>> 0
+}
+
+/**
+ * i번째(1-indexed) 바이트에 적용할 키스트림 바이트.
+ * - 롤링 키 배열에서 위치별로 다른 키 바이트를 뽑고
+ * - 좌회전으로 비트를 섞은 뒤
+ * - 위치(i)에 종속적인 바이트와 다시 섞는다.
+ * 같은 평문 바이트가 반복돼도 위치가 다르면 암호문 바이트가 달라져
+ * (반복 키 XOR과 달리) 단순 빈도분석/Kasiski류 공격에 내성을 갖는다.
+ */
+function keystreamByte(keys: number[], mult: number, i: number): number {
+    const nKeys = keys.length
+    const keyByte = keys[(i - 1) % nKeys]
+    const rotated = lrotate32(keyByte, i % 8) & 0xFF
+    const posByte = (i * mult) & 0xFF
+    return (rotated ^ posByte) & 0xFF
+}
+
+/**
+ * 숫자 리터럴을 곧이곧대로 노출하지 않고, 산술식/bit32.bxor 호출로 위장한다.
+ * "decoder(literal, literal)" 패턴을 그대로 상수 접기(constant fold)하는
+ * 단순 정적 분석 스크립트를 무력화하기 위함.
+ */
+function obfuscatedNumber(value: number): Expression {
+    const variant = randomInt(0, 2)
+    if (variant === 0) {
+        const a = randomInt(0, value)
+        return binary("+", vmNumberLiteral(a), vmNumberLiteral(value - a))
+    }
+    if (variant === 1) {
+        const a = randomInt(0, 0xFFFFFF)
+        return binary("-", vmNumberLiteral(value + a), vmNumberLiteral(a))
+    }
+    const a = randomInt(0, 0xFFFFFF)
+    const b = (value ^ a) >>> 0
+    return call(member(identifier("bit32"), "bxor"), [vmNumberLiteral(a), vmNumberLiteral(b)])
+}
+
+/**
+ * 런타임 디코더를 조립:
+ *   local function <name>(data, keys, mult)
+ *       local nKeys = #keys
+ *       local out = {}
+ *       for i = 1, #data do
+ *           local keyByte = keys[((i - 1) % nKeys) + 1]
+ *           local mixed = bit32.band(bit32.lrotate(keyByte, i % 8), 0xFF)
+ *           local posByte = bit32.band(i * mult, 0xFF)
+ *           out[i] = string.char(bit32.bxor(data[i], bit32.bxor(mixed, posByte)))
+ *       end
+ *       return table.concat(out)
+ *   end
+ */
+function buildDecoderStatement(name: string) {
+    const dataParam = randomName()
+    const keysParam = randomName()
+    const multParam = randomName()
+    const outVar = randomName()
+    const iVar = randomName()
+    const nKeysVar = randomName()
+
+    const idxExpr = binary(
+        "+",
+        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), vmNumberLiteral(8))]),
+        vmNumberLiteral(0xFF),
+    ])
+    const posByte = call(member(identifier("bit32"), "band"), [
+        binary("*", identifier(iVar), identifier(multParam)),
+        vmNumberLiteral(0xFF),
+    ])
+    const keystream = call(member(identifier("bit32"), "bxor"), [mixed, posByte])
+    const finalByte = call(member(identifier("bit32"), "bxor"), [
+        index(identifier(dataParam), identifier(iVar)),
+        keystream,
+    ])
+
+    const body = block([
+        localStatement(nKeysVar, unary("#", identifier(keysParam))),
+        localStatement(outVar, table([])),
+        numericForStatement(
+            iVar,
+            vmNumberLiteral(1),
+            unary("#", identifier(dataParam)),
+            block([
+                assignmentStatement(
+                    [index(identifier(outVar), identifier(iVar))],
+                    [call(member(identifier("string"), "char"), [finalByte])],
+                ),
+            ]),
+        ),
+        returnStatement([call(member(identifier("table"), "concat"), [identifier(outVar)])]),
+    ])
+
+    return localFunctionStatement(
+        name,
+        functionBody([functionParam(dataParam), functionParam(keysParam), functionParam(multParam)], body),
+    )
+}
+
+export function runEncryptStrings(program: Program, _options: EncryptStringsOptions): void {
+    const decoderName = randomName()
+    let used = false
+
+    transformExpressions(program, (expr: Expression) => {
+        if (expr.type !== "StringLiteral") return
+        if (expr.value.length === 0) return
+
+        used = true
+
+        const keyLen = randomInt(MIN_KEY_LEN, MAX_KEY_LEN)
+        const keys = Array.from({ length: keyLen }, () => randomInt(1, 255))
+        const mult = randomInt(1, 255)
+
+        const plainBytes = toUtf8Bytes(expr.value)
+        const cipherBytes = plainBytes.map((b, idx) => b ^ keystreamByte(keys, mult, idx + 1))
+
+        const dataTable = table(cipherBytes.map((b) => positionalField(vmNumberLiteral(b))))
+        const keysTable = table(keys.map((k) => positionalField(obfuscatedNumber(k))))
+        const multExpr = obfuscatedNumber(mult)
+
+        return call(identifier(decoderName), [dataTable, keysTable, multExpr])
+    })
+
+    if (!used) return
+
+    program.body.statements.unshift(buildDecoderStatement(decoderName))
 }

package/src/passes/GlobalMapping.ts

@@ -1,194 +1,194 @@
-import type {
-    Program, Block, Statement, Expression, Identifier, ScopeAnalysis,
-} from "luau-parser"
-import { analyzeScopes, isGlobal, getBinding } from "luau-parser"
-import {
-    identifier, numberLiteral, stringLiteral, index as indexExpr,
-    table, computedField, localStatement,
-} from "./nodeFactory"
-
-export interface GlobalMappingOptions {
-    /** 전역들을 담아둘 최상단 local 테이블 변수 이름. RenameVariables가 이후에
-     *  다시 실행되면 이 이름도 다른 이름으로 한 번 더 바뀜. */
-    tableName: string
-}
-
-type Key = number | string
-
-function randomInt(min: number, max: number): number {
-    return Math.floor(Math.random() * (max - min + 1)) + min
-}
-
-function randomKey(): Key {
-    // 숫자 키/문자열 키를 섞어서 접근 패턴을 예측하기 어렵게 함
-    if (Math.random() < 0.5) return randomInt(1, 50)
-    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    const len = randomInt(2, 4)
-    let s = ""
-    for (let i = 0; i < len; i++) s += chars[randomInt(0, chars.length - 1)]
-    return s
-}
-
-function randomPath(): Key[] {
-    const depth = randomInt(2, 4)
-    const path: Key[] = []
-    for (let i = 0; i < depth; i++) path.push(randomKey())
-    return path
-}
-
-type TreeLeaf = { leaf: string }
-type TreeNode = Map<Key, TreeNode | TreeLeaf>
-
-function isLeaf(v: TreeNode | TreeLeaf): v is TreeLeaf {
-    return !(v instanceof Map)
-}
-
-/** path를 따라 내려가며 중간 노드를 만들고 마지막 키에 리프를 심음.
- *  경로 충돌(이미 다른 값이 있음)이 나면 false를 반환 — 호출 쪽에서 다른 경로로 재시도. */
-function insertPath(root: TreeNode, path: Key[], globalName: string): boolean {
-    let node = root
-    for (let i = 0; i < path.length - 1; i++) {
-        const key = path[i]
-        let next = node.get(key)
-        if (next === undefined) {
-            next = new Map()
-            node.set(key, next)
-        } else if (isLeaf(next)) {
-            return false
-        }
-        node = next as TreeNode
-    }
-    const lastKey = path[path.length - 1]
-    if (node.has(lastKey)) return false
-    node.set(lastKey, { leaf: globalName })
-    return true
-}
-
-function assignPaths(globalNames: string[]): { root: TreeNode; paths: Map<string, Key[]> } {
-    const root: TreeNode = new Map()
-    const paths = new Map<string, Key[]>()
-
-    for (const name of globalNames) {
-        let path: Key[] = []
-        let attempts = 0
-        let ok = false
-        while (!ok && attempts < 200) {
-            path = randomPath()
-            ok = insertPath(root, path, name)
-            attempts++
-        }
-        paths.set(name, path)
-    }
-
-    return { root, paths }
-}
-
-function keyExpression(key: Key): Expression {
-    return typeof key === "number" ? numberLiteral(key) : stringLiteral(key)
-}
-
-function buildTreeTableExpr(node: TreeNode): Expression {
-    const fields = [...node.entries()].map(([key, value]) =>
-        computedField(
-            keyExpression(key),
-            isLeaf(value) ? identifier(value.leaf) : buildTreeTableExpr(value),
-        ),
-    )
-    return table(fields)
-}
-
-function buildIndexChain(tableName: string, path: Key[]): Expression {
-    let expr: Expression = identifier(tableName)
-    for (const key of path) {
-        expr = indexExpr(expr, keyExpression(key))
-    }
-    return expr
-}
-
-/** node(원래 Identifier)를 같은 객체 참조를 유지한 채로 IndexExpression으로
- *  제자리 변형함 — 이 객체를 들고 있는 부모 필드(BinaryExpression.left 등)는
- *  어디 있는지 몰라도 되고, 그냥 이 객체가 바뀌면 자동으로 반영됨. */
-function morphIntoIndexChain(node: Identifier, tableName: string, path: Key[]): void {
-    const built = buildIndexChain(tableName, path) as unknown as Record<string, unknown>
-    const target = node as unknown as Record<string, unknown>
-    for (const k of Object.keys(target)) delete target[k]
-    Object.assign(target, built)
-}
-
-/**
- * `function Foo() end` / `function T.m() end` 형태의 target.base는 리터럴
- * 이름만 허용되는 문법 자리라 인덱스 체인으로 바꿀 수 없음. 이런 자리에 쓰인
- * 전역 이름은 매핑 대상에서 제외한다.
- * (statement 트리를 따라 내려가며 찾음 — 익명함수 표현식 내부에 중첩된
- * 전역 함수 선언 같은 극단적 케이스는 대상에서 빠질 수 있음)
- */
-function collectUnsafeFunctionDeclGlobals(program: Program, analysis: ScopeAnalysis): Set<string> {
-    const unsafe = new Set<string>()
-
-    function visitBlock(block: Block): void {
-        for (const stmt of block.statements) visitStatement(stmt)
-    }
-
-    function visitStatement(stmt: Statement): void {
-        switch (stmt.type) {
-            case "FunctionDeclarationStatement": {
-                const binding = getBinding(analysis, stmt.target.base)
-                if (binding && isGlobal(binding)) unsafe.add(binding.name)
-                visitBlock(stmt.func.body)
-                return
-            }
-            case "LocalFunctionStatement":
-                visitBlock(stmt.func.body)
-                return
-            case "DoStatement":
-                visitBlock(stmt.body)
-                return
-            case "WhileStatement":
-                visitBlock(stmt.body)
-                return
-            case "RepeatStatement":
-                visitBlock(stmt.body)
-                return
-            case "IfStatement":
-                for (const clause of stmt.clauses) visitBlock(clause.body)
-                if (stmt.alternate) visitBlock(stmt.alternate)
-                return
-            case "NumericForStatement":
-                visitBlock(stmt.body)
-                return
-            case "GenericForStatement":
-                visitBlock(stmt.body)
-                return
-            default:
-                return
-        }
-    }
-
-    visitBlock(program.body)
-    return unsafe
-}
-
-export function runGlobalMapping(program: Program, options: GlobalMappingOptions): void {
-    const analysis = analyzeScopes(program)
-    const unsafe = collectUnsafeFunctionDeclGlobals(program, analysis)
-
-    const globalBindings = [...analysis.bindings.values()].filter(
-        (b) => isGlobal(b) && b.references.length > 0 && !unsafe.has(b.name),
-    )
-    if (globalBindings.length === 0) return
-
-    const { root, paths } = assignPaths(globalBindings.map((b) => b.name))
-
-    for (const binding of globalBindings) {
-        const path = paths.get(binding.name)!
-        // declarationNode(대입으로 정의된 경우)는 이미 references에 포함된
-        // 같은 객체라 references만 돌면 전부 커버됨
-        for (const ref of binding.references) {
-            morphIntoIndexChain(ref, options.tableName, path)
-        }
-    }
-
-    program.body.statements.unshift(
-        localStatement(options.tableName, buildTreeTableExpr(root)),
-    )
+import type {
+    Program, Block, Statement, Expression, Identifier, ScopeAnalysis,
+} from "luau-parser"
+import { analyzeScopes, isGlobal, getBinding } from "luau-parser"
+import {
+    identifier, numberLiteral, stringLiteral, index as indexExpr,
+    table, computedField, localStatement,
+} from "./nodeFactory"
+
+export interface GlobalMappingOptions {
+    /** 전역들을 담아둘 최상단 local 테이블 변수 이름. RenameVariables가 이후에
+     *  다시 실행되면 이 이름도 다른 이름으로 한 번 더 바뀜. */
+    tableName: string
+}
+
+type Key = number | string
+
+function randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+function randomKey(): Key {
+    // 숫자 키/문자열 키를 섞어서 접근 패턴을 예측하기 어렵게 함
+    if (Math.random() < 0.5) return randomInt(1, 50)
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    const len = randomInt(2, 4)
+    let s = ""
+    for (let i = 0; i < len; i++) s += chars[randomInt(0, chars.length - 1)]
+    return s
+}
+
+function randomPath(): Key[] {
+    const depth = randomInt(2, 4)
+    const path: Key[] = []
+    for (let i = 0; i < depth; i++) path.push(randomKey())
+    return path
+}
+
+type TreeLeaf = { leaf: string }
+type TreeNode = Map<Key, TreeNode | TreeLeaf>
+
+function isLeaf(v: TreeNode | TreeLeaf): v is TreeLeaf {
+    return !(v instanceof Map)
+}
+
+/** path를 따라 내려가며 중간 노드를 만들고 마지막 키에 리프를 심음.
+ *  경로 충돌(이미 다른 값이 있음)이 나면 false를 반환 — 호출 쪽에서 다른 경로로 재시도. */
+function insertPath(root: TreeNode, path: Key[], globalName: string): boolean {
+    let node = root
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i]
+        let next = node.get(key)
+        if (next === undefined) {
+            next = new Map()
+            node.set(key, next)
+        } else if (isLeaf(next)) {
+            return false
+        }
+        node = next as TreeNode
+    }
+    const lastKey = path[path.length - 1]
+    if (node.has(lastKey)) return false
+    node.set(lastKey, { leaf: globalName })
+    return true
+}
+
+function assignPaths(globalNames: string[]): { root: TreeNode; paths: Map<string, Key[]> } {
+    const root: TreeNode = new Map()
+    const paths = new Map<string, Key[]>()
+
+    for (const name of globalNames) {
+        let path: Key[] = []
+        let attempts = 0
+        let ok = false
+        while (!ok && attempts < 200) {
+            path = randomPath()
+            ok = insertPath(root, path, name)
+            attempts++
+        }
+        paths.set(name, path)
+    }
+
+    return { root, paths }
+}
+
+function keyExpression(key: Key): Expression {
+    return typeof key === "number" ? numberLiteral(key) : stringLiteral(key)
+}
+
+function buildTreeTableExpr(node: TreeNode): Expression {
+    const fields = [...node.entries()].map(([key, value]) =>
+        computedField(
+            keyExpression(key),
+            isLeaf(value) ? identifier(value.leaf) : buildTreeTableExpr(value),
+        ),
+    )
+    return table(fields)
+}
+
+function buildIndexChain(tableName: string, path: Key[]): Expression {
+    let expr: Expression = identifier(tableName)
+    for (const key of path) {
+        expr = indexExpr(expr, keyExpression(key))
+    }
+    return expr
+}
+
+/** node(원래 Identifier)를 같은 객체 참조를 유지한 채로 IndexExpression으로
+ *  제자리 변형함 — 이 객체를 들고 있는 부모 필드(BinaryExpression.left 등)는
+ *  어디 있는지 몰라도 되고, 그냥 이 객체가 바뀌면 자동으로 반영됨. */
+function morphIntoIndexChain(node: Identifier, tableName: string, path: Key[]): void {
+    const built = buildIndexChain(tableName, path) as unknown as Record<string, unknown>
+    const target = node as unknown as Record<string, unknown>
+    for (const k of Object.keys(target)) delete target[k]
+    Object.assign(target, built)
+}
+
+/**
+ * `function Foo() end` / `function T.m() end` 형태의 target.base는 리터럴
+ * 이름만 허용되는 문법 자리라 인덱스 체인으로 바꿀 수 없음. 이런 자리에 쓰인
+ * 전역 이름은 매핑 대상에서 제외한다.
+ * (statement 트리를 따라 내려가며 찾음 — 익명함수 표현식 내부에 중첩된
+ * 전역 함수 선언 같은 극단적 케이스는 대상에서 빠질 수 있음)
+ */
+function collectUnsafeFunctionDeclGlobals(program: Program, analysis: ScopeAnalysis): Set<string> {
+    const unsafe = new Set<string>()
+
+    function visitBlock(block: Block): void {
+        for (const stmt of block.statements) visitStatement(stmt)
+    }
+
+    function visitStatement(stmt: Statement): void {
+        switch (stmt.type) {
+            case "FunctionDeclarationStatement": {
+                const binding = getBinding(analysis, stmt.target.base)
+                if (binding && isGlobal(binding)) unsafe.add(binding.name)
+                visitBlock(stmt.func.body)
+                return
+            }
+            case "LocalFunctionStatement":
+                visitBlock(stmt.func.body)
+                return
+            case "DoStatement":
+                visitBlock(stmt.body)
+                return
+            case "WhileStatement":
+                visitBlock(stmt.body)
+                return
+            case "RepeatStatement":
+                visitBlock(stmt.body)
+                return
+            case "IfStatement":
+                for (const clause of stmt.clauses) visitBlock(clause.body)
+                if (stmt.alternate) visitBlock(stmt.alternate)
+                return
+            case "NumericForStatement":
+                visitBlock(stmt.body)
+                return
+            case "GenericForStatement":
+                visitBlock(stmt.body)
+                return
+            default:
+                return
+        }
+    }
+
+    visitBlock(program.body)
+    return unsafe
+}
+
+export function runGlobalMapping(program: Program, options: GlobalMappingOptions): void {
+    const analysis = analyzeScopes(program)
+    const unsafe = collectUnsafeFunctionDeclGlobals(program, analysis)
+
+    const globalBindings = [...analysis.bindings.values()].filter(
+        (b) => isGlobal(b) && b.references.length > 0 && !unsafe.has(b.name),
+    )
+    if (globalBindings.length === 0) return
+
+    const { root, paths } = assignPaths(globalBindings.map((b) => b.name))
+
+    for (const binding of globalBindings) {
+        const path = paths.get(binding.name)!
+        // declarationNode(대입으로 정의된 경우)는 이미 references에 포함된
+        // 같은 객체라 references만 돌면 전부 커버됨
+        for (const ref of binding.references) {
+            morphIntoIndexChain(ref, options.tableName, path)
+        }
+    }
+
+    program.body.statements.unshift(
+        localStatement(options.tableName, buildTreeTableExpr(root)),
+    )
 }