Hool mod

local LibNameUnityOnly ="libil2cpp.so"
local __bundle_require, __bundle_loaded, __bundle_register, __bundle_modules = (function(superRequire)
local loadingPlaceholder = {[{}] = true}
local register
local modules = {}
local require
local loaded = {}
register = function(name, body)
if not modules[name] then
modules[name] = body
end
end
require = function(name)
local loadedModule = loaded[name]
if loadedModule then
if loadedModule == loadingPlaceholder then
return nil
end
else
if not modules[name] then
if not superRequire then
local identifier = type(name) == 'string' and '\"' .. name .. '\"' or tostring(name)
error('Tried to require ' .. identifier .. ', but no such module has been registered')
else
return superRequire(name)
end
end
loaded[name] = loadingPlaceholder
loadedModule = modules[name](require, loaded, register, modules)
loaded[name] = loadedModule
end
return loadedModule
end
return require, loaded, register, modules
end)(require)
__bundle_register("GGIl2cpp", function(require, _LOADED, __bundle_register, __bundle_modules)
require("utils.il2cppconst")
require("il2cpp")
return Il2cpp
end)
__bundle_register("il2cpp", function(require, _LOADED, __bundle_register, __bundle_modules)
local Il2cppMemory = require("utils.il2cppmemory")
local VersionEngine = require("utils.version")
local AndroidInfo = require("utils.androidinfo")
local Searcher = require("utils.universalsearcher")
local PatchApi = require("utils.patchapi")
local Il2cppBase = {
il2cppStart = 0,
il2cppEnd = 0,
globalMetadataStart = 0,
globalMetadataEnd = 0,
globalMetadataHeader = 0,
MainType = AndroidInfo.platform and gg.TYPE_QWORD or gg.TYPE_DWORD,
pointSize = AndroidInfo.platform and 8 or 4,
Il2CppTypeDefinitionApi = {},
MetadataRegistrationApi = require("il2cppstruct.metadataRegistration"),
TypeApi = require("il2cppstruct.type"),
MethodsApi = require("il2cppstruct.method"),
GlobalMetadataApi = require("il2cppstruct.globalmetadata"),
FieldApi = require("il2cppstruct.field"),
ClassApi = require("il2cppstruct.class"),
ObjectApi = require("il2cppstruct.object"),
ClassInfoApi = require("il2cppstruct.api.classinfo"),
FieldInfoApi = require("il2cppstruct.api.fieldinfo"),
String = require("il2cppstruct.il2cppstring"),
MemoryManager = require("utils.malloc"),
PatchesAddress = function(add, Bytescodes)
local patchCode = {}
for code in string.gmatch(Bytescodes, '.') do
patchCode[#patchCode + 1] = {
address = add + #patchCode,
value = string.byte(code),
flags = gg.TYPE_BYTE
}
end
local patch = PatchApi:Create(patchCode)
patch:Patch()
return patch
end,
FindMethods = function(searchParams)
Il2cppMemory:SaveResults()
for i = 1, #searchParams do
searchParams[i] = Il2cpp.MethodsApi:Find(searchParams[i])
end
Il2cppMemory:ClearSavedResults()
return searchParams
end,
FindClass = function(searchParams)
Il2cppMemory:SaveResults()
for i = 1, #searchParams do
searchParams[i] = Il2cpp.ClassApi:Find(searchParams[i])
end
Il2cppMemory:ClearSavedResults()
return searchParams
end,
FindObject = function(searchParams)
Il2cppMemory:SaveResults()
for i = 1, #searchParams do
searchParams[i] = Il2cpp.ObjectApi:Find(Il2cpp.ClassApi:Find({Class = searchParams[i]}))
end
Il2cppMemory:ClearSavedResults()
return searchParams
end,
FindFields = function(searchParams)
Il2cppMemory:SaveResults()
for i = 1, #searchParams do
local searchParam = searchParams[i]
local searchResult = Il2cppMemory:GetInformationOfField(searchParam)
if not searchResult then
searchResult = Il2cpp.FieldApi:Find(searchParam)
Il2cppMemory:SetInformationOfField(searchParam, searchResult)
end
searchParams[i] = searchResult
end
Il2cppMemory:ClearSavedResults()
return searchParams
end,
Utf8ToString = function(Address, length)
local chars, char = {}, {
address = Address,
flags = gg.TYPE_BYTE
}
if not length then
repeat
_char = string.char(gg.getValues({char})[1].value & 0xFF)
chars[#chars + 1] = _char
char.address = char.address + 0x1
until string.find(_char, "[%z%s]")
return table.concat(chars, "", 1, #chars - 1)
else
for i = 1, length do
local _char = gg.getValues({char})[1].value
chars[i] = string.char(_char & 0xFF)
char.address = char.address + 0x1
end
return table.concat(chars)
end
end,
ChangeBytesOrder = function(bytes)
local newBytes, index, lenBytes = {}, 0, #bytes / 2
for byte in string.gmatch(bytes, "..") do
newBytes[lenBytes - index] = byte
index = index + 1
end
return table.concat(newBytes)
end,
FixValue = function(val)
return AndroidInfo.platform and val & 0x00FFFFFFFFFFFFFF or val & 0xFFFFFFFF
end,
GetValidAddress = function(Address)
local lastByte = Address & 0x000000000000000F
local delta = 0
local checkTable = {[12] = true, [4] = true, [8] = true, [0] = true}
while not checkTable[lastByte - delta] do
delta = delta + 1
end
return Address - delta
end,
SearchPointer = function(self, address)
address = self.ChangeBytesOrder(type(address) == 'number' and string.format('%X', address) or address)
gg.searchNumber('h ' .. address)
gg.refineNumber('h ' .. address:sub(1, 6))
gg.refineNumber('h ' .. address:sub(1, 2))
local FindsResult = gg.getResults(gg.getResultsCount())
gg.clearResults()
return FindsResult
end,
}
Il2cpp = setmetatable({}, {
__call = function(self, config)
config = config or {}
getmetatable(self).__index = Il2cppBase
if config.libilcpp then
self.il2cppStart, self.il2cppEnd = config.libilcpp.start, config.libilcpp['end']
else
self.il2cppStart, self.il2cppEnd = Searcher.FindIl2cpp()
end
if config.globalMetadata then
self.globalMetadataStart, self.globalMetadataEnd = config.globalMetadata.start, config.globalMetadata['end']
else
self.globalMetadataStart, self.globalMetadataEnd = Searcher:FindGlobalMetaData()
end
if config.globalMetadataHeader then
self.globalMetadataHeader = config.globalMetadataHeader
else
self.globalMetadataHeader = self.globalMetadataStart
end
self.MetadataRegistrationApi.metadataRegistration = config.metadataRegistration
VersionEngine:ChooseVersion(config.il2cppVersion, self.globalMetadataHeader)
Il2cppMemory:ClearMemorize()
end,
__index = function(self, key)
assert(key == "PatchesAddress", "You didn't call 'Il2cpp'")
return Il2cppBase[key]
end
})
return Il2cpp
end)
__bundle_register("utils.malloc", function(require, _LOADED, __bundle_register, __bundle_modules)
local MemoryManager = {
availableMemory = 0,
lastAddress = 0,
NewAlloc = function(self)
self.lastAddress = gg.allocatePage(gg.PROT_READ | gg.PROT_WRITE)
self.availableMemory = 4096
end,
}
local M = {
MAlloc = function(size)
local manager = MemoryManager
if size > manager.availableMemory then
manager:NewAlloc()
end
local address = manager.lastAddress
manager.availableMemory = manager.availableMemory - size
manager.lastAddress = manager.lastAddress + size
return address
end,
}
return M
end)
__bundle_register("il2cppstruct.il2cppstring", function(require, _LOADED, __bundle_register, __bundle_modules)
local StringApi = {
EditString = function(self, newStr)
local _stringLength = gg.getValues{{address = self.address + self.Fields._stringLength, flags = gg.TYPE_DWORD}}[1].value
_stringLength = _stringLength * 2
local bytes = gg.bytes(newStr, "UTF-16LE")
if _stringLength == #bytes then
local strStart = self.address + self.Fields._firstChar
for i, v in ipairs(bytes) do
bytes[i] = {
address = strStart + (i - 1),
flags = gg.TYPE_BYTE,
value = v
}
end
gg.setValues(bytes)
elseif _stringLength > #bytes then
local strStart = self.address + self.Fields._firstChar
local _bytes = {}
for i = 1, _stringLength do
_bytes[#_bytes + 1] = {
address = strStart + (i - 1),
flags = gg.TYPE_BYTE,
value = bytes[i] or 0
}
end
gg.setValues(_bytes)
elseif _stringLength < #bytes then
self.address = Il2cpp.MemoryManager.MAlloc(self.Fields._firstChar + #bytes + 8)
local length = #bytes % 2 == 1 and #bytes + 1 or #bytes
local _bytes = {
{ address = self.address,
flags = Il2cpp.MainType,
value = self.ClassAddress
},
{ address = self.address + self.Fields._stringLength,
flags = gg.TYPE_DWORD,
value = length / 2
}
}
local strStart = self.address + self.Fields._firstChar
for i = 1, length do
_bytes[#_bytes + 1] = {
address = strStart + (i - 1),
flags = gg.TYPE_BYTE,
value = bytes[i] or 0
}
end
_bytes[#_bytes + 1] = {
address = self.pointToStr,
flags = Il2cpp.MainType,
value = self.address
}
gg.setValues(_bytes)
end
end,
ReadString = function(self)
local _stringLength = gg.getValues{{address = self.address + self.Fields._stringLength, flags = gg.TYPE_DWORD}}[1].value
local bytes = {}
if _stringLength > 0 and _stringLength < 200 then
local strStart = self.address + self.Fields._firstChar
for i = 0, _stringLength do
bytes[#bytes + 1] = {
address = strStart + (i << 1),
flags = gg.TYPE_WORD
}
end
bytes = gg.getValues(bytes)
local code = {[[return "]]}
for i, v in ipairs(bytes) do
code[#code + 1] = string.format([[\u{%x}]], v.value & 0xFFFF)
end
code[#code + 1] = '"'
local read, err = load(table.concat(code))
if read then
return read()
end
end
return ""
end
}
local String = {
From = function(address)
local pointToStr = gg.getValues({{address = Il2cpp.FixValue(address), flags = Il2cpp.MainType}})[1]
local str = setmetatable(
{
address = Il2cpp.FixValue(pointToStr.value),
Fields = {},
pointToStr = Il2cpp.FixValue(address)
}, {__index = StringApi})
local pointClassAddress = gg.getValues({{address = str.address, flags = Il2cpp.MainType}})[1].value
local stringInfo = Il2cpp.FindClass({{Class = Il2cpp.FixValue(pointClassAddress), FieldsDump = true}})[1]
for i, v in ipairs(stringInfo) do
if v.ClassNameSpace == "System" then
str.ClassAddress = tonumber(v.ClassAddress, 16)
for indexField, FieldInfo in ipairs(v.Fields) do
str.Fields[FieldInfo.FieldName] = tonumber(FieldInfo.Offset, 16)
end
return str
end
end
return nil
end,
}
return String
end)
__bundle_register("il2cppstruct.api.fieldinfo", function(require, _LOADED, __bundle_register, __bundle_modules)
local Il2cppMemory = require("utils.il2cppmemory")
local FieldInfoApi = {
GetConstValue = function(self)
if self.IsConst then
local fieldIndex = getmetatable(self).fieldIndex
local defaultValue = Il2cppMemory:GetDefaultValue(fieldIndex)
if not defaultValue then
defaultValue = Il2cpp.GlobalMetadataApi:GetDefaultFieldValue(fieldIndex)
Il2cppMemory:SetDefaultValue(fieldIndex, defaultValue)
elseif defaultValue == "nil" then
return nil
end
return defaultValue
end
return nil
end
}
return FieldInfoApi
end)
__bundle_register("utils.il2cppmemory", function(require, _LOADED, __bundle_register, __bundle_modules)
local Il2cppMemory = {
Methods = {},
Classes = {},
Fields = {},
DefaultValues = {},
Results = {},
Types = {},
GetInformationOfType = function(self, index)
return self.Types[index]
end,
SetInformationOfType = function(self, index, typeName)
self.Types[index] = typeName
end,
SaveResults = function(self)
if gg.getResultsCount() > 0 then
self.Results = gg.getResults(gg.getResultsCount())
end
end,
ClearSavedResults = function(self)
self.Results = {}
end,
GetDefaultValue = function(self, fieldIndex)
return self.DefaultValues[fieldIndex]
end,
SetDefaultValue = function(self, fieldIndex, defaultValue)
self.DefaultValues[fieldIndex] = defaultValue or "nil"
end,
GetInformationOfField = function(self, searchParam)
return self.Fields[searchParam]
end,
SetInformationOfField = function(self, searchParam, searchResult)
if not searchResult.Error then
self.Fields[searchParam] = searchResult
end
end,
GetInformaionOfMethod = function(self, searchParam)
return self.Methods[searchParam]
end,
SetInformaionOfMethod = function(self, searchParam, searchResult)
if not searchResult.Error then
self.Methods[searchParam] = searchResult
end
end,
GetInformationOfClass = function(self, searchParam)
return self.Classes[searchParam]
end,
SetInformationOfClass = function(self, searchParam, searchResult)
self.Classes[searchParam] = searchResult
end,
ClearMemorize = function(self)
self.Methods = {}
self.Classes = {}
self.Fields = {}
self.DefaultValues = {}
self.Results = {}
self.Types = {}
end
}
return Il2cppMemory
end)
__bundle_register("il2cppstruct.api.classinfo", function(require, _LOADED, __bundle_register, __bundle_modules)
local ClassInfoApi = {
GetFieldWithName = function(self, name)
local FieldsInfo = self.Fields
if FieldsInfo then
for fieldIndex = 1, #FieldsInfo do
if FieldsInfo[fieldIndex].FieldName == name then
return FieldsInfo[fieldIndex]
end
end
else
local ClassAddress = tonumber(self.ClassAddress, 16)
local _ClassInfo = gg.getValues({
{ address = ClassAddress + Il2cpp.ClassApi.FieldsLink,
flags = Il2cpp.MainType
},
{ address = ClassAddress + Il2cpp.ClassApi.CountFields,
flags = gg.TYPE_WORD
}
})
self.Fields = Il2cpp.ClassApi:GetClassFields(Il2cpp.FixValue(_ClassInfo[1].value), _ClassInfo[2].value, {
ClassName = self.ClassName,
IsEnum = self.IsEnum,
TypeMetadataHandle = self.TypeMetadataHandle
})
return self:GetFieldWithName(name)
end
return nil
end,
GetMethodsWithName = function(self, name)
local MethodsInfo, MethodsInfoResult = self.Methods, {}
if MethodsInfo then
for methodIndex = 1, #MethodsInfo do
if MethodsInfo[methodIndex].MethodName == name then
MethodsInfoResult[#MethodsInfoResult + 1] = MethodsInfo[methodIndex]
end
end
return MethodsInfoResult
else
local ClassAddress = tonumber(self.ClassAddress, 16)
local _ClassInfo = gg.getValues({
{ address = ClassAddress + Il2cpp.ClassApi.MethodsLink,
flags = Il2cpp.MainType
},
{ address = ClassAddress + Il2cpp.ClassApi.CountMethods,
flags = gg.TYPE_WORD
}
})
self.Methods = Il2cpp.ClassApi:GetClassMethods(Il2cpp.FixValue(_ClassInfo[1].value), _ClassInfo[2].value,
self.ClassName)
return self:GetMethodsWithName(name)
end
end,
GetFieldWithOffset = function(self, fieldOffset)
if not self.Fields then
local ClassAddress = tonumber(self.ClassAddress, 16)
local _ClassInfo = gg.getValues({
{ address = ClassAddress + Il2cpp.ClassApi.FieldsLink,
flags = Il2cpp.MainType
},
{ address = ClassAddress + Il2cpp.ClassApi.CountFields,
flags = gg.TYPE_WORD
}
})
self.Fields = Il2cpp.ClassApi:GetClassFields(Il2cpp.FixValue(_ClassInfo[1].value), _ClassInfo[2].value, {
ClassName = self.ClassName,
IsEnum = self.IsEnum,
TypeMetadataHandle = self.TypeMetadataHandle
})
end
if #self.Fields > 0 then
local klass = self
while klass ~= nil do
if klass.Fields and klass.InstanceSize >= fieldOffset then
local lastField
for indexField, field in ipairs(klass.Fields) do
if not (field.IsStatic or field.IsConst) then
local offset = tonumber(field.Offset, 16)
if offset > 0 then
local maybeStruct = fieldOffset < offset
if indexField == 1 and maybeStruct then
break
elseif offset == fieldOffset or indexField == #klass.Fields then
return field
elseif maybeStruct then
return lastField
else
lastField = field
end
end
end
end
end
klass = klass.Parent ~= nil
and Il2cpp.FindClass({
{
Class = tonumber(klass.Parent.ClassAddress, 16),
FieldsDump = true
}
})[1][1]
or nil
end
end
return nil
end
}
return ClassInfoApi
end)
__bundle_register("il2cppstruct.object", function(require, _LOADED, __bundle_register, __bundle_modules)
local AndroidInfo = require("utils.androidinfo")
local ObjectApi = {
FilterObjects = function(self, Objects)
local FilterObjects = {}
for k, v in ipairs(gg.getValuesRange(Objects)) do
if v == 'A' then
FilterObjects[#FilterObjects + 1] = Objects[k]
end
end
Objects = FilterObjects
gg.loadResults(Objects)
gg.searchPointer(0)
if gg.getResultsCount() <= 0 and AndroidInfo.platform and AndroidInfo.sdk >= 30 then
local FixRefToObjects = {}
for k, v in ipairs(Objects) do
gg.searchNumber(tostring(v.address | 0xB400000000000000), gg.TYPE_QWORD)
local RefToObject = gg.getResults(gg.getResultsCount())
table.move(RefToObject, 1, #RefToObject, #FixRefToObjects + 1, FixRefToObjects)
gg.clearResults()
end
gg.loadResults(FixRefToObjects)
end
local RefToObjects, FilterObjects = gg.getResults(gg.getResultsCount()), {}
gg.clearResults()
for k, v in ipairs(gg.getValuesRange(RefToObjects)) do
if v == 'A' then
FilterObjects[#FilterObjects + 1] = {
address = Il2cpp.FixValue(RefToObjects[k].value),
flags = RefToObjects[k].flags
}
end
end
gg.loadResults(FilterObjects)
local _FilterObjects = gg.getResults(gg.getResultsCount())
gg.clearResults()
return _FilterObjects
end,
FindObjects = function(self, ClassAddress)
gg.clearResults()
gg.setRanges(0)
gg.setRanges(gg.REGION_C_HEAP | gg.REGION_C_HEAP | gg.REGION_ANONYMOUS | gg.REGION_C_BSS | gg.REGION_C_DATA |
gg.REGION_C_ALLOC)
gg.loadResults({{
address = tonumber(ClassAddress, 16),
flags = Il2cpp.MainType
}})
gg.searchPointer(0)
if gg.getResultsCount() <= 0 and AndroidInfo.platform and AndroidInfo.sdk >= 30 then
gg.searchNumber(tostring(tonumber(ClassAddress, 16) | 0xB400000000000000), gg.TYPE_QWORD)
end
local FindsResult = gg.getResults(gg.getResultsCount())
gg.clearResults()
return self:FilterObjects(FindsResult)
end,
Find = function(self, ClassesInfo)
local Objects = {}
for j = 1, #ClassesInfo do
local FindResult = self:FindObjects(ClassesInfo[j].ClassAddress)
table.move(FindResult, 1, #FindResult, #Objects + 1, Objects)
end
return Objects
end,
FindHead = function(Address)
local validAddress = Il2cpp.GetValidAddress(Address)
local mayBeHead = {}
for i = 1, 1000 do
mayBeHead[i] = {
address = validAddress - (4 * (i - 1)),
flags = Il2cpp.MainType
}
end
mayBeHead = gg.getValues(mayBeHead)
for i = 1, #mayBeHead do
local mayBeClass = Il2cpp.FixValue(mayBeHead[i].value)
if Il2cpp.ClassApi.IsClassInfo(mayBeClass) then
return mayBeHead[i]
end
end
return {value = 0, address = 0}
end,
}
return ObjectApi
end)
__bundle_register("utils.androidinfo", function(require, _LOADED, __bundle_register, __bundle_modules)
local AndroidInfo = {
platform = gg.getTargetInfo().x64,
sdk = gg.getTargetInfo().targetSdkVersion
}
return AndroidInfo
end)
__bundle_register("il2cppstruct.class", function(require, _LOADED, __bundle_register, __bundle_modules)
local Protect = require("utils.protect")
local StringUtils = require("utils.stringutils")
local Il2cppMemory = require("utils.il2cppmemory")
local ClassApi = {
GetClassName = function(self, ClassAddress)
return Il2cpp.Utf8ToString(Il2cpp.FixValue(gg.getValues({{
address = Il2cpp.FixValue(ClassAddress) + self.NameOffset,
flags = Il2cpp.MainType
}})[1].value))
end,
GetClassMethods = function(self, MethodsLink, Count, ClassName)
local MethodsInfo, _MethodsInfo = {}, {}
for i = 0, Count - 1 do
_MethodsInfo[#_MethodsInfo + 1] = {
address = MethodsLink + (i << self.MethodsStep),
flags = Il2cpp.MainType
}
end
_MethodsInfo = gg.getValues(_MethodsInfo)
for i = 1, #_MethodsInfo do
local MethodInfo
MethodInfo, _MethodsInfo[i] = Il2cpp.MethodsApi:UnpackMethodInfo({
MethodInfoAddress = Il2cpp.FixValue(_MethodsInfo[i].value),
ClassName = ClassName
})
table.move(MethodInfo, 1, #MethodInfo, #MethodsInfo + 1, MethodsInfo)
end
MethodsInfo = gg.getValues(MethodsInfo)
Il2cpp.MethodsApi:DecodeMethodsInfo(_MethodsInfo, MethodsInfo)
return _MethodsInfo
end,
GetClassFields = function(self, FieldsLink, Count, ClassCharacteristic)
local FieldsInfo, _FieldsInfo = {}, {}
for i = 0, Count - 1 do
_FieldsInfo[#_FieldsInfo + 1] = {
address = FieldsLink + (i * self.FieldsStep),
flags = Il2cpp.MainType
}
end
_FieldsInfo = gg.getValues(_FieldsInfo)
for i = 1, #_FieldsInfo do
local FieldInfo
FieldInfo = Il2cpp.FieldApi:UnpackFieldInfo(Il2cpp.FixValue(_FieldsInfo[i].address))
table.move(FieldInfo, 1, #FieldInfo, #FieldsInfo + 1, FieldsInfo)
end
FieldsInfo = gg.getValues(FieldsInfo)
_FieldsInfo = Il2cpp.FieldApi:DecodeFieldsInfo(FieldsInfo, ClassCharacteristic)
return _FieldsInfo
end,
UnpackClassInfo = function(self, ClassInfo, Config)
local _ClassInfo = gg.getValues({
{ address = ClassInfo.ClassInfoAddress + self.NameOffset,
flags = Il2cpp.MainType
},
{ address = ClassInfo.ClassInfoAddress + self.CountMethods,
flags = gg.TYPE_WORD
},
{ address = ClassInfo.ClassInfoAddress + self.CountFields,
flags = gg.TYPE_WORD
},
{ address = ClassInfo.ClassInfoAddress + self.MethodsLink,
flags = Il2cpp.MainType
},
{ address = ClassInfo.ClassInfoAddress + self.FieldsLink,
flags = Il2cpp.MainType
},
{ address = ClassInfo.ClassInfoAddress + self.ParentOffset,
flags = Il2cpp.MainType
},
{ address = ClassInfo.ClassInfoAddress + self.NameSpa