Support HTTPS compression of returned content

Author: lahma

sample2/WebOptimizer.Core.Sample2/Properties/launchSettings.json

@@ -21,7 +21,7 @@
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       },
-      "applicationUrl": "http://localhost:62609/"
+      "applicationUrl": "http://localhost:62609/;https://localhost:62610/"
     }
   }
 }

sample2/WebOptimizer.Core.Sample2/Startup.cs

@@ -24,7 +24,7 @@ public Startup(IConfiguration configuration, IWebHostEnvironment hostingEnvironm
         public void ConfigureServices(IServiceCollection services)
         {
             services.AddControllersWithViews();
-
+            services.AddResponseCompression();
 
             var cssSettings = new CssBundlingSettings();
             var codeSettings = new CodeBundlingSettings
@@ -47,9 +47,11 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
                 app.UseExceptionHandler("/Home/Error");
             }
 
+            app.UseResponseCompression();
+
             const string scriptsPath1 = "Scripts1";
             const string scriptsPath2 = "Scripts2";
-            
+
             var currentDirectory = Directory.GetCurrentDirectory();
             app.UseWebOptimizer(HostingEnvironment, new[]
             {
@@ -69,7 +71,7 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
                     FileProvider = new EmbeddedFileProvider(Lib.AssemblyTools.GetCurrentAssembly()),
                 }
             });
-            
+
             app.UseStaticFiles();
 
             app.UseRouting();

src/WebOptimizer.Core/AssetMiddleware.cs

@@ -1,5 +1,6 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Microsoft.Net.Http.Headers;
@@ -106,8 +107,19 @@ private async Task WriteOutputAsync(HttpContext context, IAsset asset, IAssetRes
 
             if (cachedResponse?.Body?.Length > 0)
             {
+                SetCompressionMode(context, options);
                 await context.Response.Body.WriteAsync(cachedResponse.Body, 0, cachedResponse.Body.Length);
             }
         }
+
+        // Only called when we expect to serve the body.
+        private static void SetCompressionMode(HttpContext context, IWebOptimizerOptions options)
+        {
+            IHttpsCompressionFeature responseCompressionFeature = context.Features.Get<IHttpsCompressionFeature>();
+            if (responseCompressionFeature != null)
+            {
+                responseCompressionFeature.Mode = options.HttpsCompression;
+            }
+        }
     }
 }

src/WebOptimizer.Core/IWebOptimizerOptions.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace WebOptimizer
 {
@@ -45,5 +46,14 @@ public interface IWebOptimizerOptions
         /// Gets or sets whether empty bundle is allowed to generate instead of throwing an exception
         /// </summary>
         public bool? AllowEmptyBundle { get; set; }
+
+        /// <summary>
+        /// Indicates if files should be compressed for HTTPS requests when the Response Compression middleware is available.
+        /// The default value is <see cref="HttpsCompressionMode.Compress"/>.
+        /// </summary>
+        /// <remarks>
+        /// Enabling compression on HTTPS requests for remotely manipulable content may expose security problems.
+        /// </remarks>
+        HttpsCompressionMode HttpsCompression { get; set; }
     }
 }

src/WebOptimizer.Core/WebOptimizerOptions.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Caching.Memory;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace WebOptimizer
 {
@@ -45,5 +46,14 @@ public class WebOptimizerOptions : IWebOptimizerOptions
         /// Gets or sets whether empty bundle is allowed to generate instead of throwing an exception
         /// </summary>
         public bool? AllowEmptyBundle { get; set; }
+
+        /// <summary>
+        /// Indicates if files should be compressed for HTTPS requests when the Response Compression middleware is available.
+        /// The default value is <see cref="HttpsCompressionMode.Compress"/>.
+        /// </summary>
+        /// <remarks>
+        /// Enabling compression on HTTPS requests for remotely manipulable content may expose security problems.
+        /// </remarks>
+        public HttpsCompressionMode HttpsCompression { get; set; } = HttpsCompressionMode.Compress;
     }
 }

test/WebOptimizer.Core.Test/AssetMiddlewareTest.cs

