C# SHA256CryptoServiceProvider.ComputeHash方法代码示例

        public static String SHA256Encrypt(String pwd)
        {
            //Encryption
            //SHA256
            //One-way hash
            //Password Token:
            // (hash(hash(userName+ pwd)+salt))

            String SALT ="buy2easy"; //
            SHA256CryptoServiceProvider provider = new SHA256CryptoServiceProvider();

            // pwd
            Byte[] inputByteArray = Encoding.UTF8.GetBytes(pwd);

            // salt
            Byte[] saltByteArray = Encoding.UTF8.GetBytes(SALT);

            // hash
            Byte[] hashedBytesArray1 = provider.ComputeHash(inputByteArray);

            // Combine salt and input bytes
            Byte[] inputBytesWithSalt = new Byte[hashedBytesArray1.Length + saltByteArray.Length];

            hashedBytesArray1.CopyTo(inputBytesWithSalt, 0);
            saltByteArray.CopyTo(inputBytesWithSalt, hashedBytesArray1.Length);

            // hash again
            Byte[] hashedBytesArray2 = provider.ComputeHash(inputBytesWithSalt);

            // return double hash encrypted string.
            return BitConverter.ToString(hashedBytesArray2);
        }

        public static byte[] Base58ToByteArray(string base58)
        {
            Org.BouncyCastle.Math.BigInteger bi2 = new Org.BouncyCastle.Math.BigInteger("0");
            string b58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

            bool IgnoreChecksum = false;

            foreach (char c in base58)
            {
                if (b58.IndexOf(c) != -1)
                {
                    bi2 = bi2.Multiply(new Org.BouncyCastle.Math.BigInteger("58"));
                    bi2 = bi2.Add(new Org.BouncyCastle.Math.BigInteger(b58.IndexOf(c).ToString()));
                }
                else if (c == '?')
                {
                    IgnoreChecksum = true;
                }
                else
                {
                    return null;
                }
            }

            byte[] bb = bi2.ToByteArrayUnsigned();

            // interpret leading '1's as leading zero bytes
            foreach (char c in base58)
            {
                if (c != '1') break;
                byte[] bbb = new byte[bb.Length + 1];
                Array.Copy(bb, 0, bbb, 1, bb.Length);
                bb = bbb;
            }

            if (bb.Length < 4) return null;

            if (IgnoreChecksum == false)
            {
                SHA256CryptoServiceProvider sha256 = new SHA256CryptoServiceProvider();
                byte[] checksum = sha256.ComputeHash(bb, 0, bb.Length - 4);
                checksum = sha256.ComputeHash(checksum);
                for (int i = 0; i < 4; i++)
                {
                    if (checksum[i] != bb[bb.Length - 4 + i]) return null;
                }
            }

            byte[] rv = new byte[bb.Length - 4];
            Array.Copy(bb, 0, rv, 0, bb.Length - 4);
            return rv;
        }

 /// <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);
 }

 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);
 }

 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 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 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 HashStringSHA256(string valueUTF8)
 {
     byte[] valueBytes = Encoding.UTF8.GetBytes(valueUTF8);
     SHA256CryptoServiceProvider shar2 = new SHA256CryptoServiceProvider();
     byte[] hashBytes = shar2.ComputeHash(valueBytes);
     return BitConverter.ToString(hashBytes).Replace("-", "");
 }

        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 string Hash(this string clear_text)
 {
     using (HashAlgorithm hash = new SHA256CryptoServiceProvider())
     {
         return Convert.ToBase64String(hash.ComputeHash(Encoding.UTF8.GetBytes(clear_text)));
     }
 }

 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);
 }

        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 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;
        }