SimpleStringCipher.cs

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace APIJSON.Data;

public class SimpleStringCipher
{
    public static SimpleStringCipher Instance { get; }

    /// <summary>
    /// This constant string is used as a "salt" value for the PasswordDeriveBytes function calls.
    /// This size of the IV (in bytes) must = (keysize / 8).  Default keysize is 256, so the IV must be
    /// 32 bytes long.  Using a 16 character string here gives us 32 bytes when converted to a byte array.
    /// </summary>
    public byte[] InitVectorBytes;

    /// <summary>
    /// Default password to encrypt/decrypt texts.
    /// It's recommented to set to another value for security.
    /// Default value: "gsKnGZ041HLL4IM8"
    /// </summary>
    public static string DefaultPassPhrase { get; set; }

    /// <summary>
    /// Default value: Encoding.ASCII.GetBytes("jkE49230Tf093b42")
    /// </summary>
    public static byte[] DefaultInitVectorBytes { get; set; }

    /// <summary>
    /// Default value: Encoding.ASCII.GetBytes("hgt!16kl")
    /// </summary>
    public static byte[] DefaultSalt { get; set; }

    /// <summary>
    /// This constant is used to determine the keysize of the encryption algorithm.
    /// </summary>
    public const int Keysize = 256;

    static SimpleStringCipher()
    {
        DefaultPassPhrase = "gsKnGZ041HLL4IM9";
        DefaultInitVectorBytes = Encoding.ASCII.GetBytes("jkE49230Tf093b42");
        DefaultSalt = Encoding.ASCII.GetBytes("hgt!11kl");
        Instance = new SimpleStringCipher();
    }

    public SimpleStringCipher()
    {
        InitVectorBytes = DefaultInitVectorBytes;
    }

    public string Encrypt(string plainText, string passPhrase = null, byte[] salt = null)
    {
        if (plainText == null)
        {
            return null;
        }

        if (passPhrase == null)
        {
            passPhrase = DefaultPassPhrase;
        }

        if (salt == null)
        {
            salt = DefaultSalt;
        }

        var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
        using (var password = new Rfc2898DeriveBytes(passPhrase, salt))
        {
            var keyBytes = password.GetBytes(Keysize / 8);
            using (var symmetricKey = Aes.Create())
            {
                symmetricKey.Mode = CipherMode.CBC;
                using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, InitVectorBytes))
                {
                    using (var memoryStream = new MemoryStream())
                    {
                        using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                        {
                            cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
                            cryptoStream.FlushFinalBlock();
                            var cipherTextBytes = memoryStream.ToArray();
                            return Convert.ToBase64String(cipherTextBytes);
                        }
                    }
                }
            }
        }
    }

    public string Decrypt(string cipherText, string passPhrase = null, byte[] salt = null)
    {
        if (string.IsNullOrEmpty(cipherText))
        {
            return null;
        }

        if (passPhrase == null)
        {
            passPhrase = DefaultPassPhrase;
        }

        if (salt == null)
        {
            salt = DefaultSalt;
        }

        var cipherTextBytes = Convert.FromBase64String(cipherText);
        using (var password = new Rfc2898DeriveBytes(passPhrase, salt))
        {
            var keyBytes = password.GetBytes(Keysize / 8);
            using (var symmetricKey = Aes.Create())
            {
                symmetricKey.Mode = CipherMode.CBC;
                using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, InitVectorBytes))
                {
                    using (var memoryStream = new MemoryStream(cipherTextBytes))
                    {
                        using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                        {
                            var plainTextBytes = new byte[cipherTextBytes.Length];
                            var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
                            return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
                        }
                    }
                }
            }
        }
    }
}