diff --git a/CMakeLists.txt b/CMakeLists.txt index 3c2d926..32d4885 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,7 +62,7 @@ include(generate_product_version) set(VERSION_MAJOR 3) set(VERSION_MINOR 1) -set(VERSION_PATCH 5) +set(VERSION_PATCH 6) set(VERSION_REVISION 0) if(BUILD_CORE) diff --git a/LunaHook/engine32/mono.cpp b/LunaHook/engine32/mono.cpp index 5e85093..2b37310 100644 --- a/LunaHook/engine32/mono.cpp +++ b/LunaHook/engine32/mono.cpp @@ -1,6 +1,5 @@ #include"mono.h" #include"mono/monocommon.hpp" -#include "mono/monoobject.h" bool monobdwgc() { diff --git a/LunaHook/engine64/mono.cpp b/LunaHook/engine64/mono.cpp index 53cde5b..6ee6ef3 100644 --- a/LunaHook/engine64/mono.cpp +++ b/LunaHook/engine64/mono.cpp @@ -1,5 +1,4 @@ #include"mono.h" -#include "mono/monoobject.h" #include"mono/monocommon.hpp" namespace{ diff --git a/LunaHook/engine64/vita3k.cpp b/LunaHook/engine64/vita3k.cpp index 1de3f3a..fc80643 100644 --- a/LunaHook/engine64/vita3k.cpp +++ b/LunaHook/engine64/vita3k.cpp @@ -58,8 +58,8 @@ bool vita3k::attach_function() HookParam hp; hp.address=DoJitPtr; hp.text_fun=[](hook_stack* stack, HookParam* hp, uintptr_t* data, uintptr_t* split, size_t* len){ - auto descriptor = *argidx(stack,idxDescriptor); // r8 - auto entrypoint = *argidx(stack,idxEntrypoint); // r9 + auto descriptor = *argidx(stack,idxDescriptor+1); // r8 + auto entrypoint = *argidx(stack,idxEntrypoint+1); // r9 auto em_address = *(uint32_t*)descriptor; if(!entrypoint)return; // ConsoleOutput("%p",em_address); diff --git a/LunaHook/engine64/yuzusuyu.cpp b/LunaHook/engine64/yuzusuyu.cpp index 09c2c50..1dcfd65 100644 --- a/LunaHook/engine64/yuzusuyu.cpp +++ b/LunaHook/engine64/yuzusuyu.cpp @@ -144,8 +144,8 @@ bool yuzusuyu::attach_function() HookParam hp; hp.address=DoJitPtr; hp.text_fun=[](hook_stack* stack, HookParam* hp, uintptr_t* data, uintptr_t* split, size_t* len){ - auto descriptor = *argidx(stack,idxDescriptor); // r8 - auto entrypoint = *argidx(stack,idxEntrypoint); // r9 + auto descriptor = *argidx(stack,idxDescriptor+1); // r8 + auto entrypoint = *argidx(stack,idxEntrypoint+1); // r9 auto em_address = *(uintptr_t*)descriptor; if(!entrypoint)return; jitaddraddr(em_address,entrypoint,JITTYPE::YUZU); diff --git a/LunaHook/engines/CMakeLists.txt b/LunaHook/engines/CMakeLists.txt index d498587..92d67cc 100644 --- a/LunaHook/engines/CMakeLists.txt +++ b/LunaHook/engines/CMakeLists.txt @@ -1,4 +1,4 @@ -add_library(commonengine ppsspp/ppsspp.cpp mages/mages.cpp v8/v8.cpp python/python2.cpp python/python3.cpp python/python.cpp pchooks/pchooks.cpp) +add_library(commonengine mono/impl_mono.cpp mono/impl_il2cpp.cpp ppsspp/ppsspp.cpp mages/mages.cpp v8/v8.cpp python/python2.cpp python/python3.cpp python/python.cpp pchooks/pchooks.cpp) target_precompile_headers(commonengine REUSE_FROM pchhook) diff --git a/LunaHook/engines/mono/il2cpp.hpp b/LunaHook/engines/mono/def_il2cpp.hpp similarity index 100% rename from LunaHook/engines/mono/il2cpp.hpp rename to LunaHook/engines/mono/def_il2cpp.hpp diff --git a/LunaHook/engines/mono/def_mono.hpp b/LunaHook/engines/mono/def_mono.hpp new file mode 100644 index 0000000..4d34224 --- /dev/null +++ b/LunaHook/engines/mono/def_mono.hpp @@ -0,0 +1,403 @@ +#pragma once + +typedef signed long SInt32; +typedef unsigned long UInt32; +typedef signed short SInt16; +typedef unsigned short UInt16; +typedef unsigned char UInt8; +typedef signed char SInt8; +typedef unsigned long long UInt64; +typedef signed long long SInt64; +#define MONO_ZERO_LEN_ARRAY 1 +#define MONO_TOKEN_TYPE_DEF 0x02000000 +#define MONO_TABLE_TYPEDEF 0x2 +struct MonoException; +struct MonoAssembly; +struct MonoClassField; +struct MonoClass; +struct MonoDomain; +struct MonoImage; +struct MonoType; +struct MonoMethodSignature; +struct MonoArray; +struct MonoThread; +struct MonoThreadsSync; +struct MonoVTable; +struct MonoProperty; +struct MonoReflectionAssembly; +struct MonoReflectionMethod; +struct MonoAppDomain; +struct MonoCustomAttrInfo; + +struct MonoReflectionType { UInt32 offset[2]; MonoType* type;}; + +typedef void* gconstpointer; +typedef void* gpointer; +typedef int gboolean; +typedef unsigned int guint32; +typedef int gint32; +typedef long gint64; +typedef unsigned char guchar; +typedef UInt16 gunichar2; + +struct MonoObject { + MonoVTable *vtable; + MonoThreadsSync *synchronisation; +}; + +typedef MonoObject* MonoStruct; +typedef MonoObject** MonoStruct_out; + +struct MonoString { + MonoObject object; + gint32 length; + gunichar2 chars[0]; +}; + +struct MonoMethod { + UInt16 flags; + UInt16 iflags; +}; + +typedef enum +{ + MONO_VERIFIER_MODE_OFF, + MONO_VERIFIER_MODE_VALID, + MONO_VERIFIER_MODE_VERIFIABLE, + MONO_VERIFIER_MODE_STRICT +} MiniVerifierMode; + +typedef enum { + MONO_SECURITY_MODE_NONE, + MONO_SECURITY_MODE_CORE_CLR, + MONO_SECURITY_MODE_CAS, + MONO_SECURITY_MODE_SMCS_HACK +} MonoSecurityMode; + +typedef void GFuncRef (void*, void*); +typedef GFuncRef* GFunc; + +typedef enum { + MONO_UNHANDLED_POLICY_LEGACY, + MONO_UNHANDLED_POLICY_CURRENT +} MonoRuntimeUnhandledExceptionPolicy; + +struct MonoMethodDesc { + char *namespace2; + char *klass; + char *name; + char *args1; + UInt32 num_args; + gboolean include_namespace, klass_glob, name_glob; +}; + + +struct MonoJitInfo; +struct MonoAssemblyName; +struct MonoDebugSourceLocation; +struct MonoLoaderError; +struct MonoDlFallbackHandler; +struct LivenessState; + +struct MonoBreakPolicy; + +typedef bool (*MonoCoreClrPlatformCB) (const char *image_name); + +typedef unsigned int guint; +typedef void (*register_object_callback)(gpointer* arr, int size, void* callback_userdata); +typedef gboolean (*MonoStackWalk) (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed, gpointer data); +typedef MonoBreakPolicy (*MonoBreakPolicyFunc) (MonoMethod *method); +typedef void* (*MonoDlFallbackLoad) (const char *name, int flags, char **err, void *user_data); +typedef void* (*MonoDlFallbackSymbol) (void *handle, const char *name, char **err, void *user_data); +typedef void* (*MonoDlFallbackClose) (void *handle, void *user_data); + +typedef enum { + MONO_TYPE_NAME_FORMAT_IL, + MONO_TYPE_NAME_FORMAT_REFLECTION, + MONO_TYPE_NAME_FORMAT_FULL_NAME, + MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED +} MonoTypeNameFormat; + +//typedef void (*vprintf_func)(const char* msg, va_list args); + +struct MonoProfiler; +typedef void (*MonoProfileFunc) (MonoProfiler *prof); + +typedef enum { + MONO_PROFILE_NONE = 0, + MONO_PROFILE_APPDOMAIN_EVENTS = 1 << 0, + MONO_PROFILE_ASSEMBLY_EVENTS = 1 << 1, + MONO_PROFILE_MODULE_EVENTS = 1 << 2, + MONO_PROFILE_CLASS_EVENTS = 1 << 3, + MONO_PROFILE_JIT_COMPILATION = 1 << 4, + MONO_PROFILE_INLINING = 1 << 5, + MONO_PROFILE_EXCEPTIONS = 1 << 6, + MONO_PROFILE_ALLOCATIONS = 1 << 7, + MONO_PROFILE_GC = 1 << 8, + MONO_PROFILE_THREADS = 1 << 9, + MONO_PROFILE_REMOTING = 1 << 10, + MONO_PROFILE_TRANSITIONS = 1 << 11, + MONO_PROFILE_ENTER_LEAVE = 1 << 12, + MONO_PROFILE_COVERAGE = 1 << 13, + MONO_PROFILE_INS_COVERAGE = 1 << 14, + MONO_PROFILE_STATISTICAL = 1 << 15, + MONO_PROFILE_METHOD_EVENTS = 1 << 16, + MONO_PROFILE_MONITOR_EVENTS = 1 << 17, + MONO_PROFILE_IOMAP_EVENTS = 1 << 18, /* this should likely be removed, too */ + MONO_PROFILE_GC_MOVES = 1 << 19 +} MonoProfileFlags; + +typedef enum { + MONO_GC_EVENT_START, + MONO_GC_EVENT_MARK_START, + MONO_GC_EVENT_MARK_END, + MONO_GC_EVENT_RECLAIM_START, + MONO_GC_EVENT_RECLAIM_END, + MONO_GC_EVENT_END, + MONO_GC_EVENT_PRE_STOP_WORLD, + MONO_GC_EVENT_POST_STOP_WORLD, + MONO_GC_EVENT_PRE_START_WORLD, + MONO_GC_EVENT_POST_START_WORLD +} MonoGCEvent; + +typedef void (*MonoProfileMethodFunc) (MonoProfiler *prof, MonoMethod *method); +typedef void (*MonoProfileGCFunc) (MonoProfiler *prof, MonoGCEvent event, int generation); +typedef void (*MonoProfileGCMoveFunc) (MonoProfiler *prof, void **objects, int num); +typedef void (*MonoProfileGCResizeFunc) (MonoProfiler *prof, gint64 new_size); +typedef void (*MonoProfileAllocFunc) (MonoProfiler *prof, MonoObject *obj, MonoClass *klass); +typedef void (*MonoProfileJitResult) (MonoProfiler *prof, MonoMethod *method, MonoJitInfo* jinfo, int result); +typedef void (*MonoProfileExceptionFunc) (MonoProfiler *prof, MonoObject *object); +typedef void (*MonoProfileExceptionClauseFunc) (MonoProfiler *prof, MonoMethod *method, int clause_type, int clause_num); +typedef void (*MonoProfileThreadFunc) (MonoProfiler *prof, uint32_t tid); + + +typedef void (*mono_thread_suspend_all_other_threads_t)(); +typedef void (*mono_thread_pool_cleanup_t)(); +typedef void (*mono_threads_set_shutting_down_t)(); +typedef void (*mono_runtime_set_shutting_down_t)(); +typedef gboolean (*mono_domain_finalize_t)(MonoDomain *domain, int timeout); +typedef void (*mono_runtime_cleanup_t)(MonoDomain *domain); +typedef MonoMethodDesc *(*mono_method_desc_new_t)(const char *name, gboolean include_namespace); +typedef MonoMethod *(*mono_method_desc_search_in_image_t)(MonoMethodDesc *desc, MonoImage *image); +typedef void (*mono_verifier_set_mode_t)(MiniVerifierMode m); +typedef void (*mono_security_set_mode_t)(MonoSecurityMode m); +typedef void (*mono_add_internal_call_t)(const char *name, gconstpointer method); +typedef void (*mono_jit_cleanup_t)(MonoDomain *domain); +typedef MonoDomain *(*mono_jit_init_t)(const char *file); +typedef MonoDomain *(*mono_jit_init_version_t)(const char *file, const char *runtime_version); +typedef int (*mono_jit_exec_t)(MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]); +typedef MonoClass *(*mono_class_from_name_t)(MonoImage *image, const char *name_space, const char *name); +typedef MonoAssembly *(*mono_domain_assembly_open_t)(MonoDomain *domain, const char *name); +typedef MonoDomain *(*mono_domain_create_appdomain_t)(const char *domainname, const char *configfile); +typedef void (*mono_domain_unload_t)(MonoDomain *domain); +typedef MonoObject *(*mono_object_new_t)(MonoDomain *domain, MonoClass *klass); +typedef void (*mono_runtime_object_init_t)(MonoObject *this_obj); +typedef MonoObject *(*mono_runtime_invoke_t)(MonoMethod *method, void *obj, void **params, MonoObject **exc); +typedef void (*mono_field_set_value_t)(MonoObject *obj, MonoClassField *field, void *value); +typedef void (*mono_field_get_value_t)(MonoObject *obj, MonoClassField *field, void *value); +typedef int (*mono_field_get_offset_t)(MonoClassField *field); +typedef MonoClassField *(*mono_class_get_fields_t)(MonoClass *klass, gpointer *iter); +typedef MonoMethod *(*mono_class_get_methods_t)(MonoClass *klass, gpointer *iter); +typedef MonoDomain *(*mono_domain_get_t)(); +typedef MonoDomain *(*mono_get_root_domain_t)(); +typedef gint32 (*mono_domain_get_id_t)(MonoDomain *domain); +typedef void (*mono_assembly_foreach_t)(GFunc func, gpointer user_data); +typedef void (*mono_image_close_t)(MonoImage *image); +typedef void (*mono_unity_socket_security_enabled_set_t)(gboolean b); +typedef const char *(*mono_image_get_name_t)(MonoImage *image); +typedef MonoClass *(*mono_get_object_class_t)(); +typedef void (*mono_set_commandline_arguments_t)(int i, const char *argv[], const char *s); +typedef const char *(*mono_field_get_name_t)(MonoClassField *field); +typedef MonoType *(*mono_field_get_type_t)(MonoClassField *field); +typedef int (*mono_type_get_type_t)(MonoType *type); +typedef const char *(*mono_method_get_name_t)(MonoMethod *method); +typedef MonoImage *(*mono_assembly_get_image_t)(MonoAssembly *assembly); +typedef MonoClass *(*mono_method_get_class_t)(MonoMethod *method); +typedef MonoClass *(*mono_object_get_class_t)(MonoObject *obj); +typedef gboolean (*mono_class_is_valuetype_t)(MonoClass *klass); +typedef guint32 (*mono_signature_get_param_count_t)(MonoMethodSignature *sig); +typedef char *(*mono_string_to_utf8_t)(MonoString *string_obj); +typedef MonoString *(*mono_string_new_wrapper_t)(const char *text); +typedef MonoClass *(*mono_class_get_parent_t)(MonoClass *klass); +typedef const char *(*mono_class_get_namespace_t)(MonoClass *klass); +typedef gboolean (*mono_class_is_subclass_of_t)(MonoClass *klass, MonoClass *klassc, gboolean check_interfaces); +typedef const char *(*mono_class_get_name_t)(MonoClass *klass); +typedef char *(*mono_type_get_name_t)(MonoType *type); +typedef MonoClass *(*mono_type_get_class_t)(MonoType *type); +typedef MonoException *(*mono_exception_from_name_msg_t)(MonoImage *image, const char *name_space, const char *name, const char *msg); +typedef void (*mono_raise_exception_t)(MonoException *ex); +typedef MonoClass *(*mono_get_exception_class_t)(); +typedef MonoClass *(*mono_get_array_class_t)(); +typedef MonoClass *(*mono_get_string_class_t)(); +typedef MonoClass *(*mono_get_int32_class_t)(); +typedef MonoArray *(*mono_array_new_t)(MonoDomain *domain, MonoClass *eclass, guint32 n); +typedef MonoArray *(*mono_array_new_full_t)(MonoDomain *domain, MonoClass *array_class, guint32 *lengths, guint32 *lower_bounds); +typedef MonoClass *(*mono_array_class_get_t)(MonoClass *eclass, guint32 rank); +typedef gint32 (*mono_class_array_element_size_t)(MonoClass *ac); +typedef MonoObject *(*mono_type_get_object_t)(MonoDomain *domain, MonoType *type); +typedef MonoThread *(*mono_thread_attach_t)(MonoDomain *domain); +typedef void (*mono_thread_detach_t)(MonoThread *thread); +typedef MonoThread *(*mono_thread_exit_t)(); +typedef MonoThread *(*mono_thread_current_t)(); +typedef void (*mono_thread_set_main_t)(MonoThread *thread); +typedef void (*mono_set_find_plugin_callback_t)(gconstpointer method); +typedef void (*mono_security_enable_core_clr_t)(); +typedef bool (*mono_security_set_core_clr_platform_callback_t)(MonoCoreClrPlatformCB a); +typedef MonoRuntimeUnhandledExceptionPolicy (*mono_runtime_unhandled_exception_policy_get_t)(); +typedef void (*mono_runtime_unhandled_exception_policy_set_t)(MonoRuntimeUnhandledExceptionPolicy policy); +typedef MonoClass *(*mono_class_get_nesting_type_t)(MonoClass *klass); +typedef MonoVTable *(*mono_class_vtable_t)(MonoDomain *domain, MonoClass *klass); +typedef MonoReflectionMethod *(*mono_method_get_object_t)(MonoDomain *domain, MonoMethod *method, MonoClass *refclass); +typedef MonoMethodSignature *(*mono_method_signature_t)(MonoMethod *method); +typedef MonoType *(*mono_signature_get_params_t)(MonoMethodSignature *sig, gpointer *iter); +typedef MonoType *(*mono_signature_get_return_type_t)(MonoMethodSignature *sig); +typedef MonoType *(*mono_class_get_type_t)(MonoClass *klass); +typedef void (*mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded_t)(gboolean value); +typedef void (*mono_debug_init_t)(int format); +typedef void (*mono_debug_open_image_from_memory_t)(MonoImage *image, const char *raw_contents, int size); +typedef guint32 (*mono_field_get_flags_t)(MonoClassField *field); +typedef MonoImage *(*mono_image_open_from_data_full_t)(const void *data, guint32 data_len, gboolean need_copy, int *status, gboolean ref_only); +typedef MonoImage *(*mono_image_open_from_data_with_name_t)(char *data, guint32 data_len, gboolean need_copy, int *status, gboolean refonly, const char *name); +typedef MonoAssembly *(*mono_assembly_load_from_t)(MonoImage *image, const char *fname, int *status); +typedef MonoObject *(*mono_value_box_t)(MonoDomain *domain, MonoClass *klass, gpointer val); +typedef MonoImage *(*mono_class_get_image_t)(MonoClass *klass); +typedef char (*mono_signature_is_instance_t)(MonoMethodSignature *signature); +typedef MonoMethod *(*mono_method_get_last_managed_t)(); +typedef MonoClass *(*mono_get_enum_class_t)(); +typedef MonoType *(*mono_class_get_byref_type_t)(MonoClass *klass); +typedef void (*mono_field_static_get_value_t)(MonoVTable *vt, MonoClassField *field, void *value); +typedef void (*mono_unity_set_embeddinghostname_t)(const char *name); +typedef void (*mono_set_assemblies_path_t)(const char *name); +typedef guint32 (*mono_gchandle_new_t)(MonoObject *obj, gboolean pinned); +typedef MonoObject *(*mono_gchandle_get_target_t)(guint32 gchandle); +typedef guint32 (*mono_gchandle_new_weakref_t)(MonoObject *obj, gboolean track_resurrection); +typedef MonoObject *(*mono_assembly_get_object_t)(MonoDomain *domain, MonoAssembly *assembly); +typedef void (*mono_gchandle_free_t)(guint32 gchandle); +typedef MonoProperty *(*mono_class_get_properties_t)(MonoClass *klass, gpointer *iter); +typedef MonoMethod *(*mono_property_get_get_method_t)(MonoProperty *prop); +typedef MonoObject *(*mono_object_new_alloc_specific_t)(MonoVTable *vtable); +typedef MonoObject *(*mono_object_new_specific_t)(MonoVTable *vtable); +typedef void (*mono_gc_collect_t)(int generation); +typedef int (*mono_gc_max_generation_t)(); +typedef MonoAssembly *(*mono_image_get_assembly_t)(MonoImage *image); +typedef MonoAssembly *(*mono_assembly_open_t)(const char *filename, int *status); +typedef gboolean (*mono_class_is_enum_t)(MonoClass *klass); +typedef gint32 (*mono_class_instance_size_t)(MonoClass *klass); +typedef guint32 (*mono_object_get_size_t)(MonoObject *obj); +typedef const char *(*mono_image_get_filename_t)(MonoImage *image); +typedef MonoAssembly *(*mono_assembly_load_from_full_t)(MonoImage *image, const char *fname, int *status, gboolean refonly); +typedef MonoClass *(*mono_class_get_interfaces_t)(MonoClass *klass, gpointer *iter); +typedef void (*mono_assembly_close_t)(MonoAssembly *assembly); +typedef MonoProperty *(*mono_class_get_property_from_name_t)(MonoClass *klass, const char *name); +typedef MonoMethod *(*mono_class_get_method_from_name_t)(MonoClass *klass, const char *name, int param_count); +typedef MonoClass *(*mono_class_from_mono_type_t)(MonoType *image); +typedef gboolean (*mono_domain_set_t)(MonoDomain *domain, gboolean force); +typedef void (*mono_thread_push_appdomain_ref_t)(MonoDomain *domain); +typedef void (*mono_thread_pop_appdomain_ref_t)(); +typedef int (*mono_runtime_exec_main_t)(MonoMethod *method, MonoArray *args, MonoObject **exc); +typedef MonoImage *(*mono_get_corlib_t)(); +typedef MonoClassField *(*mono_class_get_field_from_name_t)(MonoClass *klass, const char *name); +typedef guint32 (*mono_class_get_flags_t)(MonoClass *klass); +typedef int (*mono_parse_default_optimizations_t)(const char *p); +typedef void (*mono_set_defaults_t)(int verbose_level, guint32 opts); +typedef void (*mono_set_dirs_t)(const char *assembly_dir, const char *config_dir); +typedef void (*mono_jit_parse_options_t)(int argc, char *argv[]); +typedef gpointer (*mono_object_unbox_t)(MonoObject *o); +typedef MonoObject *(*mono_custom_attrs_get_attr_t)(MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); +typedef gboolean (*mono_custom_attrs_has_attr_t)(MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); +typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_field_t)(MonoClass *klass, MonoClassField *field); +typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_method_t)(MonoMethod *method); +typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_class_t)(MonoClass *klass); +typedef void (*mono_custom_attrs_free_t)(MonoCustomAttrInfo *attr); +typedef void (*g_free_t)(void *p); +typedef gboolean (*mono_runtime_is_shutting_down_t)(); +typedef MonoMethod *(*mono_object_get_virtual_method_t)(MonoObject *obj, MonoMethod *method); +typedef gpointer (*mono_jit_info_get_code_start_t)(MonoJitInfo *ji); +typedef int (*mono_jit_info_get_code_size_t)(MonoJitInfo *ji); +typedef MonoClass *(*mono_class_from_name_case_t)(MonoImage *image, const char *name_space, const char *name); +typedef MonoClass *(*mono_class_get_nested_types_t)(MonoClass *klass, gpointer *iter); +typedef int (*mono_class_get_userdata_offset_t)(); +typedef void *(*mono_class_get_userdata_t)(MonoClass *klass); +typedef void (*mono_class_set_userdata_t)(MonoClass *klass, void *userdata); +typedef void (*mono_set_signal_chaining_t)(gboolean chain_signals); +// typedef LONG( *mono_unity_seh_handler_t)(EXCEPTION_POINTERS* ep); +typedef void (*mono_unity_set_unhandled_exception_handler_t)(void *handler); +typedef MonoObject *(*mono_runtime_invoke_array_t)(MonoMethod *method, void *obj, MonoArray *params, MonoObject **exc); +typedef char *(*mono_array_addr_with_size_t)(MonoArray *array, int size, uintptr_t idx); +typedef gunichar2 *(*mono_string_to_utf16_t)(MonoString *string_obj); +typedef MonoClass *(*mono_field_get_parent_t)(MonoClassField *field); +typedef char *(*mono_method_full_name_t)(MonoMethod *method, gboolean signature); +typedef MonoObject *(*mono_object_isinst_t)(MonoObject *obj, MonoClass *klass); +typedef MonoString *(*mono_string_new_len_t)(MonoDomain *domain, const char *text, guint length); +typedef MonoString *(*mono_string_from_utf16_t)(gunichar2 *data); +typedef MonoException *(*mono_get_exception_argument_null_t)(const char *arg); +typedef MonoClass *(*mono_get_boolean_class_t)(); +typedef MonoClass *(*mono_get_byte_class_t)(); +typedef MonoClass *(*mono_get_char_class_t)(); +typedef MonoClass *(*mono_get_int16_class_t)(); +typedef MonoClass *(*mono_get_int64_class_t)(); +typedef MonoClass *(*mono_get_single_class_t)(); +typedef MonoClass *(*mono_get_double_class_t)(); +typedef gboolean (*mono_class_is_generic_t)(MonoClass *klass); +typedef gboolean (*mono_class_is_inflated_t)(MonoClass *klass); +typedef gboolean (*unity_mono_method_is_generic_t)(MonoMethod *method); +typedef gboolean (*unity_mono_method_is_inflated_t)(MonoMethod *method); +typedef gboolean (*mono_is_debugger_attached_t)(); +typedef gboolean (*mono_assembly_fill_assembly_name_t)(MonoImage *image, MonoAssemblyName *aname); +typedef char *(*mono_stringify_assembly_name_t)(MonoAssemblyName *aname); +typedef gboolean (*mono_assembly_name_parse_t)(const char *name, MonoAssemblyName *aname); +typedef MonoAssembly *(*mono_assembly_loaded_t)(MonoAssemblyName *aname); +typedef int (*mono_image_get_table_rows_t)(MonoImage *image, int table_id); +typedef MonoClass *(*mono_class_get_t)(MonoImage *image, guint32 type_token); +typedef gboolean (*mono_metadata_signature_equal_t)(MonoMethodSignature *sig1, MonoMethodSignature *sig2); +typedef gboolean (*mono_gchandle_is_in_domain_t)(guint32 gchandle, MonoDomain *domain); +typedef void (*mono_stack_walk_t)(MonoStackWalk func, gpointer user_data); +typedef char *(*mono_pmip_t)(void *ip); +typedef MonoObject *(*mono_runtime_delegate_invoke_t)(MonoObject *delegate, void **params, MonoObject **exc); +typedef MonoJitInfo *(*mono_jit_info_table_find_t)(MonoDomain *domain, char *addr); +typedef MonoDebugSourceLocation *(*mono_debug_lookup_source_location_t)(MonoMethod *method, guint32 address, MonoDomain *domain); +typedef void (*mono_debug_free_source_location_t)(MonoDebugSourceLocation *location); +typedef void (*mono_gc_wbarrier_generic_store_t)(gpointer ptr, MonoObject *value); +typedef MonoType *(*mono_class_enum_basetype_t)(MonoClass *klass); +typedef guint32 (*mono_class_get_type_token_t)(MonoClass *klass); +typedef int (*mono_class_get_rank_t)(MonoClass *klass); +typedef MonoClass *(*mono_class_get_element_class_t)(MonoClass *klass); +typedef gboolean (*mono_unity_class_is_interface_t)(MonoClass *klass); +typedef gboolean (*mono_unity_class_is_abstract_t)(MonoClass *klass); +typedef gint32 (*mono_array_element_size_t)(MonoClass *ac); +typedef void (*mono_config_parse_t)(const char *filename); +typedef void (*mono_set_break_policy_t)(MonoBreakPolicyFunc policy_callback); +typedef MonoArray *(*mono_custom_attrs_construct_t)(MonoCustomAttrInfo *cinfo); +typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_assembly_t)(MonoAssembly *assembly); +typedef MonoArray *(*mono_reflection_get_custom_attrs_by_type_t)(MonoObject *obj, MonoClass *attr_klass); +typedef MonoLoaderError *(*mono_loader_get_last_error_t)(); +typedef MonoException *(*mono_loader_error_prepare_exception_t)(MonoLoaderError *error); +typedef MonoDlFallbackHandler *(*mono_dl_fallback_register_t)(MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, MonoDlFallbackClose close_func, void *user_data); +typedef void (*mono_dl_fallback_unregister_t)(MonoDlFallbackHandler *handler); +typedef LivenessState *(*mono_unity_liveness_allocate_struct_t)(MonoClass *filter, guint max_count, register_object_callback callback, void *callback_userdata); +typedef void (*mono_unity_liveness_stop_gc_world_t)(); +typedef void (*mono_unity_liveness_finalize_t)(LivenessState *state); +typedef void (*mono_unity_liveness_start_gc_world_t)(); +typedef void (*mono_unity_liveness_free_struct_t)(LivenessState *state); +typedef LivenessState *(*mono_unity_liveness_calculation_begin_t)(MonoClass *filter, guint max_count, register_object_callback callback, void *callback_userdata); +typedef void (*mono_unity_liveness_calculation_end_t)(LivenessState *state); +typedef void (*mono_unity_liveness_calculation_from_root_t)(MonoObject *root, LivenessState *state); +typedef void (*mono_unity_liveness_calculation_from_statics_t)(LivenessState *state); +typedef void (*mono_trace_set_level_string_t)(const char *value); +typedef void (*mono_trace_set_mask_string_t)(char *value); +typedef gint64 (*mono_gc_get_used_size_t)(); +typedef gint64 (*mono_gc_get_heap_size_t)(); +typedef MonoMethod *(*mono_method_desc_search_in_class_t)(MonoMethodDesc *desc, MonoClass *klass); +typedef void (*mono_method_desc_free_t)(MonoMethodDesc *desc); +typedef char *(*mono_type_get_name_full_t)(MonoType *type, MonoTypeNameFormat format); +typedef void (*mono_unity_thread_clear_domain_fields_t)(); +// typedef void( *mono_unity_set_vprintf_func_t)(vprintf_func func); +typedef void (*mono_profiler_install_t)(MonoProfiler *prof, MonoProfileFunc shutdown_callback); +typedef void (*mono_profiler_set_events_t)(MonoProfileFlags events); +typedef void (*mono_profiler_install_enter_leave_t)(MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave); +typedef void (*mono_profiler_install_gc_t)(MonoProfileGCFunc callback, MonoProfileGCResizeFunc heap_resize_callback); +typedef void (*mono_profiler_install_allocation_t)(MonoProfileAllocFunc callback); +typedef void (*mono_profiler_install_jit_end_t)(MonoProfileJitResult end); +typedef void (*mono_profiler_install_exception_t)(MonoProfileExceptionFunc throw_callback, MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback); +typedef void (*mono_profiler_install_thread_t)(MonoProfileThreadFunc start, MonoProfileThreadFunc end); +typedef uint64_t* (*mono_compile_method_t)(uintptr_t); diff --git a/LunaHook/engines/mono/impl_il2cpp.cpp b/LunaHook/engines/mono/impl_il2cpp.cpp new file mode 100644 index 0000000..9e7c3d2 --- /dev/null +++ b/LunaHook/engines/mono/impl_il2cpp.cpp @@ -0,0 +1,141 @@ + +il2cpp_string_new_utf16_t il2cpp_string_new_utf16; +il2cpp_string_new_t il2cpp_string_new; +il2cpp_domain_get_t il2cpp_domain_get; +il2cpp_domain_assembly_open_t il2cpp_domain_assembly_open; +il2cpp_assembly_get_image_t il2cpp_assembly_get_image; +il2cpp_class_from_name_t il2cpp_class_from_name; +il2cpp_class_get_methods_t il2cpp_class_get_methods; +il2cpp_class_get_method_from_name_t il2cpp_class_get_method_from_name; +il2cpp_method_get_param_t il2cpp_method_get_param; +il2cpp_object_new_t il2cpp_object_new; +il2cpp_resolve_icall_t il2cpp_resolve_icall; +il2cpp_array_new_t il2cpp_array_new; +il2cpp_thread_attach_t il2cpp_thread_attach; +il2cpp_thread_detach_t il2cpp_thread_detach; +il2cpp_class_get_field_from_name_t il2cpp_class_get_field_from_name; +il2cpp_class_is_assignable_from_t il2cpp_class_is_assignable_from; +il2cpp_class_for_each_t il2cpp_class_for_each; +il2cpp_class_get_nested_types_t il2cpp_class_get_nested_types; +il2cpp_class_get_type_t il2cpp_class_get_type; +il2cpp_type_get_object_t il2cpp_type_get_object; +il2cpp_gchandle_new_t il2cpp_gchandle_new; +il2cpp_gchandle_free_t il2cpp_gchandle_free; +il2cpp_gchandle_get_target_t il2cpp_gchandle_get_target; +il2cpp_class_from_type_t il2cpp_class_from_type; +il2cpp_runtime_class_init_t il2cpp_runtime_class_init; +il2cpp_runtime_invoke_t il2cpp_runtime_invoke; +il2cpp_class_get_name_t il2cpp_class_get_name; +il2cpp_class_get_namespace_t il2cpp_class_get_namespace; +il2cpp_domain_get_assemblies_t il2cpp_domain_get_assemblies; +char* il2cpp_array_addr_with_size(void* array, int32_t size, uintptr_t idx) +{ + return ((char*)array) + kIl2CppSizeOfArray + size * idx; +} + +namespace il2cpp_symbols +{ +#define RESOLVE_IMPORT(name) name = reinterpret_cast(GetProcAddress(game_module, #name)) + + void init(HMODULE game_module) + { + RESOLVE_IMPORT(il2cpp_string_new_utf16); + RESOLVE_IMPORT(il2cpp_string_new); + RESOLVE_IMPORT(il2cpp_domain_get); + RESOLVE_IMPORT(il2cpp_domain_assembly_open); + RESOLVE_IMPORT(il2cpp_assembly_get_image); + RESOLVE_IMPORT(il2cpp_class_from_name); + RESOLVE_IMPORT(il2cpp_class_get_methods); + RESOLVE_IMPORT(il2cpp_class_get_method_from_name); + RESOLVE_IMPORT(il2cpp_method_get_param); + RESOLVE_IMPORT(il2cpp_object_new); + RESOLVE_IMPORT(il2cpp_resolve_icall); + RESOLVE_IMPORT(il2cpp_array_new); + RESOLVE_IMPORT(il2cpp_thread_attach); + RESOLVE_IMPORT(il2cpp_thread_detach); + RESOLVE_IMPORT(il2cpp_class_get_field_from_name); + RESOLVE_IMPORT(il2cpp_class_is_assignable_from); + RESOLVE_IMPORT(il2cpp_class_for_each); + RESOLVE_IMPORT(il2cpp_class_get_nested_types); + RESOLVE_IMPORT(il2cpp_class_get_type); + RESOLVE_IMPORT(il2cpp_type_get_object); + RESOLVE_IMPORT(il2cpp_gchandle_new); + RESOLVE_IMPORT(il2cpp_gchandle_free); + RESOLVE_IMPORT(il2cpp_gchandle_get_target); + RESOLVE_IMPORT(il2cpp_class_from_type); + RESOLVE_IMPORT(il2cpp_runtime_class_init); + RESOLVE_IMPORT(il2cpp_runtime_invoke); + RESOLVE_IMPORT(il2cpp_class_get_name); + RESOLVE_IMPORT(il2cpp_class_get_namespace); + RESOLVE_IMPORT(il2cpp_domain_get_assemblies); + } + Il2CppClass* get_il2cppclass1(const char* assemblyName, const char* namespaze, + const char* klassName) + { + if(!(il2cpp_thread_attach&&il2cpp_domain_get&&il2cpp_assembly_get_image&&il2cpp_class_from_name))return NULL; + auto il2cpp_domain=il2cpp_domain_get(); + if (!il2cpp_domain) return NULL; + il2cpp_thread_attach(il2cpp_domain); + void* assembly=0; + if(il2cpp_domain_assembly_open){ + do{ + assembly = il2cpp_domain_assembly_open(il2cpp_domain, assemblyName); + if(!assembly)break; + auto image = il2cpp_assembly_get_image(assembly); + if(!image)break; + auto klass = il2cpp_class_from_name(image, namespaze, klassName); + if(klass)return klass; + }while(0); + } + if(il2cpp_domain_get_assemblies&&il2cpp_assembly_get_image) + { + int _ = 0; + size_t sz = 0; + auto assemblies = il2cpp_domain_get_assemblies(il2cpp_domain, &sz); + for (auto i = 0; i < sz; i++, assemblies++) { + auto image = il2cpp_assembly_get_image(*assemblies); + auto cls = il2cpp_class_from_name(image, namespaze, klassName); + if(cls)return cls; + } + } + return NULL; + + } + struct callbackstruct{ + const char* classname; + const char* namespacename; + Il2CppClass* klass; + }; + void foreach_func(Il2CppClass* klass, void* userData){ + auto st=(callbackstruct*)userData; + auto classname = il2cpp_class_get_name(klass); + auto namespacename=il2cpp_class_get_namespace(klass); + if(strcmp(classname,st->classname)==0&&strcmp(namespacename,st->namespacename)==0) + st->klass=klass; + } + Il2CppClass* get_il2cppclass2(const char* namespaze, + const char* klassName) + { + if(!(il2cpp_class_for_each&&il2cpp_class_get_name&&il2cpp_class_get_namespace))return NULL; + callbackstruct st; + st.klass=NULL; + st.classname=klassName; + st.namespacename=namespaze; + il2cpp_class_for_each(foreach_func,&st); + + return st.klass; + } + uintptr_t get_method_pointer(const char* assemblyName, const char* namespaze, + const char* klassName, const char* name, int argsCount) + { + if(!il2cpp_class_get_method_from_name)return NULL; + auto klass=get_il2cppclass1(assemblyName,namespaze,klassName); + if (!klass) + klass=get_il2cppclass2(namespaze,klassName); + if (!klass) + return NULL; + auto ret = il2cpp_class_get_method_from_name(klass, name, argsCount); + if (ret) return ret->methodPointer; + return NULL; + } +} diff --git a/LunaHook/engines/mono/impl_mono.cpp b/LunaHook/engines/mono/impl_mono.cpp new file mode 100644 index 0000000..f5f81f2 --- /dev/null +++ b/LunaHook/engines/mono/impl_mono.cpp @@ -0,0 +1,528 @@ + + +mono_compile_method_t mono_compile_method=nullptr; +mono_thread_suspend_all_other_threads_t mono_thread_suspend_all_other_threads = nullptr; +mono_thread_pool_cleanup_t mono_thread_pool_cleanup = nullptr; +mono_threads_set_shutting_down_t mono_threads_set_shutting_down = nullptr; +mono_runtime_set_shutting_down_t mono_runtime_set_shutting_down = nullptr; +mono_domain_finalize_t mono_domain_finalize = nullptr; +mono_runtime_cleanup_t mono_runtime_cleanup = nullptr; +mono_method_desc_new_t mono_method_desc_new = nullptr; +mono_method_desc_search_in_image_t mono_method_desc_search_in_image = nullptr; +mono_verifier_set_mode_t mono_verifier_set_mode = nullptr; +mono_security_set_mode_t mono_security_set_mode = nullptr; +mono_add_internal_call_t mono_add_internal_call = nullptr; +mono_jit_cleanup_t mono_jit_cleanup = nullptr; +mono_jit_init_t mono_jit_init = nullptr; +mono_jit_init_version_t mono_jit_init_version = nullptr; +mono_jit_exec_t mono_jit_exec = nullptr; +mono_class_from_name_t mono_class_from_name = nullptr; +mono_domain_assembly_open_t mono_domain_assembly_open = nullptr; +mono_domain_create_appdomain_t mono_domain_create_appdomain = nullptr; +mono_domain_unload_t mono_domain_unload = nullptr; +mono_object_new_t mono_object_new = nullptr; +mono_runtime_object_init_t mono_runtime_object_init = nullptr; +mono_runtime_invoke_t mono_runtime_invoke = nullptr; +mono_field_set_value_t mono_field_set_value = nullptr; +mono_field_get_value_t mono_field_get_value = nullptr; +mono_field_get_offset_t mono_field_get_offset = nullptr; +mono_class_get_fields_t mono_class_get_fields = nullptr; +mono_class_get_methods_t mono_class_get_methods = nullptr; +mono_domain_get_t mono_domain_get = nullptr; +mono_get_root_domain_t mono_get_root_domain = nullptr; +mono_domain_get_id_t mono_domain_get_id = nullptr; +mono_assembly_foreach_t mono_assembly_foreach = nullptr; +mono_image_close_t mono_image_close = nullptr; +mono_unity_socket_security_enabled_set_t mono_unity_socket_security_enabled_set = nullptr; +mono_image_get_name_t mono_image_get_name = nullptr; +mono_get_object_class_t mono_get_object_class = nullptr; +mono_set_commandline_arguments_t mono_set_commandline_arguments = nullptr; +mono_field_get_name_t mono_field_get_name = nullptr; +mono_field_get_type_t mono_field_get_type = nullptr; +mono_type_get_type_t mono_type_get_type = nullptr; +mono_method_get_name_t mono_method_get_name = nullptr; +mono_assembly_get_image_t mono_assembly_get_image = nullptr; +mono_method_get_class_t mono_method_get_class = nullptr; +mono_object_get_class_t mono_object_get_class = nullptr; +mono_class_is_valuetype_t mono_class_is_valuetype = nullptr; +mono_signature_get_param_count_t mono_signature_get_param_count = nullptr; +mono_string_to_utf8_t mono_string_to_utf8 = nullptr; +mono_string_new_wrapper_t mono_string_new_wrapper = nullptr; +mono_class_get_parent_t mono_class_get_parent = nullptr; +mono_class_get_namespace_t mono_class_get_namespace = nullptr; +mono_class_is_subclass_of_t mono_class_is_subclass_of = nullptr; +mono_class_get_name_t mono_class_get_name = nullptr; +mono_type_get_name_t mono_type_get_name = nullptr; +mono_type_get_class_t mono_type_get_class = nullptr; +mono_exception_from_name_msg_t mono_exception_from_name_msg = nullptr; +mono_raise_exception_t mono_raise_exception = nullptr; +mono_get_exception_class_t mono_get_exception_class = nullptr; +mono_get_array_class_t mono_get_array_class = nullptr; +mono_get_string_class_t mono_get_string_class = nullptr; +mono_get_int32_class_t mono_get_int32_class = nullptr; +mono_array_new_t mono_array_new = nullptr; +mono_array_new_full_t mono_array_new_full = nullptr; +mono_array_class_get_t mono_array_class_get = nullptr; +mono_class_array_element_size_t mono_class_array_element_size = nullptr; +mono_type_get_object_t mono_type_get_object = nullptr; +mono_thread_attach_t mono_thread_attach = nullptr; +mono_thread_detach_t mono_thread_detach = nullptr; +mono_thread_exit_t mono_thread_exit = nullptr; +mono_thread_current_t mono_thread_current = nullptr; +mono_thread_set_main_t mono_thread_set_main = nullptr; +mono_set_find_plugin_callback_t mono_set_find_plugin_callback = nullptr; +mono_security_enable_core_clr_t mono_security_enable_core_clr = nullptr; +mono_security_set_core_clr_platform_callback_t mono_security_set_core_clr_platform_callback = nullptr; +mono_runtime_unhandled_exception_policy_get_t mono_runtime_unhandled_exception_policy_get = nullptr; +mono_runtime_unhandled_exception_policy_set_t mono_runtime_unhandled_exception_policy_set = nullptr; +mono_class_get_nesting_type_t mono_class_get_nesting_type = nullptr; +mono_class_vtable_t mono_class_vtable = nullptr; +mono_method_get_object_t mono_method_get_object = nullptr; +mono_method_signature_t mono_method_signature = nullptr; +mono_signature_get_params_t mono_signature_get_params = nullptr; +mono_signature_get_return_type_t mono_signature_get_return_type = nullptr; +mono_class_get_type_t mono_class_get_type = nullptr; +mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded_t mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded = nullptr; +mono_debug_init_t mono_debug_init = nullptr; +mono_debug_open_image_from_memory_t mono_debug_open_image_from_memory = nullptr; +mono_field_get_flags_t mono_field_get_flags = nullptr; +mono_image_open_from_data_full_t mono_image_open_from_data_full = nullptr; +mono_image_open_from_data_with_name_t mono_image_open_from_data_with_name = nullptr; +mono_assembly_load_from_t mono_assembly_load_from = nullptr; +mono_value_box_t mono_value_box = nullptr; +mono_class_get_image_t mono_class_get_image = nullptr; +mono_signature_is_instance_t mono_signature_is_instance = nullptr; +mono_method_get_last_managed_t mono_method_get_last_managed = nullptr; +mono_get_enum_class_t mono_get_enum_class = nullptr; +mono_class_get_byref_type_t mono_class_get_byref_type = nullptr; +mono_field_static_get_value_t mono_field_static_get_value = nullptr; +mono_unity_set_embeddinghostname_t mono_unity_set_embeddinghostname = nullptr; +mono_set_assemblies_path_t mono_set_assemblies_path = nullptr; +mono_gchandle_new_t mono_gchandle_new = nullptr; +mono_gchandle_get_target_t mono_gchandle_get_target = nullptr; +mono_gchandle_new_weakref_t mono_gchandle_new_weakref = nullptr; +mono_assembly_get_object_t mono_assembly_get_object = nullptr; +mono_gchandle_free_t mono_gchandle_free = nullptr; +mono_class_get_properties_t mono_class_get_properties = nullptr; +mono_property_get_get_method_t mono_property_get_get_method = nullptr; +mono_object_new_alloc_specific_t mono_object_new_alloc_specific = nullptr; +mono_object_new_specific_t mono_object_new_specific = nullptr; +mono_gc_collect_t mono_gc_collect = nullptr; +mono_gc_max_generation_t mono_gc_max_generation = nullptr; +mono_image_get_assembly_t mono_image_get_assembly = nullptr; +mono_assembly_open_t mono_assembly_open = nullptr; +mono_class_is_enum_t mono_class_is_enum = nullptr; +mono_class_instance_size_t mono_class_instance_size = nullptr; +mono_object_get_size_t mono_object_get_size = nullptr; +mono_image_get_filename_t mono_image_get_filename = nullptr; +mono_assembly_load_from_full_t mono_assembly_load_from_full = nullptr; +mono_class_get_interfaces_t mono_class_get_interfaces = nullptr; +mono_assembly_close_t mono_assembly_close = nullptr; +mono_class_get_property_from_name_t mono_class_get_property_from_name = nullptr; +mono_class_get_method_from_name_t mono_class_get_method_from_name = nullptr; +mono_class_from_mono_type_t mono_class_from_mono_type = nullptr; +mono_domain_set_t mono_domain_set = nullptr; +mono_thread_push_appdomain_ref_t mono_thread_push_appdomain_ref = nullptr; +mono_thread_pop_appdomain_ref_t mono_thread_pop_appdomain_ref = nullptr; +mono_runtime_exec_main_t mono_runtime_exec_main = nullptr; +mono_get_corlib_t mono_get_corlib = nullptr; +mono_class_get_field_from_name_t mono_class_get_field_from_name = nullptr; +mono_class_get_flags_t mono_class_get_flags = nullptr; +mono_parse_default_optimizations_t mono_parse_default_optimizations = nullptr; +mono_set_defaults_t mono_set_defaults = nullptr; +mono_set_dirs_t mono_set_dirs = nullptr; +mono_jit_parse_options_t mono_jit_parse_options = nullptr; +mono_object_unbox_t mono_object_unbox = nullptr; +mono_custom_attrs_get_attr_t mono_custom_attrs_get_attr = nullptr; +mono_custom_attrs_has_attr_t mono_custom_attrs_has_attr = nullptr; +mono_custom_attrs_from_field_t mono_custom_attrs_from_field = nullptr; +mono_custom_attrs_from_method_t mono_custom_attrs_from_method = nullptr; +mono_custom_attrs_from_class_t mono_custom_attrs_from_class = nullptr; +mono_custom_attrs_free_t mono_custom_attrs_free = nullptr; +g_free_t g_free = nullptr; +mono_runtime_is_shutting_down_t mono_runtime_is_shutting_down = nullptr; +mono_object_get_virtual_method_t mono_object_get_virtual_method = nullptr; +mono_jit_info_get_code_start_t mono_jit_info_get_code_start = nullptr; +mono_jit_info_get_code_size_t mono_jit_info_get_code_size = nullptr; +mono_class_from_name_case_t mono_class_from_name_case = nullptr; +mono_class_get_nested_types_t mono_class_get_nested_types = nullptr; +mono_class_get_userdata_offset_t mono_class_get_userdata_offset = nullptr; +mono_class_get_userdata_t mono_class_get_userdata = nullptr; +mono_class_set_userdata_t mono_class_set_userdata = nullptr; +mono_set_signal_chaining_t mono_set_signal_chaining = nullptr; +// mono_unity_seh_handler_t mono_unity_seh_handler = nullptr; +mono_unity_set_unhandled_exception_handler_t mono_unity_set_unhandled_exception_handler = nullptr; +mono_runtime_invoke_array_t mono_runtime_invoke_array = nullptr; +mono_array_addr_with_size_t mono_array_addr_with_size = nullptr; +mono_string_to_utf16_t mono_string_to_utf16 = nullptr; +mono_field_get_parent_t mono_field_get_parent = nullptr; +mono_method_full_name_t mono_method_full_name = nullptr; +mono_object_isinst_t mono_object_isinst = nullptr; +mono_string_new_len_t mono_string_new_len = nullptr; +mono_string_from_utf16_t mono_string_from_utf16 = nullptr; +mono_get_exception_argument_null_t mono_get_exception_argument_null = nullptr; +mono_get_boolean_class_t mono_get_boolean_class = nullptr; +mono_get_byte_class_t mono_get_byte_class = nullptr; +mono_get_char_class_t mono_get_char_class = nullptr; +mono_get_int16_class_t mono_get_int16_class = nullptr; +mono_get_int64_class_t mono_get_int64_class = nullptr; +mono_get_single_class_t mono_get_single_class = nullptr; +mono_get_double_class_t mono_get_double_class = nullptr; +mono_class_is_generic_t mono_class_is_generic = nullptr; +mono_class_is_inflated_t mono_class_is_inflated = nullptr; +unity_mono_method_is_generic_t unity_mono_method_is_generic = nullptr; +unity_mono_method_is_inflated_t unity_mono_method_is_inflated = nullptr; +mono_is_debugger_attached_t mono_is_debugger_attached = nullptr; +mono_assembly_fill_assembly_name_t mono_assembly_fill_assembly_name = nullptr; +mono_stringify_assembly_name_t mono_stringify_assembly_name = nullptr; +mono_assembly_name_parse_t mono_assembly_name_parse = nullptr; +mono_assembly_loaded_t mono_assembly_loaded = nullptr; +mono_image_get_table_rows_t mono_image_get_table_rows = nullptr; +mono_class_get_t mono_class_get = nullptr; +mono_metadata_signature_equal_t mono_metadata_signature_equal = nullptr; +mono_gchandle_is_in_domain_t mono_gchandle_is_in_domain = nullptr; +mono_stack_walk_t mono_stack_walk = nullptr; +mono_pmip_t mono_pmip = nullptr; +mono_runtime_delegate_invoke_t mono_runtime_delegate_invoke = nullptr; +mono_jit_info_table_find_t mono_jit_info_table_find = nullptr; +mono_debug_lookup_source_location_t mono_debug_lookup_source_location = nullptr; +mono_debug_free_source_location_t mono_debug_free_source_location = nullptr; +mono_gc_wbarrier_generic_store_t mono_gc_wbarrier_generic_store = nullptr; +mono_class_enum_basetype_t mono_class_enum_basetype = nullptr; +mono_class_get_type_token_t mono_class_get_type_token = nullptr; +mono_class_get_rank_t mono_class_get_rank = nullptr; +mono_class_get_element_class_t mono_class_get_element_class = nullptr; +mono_unity_class_is_interface_t mono_unity_class_is_interface = nullptr; +mono_unity_class_is_abstract_t mono_unity_class_is_abstract = nullptr; +mono_array_element_size_t mono_array_element_size = nullptr; +mono_config_parse_t mono_config_parse = nullptr; +mono_set_break_policy_t mono_set_break_policy = nullptr; +mono_custom_attrs_construct_t mono_custom_attrs_construct = nullptr; +mono_custom_attrs_from_assembly_t mono_custom_attrs_from_assembly = nullptr; +mono_reflection_get_custom_attrs_by_type_t mono_reflection_get_custom_attrs_by_type = nullptr; +mono_loader_get_last_error_t mono_loader_get_last_error = nullptr; +mono_loader_error_prepare_exception_t mono_loader_error_prepare_exception = nullptr; +mono_dl_fallback_register_t mono_dl_fallback_register = nullptr; +mono_dl_fallback_unregister_t mono_dl_fallback_unregister = nullptr; +mono_unity_liveness_allocate_struct_t mono_unity_liveness_allocate_struct = nullptr; +mono_unity_liveness_stop_gc_world_t mono_unity_liveness_stop_gc_world = nullptr; +mono_unity_liveness_finalize_t mono_unity_liveness_finalize = nullptr; +mono_unity_liveness_start_gc_world_t mono_unity_liveness_start_gc_world = nullptr; +mono_unity_liveness_free_struct_t mono_unity_liveness_free_struct = nullptr; +mono_unity_liveness_calculation_begin_t mono_unity_liveness_calculation_begin = nullptr; +mono_unity_liveness_calculation_end_t mono_unity_liveness_calculation_end = nullptr; +mono_unity_liveness_calculation_from_root_t mono_unity_liveness_calculation_from_root = nullptr; +mono_unity_liveness_calculation_from_statics_t mono_unity_liveness_calculation_from_statics = nullptr; +mono_trace_set_level_string_t mono_trace_set_level_string = nullptr; +mono_trace_set_mask_string_t mono_trace_set_mask_string = nullptr; +mono_gc_get_used_size_t mono_gc_get_used_size = nullptr; +mono_gc_get_heap_size_t mono_gc_get_heap_size = nullptr; +mono_method_desc_search_in_class_t mono_method_desc_search_in_class = nullptr; +mono_method_desc_free_t mono_method_desc_free = nullptr; +mono_type_get_name_full_t mono_type_get_name_full = nullptr; +mono_unity_thread_clear_domain_fields_t mono_unity_thread_clear_domain_fields = nullptr; +// mono_unity_set_vprintf_func_t mono_unity_set_vprintf_func = nullptr; +mono_profiler_install_t mono_profiler_install = nullptr; +mono_profiler_set_events_t mono_profiler_set_events = nullptr; +mono_profiler_install_enter_leave_t mono_profiler_install_enter_leave = nullptr; +mono_profiler_install_gc_t mono_profiler_install_gc = nullptr; +mono_profiler_install_allocation_t mono_profiler_install_allocation = nullptr; +mono_profiler_install_jit_end_t mono_profiler_install_jit_end = nullptr; +mono_profiler_install_exception_t mono_profiler_install_exception = nullptr; +mono_profiler_install_thread_t mono_profiler_install_thread = nullptr; + +void load_mono_functions_from_dll(HMODULE dll) +{ + mono_compile_method=(mono_compile_method_t)(GetProcAddress(dll, "mono_compile_method")); + mono_thread_suspend_all_other_threads = (mono_thread_suspend_all_other_threads_t)(GetProcAddress(dll, "mono_thread_suspend_all_other_threads")); + mono_thread_pool_cleanup = (mono_thread_pool_cleanup_t)(GetProcAddress(dll, "mono_thread_pool_cleanup")); + mono_threads_set_shutting_down = (mono_threads_set_shutting_down_t)(GetProcAddress(dll, "mono_threads_set_shutting_down")); + mono_runtime_set_shutting_down = (mono_runtime_set_shutting_down_t)(GetProcAddress(dll, "mono_runtime_set_shutting_down")); + mono_domain_finalize = (mono_domain_finalize_t)(GetProcAddress(dll, "mono_domain_finalize")); + mono_runtime_cleanup = (mono_runtime_cleanup_t)(GetProcAddress(dll, "mono_runtime_cleanup")); + mono_method_desc_new = (mono_method_desc_new_t)(GetProcAddress(dll, "mono_method_desc_new")); + mono_method_desc_search_in_image = (mono_method_desc_search_in_image_t)(GetProcAddress(dll, "mono_method_desc_search_in_image")); + mono_verifier_set_mode = (mono_verifier_set_mode_t)(GetProcAddress(dll, "mono_verifier_set_mode")); + mono_security_set_mode = (mono_security_set_mode_t)(GetProcAddress(dll, "mono_security_set_mode")); + mono_add_internal_call = (mono_add_internal_call_t)(GetProcAddress(dll, "mono_add_internal_call")); + mono_jit_cleanup = (mono_jit_cleanup_t)(GetProcAddress(dll, "mono_jit_cleanup")); + mono_jit_init = (mono_jit_init_t)(GetProcAddress(dll, "mono_jit_init")); + mono_jit_init_version = (mono_jit_init_version_t)(GetProcAddress(dll, "mono_jit_init_version")); + mono_jit_exec = (mono_jit_exec_t)(GetProcAddress(dll, "mono_jit_exec")); + mono_class_from_name = (mono_class_from_name_t)(GetProcAddress(dll, "mono_class_from_name")); + mono_domain_assembly_open = (mono_domain_assembly_open_t)(GetProcAddress(dll, "mono_domain_assembly_open")); + mono_domain_create_appdomain = (mono_domain_create_appdomain_t)(GetProcAddress(dll, "mono_domain_create_appdomain")); + mono_domain_unload = (mono_domain_unload_t)(GetProcAddress(dll, "mono_domain_unload")); + mono_object_new = (mono_object_new_t)(GetProcAddress(dll, "mono_object_new")); + mono_runtime_object_init = (mono_runtime_object_init_t)(GetProcAddress(dll, "mono_runtime_object_init")); + mono_runtime_invoke = (mono_runtime_invoke_t)(GetProcAddress(dll, "mono_runtime_invoke")); + mono_field_set_value = (mono_field_set_value_t)(GetProcAddress(dll, "mono_field_set_value")); + mono_field_get_value = (mono_field_get_value_t)(GetProcAddress(dll, "mono_field_get_value")); + mono_field_get_offset = (mono_field_get_offset_t)(GetProcAddress(dll, "mono_field_get_offset")); + mono_class_get_fields = (mono_class_get_fields_t)(GetProcAddress(dll, "mono_class_get_fields")); + mono_class_get_methods = (mono_class_get_methods_t)(GetProcAddress(dll, "mono_class_get_methods")); + mono_domain_get = (mono_domain_get_t)(GetProcAddress(dll, "mono_domain_get")); + mono_get_root_domain = (mono_get_root_domain_t)(GetProcAddress(dll, "mono_get_root_domain")); + mono_domain_get_id = (mono_domain_get_id_t)(GetProcAddress(dll, "mono_domain_get_id")); + mono_assembly_foreach = (mono_assembly_foreach_t)(GetProcAddress(dll, "mono_assembly_foreach")); + mono_image_close = (mono_image_close_t)(GetProcAddress(dll, "mono_image_close")); + mono_unity_socket_security_enabled_set = (mono_unity_socket_security_enabled_set_t)(GetProcAddress(dll, "mono_unity_socket_security_enabled_set")); + mono_image_get_name = (mono_image_get_name_t)(GetProcAddress(dll, "mono_image_get_name")); + mono_get_object_class = (mono_get_object_class_t)(GetProcAddress(dll, "mono_get_object_class")); + mono_set_commandline_arguments = (mono_set_commandline_arguments_t)(GetProcAddress(dll, "mono_set_commandline_arguments")); + mono_field_get_name = (mono_field_get_name_t)(GetProcAddress(dll, "mono_field_get_name")); + mono_field_get_type = (mono_field_get_type_t)(GetProcAddress(dll, "mono_field_get_type")); + mono_type_get_type = (mono_type_get_type_t)(GetProcAddress(dll, "mono_type_get_type")); + mono_method_get_name = (mono_method_get_name_t)(GetProcAddress(dll, "mono_method_get_name")); + mono_assembly_get_image = (mono_assembly_get_image_t)(GetProcAddress(dll, "mono_assembly_get_image")); + mono_method_get_class = (mono_method_get_class_t)(GetProcAddress(dll, "mono_method_get_class")); + mono_object_get_class = (mono_object_get_class_t)(GetProcAddress(dll, "mono_object_get_class")); + mono_class_is_valuetype = (mono_class_is_valuetype_t)(GetProcAddress(dll, "mono_class_is_valuetype")); + mono_signature_get_param_count = (mono_signature_get_param_count_t)(GetProcAddress(dll, "mono_signature_get_param_count")); + mono_string_to_utf8 = (mono_string_to_utf8_t)(GetProcAddress(dll, "mono_string_to_utf8")); + mono_string_new_wrapper = (mono_string_new_wrapper_t)(GetProcAddress(dll, "mono_string_new_wrapper")); + mono_class_get_parent = (mono_class_get_parent_t)(GetProcAddress(dll, "mono_class_get_parent")); + mono_class_get_namespace = (mono_class_get_namespace_t)(GetProcAddress(dll, "mono_class_get_namespace")); + mono_class_is_subclass_of = (mono_class_is_subclass_of_t)(GetProcAddress(dll, "mono_class_is_subclass_of")); + mono_class_get_name = (mono_class_get_name_t)(GetProcAddress(dll, "mono_class_get_name")); + mono_type_get_name = (mono_type_get_name_t)(GetProcAddress(dll, "mono_type_get_name")); + mono_type_get_class = (mono_type_get_class_t)(GetProcAddress(dll, "mono_type_get_class")); + mono_exception_from_name_msg = (mono_exception_from_name_msg_t)(GetProcAddress(dll, "mono_exception_from_name_msg")); + mono_raise_exception = (mono_raise_exception_t)(GetProcAddress(dll, "mono_raise_exception")); + mono_get_exception_class = (mono_get_exception_class_t)(GetProcAddress(dll, "mono_get_exception_class")); + mono_get_array_class = (mono_get_array_class_t)(GetProcAddress(dll, "mono_get_array_class")); + mono_get_string_class = (mono_get_string_class_t)(GetProcAddress(dll, "mono_get_string_class")); + mono_get_int32_class = (mono_get_int32_class_t)(GetProcAddress(dll, "mono_get_int32_class")); + mono_array_new = (mono_array_new_t)(GetProcAddress(dll, "mono_array_new")); + mono_array_new_full = (mono_array_new_full_t)(GetProcAddress(dll, "mono_array_new_full")); + mono_array_class_get = (mono_array_class_get_t)(GetProcAddress(dll, "mono_array_class_get")); + mono_class_array_element_size = (mono_class_array_element_size_t)(GetProcAddress(dll, "mono_class_array_element_size")); + mono_type_get_object = (mono_type_get_object_t)(GetProcAddress(dll, "mono_type_get_object")); + mono_thread_attach = (mono_thread_attach_t)(GetProcAddress(dll, "mono_thread_attach")); + mono_thread_detach = (mono_thread_detach_t)(GetProcAddress(dll, "mono_thread_detach")); + mono_thread_exit = (mono_thread_exit_t)(GetProcAddress(dll, "mono_thread_exit")); + mono_thread_current = (mono_thread_current_t)(GetProcAddress(dll, "mono_thread_current")); + mono_thread_set_main = (mono_thread_set_main_t)(GetProcAddress(dll, "mono_thread_set_main")); + mono_set_find_plugin_callback = (mono_set_find_plugin_callback_t)(GetProcAddress(dll, "mono_set_find_plugin_callback")); + mono_security_enable_core_clr = (mono_security_enable_core_clr_t)(GetProcAddress(dll, "mono_security_enable_core_clr")); + mono_security_set_core_clr_platform_callback = (mono_security_set_core_clr_platform_callback_t)(GetProcAddress(dll, "mono_security_set_core_clr_platform_callback")); + mono_runtime_unhandled_exception_policy_get = (mono_runtime_unhandled_exception_policy_get_t)(GetProcAddress(dll, "mono_runtime_unhandled_exception_policy_get")); + mono_runtime_unhandled_exception_policy_set = (mono_runtime_unhandled_exception_policy_set_t)(GetProcAddress(dll, "mono_runtime_unhandled_exception_policy_set")); + mono_class_get_nesting_type = (mono_class_get_nesting_type_t)(GetProcAddress(dll, "mono_class_get_nesting_type")); + mono_class_vtable = (mono_class_vtable_t)(GetProcAddress(dll, "mono_class_vtable")); + mono_method_get_object = (mono_method_get_object_t)(GetProcAddress(dll, "mono_method_get_object")); + mono_method_signature = (mono_method_signature_t)(GetProcAddress(dll, "mono_method_signature")); + mono_signature_get_params = (mono_signature_get_params_t)(GetProcAddress(dll, "mono_signature_get_params")); + mono_signature_get_return_type = (mono_signature_get_return_type_t)(GetProcAddress(dll, "mono_signature_get_return_type")); + mono_class_get_type = (mono_class_get_type_t)(GetProcAddress(dll, "mono_class_get_type")); + mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded = (mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded_t)(GetProcAddress(dll, "mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded")); + mono_debug_init = (mono_debug_init_t)(GetProcAddress(dll, "mono_debug_init")); + mono_debug_open_image_from_memory = (mono_debug_open_image_from_memory_t)(GetProcAddress(dll, "mono_debug_open_image_from_memory")); + mono_field_get_flags = (mono_field_get_flags_t)(GetProcAddress(dll, "mono_field_get_flags")); + mono_image_open_from_data_full = (mono_image_open_from_data_full_t)(GetProcAddress(dll, "mono_image_open_from_data_full")); + mono_image_open_from_data_with_name = (mono_image_open_from_data_with_name_t)(GetProcAddress(dll, "mono_image_open_from_data_with_name")); + mono_assembly_load_from = (mono_assembly_load_from_t)(GetProcAddress(dll, "mono_assembly_load_from")); + mono_value_box = (mono_value_box_t)(GetProcAddress(dll, "mono_value_box")); + mono_class_get_image = (mono_class_get_image_t)(GetProcAddress(dll, "mono_class_get_image")); + mono_signature_is_instance = (mono_signature_is_instance_t)(GetProcAddress(dll, "mono_signature_is_instance")); + mono_method_get_last_managed = (mono_method_get_last_managed_t)(GetProcAddress(dll, "mono_method_get_last_managed")); + mono_get_enum_class = (mono_get_enum_class_t)(GetProcAddress(dll, "mono_get_enum_class")); + mono_class_get_byref_type = (mono_class_get_byref_type_t)(GetProcAddress(dll, "mono_class_get_byref_type")); + mono_field_static_get_value = (mono_field_static_get_value_t)(GetProcAddress(dll, "mono_field_static_get_value")); + mono_unity_set_embeddinghostname = (mono_unity_set_embeddinghostname_t)(GetProcAddress(dll, "mono_unity_set_embeddinghostname")); + mono_set_assemblies_path = (mono_set_assemblies_path_t)(GetProcAddress(dll, "mono_set_assemblies_path")); + mono_gchandle_new = (mono_gchandle_new_t)(GetProcAddress(dll, "mono_gchandle_new")); + mono_gchandle_get_target = (mono_gchandle_get_target_t)(GetProcAddress(dll, "mono_gchandle_get_target")); + mono_gchandle_new_weakref = (mono_gchandle_new_weakref_t)(GetProcAddress(dll, "mono_gchandle_new_weakref")); + mono_assembly_get_object = (mono_assembly_get_object_t)(GetProcAddress(dll, "mono_assembly_get_object")); + mono_gchandle_free = (mono_gchandle_free_t)(GetProcAddress(dll, "mono_gchandle_free")); + mono_class_get_properties = (mono_class_get_properties_t)(GetProcAddress(dll, "mono_class_get_properties")); + mono_property_get_get_method = (mono_property_get_get_method_t)(GetProcAddress(dll, "mono_property_get_get_method")); + mono_object_new_alloc_specific = (mono_object_new_alloc_specific_t)(GetProcAddress(dll, "mono_object_new_alloc_specific")); + mono_object_new_specific = (mono_object_new_specific_t)(GetProcAddress(dll, "mono_object_new_specific")); + mono_gc_collect = (mono_gc_collect_t)(GetProcAddress(dll, "mono_gc_collect")); + mono_gc_max_generation = (mono_gc_max_generation_t)(GetProcAddress(dll, "mono_gc_max_generation")); + mono_image_get_assembly = (mono_image_get_assembly_t)(GetProcAddress(dll, "mono_image_get_assembly")); + mono_assembly_open = (mono_assembly_open_t)(GetProcAddress(dll, "mono_assembly_open")); + mono_class_is_enum = (mono_class_is_enum_t)(GetProcAddress(dll, "mono_class_is_enum")); + mono_class_instance_size = (mono_class_instance_size_t)(GetProcAddress(dll, "mono_class_instance_size")); + mono_object_get_size = (mono_object_get_size_t)(GetProcAddress(dll, "mono_object_get_size")); + mono_image_get_filename = (mono_image_get_filename_t)(GetProcAddress(dll, "mono_image_get_filename")); + mono_assembly_load_from_full = (mono_assembly_load_from_full_t)(GetProcAddress(dll, "mono_assembly_load_from_full")); + mono_class_get_interfaces = (mono_class_get_interfaces_t)(GetProcAddress(dll, "mono_class_get_interfaces")); + mono_assembly_close = (mono_assembly_close_t)(GetProcAddress(dll, "mono_assembly_close")); + mono_class_get_property_from_name = (mono_class_get_property_from_name_t)(GetProcAddress(dll, "mono_class_get_property_from_name")); + mono_class_get_method_from_name = (mono_class_get_method_from_name_t)(GetProcAddress(dll, "mono_class_get_method_from_name")); + mono_class_from_mono_type = (mono_class_from_mono_type_t)(GetProcAddress(dll, "mono_class_from_mono_type")); + mono_domain_set = (mono_domain_set_t)(GetProcAddress(dll, "mono_domain_set")); + mono_thread_push_appdomain_ref = (mono_thread_push_appdomain_ref_t)(GetProcAddress(dll, "mono_thread_push_appdomain_ref")); + mono_thread_pop_appdomain_ref = (mono_thread_pop_appdomain_ref_t)(GetProcAddress(dll, "mono_thread_pop_appdomain_ref")); + mono_runtime_exec_main = (mono_runtime_exec_main_t)(GetProcAddress(dll, "mono_runtime_exec_main")); + mono_get_corlib = (mono_get_corlib_t)(GetProcAddress(dll, "mono_get_corlib")); + mono_class_get_field_from_name = (mono_class_get_field_from_name_t)(GetProcAddress(dll, "mono_class_get_field_from_name")); + mono_class_get_flags = (mono_class_get_flags_t)(GetProcAddress(dll, "mono_class_get_flags")); + mono_parse_default_optimizations = (mono_parse_default_optimizations_t)(GetProcAddress(dll, "mono_parse_default_optimizations")); + mono_set_defaults = (mono_set_defaults_t)(GetProcAddress(dll, "mono_set_defaults")); + mono_set_dirs = (mono_set_dirs_t)(GetProcAddress(dll, "mono_set_dirs")); + mono_jit_parse_options = (mono_jit_parse_options_t)(GetProcAddress(dll, "mono_jit_parse_options")); + mono_object_unbox = (mono_object_unbox_t)(GetProcAddress(dll, "mono_object_unbox")); + mono_custom_attrs_get_attr = (mono_custom_attrs_get_attr_t)(GetProcAddress(dll, "mono_custom_attrs_get_attr")); + mono_custom_attrs_has_attr = (mono_custom_attrs_has_attr_t)(GetProcAddress(dll, "mono_custom_attrs_has_attr")); + mono_custom_attrs_from_field = (mono_custom_attrs_from_field_t)(GetProcAddress(dll, "mono_custom_attrs_from_field")); + mono_custom_attrs_from_method = (mono_custom_attrs_from_method_t)(GetProcAddress(dll, "mono_custom_attrs_from_method")); + mono_custom_attrs_from_class = (mono_custom_attrs_from_class_t)(GetProcAddress(dll, "mono_custom_attrs_from_class")); + mono_custom_attrs_free = (mono_custom_attrs_free_t)(GetProcAddress(dll, "mono_custom_attrs_free")); + g_free = (g_free_t)(GetProcAddress(dll, "g_free")); + mono_runtime_is_shutting_down = (mono_runtime_is_shutting_down_t)(GetProcAddress(dll, "mono_runtime_is_shutting_down")); + mono_object_get_virtual_method = (mono_object_get_virtual_method_t)(GetProcAddress(dll, "mono_object_get_virtual_method")); + mono_jit_info_get_code_start = (mono_jit_info_get_code_start_t)(GetProcAddress(dll, "mono_jit_info_get_code_start")); + mono_jit_info_get_code_size = (mono_jit_info_get_code_size_t)(GetProcAddress(dll, "mono_jit_info_get_code_size")); + mono_class_from_name_case = (mono_class_from_name_case_t)(GetProcAddress(dll, "mono_class_from_name_case")); + mono_class_get_nested_types = (mono_class_get_nested_types_t)(GetProcAddress(dll, "mono_class_get_nested_types")); + mono_class_get_userdata_offset = (mono_class_get_userdata_offset_t)(GetProcAddress(dll, "mono_class_get_userdata_offset")); + mono_class_get_userdata = (mono_class_get_userdata_t)(GetProcAddress(dll, "mono_class_get_userdata")); + mono_class_set_userdata = (mono_class_set_userdata_t)(GetProcAddress(dll, "mono_class_set_userdata")); + mono_set_signal_chaining = (mono_set_signal_chaining_t)(GetProcAddress(dll, "mono_set_signal_chaining")); + // mono_unity_seh_handler = (mono_unity_seh_handler_t)(GetProcAddress(dll, "mono_unity_seh_handler")); + mono_unity_set_unhandled_exception_handler = (mono_unity_set_unhandled_exception_handler_t)(GetProcAddress(dll, "mono_unity_set_unhandled_exception_handler")); + mono_runtime_invoke_array = (mono_runtime_invoke_array_t)(GetProcAddress(dll, "mono_runtime_invoke_array")); + mono_array_addr_with_size = (mono_array_addr_with_size_t)(GetProcAddress(dll, "mono_array_addr_with_size")); + mono_string_to_utf16 = (mono_string_to_utf16_t)(GetProcAddress(dll, "mono_string_to_utf16")); + mono_field_get_parent = (mono_field_get_parent_t)(GetProcAddress(dll, "mono_field_get_parent")); + mono_method_full_name = (mono_method_full_name_t)(GetProcAddress(dll, "mono_method_full_name")); + mono_object_isinst = (mono_object_isinst_t)(GetProcAddress(dll, "mono_object_isinst")); + mono_string_new_len = (mono_string_new_len_t)(GetProcAddress(dll, "mono_string_new_len")); + mono_string_from_utf16 = (mono_string_from_utf16_t)(GetProcAddress(dll, "mono_string_from_utf16")); + mono_get_exception_argument_null = (mono_get_exception_argument_null_t)(GetProcAddress(dll, "mono_get_exception_argument_null")); + mono_get_boolean_class = (mono_get_boolean_class_t)(GetProcAddress(dll, "mono_get_boolean_class")); + mono_get_byte_class = (mono_get_byte_class_t)(GetProcAddress(dll, "mono_get_byte_class")); + mono_get_char_class = (mono_get_char_class_t)(GetProcAddress(dll, "mono_get_char_class")); + mono_get_int16_class = (mono_get_int16_class_t)(GetProcAddress(dll, "mono_get_int16_class")); + mono_get_int64_class = (mono_get_int64_class_t)(GetProcAddress(dll, "mono_get_int64_class")); + mono_get_single_class = (mono_get_single_class_t)(GetProcAddress(dll, "mono_get_single_class")); + mono_get_double_class = (mono_get_double_class_t)(GetProcAddress(dll, "mono_get_double_class")); + mono_class_is_generic = (mono_class_is_generic_t)(GetProcAddress(dll, "mono_class_is_generic")); + mono_class_is_inflated = (mono_class_is_inflated_t)(GetProcAddress(dll, "mono_class_is_inflated")); + unity_mono_method_is_generic = (unity_mono_method_is_generic_t)(GetProcAddress(dll, "unity_mono_method_is_generic")); + unity_mono_method_is_inflated = (unity_mono_method_is_inflated_t)(GetProcAddress(dll, "unity_mono_method_is_inflated")); + mono_is_debugger_attached = (mono_is_debugger_attached_t)(GetProcAddress(dll, "mono_is_debugger_attached")); + mono_assembly_fill_assembly_name = (mono_assembly_fill_assembly_name_t)(GetProcAddress(dll, "mono_assembly_fill_assembly_name")); + mono_stringify_assembly_name = (mono_stringify_assembly_name_t)(GetProcAddress(dll, "mono_stringify_assembly_name")); + mono_assembly_name_parse = (mono_assembly_name_parse_t)(GetProcAddress(dll, "mono_assembly_name_parse")); + mono_assembly_loaded = (mono_assembly_loaded_t)(GetProcAddress(dll, "mono_assembly_loaded")); + mono_image_get_table_rows = (mono_image_get_table_rows_t)(GetProcAddress(dll, "mono_image_get_table_rows")); + mono_class_get = (mono_class_get_t)(GetProcAddress(dll, "mono_class_get")); + mono_metadata_signature_equal = (mono_metadata_signature_equal_t)(GetProcAddress(dll, "mono_metadata_signature_equal")); + mono_gchandle_is_in_domain = (mono_gchandle_is_in_domain_t)(GetProcAddress(dll, "mono_gchandle_is_in_domain")); + mono_stack_walk = (mono_stack_walk_t)(GetProcAddress(dll, "mono_stack_walk")); + mono_pmip = (mono_pmip_t)(GetProcAddress(dll, "mono_pmip")); + mono_runtime_delegate_invoke = (mono_runtime_delegate_invoke_t)(GetProcAddress(dll, "mono_runtime_delegate_invoke")); + mono_jit_info_table_find = (mono_jit_info_table_find_t)(GetProcAddress(dll, "mono_jit_info_table_find")); + mono_debug_lookup_source_location = (mono_debug_lookup_source_location_t)(GetProcAddress(dll, "mono_debug_lookup_source_location")); + mono_debug_free_source_location = (mono_debug_free_source_location_t)(GetProcAddress(dll, "mono_debug_free_source_location")); + mono_gc_wbarrier_generic_store = (mono_gc_wbarrier_generic_store_t)(GetProcAddress(dll, "mono_gc_wbarrier_generic_store")); + mono_class_enum_basetype = (mono_class_enum_basetype_t)(GetProcAddress(dll, "mono_class_enum_basetype")); + mono_class_get_type_token = (mono_class_get_type_token_t)(GetProcAddress(dll, "mono_class_get_type_token")); + mono_class_get_rank = (mono_class_get_rank_t)(GetProcAddress(dll, "mono_class_get_rank")); + mono_class_get_element_class = (mono_class_get_element_class_t)(GetProcAddress(dll, "mono_class_get_element_class")); + mono_unity_class_is_interface = (mono_unity_class_is_interface_t)(GetProcAddress(dll, "mono_unity_class_is_interface")); + mono_unity_class_is_abstract = (mono_unity_class_is_abstract_t)(GetProcAddress(dll, "mono_unity_class_is_abstract")); + mono_array_element_size = (mono_array_element_size_t)(GetProcAddress(dll, "mono_array_element_size")); + mono_config_parse = (mono_config_parse_t)(GetProcAddress(dll, "mono_config_parse")); + mono_set_break_policy = (mono_set_break_policy_t)(GetProcAddress(dll, "mono_set_break_policy")); + mono_custom_attrs_construct = (mono_custom_attrs_construct_t)(GetProcAddress(dll, "mono_custom_attrs_construct")); + mono_custom_attrs_from_assembly = (mono_custom_attrs_from_assembly_t)(GetProcAddress(dll, "mono_custom_attrs_from_assembly")); + mono_reflection_get_custom_attrs_by_type = (mono_reflection_get_custom_attrs_by_type_t)(GetProcAddress(dll, "mono_reflection_get_custom_attrs_by_type")); + mono_loader_get_last_error = (mono_loader_get_last_error_t)(GetProcAddress(dll, "mono_loader_get_last_error")); + mono_loader_error_prepare_exception = (mono_loader_error_prepare_exception_t)(GetProcAddress(dll, "mono_loader_error_prepare_exception")); + mono_dl_fallback_register = (mono_dl_fallback_register_t)(GetProcAddress(dll, "mono_dl_fallback_register")); + mono_dl_fallback_unregister = (mono_dl_fallback_unregister_t)(GetProcAddress(dll, "mono_dl_fallback_unregister")); + mono_unity_liveness_allocate_struct = (mono_unity_liveness_allocate_struct_t)(GetProcAddress(dll, "mono_unity_liveness_allocate_struct")); + mono_unity_liveness_stop_gc_world = (mono_unity_liveness_stop_gc_world_t)(GetProcAddress(dll, "mono_unity_liveness_stop_gc_world")); + mono_unity_liveness_finalize = (mono_unity_liveness_finalize_t)(GetProcAddress(dll, "mono_unity_liveness_finalize")); + mono_unity_liveness_start_gc_world = (mono_unity_liveness_start_gc_world_t)(GetProcAddress(dll, "mono_unity_liveness_start_gc_world")); + mono_unity_liveness_free_struct = (mono_unity_liveness_free_struct_t)(GetProcAddress(dll, "mono_unity_liveness_free_struct")); + mono_unity_liveness_calculation_begin = (mono_unity_liveness_calculation_begin_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_begin")); + mono_unity_liveness_calculation_end = (mono_unity_liveness_calculation_end_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_end")); + mono_unity_liveness_calculation_from_root = (mono_unity_liveness_calculation_from_root_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_from_root")); + mono_unity_liveness_calculation_from_statics = (mono_unity_liveness_calculation_from_statics_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_from_statics")); + mono_trace_set_level_string = (mono_trace_set_level_string_t)(GetProcAddress(dll, "mono_trace_set_level_string")); + mono_trace_set_mask_string = (mono_trace_set_mask_string_t)(GetProcAddress(dll, "mono_trace_set_mask_string")); + mono_gc_get_used_size = (mono_gc_get_used_size_t)(GetProcAddress(dll, "mono_gc_get_used_size")); + mono_gc_get_heap_size = (mono_gc_get_heap_size_t)(GetProcAddress(dll, "mono_gc_get_heap_size")); + mono_method_desc_search_in_class = (mono_method_desc_search_in_class_t)(GetProcAddress(dll, "mono_method_desc_search_in_class")); + mono_method_desc_free = (mono_method_desc_free_t)(GetProcAddress(dll, "mono_method_desc_free")); + mono_type_get_name_full = (mono_type_get_name_full_t)(GetProcAddress(dll, "mono_type_get_name_full")); + mono_unity_thread_clear_domain_fields = (mono_unity_thread_clear_domain_fields_t)(GetProcAddress(dll, "mono_unity_thread_clear_domain_fields")); + // mono_unity_set_vprintf_func = (mono_unity_set_vprintf_func_t)(GetProcAddress(dll, "mono_unity_set_vprintf_func")); + mono_profiler_install = (mono_profiler_install_t)(GetProcAddress(dll, "mono_profiler_install")); + mono_profiler_set_events = (mono_profiler_set_events_t)(GetProcAddress(dll, "mono_profiler_set_events")); + mono_profiler_install_enter_leave = (mono_profiler_install_enter_leave_t)(GetProcAddress(dll, "mono_profiler_install_enter_leave")); + mono_profiler_install_gc = (mono_profiler_install_gc_t)(GetProcAddress(dll, "mono_profiler_install_gc")); + mono_profiler_install_allocation = (mono_profiler_install_allocation_t)(GetProcAddress(dll, "mono_profiler_install_allocation")); + mono_profiler_install_jit_end = (mono_profiler_install_jit_end_t)(GetProcAddress(dll, "mono_profiler_install_jit_end")); + mono_profiler_install_exception = (mono_profiler_install_exception_t)(GetProcAddress(dll, "mono_profiler_install_exception")); + mono_profiler_install_thread = (mono_profiler_install_thread_t)(GetProcAddress(dll, "mono_profiler_install_thread")); +} +struct callbackstruct{ + const char* _dll; + const char* _namespace; + const char* _class; + bool goodmatch; + MonoImage* Image; + MonoClass* klass; +}; +static void MonoCallBack(void* assembly, void* userData) { + auto Image=mono_assembly_get_image((MonoAssembly*)assembly); + if(!Image)return; + auto st=reinterpret_cast(userData); + if(st->goodmatch)return; + if(mono_image_get_name){ + auto name=mono_image_get_name(Image); + if(strcmp(st->_dll,name)==0){ + st->Image=Image; + st->goodmatch=true; + st->klass=mono_class_from_name(Image, st->_namespace,st->_class); + return; + } + } + + if(!st->klass) + { + auto mono_class=mono_class_from_name(Image,st->_namespace,st->_class); + if(mono_class) + st->klass=mono_class; + } + +} +// Function to invoke a dll method in a mono application +uintptr_t getmonofunctionptr(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCount) { + if(!(mono_thread_attach&&mono_class_from_name&&mono_class_get_method_from_name&&mono_assembly_foreach&&mono_get_root_domain&&mono_compile_method))return NULL; + mono_thread_attach(mono_get_root_domain()); + + callbackstruct st; + st.Image=NULL; + st.klass=NULL; + st._dll=_dll; + st._namespace=_namespace; + st._class=_class; + st.goodmatch=false; + mono_assembly_foreach(MonoCallBack,(void*)&st); + + #if 0 + MonoDomain* domain = mono_get_root_domain(); + if(!domain)return NULL; + //Opening a custom assembly in the domain. + MonoAssembly* domainassembly = mono_domain_assembly_open(domain, _dll); + if(!domainassembly)return NULL; + //Getting the assembly's Image(Binary image, essentially a file-module). + MonoImage* Image = mono_assembly_get_image(domainassembly); + #endif + + auto pClass=st.klass; + if(!pClass)return NULL; + //Declaring the method, that attaches our assembly to the game. (Class, MethodName, Parameters) + MonoMethod* MonoClassMethod = mono_class_get_method_from_name(pClass, _method, paramCount); + if(!MonoClassMethod)return NULL; + return (uintptr_t)mono_compile_method((uintptr_t)MonoClassMethod); +} diff --git a/LunaHook/engines/mono/monocommon.hpp b/LunaHook/engines/mono/monocommon.hpp index bc53232..0cf6a39 100644 --- a/LunaHook/engines/mono/monocommon.hpp +++ b/LunaHook/engines/mono/monocommon.hpp @@ -1,46 +1,7 @@ -#include"il2cpp.hpp" -#include "monoobject.h" -#include"monofuncinfo.h" +#include"monostringapis.h" namespace { - -#define GetProcAddressXX(mm, func) auto func=(func##_t)GetProcAddress((mm), #func); -std::mutex mutex; -std::unordered_setinserted_addr; -void NewHook_check(HookParam& hp,LPCSTR n){ - std::lock_guard _(mutex); - if(inserted_addr.find(hp.address)==inserted_addr.end()){ - - auto succ=NewHook(hp,n); - #ifdef _WIN64 - if(!succ){ - hp.type|=BREAK_POINT; - NewHook(hp,n); - } - #endif - inserted_addr.insert(hp.address); - } -} -std::vector> unity_ui_text={ - {"TMPro","TMP_Text"}, - {"UnityEngine.UI","Text"}, - {"","UILabel"}, - {"UnityEngine","GUIText"}, - {"UnityEngine","TextMesh"}, - {"UnityEngine.UIElements","TextElement"}, - {"UnityEngine.UIElements","TextField","value"} - }; -void commonsolvemonostring(uintptr_t offset,uintptr_t *data, size_t*len){ - MonoString* string = (MonoString*)offset; - if(string==0)return; - *data = (uintptr_t)string->chars; - if(wcslen((wchar_t*)string->chars)!=string->length)return; - *len = string->length * 2; -} -void mscorlib_system_string_hook_fun(hook_stack* stack, HookParam *hp, uintptr_t *data, uintptr_t *split, size_t*len) -{ - commonsolvemonostring(stack->ARG1,data,len); -} + void mscorlib_system_string_InternalSubString_hook_fun(hook_stack* stack, HookParam *hp, uintptr_t *data, uintptr_t *split, size_t*len) { uintptr_t offset=stack->ARG1; @@ -54,55 +15,10 @@ void mscorlib_system_string_InternalSubString_hook_fun(hook_stack* stack, HookP *len = length * 2; } -auto mscorlib_system_string_funcs=std::unordered_map{ - {"ToCharArray",mscorlib_system_string_hook_fun}, - {"Replace",mscorlib_system_string_hook_fun}, - {"ToString",mscorlib_system_string_hook_fun}, - {"IndexOf",mscorlib_system_string_hook_fun}, - {"Substring",mscorlib_system_string_hook_fun}, - {"op_Inequality",mscorlib_system_string_hook_fun},//[230901] [ILLGAMES] ハニカム - {"InternalSubString",mscorlib_system_string_InternalSubString_hook_fun} //[1000-REKA] 早咲きのくろゆり 不这样文本会很多会很卡 - //https://learn.microsoft.com/zh-cn/dotnet/api/system.string.join?view=net-7.0 - // "Join", "IndexOfAnyUnchecked", "LastIndexOfAny", "Split", "IndexOfAny", "Compare", "Concat", "TrimEnd", "op_Inequality", "InternalSplitKeepEmptyEntries", "CreateString", "FormatHelper", "FastAllocateString", "EndsWith", "ReplaceInternal", "CopyTo", "IndexOfUnchecked", "ConcatArray", "Trim", "ToLower", "MakeSeparatorList", ".ctor", "SplitInternal", "CharCopy", "LastIndexOfAnyUnchecked", "IsNullOrWhiteSpace", "CtorCharPtrStartLength", "FillStringChecked", "op_Equality", "StartsWith", "Contains", "ToLowerInvariant", "TrimHelper", "Equals", "wstrcpy", "CtorCharArrayStartLength", "ReplaceUnchecked", "InternalSplitOmitEmptyEntries", "LastIndexOf", "Format" - //String还有其他函数，但一般这几个就可以了 - }; -void unity_ui_string_hook_fun(hook_stack* stack, HookParam *hp, uintptr_t *data, uintptr_t *split, size_t*len) +void mscorlib_system_string_hook_fun(hook_stack* stack, HookParam *hp, uintptr_t *data, uintptr_t *split, size_t*len) { - commonsolvemonostring(stack->ARG2,data,len); + commonsolvemonostring(stack->ARG1,data,len); } -void unity_ui_string_hook_after(hook_stack* stack,void* data, size_t len) -{ - MonoString* string = (MonoString*)stack->ARG2; - if(string==0)return; - if(wcslen((wchar_t*)string->chars)!=string->length)return; - - //其实也可以直接覆写到原来的String上，但重新创建一个是更安全的操作。 - auto newstring=(MonoString*)malloc(sizeof(MonoString)+len+2); - memcpy(newstring,string,sizeof(MonoString)); - wcscpy((wchar_t*)newstring->chars,(wchar_t*)data); - newstring->length=len/2; - stack->ARG2=(uintptr_t)newstring; -} - -void MONO_IL2CPP_NEW_HOOK(void* text_fun,void* hook_after, uintptr_t addr,const char*name){ - if(addr==0)return; - HookParam hp; - hp.address = addr; - hp.type = USING_STRING | CODEC_UTF16|FULL_STRING; - hp.text_fun =(decltype(hp.text_fun))text_fun; - - if(hook_after) - { - hp.type|=EMBED_ABLE|EMBED_BEFORE_SIMPLE; - hp.hook_after=(decltype(hp.hook_after))hook_after; - } - NewHook_check(hp, name); -} -auto unity_ui_string_hook=std::bind(MONO_IL2CPP_NEW_HOOK,unity_ui_string_hook_fun,unity_ui_string_hook_after,std::placeholders::_1,std::placeholders::_2); -auto mscorlib_system_string_hook=[](uintptr_t addr,std::pairfunc){ - MONO_IL2CPP_NEW_HOOK(func.second,0,addr,func.first.c_str()); -}; - /** jichi 12/26/2014 Mono * Sample game: [141226] ハ�レ�めいと @@ -124,176 +40,7 @@ void SpecialHookMonoString(hook_stack* stack, HookParam *hp, uintptr_t *data, u #endif } -} -namespace il2cpp_func{ - void insertsystemstringfunc(Il2CppClass*klass,HMODULE module){ - GetProcAddressXX(module,il2cpp_class_get_method_from_name); - if(il2cpp_class_get_method_from_name==0)return ; - for(auto func:mscorlib_system_string_funcs){ - auto ToCharArray= il2cpp_class_get_method_from_name(klass,func.first.c_str(),-1); - if(ToCharArray==0)continue; - mscorlib_system_string_hook(ToCharArray->methodPointer,func); - } - } - bool withimage(HMODULE module){ - GetProcAddressXX(module,il2cpp_domain_get); - GetProcAddressXX(module,il2cpp_thread_attach); - GetProcAddressXX(module,il2cpp_domain_get_assemblies); - GetProcAddressXX(module,il2cpp_assembly_get_image); - GetProcAddressXX(module,il2cpp_class_from_name); - GetProcAddressXX(module,il2cpp_class_get_method_from_name); - - if (!(il2cpp_domain_get && il2cpp_thread_attach && il2cpp_assembly_get_image && il2cpp_domain_get_assemblies && il2cpp_class_from_name && il2cpp_class_get_method_from_name))return false; - - auto domain = il2cpp_domain_get(); - il2cpp_thread_attach(domain); - int _ = 0; - size_t sz = 0; - auto assemblies = il2cpp_domain_get_assemblies(domain, &sz); - for (auto i = 0; i < sz; i++, assemblies++) { - auto image = il2cpp_assembly_get_image(*assemblies); - - do{ - auto cls = il2cpp_class_from_name(image, "System", "String"); - if (cls==0)break; - il2cpp_func::insertsystemstringfunc(cls,module); - }while(0); - - for(auto _:unity_ui_text){ - auto cls = il2cpp_class_from_name(image, _[0], _[1]); - if (cls == 0) continue; - auto method = il2cpp_class_get_method_from_name(cls, "set_text", 1); - if (method == 0) continue; - unity_ui_string_hook(method->methodPointer,_[1]); - } - } - return true; - - } - void foreach_func(Il2CppClass* klass, void* userData){ - HMODULE module = GetModuleHandleW(L"GameAssembly.dll"); - - GetProcAddressXX(module,il2cpp_class_get_name); - GetProcAddressXX(module,il2cpp_method_get_name); - GetProcAddressXX(module,il2cpp_class_get_methods); - GetProcAddressXX(module,il2cpp_class_get_namespace); - GetProcAddressXX(module,il2cpp_class_get_method_from_name); - - if (!(il2cpp_class_get_name ))return; - auto classname = il2cpp_class_get_name(klass); - std::string cln = classname; - - do{ - if(!(il2cpp_class_get_namespace && il2cpp_class_get_method_from_name))break; - std::string names=il2cpp_class_get_namespace(klass); - if(cln=="String" && names=="System"){ - il2cpp_func::insertsystemstringfunc(klass,module); - } - }while(0); - - - do{ - if (!( il2cpp_class_get_methods && il2cpp_method_get_name))break; - if (!(cln.size() >= 4 && (cln.substr(cln.size() - 4, 4) == "Text" || cln.substr(0, 4) == "Text"))) break; - - void* iter = 0; - while (true) { - auto methods = il2cpp_class_get_methods(klass, &iter); - if (methods == 0)break; - auto methodname = il2cpp_method_get_name(methods); - if (std::string(methodname) == "set_text") { - unity_ui_string_hook(methods->methodPointer,classname); - - } - } - }while(0); - - } - bool foreach(HMODULE module){ - - GetProcAddressXX(module,il2cpp_class_for_each); - if (il2cpp_class_for_each==0)return false; - il2cpp_class_for_each(foreach_func, 0); - return true; - } -} - - -namespace{ -HMODULE monodllhandle=0; - -void MonoCallBack(uintptr_t assembly, void* userData) { - GetProcAddressXX(monodllhandle,mono_get_root_domain); - GetProcAddressXX(monodllhandle,mono_thread_attach); - GetProcAddressXX(monodllhandle,mono_assembly_get_image); - GetProcAddressXX(monodllhandle,mono_class_get_property_from_name); - GetProcAddressXX(monodllhandle,mono_class_from_name); - GetProcAddressXX(monodllhandle,mono_property_get_set_method); - GetProcAddressXX(monodllhandle,mono_compile_method); - GetProcAddressXX(monodllhandle,mono_image_get_name); - GetProcAddressXX(monodllhandle,mono_image_get_table_info); - GetProcAddressXX(monodllhandle,mono_table_info_get_rows); - GetProcAddressXX(monodllhandle,mono_class_get); - GetProcAddressXX(monodllhandle,mono_class_get_name); - GetProcAddressXX(monodllhandle,mono_class_get_method_from_name); - if(mono_assembly_get_image==0)return ; - uintptr_t image = mono_assembly_get_image(assembly); - - if(!(mono_thread_attach&&mono_get_root_domain&&mono_compile_method))return ; - - if((mono_class_from_name&&mono_class_get_property_from_name&&mono_property_get_set_method)) - for(auto _:unity_ui_text){ - auto mono_class=mono_class_from_name(image,_[0],_[1]); - if(mono_class==0)continue; - uintptr_t mono_property=mono_class_get_property_from_name(mono_class,_.size()==3?_[2] :"text"); - if (mono_property == 0)continue; - auto mono_set_method = mono_property_get_set_method(mono_property); - mono_thread_attach(mono_get_root_domain()); - if(mono_set_method==0)continue; - uint64_t* method_pointer = mono_compile_method(mono_set_method); - if (method_pointer==0)continue; - unity_ui_string_hook((uintptr_t)method_pointer,_[1]); - - } - if((mono_image_get_name&&mono_image_get_table_info&&mono_table_info_get_rows&&mono_class_get&&mono_class_get_name&&mono_class_get_method_from_name)){ - //遍历image中的类，根据类名判断。 - //x86下遍历mono_class_get会中途卡死，故放弃，仅保留预设。 - //这个仅用于hook String - std::string mscorlib=mono_image_get_name(image); - if(mscorlib=="mscorlib"){ - auto _1=mono_image_get_table_info((void*)image,MONO_TABLE_TYPEDEF); - auto tdefcount=mono_table_info_get_rows(_1); - for (int i = 0; i < tdefcount; i++) - { - void *klass = mono_class_get((void*)image, MONO_TOKEN_TYPE_DEF | i+1); - char *name=mono_class_get_name(klass); - std::string cln = name; - if(cln=="String"){ - for(auto func:mscorlib_system_string_funcs){ - auto ToCharArray= mono_class_get_method_from_name(klass,func.first.c_str(),-1); - if(ToCharArray==0)continue; - auto ToCharArrayAddr=mono_compile_method((uintptr_t)ToCharArray); - mscorlib_system_string_hook((uint64_t)ToCharArrayAddr,func); - } - - } - - } - } - } - - - -} - -bool InsertMonoHooksByAssembly(HMODULE module) { - monodllhandle=module; - GetProcAddressXX(monodllhandle,mono_assembly_foreach); - if(mono_assembly_foreach==0)return false; - mono_assembly_foreach(MonoCallBack, NULL); - return true; -} } namespace { bool monodllhook(HMODULE module) { @@ -308,23 +55,107 @@ namespace { hp.length_offset = func.lengthIndex * 4; hp.text_fun = (decltype(hp.text_fun))func.text_fun; ConsoleOutput("Mono: INSERT"); - NewHook_check(hp, func.functionName); + NewHook(hp, func.functionName); } } return true; } } - -namespace monocommon{ - bool il2cpp() { +namespace monocommon{ + + bool monodllhook(HMODULE module) { + HookParam hp; + const MonoFunction funcs[] = { MONO_FUNCTIONS_INITIALIZER }; + for (auto func : funcs) { + if (FARPROC addr = GetProcAddress(module, func.functionName)) { + hp.address =(uintptr_t) addr; + hp.type =USING_STRING| func.hookType; + hp.filter_fun =all_ascii_Filter; + hp.offset = func.textIndex * 4; + hp.length_offset = func.lengthIndex * 4; + hp.text_fun = (decltype(hp.text_fun))func.text_fun; + NewHook(hp, func.functionName); + } + } + return true; + } + struct functioninfo{ + const char* assemblyName;const char* namespaze; + const char* klassName; const char* name;int argsCount; + int argidx;void* text_fun;bool Embed; + std::string hookname(){ + char tmp[1024]; + sprintf(tmp,"%s:%s",klassName,name); + return tmp; + } + std::string info(){ + char tmp[1024]; + sprintf(tmp,"%s:%s:%s:%s:%d",assemblyName,namespaze,klassName,name,argsCount); + return tmp; + } + }; + bool NewHook_check(uintptr_t addr,functioninfo&hook){ + + HookParam hp; + hp.address = addr; + hp.argidx=hook.argidx; + hp.type = USING_STRING | CODEC_UTF16|FULL_STRING; + hp.text_fun =(decltype(hp.text_fun))hook.text_fun; + hp.jittype=JITTYPE::UNITY; + strcpy(hp.unityfunctioninfo,hook.info().c_str()); + if(hook.Embed) + hp.type|=EMBED_ABLE|EMBED_BEFORE_SIMPLE; + auto succ=NewHook(hp,hook.hookname().c_str()); + #ifdef _WIN64 + if(!succ){ + hp.type|=BREAK_POINT; + succ|=NewHook(hp,hook.hookname().c_str()); + } + #endif + return succ; + } + std::vectorcommonhooks{ + {"mscorlib","System","String","ToCharArray",0,1,nullptr,false}, + {"mscorlib","System","String","Replace",2,1,nullptr,false}, + {"mscorlib","System","String","ToString",0,1,nullptr,false}, + {"mscorlib","System","String","IndexOf",1,1,nullptr,false}, + {"mscorlib","System","String","Substring",1,1,nullptr,false}, + {"mscorlib","System","String","Substring",2,1,nullptr,false}, + {"mscorlib","System","String","op_Inequality",2,1,0,false}, + {"mscorlib","System","String","InternalSubString",2,99999,mscorlib_system_string_InternalSubString_hook_fun,false}, + + {"Unity.TextMeshPro","TMPro","TMP_Text","set_text",1,2,nullptr,true}, + {"UnityEngine.UI","UnityEngine.UI","Text","set_text",1,2,nullptr,true}, + {"UnityEngine.UIElementsModule","UnityEngine.UIElements","TextElement","set_text",1,2,nullptr,true}, + {"UnityEngine.UIElementsModule","UnityEngine.UIElements","TextField","set_value",1,2,nullptr,true}, + {"UnityEngine.TextRenderingModule","UnityEngine","GUIText","set_text",1,2,nullptr,true}, + {"UnityEngine.TextRenderingModule","UnityEngine","TextMesh","set_text",1,2,nullptr,true}, + + }; + bool il2cpp() { HMODULE module = GetModuleHandleW(L"GameAssembly.dll"); if (module == 0)return false; - bool _1=il2cpp_func::withimage(module); - bool _2=il2cpp_func::foreach(module); - return _1||_2; + il2cpp_symbols::init(module); + bool succ=false; + for(auto hook:commonhooks){ + auto addr=il2cpp_symbols::get_method_pointer(hook.assemblyName,hook.namespaze,hook.klassName,hook.name,hook.argsCount); + //ConsoleOutput("%s %p",hook.name,addr-(uintptr_t)module); + if(!addr)continue; + succ|=NewHook_check(addr,hook); + } + return succ; + } + bool InsertMonoHooksByAssembly(HMODULE module){ + load_mono_functions_from_dll(module); + bool succ=false; + for(auto hook:commonhooks){ + auto addr=getmonofunctionptr(hook.assemblyName,hook.namespaze,hook.klassName,hook.name,hook.argsCount); + if(!addr)continue; + succ|=NewHook_check(addr,hook); + } + return succ; } - bool hook_mono(){ for (const wchar_t* monoName : { L"mono.dll", L"mono-2.0-bdwgc.dll",L"GameAssembly.dll" }) if (HMODULE module = GetModuleHandleW(monoName)) { diff --git a/LunaHook/engines/mono/monoil2cpp.hpp b/LunaHook/engines/mono/monoil2cpp.hpp new file mode 100644 index 0000000..ebd78da --- /dev/null +++ b/LunaHook/engines/mono/monoil2cpp.hpp @@ -0,0 +1,35 @@ +#include"def_mono.hpp" +#include"def_il2cpp.hpp" + +inline void commonsolvemonostring(uintptr_t offset,uintptr_t *data, size_t*len){ + MonoString* string = (MonoString*)offset; + if(string==0)return; + *data = (uintptr_t)string->chars; + if(wcslen((wchar_t*)string->chars)!=string->length)return; + *len = string->length * 2; +} + + +inline void unity_ui_string_hook_after(uintptr_t *offset,void* data, size_t len) +{ + MonoString* string = (MonoString*)*offset; + if(string==0)return; + if(wcslen((wchar_t*)string->chars)!=string->length)return; + + //其实也可以直接覆写到原来的String上，但重新创建一个是更安全的操作。 + auto newstring=(MonoString*)malloc(sizeof(MonoString)+len+2); + memcpy(newstring,string,sizeof(MonoString)); + wcscpy((wchar_t*)newstring->chars,(wchar_t*)data); + newstring->length=len/2; + *offset=(uintptr_t)newstring; +} +namespace il2cpp_symbols +{ + void init(HMODULE game_module); + uintptr_t get_method_pointer(const char* assemblyName, const char* namespaze, + const char* klassName, const char* name, int argsCount); + +} +void load_mono_functions_from_dll(HMODULE dll); + +uintptr_t getmonofunctionptr(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCount); \ No newline at end of file diff --git a/LunaHook/engines/mono/monoobject.h b/LunaHook/engines/mono/monoobject.h deleted file mode 100644 index 5d424c6..0000000 --- a/LunaHook/engines/mono/monoobject.h +++ /dev/null @@ -1,64 +0,0 @@ -#ifndef MONOOBJECT_H -#define MONOOBJECT_H - -// monoobject.h -// 12/26/2014 jichi -// https://github.com/mono/mono/blob/master/mono/metadata/object.h -// https://github.com/mono/mono/blob/master/mono/metadata/object-internals.h -// https://github.com/mono/mono/blob/master/mono/util/mono-publib.h - -#include - -#define MONO_ZERO_LEN_ARRAY 1 - -// mono/io-layer/uglify.h -//typedef int8_t gint8; -//typedef int32_t gint32; -//typedef wchar_t gunichar2; // either char or wchar_t, depending on how mono is compiled - -typedef int32_t mono_bool; -typedef uint8_t mono_byte; -typedef uint16_t mono_unichar2; -typedef uint32_t mono_unichar4; - -// mono/metadata/object.h - -typedef mono_bool MonoBoolean; - -struct MonoArray; -struct MonoDelegate; -struct MonoDomain; -struct MonoException; -struct MonoString; -struct MonoThreadsSync; -struct MonoThread; -struct MonoVTable; - -struct MonoObject { - MonoVTable *vtable; - MonoThreadsSync *synchronisation; -}; - -struct MonoString { - MonoObject object; - int32_t length; - mono_unichar2 chars[MONO_ZERO_LEN_ARRAY]; -}; -#define MONO_TOKEN_TYPE_DEF 0x02000000 -#define MONO_TABLE_TYPEDEF 0x2 -typedef void (*mono_assembly_foreach_callback_t)(uintptr_t, void*); -typedef void (*mono_assembly_foreach_t)(mono_assembly_foreach_callback_t, uintptr_t); -typedef uintptr_t(*mono_assembly_get_image_t)(uintptr_t); -typedef char* (*mono_image_get_name_t)(uintptr_t); -typedef uintptr_t(*mono_class_from_name_t)(uintptr_t, char*, char*); -typedef uintptr_t(*mono_class_get_property_from_name_t)(uintptr_t, char*); -typedef uintptr_t(*mono_property_get_set_method_t)(uintptr_t); -typedef uint64_t* (*mono_compile_method_t)(uintptr_t); -typedef MonoDomain*(*mono_get_root_domain_t)(); -typedef void (*mono_thread_attach_t)(MonoDomain*); -typedef void* (*mono_class_get_t)(void* image, uint32_t type_token); -typedef int (*mono_table_info_get_rows_t)(void*); -typedef void*(*mono_image_get_table_info_t)(void*,uint32_t); -typedef char*(*mono_class_get_name_t)(void*); -typedef void* (*mono_class_get_method_from_name_t)(void *klass, const char *name, int param_count); -#endif // MONOOBJECT_H diff --git a/LunaHook/engines/mono/monofuncinfo.h b/LunaHook/engines/mono/monostringapis.h similarity index 100% rename from LunaHook/engines/mono/monofuncinfo.h rename to LunaHook/engines/mono/monostringapis.h diff --git a/LunaHook/engines/mono/monotype.h b/LunaHook/engines/mono/monotype.h deleted file mode 100644 index df3d6af..0000000 --- a/LunaHook/engines/mono/monotype.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef MONOTYPE_H -#define MONOTYPE_H - -// monotype.h -// 12/26/2014 jichi -// https://github.com/mono/mono/blob/master/mono/metadata/object.h - -#include "mono/monoobject.h" - -// Function typedefs -typedef MonoDomain *(* mono_object_get_domain_fun_t)(MonoObject *obj); - -typedef MonoString *(* mono_string_new_utf16_fun_t)(MonoDomain *domain, const mono_unichar2 *text, int32_t len); - -typedef char * (* mono_string_to_utf8_fun_t)(MonoString *string_obj); - -#endif // MONOTYPE_H diff --git a/LunaHook/engines/mono/types.h b/LunaHook/engines/mono/types.h deleted file mode 100644 index 7f7d9b7..0000000 --- a/LunaHook/engines/mono/types.h +++ /dev/null @@ -1,41 +0,0 @@ -#pragma once - -// mono/types.h -// 12/26/2014 -// https://github.com/mono/mono/blob/master/mono/metadata/object.h -// http://api.xamarin.com/index.aspx?link=xhtml%3Adeploy%2Fmono-api-string.html - -#include - -// mono/io-layer/uglify.h -typedef int8_t gint8; -typedef int32_t gint32; -typedef wchar_t gunichar2; // either char or wchar_t, depending on how mono is compiled - -typedef gint8 mono_byte; -typedef gunichar2 mono_unichar2; - -// mono/metadata/object.h - -typedef mono_byte MonoBoolean; - -struct MonoArray; -struct MonoDelegate; -struct MonoException; -struct MonoString; -struct MonoThreadsSync; -struct MonoThread; -struct MonoVTable; - -struct MonoObject { - MonoVTable *vtable; - MonoThreadsSync *synchronisation; -}; - -struct MonoString { - MonoObject object; - gint32 length; - gunichar2 chars[0]; -}; - -// EOF diff --git a/LunaHook/main.cc b/LunaHook/main.cc index 0d03002..85fe142 100644 --- a/LunaHook/main.cc +++ b/LunaHook/main.cc @@ -205,6 +205,15 @@ void delayinsertNewHook(uintptr_t em_address){ bool NewHook(HookParam hp, LPCSTR name){ if(hp.address||hp.jittype==JITTYPE::PC) return NewHook_1(hp,name); + if(hp.jittype==JITTYPE::UNITY){ + auto spls=strSplit(hp.unityfunctioninfo,":"); + hp.address = il2cpp_symbols::get_method_pointer(spls[0].c_str(),spls[1].c_str() ,spls[2].c_str(),spls[3].c_str(),std::stoi(spls[4])); + if(!hp.address) + hp.address=getmonofunctionptr(spls[0].c_str(),spls[1].c_str() ,spls[2].c_str(),spls[3].c_str(),std::stoi(spls[4])); + if(!hp.address) + return false; + return NewHook_1(hp,name); + } //下面的是手动插入 if(emuaddr2jitaddr.find(hp.emu_addr)==emuaddr2jitaddr.end()){ delayinsertadd(hp,name); diff --git a/LunaHook/pchhook.h b/LunaHook/pchhook.h index 0c95c94..3a2a258 100644 --- a/LunaHook/pchhook.h +++ b/LunaHook/pchhook.h @@ -19,7 +19,7 @@ #include"Lang/Lang.h" #include"veh_hook.h" #include"engines/emujitarg.hpp" - +#include"engines/mono/monoil2cpp.hpp" #include "hookfinder.h" #include"util/textunion.h" #include"util/ntxpundef.h" \ No newline at end of file diff --git a/LunaHook/stackoffset.hpp b/LunaHook/stackoffset.hpp index c857700..46159bf 100644 --- a/LunaHook/stackoffset.hpp +++ b/LunaHook/stackoffset.hpp @@ -108,16 +108,21 @@ inline uintptr_t regof(regs reg,hook_stack* stack){ #define GETARG3 get_reg(regs::r8) #define GETARG4 get_reg(regs::r9) +#endif -inline uintptr_t* argidx(hook_stack* stack,int idx){ + +inline uintptr_t *argidx(hook_stack* stack,int idx){ + #ifdef _WIN64 auto offset=0; switch (idx) { - case 0:offset=get_reg(regs::rcx);break; - case 1:offset=get_reg(regs::rdx);break; - case 2:offset=get_reg(regs::r8);break; - case 3:offset=get_reg(regs::r9);break; + case 1:offset=get_reg(regs::rcx);break; + case 2:offset=get_reg(regs::rdx);break; + case 3:offset=get_reg(regs::r8);break; + case 4:offset=get_reg(regs::r9);break; } return (uintptr_t*)((uintptr_t)stack+sizeof(hook_stack)-sizeof(uintptr_t)+offset); -} -#endif \ No newline at end of file + #else + return (uintptr_t*)((uintptr_t)stack+sizeof(hook_stack)-sizeof(uintptr_t)+get_stack(idx)); + #endif +} \ No newline at end of file diff --git a/LunaHook/texthook.cc b/LunaHook/texthook.cc index ab9855e..d64087a 100644 --- a/LunaHook/texthook.cc +++ b/LunaHook/texthook.cc @@ -122,15 +122,37 @@ bool TextHook::Insert(HookParam hp) if (hp.type & BREAK_POINT) return InsertBreakPoint(); return InsertHookCode(); } - -uintptr_t queryrelativeret(uintptr_t retaddr){ +uintptr_t win64find0000(uintptr_t addr){ + uintptr_t r = 0; + __try{ + addr &= ~0xf; + for (uintptr_t i = addr, j = addr - 0x10000; i > j; i-=0x10) { + DWORD k = *(DWORD *)(i-4); + if (k == 0x00000000 + ) + return i; + } + return 0; + }__except(EXCEPTION_EXECUTE_HANDLER) {} + return r; +} +uintptr_t queryrelativeret(HookParam&hp, uintptr_t retaddr){ //不需要区分是相对于哪个module的偏移，只需要得到偏移就可以了，用来确保重启程序后ret值恒定 static Synchronized> retaddr2relative; auto &re=retaddr2relative.Acquire().contents; if(re.find(retaddr)!=re.end())return re.at(retaddr); uintptr_t relative=retaddr; + if(hp.jittype==JITTYPE::UNITY){ + #ifndef _WIN64 + relative=retaddr-SafeFindEnclosingAlignedFunction(retaddr,0x10000); + #else + relative=retaddr-win64find0000(retaddr); + #endif + } + else{ if (MEMORY_BASIC_INFORMATION info = {}; VirtualQuery((LPCVOID)retaddr, &info, sizeof(info))) relative-=(uintptr_t)info.AllocationBase; + } re.insert(std::make_pair(retaddr,relative)); return relative; } @@ -174,7 +196,7 @@ void TextHook::Send(uintptr_t lpDataBase) plpdatain=(lpDataBase + hp.offset), lpDataIn=*(uintptr_t*)plpdatain; bool isstring=false; - if(hp.jittype!=JITTYPE::PC) + if(hp.jittype!=JITTYPE::PC&&hp.jittype!=JITTYPE::UNITY) { lpDataIn=jitgetaddr(stack,&hp); plpdatain=(uintptr_t)&lpDataIn; @@ -192,6 +214,10 @@ void TextHook::Send(uintptr_t lpDataBase) isstring=true; hp.text_fun(stack, &hp, &lpDataIn, &lpSplit, &lpCount); } + else if(hp.jittype==JITTYPE::UNITY) + { + commonsolvemonostring(*argidx(stack,hp.argidx),&lpDataIn,&lpCount); + } else { if (hp.type & FIXING_SPLIT) lpSplit = FIXED_SPLIT_VALUE; // fuse all threads, and prevent floating @@ -243,7 +269,7 @@ void TextHook::Send(uintptr_t lpDataBase) buffer->type=hp.type; - lpRetn=queryrelativeret(lpRetn); + lpRetn=queryrelativeret(hp,lpRetn); ThreadParam tp{ GetCurrentProcessId(), address, lpRetn, lpSplit }; parsenewlineseperator(pbData, &lpCount); @@ -272,8 +298,11 @@ void TextHook::Send(uintptr_t lpDataBase) for(int i=lpCount;i