Fix FunctionHeader Overflowed and add hasm dump feature

.gitignore

@@ -135,4 +135,8 @@ dmypy.json
 .pytype/
 
 # Cython debug symbols
-cython_debug/
+cython_debug/
+
+# Custom
+output/*
+!output/.gitkeep

hasm.py

@@ -1,8 +1,45 @@
 from util import *
+import json
+import os
 
-def to_hasm(f, hbc):
+def dump(hbc, path):
+    assert not os.path.exists(path), f"'{path}' exists."
+    os.makedirs(path)
+    # Write all obj to metadata.json
+    json.dump(hbc.getObj(), open(f"{path}/metadata.json", "w"))
+
     stringCount = hbc.getStringCount()
     functionCount = hbc.getFunctionCount()
 
+    f = open(f"{path}/instruction.hasm", "w")
     for i in range(functionCount):
-        functionName, paramCount, registerCount, symbolCount, inst, _ = hbc.getFunction(i)
+        functionName, paramCount, registerCount, symbolCount, insts, _ = hbc.getFunction(i)
+        # Function<>1270(2 params, 1 registers, 0 symbols):
+        f.write(f"Function<{functionName.decode()}>{i}({paramCount} params, {registerCount} registers, {symbolCount} symbols):\n")
+        for opcode, operands in insts:
+            f.write(f"\t{opcode.ljust(20,' ')}\t")
+            o = []
+            ss = []
+            for ii, v in enumerate(operands):
+                t, is_str, val = v
+                o.append(f"{t}:{val}")
+
+                if is_str:
+                    s = hbc.getString(val)
+                    ss.append((ii, val, s))
+
+
+            f.write(f"{', '.join(o)}\n")
+            if len(ss) > 0:
+                for ii, val, s in ss:
+                    try:
+                        s = f"\"{s.decode()}\""
+                    except UnicodeDecodeError:
+                        s = f"hex({s.hex()})"
+
+                    f.write(f"\t; Oper[{ii}]: String({val}) {s}\n")
+
+                f.write("\n")
+
+        f.write("EndFunction\n\n")
+    f.close()

hbc/hbc74/__init__.py

@@ -17,7 +17,7 @@ class HBC74:
     def __init__(self, f):
         self.obj = parse(f)
 
-    def getObj():
+    def getObj(self):
         return self.obj
 
     def getVersion(self):
@@ -29,7 +29,7 @@ def getHeader(self):
     def getFunctionCount(self):
         return self.obj["header"]["functionCount"]
 
-    def getFunction(self, fid):
+    def getFunction(self, fid, disasm=True):
         assert fid >= 0 and fid < self.getFunctionCount(), "Invalid function ID"
 
         functionHeader = self.obj["functionHeaders"][fid]
@@ -43,7 +43,10 @@ def getFunction(self, fid):
         instOffset = self.obj["instOffset"]
         start = offset - instOffset
         end = start + bytecodeSizeInBytes
-        inst = disassemble(self.obj["inst"][start:end])
+        inst = self.obj["inst"][start:end]
+        if disasm:
+            inst = disassemble(inst)
+
 
         functionNameStr = self.getString(functionName)
 

hbc/hbc74/data/structure.json

@@ -34,6 +34,18 @@
         "highestWriteCacheIndex": ["bit", 8, 1],
         "flags": ["uint", 8, 1]
     },
+    "FuncHeader": {
+        "offset": ["uint", 32, 1],
+        "paramCount": ["uint", 32, 1],
+        "bytecodeSizeInBytes": ["uint", 32, 1],
+        "functionName": ["uint", 32, 1],
+        "infoOffset": ["uint", 32, 1],
+        "frameSize": ["uint", 32, 1],
+        "environmentSize": ["uint", 32, 1],
+        "highestReadCacheIndex": ["uint", 8, 1],
+        "highestWriteCacheIndex": ["uint", 8, 1],
+        "flags": ["uint", 8, 1]
+    },
     "SmallStringTableEntry": {
         "isUTF16": ["bit", 1, 1],
         "offset": ["bit", 23, 1],

hbc/hbc74/parser.py

@@ -14,7 +14,8 @@ def parse(f):
     structure = json.load(open(f"{basepath}/data/structure.json", "r"))
 
     headerS = structure["header"]
-    functionHeaderS = structure["SmallFuncHeader"]
+    smallFunctionHeaderS = structure["SmallFuncHeader"]
+    functionHeaderS = structure["FuncHeader"]
     stringTableEntryS = structure["SmallStringTableEntry"]
     overflowStringTableEntryS = structure["OverflowStringTableEntry"]
     stringStorageS = structure["StringStorage"]
@@ -37,11 +38,20 @@ def parse(f):
 
     # Segment 2: Function Header
     functionHeaders = []
-    for _ in range(header["functionCount"]):
+    for i in range(header["functionCount"]):
         functionHeader = {}
-        for key in functionHeaderS:
-            functionHeader[key] = read(f, functionHeaderS[key])
+        for key in smallFunctionHeaderS:
+            functionHeader[key] = read(f, smallFunctionHeaderS[key])
 
+        if (functionHeader["flags"] >> 5) & 1:
+            saved_pos = f.tell()
+            large_offset = (functionHeader["infoOffset"] << 16 )  | functionHeader["offset"]
+            f.seek(large_offset)
+            for key in functionHeaderS:
+                functionHeader[key] = read(f, functionHeaderS[key])
+
+            f.seek(saved_pos)
+
         functionHeaders.append(functionHeader)
 
     obj["functionHeaders"] = functionHeaders

hbc/hbc74/translator.py

@@ -31,7 +31,7 @@ def disassemble(inst):
             if is_str:
                 oper_t = oper_t[:-2]
 
-            size, conv_to, conv_from = operand_type[oper_t]
+            size, conv_to, _ = operand_type[oper_t]
             val = conv_to(inst[i:i+size])
             r[1].append((oper_t, is_str, val))
             i+=size

hbctool.py

@@ -1,11 +1,5 @@
 from hbc import parseFromFile
-
-def to_hasm():
-    pass
-
+import hasm
 
 if __name__ == "__main__":
-    hbc = parseFromFile(open("hbc/hbc74/example/index.android.bundle", "rb"))
-    functionName, paramCount, registerCount, symbolCount, inst, _ = hbc.getFunction(3819)
-
-
+    pass

test.py

@@ -0,0 +1,6 @@
+from hbc import parseFromFile
+import hasm
+
+if __name__ == "__main__":
+    hbc = parseFromFile(open("hbc/hbc74/example/index.android.bundle", "rb"))
+    hasm.dump(hbc, "output/test")