internal IL2Patch(IL2Method targetMethod, IntPtr newMethod) : base(newMethod)
{
ptr = newMethod;
TargetMethod = targetMethod;
// OriginalMethod = *(IntPtr*)TargetMethod.ptr.ToPointer();
IL2Import.VRC_CreateHook(*(IntPtr *)targetMethod.ptr.ToPointer(), newMethod, out OriginalMethod);
// Console.WriteLine("T1: " + ptr + " | T2: " + targetMethod.ptr + " | T3: " + OriginalMethod);
}
public static void Test(GameObject gameObject)
{
try
{
VRC.Network.RPC(VRC_EventHandler.VrcTargetType.AllBufferOne, gameObject, "initUSpeakSenderRPC", new IntPtr[]
{
IL2Import.CreateNewObject(rand.Next(0, 25), BlazeTools.IL2SystemClass.Int32)
});
}
catch { }
}
public IL2Object PInvokeOriginal(IntPtr arg1, IntPtr arg2, IntPtr arg3, IntPtr arg4, IntPtr arg5, IntPtr arg6, IntPtr arg7, IntPtr arg8, IntPtr arg9)
{
IntPtr result = IL2Import.VRC_PInvoke(OriginalMethod, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
if (result == IntPtr.Zero)
{
return(null);
}
return(new IL2Object(result, TargetMethod.GetReturnType()));
}
public IL2Object InvokeOriginal(params IL2Object[] paramtbl)
{
if (paramtbl.Length == 1)
{
return(InvokeOriginal(paramtbl[0]));
}
else
{
return(InvokeOriginal(IntPtr.Zero, IL2Import.IL2CPPObjectArrayToIntPtrArray(paramtbl)));
}
}
internal IL2Assembly(IntPtr newPtr) : base(newPtr)
{
ptr = newPtr;
Name = Path.GetFileNameWithoutExtension(Marshal.PtrToStringAnsi(IL2Import.il2cpp_image_get_name(newPtr)));
// Map out Classes
uint count = IL2Import.il2cpp_image_get_class_count(newPtr);
for (uint i = 0; i < count; i++)
{
ClassList.Add(new IL2Type(IL2Import.il2cpp_image_get_class(newPtr, i)));
}
}
public IL2BindingFlags GetFlags()
{
if (Flags == null)
{
uint flags = 0;
Flags = (IL2BindingFlags)IL2Import.il2cpp_class_get_flags(ptr, ref flags);
if (Flags == null)
{
return(IL2BindingFlags.TYPE_CLASS);
}
}
return((IL2BindingFlags)Flags);
}
public IL2Type(IntPtr newPtr) : base(newPtr)
{
ptr = newPtr;
Name = Marshal.PtrToStringAnsi(IL2Import.il2cpp_class_get_name(newPtr));
Namespace = Marshal.PtrToStringAnsi(IL2Import.il2cpp_class_get_namespace(newPtr));
// Find Methods
IntPtr method_iter = IntPtr.Zero;
IntPtr method = IntPtr.Zero;
while ((method = IL2Import.il2cpp_class_get_methods(newPtr, ref method_iter)) != IntPtr.Zero)
{
MethodList.Add(new IL2Method(method));
}
// Find Fields
IntPtr field_iter = IntPtr.Zero;
IntPtr field = IntPtr.Zero;
while ((field = IL2Import.il2cpp_class_get_fields(newPtr, ref field_iter)) != IntPtr.Zero)
{
FieldList.Add(new IL2Field(field));
}
/*
*
* // Map out Events
* IntPtr evt_iter = IntPtr.Zero;
* IntPtr evt = IntPtr.Zero;
* while ((evt = IL2CPP.il2cpp_class_get_events(Ptr, ref evt_iter)) != IntPtr.Zero)
* EventList.Add(new IL2CPP_Event(evt));
*
*/
// Find Nested Class
IntPtr nestedtype_iter = IntPtr.Zero;
IntPtr nestedtype = IntPtr.Zero;
while ((nestedtype = IL2Import.il2cpp_class_get_nested_types(newPtr, ref nestedtype_iter)) != IntPtr.Zero)
{
NestedTypeList.Add(new IL2Type(nestedtype));
}
// Find Property
IntPtr property_iter = IntPtr.Zero;
IntPtr property = IntPtr.Zero;
while ((property = IL2Import.il2cpp_class_get_properties(newPtr, ref property_iter)) != IntPtr.Zero)
{
PropertyList.Add(new IL2Property(property));
}
}
public static IntPtr ArrayToIntPtr(this IntPtr[] array, IL2Type typeobject = null)
{
if (typeobject == null)
{
typeobject = BlazeTools.IL2SystemClass.Object;
}
int length = array.Length;
IntPtr result = IL2Import.il2cpp_array_new(typeobject.ptr, length);
for (int i = 0; i < length; i++)
{
*(IntPtr *)((IntPtr)((long *)result + 4) + i * IntPtr.Size) = array[i];
}
return(result);
}
internal static IL2TypeObject IL2Typeof(IL2Type klass)
{
IntPtr ptr = IL2Import.il2cpp_class_get_type(klass.ptr);
if (ptr == IntPtr.Zero)
{
return(null);
}
IntPtr result = IL2Import.il2cpp_type_get_object(ptr);
if (ptr == IntPtr.Zero)
{
return(null);
}
return(result.MonoCast <IL2TypeObject>());
}
public static GameObject SpawnPortal(Vector3 Position)
{
GameObject gameObject = VRC.Network.Instantiate(VRC_EventHandler.VrcBroadcastType.Always, "Portals/PortalInternalDynamic", Position, new Quaternion(0, 0, 0, 0));
if (gameObject == null)
{
return(null);
}
VRC.Network.RPC(VRC_EventHandler.VrcTargetType.AllBufferOne, gameObject, "ConfigurePortal", new IntPtr[]
{
IL2Import.StringToIntPtr("wrld_a61806c2-4f5c-4c00-8aae-c5f6d5c3bfde"),
IL2Import.il2cpp_string_new_len("Banned Instance\nTupper\0", "Banned Instance\nTupper\0".Length),
IL2Import.CreateNewObject(0, BlazeTools.IL2SystemClass.Int32)
});
return(gameObject);
}
public unsafe static IntPtr CreateDelegate <T>(Delegate function, T instance, IL2Type klass = null)
{
if (klass == null)
{
klass = Instance_Class;
}
var obj = IL2Import.il2cpp_object_new(klass.ptr);
if (instance == null || (typeof(T) == typeof(IntPtr) && (IntPtr)(object)instance == IntPtr.Zero))
{
var runtimeStaticMethod = Marshal.AllocHGlobal(8);
*(IntPtr *)runtimeStaticMethod = function.Method.MethodHandle.GetFunctionPointer();
*((IntPtr *)obj + 2) = function.Method.MethodHandle.GetFunctionPointer();
*((IntPtr *)obj + 4) = IntPtr.Zero;
*((IntPtr *)obj + 5) = runtimeStaticMethod;
return(obj);
}
IL2Method ctor = klass.GetMethod(".ctor");
GCHandle handle1 = GCHandle.Alloc(instance);
var runtimeMethod = Marshal.AllocHGlobal(80);
//methodPtr
*((IntPtr *)runtimeMethod) = function.Method.MethodHandle.GetFunctionPointer();
byte paramCount = (byte)(function.Method.GetParameters()?.Length ?? 0);
//Parameter count
*((byte *)runtimeMethod + 75) = 0; // 0 parameter_count
//Slot (65535)
*((byte *)runtimeMethod + 74) = 0xFF;
*((byte *)runtimeMethod + 73) = 0xFF;
*((IntPtr *)obj + 2) = function.Method.MethodHandle.GetFunctionPointer();
*((IntPtr *)obj + 4) = obj;
*((IntPtr *)obj + 5) = runtimeMethod;
*((IntPtr *)obj + 7) = GCHandle.ToIntPtr(handle1);
return(obj);
}
private static void patch_method(IntPtr endpoint, IntPtr method, IntPtr responseContainer, IntPtr requestParams, IntPtr authenticationRequired, IntPtr disableCache, IntPtr cacheLifetime, IntPtr retryCount, IntPtr credentials)
{
string sEndpoint = IL2Import.IntPtrToString(endpoint);
if ((sEndpoint == "visits" || sEndpoint == "joins" || (sEndpoint.StartsWith("avatars/avtr_") && sEndpoint.EndsWith("/select"))) && BlazeManager.GetForPlayer <bool>("Invis API"))
{
return;
}
pInvisMode.InvokeOriginal(IntPtr.Zero, new IntPtr[] {
endpoint,
method,
responseContainer,
requestParams,
authenticationRequired,
disableCache,
cacheLifetime,
retryCount,
credentials
});
}
public IL2Object InvokeOriginal(IntPtr obj, params IL2Object[] paramtbl) => InvokeOriginal(obj, IL2Import.IL2CPPObjectArrayToIntPtrArray(paramtbl));
public static void Start()
{
IL2Method method;
int iError = 0;
// ~ Analytics [Count: 3]
try
{
method = Assemblies.a["UnityEngine.UnityAnalyticsModule"].GetClass("Analytics", "UnityEngine.Analytics").GetMethods()
.Where(x => x.Name == "CustomEvent" && x.GetParameters().Length == 2)
.First(x => x.GetParameters()[1].Name == "eventData");
pAnalytics[0] = IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_3", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [2]");
iError++;
}
try
{
method = Assemblies.a["Assembly-CSharp"].GetClass("Analytics").GetMethods()
.Where(x => x.GetReturnType().Name == "System.Void" && x.GetParameters().Length == 3)
.Where(x => x.GetParameters()[0].typeName[0] == 'A')
.First(x => x.HasFlag(IL2BindingFlags.METHOD_STATIC));
pAnalytics[1] = IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_4", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [3]");
iError++;
}
try
{
method = Assemblies.a["VRCCore-Standalone"].GetClass("AmplitudeWrapper", "AmplitudeSDKWrapper").GetMethod("CheckedLogEvent");
pAnalytics[2] = IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_5", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [4]");
iError++;
}
try
{
foreach (var m in Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethods()
.Where(x => x.GetReturnType().Name == "System.Boolean" && x.GetParameters().Length == 0))
{
//.Where(x => x.HasFlag(IL2BindingFlags.METHOD_STATIC)))
IL2Ch.Patch(m, typeof(patch_AntiKick).GetMethod("patch_method_6", BindingFlags.Static | BindingFlags.NonPublic));
}
}
catch
{
ConSole.Error("Patch: AntiKick [5]");
iError++;
}
try
{
foreach (var m in Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethods()
.Where(x => x.GetParameters().Length == 3)
.Where(x => IL2Import.il2cpp_type_get_name(x.GetParameters()[0].ptr) == "System.String")
.Where(x => IL2Import.il2cpp_type_get_name(x.GetParameters()[1].ptr) == "System.String")
.Where(x => IL2Import.il2cpp_type_get_name(x.GetParameters()[2].ptr) == "System.String"))
{
IL2Ch.Patch(m, typeof(patch_AntiKick).GetMethod("patch_method_7", BindingFlags.Static | BindingFlags.NonPublic));
}
}
catch
{
ConSole.Error("Patch: AntiKick [6]");
iError++;
}
try
{
method = Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethod("KickUserRPC");
IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_5", BindingFlags.Static | BindingFlags.NonPublic));
method = Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethod("WarnUserRPC");
IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_5", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [6]");
iError++;
}
// Debug
if (iError == 0)
{
ConSole.Success("Patch: AntiKick");
}
else
{
ConSole.Error("Patch: AntiKick");
}
}
