Add option to always hash channel names (#28)

* Always hash channel names as precaution against sql injection

* Use channel name length as min length

* Try more robust hashing

* Add sha256 channel name normalization plus raw prefix

* Add channel normalization options

* Update readmes to add channel name normalization option

* Add timeout to test step

* Update lifetime manager class order

Author: IanWold

.github/workflows/build.yml

@@ -1,14 +1,14 @@
-name: Build
-
-on:
-  pull_request:
-    branches: [ "main" ]
-
-permissions:
-  contents: read
-
-jobs:
-  build:
+name: Build
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
     runs-on: ubuntu-latest
     name: Build
     steps:
@@ -23,3 +23,4 @@ jobs:
       run: dotnet build --no-restore
     - name: Test
       run: dotnet test PostgreSignalR.slnx --no-build --verbosity normal -m:1
+      timeout-minutes: 10

README.md

@@ -43,6 +43,7 @@ var dataSource = new NpgsqlDataSourceBuilder("<your_postgres_connection_string>"
 builder.Services.AddSignalR().AddPostgresBackplane(dataSource, options =>
 {
     options.Prefix = "myapp";
+    options.ChannelNameNormaization = ChannelNameNormaization.Truncate;
     options.OnInitialized += () => { /* Do something */ }
 });
 ```

README_NUGET.md

@@ -22,13 +22,15 @@ That is all you need to get up and going! PostgreSignalR aims to be very extensi
 
 ### Backplane Configuration
 
-You can configure options for the backplane. Options are [documented in the wiki](https://github.com/IanWold/PostgreSignalR/wiki/Options).
+You can configure options for the backplane. All of the options are presented blow and [documented in detail in the wiki](https://github.com/IanWold/PostgreSignalR/wiki/Options):
 
 ```csharp
 var dataSource = new NpgsqlDataSourceBuilder("<your_postgres_connection_string>").Build();
 builder.Services.AddSignalR().AddPostgresBackplane(dataSource, options =>
 {
     options.Prefix = "myapp";
+    options.ChannelNameNormaization = ChannelNameNormaization.Truncate;
+    options.OnInitialized += () => { /* Do something */ }
 });
 ```
 
@@ -42,14 +44,19 @@ builder.Services.AddSignalR()
     .AddBackplaneTablePayloadStrategy();
 ```
 
-The payload table strategy comes with its own configuration options as well:
+The payload table strategy comes with its own configuration options as well. All of the options are presented below and [documented in detail in the wiki](https://github.com/IanWold/PostgreSignalR/wiki/Options):
 
 ```csharp
 builder.Services.AddSignalR()
     .AddPostgresBackplane(dataSource)
     .AddBackplaneTablePayloadStrategy(options =>
     {
-        options.StorageMode = PostgresBackplanePayloadTableStorage.Always;
+        options.StorageMode = PostgresBackplanePayloadTableStorage.Auto;
+        options.SchemaName = "backplane";
+        options.TableName = "payloads";
+        options.AutomaticCleanup = true;
+        options.AutomaticCleanupTtlMs = 1000;
+        options.AutomaticCleanupIntervalMs = 3600000;
     });
 ```
 

src/ChannelNameProvider.cs

@@ -0,0 +1,114 @@
+using System.Buffers.Text;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace PostgreSignalR;
+
+internal abstract class ChannelNameProvider
+{
+    public ChannelNameProvider(string returnServerName)
+    {
+        All = Normalize("all");
+        GroupManagement = Normalize("internal_groups");
+        ReturnResults = Normalize($"internal_return_{returnServerName}");
+    }
+
+    /// <summary>
+    /// Postgres limits channel names to identifiers up to 63 characters.
+    /// Normalization should ensure any channel names meet this.
+    /// </summary>
+    /// <param name="name">The raw name of the channel</param>
+    /// <returns>The normalized channel name</returns>
+    internal abstract string Normalize(string name);
+
+    /// <summary>
+    /// Gets the name of the channel for sending to all connections.
+    /// </summary>
+    /// <remarks>
+    /// The payload on this channel is <see cref="PostgresInvocation"/> objects containing
+    /// invocations to be sent to all connections
+    /// </remarks>
+    public string All { get; init; } 
+
+    /// <summary>
+    /// Gets the name of the internal channel for group management messages.
+    /// </summary>
+    public string GroupManagement { get; }
+
+    /// <summary>
+    /// Gets the name of the internal channel for receiving client results.
+    /// </summary>
+    public string ReturnResults { get; }
+
+    /// <summary>
+    /// Gets the name of the channel for sending a message to a specific connection.
+    /// </summary>
+    /// <param name="connectionId">The ID of the connection to get the channel for.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string Connection(string connectionId) => Normalize($"connection_{connectionId}");
+
+    /// <summary>
+    /// Gets the name of the channel for sending a message to a named group of connections.
+    /// </summary>
+    /// <param name="groupName">The name of the group to get the channel for.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string Group(string groupName) => Normalize($"group_{groupName}");
+
+    /// <summary>
+    /// Gets the name of the channel for sending a message to all collections associated with a user.
+    /// </summary>
+    /// <param name="userId">The ID of the user to get the channel for.</param>32
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string User(string userId) => Normalize($"user_{userId}");
+
+    /// <summary>
+    /// Gets the name of the acknowledgement channel for the specified server.
+    /// </summary>
+    /// <param name="serverName">The name of the server to get the acknowledgement channel for.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string Ack(string serverName) => Normalize($"internal_ack_{serverName}");
+}
+
+internal sealed class TruncatingChannelNameProvider(string prefix, string returnServerName) : ChannelNameProvider(returnServerName)
+{
+    internal override string Normalize(string name)
+    {
+        name = prefix + name;
+
+        if (name.Length <= 63)
+        {
+            return name;
+        }
+
+        var hash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(name))).ToLowerInvariant();
+        var suffix = $"_{hash[..8]}";
+        var trimLength = Math.Max(63 - suffix.Length, 0);
+
+        return $"{name[..trimLength]}{suffix}";
+    }
+}
+
+internal sealed class HashingChannelNameProvider(string prefix, string returnServerName) : ChannelNameProvider(returnServerName)
+{
+    internal override string Normalize(string name)
+    {
+        Span<byte> utf8 = stackalloc byte[1024];
+        var utf8Length = Encoding.UTF8.GetBytes(name.AsSpan(), utf8);
+
+        Span<byte> hash = stackalloc byte[32];
+        SHA256.HashData(utf8[..utf8Length], hash);
+
+        Span<byte> base64 = stackalloc byte[44];
+        Base64.EncodeToUtf8(hash, base64, out _, out var written);
+
+        return prefix + string.Create(written-1, base64.ToArray(), static (destination, source) =>
+        {
+            for (int i = 0; i < destination.Length; i++)
+            {
+                var c = source[i];
+                destination[i] = c == (byte)'+' || c == (byte)'/' ? '_' : (char)c;
+            }
+        });
+    }
+}

src/LogExtensions.cs

@@ -122,4 +122,11 @@ internal static partial class LogExtensions
         Message = "Postgres backplane encountered error while handling OnInitialized event. Ignoring."
     )]
     public static partial void BackplaneErrorDuringOnInitialized(this ILogger logger, Exception ex);
