Merge pull request #51 from selfmadecode/dev

feat: add rsa algorithm, change aes algorithms to static methods

Author: selfmadecode

README.md

@@ -4,14 +4,14 @@ A C# library for encryption and decryption.
 
 ## Overview
 
-The Encryption library provides a set of methods for encrypting and decrypting data using the Advanced Encryption Standard (AES) algorithm, and other algorithm. It is designed to be easy to use and can be integrated into C# applications that require secure data transmission or storage.
-
+The SafeCrypt library provides a set of methods for encrypting and decrypting data using various encryption algorithms,
+including the Advanced Encryption Standard (AES) and RSA (Rivest–Shamir–Adleman).
+It is designed to be easy to use and can be integrated into C# applications that require secure data transmission or storage.
 ## Table of Contents
 
 - [Installation](#installation)
-- [Usage](#usage)
-- [API Reference](#api-reference)
-- [Examples](#examples)
+- [AES Encryption and Decryption usage](#usage)
+- [RSA Encryption and Decryption usage](#rsa)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -34,28 +34,25 @@ To use the SafeCrypt library in your C# project, follow these steps:
 
 Now, you can reference the SafeCrypt library in your C# project.
 
-## Basic Usage
+## Usage
 
-To use the library in your C# application, instantiate the `AesEncryption` or `AesDecryption` class and call the provided methods. Here's a simple example:
+To use the AES encryption in your C# application,
+instantiate the `AesEncryption` or `AesDecryption` class and call the provided methods. Here's a simple example:
 
 ```csharp
-using SafeCrypt.AESDecryption;
-using SafeCrypt.AESEncryption;
+using SafeCrypt.AES;
 using SafeCrypt.Models; 
 
 class Program
 {
     static async Task Main()
     {
-        var aesEncryptor = new AesEncryption();
 
-        var encryptedData = await aesEncryptor.EncryptToBase64StringAsync("Hello, World!", "gdjdtsraewsuteastwerse=="
+        var encryptedData = await Aes.EncryptToBase64StringAsync("Hello, World!", "gdjdtsraewsuteastwerse=="
 
         Console.WriteLine($"Encrypted Data: {encryptedData.EncryptedData}");
         Console.WriteLine($"Initialization Vector: {encryptedData.Iv}");
-
-        var aesDecryptor = new AesDecryption();
-
+                
         var parameterToDecrypt = new DecryptionParameters
         {
           DataToDecrypt = encryptedData.EncryptedData,
@@ -64,7 +61,7 @@ class Program
 
         };
 
-        var data = await aesDecryptor.DecryptFromBase64StringAsync(parameterToDecrypt)
+        var data = await Aes.DecryptFromBase64StringAsync(parameterToDecrypt)
 
         Console.WriteLine($"Decrypted Data: {data.DecryptedData}");
         Console.WriteLine($"Initialization Vector: {data.Iv}");
@@ -74,8 +71,7 @@ class Program
 
 -------------------------------------------------------------------------------------------------------
 
-using SafeCrypt.AESDecryption;
-using SafeCrypt.AESEncryption;
+using SafeCrypt.AES;
 using SafeCrypt.Models; 
 
 class Program
@@ -94,9 +90,8 @@ class Program
             SecretKey = secret
         };
 
-        var encryptor = new AesEncryption();
 
-        var response = await encryptor.EncryptToBase64StringAsync(encryptionParam.DataToEncrypt, secret);
+        var response = await Aes.EncryptToBase64StringAsync(encryptionParam.DataToEncrypt, secret);
 
         Console.WriteLine(response.EncryptedData);
         Console.WriteLine(response.Iv);
@@ -112,8 +107,7 @@ class Program
         };
 
 
-        var decryptor = new AesDecryption();
-        var decryptionData = await decryptor.DecryptFromBase64StringAsync(decryptorParam);
+        var decryptionData = await Aes.DecryptFromBase64StringAsync(decryptorParam);
 
         Console.WriteLine(decryptionData.DecryptedData);
         Console.WriteLine(decryptionData.Iv);
@@ -122,6 +116,14 @@ class Program
 }
 ```
 
+
+## Rsa
+This library provides a straightforward implementation of RSA encryption and decryption in C# using the .NET `RSACryptoServiceProvider`.
+It includes methods for generating RSA key pairs, encrypting data with a public key, and decrypting data with a private key.
+
+For more details on RSA Encryption, check the [Rsa.md](doc/Rsa.md) document.
+
+
 ## Contributing
 
 If you would like to contribute to the development of the SafeCrypt library, follow these steps:

doc/Rsa.md

@@ -0,0 +1,90 @@
+# RSA Encryption and Decryption
+
+## Overview
+
+This library provides a straightforward implementation of RSA encryption and decryption in C# using the .NET `RSACryptoServiceProvider`.
+It includes methods for generating RSA key pairs, encrypting data with a public key, and decrypting data with a private key.
+
+## Table of Contents
+
+- [Usage](#usage)
+  - [Generate RSA Keys](#generate-rsa-keys)
+  - [Encrypt and Decrypt using RSA](#encrypt-and-decrypt-using-rsa)
+
+## Usage
+
+### Generate RSA Keys
+
+```csharp
+using SafeCrypt.Helpers;
+using SafeCrypt.RsaEncryption;
+
+var rsaKeyPair = KeyGenerators.GenerateRsaKeys(2048);
+
+string rsaPublicKey = rsaKeyPair.Item1;
+string rsaPrivateKey = rsaKeyPair.Item2;
+
+Console.WriteLine($"Public Key: {rsaPublicKey}");
+Console.WriteLine($"Private Key: {rsaPrivateKey}");
+```
+
+### Encrypt and Decrypt using RSA
+
+```csharp
+    using SafeCrypt.RsaEncryption;
+
+    // Encrypt
+    string originalData = "Hello, RSA Encryption!";
+
+    var encryptionModel = new RsaEncryptionParameters
+    {
+        DataToEncrypt = originalData,
+        PublicKey = rsaPublicKey,
+    };
+
+    var encryptedData = await Rsa.EncryptAsync(encryptionModel);
+
+    Console.WriteLine($"Original Data: {originalData}");
+    Console.WriteLine("Encrypted Data: " + BitConverter.ToString(encryptedData.EncryptedData));
+
+    // Convert encrypted byte array to Base64 string
+    string encryptedDataConvertedString = Convert.ToBase64String(encryptedData.EncryptedData);
+
+    // Convert string back to byte array for decryption
+    byte[] convertedBytes = Convert.FromBase64String(encryptedDataConvertedString);
+
+    bool arraysAreEqual = StructuralComparisons.StructuralEqualityComparer.Equals(encryptedData.EncryptedData, convertedBytes);
+    Console.WriteLine("Original and converted byte arrays are equal: " + arraysAreEqual); // should return true
+
+
+
+    // Decrypt
+    var decryptionModel = new RsaDecryptionParameters
+    {
+        DataToDecrypt = convertedBytes, // encryptedData.EncryptedData
+        PrivateKey = rsaPrivateKey,
+    };
+
+    var decryptedData = await Rsa.DecryptAsync(decryptionModel);
+
+    // if Error occurs during encryption
+    if (decryptedData.Errors.Count > 0)
+    {
+        Console.WriteLine("Decryption Errors:");
+        foreach (var error in decryptedData.Errors)
+        {
+            Console.WriteLine(error);
+        }
+    }
+    else
+    {
+        Console.WriteLine($"Decrypted Data: {decryptedData.DecryptedData}"); 
+    }
+
+// Note: The return type from Rsa.EncryptAsync is `EncryptionResult`, and Rsa.DecryptAsync is `DecryptionResult`.
+// Both models include a list of errors encountered during encryption/decryption.
+
+```
+## Contributing
+
+Contributions are welcome! Feel free to open issues, submit pull requests, or provide feedback.

src/SafeCrypt.Lib/Encryption/AesEncryption/BaseAesEncryption.cs

@@ -6,7 +6,7 @@
 
 namespace SafeCrypt.AesEncryption
 {
-    public class BaseAesEncryption
+    public static class BaseAesEncryption
     {
         /// <summary>
         /// Encrypts the provided data using the Advanced Encryption Standard (AES) algorithm.

src/SafeCrypt.Lib/Encryption/AesEncryption/Decrypting.cs

@@ -5,9 +5,9 @@
 using System.Security.Cryptography;
 using System.Threading.Tasks;
 
-namespace SafeCrypt.AESDecryption
+namespace SafeCrypt.AES
 {
-    public class AesDecryption : BaseAesEncryption
+    public static partial class Aes 
     {
         /// <summary>
         /// Asynchronously decrypts data from a hexadecimal string using the specified decryption parameters and cipher mode.
@@ -19,7 +19,7 @@ public class AesDecryption : BaseAesEncryption
         /// The task result is a <see cref="DecryptionData"/> object containing the decrypted data, IV, and secret key.
         /// If decryption fails, the <see cref="DecryptionData"/> object will contain error information.
         /// </returns>
-        public async Task<DecryptionData> DecryptFromHexStringAsync(DecryptionParameters param, CipherMode mode = CipherMode.CBC)
+        public static async Task<DecryptionData> DecryptFromHexStringAsync(DecryptionParameters param, CipherMode mode = CipherMode.CBC)
         {
             var responseData = new DecryptionData();
 
@@ -55,7 +55,7 @@ public async Task<DecryptionData> DecryptFromHexStringAsync(DecryptionParameters
                 Data = param.DataToDecrypt.HexadecimalStringToByteArray()
             };
 
-            var response = await DecryptAsync(byteEncryptionParameters, mode);
+            var response = await BaseAesEncryption.DecryptAsync(byteEncryptionParameters, mode);
 
             return new DecryptionData
             {
@@ -75,7 +75,7 @@ public async Task<DecryptionData> DecryptFromHexStringAsync(DecryptionParameters
         /// The task result is a <see cref="DecryptionData"/> object containing the decrypted data, IV, and secret key.
         /// If decryption fails, the <see cref="DecryptionData"/> object will contain error information.
         /// </returns>
-        public async Task<DecryptionData> DecryptFromBase64StringAsync(DecryptionParameters param, CipherMode mode = CipherMode.CBC)
+        public static async Task<DecryptionData> DecryptFromBase64StringAsync(DecryptionParameters param, CipherMode mode = CipherMode.CBC)
         {
             var responseData = new DecryptionData();
 
@@ -103,7 +103,7 @@ public async Task<DecryptionData> DecryptFromBase64StringAsync(DecryptionParamet
                     Data = Convert.FromBase64String(param.DataToDecrypt)
                 };
 
-                var response = await DecryptAsync(byteDecryptionParameters, mode);
+                var response = await BaseAesEncryption.DecryptAsync(byteDecryptionParameters, mode);
 
                 return new DecryptionData
                 {
@@ -121,7 +121,7 @@ public async Task<DecryptionData> DecryptFromBase64StringAsync(DecryptionParamet
         }
 
 
-        private void NullChecks(string data, string secretKey, string iv)
+        private static void NullChecks(string data, string secretKey, string iv)
         {
             if (data == null || data.Length <= 0)
                 throw new ArgumentNullException(nameof(data));
@@ -133,13 +133,13 @@ private void NullChecks(string data, string secretKey, string iv)
                 throw new ArgumentNullException(nameof(iv));
         }
 
-        private (byte[], byte[]) ConvertKeysToBytesAndGetKeys(string secretKey, string iv)
+        private static (byte[], byte[]) ConvertKeysToBytesAndGetKeys(string secretKey, string iv)
         {
 
             return (secretKey.ConvertKeysToBytes(), iv.ConvertKeysToBytes());
         }
 
-        private void AddError(DecryptionData responseData, string error)
+        private static void AddError(DecryptionData responseData, string error)
         {
             responseData.HasError = true;
             responseData.Errors.Add(error);

src/SafeCrypt.Lib/Encryption/AesEncryption/Encrypting.cs

@@ -5,9 +5,9 @@
 using System.Security.Cryptography;
 using System.Threading.Tasks;
 
-namespace SafeCrypt.AESEncryption
+namespace SafeCrypt.AES
 {
-    public class AesEncryption : BaseAesEncryption
+    public static partial class Aes
     {
         /// <summary>
         /// Asynchronously encrypts the provided data using the specified secret key and initialization vector (IV).
@@ -23,7 +23,7 @@ public class AesEncryption : 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 async Task<EncryptionData> EncryptToHexStringAsync(EncryptionParameters param, CipherMode mode = CipherMode.CBC)
+        public static async Task<EncryptionData> EncryptToHexStringAsync(EncryptionParameters param, CipherMode mode = CipherMode.CBC)
         {
             var responseData = new EncryptionData();
 
@@ -52,7 +52,7 @@ public async Task<EncryptionData> EncryptToHexStringAsync(EncryptionParameters p
                 Data = param.DataToEncrypt.ConvertToHexString().HexadecimalStringToByteArray()
             };
 
-            var response = await EncryptAsync(byteEncryptionParameters, mode);
+            var response = await BaseAesEncryption.EncryptAsync(byteEncryptionParameters, mode);
 
             return new EncryptionData
             {
@@ -84,7 +84,7 @@ public async Task<EncryptionData> EncryptToHexStringAsync(EncryptionParameters p
         /// <exception cref="FormatException">
         /// Thrown if the base64secretKey is not a valid Base64-encoded string.
         /// </exception>
-        public async Task<EncryptionData> EncryptToBase64StringAsync(string dataToBeEncrypted, string base64secretKey, CipherMode mode = CipherMode.CBC)
+        public static async Task<EncryptionData> EncryptToBase64StringAsync(string dataToBeEncrypted, string base64secretKey, CipherMode mode = CipherMode.CBC)
         {
             // validate is base64
             if (!Validators.IsBase64String(base64secretKey))
@@ -104,7 +104,7 @@ public async Task<EncryptionData> EncryptToBase64StringAsync(string dataToBeEncr
                 Data = dataToBeEncrypted.ConvertToHexString().HexadecimalStringToByteArray()
             };
 
-            var response = await EncryptAsync(byteEncryptionParameters, mode);
+            var response = await BaseAesEncryption.EncryptAsync(byteEncryptionParameters, mode);
 
             return new EncryptionData
             {
@@ -114,7 +114,7 @@ public async Task<EncryptionData> EncryptToBase64StringAsync(string dataToBeEncr
             };
         }
 
-        private EncryptionData ValidateEncryptionParameters(EncryptionParameters param)
+        private static EncryptionData ValidateEncryptionParameters(EncryptionParameters param)
         {
             var responseData = new EncryptionData();
 
@@ -134,7 +134,7 @@ private EncryptionData ValidateEncryptionParameters(EncryptionParameters param)
             return responseData;
         }
 
-        private void NullChecks(string data, string secretKey)
+        private static void NullChecks(string data, string secretKey)
         {
             if (data == null || data.Length <= 0)
                 throw new ArgumentNullException(nameof(data));
@@ -143,7 +143,7 @@ private void NullChecks(string data, string secretKey)
                 throw new ArgumentNullException(nameof(secretKey));
         }
 
-        private void AddError(EncryptionData responseData, string error)
+        private static void AddError(EncryptionData responseData, string error)
         {
             responseData.HasError = true;
             responseData.Errors.Add(error);

src/SafeCrypt.Lib/Encryption/RsaEncryption/Models/Encrypt/RsaEncryptionParameters.cs

@@ -0,0 +1,34 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace SafeCrypt.RsaEncryption
+{
+    public sealed class RsaEncryptionParameters : IEncryptionData
+    {
+        /// <summary>
+        /// Gets or sets the public key for RSA encryption.
+        /// </summary>
+        [Required]
+        public string PublicKey { get; set; }       
+
+        /// <summary>
+        /// Gets or sets the data to be encrypted using RSA.
+        /// </summary>
+        [Required]
+        public string DataToEncrypt { get; set; }
+    }
+
+    public sealed class RsaDecryptionParameters 
+    {
+        /// <summary>
+        /// Gets or sets the public key for RSA encryption.
+        /// </summary>
+        [Required]
+        public string PrivateKey { get; set; }
+
+        /// <summary>
+        /// Gets or sets the data to be encrypted using RSA.
+        /// </summary>
+        [Required]
+        public byte[] DataToDecrypt { get; set; }
+    }
+}