CPunch/LuaDecompy
1
0
Fork 0
mirror of https://github.com/CPunch/LuaDecompy.git synced 2025-02-03 05:50:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: CPunch:bc4e762e26785ae4db93c3b757118960b841f3e9
Branches Tags
CPunch:main CPunch:refactor
...
compare: CPunch:refactor
Branches Tags
CPunch:refactor CPunch:main

9 Commits
bc4e762e26 ... refactor

Author SHA1 Message Date
CPunch
6c98c3c5a0 lundump: prettier instruction annotations 2023-12-25 17:54:46 -06:00
CPunch
df8e9f7e83 refactoring: switched to match/case 
wow! python actually added switch cases! too bad this is just syntax sugar...
 2023-12-09 12:01:04 -06:00
CPunch
a22aa808e0 lp: added support for OP_TEST 2022-08-26 01:18:24 -05:00
CPunch
935844f274 more minor refactoring 2022-08-22 00:59:21 -05:00
CPunch
c37e9a21d8 ld: minor refactoring 2022-08-22 00:54:59 -05:00
CPunch
34b1ec7285 ld: added LuaDump() 
- chunks can now be serialized back into lua bytecode dumps :D
 2022-08-22 00:50:08 -05:00
CPunch
f9f1d4af00 ld: minor refactoring 2022-08-19 15:46:47 -05:00
CPunch
3be45f156a lp: support OP_CLOSURE, boilerplate function/proto support 2022-08-17 22:14:45 -05:00
CPunch
b28edcba1d lp: fix isValidLocal() not respecting capitals 2022-08-17 22:14:13 -05:00
5 changed files with 426 additions and 253 deletions
Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -1,2 +1,3 @@
example.* example.*
__pycache__ __pycache__
NOTES.md

99
README.md
View File

