[Client encryption]: Adds support for Brotli compression

Microsoft.Azure.Cosmos.Encryption.Custom/src/CompressionOptions.cs

@@ -0,0 +1,48 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// ------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos.Encryption.Custom
+{
+    using System.IO.Compression;
+
+    /// <summary>
+    /// Options for payload compression
+    /// </summary>
+    public class CompressionOptions
+    {
+        /// <summary>
+        /// Supported compression algorithms
+        /// </summary>
+        /// <remarks>Compression is only supported with .NET8.0+.</remarks>
+        public enum CompressionAlgorithm
+        {
+            /// <summary>
+            /// No compression
+            /// </summary>
+            None = 0,
+#if NET8_0_OR_GREATER
+
+            /// <summary>
+            /// Brotli compression
+            /// </summary>
+            Brotli = 1,
+#endif
+        }
+
+        /// <summary>
+        /// Gets or sets compression algorithm.
+        /// </summary>
+        public CompressionAlgorithm Algorithm { get; set; } = CompressionAlgorithm.None;
+
+        /// <summary>
+        /// Gets or sets compression level.
+        /// </summary>
+        public CompressionLevel CompressionLevel { get; set; } = CompressionLevel.Fastest;
+
+        /// <summary>
+        /// Gets or sets minimal property size for compression.
+        /// </summary>
+        public int MinimalCompressedLength { get; set; } = 128;
+    }
+}

Microsoft.Azure.Cosmos.Encryption.Custom/src/Constants.cs

@@ -13,6 +13,8 @@ internal static class Constants
         public const string EncryptionDekId = "_en";
         public const string EncryptionFormatVersion = "_ef";
         public const string EncryptedPaths = "_ep";
+        public const string CompressionAlgorithm = "_ce";
+        public const string CompressedEncryptedPaths = "_cp";
         public const int DekPropertiesDefaultTTLInMinutes = 120;
     }
 }

Microsoft.Azure.Cosmos.Encryption.Custom/src/CosmosEncryptionAlgorithm.cs

@@ -21,7 +21,7 @@ public static class CosmosEncryptionAlgorithm
         /// MDE(Microsoft.Data.Encryption) Randomized AEAD_AES_256_CBC_HMAC_SHA256 Algorithm.
         /// As described <see href="http://tools.ietf.org/html/draft-mcgrew-aead-aes-cbc-hmac-sha2-05">here</see>.
         /// </summary>
-        public const string MdeAeadAes256CbcHmac256Randomized = "MdeAeadAes256CbcHmac256Randomized";
+        public const string MdeAeadAes256CbcHmac256Randomized = @"MdeAeadAes256CbcHmac256Randomized";
 
         /// <summary>
         /// Verify if the Encryption Algorithm is supported by Cosmos.

Microsoft.Azure.Cosmos.Encryption.Custom/src/EncryptionOptions.cs

@@ -29,6 +29,11 @@ public sealed class EncryptionOptions
         /// </remarks>
         public string EncryptionAlgorithm { get; set; }
 
+        /// <summary>
+        /// Gets or sets payload compression mode
+        /// </summary>
+        public CompressionOptions CompressionOptions { get; set; } = new CompressionOptions();
+
         /// <summary>
         /// Gets or sets list of JSON paths to encrypt on the payload.
         /// Only top level paths are supported.

Microsoft.Azure.Cosmos.Encryption.Custom/src/EncryptionOptionsExtensions.cs

@@ -0,0 +1,47 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// ------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos.Encryption.Custom
+{
+    using System;
+
+    internal static class EncryptionOptionsExtensions
+    {
+        internal static void Validate(this EncryptionOptions options)
+        {
+            if (string.IsNullOrWhiteSpace(options.DataEncryptionKeyId))
+            {
+#pragma warning disable CA2208 // Instantiate argument exceptions correctly
+                throw new ArgumentNullException(nameof(options.DataEncryptionKeyId));
+#pragma warning restore CA2208 // Instantiate argument exceptions correctly
+            }
+
+            if (string.IsNullOrWhiteSpace(options.EncryptionAlgorithm))
+            {
+#pragma warning disable CA2208 // Instantiate argument exceptions correctly
+                throw new ArgumentNullException(nameof(options.EncryptionAlgorithm));
+#pragma warning restore CA2208 // Instantiate argument exceptions correctly
+            }
+
+            if (options.PathsToEncrypt == null)
+            {
+#pragma warning disable CA2208 // Instantiate argument exceptions correctly
+                throw new ArgumentNullException(nameof(options.PathsToEncrypt));
+#pragma warning restore CA2208 // Instantiate argument exceptions correctly
+            }
+
+            options.CompressionOptions?.Validate();
+        }
+
+        internal static void Validate(this CompressionOptions options)
+        {
+            if (options.MinimalCompressedLength < 0)
+            {
+#pragma warning disable CA2208 // Instantiate argument exceptions correctly
+                throw new ArgumentOutOfRangeException(nameof(options.MinimalCompressedLength));
+#pragma warning restore CA2208 // Instantiate argument exceptions correctly
+            }
+        }
+    }
+}

Microsoft.Azure.Cosmos.Encryption.Custom/src/EncryptionProcessor.cs

@@ -206,22 +206,7 @@ private static void ValidateInputForEncrypt(
             }
 #endif
 
