feat: add byte encryption paramter class to encapsulate the iv, secret and data

Author: selfmadecode

src/Encryption/AesEncryption/BaseAesEncryption.cs

@@ -1,4 +1,5 @@
-using System;
+using SafeCrypt.src.Encryption.AesEncryption.Models;
+using System;
 using System.IO;
 using System.Security.Cryptography;
 
@@ -9,9 +10,9 @@ public class BaseAesEncryption
         /// <summary>
         /// Encrypts the provided data using the Advanced Encryption Standard (AES) algorithm.
         /// </summary>
-        /// <param name="data">The data to be encrypted.</param>
-        /// <param name="key">The secret key used for encryption.</param>
-        /// <param name="iv">The initialization vector used for encryption.</param>
+        /// <param name="param.Data">The data to be encrypted.</param>
+        /// <param name="param.SecretKey">The secret key used for encryption.</param>
+        /// <param name="param.IV">The initialization vector used for encryption.</param>
         /// <returns>The encrypted data as a byte array.</returns>
         /// <remarks>
         /// The method uses the AES algorithm to encrypt the input data with the provided key and initialization vector.
@@ -22,16 +23,16 @@ public class BaseAesEncryption
         /// <exception cref="Exception">
         /// Thrown for general encryption-related exceptions.
         /// </exception>
