Make H2 WebSockets ignore MaxRequestBodySize and MinRequestBodyDataRate #42101 (#42269)

Author: Tratcher

src/Middleware/WebSockets/samples/EchoApp/EchoApp.csproj

@@ -6,6 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <Reference Include="Microsoft.AspNetCore" />
     <Reference Include="Microsoft.AspNetCore.Diagnostics" />
     <Reference Include="Microsoft.AspNetCore.Server.IISIntegration" />
     <Reference Include="Microsoft.AspNetCore.Server.Kestrel" />
@@ -14,4 +15,10 @@
     <Reference Include="Microsoft.Extensions.Logging.Console" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Content Update="appsettings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
 </Project>

src/Middleware/WebSockets/samples/EchoApp/Program.cs

@@ -1,23 +1,89 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Net.WebSockets;
+using System.Text;
+using Microsoft.AspNetCore.Http.Features;
+
 namespace EchoApp;
 
 public class Program
 {
     public static Task Main(string[] args)
     {
-        var host = new HostBuilder()
-            .ConfigureWebHost(webHostBuilder =>
+        var builder = WebApplication.CreateBuilder();
+        var app = builder.Build();
+
+        app.UseDeveloperExceptionPage();
+        app.UseWebSockets();
+
+        app.Use(async (context, next) =>
+        {
+            if (context.WebSockets.IsWebSocketRequest)
+            {
+                var webSocket = await context.WebSockets.AcceptWebSocketAsync(new WebSocketAcceptContext() { DangerousEnableCompression = true });
+                await Echo(context, webSocket, app.Logger);
+                return;
+            }
+
+            await next(context);
+        });
+
+        app.UseFileServer();
+
+        return app.RunAsync();
+    }
+
+    private static async Task Echo(HttpContext context, WebSocket webSocket, ILogger logger)
+    {
+        var buffer = new byte[1024 * 4];
+        var result = await webSocket.ReceiveAsync(buffer.AsMemory(), CancellationToken.None);
+        LogFrame(logger, webSocket, result, buffer);
+        while (result.MessageType != WebSocketMessageType.Close)
+        {
+            // If the client send "ServerClose", then they want a server-originated close to occur
+            string content = "<<binary>>";
+            if (result.MessageType == WebSocketMessageType.Text)
+            {
+                content = Encoding.UTF8.GetString(buffer, 0, result.Count);
+                if (content.Equals("ServerClose"))
+                {
+                    await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing from Server", CancellationToken.None);
+                    logger.LogDebug($"Sent Frame Close: {WebSocketCloseStatus.NormalClosure} Closing from Server");
+                    return;
+                }
+                else if (content.Equals("ServerAbort"))
+                {
+                    context.Abort();
+                }
+            }
+
+            await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);
+            logger.LogDebug($"Sent Frame {result.MessageType}: Len={result.Count}, Fin={result.EndOfMessage}: {content}");
+
+            result = await webSocket.ReceiveAsync(buffer.AsMemory(), CancellationToken.None);
+            LogFrame(logger, webSocket, result, buffer);
+        }
+        await webSocket.CloseAsync(webSocket.CloseStatus.Value, webSocket.CloseStatusDescription, CancellationToken.None);
+    }
+
+    private static void LogFrame(ILogger logger, WebSocket webSocket, ValueWebSocketReceiveResult frame, byte[] buffer)
+    {
+        var close = frame.MessageType == WebSocketMessageType.Close;
+        string message;
+        if (close)
+        {
+            message = $"Close: {webSocket.CloseStatus.Value} {webSocket.CloseStatusDescription}";
+        }
+        else
+        {
+            string content = "<<binary>>";
+            if (frame.MessageType == WebSocketMessageType.Text)
             {
-                webHostBuilder
-                .UseKestrel()
-                .UseContentRoot(Directory.GetCurrentDirectory())
-                .UseIISIntegration()
-                .UseStartup<Startup>();
-            })
-            .Build();
-
-        return host.RunAsync();
+                content = Encoding.UTF8.GetString(buffer, 0, frame.Count);
+            }
+            message = $"{frame.MessageType}: Len={frame.Count}, Fin={frame.EndOfMessage}: {content}";
+        }
+        logger.LogDebug("Received Frame " + message);
     }
 }

src/Middleware/WebSockets/samples/EchoApp/Startup.cs

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug",
+      "Microsoft.AspNetCore": "Trace"
+    }
+  }
+}

src/Middleware/WebSockets/samples/EchoApp/appsettings.json

@@ -149,7 +149,7 @@ CancellationToken IHttpRequestLifetimeFeature.RequestAborted
 
     bool IHttpUpgradeFeature.IsUpgradableRequest => IsUpgradableRequest;
 
-    bool IHttpExtendedConnectFeature.IsExtendedConnect => IsConnectRequest;
+    bool IHttpExtendedConnectFeature.IsExtendedConnect => IsExtendedConnectRequest;
 
     string? IHttpExtendedConnectFeature.Protocol => ConnectProtocol;
 
@@ -195,7 +195,7 @@ bool IHttpBodyControlFeature.AllowSynchronousIO
         set => AllowSynchronousIO = value;
     }
 
