luau-obfuscator 1.0.6 → 1.0.8

package/package.json

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

package/smoketest/tests.luau

@@ -106,6 +106,22 @@ check("string length ascii", #"Roblox", 6)
 check("string.upper", string.upper("mixedCase"), "MIXEDCASE")
 check("string.sub", string.sub("Hello, Roblox!", 1, 5), "Hello")
 
+-- 11) 제네릭 for의 iterator가 `a.b` / `a:b()`일 때 루프 변수가 밀리지 않는지
+--     (예전엔 `a`를 담은 임시 레지스터가 남아 첫 변수에 `a`가 들어가고 루프가 안 끝났음)
+local holder = { items = { "x", "y" } }
+function holder:GetItems() return self.items end
+local memberParts, methodParts = {}, {}
+for i, v in holder.items do
+    if #memberParts > 5 then break end
+    memberParts[#memberParts + 1] = tostring(i) .. "=" .. tostring(v)
+end
+for i, v in holder:GetItems() do
+    if #methodParts > 5 then break end
+    methodParts[#methodParts + 1] = tostring(i) .. "=" .. tostring(v)
+end
+check("generic for over a.b", table.concat(memberParts, ","), "1=x,2=y")
+check("generic for over a:b()", table.concat(methodParts, ","), "1=x,2=y")
+
 print("===== ObfuscationTest end =====")
 
 if failCount == 0 then

package/src/passes/vmify/compiler.ts

@@ -642,6 +642,18 @@ export class VmCompiler {
             }
         }
 
+        // iterator 표현식이 남긴 임시 레지스터를 반납한다(`a.b` / `a:b()`는 `a`를 담은
+        // 레지스터를 잡아둔 채로 끝난다). 아래 CALL은 top()부터 결과를 쓰고 루프 변수는
+        // declareLocal()로 base+3부터 잡히므로, 여기서 top을 base+3으로 맞추지 않으면
+        // 루프 변수가 한 칸씩 밀려 첫 변수에 `a`가 들어가고 루프가 끝나지 않는다.
+        state.regs.freeTemp(base + 3)
+
+        // Luau 제네릭 반복은 iterator 표현식이 함수가 아니라 테이블일 수 있다
+        // (플레인 테이블 → array-then-hash 순회, __iter 메타메서드 → 그 결과). base가
+        // 함수가 아니면 루프 진입 전에 한 번 정규화한다 — 안 하면 아래 CALL이 테이블을
+        // 호출하려다 "attempt to call a table value"로 터진다.
+        this.emit(state, Opcode.NORMITER, base, 0, 0, "normalize-generic-iter")
+
         const loopStart = state.proto.code.length
         const nVars = stmt.variables.length
         const callBase = state.regs.top()

package/src/passes/vmify/names.ts

@@ -20,6 +20,9 @@ export interface VmNames {
     dispatch: string
     /** local function __vm_rk(frame, x) */
     rk: string
+    /** local function __vm_tableIter(t) — 제네릭 for가 플레인 테이블을 순회할 때 쓰는
+     *  array-then-hash 이터레이터 클로저 팩토리 (NORMITER opcode에서 사용) */
+    tableIter: string
     /** __vm_execute/핸들러의 frame 파라미터 이름 */
     frame: string
     // frame 테이블 필드
@@ -63,6 +66,7 @@ export function generateVmNames(random: () => number = Math.random): VmNames {
     const id = makeIdGenerator(random)
     return {
         globals: id(), protoRoot: id(), execute: id(), handlers: id(), dispatch: id(), rk: id(),
+        tableIter: id(),
         frame: id(),
         R: id(), K: id(), code: id(), protos: id(), upvals: id(), varargs: id(),
         nVarargs: id(), multiTop: id(),

package/src/passes/vmify/opcodes.ts

@@ -41,6 +41,10 @@ export enum Opcode {
                  //   생성자 마지막 필드가 Call/MethodCall/Vararg로 다중값을 낼 때 씀 (`{f()}`, `{...}`)
     IDIV,        // R[A] = RK(B) // RK(C)  (Luau 바닥 나눗셈 연산자, 뒤에 추가되어 기존 opcode
                  //   번호를 안 건드림 — enum 중간에 끼워넣으면 runtime.ts의 숫자 인덱스가 전부 밀림)
+    NORMITER,    // 제네릭 for 진입 시 R[A..A+2] 이터레이터 3-튜플을 정규화. R[A]가 함수가
+                 //   아니라 테이블이면(플레인 테이블 or __iter 메타메서드) Luau 제네릭 반복
+                 //   의미대로 (fn, state, ctrl)로 바꿔준다. 안 하면 뒤의 CALL이 테이블을
+                 //   호출하려다 "attempt to call a table value"로 터짐. (enum 끝에 추가)
 }
 
 export interface Instr {

package/src/passes/vmify/runtime.ts

@@ -60,6 +60,34 @@ local function ${N.rk}(${N.frame}, x)
     end
 end
 
+-- 플레인 테이블에 대한 Luau 제네릭 반복(for k, v in t) 이터레이터.
+-- 배열부(1..경계)를 순서대로 먼저, 그다음 해시부(이미 낸 정수 키는 건너뜀)를 낸다.
+-- 상태를 클로저에 담으므로 (fn, state, ctrl) 중 state/ctrl은 안 쓴다.
+local function ${N.tableIter}(t)
+    local i = 0
+    local arrayDone = false
+    local hk = nil
+    return function()
+        if not arrayDone then
+            i = i + 1
+            local v = t[i]
+            if v ~= nil then
+                return i, v
+            end
+            arrayDone = true
+        end
+        local k, v = next(t, hk)
+        while k ~= nil do
+            if type(k) ~= "number" or k ~= math.floor(k) or k < 1 or k >= i then
+                hk = k
+                return k, v
+            end
+            k, v = next(t, k)
+        end
+        return nil
+    end
+end
+
 -- MOVE
 ${N.handlers}[${op(Opcode.MOVE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]]
@@ -261,6 +289,30 @@ ${N.handlers}[${op(Opcode.RETURN)}] = function(${N.frame}, pc, instr)
     return table.pack(table.unpack(${N.frame}.${N.R}, a, a + b - 2))
 end
 
+-- NORMITER: 제네릭 for 진입 시 이터레이터 3-튜플(R[A..A+2])을 정규화.
+-- R[A]가 함수면 그대로 두고(pairs/ipairs/커스텀 이터레이터), 테이블이면 __iter
+-- 메타메서드가 있으면 그걸 호출해 (fn,state,ctrl)로, 없으면 array-then-hash
+-- 클로저 이터레이터로 바꾼다. 이후 CALL 핸들러가 함수를 정상 호출하게 된다.
+${N.handlers}[${op(Opcode.NORMITER)}] = function(${N.frame}, pc, instr)
+    local a = instr[2]
+    local it = ${N.frame}.${N.R}[a]
+    if type(it) ~= "function" then
+        local mt = getmetatable(it)
+        local customIter = mt and rawget(mt, "__iter")
+        if customIter ~= nil then
+            local f, s, c = customIter(it)
+            ${N.frame}.${N.R}[a] = f
+            ${N.frame}.${N.R}[a + 1] = s
+            ${N.frame}.${N.R}[a + 2] = c
+        elseif type(it) == "table" then
+            ${N.frame}.${N.R}[a] = ${N.tableIter}(it)
+            ${N.frame}.${N.R}[a + 1] = nil
+            ${N.frame}.${N.R}[a + 2] = nil
+        end
+    end
+    return pc + 1
+end
+
 -- FORPREP
 ${N.handlers}[${op(Opcode.FORPREP)}] = function(${N.frame}, pc, instr)
     local a = instr[2]