Overhaul IDA script output and add progress waitbox
This commit is contained in:
LukeFZ
@@ -38,13 +38,15 @@ namespace Il2CppInspector.Outputs
|
||||
using var fs = new FileStream(typeHeaderFile, FileMode.Create);
|
||||
_writer = new StreamWriter(fs, Encoding.ASCII);
|
||||
|
||||
const string decompilerIfDef = "#if !defined(_GHIDRA_) && !defined(_IDA_) && !defined(_IDACLANG_)";
|
||||
|
||||
using (_writer)
|
||||
{
|
||||
writeHeader();
|
||||
|
||||
// Write primitive type definitions for when we're not including other headers
|
||||
writeCode($$"""
|
||||
#if defined(_GHIDRA_) || defined(_IDA_)
|
||||
writeCode($"""
|
||||
#if defined(_GHIDRA_) || defined(_IDA_) || defined(_IDACLANG_)
|
||||
typedef unsigned __int8 uint8_t;
|
||||
typedef unsigned __int16 uint16_t;
|
||||
typedef unsigned __int32 uint32_t;
|
||||
@@ -55,13 +57,16 @@ namespace Il2CppInspector.Outputs
|
||||
typedef __int64 int64_t;
|
||||
#endif
|
||||
|
||||
#if defined(_GHIDRA_)
|
||||
typedef __int{{_model.Package.BinaryImage.Bits}} size_t;
|
||||
typedef size_t intptr_t;
|
||||
typedef size_t uintptr_t;
|
||||
#if defined(_GHIDRA_) || defined(_IDACLANG_)
|
||||
typedef int{_model.Package.BinaryImage.Bits}_t intptr_t;
|
||||
typedef uint{_model.Package.BinaryImage.Bits}_t uintptr_t;
|
||||
#endif
|
||||
|
||||
#if !defined(_GHIDRA_) && !defined(_IDA_)
|
||||
#if defined(_GHIDRA_)
|
||||
typedef uint{_model.Package.BinaryImage.Bits}_t size_t;
|
||||
#endif
|
||||
|
||||
{decompilerIfDef}
|
||||
#define _CPLUSPLUS_
|
||||
#endif
|
||||
""");
|
||||
@@ -101,7 +106,7 @@ namespace Il2CppInspector.Outputs
|
||||
}
|
||||
|
||||
// C does not support namespaces
|
||||
writeCode("#if !defined(_GHIDRA_) && !defined(_IDA_)");
|
||||
writeCode($"{decompilerIfDef}");
|
||||
writeCode("namespace app {");
|
||||
writeCode("#endif");
|
||||
writeLine("");
|
||||
@@ -111,7 +116,7 @@ namespace Il2CppInspector.Outputs
|
||||
writeTypesForGroup("Application types from usages", "types_from_usages");
|
||||
writeTypesForGroup("Application unused value types", "unused_concrete_types");
|
||||
|
||||
writeCode("#if !defined(_GHIDRA_) && !defined(_IDA_)");
|
||||
writeCode($"{decompilerIfDef}");
|
||||
writeCode("}");
|
||||
writeCode("#endif");
|
||||
}
|
||||
|
||||
@@ -5,24 +5,18 @@ from ghidra.app.util.cparser.C import CParserUtils
|
||||
from ghidra.program.model.data import ArrayDataType
|
||||
from ghidra.program.model.symbol import SourceType
|
||||
|
||||
def SetName(addr, name):
|
||||
def set_name(addr, name):
|
||||
createLabel(toAddr(addr), name, True)
|
||||
|
||||
def MakeFunction(start, name=None, addrMax=None):
|
||||
def make_function(start, end = None):
|
||||
addr = toAddr(start)
|
||||
# Don't override existing functions
|
||||
fn = getFunctionAt(addr)
|
||||
if fn is not None and name is not None:
|
||||
# Set existing function name if name available
|
||||
fn.setName(name, SourceType.USER_DEFINED)
|
||||
elif fn is None:
|
||||
if fn is None:
|
||||
# Create new function if none exists
|
||||
createFunction(addr, name)
|
||||
# Set header comment if name available
|
||||
if name is not None:
|
||||
setPlateComment(addr, name)
|
||||
createFunction(addr, None)
|
||||
|
||||
def MakeArray(addr, numItems, cppType):
|
||||
def make_array(addr, numItems, cppType):
|
||||
if cppType.startswith('struct '):
|
||||
cppType = cppType[7:]
|
||||
|
||||
@@ -32,18 +26,18 @@ def MakeArray(addr, numItems, cppType):
|
||||
removeDataAt(addr)
|
||||
createData(addr, a)
|
||||
|
||||
def DefineCode(code):
|
||||
def define_code(code):
|
||||
# Code declarations are not supported in Ghidra
|
||||
# This only affects string literals for metadata version < 19
|
||||
# TODO: Replace with creating a DataType for enums
|
||||
pass
|
||||
|
||||
def SetFunctionType(addr, sig):
|
||||
MakeFunction(addr)
|
||||
def set_function_type(addr, sig):
|
||||
make_function(addr)
|
||||
typeSig = CParserUtils.parseSignature(None, currentProgram, sig)
|
||||
ApplyFunctionSignatureCmd(toAddr(addr), typeSig, SourceType.USER_DEFINED, False, True).applyTo(currentProgram)
|
||||
|
||||
def SetType(addr, cppType):
|
||||
def set_type(addr, cppType):
|
||||
if cppType.startswith('struct '):
|
||||
cppType = cppType[7:]
|
||||
|
||||
@@ -52,13 +46,13 @@ def SetType(addr, cppType):
|
||||
removeDataAt(addr)
|
||||
createData(addr, t)
|
||||
|
||||
def SetComment(addr, text):
|
||||
def set_comment(addr, text):
|
||||
setEOLComment(toAddr(addr), text)
|
||||
|
||||
def SetHeaderComment(addr, text):
|
||||
def set_header_comment(addr, text):
|
||||
setPlateComment(toAddr(addr), text)
|
||||
|
||||
def CustomInitializer():
|
||||
def script_prologue(status):
|
||||
# Check that the user has parsed the C headers first
|
||||
if len(getDataTypes('Il2CppObject')) == 0:
|
||||
print('STOP! You must import the generated C header file (%TYPE_HEADER_RELATIVE_PATH%) before running this script.')
|
||||
@@ -70,5 +64,10 @@ def CustomInitializer():
|
||||
if currentProgram.getExecutableFormat().endswith('(ELF)'):
|
||||
currentProgram.setImageBase(toAddr(%IMAGE_BASE%), True)
|
||||
|
||||
def GetScriptDirectory():
|
||||
def script_epilogue(status):
|
||||
pass
|
||||
|
||||
def get_script_directory():
|
||||
return getSourceFile().getParentFile().toString()
|
||||
|
||||
class StatusWrapper(BaseStatusHandler): pass
|
||||
@@ -1,58 +1,174 @@
|
||||
# IDA-specific implementation
|
||||
import idaapi
|
||||
import ida_kernwin
|
||||
import ida_name
|
||||
import ida_idaapi
|
||||
import ida_typeinf
|
||||
import ida_bytes
|
||||
import ida_nalt
|
||||
import ida_ida
|
||||
import ida_ua
|
||||
|
||||
def SetName(addr, name):
|
||||
ret = idc.set_name(addr, name, SN_NOWARN | SN_NOCHECK)
|
||||
if ret == 0:
|
||||
new_name = name + '_' + str(addr)
|
||||
ret = idc.set_name(addr, new_name, SN_NOWARN | SN_NOCHECK)
|
||||
try: # 7.7+
|
||||
import ida_srclang
|
||||
IDACLANG_AVAILABLE = True
|
||||
except ImportError:
|
||||
IDACLANG_AVAILABLE = False
|
||||
|
||||
def MakeFunction(start, name=None, addrMax=None):
|
||||
ida_funcs.add_func(start)
|
||||
#limit end function to maxAddr if any
|
||||
if addrMax is None:
|
||||
import datetime
|
||||
|
||||
def set_name(addr, name):
|
||||
ida_name.set_name(addr, name, ida_name.SN_NOWARN | ida_name.SN_NOCHECK | ida_name.SN_FORCE)
|
||||
|
||||
def make_function(start, end = None):
|
||||
ida_bytes.del_items(start, ida_bytes.DELIT_SIMPLE, 12) # Undefine x bytes which should hopefully be enough for the first instruction
|
||||
ida_ua.create_insn(start) # Create instruction at start
|
||||
if not ida_funcs.add_func(start, end if end is not None else ida_idaapi.BADADDR): # This fails if the function doesn't start with an instruction
|
||||
print(f"failed to mark function {hex(start)}-{hex(end) if end is not None else '???'} as function")
|
||||
|
||||
TYPE_CACHE = {}
|
||||
|
||||
def get_type(typeName):
|
||||
if typeName not in TYPE_CACHE:
|
||||
info = ida_typeinf.idc_parse_decl(None, typeName, ida_typeinf.PT_RAWARGS)
|
||||
if info is None:
|
||||
print(f"Failed to create type {typeName}.")
|
||||
return None
|
||||
|
||||
TYPE_CACHE[typeName] = info[1:]
|
||||
|
||||
return TYPE_CACHE[typeName]
|
||||
|
||||
TINFO_DEFINITE = 0x0001 # These only exist in idc for some reason, so we redefine it here
|
||||
|
||||
def set_type(addr, cppType):
|
||||
cppType += ';'
|
||||
|
||||
info = get_type(cppType)
|
||||
if info is None:
|
||||
return
|
||||
addrEnd = idc.get_func_attr(start,FUNCATTR_END)
|
||||
if addrEnd == idaapi.BADADDR:
|
||||
|
||||
if ida_typeinf.apply_type(None, info[0], info[1], addr, TINFO_DEFINITE) is None:
|
||||
print(f"set_type({hex(addr)}, {cppType}); failed!")
|
||||
|
||||
def set_function_type(addr, sig):
|
||||
set_type(addr, sig)
|
||||
|
||||
def make_array(addr, numItems, cppType):
|
||||
set_type(addr, cppType)
|
||||
|
||||
flags = ida_bytes.get_flags(addr)
|
||||
if ida_bytes.is_struct(flags):
|
||||
opinfo = ida_nalt.opinfo_t()
|
||||
ida_bytes.get_opcode(opinfo, addr, 0, flags)
|
||||
entrySize = ida_bytes.get_data_elsize(addr, flags, opinfo)
|
||||
tid = opinfo.tid
|
||||
else:
|
||||
entrySize = ida_bytes.get_item_size(addr)
|
||||
tid = ida_idaapi.BADADDR
|
||||
|
||||
ida_bytes.create_data(addr, flags, numItems * entrySize, tid)
|
||||
|
||||
def define_code(code):
|
||||
ida_typeinf.idc_parse_types(code)
|
||||
|
||||
def set_comment(addr, comment, repeatable = True):
|
||||
ida_bytes.set_cmt(addr, comment, repeatable)
|
||||
|
||||
def set_header_comment(addr, comment):
|
||||
func = ida_funcs.get_func(addr)
|
||||
if func is None:
|
||||
return
|
||||
if addrEnd > addrMax:
|
||||
idc.set_func_end(start,addrMax)
|
||||
|
||||
def MakeArray(addr, numItems, cppType):
|
||||
SetType(addr, cppType)
|
||||
idc.make_array(addr, numItems)
|
||||
ida_funcs.set_func_cmt(func, comment, True)
|
||||
|
||||
def DefineCode(code):
|
||||
idc.parse_decls(code)
|
||||
cached_genflags = 0
|
||||
|
||||
def SetFunctionType(addr, sig):
|
||||
SetType(addr, sig)
|
||||
def script_prologue(status):
|
||||
global cached_genflags
|
||||
# Disable autoanalysis
|
||||
cached_genflags = ida_ida.inf_get_genflags()
|
||||
ida_ida.inf_set_genflags(cached_genflags & ~ida_ida.INFFL_AUTO)
|
||||
|
||||
def SetType(addr, cppType):
|
||||
if not cppType.endswith(';'):
|
||||
cppType += ';'
|
||||
tinfo = idc.parse_decl(cppType,idaapi.PT_RAWARGS)
|
||||
ret = None
|
||||
if not(tinfo is None):
|
||||
ret = idc.apply_type(addr,tinfo)
|
||||
if ret is None:
|
||||
ret = idc.SetType(addr, cppType)
|
||||
if ret is None:
|
||||
print('SetType(0x%x, %r) failed!' % (addr, cppType))
|
||||
# Unload type libraries we know to cause issues - like the c++ linux one
|
||||
PLATFORMS = ["x86", "x64", "arm", "arm64"]
|
||||
PROBLEMATIC_TYPELIBS = ["gnulnx"]
|
||||
|
||||
def SetComment(addr, text):
|
||||
idc.set_cmt(addr, text, 1)
|
||||
for lib in PROBLEMATIC_TYPELIBS:
|
||||
for platform in PLATFORMS:
|
||||
ida_typeinf.del_til(f"{lib}_{platform}")
|
||||
|
||||
def SetHeaderComment(addr, text):
|
||||
SetComment(addr, text)
|
||||
# Set name mangling to GCC 3.x and display demangled as default
|
||||
ida_ida.inf_set_demnames(ida_ida.DEMNAM_GCC3 | ida_ida.DEMNAM_NAME)
|
||||
|
||||
def CustomInitializer():
|
||||
print('Processing Types')
|
||||
status.update_step('Processing Types')
|
||||
|
||||
original_macros = ida_typeinf.get_c_macros()
|
||||
ida_typeinf.set_c_macros(original_macros + ";_IDA_=1")
|
||||
idc.parse_decls(os.path.join(GetScriptDirectory(), "%TYPE_HEADER_RELATIVE_PATH%"), idc.PT_FILE)
|
||||
ida_typeinf.set_c_macros(original_macros)
|
||||
if IDACLANG_AVAILABLE:
|
||||
header_path = os.path.join(get_script_directory(), "%TYPE_HEADER_RELATIVE_PATH%")
|
||||
ida_srclang.set_parser_argv("clang", "-x c++ -D_IDACLANG_=1")
|
||||
ida_srclang.parse_decls_with_parser("clang", None, header_path, True)
|
||||
else:
|
||||
original_macros = ida_typeinf.get_c_macros()
|
||||
ida_typeinf.set_c_macros(original_macros + ";_IDA_=1")
|
||||
ida_typeinf.idc_parse_types(os.path.join(get_script_directory(), "%TYPE_HEADER_RELATIVE_PATH%"), ida_typeinf.PT_FILE)
|
||||
ida_typeinf.set_c_macros(original_macros)
|
||||
|
||||
def GetScriptDirectory():
|
||||
def script_epilogue(status):
|
||||
# Reenable auto-analysis
|
||||
global cached_genflags
|
||||
ida_ida.inf_set_genflags(cached_genflags)
|
||||
|
||||
def get_script_directory():
|
||||
return os.path.dirname(os.path.realpath(__file__))
|
||||
|
||||
class StatusHandler(BaseStatusHandler):
|
||||
def __init__(self):
|
||||
self.step = "Initializing"
|
||||
self.max_items = 0
|
||||
self.current_items = 0
|
||||
self.start_time = datetime.datetime.now()
|
||||
self.step_start_time = self.start_time
|
||||
self.last_updated_time = datetime.datetime.min
|
||||
|
||||
def initialize(self):
|
||||
ida_kernwin.show_wait_box("Processing")
|
||||
|
||||
def update(self):
|
||||
if self.was_cancelled():
|
||||
raise RuntimeError("Cancelled script.")
|
||||
|
||||
current_time = datetime.datetime.now()
|
||||
if 0.5 > (current_time - self.last_updated_time).total_seconds():
|
||||
return
|
||||
|
||||
self.last_updated_time = current_time
|
||||
|
||||
step_time = current_time - self.step_start_time
|
||||
total_time = current_time - self.start_time
|
||||
message = f"""
|
||||
Running IL2CPP script.
|
||||
Current Step: {self.step}
|
||||
Progress: {self.current_items}/{self.max_items}
|
||||
Elapsed: {step_time} ({total_time})
|
||||
"""
|
||||
|
||||
ida_kernwin.replace_wait_box(message)
|
||||
|
||||
def update_step(self, step, max_items = 0):
|
||||
print(step)
|
||||
|
||||
self.step = step
|
||||
self.max_items = max_items
|
||||
self.current_items = 0
|
||||
self.step_start_time = datetime.datetime.now()
|
||||
self.last_updated_time = datetime.datetime.min
|
||||
self.update()
|
||||
|
||||
def update_progress(self, new_progress = 1):
|
||||
self.current_items += new_progress
|
||||
self.update()
|
||||
|
||||
def was_cancelled(self):
|
||||
return ida_kernwin.user_cancelled()
|
||||
|
||||
def close(self):
|
||||
ida_kernwin.hide_wait_box()
|
||||
@@ -1,155 +1,177 @@
|
||||
# Shared interface
|
||||
def AsUTF8(s):
|
||||
return s if sys.version_info[0] > 2 else s.encode('utf-8')
|
||||
def from_hex(addr): return int(addr, 0)
|
||||
|
||||
def ParseAddress(d):
|
||||
return int(d['virtualAddress'], 0)
|
||||
def parse_address(d): return from_hex(d['virtualAddress'])
|
||||
|
||||
def DefineILMethod(jsonDef):
|
||||
addr = ParseAddress(jsonDef)
|
||||
SetName(addr, AsUTF8(jsonDef['name']))
|
||||
SetFunctionType(addr, AsUTF8(jsonDef['signature']))
|
||||
SetHeaderComment(addr, AsUTF8(jsonDef['dotNetSignature']))
|
||||
def define_il_method(jsonDef):
|
||||
addr = parse_address(jsonDef)
|
||||
set_name(addr, jsonDef['name'])
|
||||
set_function_type(addr, jsonDef['signature'])
|
||||
set_header_comment(addr, jsonDef['dotNetSignature'])
|
||||
|
||||
def DefineILMethodInfo(jsonDef):
|
||||
addr = ParseAddress(jsonDef)
|
||||
SetName(addr, AsUTF8(jsonDef['name']))
|
||||
SetType(addr, r'struct MethodInfo *')
|
||||
SetComment(addr, AsUTF8(jsonDef['dotNetSignature']))
|
||||
def define_il_method_info(jsonDef):
|
||||
addr = parse_address(jsonDef)
|
||||
set_name(addr, jsonDef['name'])
|
||||
set_type(addr, r'struct MethodInfo *')
|
||||
set_comment(addr, jsonDef['dotNetSignature'])
|
||||
|
||||
def DefineCppFunction(jsonDef):
|
||||
addr = ParseAddress(jsonDef)
|
||||
SetName(addr, AsUTF8(jsonDef['name']))
|
||||
SetFunctionType(addr, AsUTF8(jsonDef['signature']))
|
||||
def define_cpp_function(jsonDef):
|
||||
addr = parse_address(jsonDef)
|
||||
set_name(addr, jsonDef['name'])
|
||||
set_function_type(addr, jsonDef['signature'])
|
||||
|
||||
def DefineString(jsonDef):
|
||||
addr = ParseAddress(jsonDef)
|
||||
SetName(addr, AsUTF8(jsonDef['name']))
|
||||
SetType(addr, r'struct String *')
|
||||
SetComment(addr, AsUTF8(jsonDef['string']))
|
||||
def define_string(jsonDef):
|
||||
addr = parse_address(jsonDef)
|
||||
set_name(addr, jsonDef['name'])
|
||||
set_type(addr, r'struct String *')
|
||||
set_comment(addr, jsonDef['string'])
|
||||
|
||||
def DefineFieldFromJson(jsonDef):
|
||||
DefineField(jsonDef['virtualAddress'], jsonDef['name'], jsonDef['type'], jsonDef['dotNetType'])
|
||||
def define_field(addr, name, type, ilType = None):
|
||||
addr = from_hex(addr)
|
||||
set_name(addr, name)
|
||||
set_type(addr, type)
|
||||
if ilType is not None:
|
||||
set_comment(addr, ilType)
|
||||
|
||||
def DefineField(addr, name, type, ilType = None):
|
||||
addr = int(addr, 0)
|
||||
SetName(addr, AsUTF8(name))
|
||||
SetType(addr, AsUTF8(type))
|
||||
if (ilType is not None):
|
||||
SetComment(addr, AsUTF8(ilType))
|
||||
def define_field_from_json(jsonDef):
|
||||
define_field(jsonDef['virtualAddress'], jsonDef['name'], jsonDef['type'], jsonDef['dotNetType'])
|
||||
|
||||
def DefineArray(jsonDef):
|
||||
addr = ParseAddress(jsonDef)
|
||||
MakeArray(addr, int(jsonDef['count']), AsUTF8(jsonDef['type']))
|
||||
SetName(addr, AsUTF8(jsonDef['name']))
|
||||
def define_array(jsonDef):
|
||||
addr = parse_address(jsonDef)
|
||||
make_array(addr, int(jsonDef['count']), jsonDef['type'])
|
||||
set_name(addr, jsonDef['name'])
|
||||
|
||||
def DefineFieldWithValue(jsonDef):
|
||||
addr = ParseAddress(jsonDef)
|
||||
SetName(addr, AsUTF8(jsonDef['name']))
|
||||
SetComment(addr, AsUTF8(jsonDef['value']))
|
||||
def define_field_with_value(jsonDef):
|
||||
addr = parse_address(jsonDef)
|
||||
set_name(addr, jsonDef['name'])
|
||||
set_comment(addr, jsonDef['value'])
|
||||
|
||||
# Process JSON
|
||||
def ProcessJSON(jsonData):
|
||||
|
||||
# Method definitions
|
||||
print('Processing method definitions')
|
||||
for d in jsonData['methodDefinitions']:
|
||||
DefineILMethod(d)
|
||||
|
||||
# Constructed generic methods
|
||||
print('Processing constructed generic methods')
|
||||
for d in jsonData['constructedGenericMethods']:
|
||||
DefineILMethod(d)
|
||||
|
||||
# Custom attributes generators
|
||||
print('Processing custom attributes generators')
|
||||
for d in jsonData['customAttributesGenerators']:
|
||||
DefineCppFunction(d)
|
||||
|
||||
# Method.Invoke thunks
|
||||
print('Processing Method.Invoke thunks')
|
||||
for d in jsonData['methodInvokers']:
|
||||
DefineCppFunction(d)
|
||||
|
||||
# String literals for version >= 19
|
||||
print('Processing string literals')
|
||||
if 'virtualAddress' in jsonData['stringLiterals'][0]:
|
||||
for d in jsonData['stringLiterals']:
|
||||
DefineString(d)
|
||||
|
||||
# String literals for version < 19
|
||||
else:
|
||||
litDecl = 'enum StringLiteralIndex {\n'
|
||||
for d in jsonData['stringLiterals']:
|
||||
litDecl += " " + AsUTF8(d['name']) + ",\n"
|
||||
litDecl += '};\n'
|
||||
DefineCode(litDecl)
|
||||
|
||||
# Il2CppClass (TypeInfo) pointers
|
||||
print('Processing Il2CppClass (TypeInfo) pointers')
|
||||
for d in jsonData['typeInfoPointers']:
|
||||
DefineFieldFromJson(d)
|
||||
|
||||
# Il2CppType (TypeRef) pointers
|
||||
print('Processing Il2CppType (TypeRef) pointers')
|
||||
for d in jsonData['typeRefPointers']:
|
||||
DefineField(d['virtualAddress'], d['name'], r'struct Il2CppType *', d['dotNetType'])
|
||||
|
||||
# MethodInfo pointers
|
||||
print('Processing MethodInfo pointers')
|
||||
for d in jsonData['methodInfoPointers']:
|
||||
DefineILMethodInfo(d)
|
||||
|
||||
# FieldInfo pointers, add the contents as a comment
|
||||
print('Processing FieldInfo pointers')
|
||||
for d in jsonData['fields']:
|
||||
DefineFieldWithValue(d)
|
||||
|
||||
# FieldRva pointers, add the contents as a comment
|
||||
print('Processing FieldRva pointers')
|
||||
for d in jsonData['fieldRvas']:
|
||||
DefineFieldWithValue(d)
|
||||
|
||||
def process_json(jsonData, status):
|
||||
# Function boundaries
|
||||
print('Processing function boundaries')
|
||||
functionAddresses = jsonData['functionAddresses']
|
||||
functionAddresses.sort()
|
||||
count = len(functionAddresses)
|
||||
|
||||
status.update_step('Processing function boundaries', count)
|
||||
for i in range(count):
|
||||
addrStart = int(functionAddresses[i],0)
|
||||
if addrStart == 0:
|
||||
start = from_hex(functionAddresses[i])
|
||||
if start == 0:
|
||||
status.update_progress()
|
||||
continue
|
||||
addrNext = None
|
||||
if i != count -1:
|
||||
addrNext = int(functionAddresses[i+1],0)
|
||||
MakeFunction(addrStart,None,addrNext)
|
||||
|
||||
end = from_hex(functionAddresses[i + 1]) if i + 1 != count else None
|
||||
|
||||
make_function(start, end)
|
||||
status.update_progress()
|
||||
|
||||
# Method definitions
|
||||
status.update_step('Processing method definitions', len(jsonData['methodDefinitions']))
|
||||
for d in jsonData['methodDefinitions']:
|
||||
define_il_method(d)
|
||||
status.update_progress()
|
||||
|
||||
# Constructed generic methods
|
||||
status.update_step('Processing constructed generic methods', len(jsonData['constructedGenericMethods']))
|
||||
for d in jsonData['constructedGenericMethods']:
|
||||
define_il_method(d)
|
||||
status.update_progress()
|
||||
|
||||
# Custom attributes generators
|
||||
status.update_step('Processing custom attributes generators', len(jsonData['customAttributesGenerators']))
|
||||
for d in jsonData['customAttributesGenerators']:
|
||||
define_cpp_function(d)
|
||||
status.update_progress()
|
||||
|
||||
# Method.Invoke thunks
|
||||
status.update_step('Processing Method.Invoke thunks', len(jsonData['methodInvokers']))
|
||||
for d in jsonData['methodInvokers']:
|
||||
define_cpp_function(d)
|
||||
status.update_progress()
|
||||
|
||||
# String literals for version >= 19
|
||||
if 'virtualAddress' in jsonData['stringLiterals'][0]:
|
||||
status.update_step('Processing string literals (V19+)', len(jsonData['stringLiterals']))
|
||||
for d in jsonData['stringLiterals']:
|
||||
define_string(d)
|
||||
status.update_progress()
|
||||
|
||||
# String literals for version < 19
|
||||
else:
|
||||
status.update_step('Processing string literals (pre-V19)')
|
||||
litDecl = 'enum StringLiteralIndex {\n'
|
||||
for d in jsonData['stringLiterals']:
|
||||
litDecl += " " + d['name'] + ",\n"
|
||||
litDecl += '};\n'
|
||||
define_code(litDecl)
|
||||
|
||||
# Il2CppClass (TypeInfo) pointers
|
||||
status.update_step('Processing Il2CppClass (TypeInfo) pointers', len(jsonData['typeInfoPointers']))
|
||||
for d in jsonData['typeInfoPointers']:
|
||||
define_field_from_json(d)
|
||||
status.update_progress()
|
||||
|
||||
# Il2CppType (TypeRef) pointers
|
||||
status.update_step('Processing Il2CppType (TypeRef) pointers', len(jsonData['typeRefPointers']))
|
||||
for d in jsonData['typeRefPointers']:
|
||||
define_field(d['virtualAddress'], d['name'], r'struct Il2CppType *', d['dotNetType'])
|
||||
status.update_progress()
|
||||
|
||||
# MethodInfo pointers
|
||||
status.update_step('Processing MethodInfo pointers', len(jsonData['methodInfoPointers']))
|
||||
for d in jsonData['methodInfoPointers']:
|
||||
define_il_method_info(d)
|
||||
status.update_progress()
|
||||
|
||||
# FieldInfo pointers, add the contents as a comment
|
||||
status.update_step('Processing FieldInfo pointers', len(jsonData['fields']))
|
||||
for d in jsonData['fields']:
|
||||
define_field_with_value(d)
|
||||
status.update_progress()
|
||||
|
||||
# FieldRva pointers, add the contents as a comment
|
||||
status.update_step('Processing FieldRva pointers', len(jsonData['fieldRvas']))
|
||||
for d in jsonData['fieldRvas']:
|
||||
define_field_with_value(d)
|
||||
status.update_progress()
|
||||
|
||||
# IL2CPP type metadata
|
||||
print('Processing IL2CPP type metadata')
|
||||
status.update_step('Processing IL2CPP type metadata', len(jsonData['typeMetadata']))
|
||||
for d in jsonData['typeMetadata']:
|
||||
DefineField(d['virtualAddress'], d['name'], d['type'])
|
||||
define_field(d['virtualAddress'], d['name'], d['type'])
|
||||
|
||||
# IL2CPP function metadata
|
||||
print('Processing IL2CPP function metadata')
|
||||
status.update_step('Processing IL2CPP function metadata', len(jsonData['functionMetadata']))
|
||||
for d in jsonData['functionMetadata']:
|
||||
DefineCppFunction(d)
|
||||
define_cpp_function(d)
|
||||
|
||||
# IL2CPP array metadata
|
||||
print('Processing IL2CPP array metadata')
|
||||
status.update_step('Processing IL2CPP array metadata', len(jsonData['arrayMetadata']))
|
||||
for d in jsonData['arrayMetadata']:
|
||||
DefineArray(d)
|
||||
define_array(d)
|
||||
|
||||
# IL2CPP API functions
|
||||
print('Processing IL2CPP API functions')
|
||||
status.update_step('Processing IL2CPP API functions', len(jsonData['apis']))
|
||||
for d in jsonData['apis']:
|
||||
DefineCppFunction(d)
|
||||
define_cpp_function(d)
|
||||
|
||||
# Entry point
|
||||
print('Generated script file by Il2CppInspector - http://www.djkaty.com - https://github.com/djkaty')
|
||||
CustomInitializer()
|
||||
print('Generated script file by Il2CppInspectorRedux - https://github.com/LukeFZ (Original Il2CppInspector by http://www.djkaty.com - https://github.com/djkaty)')
|
||||
status = StatusHandler()
|
||||
status.initialize()
|
||||
|
||||
with open(os.path.join(GetScriptDirectory(), "%JSON_METADATA_RELATIVE_PATH%"), "r") as jsonFile:
|
||||
jsonData = json.load(jsonFile)['addressMap']
|
||||
ProcessJSON(jsonData)
|
||||
try:
|
||||
status.update_step("Running script prologue")
|
||||
script_prologue(status)
|
||||
|
||||
print('Script execution complete.')
|
||||
with open(os.path.join(get_script_directory(), "%JSON_METADATA_RELATIVE_PATH%"), "r") as jsonFile:
|
||||
status.update_step("Loading JSON metadata")
|
||||
jsonData = json.load(jsonFile)['addressMap']
|
||||
process_json(jsonData, status)
|
||||
|
||||
status.update_step("Running script epilogue")
|
||||
script_epilogue(status)
|
||||
|
||||
status.update_step('Script execution complete.')
|
||||
except RuntimeError: pass
|
||||
finally: status.close()
|
||||
|
||||
@@ -1,6 +1,13 @@
|
||||
# Generated script file by Il2CppInspector - http://www.djkaty.com - https://github.com/djkaty
|
||||
# Generated script file by Il2CppInspectorRedux - https://github.com/LukeFZ (Original Il2CppInspector by http://www.djkaty.com - https://github.com/djkaty)
|
||||
# Target Unity version: %TARGET_UNITY_VERSION%
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
class BaseStatusHandler:
|
||||
def initialize(self): pass
|
||||
def update_step(self, name, max_items = 0): print(name)
|
||||
def update_progress(self, progress = 1): pass
|
||||
def was_cancelled(self): return False
|
||||
def close(self): pass
|
||||
|
||||
Reference in New Issue
Block a user