using System;

​

using System.ComponentModel;

using System.IO;

using System.Security.Cryptography;

using System.Text;

public class Program

{

    public static void Main()

    {

        var passwordToCheck = "monMotDePasse2020";

​

            var passwordFormatInDb = PasswordFormat.Hashed;

            var passwordInDb = "48DD9F3C18A5A37FA050CBA645701B2ED228DF3A";

            var saltKeyInDb = "DUAGmGc=";

​

            // Check Password     

            var customerService = new CustomerService();

            var isValid = customerService.ValidatePassword(passwordToCheck, passwordInDb, passwordFormatInDb, saltKeyInDb);

​

            Console.WriteLine("Password is valid " + isValid);

    }

    public enum PasswordFormat

    {

        Clear = 0,

        Hashed = 1,

        Encrypted = 2

    }

​

    public class CustomerService

    {

        private static EncryptionService _encryptionService = new EncryptionService();

        private const string HashedPasswordFormat = "SHA1";

​

        public bool ValidatePassword(string passwordToCheck, string passwordInDb, PasswordFormat passwordFormatInDb, string saltKeyInDb = null)

        {

            switch (passwordFormatInDb)

            {

                case PasswordFormat.Clear:

                    return passwordInDb == passwordToCheck;

                case PasswordFormat.Encrypted:

                    return passwordInDb == _encryptionService.EncryptText(passwordToCheck);

                case PasswordFormat.Hashed:

                    {

                        return passwordInDb == _encryptionService.CreatePasswordHash(passwordToCheck, saltKeyInDb, HashedPasswordFormat);

                    }

                default:

                    throw new InvalidEnumArgumentException("PasswordFormat must be one of Clear = 0 or Hashed = 1 or Encrypted = 2");

            }

        }

    }

​

    public class EncryptionService

    {

        private const string ENCRYPTION_KEY = "8410894616317067";

​

        /// <summary>

        /// Create a password hash

        /// </summary>

        /// <param name="password">{assword</param>

        /// <param name="saltkey">Salk key</param>

        /// <param name="passwordFormat">Password format (hash algorithm)</param>

        /// <returns>Password hash</returns>

        public virtual string CreatePasswordHash(string password, string saltkey, string passwordFormat = "SHA1")

        {

            return CreateHash(Encoding.UTF8.GetBytes(String.Concat(password, saltkey)), passwordFormat);

        }

​

        /// <summary>

        /// Create a data hash

        /// </summary>

        /// <param name="data">The data for calculating the hash</param>

        /// <param name="hashAlgorithm">Hash algorithm</param>

        /// <returns>Data hash</returns>

        public virtual string CreateHash(byte[] data, string hashAlgorithm = "SHA1")

        {

            if (String.IsNullOrEmpty(hashAlgorithm))

                hashAlgorithm = "SHA1";

​

            //return FormsAuthentication.HashPasswordForStoringInConfigFile(saltAndPassword, passwordFormat);

            var algorithm = HashAlgorithm.Create(hashAlgorithm);

            if (algorithm == null)

                throw new ArgumentException("Unrecognized hash name");

​

            var hashByteArray = algorithm.ComputeHash(data);

            return BitConverter.ToString(hashByteArray).Replace("-", "");

        }

​

        /// <summary>

        /// Encrypt text

        /// </summary>

        /// <param name="plainText">Text to encrypt</param>

        /// <param name="encryptionPrivateKey">Encryption private key</param>

        /// <returns>Encrypted text</returns>

        public virtual string EncryptText(string plainText, string encryptionPrivateKey = "")

        {

            if (string.IsNullOrEmpty(plainText))

                return plainText;

​

            if (String.IsNullOrEmpty(encryptionPrivateKey))

                encryptionPrivateKey = ENCRYPTION_KEY;

​

            var tDESalg = new TripleDESCryptoServiceProvider();

            tDESalg.Key = Encoding.ASCII.GetBytes(encryptionPrivateKey.Substring(0, 16));

            tDESalg.IV = Encoding.ASCII.GetBytes(encryptionPrivateKey.Substring(8, 8));

​

            byte[] encryptedBinary = EncryptTextToMemory(plainText, tDESalg.Key, tDESalg.IV);

            return Convert.ToBase64String(encryptedBinary);

        }

​

        #region Utilities

​

        private byte[] EncryptTextToMemory(string data, byte[] key, byte[] iv)

        {

            using (var ms = new MemoryStream())

            {

                using (var cs = new CryptoStream(ms, new TripleDESCryptoServiceProvider().CreateEncryptor(key, iv), CryptoStreamMode.Write))

                {

                    byte[] toEncrypt = Encoding.Unicode.GetBytes(data);

                    cs.Write(toEncrypt, 0, toEncrypt.Length);

                    cs.FlushFinalBlock();

                }

​

                return ms.ToArray();

            }

        }

​

        public virtual string CreateSaltKey(int size)

        {

            // Generate a cryptographic random number

            var rng = new RNGCryptoServiceProvider();

            var buff = new byte[size];

            rng.GetBytes(buff);

​

            // Return a Base64 string representation of the random number

            return Convert.ToBase64String(buff);

        }

        #endregion

    }

}