FREE WNoSteam : 1.2.0 1.2.0

using System;
using System.Collections.Generic;
using System.Reflection;
using Oxide.Core.Plugins;
using Steamworks;
using Newtonsoft.Json;
using Network;
using UnityEngine;

namespace Oxide.Plugins
{
	[Info("NoSteam", "WOLF#4002", "1.2.0")] 
	class WNoSteam : RustPlugin
	{
		#region Variables

		private Dictionary<ulong, uint> ListAppID { get; } = new Dictionary<ulong, uint>();
		

		private Configuration _config;
		#endregion

		#region Configuration
		public class Configuration
		{
			[JsonProperty("Авторизовывать ВСЕХ игроков как NoSteam игроков")]
			public bool AnyPlayersPirate = false;

			[JsonProperty("Разрешить входить NoSteam игрокам без очереди")]
			public bool HasAnyWayJoin = false;

			[JsonProperty("Не пускать разработчиков на сервер")]
			public bool kickDevelopers = false;

			[JsonProperty("Проверять AppID для NoSteam игроков")]
			public bool checkAppID = false;
		}

		protected override void LoadConfig()
		{
			base.LoadConfig();
			try
			{
				this._config = Config.ReadObject<Configuration>();
				Config.WriteObject(this._config, true);
			}
			catch
			{
				PrintError("Error reading config, please check!");
			}
		}

		protected override void LoadDefaultConfig()
		{
			Config.WriteObject(new Configuration(), true);
		}
		#endregion

		#region Init
		private void Loaded()
		{
			#region [Section] Subcribe to {OnUpdateServerInformation} hook
			FieldInfo fieldInfo_isCorePlugin = typeof(Plugin).GetField("isCorePlugin", BindingFlags.CreateInstance | BindingFlags.Instance | BindingFlags.NonPublic);
			fieldInfo_isCorePlugin.SetValue(this, true);
			this.Subscribe("IOnUpdateServerInformation");
			fieldInfo_isCorePlugin.SetValue(this, false);
			#endregion
            
			
		}
		#endregion

		#region Oxide Hooks
		private object OnUserApprove(Network.Connection connection)
		{
			if (this._config.kickDevelopers && (DeveloperList.Contains(connection.userid) || DeveloperList.Contains(connection.ownerid)))
			{
				PrintError(connection.ToString() + " is a developer");
				ConnectionAuth.Reject(connection, "You banned from this server!");
				return false;
			}

			bool canPirate = this.CanPirate(connection, true);
			if (canPirate == true || this._config.AnyPlayersPirate)
			{
				ulong steamID_1 = BitConverter.ToUInt64(connection.token, 12);
				ulong steamID_2 = BitConverter.ToUInt64(connection.token, 64);

				if (steamID_1 == connection.userid && steamID_2 == connection.userid)
				{

					#region [Section] Disable Steam
					connection.authStatus = "ok";
					#endregion

					#region [Section] Disable Encryption
					connection.os = "editor";
					connection.ownerid = 76561197960279927UL;
					#endregion

					#region [Section] Disable EAC
					MethodInfo authLocal = typeof(EACServer).GetMethod("OnAuthenticatedLocal", BindingFlags.Static | BindingFlags.NonPublic);
			        MethodInfo authRemote = typeof(EACServer).GetMethod("OnAuthenticatedRemote", BindingFlags.Static | BindingFlags.NonPublic);
			
					authLocal.Invoke(null, new object[]
					{
						connection
					});
					authRemote.Invoke(null, new object[]
					{
						connection
					});
					#endregion

					if (this._config.HasAnyWayJoin)
					{
						SingletonComponent<ServerMgr>.Instance.JoinGame(connection);
					}
					else
					{
						SingletonComponent<ServerMgr>.Instance.connectionQueue.GetType()
							.GetMethod("Join", BindingFlags.Instance | BindingFlags.CreateInstance | BindingFlags.NonPublic)
							.Invoke(SingletonComponent<ServerMgr>.Instance.connectionQueue, new object[] {connection});
					}

					PrintWarning($"Player [{connection.userid} / {connection.username} / {connection.ipaddress}] use no-steam!");

					return false;
				}
				else
				{
					PrintError($"Danger: [{connection.userid} / {connection.ipaddress}] - trying to replace steamid! userID: {connection.userid}, steamID1: {steamID_1}, steamID2: {steamID_2}");
					ConnectionAuth.Reject(connection, "Steam Auth Failed");
					return false;
				}
			}

			return null;
		}

		private void IOnUpdateServerInformation()
		{
			int pirateOnline = 0;
			for (var i = 0; i < BasePlayer.activePlayerList.Count; i++)
			{
				if (this.CanPirate(BasePlayer.activePlayerList[i].Connection))
				{
					pirateOnline++;
				}
			}
			string newTagsLine = "";
			string[] tags = SteamServer.GameTags.Split(new char[]{ ',' }, StringSplitOptions.RemoveEmptyEntries);
			for (var i = 0; i < tags.Length; i++)
			{
				if (tags[i].Substring(0, 2) == "cp")
				{
					newTagsLine += (newTagsLine.Length > 0 ? "," : "") + "cp" + (BasePlayer.activePlayerList.Count - pirateOnline);
				}
				else
				{
					newTagsLine += (newTagsLine.Length > 0 ? "," : "") + tags[i];
				}
			}

			newTagsLine += $",ai{pirateOnline},fl{BasePlayer.activePlayerList.Count},kkk";
			SteamServer.GameTags = newTagsLine;
		}

		private void OnPlayerConnected(Network.Message packet)
		{
			#region [Section] Disable Vanish from Encryption
			if (packet.connection.os == "editor")
			{
				packet.connection.os = "windows";
				packet.connection.ownerid = packet.connection.userid;
			}
			#endregion
		}
		#endregion
		
		public bool CanPirate(Connection connection, bool rebuild = false)
		{
			uint appID = 0;
			if (connection.token.Length == 234 || connection.token.Length == 240)
			{
				if (rebuild == true || this.ListAppID.TryGetValue(connection.userid, out appID) == false)
				{
					appID = BitConverter.ToUInt32(connection.token, 72);
					this.ListAppID[connection.userid] = appID;
				}
			}
			return (appID == 480);
		}
    }
}