@@ -1,10 +1,8 @@
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using System.Reflection;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -38,6 +36,7 @@ public async Task AssetMiddleware_NoCache()
                    .Returns(response.Object);
 
             context.Setup(c => c.Request.Path).Returns("/file.css");
+            context.Setup(c => c.Features.Get<IHttpsCompressionFeature>()).Returns((IHttpsCompressionFeature) null);
 
             response.SetupGet(c => c.Headers)
                    .Returns(new HeaderDictionary());
@@ -131,6 +130,7 @@ public async Task AssetMiddleware_Cache()
                    .Returns(response.Object);
 
             context.Setup(c => c.Request.Path).Returns("/file.css");
+            context.Setup(c => c.Features.Get<IHttpsCompressionFeature>()).Returns((IHttpsCompressionFeature) null);
 
             var next = new Mock<RequestDelegate>();
             var env = new HostingEnvironment();
@@ -247,5 +247,66 @@ public async Task AssetMiddleware_NoAssetMatch()
             next.Verify(n => n(context.Object), Times.Once);
 
         }
+
+        [Fact2]
+        public async Task AssetMiddleware_Compression()
+        {
+            var cssContent = "*{color:red}".AsByteArray();
+
+            var pipeline = new AssetPipeline();
+            var options = new WebOptimizerOptions() { HttpsCompression = HttpsCompressionMode.Compress };
+            var asset = new Mock<IAsset>().SetupAllProperties();
+            asset.SetupGet(a => a.ContentType).Returns("text/css");
+            asset.SetupGet(a => a.Route).Returns("/file.css");
+            asset.Setup(a => a.ExecuteAsync(It.IsAny<HttpContext>(), options))
+                 .Returns(Task.FromResult(cssContent));
+
+            StringValues values;
+            var response = new Mock<HttpResponse>().SetupAllProperties();
+            var context = new Mock<HttpContext>().SetupAllProperties();
+            context.Setup(s => s.Request.Headers.TryGetValue("Accept-Encoding", out values))
+                   .Returns(false);
+            context.Setup(c => c.Response)
+                   .Returns(response.Object);
+
+            context.Setup(c => c.Request.Path).Returns("/file.css");
+
+            var compressionFeature = new HttpsCompressionFeature();
+            context.Setup(c => c.Features.Get<IHttpsCompressionFeature>()).Returns(compressionFeature);
+
+            var next = new Mock<RequestDelegate>();
+            var cache = new Mock<IMemoryCache>();
+            var mcr = new AssetResponse(cssContent, null);
+
+            object bytes = mcr;
+            cache.Setup(c => c.TryGetValue(It.IsAny<string>(), out bytes))
+                 .Returns(true);
+
+            pipeline._assets = new ConcurrentDictionary<string, IAsset>();
+            pipeline._assets.TryAdd(asset.Object.Route, asset.Object);
+
+            var amo = new Mock<IOptionsSnapshot<WebOptimizerOptions>>();
+            amo.SetupGet(a => a.Value).Returns(options);
+
+            var logger = new Mock<ILogger<AssetMiddleware>>();
+            var builder = new Mock<IAssetBuilder>();
+            builder.Setup(b => b.BuildAsync(It.IsAny<IAsset>(), context.Object, options)).Returns(Task.FromResult<IAssetResponse>(mcr));
+            var middleware = new AssetMiddleware(next.Object, pipeline, logger.Object, builder.Object);
+            var stream = new MemoryStream();
+
+            response.Setup(r => r.Body).Returns(stream);
+            await middleware.InvokeAsync(context.Object, amo.Object);
+
+            Assert.Equal("text/css", context.Object.Response.ContentType);
+            Assert.Equal(cssContent, await stream.AsBytesAsync());
+            Assert.Equal(0, response.Object.StatusCode);
+
+            Assert.Equal(compressionFeature.Mode, HttpsCompressionMode.Compress);
+        }
+
+        private class HttpsCompressionFeature : IHttpsCompressionFeature
+        {
+            public HttpsCompressionMode Mode { get; set; }
+        }
     }
 }