C# Cryptography.SHA1CryptoServiceProvider类代码示例

 public static string Sha1(string text)
 {
     byte[] buffer = Encoding.UTF8.GetBytes(text);
     SHA1CryptoServiceProvider cryptoTransformSHA1 = new SHA1CryptoServiceProvider();
     byte[] outbuffer = cryptoTransformSHA1.ComputeHash(buffer);
     return Convert.ToBase64String(outbuffer);
 }

 /// <summary>
 /// Gets the SHA1 hash of a string.
 /// </summary>
 /// <param name="str">The string to be hashed.</param>
 /// <returns>The Base64 hashed value.</returns>
 public static string Sha1Hash(this string str)
 {
     using (var sha1 = new SHA1CryptoServiceProvider())
     {
         return Convert.ToBase64String(sha1.ComputeHash(Encoding.ASCII.GetBytes(str)));
     }
 }

 internal static byte[] ComputeFileHash(byte[] fileBytes)
 {
     using (var sha1 = new SHA1CryptoServiceProvider())
     {
         return sha1.ComputeHash(fileBytes);
     }
 }

        //
        // internal static methods
        //

        // CMS TripleDES KeyWrap as described in "http://www.w3.org/2001/04/xmlenc#kw-tripledes"
        internal static byte[] TripleDESKeyWrapEncrypt (byte[] rgbKey, byte[] rgbWrappedKeyData) {
            // checksum the key
            SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
            byte[] rgbCKS = sha.ComputeHash(rgbWrappedKeyData);

            // generate a random IV
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            byte[] rgbIV = new byte[8];
            rng.GetBytes(rgbIV);

            // rgbWKCS = rgbWrappedKeyData | (first 8 bytes of the hash)
            byte[] rgbWKCKS = new byte[rgbWrappedKeyData.Length + 8];
            TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
            // Don't add padding, use CBC mode: for example, a 192 bits key will yield 40 bytes of encrypted data
            tripleDES.Padding = PaddingMode.None;
            ICryptoTransform enc1 = tripleDES.CreateEncryptor(rgbKey, rgbIV);
            Buffer.BlockCopy(rgbWrappedKeyData, 0, rgbWKCKS, 0, rgbWrappedKeyData.Length);
            Buffer.BlockCopy(rgbCKS, 0, rgbWKCKS, rgbWrappedKeyData.Length, 8);
            byte[] temp1 = enc1.TransformFinalBlock(rgbWKCKS, 0, rgbWKCKS.Length);
            byte[] temp2 = new byte[rgbIV.Length + temp1.Length];
            Buffer.BlockCopy(rgbIV, 0, temp2, 0, rgbIV.Length);
            Buffer.BlockCopy(temp1, 0, temp2, rgbIV.Length, temp1.Length);
            // temp2 = REV (rgbIV | E_k(rgbWrappedKeyData | rgbCKS))
            Array.Reverse(temp2);

            ICryptoTransform enc2 = tripleDES.CreateEncryptor(rgbKey, s_rgbTripleDES_KW_IV);
            return enc2.TransformFinalBlock(temp2, 0, temp2.Length);
        }

		public static void Main(string[] args)
		{
			// Use Release Build to use jsc to generate java program
			// Use Debug Build to develop on .net

			// doubleclicking on the jar will not show the console

			{
				Console.WriteLine("SHA1:");
				var hash = new SHA1CryptoServiceProvider().ComputeHash(new byte[] { 0, 1, 2, 3 });

				foreach (var k in hash)
				{
					Console.Write(" " + k);
				}
				Console.WriteLine();
			}

			{
				Console.WriteLine("MD5:");
				var hash = new MD5CryptoServiceProvider().ComputeHash(new byte[] { 0, 1, 2, 3 });

				foreach (var k in hash)
				{
					Console.Write(" " + k);
				}
				Console.WriteLine();
			}

			Console.ReadLine();
		}

 public static string SHA1File(FileInfo fileInfo)
 {
     using (SHA1 sha1 = new SHA1CryptoServiceProvider())
     {
         return FileHash(fileInfo, sha1);
     }
 }

        private byte[] Sign(SHA1CryptoServiceProvider hash)
        {
            var formatter = new RSAPKCS1SignatureFormatter(_certificate.PrivateKey).
                Tap(it => it.SetHashAlgorithm("MD5"));

            return formatter.CreateSignature(hash);
        }

        public static int GenarateSinature(string sToken, string sTimeStamp, string sNonce, string sMsgEncrypt, ref string sMsgSignature)
        {
            ArrayList AL = new ArrayList();
            AL.Add(sToken);
            AL.Add(sTimeStamp);
            AL.Add(sNonce);
            AL.Add(sMsgEncrypt);
            AL.Sort(new DictionarySort());
            string raw = "";
            for (int i = 0; i < AL.Count; ++i)
            {
                raw += AL[i];
            }

            SHA1 sha;
            ASCIIEncoding enc;
            string hash = "";
            try
            {
                sha = new SHA1CryptoServiceProvider();
                enc = new ASCIIEncoding();
                byte[] dataToHash = enc.GetBytes(raw);
                byte[] dataHashed = sha.ComputeHash(dataToHash);
                hash = BitConverter.ToString(dataHashed).Replace("-", "");
                hash = hash.ToLower();
            }
            catch (Exception)
            {
                return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_ComputeSignature_Error;
            }
            sMsgSignature = hash;
            return 0;
        }

 /// <summary>
 /// Хэширует текст
 /// </summary>
 /// <param name="phrase"></param>
 /// <returns></returns>
 public static string Sha1EncryptPassword(string phrase)
 {
     var encoder = new UTF8Encoding();
     var sha1Hasher = new SHA1CryptoServiceProvider();
     var hashedDataBytes = sha1Hasher.ComputeHash(encoder.GetBytes(phrase));
     return ByteArrayToString(hashedDataBytes);
 }

        /// <summary> Private method used to calculate the sha1 check summ</summary>
        private void ComputeChecksum()
        {
            try
            {
                FileStream hashFile = new FileStream(fileName, FileMode.Open, FileAccess.Read);

                SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
                byte[] result = sha1.ComputeHash(hashFile);

                hashFile.Close();

                string buffer = "";
                foreach (byte thisByte in result)
                {
                    if (thisByte < 16)
                    {
                        buffer += "0" + thisByte.ToString("x");
                    }
                    else
                    {
                        buffer += thisByte.ToString("x");
                    }
                }
                hashResult = buffer;

                errorFlag = false;
            }
            catch
            {
                hashResult = "ERROR";
                errorFlag = true;
            }
        }

 public static string GetSHA1Checksum(byte[] inBytes)
 {
     using (SHA1CryptoServiceProvider _sha1CryptoServiceProvider = new SHA1CryptoServiceProvider())
     {
         return BitConverter.ToString(_sha1CryptoServiceProvider.ComputeHash(inBytes));
     }
 }

 public static string sha1encrypt(string phrase)
 {
     UTF8Encoding encoder = new UTF8Encoding();
     SHA1CryptoServiceProvider sha1hasher = new SHA1CryptoServiceProvider();
     byte[] hashedDataBytes = sha1hasher.ComputeHash(encoder.GetBytes(phrase));
     return byteArrayToString(hashedDataBytes);
 }

 /// <summary>
 /// SHA1加密 使用缺省密钥给字符串加密
 /// </summary>
 /// <param name="sourceString"></param>
 /// <returns></returns>
 public static string Sha1Encrypt(string sourceString)
 {
     var data = Encoding.Default.GetBytes(sourceString);
     HashAlgorithm sha = new SHA1CryptoServiceProvider();
     var bytes = sha.ComputeHash(data);
     return BitConverter.ToString(bytes).Replace("-", "");
 }

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

        static void Main(string[] args)
        {
            SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();

            Console.Write("Enter username: ");
            string username = Console.ReadLine().ToUpper();
            Console.Write("Enter password: ");
            string password = Console.ReadLine().ToUpper();

            string temp = username + ":" + password;

            byte[] temp2 = Encoding.ASCII.GetBytes(temp);

            sha.ComputeHash(temp2, 0, temp2.Length);

            string hash = String.Empty;

            for (int i = 0; i < sha.Hash.Length; i++)
            {
                hash += sha.Hash[i].ToString("X2");
            }

            Console.WriteLine("Hash: {0}", hash);
            Console.ReadKey();
        }