-    bool IHttpMaxRequestBodySizeFeature.IsReadOnly => HasStartedConsumingRequestBody || IsUpgraded;
+    bool IHttpMaxRequestBodySizeFeature.IsReadOnly => HasStartedConsumingRequestBody || IsUpgraded || IsExtendedConnectRequest;
 
     long? IHttpMaxRequestBodySizeFeature.MaxRequestBodySize
     {
@@ -290,12 +290,12 @@ async Task<Stream> IHttpUpgradeFeature.UpgradeAsync()
 
     async ValueTask<Stream> IHttpExtendedConnectFeature.AcceptAsync()
     {
-        if (!IsConnectRequest)
+        if (!IsExtendedConnectRequest)
         {
             throw new InvalidOperationException(CoreStrings.CannotAcceptNonConnectRequest);
         }
 
-        if (IsUpgraded)
+        if (IsExtendedConnectAccepted)
         {
             throw new InvalidOperationException(CoreStrings.AcceptCannotBeCalledMultipleTimes);
         }
@@ -305,7 +305,7 @@ async ValueTask<Stream> IHttpExtendedConnectFeature.AcceptAsync()
             throw new InvalidOperationException(CoreStrings.ConnectStatusMustBe200);
         }
 
-        IsUpgraded = true;
+        IsExtendedConnectAccepted = true;
 
         await FlushAsync();
 

src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.FeatureCollection.cs

@@ -127,7 +127,8 @@ public string TraceIdentifier
 
     public bool IsUpgradableRequest { get; private set; }
     public bool IsUpgraded { get; set; }
-    public bool IsConnectRequest { get; set; }
+    public bool IsExtendedConnectRequest { get; set; }
+    public bool IsExtendedConnectAccepted { get; set; }
     public IPAddress? RemoteIpAddress { get; set; }
     public int RemotePort { get; set; }
     public IPAddress? LocalIpAddress { get; set; }
@@ -359,6 +360,8 @@ public void Reset()
         _statusCode = StatusCodes.Status200OK;
         _reasonPhrase = null;
         IsUpgraded = false;
+        IsExtendedConnectRequest = false;
+        IsExtendedConnectAccepted = false;
 
         var remoteEndPoint = RemoteEndPoint;
         RemoteIpAddress = remoteEndPoint?.Address;

src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs

@@ -37,6 +37,8 @@ protected MessageBody(HttpProtocol context)
 
     public bool RequestUpgrade { get; protected set; }
 
+    public bool ExtendedConnect { get; protected set; }
+
     public virtual bool IsEmpty => false;
 
     protected KestrelTrace Log => _context.ServiceContext.Log;
@@ -122,7 +124,7 @@ protected Task TryStartAsync()
         OnReadStarting();
         _context.HasStartedConsumingRequestBody = true;
 
-        if (!RequestUpgrade)
+        if (!RequestUpgrade && !ExtendedConnect)
         {
             // Accessing TraceIdentifier will lazy-allocate a string ID.
             // Don't access TraceIdentifer unless logging is enabled.
@@ -150,7 +152,7 @@ protected void TryStop()
 
         _stopped = true;
 
-        if (!RequestUpgrade)
+        if (!RequestUpgrade && !ExtendedConnect)
         {
             // Accessing TraceIdentifier will lazy-allocate a string ID
             // Don't access TraceIdentifer unless logging is enabled.

src/Servers/Kestrel/Core/src/Internal/Http/MessageBody.cs

@@ -19,6 +19,7 @@ public Http2MessageBody(Http2Stream context)
         : base(context)
     {
         _context = context;
+        ExtendedConnect = _context.IsExtendedConnectRequest;
     }
 
     protected override void OnReadStarting()
@@ -51,6 +52,7 @@ public override void Reset()
     {
         base.Reset();
         _readResult = default;
+        ExtendedConnect = _context.IsExtendedConnectRequest;
     }
 
     public override void AdvanceTo(SequencePosition consumed, SequencePosition examined)
@@ -62,7 +64,12 @@ public override void AdvanceTo(SequencePosition consumed, SequencePosition exami
 
         // The HTTP/2 flow control window cannot be larger than 2^31-1 which limits bytesRead.
         _context.OnDataRead((int)newlyExaminedBytes);
-        AddAndCheckObservedBytes(newlyExaminedBytes);
+
+        // Don't limit extended CONNECT requests to the MaxRequestBodySize.
+        if (!ExtendedConnect)
+        {
+            AddAndCheckObservedBytes(newlyExaminedBytes);
+        }
     }
 
     public override bool TryRead(out ReadResult readResult)

src/Servers/Kestrel/Core/src/Internal/Http2/Http2MessageBody.cs

@@ -239,7 +239,7 @@ private bool TryValidatePseudoHeaders()
                     return false;
                 }
                 ConnectProtocol = HttpRequestHeaders.HeaderProtocol;
-                IsConnectRequest = true;
+                IsExtendedConnectRequest = true;
             }
             // CONNECT - :scheme and :path must be excluded
             else if (!StringValues.IsNullOrEmpty(HttpRequestHeaders.HeaderScheme) || !StringValues.IsNullOrEmpty(HttpRequestHeaders.HeaderPath))