Ignore everything but path and query in requests for absolute URIs (#666).

Author: Cesar Blum Silveira

src/Microsoft.AspNetCore.Server.Kestrel/Http/Frame.cs

@@ -804,8 +804,21 @@ protected bool TakeStartLine(SocketInput input)
                 QueryString = queryString;
                 HttpVersion = httpVersion;
 
-                bool caseMatches;
+                if (requestUrlPath.Length > 0 && requestUrlPath[0] != '/')
+                {
+                    Uri uri;
+                    if (Uri.TryCreate(requestUrlPath, UriKind.Absolute, out uri))
+                    {
+                        requestUrlPath = uri.PathAndQuery;
+                    }
+                    else
+                    {
+                        ReportCorruptedHttpRequest(new BadHttpRequestException($"Invalid request path: {requestUrlPath}"));
+                        return true;
+                    }
+                }
 
+                bool caseMatches;
                 if (!string.IsNullOrEmpty(_pathBase) &&
                     (requestUrlPath.Length == _pathBase.Length || (requestUrlPath.Length > _pathBase.Length && requestUrlPath[_pathBase.Length] == '/')) &&
                     RequestUrlStartsWithPathBase(requestUrlPath, out caseMatches))

src/Microsoft.AspNetCore.Server.Kestrel/Http/FrameOfT.cs

@@ -54,6 +54,12 @@ public override async Task RequestProcessingAsync()
 
                     InitializeHeaders();
 
+                    if (_corruptedRequest)
+                    {
+                        await ProduceEnd();
+                        return;
+                    }
+
                     while (!_requestProcessingStopping && !TakeMessageHeaders(SocketInput, FrameRequestHeaders))
                     {
                         if (SocketInput.RemoteIntakeFin)

test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/RequestTests.cs

@@ -145,7 +145,6 @@ public async Task DoesNotHangOnConnectionCloseRequest()
                 {
                     app.Run(async context =>
                     {
-                        var connection = context.Connection;
                         await context.Response.WriteAsync("hello, world");
                     });
                 });
@@ -174,7 +173,6 @@ public void RequestPathIsNormalized()
                 {
                     app.Run(async context =>
                     {
-                        var connection = context.Connection;
                         Assert.Equal("/\u00C5", context.Request.PathBase.Value);
                         Assert.Equal("/B/\u00C5", context.Request.Path.Value);
                         await context.Response.WriteAsync("hello, world");
@@ -208,6 +206,92 @@ public void RequestPathIsNormalized()
             }
         }
 
+        [Fact]
+        public void RequestWithFullUriHasSchemeHostAndPortIgnored()
+        {
+            var port = PortManager.GetPort();
+            var builder = new WebHostBuilder()
+                .UseServer("Microsoft.AspNetCore.Server.Kestrel")
+                .UseUrls($"http://localhost:{port}")
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        Assert.Equal("/test", context.Request.Path.Value);
+                        Assert.Equal("?arg=value", context.Request.QueryString.Value);
+                        await context.Response.WriteAsync("hello, world");
+                    });
+                });
+
+            using (var host = builder.Build())
+            {
+                host.Start();
+
+                using (var socket = TestConnection.CreateConnectedLoopbackSocket(port))
+                {
+                    socket.Send(Encoding.ASCII.GetBytes($"GET http://doesnotmatter:8080/test?arg=value HTTP/1.1\r\n\r\n"));
+                    socket.Shutdown(SocketShutdown.Send);
+
+                    var response = new StringBuilder();
+                    var buffer = new byte[4096];
+                    while (true)
+                    {
+                        var length = socket.Receive(buffer);
+                        if (length == 0)
+                        {
+                            break;
+                        }
+
+                        response.Append(Encoding.ASCII.GetString(buffer, 0, length));
+                    }
+
+                    Assert.StartsWith("HTTP/1.1 200 OK", response.ToString());
+                }
+            }
+        }
+
+        [Fact]
+        public void RequestWithInvalidPathReturns400()
+        {
+            var port = PortManager.GetPort();
+            var builder = new WebHostBuilder()
+                .UseServer("Microsoft.AspNetCore.Server.Kestrel")
+                .UseUrls($"http://localhost:{port}")
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        await context.Response.WriteAsync("hello, world");
+                    });
+                });
+
+            using (var host = builder.Build())
+            {
+                host.Start();
+
+                using (var socket = TestConnection.CreateConnectedLoopbackSocket(port))
+                {
+                    socket.Send(Encoding.ASCII.GetBytes($"GET invalid HTTP/1.1\r\n\r\n"));
+                    socket.Shutdown(SocketShutdown.Send);
+
+                    var response = new StringBuilder();
+                    var buffer = new byte[4096];
+                    while (true)
+                    {
+                        var length = socket.Receive(buffer);
+                        if (length == 0)
+                        {
+                            break;
+                        }
+
+                        response.Append(Encoding.ASCII.GetString(buffer, 0, length));
+                    }
+
+                    Assert.StartsWith("HTTP/1.1 400 Bad Request", response.ToString());
+                }
+            }
+        }
+
         private async Task TestRemoteIPAddress(string registerAddress, string requestAddress, string expectAddress)
         {
             var port = PortManager.GetPort();