using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.IL2CPP;
using BepInEx.IL2CPP.Utils;
using BepInEx.Logging;
using CrabDevKit.Intermediary;
using HarmonyLib;
using Il2CppSystem.Runtime.InteropServices;
using Microsoft.CodeAnalysis;
using PersistentData;
using SteamworksNative;
using TMPro;
using UnhollowerBaseLib;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace AntiCrasher
{
internal static class LobbyTracker
{
internal static HashSet<ulong> currentMembers = new HashSet<ulong>();
internal static HashSet<ulong> blockedMembers = new HashSet<ulong>();
internal static void Init()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
new Harmony("AntiCrasher.LobbyTracker").PatchAll(typeof(LobbyTracker));
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "Method_Private_Void_LobbyEnter_t_PDM_1")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static void PreSteamManagerLobbyEnter(LobbyEnter_t param_1)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
currentMembers.Clear();
blockedMembers.Clear();
CSteamID val = default(CSteamID);
((CSteamID)(ref val))..ctor(param_1.m_ulSteamIDLobby);
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(val);
currentMembers.EnsureCapacity(numLobbyMembers);
for (int i = 0; i < numLobbyMembers; i++)
{
currentMembers.Add(SteamMatchmaking.GetLobbyMemberByIndex(val, i).m_SteamID);
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "Method_Private_Void_LobbyChatUpdate_t_PDM_3")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static void PreSteamManagerPlayerJoinOrLeave(LobbyChatUpdate_t param_1)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (param_1.m_rgfChatMemberStateChange == 1)
{
currentMembers.Add(param_1.m_ulSteamIDUserChanged);
return;
}
currentMembers.Remove(param_1.m_ulSteamIDUserChanged);
blockedMembers.Remove(param_1.m_ulSteamIDUserChanged);
}
[HarmonyPatch(typeof(SteamMatchmaking), "LeaveLobby")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static void PreSteamMatchmakingLeaveLobby()
{
currentMembers.Clear();
blockedMembers.Clear();
}
}
internal static class PersistentDataCompatibility
{
internal static bool? enabled;
internal static bool Enabled
{
get
{
if (enabled.HasValue)
{
return enabled.Value;
}
bool? flag = (enabled = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("lammas123.PersistentData"));
return flag.Value;
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static bool SetClientData(ulong clientId, string key, string value)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
ClientDataFile clientDataFile = Api.GetClientDataFile(clientId);
bool result = ((ClientDataFile)(ref clientDataFile)).Set(key, value);
((ClientDataFile)(ref clientDataFile)).SaveFile();
return result;
}
}
internal static class PacketLogger
{
internal sealed class PacketLog
{
internal DateTime time;
internal ulong senderId;
internal string senderName;
internal int channel;
internal int packetThisFrame;
internal byte[] bytes;
}
private static readonly ConcurrentQueue<PacketLog> packetQueue = new ConcurrentQueue<PacketLog>();
private static readonly AutoResetEvent signal = new AutoResetEvent(initialState: false);
private static Thread writerThread;
private static volatile bool writerRunning;
internal static void Init()
{
StartWriterThread();
}
private static void StartWriterThread()
{
if (!writerRunning)
{
writerRunning = true;
writerThread = new Thread(PacketWriterLoop)
{
IsBackground = true,
Name = "AntiCrasherPacketWriter"
};
writerThread.Start();
((BasePlugin)AntiCrasher.Instance).Log.LogInfo((object)"Started PacketLogger writer thread");
}
}
private static void PacketWriterLoop()
{
string path = Path.Combine(Paths.BepInExRootPath, "PacketLog.txt");
try
{
using FileStream stream = new FileStream(path, FileMode.Truncate, FileAccess.Write, FileShare.Read, 8192, FileOptions.WriteThrough);
using StreamWriter streamWriter = new StreamWriter(stream, Encoding.UTF8)
{
AutoFlush = false
};
StringBuilder stringBuilder = new StringBuilder(16384);
while (writerRunning)
{
signal.WaitOne(100);
bool flag = false;
PacketLog result;
while (packetQueue.TryDequeue(out result))
{
flag = true;
stringBuilder.Append($"{DateTime.Now,-11:h:mm:ss tt} ").Append(result.senderName).Append(" (@")
.Append(result.senderId)
.Append(") ");
stringBuilder.Append('#').Append(result.packetThisFrame).Append(' ')
.Append((object)(EnumNPublicSealedvaTo3vToUnique)result.channel)
.Append(" Len:")
.Append(result.bytes.Length)
.Append(' ');
stringBuilder.Append(BitConverter.ToString(result.bytes));
stringBuilder.AppendLine();
if (stringBuilder.Length > 65536)
{
streamWriter.Write(stringBuilder.ToString());
stringBuilder.Clear();
streamWriter.Flush();
}
}
if (flag && stringBuilder.Length > 0)
{
streamWriter.Write(stringBuilder.ToString());
stringBuilder.Clear();
streamWriter.Flush();
}
}
if (stringBuilder.Length > 0)
{
streamWriter.Write(stringBuilder.ToString());
streamWriter.Flush();
}
}
catch (Exception ex)
{
writerRunning = false;
try
{
File.AppendAllText(path, "\n[PacketWriterLoop crashed]\n" + ex?.ToString() + "\n");
}
catch
{
}
}
}
internal static void EnqueuePacket(ulong senderId, int channel, int packetThisFrame, byte[] data)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
if (AntiCrasher.Instance.packetLogging && writerRunning && senderId != 0L)
{
packetQueue.Enqueue(new PacketLog
{
time = DateTime.Now,
senderId = senderId,
senderName = SteamFriends.GetFriendPersonaName(new CSteamID(senderId)),
channel = channel,
packetThisFrame = packetThisFrame,
bytes = data
});
signal.Set();
}
}
}
internal static class HandlePacketPatches
{
internal static Coroutine keybindCoro;
private const int MIN_PACKET_SIZE = 8;
private static int _maxHandledPackets;
private static int _totalHandledPackets;
internal static IEnumerator CoroKeybinds()
{
while (true)
{
yield return null;
if ((Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307)) && Input.GetKeyDown((KeyCode)116))
{
((BasePlugin)AntiCrasher.Instance).Log.LogInfo((object)"Tested AntiCrasher");
if (Object.op_Implicit((Object)(object)MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance))
{
MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance.AppendMessage(0uL, "Functional", "AntiCrasher");
}
}
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInVoAwVoVoVoVoVoVoUnique), "Awake")]
[HarmonyPostfix]
internal static void PostMainManagerAwake()
{
if (keybindCoro == null)
{
keybindCoro = MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInVoAwVoVoVoVoVoVoUnique.Instance, CoroKeybinds());
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "Update")]
[HarmonyPostfix]
internal static void PostSteamPacketManagerUpdate()
{
while (_maxHandledPackets == SteamPacketManagerExtensions.deobf_messagesToCheckFor)
{
((BasePlugin)AntiCrasher.Instance).Log.LogInfo((object)"Handled 70 packets! Checking for more...");
_maxHandledPackets = 0;
MonoBehaviourPublicInStInpabyDiInpaby2Unique.CheckForPackets();
}
_totalHandledPackets = 0;
}
[HarmonyPatch(typeof(SteamNetworkingMessages), "ReceiveMessagesOnChannel")]
[HarmonyPostfix]
internal static void PostSteamPacketManagerUpdate(int __result, int nLocalChannel)
{
if ((nLocalChannel == 0 || nLocalChannel == 1) && __result > _maxHandledPackets)
{
_maxHandledPackets = __result;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "Method_Private_Static_Void_SteamNetworkingMessage_t_Int32_0")]
[HarmonyPrefix]
[HarmonyPriority(int.MinValue)]
internal static bool PreSteamPacketManagerHandlePacket(SteamNetworkingMessage_t param_0, int param_1)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Expected O, but got Unknown
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Invalid comparison between Unknown and I4
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Invalid comparison between Unknown and I4
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Invalid comparison between Unknown and I4
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Invalid comparison between Unknown and I4
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Invalid comparison between Unknown and I4
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: Invalid comparison between Unknown and I4
_totalHandledPackets++;
ulong steamID = param_0.m_identityPeer.GetSteamID64();
if (!SessionVerifier.IsValid(steamID))
{
MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.StopP2P(new CSteamID(steamID));
if (AntiCrasher.Instance.packetLogging)
{
PacketLogger.EnqueuePacket(steamID, -1, _totalHandledPackets, Array.Empty<byte>());
}
return false;
}
int cbSize = param_0.m_cbSize;
if (cbSize < 8)
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.InvalidPacketLength);
if (AntiCrasher.Instance.packetLogging)
{
PacketLogger.EnqueuePacket(steamID, -2, _totalHandledPackets, Array.Empty<byte>());
}
return false;
}
Il2CppStructArray<byte> val = new Il2CppStructArray<byte>((long)cbSize);
Marshal.Copy(param_0.m_pData, val, 0, cbSize);
ObjectPublicIDisposableLi1ByInByBoUnique val2 = new ObjectPublicIDisposableLi1ByInByBoUnique();
PacketExtensions.SetBytes(val2, Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)val));
PacketExtensions.ReadInt(val2, true);
int num = PacketExtensions.ReadInt(val2, true);
if (AntiCrasher.Instance.packetLogging)
{
PacketLogger.EnqueuePacket(steamID, param_1, _totalHandledPackets, Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)val));
}
if (param_1 == 1)
{
if (!Enum.IsDefined(typeof(EnumPublicSealedvahawesepirepiselostUnique), num))
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.InvalidClientPacketType);
return false;
}
EnumPublicSealedvahawesepirepiselostUnique val3 = (EnumPublicSealedvahawesepirepiselostUnique)num;
if ((int)val3 <= 7)
{
if ((int)val3 == 3)
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedPingPongPacket);
return false;
}
if ((int)val3 == 7)
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedColorChangeRequestPacket);
return false;
}
}
else
{
if ((int)val3 == 12)
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedRequestGameStartedCooldownPacket);
return false;
}
if ((int)val3 == 23)
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedTryBuyItemPacket);
return false;
}
if ((int)val3 == 26)
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedPlayerReloadPacket);
return false;
}
}
}
else
{
if (!Enum.IsDefined(typeof(EnumPublicSealedvawesepilorelogasespUnique), num))
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.InvalidServerPacketType);
return false;
}
if (steamID != SteamMatchmaking.GetLobbyOwner(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby).m_SteamID)
{
if (num == 13 || num == 14)
{
AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnauthorizedServerPacketFromNonHost);
}
return false;
}
if (num == 39)
{
if (cbSize < 16)
{
return false;
}
ulong clientId = PacketExtensions.ReadUlong(val2, true);
AntiCrasher.Instance.Flag(clientId, AntiCrashReason.UnusedPlayerReloadPacketFromHost, banOffender: false);
return false;
}
}
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "Method_Private_Static_Void_SteamNetworkingMessage_t_Int32_0")]
[HarmonyFinalizer]
internal static Exception FinalSteamPacketManagerHandlePacket(SteamNetworkingMessage_t param_0, int param_1, Exception __exception)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if (__exception != null)
{
ManualLogSource log = ((BasePlugin)AntiCrasher.Instance).Log;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(51, 4, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("An exception occurred handling a ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<EnumNPublicSealedvaTo3vToUnique>((EnumNPublicSealedvaTo3vToUnique)param_1);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" packet from ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SteamFriends.GetFriendPersonaName(param_0.m_identityPeer.GetSteamID()));
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(param_0.m_identityPeer.GetSteamID64());
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("):\n");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(__exception);
}
log.LogError(val);
}
return null;
}
}
internal static class InvalidHelpers
{
internal static bool IsInvalid(this float value)
{
if (!float.IsNaN(value) && !float.IsInfinity(value) && value != float.MaxValue)
{
return value == float.MinValue;
}
return true;
}
internal static bool IsInvalid(this Vector3 value)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
if (!value.x.IsInvalid() && !value.y.IsInvalid())
{
return value.z.IsInvalid();
}
return true;
}
}
internal static class ServerHandlePatches
{
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerPosition")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreServerHandlePlayerPosition(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
int num = PacketExtensions[param_1];
if (PacketExtensions.ReadVector3(param_1, true).IsInvalid())
{
AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerPositionPacket);
PacketExtensions[param_1] = num;
return false;
}
PacketExtensions[param_1] = num;
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerRotation")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreServerHandlePlayerRotation(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
{
int num = PacketExtensions[param_1];
float value = PacketExtensions.ReadFloat(param_1, true);
if (PacketExtensions.ReadFloat(param_1, true).IsInvalid() || value.IsInvalid())
{
AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerRotationPacket);
PacketExtensions[param_1] = num;
return false;
}
PacketExtensions[param_1] = num;
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerAnimation")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreServerHandlePlayerAnimation(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
{
int num = PacketExtensions[param_1];
int num2 = PacketExtensions.ReadInt(param_1, true);
if (!Enum.IsDefined(typeof(EnumNPublicSealedvaCrMe3vUnique), num2))
{
AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerAnimationPacket);
PacketExtensions[param_1] = num;
return false;
}
PacketExtensions[param_1] = num;
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "CrabDamage")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreServerHandleCrabDamage(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
{
int num = PacketExtensions[param_1];
int num2 = PacketExtensions.ReadInt(param_1, true);
int num3 = PacketExtensions.ReadInt(param_1, true);
ItemData itemById = MonoBehaviourPublicDi2InItidGamoObInUnique.GetItemById(num2);
if ((Object)(object)itemById == (Object)null || itemById.itemName != "Snowball" || !MonoBehaviourPublicDi2InObInObInUnique.Instance.Contains(num3))
{
AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidCrabDamagePacket);
PacketExtensions[param_1] = num;
return false;
}
MonoBehaviourPublicInidBoskUnique sharedObject = MonoBehaviourPublicDi2InObInObInUnique.Instance.GetSharedObject(num3);
if ((Object)(object)sharedObject != (Object)null)
{
MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique component = ((Component)sharedObject).GetComponent<MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique>();
if ((Object)(object)component != (Object)null && component.itemData.itemID != num2)
{
AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidCrabDamagePacket);
PacketExtensions[param_1] = num;
return false;
}
}
PacketExtensions[param_1] = num;
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerDamage")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreServerHandlePlayerDamage(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
int num = PacketExtensions[param_1];
PacketExtensions.ReadUlong(param_1, true);
PacketExtensions.ReadInt(param_1, true);
Vector3 val = PacketExtensions.ReadVector3(param_1, true);
if (val.IsInvalid() || (val != Vector3.zero && (((Vector3)(ref val)).magnitude > 1.0001f || ((Vector3)(ref val)).magnitude < 0.9999f)))
{
AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerDamagePacket);
PacketExtensions[param_1] = num;
return false;
}
PacketExtensions[param_1] = num;
return true;
}
}
internal static class ClientHandlePatches
{
[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerPosition")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreClientHandlePlayerPosition(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
int num = PacketExtensions[param_0];
ulong clientId = PacketExtensions.ReadUlong(param_0, true);
if (PacketExtensions.ReadVector3(param_0, true).IsInvalid())
{
AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerPositionPacketFromHost, banOffender: false);
PacketExtensions[param_0] = num;
return false;
}
PacketExtensions[param_0] = num;
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerRotation")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreClientHandlePlayerRotation(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
{
int num = PacketExtensions[param_0];
ulong clientId = PacketExtensions.ReadUlong(param_0, true);
float value = PacketExtensions.ReadFloat(param_0, true);
if (PacketExtensions.ReadFloat(param_0, true).IsInvalid() || value.IsInvalid())
{
AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerRotationPacketFromHost, banOffender: false);
PacketExtensions[param_0] = num;
return false;
}
PacketExtensions[param_0] = num;
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerAnimation")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreClientHandlePlayerAnimation(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
{
int num = PacketExtensions[param_0];
ulong clientId = PacketExtensions.ReadUlong(param_0, true);
int num2 = PacketExtensions.ReadInt(param_0, true);
if (!Enum.IsDefined(typeof(EnumNPublicSealedvaCrMe3vUnique), num2))
{
AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerAnimationPacketFromHost, banOffender: false);
PacketExtensions[param_0] = num;
return false;
}
PacketExtensions[param_0] = num;
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerDamage")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreClientHandlePlayerDamage(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
int num = PacketExtensions[param_0];
ulong clientId = PacketExtensions.ReadUlong(param_0, true);
PacketExtensions.ReadUlong(param_0, true);
PacketExtensions.ReadInt(param_0, true);
Vector3 val = PacketExtensions.ReadVector3(param_0, true);
if (val.IsInvalid() || (val != Vector3.zero && (((Vector3)(ref val)).magnitude > 1.0001f || ((Vector3)(ref val)).magnitude < 0.9999f)))
{
AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerDamagePacketFromHost, banOffender: false);
PacketExtensions[param_0] = num;
return !val.IsInvalid();
}
PacketExtensions[param_0] = num;
return true;
}
}
internal static class ChatboxPatches
{
[HarmonyPatch(typeof(MonoBehaviourPublicRaovTMinTemeColoonCoUnique), "ForceMessage")]
[HarmonyPostfix]
internal static void PostChatboxForceMessage(MonoBehaviourPublicRaovTMinTemeColoonCoUnique __instance)
{
if (((TMP_Text)__instance.messages).text.Length > ChatboxExtensions[__instance])
{
TextMeshProUGUI messages = __instance.messages;
string text = ((TMP_Text)__instance.messages).text;
int num = ChatboxExtensions[__instance];
int length = text.Length;
int num2 = length - num;
((TMP_Text)messages).text = text.Substring(num2, length - num2);
}
}
}
internal static class PlayerChatDropPatches
{
private static bool _shouldNotParse = false;
private static readonly HashSet<ulong> _recentDrops = new HashSet<ulong>();
[HarmonyPatch(typeof(MonoBehaviourPublicStCaSt1ObSthaUIStmaUnique), "PlayerChatDrop")]
[HarmonyPrefix]
internal static void PreDeobf_SteamInventoryPlayerChatDrop()
{
_shouldNotParse = true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicStCaSt1ObSthaUIStmaUnique), "PlayerChatDrop")]
[HarmonyPostfix]
internal static void PostDeobf_SteamInventoryPlayerChatDrop()
{
_shouldNotParse = false;
}
[HarmonyPatch(typeof(SteamFriends), "GetFriendPersonaName")]
[HarmonyPostfix]
internal static void PostSteamFriendsGetFriendPersonaName(ref string __result)
{
if (_shouldNotParse)
{
__result = "<noparse>" + __result.Replace("noparse", "") + "</noparse>";
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerDropSerialized")]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreServerHandlePlayerDropSerialized(ulong param_0)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
if (_recentDrops.Contains(param_0))
{
return false;
}
_recentDrops.Add(param_0);
MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInVoAwVoVoVoVoVoVoUnique.Instance, CoroChatDropCooldown(param_0));
string friendPersonaName = SteamFriends.GetFriendPersonaName(new CSteamID(param_0));
int num = friendPersonaName.IndexOf('<');
if (num == -1 || num + 1 >= friendPersonaName.Length)
{
return true;
}
return friendPersonaName.IndexOf(">", num + 1) == -1;
}
private static IEnumerator CoroChatDropCooldown(ulong clientId)
{
yield return (object)new WaitForSeconds(1f);
_recentDrops.Remove(clientId);
}
}
internal static class AntiShadowModPatches
{
[HarmonyPatch(typeof(MonoBehaviourPublicGapaTrconaGaDi2UIObUnique), "UpdateList")]
[HarmonyPostfix]
internal static void PostPlayerListUpdateList(MonoBehaviourPublicGapaTrconaGaDi2UIObUnique __instance)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
if (!MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
{
return;
}
foreach (ObjectPublicBoInBoCSItBoInSiBySiUnique item in (Il2CppArrayBase<ObjectPublicBoInBoCSItBoInSiBySiUnique>)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.GetClients())
{
if (!(item.field_Public_CSteamID_0 == CSteamID.Nil) && !__instance.field_Private_Dictionary_2_UInt64_MonoBehaviourPublicRabaicRaTeusscTepiObUnique_0.ContainsKey(item.field_Public_CSteamID_0.m_SteamID))
{
MonoBehaviourPublicRabaicRaTeusscTepiObUnique component = Object.Instantiate<GameObject>(__instance.namePrefab, __instance.contentParent).GetComponent<MonoBehaviourPublicRabaicRaTeusscTepiObUnique>();
__instance.field_Private_Dictionary_2_UInt64_MonoBehaviourPublicRabaicRaTeusscTepiObUnique_0.Add(item.field_Public_CSteamID_0.m_SteamID, component);
((TMP_Text)component.username).text = MonoBehaviourPublicRaovTMinTemeColoonCoUnique.RemoveRichText(SteamFriends.GetFriendPersonaName(item.field_Public_CSteamID_0));
if (MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(item.field_Public_CSteamID_0.m_SteamID))
{
component.SetPlayer(MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[item.field_Public_CSteamID_0.m_SteamID]);
}
else
{
component.SetSpectator(item.field_Public_CSteamID_0.m_SteamID);
}
((Graphic)component.background).color = Color.yellow;
((Graphic)component.icon).color = Color.yellow;
}
}
}
}
[BepInPlugin("lammas123.AntiCrasher", "AntiCrasher", "1.1.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class AntiCrasher : BasePlugin
{
internal static AntiCrasher Instance;
internal bool chatFlags = true;
internal bool persistentDataBan;
internal bool packetLogging;
public override void Load()
{
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0131: Expected O, but got Unknown
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
Instance = this;
chatFlags = ((BasePlugin)this).Config.Bind<bool>("AntiCrasher", "ChatFlags", true, "Whether to notify you about the Anti Crasher being flagged in the chatbox or not. You'll still be able to check for flags in the console or LogOutput.txt.").Value;
persistentDataBan = ((BasePlugin)this).Config.Bind<bool>("AntiCrasher", "PersistentDataBans", false, "If flagged crashers should be permanently banned via PersistentData if it's installed.").Value;
packetLogging = ((BasePlugin)this).Config.Bind<bool>("AntiCrasher", "PacketLogging", false, "If all received packets should be logged to PacketLog.txt at the root of your BepInEx directory.").Value;
LobbyTracker.Init();
SessionVerifier.Init();
if (packetLogging)
{
PacketLogger.Init();
}
Harmony val = new Harmony("AntiCrasher");
val.PatchAll(typeof(HandlePacketPatches));
val.PatchAll(typeof(ServerHandlePatches));
val.PatchAll(typeof(ClientHandlePatches));
val.PatchAll(typeof(ChatboxPatches));
val.PatchAll(typeof(PlayerChatDropPatches));
val.PatchAll(typeof(AntiShadowModPatches));
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Initialized [");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("AntiCrasher");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("1.1.1");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("]");
}
log.LogInfo(val2);
}
internal void Flag(ulong clientId, AntiCrashReason reason, bool banOffender = true)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(17, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Flagged ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SteamFriends.GetFriendPersonaName(new CSteamID(clientId)));
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(clientId);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") for: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AntiCrashReason>(reason);
}
log.LogInfo(val);
if (chatFlags && Object.op_Implicit((Object)(object)MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance))
{
MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance.AppendMessage(0uL, reason.ToString(), "AntiCrasher Flagged " + SteamFriends.GetFriendPersonaName(new CSteamID(clientId)) + " for");
}
if (!banOffender || !MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() || clientId == SteamUser.GetSteamID().m_SteamID)
{
if (banOffender && clientId != SteamUser.GetSteamID().m_SteamID)
{
if (clientId == MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.originalLobbyOwnerId.m_SteamID)
{
MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.LeaveLobby();
MonoBehaviourPublicGaprLi1ObGaprInUnique.Instance.NewPrompt("Anti Crasher", $"The host was flagged for {reason}, left lobby.");
}
else
{
LobbyTracker.blockedMembers.Add(clientId);
MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.StopP2P(new CSteamID(clientId));
}
}
}
else
{
if (persistentDataBan && PersistentDataCompatibility.Enabled)
{
PersistentDataCompatibility.SetClientData(clientId, "Banned", $"[AntiCrasher] detected: {reason}");
}
LobbyTracker.blockedMembers.Add(clientId);
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.BanPlayer(clientId);
}
}
}
internal enum AntiCrashReason
{
InvalidPacketLength,
InvalidClientPacketType,
InvalidServerPacketType,
UnauthorizedServerPacketFromNonHost,
UnusedPingPongPacket,
UnusedColorChangeRequestPacket,
UnusedRequestGameStartedCooldownPacket,
UnusedTryBuyItemPacket,
UnusedPlayerReloadPacket,
UnusedPlayerReloadPacketFromHost,
InvalidPlayerPositionPacket,
InvalidPlayerRotationPacket,
InvalidPlayerAnimationPacket,
InvalidCrabDamagePacket,
InvalidPlayerDamagePacket,
InvalidPlayerPositionPacketFromHost,
InvalidPlayerRotationPacketFromHost,
InvalidPlayerAnimationPacketFromHost,
InvalidPlayerDamagePacketFromHost
}
internal static class SessionVerifier
{
internal static void Init()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
new Harmony("AntiCrasher.SessionVerifier").PatchAll(typeof(SessionVerifier));
}
internal static bool IsValid(ulong clientId)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if (clientId != SteamUser.GetSteamID().m_SteamID)
{
if (LobbyTracker.currentMembers.Contains(clientId))
{
return !LobbyTracker.blockedMembers.Contains(clientId);
}
return false;
}
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(CSteamID) })]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreSteamManagerNewAcceptP2P(CSteamID param_1)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (IsValid(param_1.m_SteamID))
{
return true;
}
if (AntiCrasher.Instance.packetLogging)
{
PacketLogger.EnqueuePacket(param_1.m_SteamID, -1, -1, Array.Empty<byte>());
}
return false;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(SteamNetworkingIdentity) })]
[HarmonyPrefix]
[HarmonyPriority(int.MaxValue)]
internal static bool PreSteamManagerNewAcceptP2P(SteamNetworkingIdentity param_1)
{
if (IsValid(param_1.GetSteamID64()))
{
return true;
}
if (AntiCrasher.Instance.packetLogging)
{
PacketLogger.EnqueuePacket(param_1.GetSteamID64(), -1, -1, Array.Empty<byte>());
}
return false;
}
}
internal static class TestAntiCrash
{
internal static void Test()
{
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "lammas123.AntiCrasher";
public const string PLUGIN_NAME = "AntiCrasher";
public const string PLUGIN_VERSION = "1.1.1";
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
