reset files requested by Jeremy

Author: gewarren

snippets/csharp/System.Security.Cryptography/TripleDES/Create/fileexample.cs

@@ -3,11 +3,10 @@
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
-using System.Threading.Tasks;
 
 class TripleDESSample
 {
-    static async Task Main()
+    static void Main()
     {
         try
         {
@@ -28,10 +27,10 @@ static async Task Main()
             string filename = "CText.enc";
 
             // Encrypt the string to a file.
-            await EncryptTextToFile(original, filename, key, iv);
+            EncryptTextToFile(original, filename, key, iv);
 
             // Decrypt the file back to a string.
-            string decrypted = await DecryptTextFromFile(filename, key, iv);
+            string decrypted = DecryptTextFromFile(filename, key, iv);
 
             // Display the decrypted string to the console.
             Console.WriteLine(decrypted);
@@ -42,25 +41,25 @@ static async Task Main()
         }
     }
 
-    public static async Task EncryptTextToFile(string text, string path, byte[] key, byte[] iv)
+    public static void EncryptTextToFile(string text, string path, byte[] key, byte[] iv)
     {
         try
         {
             // Create or open the specified file.
-            using FileStream fileStream = File.Open(path, FileMode.Create);
+            using (FileStream fStream = File.Open(path, FileMode.Create))
             // Create a new TripleDES object.
-            using TripleDES tripleDes = TripleDES.Create();
+            using (TripleDES tripleDes = TripleDES.Create())
             // Create a TripleDES encryptor from the key and IV
-            using ICryptoTransform encryptor = tripleDes.CreateEncryptor(key, iv);
+            using (ICryptoTransform encryptor = tripleDes.CreateEncryptor(key, iv))
             // Create a CryptoStream using the FileStream and encryptor
-            using var cryptoStream = new CryptoStream(fileStream, encryptor, CryptoStreamMode.Write);
-
-            // Convert the provided string to a byte array.
-            byte[] toEncrypt = Encoding.UTF8.GetBytes(text);
-
-            // Write the byte array to the crypto stream.
-            await cryptoStream.WriteAsync(toEncrypt);
+            using (var cStream = new CryptoStream(fStream, encryptor, CryptoStreamMode.Write))
+            {
+                // Convert the provided string to a byte array.
+                byte[] toEncrypt = Encoding.UTF8.GetBytes(text);
 
+                // Write the byte array to the crypto stream.
+                cStream.Write(toEncrypt, 0, toEncrypt.Length);
+            }
         }
         catch (CryptographicException e)
         {
@@ -69,25 +68,26 @@ public static async Task EncryptTextToFile(string text, string path, byte[] key,
         }
     }
 
-    public static async Task<string> DecryptTextFromFile(string path, byte[] key, byte[] iv)
+    public static string DecryptTextFromFile(string path, byte[] key, byte[] iv)
     {
         try
         {
             // Open the specified file
-            using FileStream fileStream = File.OpenRead(path);
+            using (FileStream fStream = File.OpenRead(path))
             // Create a new TripleDES object.
-            using TripleDES tripleDes = TripleDES.Create();
+            using (TripleDES tripleDes = TripleDES.Create())
             // Create a TripleDES decryptor from the key and IV
-            using ICryptoTransform decryptor = tripleDes.CreateDecryptor(key, iv);
+            using (ICryptoTransform decryptor = tripleDes.CreateDecryptor(key, iv))
             // Create a CryptoStream using the FileStream and decryptor
-            using var cryptoStream = new CryptoStream(fileStream, decryptor, CryptoStreamMode.Read);
+            using (var cStream = new CryptoStream(fStream, decryptor, CryptoStreamMode.Read))
             // Create a StreamReader to turn the bytes back into text
-            using var reader = new StreamReader(cryptoStream, Encoding.UTF8);
-
-            // Read back all of the text from the StreamReader, which receives
-            // the decrypted bytes from the CryptoStream, which receives the
-            // encrypted bytes from the FileStream.
-            return await reader.ReadToEndAsync();
+            using (StreamReader reader = new StreamReader(cStream, Encoding.UTF8))
+            {
+                // Read back all of the text from the StreamReader, which receives
+                // the decrypted bytes from the CryptoStream, which receives the
+                // encrypted bytes from the FileStream.
+                return reader.ReadToEnd();
+            }
         }
         catch (CryptographicException e)
         {

snippets/csharp/System.Security.Cryptography/TripleDES/Create/memoryexample.cs

@@ -1,13 +1,12 @@
 // <SNIPPET1>
 using System;
-using System.IO;
 using System.Security.Cryptography;
 using System.Text;
-using System.Threading.Tasks;
+using System.IO;
 
 class TripleDESSample2
 {
-    static async Task Main()
+    static void Main()
     {
         try
         {
@@ -26,10 +25,10 @@ static async Task Main()
             string original = "Here is some data to encrypt.";
 
             // Encrypt the string to an in-memory buffer.
-            byte[] encrypted = await EncryptTextToMemory(original, key, iv);
+            byte[] encrypted = EncryptTextToMemory(original, key, iv);
 
             // Decrypt the buffer back to a string.
-            string decrypted = await DecryptTextFromMemory(encrypted, key, iv);
+            string decrypted = DecryptTextFromMemory(encrypted, key, iv);
 
             // Display the decrypted string to the console.
             Console.WriteLine(decrypted);
@@ -40,34 +39,35 @@ static async Task Main()
         }
     }
 
-    public static async Task<byte[]> EncryptTextToMemory(string text, byte[] key, byte[] iv)
+    public static byte[] EncryptTextToMemory(string text, byte[] key, byte[] iv)
     {
         try
         {
             // Create a MemoryStream.
-            using var memoryStream = new MemoryStream();
-
-            // Create a new TripleDES object.
-            using (TripleDES tripleDes = TripleDES.Create())
-            // Create a TripleDES encryptor from the key and IV
-            using (ICryptoTransform encryptor = tripleDes.CreateEncryptor(key, iv))
-            // Create a CryptoStream using the MemoryStream and encryptor
-            using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
+            using (MemoryStream mStream = new MemoryStream())
             {
-                // Convert the provided string to a byte array.
-                byte[] toEncrypt = Encoding.UTF8.GetBytes(text);
+                // Create a new TripleDES object.
+                using (TripleDES tripleDes = TripleDES.Create())
+                // Create a TripleDES encryptor from the key and IV
+                using (ICryptoTransform encryptor = tripleDes.CreateEncryptor(key, iv))
+                // Create a CryptoStream using the MemoryStream and encryptor
+                using (var cStream = new CryptoStream(mStream, encryptor, CryptoStreamMode.Write))
+                {
+                    // Convert the provided string to a byte array.
+                    byte[] toEncrypt = Encoding.UTF8.GetBytes(text);
 
-                // Write the byte array to the crypto stream and flush it.
-                await cryptoStream.WriteAsync(toEncrypt);
+                    // Write the byte array to the crypto stream and flush it.
+                    cStream.Write(toEncrypt, 0, toEncrypt.Length);
 
-                // Ending the using statement for the CryptoStream completes the encryption.
-            }
+                    // Ending the using statement for the CryptoStream completes the encryption.
+                }
 
-            // Get an array of bytes from the MemoryStream that holds the encrypted data.
-            byte[] ret = memoryStream.ToArray();
+                // Get an array of bytes from the MemoryStream that holds the encrypted data.
+                byte[] ret = mStream.ToArray();
 
-            // Return the encrypted buffer.
-            return ret;
+                // Return the encrypted buffer.
+                return ret;
+            }
         }
         catch (CryptographicException e)
         {
@@ -76,34 +76,38 @@ public static async Task<byte[]> EncryptTextToMemory(string text, byte[] key, by
         }
     }
 
-    public static async Task<string> DecryptTextFromMemory(byte[] encrypted, byte[] key, byte[] iv)
+    public static string DecryptTextFromMemory(byte[] encrypted, byte[] key, byte[] iv)
     {
         try
         {
             // Create a buffer to hold the decrypted data.
             // TripleDES-encrypted data will always be slightly bigger than the decrypted data.
             byte[] decrypted = new byte[encrypted.Length];
-            Memory<byte> buffer = decrypted;
+            int offset = 0;
 
             // Create a new MemoryStream using the provided array of encrypted data.
-            using var memoryStream = new MemoryStream(encrypted);
-
-            // Create a new TripleDES object.
-            using (TripleDES tripleDes = TripleDES.Create())
-            // Create a TripleDES decryptor from the key and IV
-            using (ICryptoTransform decryptor = tripleDes.CreateDecryptor(key, iv))
-            // Create a CryptoStream using the MemoryStream and decryptor
-            using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
+            using (MemoryStream mStream = new MemoryStream(encrypted))
             {
-                // Keep reading from the CryptoStream until it finishes (returns 0).
-                while (await cryptoStream.ReadAsync(buffer) is var read and > 0)
+                // Create a new TripleDES object.
+                using (TripleDES tripleDes = TripleDES.Create())
+                // Create a TripleDES decryptor from the key and IV
+                using (ICryptoTransform decryptor = tripleDes.CreateDecryptor(key, iv))
+                // Create a CryptoStream using the MemoryStream and decryptor
+                using (var cStream = new CryptoStream(mStream, decryptor, CryptoStreamMode.Read))
                 {
-                    buffer = buffer.Slice(read);
+                    // Keep reading from the CryptoStream until it finishes (returns 0).
+                    int read = 1;
+
+                    while (read > 0)
+                    {
+                        read = cStream.Read(decrypted, offset, decrypted.Length - offset);
+                        offset += read;
+                    }
                 }
             }
 
             // Convert the buffer into a string and return it.
-            return Encoding.UTF8.GetString(decrypted.AsSpan(..^buffer.Length));
+            return Encoding.UTF8.GetString(decrypted, 0, offset);
         }
         catch (CryptographicException e)
         {