C# Rfc2898DeriveBytes.Dispose方法代碼示例

        private static byte[] AESEncryptData(byte[] Data, byte[] key, byte[] IVSeed)
        {
            byte[] retByte;

            using (Aes encryptor = Aes.Create())
            {
                Rfc2898DeriveBytes rfcDBGen = new Rfc2898DeriveBytes(key, IVSeed, 128);
                encryptor.IV = rfcDBGen.GetBytes(16);
                encryptor.Key = rfcDBGen.GetBytes(32);
                rfcDBGen.Dispose();
                using(MemoryStream ms = new MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(Data, 0, Data.Length);
                        cs.Close();
                    }
                    retByte = ms.ToArray();
                }
            }

            return retByte;
        }

		/// <summary>
		/// Computes the "Hi()"-formula which is part of the client's response
		/// to the server challenge.
		/// </summary>
		/// <param name="password">The supplied password to use.</param>
		/// <param name="salt">The salt received from the server.</param>
		/// <param name="count">The iteration count.</param>
		/// <returns>An array of bytes containing the result of the computation of the
		/// "Hi()"-formula.</returns>
		/// <remarks>
		/// Hi is, essentially, PBKDF2 with HMAC as the pseudorandom function (PRF) and with
		/// dkLen == output length of HMAC() == output length of H(). (Refer to RFC 5802, p.6)
		/// </remarks>
		private byte[] Hi(string password, string salt, int count) {
			// The salt is sent by the server as a base64-encoded string.
			byte[] saltBytes = Convert.FromBase64String(salt);
			// Annoyingly, Rfc2898DeriveBytes only implements IDisposable in .NET 4 and upwards.
			var db = new Rfc2898DeriveBytes(password, saltBytes, count);
			try {
				// Generate 20 key bytes, which is the size of the hash result of SHA-1.
				return db.GetBytes(20);
			} finally {
#if !NET35
				if(db != null)
					db.Dispose();
#endif
			}
		}

        static DeepLinkHelper()
        {
            const string Password = "aGD4d&%SS1&gFd&F!";
            const string SaltString = "[email protected]%f&!hg8asH2J7";

            var salt = Encoding.UTF8.GetBytes(SaltString);

            using (var encryptionAlgorithm = new AesManaged())
            {
                BlockSize = encryptionAlgorithm.LegalBlockSizes[0].MaxSize;
                KeySize = encryptionAlgorithm.LegalKeySizes[0].MaxSize;
            }

            Rfc2898DeriveBytes keyGenerator = null;

            try
            {
                keyGenerator = new Rfc2898DeriveBytes(Password, salt);
                Key = keyGenerator.GetBytes(KeySize / 8);
                InitializationVector = keyGenerator.GetBytes(BlockSize / 8);
            }
            finally
            {
#if !SILVERLIGHT
                if (keyGenerator != null)
                {
                    keyGenerator.Dispose();
                }
#endif
            }
        }

        private byte[] Hi(string password, string salt, int count)
        {
            byte[] saltBytes = Convert.FromBase64String(salt);

            var db = new Rfc2898DeriveBytes(password, saltBytes, count);
            try
            {
                return db.GetBytes(20);
            }
            finally
            {
            #if !NET35
                if (db != null)
                {
                    db.Dispose();
                }
            #endif
            }
        }

    //This area contains all static methods.
    //This method uses the rfc2898 hash class to hash the users password.
    public static Client hashPassword(Client user)
    {
        //tries to perform hash and catches null string
        try
        {
            const int SALT_SIZE = 16;
            byte[] saltInBytes = new byte[SALT_SIZE];

            //Creates a random salt.
            new RNGCryptoServiceProvider().GetBytes(saltInBytes);
            user.Salt = saltInBytes;

            //Generates hash with 16 byte salt, and 10000 iterations
            Rfc2898DeriveBytes hash1 = new Rfc2898DeriveBytes(user.password, saltInBytes, ITERATIONS);

            //Gets the hashed object.
            byte[] hash = hash1.GetBytes(20);

            user.Password = Convert.ToBase64String(hash);

            hash1.Dispose();
            //Returns the user with hashed password and salt assigned.
            return user;

            #region Zach's MD5 Hashing Algorithm
            ////holder for return text
            //string returnText;
            ////converts input text into bytes
            //byte[] textbytes = System.Text.Encoding.Default.GetBytes(password);
            ////creates hash object
            //System.Security.Cryptography.MD5 hash = System.Security.Cryptography.MD5.Create();
            ////gets hashed text as a string
            //returnText = System.Text.Encoding.Default.GetString(hash.ComputeHash(textbytes));
            ////cleans up
            //hash.Dispose();
            ////returns holder for hashed text
            //return returnText; 
            #endregion
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
            return null;
        }
    }

 /// <summary>
 /// Computes the PBKDF2-SHA1 hash of a password.
 /// </summary>
 /// <param name="password">The password to hash.</param>
 /// <param name="salt">The salt.</param>
 /// <param name="iterations">The PBKDF2 iteration count.</param>
 /// <param name="outputBytes">The length of the hash to generate, in bytes.</param>
 /// <returns>A hash of the password.</returns>
 private static byte[] PBKDF2(string password, byte[] salt, int iterations, int outputBytes)
 {
     Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, salt);
     pbkdf2.IterationCount = iterations;
     byte[] rtn = pbkdf2.GetBytes(outputBytes);
     pbkdf2.Dispose();
     return rtn;
 }