C# SHA256Managed.Initialize方法代码示例

 public static byte[] SHA256(string str)
 {
     SHA256 sha = new SHA256Managed();
     sha.Initialize();
     //return sha.ComputeHash(str.ToByteArray());
     return sha.ComputeHash(Encoding.UTF8.GetBytes(str));
 }

 public static String hashString(String text)
 {
     SHA256 hasher = new SHA256Managed();
     hasher.Initialize();
     byte[] bytes = Encoding.Unicode.GetBytes(text);
     byte[] hash = hasher.ComputeHash(bytes);
     return BitConverter.ToString(hash).Replace("-", String.Empty);
 }

 //Shy Ronnie
 private static string Sha256(string s)
 {
     var sh = new SHA256Managed();
     var request = Encoding.UTF8.GetBytes(s);
     sh.Initialize();
     var b4Bbuff = sh.ComputeHash(request, 0, request.Length);
     var b64 = Convert.ToBase64String(b4Bbuff);
     return b64.Substring(0, 43);
 }

        public static string CalculateFingerprintHash(string fingerprint)
        {
            SHA256Managed sh = new SHA256Managed();
            byte[] request = UTF8Encoding.UTF8.GetBytes(fingerprint);

            sh.Initialize();
            byte[] hash = sh.ComputeHash(request, 0, request.Length);

            return Convert.ToBase64String(hash);
        }

        public byte[] GetHash(string password)
        {
            var passwordData = Encoding.Unicode.GetBytes(password);
            var toHashData = new byte[passwordData.Length + PasswordSalt.Length];
            passwordData.CopyTo(toHashData, 0);
            PasswordSalt.CopyTo(toHashData, passwordData.Length);

            var sha1 = new SHA256Managed();
            sha1.Initialize();
            return sha1.ComputeHash(toHashData);
        }

        public static String GenerateHash(String password)
        {
            //WARNING: This code does not reflect best practice.  It is a simplistic implementation designed to introduce the concept of hashing.
            password = "$$$$$" + password + "$#!%^";
            var pwdBytes = Encoding.UTF8.GetBytes(password);

            SHA256 hashAlg = new SHA256Managed();
            hashAlg.Initialize();
            var hashedBytes = hashAlg.ComputeHash(pwdBytes);
            var hash = Convert.ToBase64String(hashedBytes);
            return hash;
        }

 public User CreateNew(NewUser model)
 {
     using (var contextAccessor = new WriteContextAccessor())
     {
         SHA256Managed sha = new SHA256Managed();
         sha.Initialize();
         var user = new User
         {
             Name = model.UserName,
             PasswordHash = sha.ComputeHash(Encoding.UTF8.GetBytes(model.Password)).ToHexString()
         };
         contextAccessor.ReadWriteContext.Users.Add(user);
         contextAccessor.ReadWriteContext.SaveChanges();
         return user;
     }
 }

        //===============================================================
        // Function: SHA256HashPassword
        //===============================================================
        private string SHA256HashPassword(string password)
        {
            SHA256Managed hashProvider;
            Byte[] passwordBytes;
            //Byte[] hashBytes;

            passwordBytes = System.Text.Encoding.Unicode.GetBytes(password);
            hashProvider = new SHA256Managed();
            hashProvider.Initialize();
            passwordBytes = hashProvider.ComputeHash(passwordBytes);
            string hashedPassword = Convert.ToBase64String(passwordBytes);

            return hashedPassword;
        }

        public static byte[] GetBytes(byte[] password, byte[] salt, int iterations, int howManyBytes)
        {
            // round up

            uint cBlocks = (uint)((howManyBytes+ HASH_SIZE_IN_BYTES-1)/HASH_SIZE_IN_BYTES);

            // seed for the pseudo-random fcn: salt + block index
            byte[] saltAndIndex = new byte[salt.Length + 4];
            Array.Copy(salt, 0, saltAndIndex, 0, salt.Length);

            byte[] output = new byte[cBlocks*HASH_SIZE_IN_BYTES];
            int outputOffset = 0;

            SHA256Managed innerHash = new SHA256Managed();
            SHA256Managed outerHash = new SHA256Managed();

            // HMAC says the key must be hashed or padded with zeros
            // so it fits into a single block of the hash in use
            if (password.Length > BLOCK_SIZE_IN_BYTES) {
                password = innerHash.ComputeHash(password);
            }
            byte[] key = new byte[BLOCK_SIZE_IN_BYTES];
            Array.Copy(password, 0, key, 0, password.Length);

            byte[] InnerKey = new byte[BLOCK_SIZE_IN_BYTES];
            byte[] OuterKey = new byte[BLOCK_SIZE_IN_BYTES];
            for (int i = 0; i < BLOCK_SIZE_IN_BYTES; ++i) {
                InnerKey[i] = (byte)(key[i] ^ IPAD);
                OuterKey[i] = (byte)(key[i] ^ OPAD);
            }

            // for each block of desired output
            for (int iBlock = 0; iBlock < cBlocks; ++iBlock) {
                // seed HMAC with salt & block index
                _incrementBigEndianIndex(saltAndIndex, salt.Length);
                byte[] U = saltAndIndex;

                for (int i = 0; i < iterations; ++i) {
                    // simple implementation of HMAC-SHA-256
                    innerHash.Initialize();
                    innerHash.TransformBlock(InnerKey, 0,
                        BLOCK_SIZE_IN_BYTES, InnerKey, 0);
                    innerHash.TransformFinalBlock(U, 0, U.Length);

                    byte[] temp = innerHash.Hash;

                    outerHash.Initialize();
                    outerHash.TransformBlock(OuterKey, 0,
                        BLOCK_SIZE_IN_BYTES, OuterKey, 0);
                    outerHash.TransformFinalBlock(temp, 0, temp.Length);

                    U = outerHash.Hash; // U = result of HMAC

                    // xor result into output buffer
                    _xorByteArray(U, 0, HASH_SIZE_IN_BYTES,
                        output, outputOffset);
                }
                outputOffset += HASH_SIZE_IN_BYTES;
            }
            byte[] result = new byte[howManyBytes];
            Array.Copy(output, 0, result, 0, howManyBytes);
            return result;
        }

        public static string GetJWT(string clientEmail, RSACryptoServiceProvider privateKey, DateTime now) {
            var payload = new {
                scope = scope,
                iss = clientEmail,
                aud = "https://accounts.google.com/o/oauth2/token",
                exp = (int)(now - zeroDate + TimeSpan.FromHours(1)).TotalSeconds,
                iat = (int)(now - zeroDate).TotalSeconds,
                //sub = "[email protected]",
            };

            string serializedPayload = JsonConvert.SerializeObject(payload);

            using (var hashAlg = new SHA256Managed()) {
                hashAlg.Initialize();
                var headerAndPayload = UrlBase64Encode(serializedHeader) + "." + UrlBase64Encode(serializedPayload);
                var headerPayloadBytes = Encoding.ASCII.GetBytes(headerAndPayload);
                var signature = UrlBase64Encode(privateKey.SignData(headerPayloadBytes, hashAlg));
                return headerAndPayload + "." + signature;
            }

        }

 /// <summary>
 /// Encrypts a given string (password) using the SHA1 cryptography algorithm
 /// </summary>
 /// <param name="password">string (passowrd) to encrypt</param>
 /// <returns>Encrypted hash for the supplied string (password)</returns>
 public string HashPassword(string password)
 {
     Byte[] passwordBytes = Encoding.Unicode.GetBytes(password);
     SHA256Managed hashProvider = new SHA256Managed();
     hashProvider.Initialize();
     passwordBytes = hashProvider.ComputeHash(passwordBytes);
     hashProvider.Clear();
     return Convert.ToBase64String(passwordBytes);
 }

 //Create a string from the input
 private static string Hash(string url)
 {
     byte[] result;
     SHA256 shaM = new SHA256Managed();
     byte[] ms = new byte[url.Length];
     for (int i = 0; i < url.Length; i++)
     {
         byte b = Convert.ToByte(url[i]);
         ms[i] = (b);
     }
     shaM.Initialize();
     result = shaM.ComputeHash(ms, 0, ms.Length);
     return BitConverter.ToString(result);
 }