Basic rate limiting for chat messages (#21907)

Content.Server/Chat/Managers/ChatManager.RateLimit.cs

@@ -0,0 +1,84 @@
+using System.Runtime.InteropServices;
+using Content.Shared.CCVar;
+using Content.Shared.Database;
+using Robust.Shared.Enums;
+using Robust.Shared.Player;
+using Robust.Shared.Timing;
+
+namespace Content.Server.Chat.Managers;
+
+internal sealed partial class ChatManager
+{
+    private readonly Dictionary<ICommonSession, RateLimitDatum> _rateLimitData = new();
+
+    public bool HandleRateLimit(ICommonSession player)
+    {
+        ref var datum = ref CollectionsMarshal.GetValueRefOrAddDefault(_rateLimitData, player, out _);
+        var time = _gameTiming.RealTime;
+        if (datum.CountExpires < time)
+        {
+            // Period expired, reset it.
+            var periodLength = _configurationManager.GetCVar(CCVars.ChatRateLimitPeriod);
+            datum.CountExpires = time + TimeSpan.FromSeconds(periodLength);
+            datum.Count = 0;
+            datum.Announced = false;
+        }
+
+        var maxCount = _configurationManager.GetCVar(CCVars.ChatRateLimitCount);
+        datum.Count += 1;
+
+        if (datum.Count <= maxCount)
+            return true;
+
+        // Breached rate limits, inform admins if configured.
+        if (_configurationManager.GetCVar(CCVars.ChatRateLimitAnnounceAdmins))
+        {
+            if (datum.NextAdminAnnounce < time)
+            {
+                SendAdminAlert(Loc.GetString("chat-manager-rate-limit-admin-announcement", ("player", player.Name)));
+                var delay = _configurationManager.GetCVar(CCVars.ChatRateLimitAnnounceAdminsDelay);
+                datum.NextAdminAnnounce = time + TimeSpan.FromSeconds(delay);
+            }
+        }
+
+        if (!datum.Announced)
+        {
+            DispatchServerMessage(player, Loc.GetString("chat-manager-rate-limited"), suppressLog: true);
+            _adminLogger.Add(LogType.ChatRateLimited, LogImpact.Medium, $"Player {player} breached chat rate limits");
+
+            datum.Announced = true;
+        }
+
+        return false;
+    }
+
+    private void PlayerStatusChanged(object? sender, SessionStatusEventArgs e)
+    {
+        if (e.NewStatus == SessionStatus.Disconnected)
+            _rateLimitData.Remove(e.Session);
+    }
+
+    private struct RateLimitDatum
+    {
+        /// <summary>
+        /// Time stamp (relative to <see cref="IGameTiming.RealTime"/>) this rate limit period will expire at.
+        /// </summary>
+        public TimeSpan CountExpires;
+
+        /// <summary>
+        /// How many messages have been sent in the current rate limit period.
+        /// </summary>
+        public int Count;
+
+        /// <summary>
+        /// Have we announced to the player that they've been blocked in this rate limit period?
+        /// </summary>
+        public bool Announced;
+
+        /// <summary>
+        /// Time stamp (relative to <see cref="IGameTiming.RealTime"/>) of the
+        /// next time we can send an announcement to admins about rate limit breach.
+        /// </summary>
+        public TimeSpan NextAdminAnnounce;
+    }
+}

Content.Server/Chat/Managers/ChatManager.cs

@@ -11,10 +11,12 @@ using Content.Shared.CCVar;
 using Content.Shared.Chat;
 using Content.Shared.Database;
 using Content.Shared.Mind;
+using Robust.Server.Player;
 using Robust.Shared.Configuration;
 using Robust.Shared.Network;
 using Robust.Shared.Player;
 using Robust.Shared.Replays;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Content.Server.Chat.Managers
@@ -22,7 +24,7 @@ namespace Content.Server.Chat.Managers
     /// <summary>
     ///     Dispatches chat messages to clients.
     /// </summary>
-    internal sealed class ChatManager : IChatManager
+    internal sealed partial class ChatManager : IChatManager
     {
         private static readonly Dictionary<string, string> PatronOocColors = new()
         {
@@ -41,6 +43,8 @@ namespace Content.Server.Chat.Managers
         [Dependency] private readonly IConfigurationManager _configurationManager = default!;
         [Dependency] private readonly INetConfigurationManager _netConfigManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IGameTiming _gameTiming = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
 
         /// <summary>
         /// The maximum length a player-sent message can be sent
@@ -59,6 +63,8 @@ namespace Content.Server.Chat.Managers
 
             _configurationManager.OnValueChanged(CCVars.OocEnabled, OnOocEnabledChanged, true);
             _configurationManager.OnValueChanged(CCVars.AdminOocEnabled, OnAdminOocEnabledChanged, true);
+
+            _playerManager.PlayerStatusChanged += PlayerStatusChanged;
         }
 
         private void OnOocEnabledChanged(bool val)
@@ -178,6 +184,9 @@ namespace Content.Server.Chat.Managers
         /// <param name="type">The type of message.</param>
         public void TrySendOOCMessage(ICommonSession player, string message, OOCChatType type)
         {
+            if (!HandleRateLimit(player))
+                return;
+
             // Check if message exceeds the character limit
             if (message.Length > MaxMessageLength)
             {

Content.Server/Chat/Managers/IChatManager.cs

@@ -41,5 +41,13 @@ namespace Content.Server.Chat.Managers
 
         [return: NotNullIfNotNull(nameof(author))]
         ChatUser? EnsurePlayer(NetUserId? author);
+
+        /// <summary>
+        /// Called when a player sends a chat message to handle rate limits.
+        /// Will update counts and do necessary actions if breached.
+        /// </summary>
+        /// <param name="player">The player sending a chat message.</param>
+        /// <returns>False if the player has violated rate limits and should be blocked from sending further messages.</returns>
+        bool HandleRateLimit(ICommonSession player);
     }
 }