Tutorial Universal ESP hack for all FPS Games (Unity3D) - H5GG - [No JB]

kaethegoat01 · March 5, 2023

Nice

Happy Secret · March 6, 2023

On 3/3/2023 at 9:33 PM, 𓄼 . f v c k . 𓄹 said:

Oh okay, yeah afaik Unity5D do not have such features.

Tho if you could manage to do something like this, it would be insane

I am getting good progress on it but got stuck on Javascript cannot pass primitive type as reference .

In cpp, we can do following

void* fieldValue;

IL2CPP_.il2cpp_field_get_value(objectIL_, fieldInfo, &fieldValue);

while, fieldValue will store the result.

But in Javascript, I can’t do primitive type passing by reference. fieldValue suppose will store an Integer.
but in JavaScript, I will always get 0.

Is it possible to write a wrapper function in cpp and package as Dylib for H5GG to use?

What I need is a simple function that wrap the IL2CPP_.il2cpp_field_get_value and return fieldValue as usual.

I actually found something similar online.

Spoiler

#include <exception>
#include "GameObject.h"
 
/******************** External API ********************/
 
/******************** Module Typedefs ********************/
 
/******************** Module Constants ********************/
 
/******************** Module Variables ********************/
 
/* Declare the static reference to the IL2CPP object. */
IL2CPP GameObject::IL2CPP_ = IL2CPP();
 
/******************** Module Prototypes ********************/
 
/******************** Public Code ********************/
 
GameObject::GameObject(Il2CppObject* objectIL)
	:	objectIL_(objectIL), className_(getIL2CPPClassName(objectIL))
{
	/* Constructor that sets the objects base address. */
}
 
std::unique_ptr<GameObject> GameObject::getStaticGameObjectFromClass(const char* nameSpace, const char* className, const char* fieldName)
{
	std::unique_ptr<GameObject> result = nullptr;
 
	/* Get the IL2CPP object. */
	auto ilObject = (Il2CppObject*)getIL2CPPStaticFieldFromClass(nameSpace, className, fieldName);
	if (NULL != ilObject)
	{
		result = std::make_unique<GameObject>(ilObject);
	}
 
	return result;
}
 
void* GameObject::getStaticValueFromClass(const char* nameSpace, const char* className, const char* fieldName)
{
	return getIL2CPPStaticFieldFromClass(nameSpace, className, fieldName);
}
 
std::unique_ptr<GameObject> GameObject::getGameObjectFromField(const char* fieldName)
{
	std::unique_ptr<GameObject> result = nullptr;
 
	auto ilObject = (Il2CppObject*)getIL2CPPFieldFromObject(fieldName);
	if (NULL != ilObject)
	{
		result = std::make_unique<GameObject>(ilObject);
	}
 
	return result;
}
 
void* GameObject::getValueFromField(const char* fieldName)
{
	return getIL2CPPFieldFromObject(fieldName);
}
 
/******************** Private Code ********************/
 
std::string GameObject::getIL2CPPClassName(Il2CppObject* objectIL)
{
	TypeInfo* typeInfo = IL2CPP_.il2cpp_object_get_class(objectIL);
	if (NULL == typeInfo)
	{
		throw std::exception("Unable to get TypeInfo of object.");
	}
 
	return std::string(typeInfo->namespaze) + "::" + typeInfo->name;
}
 
void* GameObject::getIL2CPPStaticFieldFromClass(const char* nameSpace, const char* className, const char* fieldName)
{
	void* result = NULL;
 
	/* Attempt to find typeinfo of the class in all of the loaded assemblies. */
	TypeInfo* classTypeInfo = NULL;
 
	Il2CppDomain* domain = IL2CPP_.il2cpp_domain_get();
	if (NULL == domain)
	{
		throw std::exception("Unable to get domain.");
	}
 
	size_t assemblyListLength = 0;
	Il2CppAssembly** assemblyList = IL2CPP_.il2cpp_domain_get_assemblies(domain, &assemblyListLength);
 
	for (size_t i = 0; i < assemblyListLength; i++)
	{
		Il2CppAssembly* assembly = assemblyList[i];
 
		if (NULL != assembly)
		{
			Il2CppImage* image = IL2CPP_.il2pp_assembly_get_image(assembly);
			if (NULL != image)
			{
				classTypeInfo = IL2CPP_.il2cpp_class_from_name(image, nameSpace, className);
 
				if (NULL != classTypeInfo)
				{
					/* Class has been found, break from the loop. */
					break;
				}
			}
		}
	}
 
	/* If we managed to get the type information of the class, continue. */
	if (NULL != classTypeInfo)
	{
		/* Get the field information of the class. */
		FieldInfo* classFieldInfo = IL2CPP_.il2cpp_class_get_field_from_name(classTypeInfo, fieldName);
		if (NULL == classFieldInfo)
		{
			throw std::exception("Unable to get FieldInfo of the requested field.");
		}
 
		/* Retrieve the static value. */
		IL2CPP_.il2cpp_field_static_get_value(classFieldInfo, &result);
	}
	else
	{
		throw std::exception("Unable to get type information of class.");
	}
 
	return result;
}
 
void* GameObject::getIL2CPPFieldFromObject(const char* fieldName)
{
	/* Get the type info of the current object. */
	TypeInfo* thisType = IL2CPP_.il2cpp_object_get_class(objectIL_);
	if (NULL == thisType)
	{
		throw std::exception("Unable to get TypeInfo of current object.");
	}
 
	/* Then get the field info from the type info. */
	FieldInfo* fieldInfo = IL2CPP_.il2cpp_class_get_field_from_name(thisType, fieldName);
	if (NULL != fieldInfo)
	{
		throw std::exception("Unable to get FieldInfo of the requested field.");
	}
 
	/* Then get the value from the object. */
	void* fieldValue;
	IL2CPP_.il2cpp_field_get_value(objectIL_, fieldInfo, &fieldValue);
 
	return fieldValue;
}