internal static string GenerateHash(this string input)
 {
     HashAlgorithm hashAlgorithm = new SHA256CryptoServiceProvider();
     var byteValue = System.Text.Encoding.UTF8.GetBytes(input);
     var byteHash = hashAlgorithm.ComputeHash(byteValue);
     return Convert.ToBase64String(byteHash);
 }

 /// <summary>
 /// Hashes the specified arguments.
 /// </summary>
 /// <param name="args">The arguments.</param>
 /// <returns>The hash</returns>
 public static string Hash(params object[] args)
 {
     HashAlgorithm hashAlg = new SHA256CryptoServiceProvider();
     byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(String.Concat(args));
     byte[] bytHash = hashAlg.ComputeHash(bytValue);
     return Convert.ToBase64String(bytHash);
 }

 protected string GenerateCacheKeyHash(int tabId, string cacheKey)
 {
     byte[] hash = Encoding.ASCII.GetBytes(cacheKey);
     var sha256 = new SHA256CryptoServiceProvider();
     hash = sha256.ComputeHash(hash);
     return string.Concat(tabId.ToString(), "_", ByteArrayToString(hash));
 }

 private String EncriptarPassword(String password)
 {
     byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
     SHA256 sha256 = new SHA256CryptoServiceProvider();
     byte[] hashedPassword = sha256.ComputeHash(passwordBytes);
     return BitConverter.ToString(hashedPassword).Replace("-","");
 }

 public static string Encrypt(string clearText)
 {
     byte[] arrbyte = new byte[clearText.Length];
     SHA256 hash = new SHA256CryptoServiceProvider();
     arrbyte = hash.ComputeHash(Encoding.UTF8.GetBytes(clearText));
     return Convert.ToBase64String(arrbyte);
 }

 public static HashAlgorithm GetHashProvider(HashType type)
 {
     HashAlgorithm hash = null;
     switch (type)
     {
         case HashType.MD5:
             {
                 hash = new MD5CryptoServiceProvider();
                 break;
             }
         case HashType.SHA1:
             {
                 hash = new SHA1CryptoServiceProvider();
                 break;
             }
         case HashType.SHA256:
             {
                 hash = new SHA256CryptoServiceProvider();
                 break;
             }
         case HashType.SHA384:
             {
                 hash = new SHA384CryptoServiceProvider();
                 break;
             }
         case HashType.SHA512:
             {
                 hash = new SHA512CryptoServiceProvider();
                 break;
             }
     }
     return hash;
 }

 public static string HashStringSHA256(string valueUTF8)
 {
     byte[] valueBytes = Encoding.UTF8.GetBytes(valueUTF8);
     SHA256CryptoServiceProvider shar2 = new SHA256CryptoServiceProvider();
     byte[] hashBytes = shar2.ComputeHash(valueBytes);
     return BitConverter.ToString(hashBytes).Replace("-", "");
 }

        public string CreateDoctorAcccount(string email, string dname, string pwd, string cfmpwd, string mobileno, string dob, string pip)
        {
            if (dname.Length == 0)
                returnMessage += "Therapist Name cannot be blank <br />";
            if (pwd.Length == 0)
                returnMessage += "Password cannot be blank <br/>";
            if (cfmpwd.Length == 0)
                returnMessage += "Cofirm Passowrd cannot be blank <br/>";
            if (mobileno.Length == 0)
                returnMessage += "Mobile Number cannot be blank <br/>";
            if (dob.Length == 0)
                returnMessage += "Date of Birth cannnot be blank <br/>";
            if (pip.Length == 0)
                returnMessage += "Please Upload an image <br/>";
            if (pwd != cfmpwd)
                returnMessage += "Your passwords dont match <br/>";

            if (returnMessage.Length == 0)
            {
                SHA256 sha = new SHA256CryptoServiceProvider();
                byte[] data = Encoding.ASCII.GetBytes(pwd);
                byte[] result = sha.ComputeHash(data);
                string hashedpwd = Convert.ToBase64String(result);
                AzureUserDAL doc = new AzureUserDAL(email, dname, hashedpwd, mobileno, dob, pip);
                int noofRows = 0;
                noofRows = doc.CreateDoctorProfile();

                if (noofRows > 0)
                    returnMessage = "You Signed Up Succuesfully.";
                else
                    returnMessage = "Error,Please try again";

            }
            return returnMessage;
        }

        public static string HashPassword(string password, string saltValue)
        {
            if (String.IsNullOrEmpty(password)) throw new ArgumentException("Password is null");

            var encoding = new UnicodeEncoding();
            var hash = new SHA256CryptoServiceProvider();

            if (saltValue == null)
            {
                saltValue = GenerateSaltValue();
            }

            byte[] binarySaltValue = Convert.FromBase64String(saltValue);
            byte[] valueToHash = new byte[SaltValueSize + encoding.GetByteCount(password)];
            byte[] binaryPassword = encoding.GetBytes(password);

            binarySaltValue.CopyTo(valueToHash, 0);
            binaryPassword.CopyTo(valueToHash, SaltValueSize);

            byte[] hashValue = hash.ComputeHash(valueToHash);
            var hashedPassword = String.Empty;
            foreach (byte hexdigit in hashValue)
            {
                hashedPassword += hexdigit.ToString("X2", CultureInfo.InvariantCulture.NumberFormat);
            }

            return hashedPassword;
        }

        public static string GenerateToken(string @namespace, string eventHub, string publisher, string sharedAccessKeyName, string sharedAccessKey, DateTimeOffset expiry)
        {
            var unixEpoch = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero);
            var timeSinceEpoch = expiry - unixEpoch;
            var timeSinceEpochInMilliseconds = (long)timeSinceEpoch.TotalMilliseconds;

            var url = Helper.BuildUrl(@namespace, eventHub, publisher);
            var encodedUrl = HttpUtility.UrlEncode(url);
            var signatureContent = string.Format("{0}\n{1}", encodedUrl, timeSinceEpochInMilliseconds);

            var signatureContentAsBytes = Encoding.UTF8.GetBytes(signatureContent);
            var provider = new SHA256CryptoServiceProvider();
            var signatureAsBytes = provider.ComputeHash(signatureContentAsBytes);
            var signature = Convert.ToBase64String(signatureAsBytes);

            var token = string.Format(
                "sr={0}&sig={1}&se={2}&skn={3}",
                HttpUtility.UrlEncode(url),
                HttpUtility.UrlEncode(signature),
                timeSinceEpochInMilliseconds,
                HttpUtility.UrlEncode(sharedAccessKeyName)
                );

            return token;
        }

 public static void Signature(Stream input, Stream output, string privateKey)
 {
     using (var sha = new SHA256CryptoServiceProvider())
     using (var rsa = new RSACryptoServiceProvider())
     {
         // Compute hash
         var buffer = ReadAllBytes(input);
         var hash = sha.ComputeHash(buffer);
         // RSA Initialize
         rsa.FromXmlString(privateKey);
         // format
         var formatter = new RSAPKCS1SignatureFormatter(rsa);
         formatter.SetHashAlgorithm("SHA256");
         var signature = formatter.CreateSignature(hash);
         // Krile Signature Package
         var magic = MagicStr + ":" + signature.Length + ":";
         var magicbytes = Encoding.UTF8.GetBytes(magic);
         if (magicbytes.Length > 64)
             throw new Exception("Magic bits too long.");
         output.Write(magicbytes, 0, magicbytes.Length);
         var padding = new byte[64 - magicbytes.Length];
         output.Write(padding, 0, padding.Length);
         output.Write(signature, 0, signature.Length);
         output.Write(buffer, 0, buffer.Length);
     }
 }

 public static string SHA256(string str)
 {
     byte[] buffer = Encoding.UTF8.GetBytes(str);
     SHA256CryptoServiceProvider SHA256 = new SHA256CryptoServiceProvider();
     byte[] byteArr = SHA256.ComputeHash(buffer);
     return BitConverter.ToString(byteArr);
 }

 public static string Hash(this string clear_text)
 {
     using (HashAlgorithm hash = new SHA256CryptoServiceProvider())
     {
         return Convert.ToBase64String(hash.ComputeHash(Encoding.UTF8.GetBytes(clear_text)));
     }
 }

        private NewPassword HashPassword(NewPassword np)
        {
            HashAlgorithm hashAlg = null;

            try
            {
                hashAlg = new SHA256CryptoServiceProvider();
                byte[] bytValue = System.Text.Encoding.UTF8.GetBytes(np.GetSaltPassword());
                byte[] bytHash = hashAlg.ComputeHash(bytValue);
                np.SaltedHashedPassword = Convert.ToBase64String(bytHash);
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                if (hashAlg != null)
                {
                    hashAlg.Clear();
                    hashAlg.Dispose();
                    hashAlg = null;
                }
            }

            return np;
        }

 public static string CreateHashedPassword(string password, string salt)
 {
     var sha256 = new SHA256CryptoServiceProvider();
     byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password + salt);
     byte[] hashedPasswordBytes = sha256.ComputeHash(passwordBytes);
     return Convert.ToBase64String(hashedPasswordBytes);
 }

        public static string Sha256(string text)
        {
            var bits = Encoding.UTF8.GetBytes(text);
            var hash = new SHA256CryptoServiceProvider().ComputeHash(bits);

            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }

        private HashAlgorithm GetHashAlgorithm(string hashType)
        {
            HashAlgorithm hash = null;
            string hashTypeLower = hashType.ToLowerInvariant();

            switch (hashTypeLower)
            {
                case "md5":
                    hash = new MD5CryptoServiceProvider();
                    break;
                case "ripemd160":
                    hash = new RIPEMD160Managed();
                    break;
                case "sha1":
                    hash = new SHA1CryptoServiceProvider();
                    break;
                case "sha256":
                    hash = new SHA256CryptoServiceProvider();
                    break;
                case "sha384":
                    hash = new SHA384CryptoServiceProvider();
                    break;
                case "sha512":
                    hash = new SHA512CryptoServiceProvider();
                    break;
                default:
                    break;
            }

            return hash;
        }

 private static string Hash(byte[] clearBuffer, HashAlgorithm algorithm)
 {
     System.Security.Cryptography.HashAlgorithm hashAlgorithm;
     switch (algorithm)
     {
         case HashAlgorithm.MD5:
             hashAlgorithm = new MD5CryptoServiceProvider();
             break;
         case HashAlgorithm.SHA1:
         default:
             hashAlgorithm = new SHA1CryptoServiceProvider();
             break;
         case HashAlgorithm.SHA256:
             hashAlgorithm = new SHA256CryptoServiceProvider();
             break;
         case HashAlgorithm.SHA384:
             hashAlgorithm = new SHA384CryptoServiceProvider();
             break;
         case HashAlgorithm.SHA512:
             hashAlgorithm = new SHA512CryptoServiceProvider();
             break;
     }
     var encryptedBuffer = hashAlgorithm.ComputeHash(clearBuffer);
     return Convert.ToBase64String(encryptedBuffer);
 }

        public static bool ValidatePathWithEncodedRSAPKCS1SignatureAndPublicRSAKey(string path, string base64Signature, string publicKey) {

            try {

                byte[] signature = Convert.FromBase64String(base64Signature);
                byte[] data = File.ReadAllBytes(path);
                SHA256CryptoServiceProvider cryptoTransformSHA256 = new SHA256CryptoServiceProvider();
                byte[] sha256Hash = cryptoTransformSHA256.ComputeHash(data);
                string cleanKey = "";

                string[] lines = publicKey.Split(new char[] {'\n', '\r'});

                foreach (string line in lines) {
                        cleanKey += line.Trim();
                }

                byte[] publicKeyData = Convert.FromBase64String(cleanKey);

                RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
                provider.ImportCspBlob(publicKeyData);
                RSAPKCS1SignatureDeformatter formatter = new RSAPKCS1SignatureDeformatter(provider);
                formatter.SetHashAlgorithm("SHA256");
                return formatter.VerifySignature(sha256Hash, signature);

            } catch (Exception ex) {
                Console.WriteLine(ex.Message);
                return false;
            }

        }

        public static string CalculateSha256(string text, Encoding enc)
        {
            byte[] buffer = enc.GetBytes(text);

            using (var cryptoTransformSha1 = new SHA256CryptoServiceProvider())
                return BitConverter.ToString(cryptoTransformSha1.ComputeHash(buffer)).Replace("-", "");
        }