+
+    [LoggerMessage(
+        EventId = 160,
+        Level = LogLevel.Error,
+        Message = "Postgres backplane configuration is invalid: {Message}"
+    )]
+    public static partial void BackplaneConfigurationInvalid(this ILogger logger, string message);
 }

src/PostgresBackplaneOptions.cs

@@ -2,6 +2,24 @@
 
 namespace PostgreSignalR;
 
+/// <summary>
+/// Postgres limits channel names to identifiers up to 63 characters.
+/// To guarantee this constraint is met, the backplane normalizes channel names.
+/// </summary>
+public enum ChannelNameNormaization
+{
+    /// <summary>
+    /// Only applies normalization to channel names greater than 63 characters.
+    /// For large names, the last 8 characters will be a hash of the channel name
+    /// </summary>
+    Truncate,
+
+    /// <summary>
+    /// Always hashes the channel name. The prefix is not modified.
+    /// </summary>
+    HashAlways
+}
+
 /// <summary>
 /// Handler for <see cref="PostgresBackplaneOptions.OnInitialized"/>
 /// </summary>
@@ -21,6 +39,17 @@ public class PostgresBackplaneOptions
     /// </remarks>
     public string Prefix { get; set; } = "postgresignalr";
 
+    /// <summary>
+    /// Configures how the backplane normalizes channel names.
+    /// Possible values:
+    /// <list type="bullet">
+    ///     <item><see cref="ChannelNameNormaization.Truncate"/>: Truncates long channel names with a short hash. Better for performance.</item>
+    ///     <item><see cref="ChannelNameNormaization.HashAlways"/>: Always hashes channel names. Better for safety.</item>
+    /// </list>
+    /// Default: <see cref="ChannelNameNormaization.Truncate"/>
+    /// </summary>
+    public ChannelNameNormaization ChannelNameNormaization { get; set; } = ChannelNameNormaization.Truncate;
+
     /// <summary>
     /// Configures the <see href="https://www.npgsql.org/doc/api/Npgsql.NpgsqlDataSource.html">NpgsqlDataSource</see> to connect to the Postgres database.
     /// </summary>
@@ -41,4 +70,16 @@ public class PostgresBackplaneOptions
 
     internal void InvokeOnInitialized() =>
         OnInitialized?.Invoke();
+
+    internal bool IsValid(out string? message)
+    {
+        message = null;
+
+        if (Prefix.Length >= 20)
+        {
+            message = "Prefix must be less than 20 characters.";
+        }
+
+        return message is null;
+    }
 }