@@ -12,70 +12,95 @@ Lua has a relatively small instruction set (only 38 different opcodes!). This ma
```sh ```sh
> cat example.lua && luac5.1 -o example.luac example.lua > cat example.lua && luac5.1 -o example.luac example.lua
local tbl = {"He", "llo", " ", "Wo", "rld", "!"} local printMsg = function(append)
local tbl = {"He", "llo", " ", "Wo"}
local str = "" local str = ""
for i = 1, #tbl do for i = 1, #tbl do
str = str .. tbl[i] str = str .. tbl[i]
end end
print(str) print(str .. append)
end
printMsg("rld!")
> python main.py example.luac > python main.py example.luac
example.luac example.luac
==== [[example.lua's constants]] ==== ==== [[example.lua's constants]] ====
0: [STRING] rld!
==== [[example.lua's locals]] ====
R[0]: printMsg
==== [[example.lua's dissassembly]] ====
[ 0] CLOSURE : R[0] 0 ;
[ 1] MOVE : 1 0 0 ; move R[0] into R[1]
[ 2] LOADK : R[2] K[0] ; load "rld!" into R[2]
[ 3] CALL : 1 2 1 ;
[ 4] RETURN : 0 1 0 ;
==== [[example.lua's protos]] ====
==== [['s constants]] ====
0: [STRING] He 0: [STRING] He
1: [STRING] llo 1: [STRING] llo
2: [STRING] 2: [STRING]
3: [STRING] Wo 3: [STRING] Wo
4: [STRING] rld 4: [STRING]
5: [STRING] ! 5: [NUMBER] 1.0
6: [STRING] 6: [STRING] print
7: [NUMBER] 1.0
8: [STRING] print
==== [[example.lua's locals]] ==== ==== [['s locals]] ====
R[0]: tbl R[0]: append
R[1]: str R[1]: tbl
R[2]: (for index) R[2]: str
R[3]: (for limit) R[3]: (for index)
R[4]: (for step) R[4]: (for limit)
R[5]: i R[5]: (for step)
R[6]: i
==== [[example.lua's dissassembly]] ==== ==== [['s dissassembly]] ====
[ 0] NEWTABLE : 0 6 0 ; [ 0] NEWTABLE : 1 4 0 ;
[ 1] LOADK : R[1] K[0] ; load "He" into R[1] [ 1] LOADK : R[2] K[0] ; load "He" into R[2]
[ 2] LOADK : R[2] K[1] ; load "llo" into R[2] [ 2] LOADK : R[3] K[1] ; load "llo" into R[3]
[ 3] LOADK : R[3] K[2] ; load " " into R[3] [ 3] LOADK : R[4] K[2] ; load " " into R[4]
[ 4] LOADK : R[4] K[3] ; load "Wo" into R[4] [ 4] LOADK : R[5] K[3] ; load "Wo" into R[5]
[ 5] LOADK : R[5] K[4] ; load "rld" into R[5] [ 5] SETLIST : 1 4 1 ;
[ 6] LOADK : R[6] K[5] ; load "!" into R[6] [ 6] LOADK : R[2] K[4] ; load "" into R[2]
[ 7] SETLIST : 0 6 1 ; [ 7] LOADK : R[3] K[5] ; load 1 into R[3]
[ 8] LOADK : R[1] K[6] ; load "" into R[1] [ 8] LEN : 4 1 0 ;
[ 9] LOADK : R[2] K[7] ; load 1 into R[2] [ 9] LOADK : R[5] K[5] ; load 1 into R[5]
[ 10] LEN : 3 0 0 ; [ 10] FORPREP : R[3] 3 ;
[ 11] LOADK : R[4] K[7] ; load 1 into R[4] [ 11] MOVE : 7 2 0 ; move R[2] into R[7]
[ 12] FORPREP : R[2] 3 ; [ 12] GETTABLE : R[8] 1 R[6] ;
[ 13] MOVE : 6 1 0 ; move R[1] into R[6] [ 13] CONCAT : 2 7 8 ; concat 2 values from R[7] to R[8], store into R[2]
[ 14] GETTABLE : R[7] 0 R[5] ; [ 14] FORLOOP : R[3] -4 ;
[ 15] CONCAT : 1 6 7 ; concat 2 values from R[6] to R[7], store into R[1] [ 15] GETGLOBAL : R[3] K[6] ; move _G["print"] into R[3]
[ 16] FORLOOP : R[2] -4 ; [ 16] MOVE : 4 2 0 ; move R[2] into R[4]
[ 17] GETGLOBAL : R[2] K[8] ; move _G["print"] into R[2] [ 17] MOVE : 5 0 0 ; move R[0] into R[5]
[ 18] MOVE : 3 1 0 ; move R[1] into R[3] [ 18] CONCAT : 4 4 5 ; concat 2 values from R[4] to R[5], store into R[4]
[ 19] CALL : 2 2 1 ; [ 19] CALL : 3 2 1 ;
[ 20] RETURN : 0 1 0 ; [ 20] RETURN : 0 1 0 ;
==== [[example.lua's pseudo-code]] ==== ==== [[example.lua's pseudo-code]] ====
local tbl = {"He", "llo", " ", "Wo", "rld", "!", } local printMsg = function(append)
local tbl = {"He", "llo", " ", "Wo", }
local str = "" local str = ""
for i = 1, #tbl, 1 do for i = 1, #tbl, 1 do
str = str .. tbl[i] str = str .. tbl[i]
end end
print(str) print(str .. append)
end
printMsg("rld!")
``` ```

118
lparser.py
View File

@@ -6,8 +6,6 @@
An experimental bytecode decompiler. An experimental bytecode decompiler.
''' '''
from operator import concat
from subprocess import call
from lundump import Chunk, Constant, Instruction, Opcodes, whichRK, readRKasK from lundump import Chunk, Constant, Instruction, Opcodes, whichRK, readRKasK
class _Scope: class _Scope:
@@ -30,18 +28,18 @@ class _Line:
def isValidLocal(ident: str) -> bool: def isValidLocal(ident: str) -> bool:
# has to start with an alpha or _ # has to start with an alpha or _
if ident[0] not in "abcdefghijklmnopqrstuvwxyz_": if ident[0] not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_":
return False return False
# then it can be alphanum or _ # then it can be alphanum or _
for c in ident[1:]: for c in ident[1:]:
if c not in "abcdefghijklmnopqrstuvwxyz1234567890_": if c not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_":
return False return False
return True return True
class LuaDecomp: class LuaDecomp:
def __init__(self, chunk: Chunk): def __init__(self, chunk: Chunk, headChunk: bool = True, scopeOffset: int = 0):
self.chunk = chunk self.chunk = chunk
self.pc = 0 self.pc = 0
self.scope: list[_Scope] = [] self.scope: list[_Scope] = []
@@ -50,6 +48,8 @@ class LuaDecomp:
self.locals = {} self.locals = {}
self.traceback = {} self.traceback = {}
self.unknownLocalCount = 0 self.unknownLocalCount = 0
self.headChunk = headChunk
self.scopeOffset = scopeOffset # number of scopes this chunk/proto is in
self.src: str = "" self.src: str = ""
# configurations! # configurations!
@@ -59,6 +59,20 @@ class LuaDecomp:
self.__loadLocals() self.__loadLocals()
if not self.headChunk:
functionProto = "function("
# define params
for i in range(self.chunk.numParams):
# add param to function prototype (also make a local in the register if it doesn't exist)
functionProto += ("%s, " if i+1 < self.chunk.numParams else "%s") % self.__makeLocalIdentifier(i)
# mark local as defined
self.__addSetTraceback(i)
functionProto += ")"
self.__startScope(functionProto, 0, len(self.chunk.instructions))
# parse instructions # parse instructions
while self.pc < len(self.chunk.instructions): while self.pc < len(self.chunk.instructions):
self.parseInstr() self.parseInstr()
@@ -67,12 +81,18 @@ class LuaDecomp:
# end the scope (if we're supposed too) # end the scope (if we're supposed too)
self.__checkScope() self.__checkScope()
print("\n==== [[" + str(self.chunk.name) + "'s pseudo-code]] ====\n") if not self.headChunk:
self.__endScope()
def getPseudoCode(self) -> str:
fullSrc = ""
for line in self.lines: for line in self.lines:
if self.annotateLines: if self.annotateLines:
print("-- PC: %d to PC: %d" % (line.startPC, line.endPC)) fullSrc += "-- PC: %d to PC: %d\n" % (line.startPC, line.endPC)
print(((' ' * self.indexWidth) * line.scope) + line.src) fullSrc += ((' ' * self.indexWidth) * (line.scope + self.scopeOffset)) + line.src + "\n"
return fullSrc
# =======================================[[ Helpers ]]========================================= # =======================================[[ Helpers ]]=========================================
@@ -179,7 +199,6 @@ class LuaDecomp:
return self.locals[indx] return self.locals[indx]
def __newLocal(self, indx: int, expr: str) -> None: def __newLocal(self, indx: int, expr: str) -> None:
# TODO: grab identifier from chunk(?)
self.__makeLocalIdentifier(indx) self.__makeLocalIdentifier(indx)
self.__addExpr("local " + self.locals[indx] + " = " + expr) self.__addExpr("local " + self.locals[indx] + " = " + expr)
@@ -212,7 +231,8 @@ class LuaDecomp:
def __emitOperand(self, a: int, b: str, c: str, op: str) -> None: def __emitOperand(self, a: int, b: str, c: str, op: str) -> None:
self.__setReg(a, "(" + b + op + c + ")") self.__setReg(a, "(" + b + op + c + ")")
def __compJmp(self, op: str): # handles conditional jumps
def __condJmp(self, op: str, rkBC: bool = True):
instr = self.__getCurrInstr() instr = self.__getCurrInstr()
jmpType = "if" jmpType = "if"
scopeStart = "then" scopeStart = "then"
@@ -235,7 +255,13 @@ class LuaDecomp:
self.__addExpr("%s not " % jmpType) self.__addExpr("%s not " % jmpType)
else: else:
self.__addExpr("%s " % jmpType) self.__addExpr("%s " % jmpType)
# write actual comparison
if rkBC:
self.__addExpr(self.__readRK(instr.B) + op + self.__readRK(instr.C) + " ") self.__addExpr(self.__readRK(instr.B) + op + self.__readRK(instr.C) + " ")
else: # just testing rkB
self.__addExpr(op + self.__readRK(instr.B))
self.pc += 1 # skip next instr self.pc += 1 # skip next instr
if scopeStart: if scopeStart:
self.__startScope("%s " % scopeStart, self.pc - 1, jmp) self.__startScope("%s " % scopeStart, self.pc - 1, jmp)
@@ -296,48 +322,48 @@ class LuaDecomp:
def parseInstr(self): def parseInstr(self):
instr = self.__getCurrInstr() instr = self.__getCurrInstr()
# python, add switch statements *please* match instr.opcode:
if instr.opcode == Opcodes.MOVE: # move is a fake ABC instr, C is ignored case Opcodes.MOVE: # move is a fake ABC instr, C is ignored
# move registers # move registers
self.__setReg(instr.A, self.__getReg(instr.B)) self.__setReg(instr.A, self.__getReg(instr.B))
elif instr.opcode == Opcodes.LOADK: case Opcodes.LOADK:
self.__setReg(instr.A, self.chunk.getConstant(instr.B).toCode()) self.__setReg(instr.A, self.chunk.getConstant(instr.B).toCode())
elif instr.opcode == Opcodes.LOADBOOL: case Opcodes.LOADBOOL:
if instr.B == 0: if instr.B == 0:
self.__setReg(instr.A, "false") self.__setReg(instr.A, "false")
else: else:
self.__setReg(instr.A, "true") self.__setReg(instr.A, "true")
elif instr.opcode == Opcodes.GETGLOBAL: case Opcodes.GETGLOBAL:
self.__setReg(instr.A, self.chunk.getConstant(instr.B).data) self.__setReg(instr.A, self.chunk.getConstant(instr.B).data)
elif instr.opcode == Opcodes.GETTABLE: case Opcodes.GETTABLE:
self.__setReg(instr.A, self.__getReg(instr.B) + "[" + self.__readRK(instr.C) + "]") self.__setReg(instr.A, self.__getReg(instr.B) + "[" + self.__readRK(instr.C) + "]")
elif instr.opcode == Opcodes.SETGLOBAL: case Opcodes.SETGLOBAL:
self.__addExpr(self.chunk.getConstant(instr.B).data + " = " + self.__getReg(instr.A)) self.__addExpr(self.chunk.getConstant(instr.B).data + " = " + self.__getReg(instr.A))
self.__endStatement() self.__endStatement()
elif instr.opcode == Opcodes.SETTABLE: case Opcodes.SETTABLE:
self.__addExpr(self.__getReg(instr.A) + "[" + self.__readRK(instr.B) + "] = " + self.__readRK(instr.C)) self.__addExpr(self.__getReg(instr.A) + "[" + self.__readRK(instr.B) + "] = " + self.__readRK(instr.C))
self.__endStatement() self.__endStatement()
elif instr.opcode == Opcodes.NEWTABLE: case Opcodes.NEWTABLE:
self.__parseNewTable(instr.A) self.__parseNewTable(instr.A)
elif instr.opcode == Opcodes.ADD: case Opcodes.ADD:
self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " + ") self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " + ")
elif instr.opcode == Opcodes.SUB: case Opcodes.SUB:
self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " - ") self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " - ")
elif instr.opcode == Opcodes.MUL: case Opcodes.MUL:
self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " * ") self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " * ")
elif instr.opcode == Opcodes.DIV: case Opcodes.DIV:
self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " / ") self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " / ")
elif instr.opcode == Opcodes.MOD: case Opcodes.MOD:
self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " % ") self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " % ")
elif instr.opcode == Opcodes.POW: case Opcodes.POW:
self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " ^ ") self.__emitOperand(instr.A, self.__readRK(instr.B), self.__readRK(instr.C), " ^ ")
elif instr.opcode == Opcodes.UNM: case Opcodes.UNM:
self.__setReg(instr.A, "-" + self.__getReg(instr.B)) self.__setReg(instr.A, "-" + self.__getReg(instr.B))
elif instr.opcode == Opcodes.NOT: case Opcodes.NOT:
self.__setReg(instr.A, "not " + self.__getReg(instr.B)) self.__setReg(instr.A, "not " + self.__getReg(instr.B))
elif instr.opcode == Opcodes.LEN: case Opcodes.LEN:
self.__setReg(instr.A, "#" + self.__getReg(instr.B)) self.__setReg(instr.A, "#" + self.__getReg(instr.B))
elif instr.opcode == Opcodes.CONCAT: case Opcodes.CONCAT:
count = instr.C-instr.B+1 count = instr.C-instr.B+1
concatStr = "" concatStr = ""
@@ -346,15 +372,20 @@ class LuaDecomp:
concatStr += self.__getReg(instr.B + i) + (" .. " if not i == count - 1 else "") concatStr += self.__getReg(instr.B + i) + (" .. " if not i == count - 1 else "")
self.__setReg(instr.A, concatStr) self.__setReg(instr.A, concatStr)
elif instr.opcode == Opcodes.JMP: case Opcodes.JMP:
pass pass
elif instr.opcode == Opcodes.EQ: case Opcodes.EQ:
self.__compJmp(" == ") self.__condJmp(" == ")
elif instr.opcode == Opcodes.LT: case Opcodes.LT:
self.__compJmp(" < ") self.__condJmp(" < ")
elif instr.opcode == Opcodes.LE: case Opcodes.LE:
self.__compJmp(" <= ") self.__condJmp(" <= ")
elif instr.opcode == Opcodes.CALL: case Opcodes.TEST:
if instr.C == 0:
self.__condJmp("", False)
else:
self.__condJmp("not ", False)
case Opcodes.CALL:
preStr = "" preStr = ""
callStr = "" callStr = ""
ident = "" ident = ""
@@ -384,15 +415,15 @@ class LuaDecomp:
self.__addExpr(preStr + callStr) self.__addExpr(preStr + callStr)
self.__endStatement() self.__endStatement()
elif instr.opcode == Opcodes.RETURN: case Opcodes.RETURN:
self.__endStatement() self.__endStatement()
pass # no-op for now pass # no-op for now
elif instr.opcode == Opcodes.FORLOOP: case Opcodes.FORLOOP:
pass # no-op for now pass # no-op for now
elif instr.opcode == Opcodes.FORPREP: case Opcodes.FORPREP:
self.__addExpr("for %s = %s, %s, %s " % (self.__getLocal(instr.A+3), self.__getReg(instr.A), self.__getReg(instr.A + 1), self.__getReg(instr.A + 2))) self.__addExpr("for %s = %s, %s, %s " % (self.__getLocal(instr.A+3), self.__getReg(instr.A), self.__getReg(instr.A + 1), self.__getReg(instr.A + 2)))
self.__startScope("do", self.pc, instr.B) self.__startScope("do", self.pc, instr.B)
elif instr.opcode == Opcodes.SETLIST: case Opcodes.SETLIST:
# LFIELDS_PER_FLUSH (50) is the number of elements that *should* have been set in the list in the *last* SETLIST # LFIELDS_PER_FLUSH (50) is the number of elements that *should* have been set in the list in the *last* SETLIST
# eg. # eg.
# [ 49] LOADK : R[49] K[1] ; load 0.0 into R[49] # [ 49] LOADK : R[49] K[1] ; load 0.0 into R[49]
@@ -408,5 +439,8 @@ class LuaDecomp:
for i in range(numElems): for i in range(numElems):
self.__addExpr("%s[%d] = %s" % (ident, (startAt + i + 1), self.__getReg(instr.A + i + 1))) self.__addExpr("%s[%d] = %s" % (ident, (startAt + i + 1), self.__getReg(instr.A + i + 1)))
self.__endStatement() self.__endStatement()
else: case Opcodes.CLOSURE:
proto = LuaDecomp(self.chunk.protos[instr.B], headChunk=False, scopeOffset=len(self.scope))
self.__setReg(instr.A, proto.getPseudoCode())
case _:
raise Exception("unsupported instruction: %s" % instr.toString()) raise Exception("unsupported instruction: %s" % instr.toString())

