C# SHA512Managed.ComputeHash方法代码示例

        public static void VerifySHA512Hash(byte[] bytesA, byte[] bytesB)
        {
            SHA512 shaM = new SHA512Managed();
            byte[] hashA = shaM.ComputeHash(bytesA);
            byte[] hashB = shaM.ComputeHash(bytesB);

            // Create a StringComparer an compare the hashes.
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            // Create a new Stringbuilder to collect the bytes
            // and create a string.
            StringBuilder hashAStringBuilder = new StringBuilder();
            StringBuilder hashBStringBuilder = new StringBuilder();

            // Loop through each byte of the hashed data
            // and format each one as a hexadecimal string.
            for (int i = 0; i < hashA.Length; i++)
            {
                hashAStringBuilder.Append(hashA[i].ToString("x2"));
            }

            string inputA = hashAStringBuilder.ToString();

            for (int i = 0; i < hashB.Length; i++)
            {
                hashBStringBuilder.Append(hashB[i].ToString("x2"));
            }

            string inputB = hashBStringBuilder.ToString();

            if (comparer.Compare(inputA, inputB) != 0)
            {
                Assert.Fail("Hash not match! Expected: '{0}', but was '{1}'", inputA, inputB);
            }
        }

 public string HashValue(string Value)
 {
     var hash = new SHA512Managed();
     byte[] result = hash.ComputeHash(Encoding.Unicode.GetBytes(Value));
     for (int i = 1; i <= _iterations; i++ )
     {
         result = hash.ComputeHash(result);
     }
     return Convert.ToBase64String(result);
 }

        //*************************
        //** Create An IV
        //*************************

        public static byte[] CreateRijndaelIVWithSHA512(string strPassword)
        {
            //Convert strPassword to an array and store in chrData.
            char[] chrData = strPassword.ToCharArray();
            //Use intLength to get strPassword size.
            int intLength = chrData.GetUpperBound(0);
            //Declare bytDataToHash and make it the same size as chrData.
            byte[] bytDataToHash = new byte[intLength + 1];

            //Use For Next to convert and store chrData into bytDataToHash.
            for (int i = 0; i <= chrData.GetUpperBound(0); i++) {
                bytDataToHash[i] = Convert.ToByte(Strings.Asc(chrData[i]));
            }

            //Declare what hash to use.
            System.Security.Cryptography.SHA512Managed SHA512 = new System.Security.Cryptography.SHA512Managed();
            //Declare bytResult, Hash bytDataToHash and store it in bytResult.
            byte[] bytResult = SHA512.ComputeHash(bytDataToHash);
            //Declare bytIV(15).  It will hold 128 bits.
            byte[] bytIV = new byte[16];

            //Use For Next to put a specific size (128 bits) of bytResult into bytIV.
            //The 0 To 30 for bytKey used the first 256 bits of the hashed password.
            //The 32 To 47 will put the next 128 bits into bytIV.
            for (int i = 32; i <= 47; i++) {
                bytIV[i - 32] = bytResult[i];
            }

            return bytIV;
            //Return the IV.
        }

        // Add User buttonin logiikka
        private void btn_addUser_Click(object sender, RoutedEventArgs e)
        {
            if (tb_password1.Password == tb_password2.Password && tb_password1.Password != "" && tb_password2.Password != "" && tb_username.Text != "") // Tarkistetaan että kentät on täytetty oikein.
            {

                SHA512 sha512 = new SHA512Managed();                    // SHA512 cryptaus pitäisi riittää.
                UTF8Encoding utf8 = new UTF8Encoding();                 // SHA512 ottaa byte arrayn joten string täytyy muuttaa ennen kryptausta.
                String password = BitConverter.ToString(sha512.ComputeHash(utf8.GetBytes(tb_password1.Password)));  // Aika monimutkainen rivi joka muuttaa string byte arrayksi ja kryptaa sen

                string dbConnectionString = @"Data Source=database.db;Version=3;";               // Määritellään sqlite tietokannan nimeksi database.db ja versioksi 3.
                SQLiteConnection sqliteCon = new SQLiteConnection(dbConnectionString);           // Tehdään yhteys olio sqliteCon jota voidaan käyttää myöhemmin.
                try
                {
                    sqliteCon.Open();                                                            // Avataan sqlite yhteys
                    string Query = "INSERT INTO users (username, password) VALUES('" + this.tb_username.Text + "','" + password + "') ";    // Syötetään uuden käyttäjän tiedot tietokantaan. Huom. kryptattu salasana.
                    SQLiteCommand createCommand = new SQLiteCommand(Query, sqliteCon);           // Tehdään SQlite komento query ja sqlitecon argumenteilla.
                    createCommand.ExecuteNonQuery();                                             // Suoritetaan query.
                    sqliteCon.Close();                                                           // Suljetaan db yhteys.

                    tb_username.Text = "";                                                       // Tyhjennetään kentät ettei vahingossa upita samoja tietoja uudestaan
                    tb_password1.Password = "";
                    tb_password2.Password = "";
                    MessageBox.Show("User added successfully!");                                 // Ilmoitus käyttäjälle onnistumisesta.
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);                                                 // Tai epäonnistumisesta.
                }
            }
            else
            {
                MessageBox.Show("Oops, check the fields.");                                      // Kaikki kentät pitää täyttää, ja vieläpä oikein.
            }
        }

        /// <summary>
        /// Creates a new sum proof.
        /// </summary>
        /// <param name="r">The randomness used to encrypt the vote.</param>
        /// <param name="voteSum">The sum of all votes for which to generate a proof.</param>
        /// <param name="publicKey">The public key with which the vote was encrypted.</param>
        /// <param name="parameters">Cryptographic Parameters.</param>
        public Proof(BigInt r, Vote voteSum, BigInt publicKey, BaseParameters parameters)
        {
            if (r == null)
            throw new ArgumentNullException("r");
              if (voteSum == null)
            throw new ArgumentNullException("vote");
              if (publicKey == null)
            throw new ArgumentNullException("publicKey");
              if (parameters == null)
            throw new ArgumentNullException("parameters");

              BigInt r0 = parameters.Random();

              T0 = publicKey.PowerMod(r0, parameters.P);

              MemoryStream serializeStream = new MemoryStream();
              SerializeContext serializer = new SerializeContext(serializeStream);
              serializer.Write(voteSum.Ciphertext);
              serializer.Write(voteSum.HalfKey);
              serializer.Write(publicKey);
              serializer.Write(T0);
              serializer.Close();
              serializeStream.Close();

              SHA512Managed sha512 = new SHA512Managed();
              byte[] hash = sha512.ComputeHash(serializeStream.ToArray());
              C0 = hash[0] | (hash[1] << 8);

              S0 = r0 + r * C0;
        }

 /// <summary>
 /// Creates a SHA512 hash of a string
 /// </summary>
 /// <param name="text"></param>
 /// <param name="salt"></param>
 /// <param name="extraHashKey"></param>
 /// <returns></returns>
 public static string HashSha512(string text, string salt, string extraHashKey = "")
 {
     using (SHA512 shaM = new SHA512Managed())
     {
         return Convert.ToBase64String(shaM.ComputeHash(System.Text.Encoding.UTF8.GetBytes(text + extraHashKey + salt)));
     }
 }

 private byte[] MakeHash(byte[] data)
 {
     using (var sha512Hash = new SHA512Managed())
     {
         return sha512Hash.ComputeHash(data);
     }
 }

        public void CreateUser(UserInfo userInfo)
        {
            if (userInfo == null)
            {
                throw new ArgumentNullException(nameof(userInfo));
            }
            if (string.IsNullOrWhiteSpace(userInfo.Username))
            {
                throw new ArgumentNullException(nameof(userInfo.Username));
            }

            if (string.IsNullOrWhiteSpace(userInfo.Password))
            {
                throw new ArgumentNullException(nameof(userInfo.Password));
            }

            if (UsernameExists(userInfo.Username))
            {
                throw new Exception("Username already exists, please enter a different username");
            }

            using (var shazam = new SHA512Managed())
            {
                var salt = GenerateSaltValue();
                var passwordAndSalt = userInfo.Password + salt;
                var hashedPassword = Encoding.UTF8.GetString(shazam.ComputeHash(Encoding.UTF8.GetBytes(passwordAndSalt)));
                userInfo.Password = hashedPassword;
                userInfo.Salt = salt;
                userDal.CreateUser(userInfo);
            }
        }

 public static string sha512encrypt(string phrase)
 {
     UTF8Encoding encoder = new UTF8Encoding();
     SHA512Managed sha512hasher = new SHA512Managed();
     byte[] hashedDataBytes = sha512hasher.ComputeHash(encoder.GetBytes(phrase));
     return byteArrayToString(hashedDataBytes);
 }

        public HttpResponseMessage Register(User user)
        {
            if (!_validator.Validate(user.Password))
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest);
            }

            using (SHA512 sha = new SHA512Managed())
            {
                user.Password = BitConverter.ToString(sha.ComputeHash(Encoding.UTF8.GetBytes(user.Password))).Replace("-", string.Empty);
            }

            _db.Users.Add(user);
            if(_db.GetValidationErrors().Any())
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest);
            }

            try
            {
                _db.SaveChanges();
            }
            catch (DbUpdateException)
            {
                return Request.CreateResponse(HttpStatusCode.Conflict);
            }

            return Request.CreateResponse(HttpStatusCode.Created);
        }

        public byte[] CreateHashSha512(string userEnteredPw)
        {
            //userEnteredPw = userEnteredPw.Trim();
            SHA512Managed sha512 = new SHA512Managed();

            return sha512.ComputeHash(Encoding.UTF8.GetBytes(userEnteredPw));
        }

 private string GetPasswordHash(string stringPassword)
 {
     using (var sha512 = new SHA512Managed())
     {
         return BitConverter.ToString(sha512.ComputeHash(Encoding.Default.GetBytes(stringPassword)));
     }
 }

 public static string CalculateSha512Hash(string input)
 {
     var inputBytes = Encoding.UTF8.GetBytes(input);
     var hasher = new SHA512Managed();
     var hashBytes = hasher.ComputeHash(inputBytes);
     return BitConverter.ToString(hashBytes).Replace("-", string.Empty).ToLowerInvariant();
 }

 public static byte[] Hash(string s)
 {
     using (SHA512 shaM = new SHA512Managed())
     {
         return shaM.ComputeHash(Encoding.UTF8.GetBytes(s));
     }
 }

 public void Encryption2()
 {
     byte[] data = new byte[2];
     byte[] result;
     SHA512 shaM = new SHA512Managed();
     result = shaM.ComputeHash(data);
 }