-#pragma warning disable CA2208 // Instantiate argument exceptions correctly
-            if (string.IsNullOrWhiteSpace(encryptionOptions.DataEncryptionKeyId))
-            {
-                throw new ArgumentNullException(nameof(encryptionOptions.DataEncryptionKeyId));
-            }
-
-            if (string.IsNullOrWhiteSpace(encryptionOptions.EncryptionAlgorithm))
-            {
-                throw new ArgumentNullException(nameof(encryptionOptions.EncryptionAlgorithm));
-            }
-
-            if (encryptionOptions.PathsToEncrypt == null)
-            {
-                throw new ArgumentNullException(nameof(encryptionOptions.PathsToEncrypt));
-            }
-#pragma warning restore CA2208 // Instantiate argument exceptions correctly
+            encryptionOptions.Validate();
         }
 
         private static JObject RetrieveItem(

Microsoft.Azure.Cosmos.Encryption.Custom/src/EncryptionProperties.cs

@@ -24,18 +24,28 @@ internal class EncryptionProperties
         [JsonProperty(PropertyName = Constants.EncryptedPaths)]
         public IEnumerable<string> EncryptedPaths { get; }
 
+        [JsonProperty(PropertyName = Constants.CompressionAlgorithm)]
+        public CompressionOptions.CompressionAlgorithm CompressionAlgorithm { get; }
+
+        [JsonProperty(PropertyName = Constants.CompressedEncryptedPaths)]
+        public IDictionary<string, int> CompressedEncryptedPaths { get; }
+
         public EncryptionProperties(
             int encryptionFormatVersion,
             string encryptionAlgorithm,
             string dataEncryptionKeyId,
             byte[] encryptedData,
-            IEnumerable<string> encryptedPaths)
+            IEnumerable<string> encryptedPaths,
+            CompressionOptions.CompressionAlgorithm compressionAlgorithm = CompressionOptions.CompressionAlgorithm.None,
+            IDictionary<string, int> compressedEncryptedPaths = null)
         {
             this.EncryptionFormatVersion = encryptionFormatVersion;
             this.EncryptionAlgorithm = encryptionAlgorithm;
             this.DataEncryptionKeyId = dataEncryptionKeyId;
             this.EncryptedData = encryptedData;
             this.EncryptedPaths = encryptedPaths;
+            this.CompressionAlgorithm = compressionAlgorithm;
+            this.CompressedEncryptedPaths = compressedEncryptedPaths;
         }
     }
 }

Microsoft.Azure.Cosmos.Encryption.Custom/src/Transformation/BrotliCompressor.cs

@@ -0,0 +1,110 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// ------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos.Encryption.Custom.Transformation
+{
+#if NET8_0_OR_GREATER
+
+    using System;
+    using System.Buffers;
+    using System.Collections.Generic;
+    using System.IO.Compression;
+
+    internal class BrotliCompressor : IDisposable
+    {
+        private const int DefaultWindow = 22;
+
+        internal static int GetQualityFromCompressionLevel(CompressionLevel compressionLevel)
+        {
+            return compressionLevel switch
+            {
+                CompressionLevel.NoCompression => 0,
+                CompressionLevel.Fastest => 1,
+                CompressionLevel.Optimal => 4,
+                CompressionLevel.SmallestSize => 11,
+                _ => throw new ArgumentException("Unsupported compression level", nameof(compressionLevel))
+            };
+        }
+
+        internal static int GetMaxCompressedSize(int inputSize)
+        {
+            return BrotliEncoder.GetMaxCompressedLength(inputSize);
+        }
+
+        private readonly BrotliDecoder decoder;
+        private readonly BrotliEncoder encoder;
+        private bool disposedValue;
+
+        public BrotliCompressor()
+        {
+        }
+
+        public BrotliCompressor(CompressionLevel compressionLevel)
+        {
+            this.encoder = new BrotliEncoder(BrotliCompressor.GetQualityFromCompressionLevel(compressionLevel), DefaultWindow);
+        }
+
+        public virtual int Compress(Dictionary<string, int> compressedPaths, string path, byte[] bytes, int length, byte[] outputBytes)
+        {
+            OperationStatus status = this.encoder.Compress(bytes.AsSpan(0, length), outputBytes, out int bytesConsumed, out int bytesWritten, true);
+
+            ThrowIfFailure(status, length, bytesConsumed);
+
+            compressedPaths[path] = length;
+
+            return bytesWritten;
+        }
+
+        public virtual int Decompress(byte[] inputBytes, int length, byte[] outputBytes)
+        {
+            OperationStatus status = this.decoder.Decompress(inputBytes.AsSpan(0, length), outputBytes, out int bytesConsumed, out int bytesWritten);
+
+            ThrowIfFailure(status, length, bytesConsumed);
+
+            return bytesWritten;
+        }
+
+        private static void ThrowIfFailure(OperationStatus status, int expectedLength, int processedLength)
+        {
+            if (status != OperationStatus.Done)
+            {
+                throw new InvalidOperationException($"Brotli compressor failed : {status}");
+            }
+
+            if (expectedLength != processedLength)
+            {
+                throw new InvalidOperationException($"Expected to process {expectedLength} but only processed {processedLength}");
+            }
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!this.disposedValue)
+            {
+                if (disposing)
+                {
+                }
+
+                // TODO: free unmanaged resources (unmanaged objects) and override finalizer
+                this.encoder.Dispose();
+
+                this.disposedValue = true;
+            }
+        }
+
+        ~BrotliCompressor()
+        {
+            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+            this.Dispose(disposing: false);
+        }
+
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+            this.Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+    }
+#endif
+}