luau-obfuscator 1.0.3 → 1.0.5

package/smoketest/tests.luau

@@ -1,115 +1,115 @@
--- ObfuscationTest.lua
---
--- 사용법:
--- 1) 이 스크립트를 원본 그대로 한 번 Roblox Studio(ServerScriptService 등)에서 실행해서
---    콘솔에 "ALL TESTS PASSED" 가 뜨는지 확인 (원본이 정상 동작하는지 베이스라인 확인).
--- 2) 이 파일을 obfuscator에 통과시켜 나온 결과물을 같은 위치에 붙여넣고 다시 실행.
--- 3) 두 경우 모두 콘솔 출력이 "[OK] ..." 목록 + 마지막 "ALL TESTS PASSED"로 동일하면
---    난독화가 값을 깨뜨리지 않았다는 뜻.
---    중간에 assert가 실패하면 어떤 케이스가 깨졌는지 에러 메시지로 바로 알 수 있음.
-
-local failCount = 0
-
-local function check(name, actual, expected)
-    if actual == expected then
-        print(string.format("[OK] %s -> %s", name, tostring(actual)))
-    else
-        failCount += 1
-        warn(string.format(
-            "[FAIL] %s -> got %s (%s), expected %s (%s)",
-            name, tostring(actual), typeof(actual), tostring(expected), typeof(expected)
-        ))
-    end
-end
-
-print("===== ObfuscationTest start =====")
-
--- 1) 문자열 리터럴: ASCII / 한글 / 이모지 / 빈 문자열 / 특수문자(따옴표, 개행, 이스케이프)
-check("ascii string", "Hello, Roblox!", "Hello, Roblox!")
-check("korean string", "안녕하세요, 로블록스", "안녕하세요, 로블록스")
-check("emoji string", "😀🔥✨", "😀🔥✨")
-check("empty string", "", "")
-check("quote/escape string", "he said \"hi\"\nnext line\ttab", "he said \"hi\"\nnext line\ttab")
-
--- 2) 문자열 연결(concat) : 리터럴끼리, 변수와 리터럴 혼합
-local name = "World"
-check("concat literal+var", "Hello, " .. name .. "! Welcome to Roblox.", "Hello, World! Welcome to Roblox.")
-
-local parts = "A" .. "B" .. "C" .. "D" .. "E" .. "F" .. "G" .. "H"
-check("long concat chain", parts, "ABCDEFGH")
-
--- 3) 숫자 리터럴: 0, 양수, 음수, 큰 정수, 소수
-check("zero", 0, 0)
-check("positive int", 42, 42)
-check("negative int", -17, -17)
-check("large int", 1234567, 1234567)
-check("negative large int", -987654, -987654)
-check("float", 3.14, 3.14)
-check("negative float", -2.5, -2.5)
-
--- 4) 산술식으로 위장됐을 법한 값들의 실제 계산 결과
-local total = 5 + 10 * 2
-check("arithmetic literal combo", total, 25)
-
-local mixed = (100 - 37) * 2 + 1
-check("mixed arithmetic", mixed, 127)
-
--- 5) 테이블 안의 숫자 리터럴들
-local nums = { 1, 2, 3, 4, 5, -6, 7, 100 }
-local sum = 0
-for i = 1, #nums do
-    sum += nums[i]
-end
-check("table of numbers sum", sum, 116)
-
--- 6) 테이블 안의 문자열 리터럴들 + 순회
-local words = { "alpha", "beta", "gamma", "delta" }
-local joined = table.concat(words, "-")
-check("table of strings joined", joined, "alpha-beta-gamma-delta")
-
--- 7) 반복문 경계값(숫자 리터럴)이 정확히 유지되는지
-local loopSum = 0
-for i = 1, 10 do
-    loopSum += i
-end
-check("for-loop 1..10 sum", loopSum, 55)
-
-local countdown = 0
-local n = 5
-while n > 0 do
-    countdown += 1
-    n -= 1
-end
-check("while-loop countdown", countdown, 5)
-
--- 8) 함수 인자/리턴 값으로 쓰인 문자열, 숫자
-local function greet(personName, times)
-    local msg = ""
-    for i = 1, times do
-        msg = msg .. personName .. ";"
-    end
-    return msg
-end
-check("function with literal args", greet("Bob", 3), "Bob;Bob;Bob;")
-
--- 9) 재귀 함수 자체가 난독화 후에도 정상 동작하는지 (사용자 스크립트 자체의 재귀, 별개 검증용)
-local function factorial(k)
-    if k <= 1 then
-        return 1
-    end
-    return k * factorial(k - 1)
-end
-check("recursive factorial(6)", factorial(6), 720)
-
--- 10) 문자열 인덱싱/길이 (UTF-8 바이트 변환이 안 깨졌는지 간접 확인)
-check("string length ascii", #"Roblox", 6)
-check("string.upper", string.upper("mixedCase"), "MIXEDCASE")
-check("string.sub", string.sub("Hello, Roblox!", 1, 5), "Hello")
-
-print("===== ObfuscationTest end =====")
-
-if failCount == 0 then
-    print("ALL TESTS PASSED")
-else
-    warn(string.format("%d TEST(S) FAILED", failCount))
+-- ObfuscationTest.lua
+--
+-- 사용법:
+-- 1) 이 스크립트를 원본 그대로 한 번 Roblox Studio(ServerScriptService 등)에서 실행해서
+--    콘솔에 "ALL TESTS PASSED" 가 뜨는지 확인 (원본이 정상 동작하는지 베이스라인 확인).
+-- 2) 이 파일을 obfuscator에 통과시켜 나온 결과물을 같은 위치에 붙여넣고 다시 실행.
+-- 3) 두 경우 모두 콘솔 출력이 "[OK] ..." 목록 + 마지막 "ALL TESTS PASSED"로 동일하면
+--    난독화가 값을 깨뜨리지 않았다는 뜻.
+--    중간에 assert가 실패하면 어떤 케이스가 깨졌는지 에러 메시지로 바로 알 수 있음.
+
+local failCount = 0
+
+local function check(name, actual, expected)
+    if actual == expected then
+        print(string.format("[OK] %s -> %s", name, tostring(actual)))
+    else
+        failCount += 1
+        warn(string.format(
+            "[FAIL] %s -> got %s (%s), expected %s (%s)",
+            name, tostring(actual), typeof(actual), tostring(expected), typeof(expected)
+        ))
+    end
+end
+
+print("===== ObfuscationTest start =====")
+
+-- 1) 문자열 리터럴: ASCII / 한글 / 이모지 / 빈 문자열 / 특수문자(따옴표, 개행, 이스케이프)
+check("ascii string", "Hello, Roblox!", "Hello, Roblox!")
+check("korean string", "안녕하세요, 로블록스", "안녕하세요, 로블록스")
+check("emoji string", "😀🔥✨", "😀🔥✨")
+check("empty string", "", "")
+check("quote/escape string", "he said \"hi\"\nnext line\ttab", "he said \"hi\"\nnext line\ttab")
+
+-- 2) 문자열 연결(concat) : 리터럴끼리, 변수와 리터럴 혼합
+local name = "World"
+check("concat literal+var", "Hello, " .. name .. "! Welcome to Roblox.", "Hello, World! Welcome to Roblox.")
+
+local parts = "A" .. "B" .. "C" .. "D" .. "E" .. "F" .. "G" .. "H"
+check("long concat chain", parts, "ABCDEFGH")
+
+-- 3) 숫자 리터럴: 0, 양수, 음수, 큰 정수, 소수
+check("zero", 0, 0)
+check("positive int", 42, 42)
+check("negative int", -17, -17)
+check("large int", 1234567, 1234567)
+check("negative large int", -987654, -987654)
+check("float", 3.14, 3.14)
+check("negative float", -2.5, -2.5)
+
+-- 4) 산술식으로 위장됐을 법한 값들의 실제 계산 결과
+local total = 5 + 10 * 2
+check("arithmetic literal combo", total, 25)
+
+local mixed = (100 - 37) * 2 + 1
+check("mixed arithmetic", mixed, 127)
+
+-- 5) 테이블 안의 숫자 리터럴들
+local nums = { 1, 2, 3, 4, 5, -6, 7, 100 }
+local sum = 0
+for i = 1, #nums do
+    sum += nums[i]
+end
+check("table of numbers sum", sum, 116)
+
+-- 6) 테이블 안의 문자열 리터럴들 + 순회
+local words = { "alpha", "beta", "gamma", "delta" }
+local joined = table.concat(words, "-")
+check("table of strings joined", joined, "alpha-beta-gamma-delta")
+
+-- 7) 반복문 경계값(숫자 리터럴)이 정확히 유지되는지
+local loopSum = 0
+for i = 1, 10 do
+    loopSum += i
+end
+check("for-loop 1..10 sum", loopSum, 55)
+
+local countdown = 0
+local n = 5
+while n > 0 do
+    countdown += 1
+    n -= 1
+end
+check("while-loop countdown", countdown, 5)
+
+-- 8) 함수 인자/리턴 값으로 쓰인 문자열, 숫자
+local function greet(personName, times)
+    local msg = ""
+    for i = 1, times do
+        msg = msg .. personName .. ";"
+    end
+    return msg
+end
+check("function with literal args", greet("Bob", 3), "Bob;Bob;Bob;")
+
+-- 9) 재귀 함수 자체가 난독화 후에도 정상 동작하는지 (사용자 스크립트 자체의 재귀, 별개 검증용)
+local function factorial(k)
+    if k <= 1 then
+        return 1
+    end
+    return k * factorial(k - 1)
+end
+check("recursive factorial(6)", factorial(6), 720)
+
+-- 10) 문자열 인덱싱/길이 (UTF-8 바이트 변환이 안 깨졌는지 간접 확인)
+check("string length ascii", #"Roblox", 6)
+check("string.upper", string.upper("mixedCase"), "MIXEDCASE")
+check("string.sub", string.sub("Hello, Roblox!", 1, 5), "Hello")
+
+print("===== ObfuscationTest end =====")
+
+if failCount == 0 then
+    print("ALL TESTS PASSED")
+else
+    warn(string.format("%d TEST(S) FAILED", failCount))
 end

package/src/passes/ConstantArray.ts

@@ -1,91 +1,91 @@
-import type { Program, TableField } from "luau-parser"
-import { transformExpressions } from "./walk"
-import {
-    stringLiteral, numberLiteral, vmNumberLiteral, index as indexExpr, identifier, table, localStatement,
-    vmStructuralNumbers,
-} from "./nodeFactory"
-
-export interface ConstantArrayOptions {
-    /** 상수 배열을 담을 local 변수 이름. 생략하면 랜덤 생성됨
-     *  (어차피 RenameVariables가 이후에 한 번 더 이름을 바꿔줌). */
-    arrayName?: string
-}
-
-type Entry = { kind: "string"; value: string } | { kind: "number"; value: number }
-type ConstKey = string
-
-function keyOf(kind: Entry["kind"], value: string | number): ConstKey {
-    return kind === "string" ? `s:${value}` : `n:${value}`
-}
-
-function shuffleIndices(length: number): number[] {
-    const order = Array.from({ length }, (_, i) => i)
-    for (let i = order.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1))
-        ;[order[i], order[j]] = [order[j], order[i]]
-    }
-    return order
-}
-
-function defaultArrayName(): string {
-    return "_CA" + Math.random().toString(36).slice(2, 8)
-}
-
-export function runConstantArray(program: Program, options: ConstantArrayOptions): void {
-    const order: Entry[] = []
-    const seen = new Set<ConstKey>()
-
-    transformExpressions(program, (expr) => {
-        if (expr.type === "StringLiteral") {
-            const k = keyOf("string", expr.value)
-            if (!seen.has(k)) {
-                seen.add(k)
-                order.push({ kind: "string", value: expr.value })
-            }
-        } else if (expr.type === "NumberLiteral" && !vmStructuralNumbers.has(expr)) {
-            const k = keyOf("number", expr.value)
-            if (!seen.has(k)) {
-                seen.add(k)
-                order.push({ kind: "number", value: expr.value })
-            }
-        }
-        return undefined
-    })
-
-    if (order.length === 0) return
-
-    // 2) 배열 안에서 실제로 놓일 위치를 등장 순서와 다르게 섞음.
-    //    shuffledOrder[슬롯] = order 배열에서의 원래 인덱스
-    const shuffledOrder = shuffleIndices(order.length)
-    const indexOf = new Map<ConstKey, number>() // 상수 키 -> 1-based 배열 인덱스
-    shuffledOrder.forEach((originalIndex, slot) => {
-        const entry = order[originalIndex]
-        indexOf.set(keyOf(entry.kind, entry.value), slot + 1)
-    })
-
-    const arrayName = options.arrayName ?? defaultArrayName()
-
-    // 3) 기존 트리를 돌면서 리터럴을 ARR[idx] 접근으로 치환.
-    //    배열 선언문은 아직 트리에 넣지 않은 상태에서 해야 함 — 넣고 나서 돌리면
-    //    배열 자신의 값들까지 자기 자신을 가리키게 치환돼서 깨짐.
-    transformExpressions(program, (expr) => {
-        if (expr.type === "StringLiteral") {
-            const idx = indexOf.get(keyOf("string", expr.value))!
-            return indexExpr(identifier(arrayName), vmNumberLiteral(idx))
-        }
-        if (expr.type === "NumberLiteral" && !vmStructuralNumbers.has(expr)) {
-            const idx = indexOf.get(keyOf("number", expr.value))!
-            return indexExpr(identifier(arrayName), vmNumberLiteral(idx))
-        }
-        return undefined
-    })
-
-    // 4) 치환이 끝난 뒤에야 배열 선언문을 맨 위에 삽입.
-    const fields: TableField[] = shuffledOrder.map((originalIndex) => {
-        const entry = order[originalIndex]
-        const value = entry.kind === "string" ? stringLiteral(entry.value) : numberLiteral(entry.value)
-        return { type: "TableFieldPositional", value }
-    })
-
-    program.body.statements.unshift(localStatement(arrayName, table(fields)))
+import type { Program, TableField } from "luau-parser"
+import { transformExpressions } from "./walk"
+import {
+    stringLiteral, numberLiteral, vmNumberLiteral, index as indexExpr, identifier, table, localStatement,
+    vmStructuralNumbers,
+} from "./nodeFactory"
+
+export interface ConstantArrayOptions {
+    /** 상수 배열을 담을 local 변수 이름. 생략하면 랜덤 생성됨
+     *  (어차피 RenameVariables가 이후에 한 번 더 이름을 바꿔줌). */
+    arrayName?: string
+}
+
+type Entry = { kind: "string"; value: string } | { kind: "number"; value: number }
+type ConstKey = string
+
+function keyOf(kind: Entry["kind"], value: string | number): ConstKey {
+    return kind === "string" ? `s:${value}` : `n:${value}`
+}
+
+function shuffleIndices(length: number): number[] {
+    const order = Array.from({ length }, (_, i) => i)
+    for (let i = order.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1))
+        ;[order[i], order[j]] = [order[j], order[i]]
+    }
+    return order
+}
+
+function defaultArrayName(): string {
+    return "_CA" + Math.random().toString(36).slice(2, 8)
+}
+
+export function runConstantArray(program: Program, options: ConstantArrayOptions): void {
+    const order: Entry[] = []
+    const seen = new Set<ConstKey>()
+
+    transformExpressions(program, (expr) => {
+        if (expr.type === "StringLiteral") {
+            const k = keyOf("string", expr.value)
+            if (!seen.has(k)) {
+                seen.add(k)
+                order.push({ kind: "string", value: expr.value })
+            }
+        } else if (expr.type === "NumberLiteral" && !vmStructuralNumbers.has(expr)) {
+            const k = keyOf("number", expr.value)
+            if (!seen.has(k)) {
+                seen.add(k)
+                order.push({ kind: "number", value: expr.value })
+            }
+        }
+        return undefined
+    })
+
+    if (order.length === 0) return
+
+    // 2) 배열 안에서 실제로 놓일 위치를 등장 순서와 다르게 섞음.
+    //    shuffledOrder[슬롯] = order 배열에서의 원래 인덱스
+    const shuffledOrder = shuffleIndices(order.length)
+    const indexOf = new Map<ConstKey, number>() // 상수 키 -> 1-based 배열 인덱스
+    shuffledOrder.forEach((originalIndex, slot) => {
+        const entry = order[originalIndex]
+        indexOf.set(keyOf(entry.kind, entry.value), slot + 1)
+    })
+
+    const arrayName = options.arrayName ?? defaultArrayName()
+
+    // 3) 기존 트리를 돌면서 리터럴을 ARR[idx] 접근으로 치환.
+    //    배열 선언문은 아직 트리에 넣지 않은 상태에서 해야 함 — 넣고 나서 돌리면
+    //    배열 자신의 값들까지 자기 자신을 가리키게 치환돼서 깨짐.
+    transformExpressions(program, (expr) => {
+        if (expr.type === "StringLiteral") {
+            const idx = indexOf.get(keyOf("string", expr.value))!
+            return indexExpr(identifier(arrayName), vmNumberLiteral(idx))
+        }
+        if (expr.type === "NumberLiteral" && !vmStructuralNumbers.has(expr)) {
+            const idx = indexOf.get(keyOf("number", expr.value))!
+            return indexExpr(identifier(arrayName), vmNumberLiteral(idx))
+        }
+        return undefined
+    })
+
+    // 4) 치환이 끝난 뒤에야 배열 선언문을 맨 위에 삽입.
+    const fields: TableField[] = shuffledOrder.map((originalIndex) => {
+        const entry = order[originalIndex]
+        const value = entry.kind === "string" ? stringLiteral(entry.value) : numberLiteral(entry.value)
+        return { type: "TableFieldPositional", value }
+    })
+
+    program.body.statements.unshift(localStatement(arrayName, table(fields)))
 }