268
lundump.py
View File

@@ -1,7 +1,7 @@
''' '''
l(un)dump.py l(un)dump.py
A Lua5.1 cross-platform bytecode deserializer. This module pulls int and size_t sizes from the A Lua5.1 cross-platform bytecode deserializer && serializer. This module pulls int and size_t sizes from the
chunk header, meaning it should be able to deserialize lua bytecode dumps from most platforms, chunk header, meaning it should be able to deserialize lua bytecode dumps from most platforms,
regardless of the host machine. regardless of the host machine.
@@ -9,11 +9,9 @@
as well as read the lundump.c source file from the Lua5.1 source. as well as read the lundump.c source file from the Lua5.1 source.
''' '''
from multiprocessing.spawn import get_executable
import struct import struct
import array import array
from enum import IntEnum, Enum, auto from enum import IntEnum, Enum, auto
from typing_extensions import Self
class InstructionType(Enum): class InstructionType(Enum):
ABC = auto(), ABC = auto(),
@@ -70,6 +68,8 @@ _RKBCInstr = [Opcodes.SETTABLE, Opcodes.ADD, Opcodes.SUB, Opcodes.MUL, Opcodes.D
_RKCInstr = [Opcodes.GETTABLE, Opcodes.SELF] _RKCInstr = [Opcodes.GETTABLE, Opcodes.SELF]
_KBx = [Opcodes.LOADK, Opcodes.GETGLOBAL, Opcodes.SETGLOBAL] _KBx = [Opcodes.LOADK, Opcodes.GETGLOBAL, Opcodes.SETGLOBAL]
_LUAMAGIC = b'\x1bLua'
# is an 'RK' value a K? (result is true for K, false for R) # is an 'RK' value a K? (result is true for K, false for R)
def whichRK(rk: int): def whichRK(rk: int):
return (rk & (1 << 8)) > 0 return (rk & (1 << 8)) > 0
@@ -127,22 +127,21 @@ class Instruction:
def getAnnotation(self, chunk): def getAnnotation(self, chunk):
if self.opcode == Opcodes.MOVE: if self.opcode == Opcodes.MOVE:
return "move R[%d] into R[%d]" % (self.B, self.A) return "R[%d] := R[%d]" % (self.A, self.B)
elif self.opcode == Opcodes.LOADK: elif self.opcode == Opcodes.LOADK:
return "load %s into R[%d]" % (chunk.getConstant(self.B).toCode(), self.A) return "R[%d] := K[%d] (%s)" % (self.A, self.B, chunk.getConstant(self.B).toCode())
elif self.opcode == Opcodes.GETGLOBAL: elif self.opcode == Opcodes.GETGLOBAL:
return 'move _G[%s] into R[%d]' % (chunk.getConstant(self.B).toCode(), self.A) return 'R[%d] := _G[%s]' % (self.A, chunk.getConstant(self.B).toCode())
elif self.opcode == Opcodes.ADD: elif self.opcode == Opcodes.ADD:
return 'add %s to %s, place into R[%d]' % (self.__formatRK(self.C), self.__formatRK(self.B), self.A) return 'R[%d] := %s + %s' % (self.A, self.__formatRK(self.B), self.__formatRK(self.C))
elif self.opcode == Opcodes.SUB: elif self.opcode == Opcodes.SUB:
return 'sub %s from %s, place into R[%d]' % (self.__formatRK(self.C), self.__formatRK(self.B), self.A) return 'R[%d] := %s - %s' % (self.A, self.__formatRK(self.B), self.__formatRK(self.C))
elif self.opcode == Opcodes.MUL: elif self.opcode == Opcodes.MUL:
return 'mul %s to %s, place into R[%d]' % (self.__formatRK(self.C), self.__formatRK(self.B), self.A) return 'R[%d] := %s * %s' % (self.A, self.__formatRK(self.B), self.__formatRK(self.C))
elif self.opcode == Opcodes.DIV: elif self.opcode == Opcodes.DIV:
return 'div %s from %s, place into R[%d]' % (self.__formatRK(self.C), self.__formatRK(self.B), self.A) return 'R[%d] := %s / %s' % (self.A, self.__formatRK(self.B), self.__formatRK(self.C))
elif self.opcode == Opcodes.CONCAT: elif self.opcode == Opcodes.CONCAT:
count = self.C - self.B + 1 return "R[%d] := R[%d] .. R[%d]" % (self.A, self.B, self.C)
return "concat %d values from R[%d] to R[%d], store into R[%d]" % (count, self.B, self.C, self.A)
else: else:
return "" return ""
@@ -189,6 +188,7 @@ class Chunk:
self.maxStack: int = 0 self.maxStack: int = 0
self.upvalues: list[str] = [] self.upvalues: list[str] = []
self.lineNums: list[int] = []
self.locals: list[Local] = [] self.locals: list[Local] = []
def appendInstruction(self, instr: Instruction): def appendInstruction(self, instr: Instruction):
@@ -200,9 +200,15 @@ class Chunk:
def appendProto(self, proto): def appendProto(self, proto):
self.protos.append(proto) self.protos.append(proto)
def appendLine(self, line: int):
self.lineNums.append(line)
def appendLocal(self, local: Local): def appendLocal(self, local: Local):
self.locals.append(local) self.locals.append(local)
def appendUpval(self, upval: str):
self.upvalues.append(upval)
def findLocal(self, pc: int) -> Local: def findLocal(self, pc: int) -> Local:
for l in self.locals: for l in self.locals:
if l.start <= pc and l.end >= pc: if l.start <= pc and l.end >= pc:
@@ -298,11 +304,7 @@ class LuaUndump:
self.rootChunk: Chunk = None self.rootChunk: Chunk = None
self.index = 0 self.index = 0
@staticmethod def _loadBlock(self, sz) -> bytearray:
def dis_chunk(chunk: Chunk):
chunk.print()
def loadBlock(self, sz) -> bytearray:
if self.index + sz > len(self.bytecode): if self.index + sz > len(self.bytecode):
raise Exception("Malformed bytecode!") raise Exception("Malformed bytecode!")
@@ -310,82 +312,71 @@ class LuaUndump:
self.index = self.index + sz self.index = self.index + sz
return temp return temp
def get_byte(self) -> int: def _get_byte(self) -> int:
return self.loadBlock(1)[0] return self._loadBlock(1)[0]
def get_int32(self) -> int: def _get_uint32(self) -> int:
if (self.big_endian): order = 'big' if self.big_endian else 'little'
return int.from_bytes(self.loadBlock(4), byteorder='big', signed=False) return int.from_bytes(self._loadBlock(4), byteorder=order, signed=False)
else:
return int.from_bytes(self.loadBlock(4), byteorder='little', signed=False)
def get_int(self) -> int: def _get_uint(self) -> int:
if (self.big_endian): order = 'big' if self.big_endian else 'little'
return int.from_bytes(self.loadBlock(self.int_size), byteorder='big', signed=False) return int.from_bytes(self._loadBlock(self.int_size), byteorder=order, signed=False)
else:
return int.from_bytes(self.loadBlock(self.int_size), byteorder='little', signed=False)
def get_size_t(self) -> int: def _get_size_t(self) -> int:
if (self.big_endian): order = 'big' if self.big_endian else 'little'
return int.from_bytes(self.loadBlock(self.size_t), byteorder='big', signed=False) return int.from_bytes(self._loadBlock(self.size_t), byteorder=order, signed=False)
else:
return int.from_bytes(self.loadBlock(self.size_t), byteorder='little', signed=False)
def get_double(self) -> int: def _get_double(self) -> int:
if self.big_endian: order = '>d' if self.big_endian else '<d'
return struct.unpack('>d', self.loadBlock(8))[0] return struct.unpack(order, self._loadBlock(self.l_number_size))[0]
else:
return struct.unpack('<d', self.loadBlock(8))[0]
def get_string(self, size) -> str: def _get_string(self) -> str:
if (size == None): size = self._get_size_t()
size = self.get_size_t()
if (size == 0): if (size == 0):
return "" return ""
return "".join(chr(x) for x in self.loadBlock(size)) # [:-1] to remove the NULL terminator
return ("".join(chr(x) for x in self._loadBlock(size)))[:-1]
def decode_chunk(self) -> Chunk: def decode_chunk(self) -> Chunk:
chunk = Chunk() chunk = Chunk()
chunk.name = self.get_string(None) # chunk meta info
chunk.frst_line = self.get_int() chunk.name = self._get_string()
chunk.last_line = self.get_int() chunk.frst_line = self._get_uint()
chunk.last_line = self._get_uint()
chunk.numUpvals = self.get_byte() chunk.numUpvals = self._get_byte()
chunk.numParams = self.get_byte() chunk.numParams = self._get_byte()
chunk.isVarg = (self.get_byte() != 0) chunk.isVarg = (self._get_byte() != 0)
chunk.maxStack = self.get_byte() chunk.maxStack = self._get_byte()
if (not chunk.name == ""):
chunk.name = chunk.name[1:-1]
# parse instructions # parse instructions
num = self.get_int() num = self._get_uint()
for i in range(num): for i in range(num):
chunk.appendInstruction(_decode_instr(self.get_int32())) chunk.appendInstruction(_decode_instr(self._get_uint32()))
# get constants # get constants
num = self.get_int() num = self._get_uint()
for i in range(num): for i in range(num):
constant: Constant = None constant: Constant = None
type = self.get_byte() type = self._get_byte()
if type == 0: # nil if type == 0: # nil
constant = Constant(ConstType.NIL, None) constant = Constant(ConstType.NIL, None)
elif type == 1: # bool elif type == 1: # bool
constant = Constant(ConstType.BOOL, (self.get_byte() != 0)) constant = Constant(ConstType.BOOL, (self._get_byte() != 0))
elif type == 3: # number elif type == 3: # number
constant = Constant(ConstType.NUMBER, self.get_double()) constant = Constant(ConstType.NUMBER, self._get_double())
elif type == 4: # string elif type == 4: # string
constant = Constant(ConstType.STRING, self.get_string(None)[:-1]) constant = Constant(ConstType.STRING, self._get_string())
else: else:
raise Exception("Unknown Datatype! [%d]" % type) raise Exception("Unknown Datatype! [%d]" % type)
chunk.appendConstant(constant) chunk.appendConstant(constant)
# parse protos # parse protos
num = self.get_int() num = self._get_uint()
for i in range(num): for i in range(num):
chunk.appendProto(self.decode_chunk()) chunk.appendProto(self.decode_chunk())
@@ -393,28 +384,28 @@ class LuaUndump:
# eh, for now just consume the bytes. # eh, for now just consume the bytes.
# line numbers # line numbers
num = self.get_int() num = self._get_uint()
for i in range(num): for i in range(num):
self.get_int() self._get_uint()
# locals # locals
num = self.get_int() num = self._get_uint()
for i in range(num): for i in range(num):
name = self.get_string(None)[:-1] # local name ([:-1] to remove the NULL terminator) name = self._get_string() # local name
start = self.get_int() # local start PC start = self._get_uint() # local start PC
end = self.get_int() # local end PC end = self._get_uint() # local end PC
chunk.appendLocal(Local(name, start, end)) chunk.appendLocal(Local(name, start, end))
# upvalues # upvalues
num = self.get_int() num = self._get_uint()
for i in range(num): for i in range(num):
self.get_string(None) # upvalue name chunk.appendUpval(self._get_string()) # upvalue name
return chunk return chunk
def decode_rawbytecode(self, rawbytecode): def decode_rawbytecode(self, rawbytecode):
# bytecode sanity checks # bytecode sanity checks
if not rawbytecode[0:4] == b'\x1bLua': if not rawbytecode[0:4] == _LUAMAGIC:
raise Exception("Lua Bytecode expected!") raise Exception("Lua Bytecode expected!")
bytecode = array.array('b', rawbytecode) bytecode = array.array('b', rawbytecode)
@@ -426,14 +417,14 @@ class LuaUndump:
# aligns index, skips header # aligns index, skips header
self.index = 4 self.index = 4
self.vm_version = self.get_byte() self.vm_version = self._get_byte()
self.bytecode_format = self.get_byte() self.bytecode_format = self._get_byte()
self.big_endian = (self.get_byte() == 0) self.big_endian = (self._get_byte() == 0)
self.int_size = self.get_byte() self.int_size = self._get_byte()
self.size_t = self.get_byte() self.size_t = self._get_byte()
self.instr_size = self.get_byte() # gets size of instructions self.instr_size = self._get_byte() # gets size of instructions
self.l_number_size = self.get_byte() # size of lua_Number self.l_number_size = self._get_byte() # size of lua_Number
self.integral_flag = self.get_byte() self.integral_flag = self._get_byte() # is lua_Number defined as an int? false = float/double, true = int/long/short/etc.
self.rootChunk = self.decode_chunk() self.rootChunk = self.decode_chunk()
return self.rootChunk return self.rootChunk
@@ -444,5 +435,122 @@ class LuaUndump:
return self.decode_rawbytecode(bytecode) return self.decode_rawbytecode(bytecode)
def print_dissassembly(self): def print_dissassembly(self):
LuaUndump.dis_chunk(self.rootChunk) self.rootChunk.print()
class LuaDump:
def __init__(self, rootChunk: Chunk):
self.rootChunk = rootChunk
self.bytecode = bytearray()
# header info
self.vm_version = 0x51
self.bytecode_format = 0x00
self.big_endian = False
# data sizes
self.int_size = 4
self.size_t = 8
self.instr_size = 4
self.l_number_size = 8
self.integral_flag = False # lua_Number is a double
def _writeBlock(self, data: bytes):
self.bytecode += bytearray(data)
def _set_byte(self, b: int):
self.bytecode.append(b)
def _set_uint32(self, i: int):
order = 'big' if self.big_endian else 'little'
self._writeBlock(i.to_bytes(4, order, signed=False))
def _set_uint(self, i: int):
order = 'big' if self.big_endian else 'little'
self._writeBlock(i.to_bytes(self.int_size, order, signed=False))
def _set_size_t(self, i: int):
order = 'big' if self.big_endian else 'little'
self._writeBlock(i.to_bytes(self.size_t, order, signed=False))
def _set_double(self, f: float):
order = '>d' if self.big_endian else '<d'
self._writeBlock(struct.pack(order, f))
def _set_string(self, string: str):
self._set_size_t(len(string)+1)
self._writeBlock(string.encode('utf-8'))
self._set_byte(0x00) # write null terminator
def _dumpChunk(self, chunk: Chunk):
# write meta info
self._set_string(chunk.name)
self._set_uint(chunk.frst_line)
self._set_uint(chunk.last_line)
self._set_byte(chunk.numUpvals)
self._set_byte(chunk.numParams)
self._set_byte(1 if chunk.isVarg else 1)
self._set_byte(chunk.maxStack)
# write instructions
self._set_uint(len(chunk.instructions))
for l in chunk.instructions:
self._set_uint32(_encode_instr(l))
# write constants
self._set_uint(len(chunk.constants))
for constant in chunk.constants:
# write constant data
if constant.type == ConstType.NIL:
self._set_byte(0)
elif constant.type == ConstType.BOOL:
self._set_byte(1)
self._set_byte(1 if constant.data else 0)
elif constant.type == ConstType.NUMBER: # number
self._set_byte(3)
self._set_double(constant.data)
elif constant.type == ConstType.STRING: # string
self._set_byte(4)
self._set_string(constant.data)
else:
raise Exception("Unknown Datatype! [%s]" % str(constant.type))
# write child protos
self._set_uint(len(chunk.protos))
for p in chunk.protos:
self._dumpChunk(p)
# write line numbers
self._set_uint(len(chunk.lineNums))
for l in chunk.lineNums:
self._set_uint(l)
# write locals
self._set_uint(len(chunk.locals))
for l in chunk.locals:
self._set_string(l.name)
self._set_uint(l.start)
self._set_uint(l.end)
# write upvals
self._set_uint(len(chunk.upvalues))
for u in chunk.upvalues:
self._set_string(u)
def _dumpHeader(self):
self._writeBlock(_LUAMAGIC)
# write header info
self._set_byte(self.vm_version)
self._set_byte(self.bytecode_format)
self._set_byte(0 if self.big_endian else 1)
self._set_byte(self.int_size)
self._set_byte(self.size_t)
self._set_byte(self.instr_size)
self._set_byte(self.l_number_size)
self._set_byte(self.integral_flag)
def dump(self) -> bytearray:
self._dumpHeader()
self._dumpChunk(self.rootChunk)
return self.bytecode

5
main.py Normal file → Executable file
View File

@@ -1,3 +1,4 @@
#!/usr/bin/env python3
import sys import sys
import lundump import lundump
import lparser import lparser
@@ -7,4 +8,8 @@ print(sys.argv[1])
chunk = lc.loadFile(sys.argv[1]) chunk = lc.loadFile(sys.argv[1])
lc.print_dissassembly() lc.print_dissassembly()
lp = lparser.LuaDecomp(chunk) lp = lparser.LuaDecomp(chunk)
print("\n==== [[" + str(chunk.name) + "'s pseudo-code]] ====\n")
print(lp.getPseudoCode())