fix async/dispose problem in Secrets.DecryptFileTo* functions

Author: stefanmaierhofer

RELEASE_NOTES.md

@@ -1,3 +1,6 @@
+### 0.2.1
+- fix async/dispose problem in Secrets.DecryptFileTo* functions
+
 ### 0.2.0
 - refactoring: all encrypt/decrypt combinations with systematic naming scheme
   - `Secrets.Encrypt[Stream|Buffer|String|File]To[Stream|Buffer|File]Async`

data/image.jpg

@@ -20,7 +20,7 @@ private static TestFile SRC_FILE
             }
         }
 
-        private static byte[] ENCRYPTED_BUFFER = Secrets.EncryptStringToBufferAsync(SRC_STRING, PWD).Result;
+        private static readonly byte[] ENCRYPTED_BUFFER = Secrets.EncryptStringToBufferAsync(SRC_STRING, PWD).Result;
         private static Stream ENCRYPTED_STREAM => new MemoryStream(ENCRYPTED_BUFFER);
         private static TestFile ENCRYPTED_FILE
         {
@@ -32,35 +32,35 @@ private static TestFile ENCRYPTED_FILE
             }
         }
 
-        private async Task CheckEncryptedAsync(MemoryStream encrypted)
+        private static async Task CheckEncryptedAsync(MemoryStream encrypted)
         {
             var decrypted = await Secrets.DecryptBufferToStringAsync(encrypted.ToArray(), PWD);
             Assert.True(decrypted == SRC_STRING);
         }
-        private async Task CheckEncryptedAsync(byte[] encrypted)
+        private static async Task CheckEncryptedAsync(byte[] encrypted)
         {
             var decrypted = await Secrets.DecryptBufferToStringAsync(encrypted, PWD);
             Assert.True(decrypted == SRC_STRING);
         }
-        private async Task CheckEncryptedAsync(TestFile encrypted)
+        private static async Task CheckEncryptedAsync(TestFile encrypted)
         {
             var decrypted = await Secrets.DecryptFileToStringAsync(encrypted.Path, PWD);
             Assert.True(decrypted == SRC_STRING);
         }
 
-        private void CheckDecrypted(string decrypted)
+        private static void CheckDecrypted(string decrypted)
         {
             Assert.True(decrypted == SRC_STRING);
         }
-        private void CheckDecryptedAsync(MemoryStream decrypted)
+        private static void CheckDecryptedAsync(MemoryStream decrypted)
         {
             CheckDecrypted(decrypted.ToArray());
         }
-        private void CheckDecrypted(byte[] decrypted)
+        private static void CheckDecrypted(byte[] decrypted)
         {
             CheckDecrypted(Encoding.UTF8.GetString(decrypted));
         }
-        private void CheckDecrypted(TestFile decrypted)
+        private static void CheckDecrypted(TestFile decrypted)
         {
             var s = File.ReadAllText(decrypted.Path);
             Assert.True(s == SRC_STRING);
@@ -328,5 +328,34 @@ public async Task Roundtrip_UrlEncodedBase64()
 
             Assert.True(plaintext0 == plaintext1);
         }
+
+
+
+        [Fact]
+        public async Task RoundTrip_Large_File()
+        {
+            var sourceFile = Path.GetFullPath(@"../../../../../data/image.jpg");
+            var encryptedFile = sourceFile + ".encrypted";
+            var decryptedFile = sourceFile + ".decrypted.jpg";
+
+            try
+            {
+                await Secrets.EncryptFileToFileAsync(sourceFile, encryptedFile, "password");
+                await Secrets.DecryptFileToFileAsync(encryptedFile, decryptedFile, "password");
+
+                var buffer0 = File.ReadAllBytes(sourceFile);
+                var buffer1 = File.ReadAllBytes(decryptedFile);
+                Assert.True(buffer0.Length == buffer1.Length);
+                for (var i = 0; i < buffer0.Length; i++)
+                {
+                    if (buffer0[i] != buffer1[i]) Assert.Fail("Decrypted file is not identical to original file.");
+                }
+            }
+            finally
+            {
+                File.Delete(encryptedFile);
+                File.Delete(decryptedFile);
+            }
+        }
     }
 }

src/Aardvark.Base.Cryptography.Tests/SecretsTests.cs

@@ -360,38 +360,45 @@ public static Task DecryptBufferToFileAsync(byte[] source, string targetFile, st
     /// <summary>
     /// Decrypt file to stream.
     /// </summary>
-    public static Task DecryptFileToStreamAsync(string sourceFile, Stream target, string password)
+    public static async Task DecryptFileToStreamAsync(string sourceFile, Stream target, string password)
     {
-        using var sourceStream = GetFileReadStream(sourceFile);
-        return DecryptStreamToStreamAsync(sourceStream, target, password);
+        var sourceStream = GetFileReadStream(sourceFile);
+        await DecryptStreamToStreamAsync(sourceStream, target, password);
+        sourceStream.Dispose();
     }
 
     /// <summary>
     /// Decrypt file to buffer.
     /// </summary>
-    public static Task<byte[]> DecryptFileToBufferAsync(string sourceFile, string password)
+    public static async Task<byte[]> DecryptFileToBufferAsync(string sourceFile, string password)
     {
-        using var sourceStream = GetFileReadStream(sourceFile);
-        return DecryptStreamToBufferAsync(sourceStream, password);
+        var sourceStream = GetFileReadStream(sourceFile);
+        var result = await DecryptStreamToBufferAsync(sourceStream, password);
+        sourceStream.Dispose();
+        return result;
     }
 
     /// <summary>
     /// Decrypt file to string.
     /// </summary>
     public static async Task<string> DecryptFileToStringAsync(string sourceFile, string password)
     {
-        using var sourceStream = GetFileReadStream(sourceFile);
-        return await DecryptStreamToStringAsync(sourceStream, password);
+        var sourceStream = GetFileReadStream(sourceFile);
+        var result = await DecryptStreamToStringAsync(sourceStream, password);
+        sourceStream.Dispose();
+        return result;
     }
 
     /// <summary>
     /// Decrypt file to file.
     /// </summary>
-    public static Task DecryptFileToFileAsync(string sourceFile, string targetFile, string password)
+    public static async Task DecryptFileToFileAsync(string sourceFile, string targetFile, string password)
     {
-        using var sourceStream = GetFileReadStream(sourceFile);
-        using var targetStream = GetFileWriteStream(targetFile);
-        return DecryptStreamToStreamAsync(sourceStream, targetStream, password);
+        var sourceStream = GetFileReadStream(sourceFile);
+        var targetStream = GetFileWriteStream(targetFile);
+        await DecryptStreamToStreamAsync(sourceStream, targetStream, password);
+        sourceStream.Dispose();
+        targetStream.Dispose();
     }
 
     #endregion