package/src/passes/EncryptNumbers.ts

@@ -1,123 +1,123 @@
-import type { Program, Expression } from "luau-parser"
-import { transformExpressions } from "./walk"
-import {
-    identifier, numberLiteral, call, member,
-    localFunctionStatement, functionParam, functionBody, block, returnStatement,
-    localStatement, binary, vmStructuralNumbers,
-} from "./nodeFactory"
-
-export interface EncryptNumbersOptions {}
-
-// bit32.bxor는 32비트 부호 없는 정수만 다룸. 실수/음수/범위 밖 값은 그대로 둔다
-// (그런 값은 NumbersToExpressions 쪽 산술식 위장으로 커버).
-const UINT32_MAX = 0xFFFFFFFF
-const MOD32 = 4294967296 // 2^32
-
-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 isEncryptable(value: number): boolean {
-    return Number.isInteger(value) && value >= 0 && value <= UINT32_MAX
-}
-
-/** JS의 ^ 연산자는 32비트 부호 있는 정수로 계산하므로 >>> 0으로 다시
- *  부호 없는 32비트 표현으로 맞춰줌 — bit32.bxor와 동일한 비트 결과가 나옴. */
-function xor32(a: number, b: number): number {
-    return (a ^ b) >>> 0
-}
-
-/** Luau의 %는 항상 피제수와 같은 부호(양수 나눗셈이면 0 이상)를 반환하므로
- *  음수가 나와도 자동으로 [0, 2^32) 범위로 랩어라운드된다. */
-function modAdd32(a: number, b: number): number {
-    return ((a + b) % MOD32 + MOD32) % MOD32
-}
-
-/**
- * 숫자 리터럴을 곧이곧대로 노출하지 않고 산술식/bit32.bxor 호출로 위장한다.
- * "decoder(literal, literal, literal)" 형태를 그대로 상수 접기(constant fold)
- * 하는 단순 정적 분석 스크립트를 무력화하기 위함.
- */
-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))
-    }
-    if (variant === 1) {
-        const a = randomInt(0, 0xFFFFFF)
-        return binary("-", numberLiteral(value + a), numberLiteral(a))
-    }
-    const a = randomInt(0, 0xFFFFFF)
-    const b = xor32(value, a)
-    return call(member(identifier("bit32"), "bxor"), [numberLiteral(a), numberLiteral(b)])
-}
-
-/**
- * 런타임 디코더를 조립. 단순 XOR 한 번이 아니라 XOR + 모듈러 덧셈 두 단계를 거치므로,
- * "bit32.bxor(literalA, literalB)" 같은 단일 호출 패턴 매칭으로는 상수 접기가 안 된다:
- *
- *   local function <name>(x, keyA, keyB)
- *       local t = (x - keyB) % 4294967296
- *       return bit32.bxor(t, keyA)
- *   end
- */
-function buildDecoderStatement(name: string) {
-    const xParam = randomName()
-    const keyAParam = randomName()
-    const keyBParam = randomName()
-    const tVar = randomName()
-
-    const body = block([
-        localStatement(
-            tVar,
-            binary(
-                "%",
-                binary("-", identifier(xParam), identifier(keyBParam)),
-                numberLiteral(MOD32),
-            ),
-        ),
-        returnStatement([call(member(identifier("bit32"), "bxor"), [identifier(tVar), identifier(keyAParam)])]),
-    ])
-
-    return localFunctionStatement(
-        name,
-        functionBody([functionParam(xParam), functionParam(keyAParam), functionParam(keyBParam)], body),
-    )
-}
-
-export function runEncryptNumbers(program: Program, _options: EncryptNumbersOptions): void {
-    const decoderName = randomName()
-    let used = false
-
-    transformExpressions(program, (expr: Expression) => {
-        if (expr.type !== "NumberLiteral") return
-        if (vmStructuralNumbers.has(expr)) return
-        if (!isEncryptable(expr.value)) return
-
-        used = true
-
-        const keyA = randomInt(1, 0xFFFFFF)
-        const keyB = randomInt(1, 0xFFFFFF)
-
-        // decode(encode(value)) == value 가 되도록 순전파를 정의:
-        //   t1 = value xor keyA
-        //   encoded = (t1 + keyB) mod 2^32
-        const t1 = xor32(expr.value, keyA)
-        const encoded = modAdd32(t1, keyB)
-
-        return call(identifier(decoderName), [
-            obfuscatedNumber(encoded),
-            obfuscatedNumber(keyA),
-            obfuscatedNumber(keyB),
-        ])
-    })
-
-    if (!used) return
-
-    program.body.statements.unshift(buildDecoderStatement(decoderName))
+import type { Program, Expression } from "luau-parser"
+import { transformExpressions } from "./walk"
+import {
+    identifier, numberLiteral, call, member,
+    localFunctionStatement, functionParam, functionBody, block, returnStatement,
+    localStatement, binary, vmStructuralNumbers,
+} from "./nodeFactory"
+
+export interface EncryptNumbersOptions {}
+
+// bit32.bxor는 32비트 부호 없는 정수만 다룸. 실수/음수/범위 밖 값은 그대로 둔다
+// (그런 값은 NumbersToExpressions 쪽 산술식 위장으로 커버).
+const UINT32_MAX = 0xFFFFFFFF
+const MOD32 = 4294967296 // 2^32
+
+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 isEncryptable(value: number): boolean {
+    return Number.isInteger(value) && value >= 0 && value <= UINT32_MAX
+}
+
+/** JS의 ^ 연산자는 32비트 부호 있는 정수로 계산하므로 >>> 0으로 다시
+ *  부호 없는 32비트 표현으로 맞춰줌 — bit32.bxor와 동일한 비트 결과가 나옴. */
+function xor32(a: number, b: number): number {
+    return (a ^ b) >>> 0
+}
+
+/** Luau의 %는 항상 피제수와 같은 부호(양수 나눗셈이면 0 이상)를 반환하므로
+ *  음수가 나와도 자동으로 [0, 2^32) 범위로 랩어라운드된다. */
+function modAdd32(a: number, b: number): number {
+    return ((a + b) % MOD32 + MOD32) % MOD32
+}
+
+/**
+ * 숫자 리터럴을 곧이곧대로 노출하지 않고 산술식/bit32.bxor 호출로 위장한다.
+ * "decoder(literal, literal, literal)" 형태를 그대로 상수 접기(constant fold)
+ * 하는 단순 정적 분석 스크립트를 무력화하기 위함.
+ */
+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))
+    }
+    if (variant === 1) {
+        const a = randomInt(0, 0xFFFFFF)
+        return binary("-", numberLiteral(value + a), numberLiteral(a))
+    }
+    const a = randomInt(0, 0xFFFFFF)
+    const b = xor32(value, a)
+    return call(member(identifier("bit32"), "bxor"), [numberLiteral(a), numberLiteral(b)])
+}
+
+/**
+ * 런타임 디코더를 조립. 단순 XOR 한 번이 아니라 XOR + 모듈러 덧셈 두 단계를 거치므로,
+ * "bit32.bxor(literalA, literalB)" 같은 단일 호출 패턴 매칭으로는 상수 접기가 안 된다:
+ *
+ *   local function <name>(x, keyA, keyB)
+ *       local t = (x - keyB) % 4294967296
+ *       return bit32.bxor(t, keyA)
+ *   end
+ */
+function buildDecoderStatement(name: string) {
+    const xParam = randomName()
+    const keyAParam = randomName()
+    const keyBParam = randomName()
+    const tVar = randomName()
+
+    const body = block([
+        localStatement(
+            tVar,
+            binary(
+                "%",
+                binary("-", identifier(xParam), identifier(keyBParam)),
+                numberLiteral(MOD32),
+            ),
+        ),
+        returnStatement([call(member(identifier("bit32"), "bxor"), [identifier(tVar), identifier(keyAParam)])]),
+    ])
+
+    return localFunctionStatement(
+        name,
+        functionBody([functionParam(xParam), functionParam(keyAParam), functionParam(keyBParam)], body),
+    )
+}
+
+export function runEncryptNumbers(program: Program, _options: EncryptNumbersOptions): void {
+    const decoderName = randomName()
+    let used = false
+
+    transformExpressions(program, (expr: Expression) => {
+        if (expr.type !== "NumberLiteral") return
+        if (vmStructuralNumbers.has(expr)) return
+        if (!isEncryptable(expr.value)) return
+
+        used = true
+
+        const keyA = randomInt(1, 0xFFFFFF)
+        const keyB = randomInt(1, 0xFFFFFF)
+
+        // decode(encode(value)) == value 가 되도록 순전파를 정의:
+        //   t1 = value xor keyA
+        //   encoded = (t1 + keyB) mod 2^32
+        const t1 = xor32(expr.value, keyA)
+        const encoded = modAdd32(t1, keyB)
+
+        return call(identifier(decoderName), [
+            obfuscatedNumber(encoded),
+            obfuscatedNumber(keyA),
+            obfuscatedNumber(keyB),
+        ])
+    })
+
+    if (!used) return
+
+    program.body.statements.unshift(buildDecoderStatement(decoderName))
 }