-        public virtual byte[] EncryptAES(byte[] data, byte[] key, byte[] iv)
+        public virtual byte[] EncryptAES(ByteEncryptionParameters param)
         {
             try
             {
                 // Create an instance of the AES algorithm
                 using (Aes aes = Aes.Create())
                 {
                     // Set the key and initialization vector
-                    aes.Key = key;
-                    aes.IV = iv;
+                    aes.Key = param.SecretKey;
+                    aes.IV = param.IV;
                     // Create an encryptor using the key and initialization vector
                     ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
 
@@ -42,7 +43,7 @@ public virtual byte[] EncryptAES(byte[] data, byte[] key, byte[] iv)
                         using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                         {
                             // Write the data to be encrypted to the CryptoStream
-                            cryptoStream.Write(data, 0, data.Length);
+                            cryptoStream.Write(param.Data, 0, param.Data.Length);
                             cryptoStream.FlushFinalBlock();
 
                             // Return the encrypted data as a byte array

src/Encryption/AesEncryption/Encrypting.cs

@@ -10,9 +10,7 @@ public class Encrypting : BaseAesEncryption
         /// <summary>
         /// Encrypts the provided data using the specified secret key and initialization vector (IV).
         /// </summary>
-        /// <param name="data">The data to be encrypted.</param>
-        /// <param name="secretKey">The secret key used for encryption.</param>
-        /// <param name="iv">The initialization vector used for encryption.</param>
+        /// <param name="parameters">The encryption parameters.</param>
         /// <returns>The encrypted data as a byte array.</returns>
         /// <remarks>
         /// This method serves as a wrapper around the underlying AES encryption logic provided by the
@@ -23,62 +21,138 @@ public class Encrypting : BaseAesEncryption
         /// <param name="secretKey">The secret key used for encryption.</param>
         /// <param name="iv">The initialization vector used for encryption.</param>
         /// <returns>The encrypted data as a byte array.</returns>
-        public byte[] Encrypt(byte[] data, byte[] secretKey, byte[] iv)
+        public byte[] Encrypt(ByteEncryptionParameters param)
         {
             // Delegate the encryption to the underlying AES encryption method
-            return EncryptAES(data, secretKey, iv);
+            return EncryptAES(param);
         }
 
 
-        public byte[] Encrypt(string data, string secretKey, string iv)
+        public byte[] Encrypt(StringEncryptionParameters param)
         {
-            NullChecks(data, secretKey, iv);
+            NullChecks(param.Data, param.SecretKey, param.IV);
 
-            var aesKey = secretKey.ConvertKeysToBytes();
-            var aesIv = iv.ConvertKeysToBytes();
+            var byteEncryptionParameters = new ByteEncryptionParameters
+            {
+                SecretKey = param.SecretKey.ConvertKeysToBytes(),
+                IV = param.IV.ConvertKeysToBytes(),
+                Data = param.Data.HexadecimalStringToByteArray()
+            };
 
-            var aesData = data.HexadecimalStringToByteArray();
-            return EncryptAES(aesData, aesKey, aesIv);
-        }       
+            return EncryptAES(byteEncryptionParameters);
+        }
 
-        public AesEncryptionData Encrypt(string data, string secretKey)
+        /// <summary>
+        /// Encrypts the provided string data using the Advanced Encryption Standard (AES) algorithm.
+        /// </summary>
+        /// <param name="data">The string data to be encrypted.</param>
+        /// <param name="secretKey">The secret key used for encryption.</param>
+        /// <returns>An <see cref="AesEncrypted"/> object containing the encrypted data and initialization vector (IV).</returns>
+        /// <remarks>
+        /// This method encrypts the input string data using the specified secret key and a randomly generated initialization
+        /// vector (IV) for AES encryption in Cipher Block Chaining (CBC) mode. The resulting encrypted data and IV are encapsulated
+        /// in an <see cref="AesEncrypted"/> object, which is then returned.
+        /// </remarks>
+        /// <param name="data">The string data to be encrypted.</param>
+        /// <param name="secretKey">The secret key used for encryption.</param>
+        /// <returns>An <see cref="AesEncrypted"/> object containing the encrypted data and initialization vector (IV).</returns>
+        /// <exception cref="ArgumentNullException">
+        /// Thrown if the input data or secret key is null.
+        /// </exception>
+        public AesEncrypted Encrypt(string data, string secretKey)
         {
             NullChecks(data, secretKey);
 
             // Generate a random 16-byte IV for AES in CBC mode
             var aesIv = GenerateRandomIVKeyAsBytes(16);
 
-            var aesKey = Encoding.UTF8.GetBytes(secretKey);
-            var aesData = data.HexadecimalStringToByteArray();
+            //var aesKey = Encoding.UTF8.GetBytes(secretKey);
+            //var aesData = data.HexadecimalStringToByteArray();
+
+            var byteEncryptionParameters = new ByteEncryptionParameters
+            {
+                SecretKey = Encoding.UTF8.GetBytes(secretKey),
+                IV = aesIv,
+                Data = data.HexadecimalStringToByteArray()
+            };
 
-            var response = EncryptAES(aesData, aesKey, aesIv);
+            //var response = EncryptAES(aesData, aesKey, aesIv);
+            var response = EncryptAES(byteEncryptionParameters);
 
-            var responseData = new AesEncryptionData
+            var responseData = new AesEncrypted
             {
                 Data = response,
                 Iv = aesIv
             };
 
             return responseData;
         }
-
-        public string EncryptByteToHexString(byte[] data, byte[] secretKey, byte[] iv)
+        /// <summary>
+        /// Encrypts the provided byte data using the Advanced Encryption Standard (AES) algorithm
+        /// and returns the encrypted data as a hexadecimal string.
+        /// </summary>
+        /// <param name="param">The parameters containing the byte data, secret key, and initialization vector (IV).</param>
+        /// <returns>The encrypted data represented as a hexadecimal string.</returns>
+        /// <remarks>
+        /// This method encrypts the input byte data using the specified secret key and initialization vector (IV)
+        /// using the AES algorithm. The resulting encrypted data is then converted to a hexadecimal string before being
+        /// returned. The encryption parameters are encapsulated in a <see cref="ByteEncryptionParameters"/> object.
+        /// </remarks>
+        /// <param name="param">The parameters containing the byte data, secret key, and initialization vector (IV).</param>
+        /// <returns>The encrypted data represented as a hexadecimal string.</returns>
+        /// <exception cref="ArgumentNullException">
+        /// Thrown if the input parameters or byte data is null.
+        /// </exception>
+        public string EncryptByteToHexString(ByteEncryptionParameters param)
         {
-            var cipherText = EncryptAES(data, secretKey, iv);
+            var cipherText = EncryptAES(param);
 
+            // Convert the encrypted data to a hexadecimal string
             return cipherText.ByteArrayToHexString();
         }
 
-        public string EncryptByteToBase64String(byte[] data, byte[] secretKey, byte[] iv)
+        /// <summary>
+        /// Encrypts the provided byte data using the Advanced Encryption Standard (AES) algorithm
+        /// and returns the encrypted data as a Base64-encoded string.
+        /// </summary>
+        /// <param name="param">The parameters containing the byte data, secret key, and initialization vector (IV).</param>
+        /// <returns>The encrypted data represented as a Base64-encoded string.</returns>
+        /// <remarks>
+        /// This method encrypts the input byte data using the specified secret key and initialization vector (IV)
+        /// using the AES algorithm. The resulting encrypted data is then converted to a Base64-encoded string before
+        /// being returned. The encryption parameters are encapsulated in a <see cref="ByteEncryptionParameters"/> object.
+        /// </remarks>
+        /// <param name="param">The parameters containing the byte data, secret key, and initialization vector (IV).</param>
+        /// <returns>The encrypted data represented as a Base64-encoded string.</returns>
+        /// <exception cref="ArgumentNullException">
+        /// Thrown if the input parameters or byte data is null.
+        /// </exception>
+        public string EncryptByteToBase64String(ByteEncryptionParameters param)
         {
-            var cipherText = EncryptAES(data, secretKey, iv);
+            var cipherText = EncryptAES(param);
 
             return Convert.ToBase64String(cipherText);
         }
 
-        public string EncryptByteToString(byte[] data, byte[] secretKey, byte[] iv)
+        /// <summary>
+        /// Encrypts the provided byte data using the Advanced Encryption Standard (AES) algorithm
+        /// and returns the encrypted data as a string using UTF-8 encoding.
+        /// </summary>
+        /// <param name="param">The parameters containing the byte data, secret key, and initialization vector (IV).</param>
+        /// <returns>The encrypted data represented as a string using UTF-8 encoding.</returns>
+        /// <remarks>
+        /// This method encrypts the input byte data using the specified secret key and initialization vector (IV)
+        /// using the AES algorithm. The resulting encrypted data is then converted to a string using UTF-8
+        /// encoding before being returned. The encryption parameters are encapsulated in a <see cref="ByteEncryptionParameters"/> object.
+        /// </remarks>
+        /// <param name="param">The parameters containing the byte data, secret key, and initialization vector (IV).</param>
+        /// <returns>The encrypted data represented as a string using UTF-8 encoding.</returns>
+        /// <exception cref="ArgumentNullException">
+        /// Thrown if the input parameters or byte data is null.
+        /// </exception>
+        public string EncryptByteToString(ByteEncryptionParameters param)
         {
-            var cipherText = EncryptAES(data, secretKey, iv);
+            var cipherText = EncryptAES(param);
 
             return cipherText.BytesToString();
         }

src/Encryption/AesEncryption/Models/EncryptionParameters.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Text;
+
+namespace SafeCrypt.src.Encryption.AesEncryption.Models
+{
+    /// <summary>
+    /// Represents the parameters required for encryption.
+    /// </summary>
+    public class ByteEncryptionParameters
+    {
+        /// <summary>
+        /// Gets or sets the data to be encrypted.
+        /// </summary>
+        [Required]
+        public byte[] Data { get; set; }
+
+        /// <summary>
+        /// Gets or sets the secret key used for encryption.
+        /// </summary>
+        [Required]
+        public byte[] SecretKey { get; set; }
+
+        /// <summary>
+        /// Gets or sets the initialization vector (IV) used for encryption.
+        /// </summary>
+        [Required]
+        public byte[] IV { get; set; }
+    }
+        
+
+    
+
+}