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

 /// <summary>
 /// 引用证书非对称加/解密RSA-公钥验签【OriginalString：原文；SignatureString：签名字符；pubkey_path：证书路径；CertificatePW：证书密码；SignType：签名摘要类型（1：MD5，2：SHA1）】
 /// </summary>
 public static bool CerRSAVerifySignature(string OriginalString, string SignatureString, string pubkey_path, string CertificatePW, int SignType)
 {
     byte[] OriginalByte = System.Text.Encoding.UTF8.GetBytes(OriginalString);
     byte[] SignatureByte = Convert.FromBase64String(SignatureString);
     X509Certificate2 x509_Cer1 = new X509Certificate2(pubkey_path, CertificatePW);
     RSACryptoServiceProvider rsapub = (RSACryptoServiceProvider)x509_Cer1.PublicKey.Key;
     rsapub.ImportCspBlob(rsapub.ExportCspBlob(false));
     RSAPKCS1SignatureDeformatter f = new RSAPKCS1SignatureDeformatter(rsapub);
     byte[] HashData;
     switch (SignType)
     {
         case 1:
             f.SetHashAlgorithm("MD5");//摘要算法MD5
             MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
             HashData = md5.ComputeHash(OriginalByte);
             break;
         default:
             f.SetHashAlgorithm("SHA1");//摘要算法SHA1
             SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
             HashData = sha.ComputeHash(OriginalByte);
             break;
     }
     if (f.VerifySignature(HashData, SignatureByte))
     {
         return true;
     }
     else
     {
         return false;
     }
 }

        public static RealmPacket CreateAuthResponse(String name, String password)
        {
            SHA1 sha = new SHA1CryptoServiceProvider();
            byte[] user_pass = System.Text.Encoding.UTF8.GetBytes(((name + ":" + password).ToCharArray()));
            byte[] hash = sha.ComputeHash(user_pass);
            byte[] salt = new byte[32];
            new Random().NextBytes(salt);
            byte[] result = new byte[hash.Length + salt.Length];
            hash.CopyTo(result, 0);
            salt.CopyTo(result, hash.Length);
            byte[] finalhash = sha.ComputeHash(result);

            byte[] rand = new byte[20];
            new Random().NextBytes(rand);
            //BigInteger int_a = new BigInteger(reverse(finalhash));
            //BigInteger int_b = new BigInteger(reverse(N));
            BigInteger int_c = new BigInteger(new Byte[] { 7 });
            BigInteger int_d = int_c.modPow(new BigInteger(reverse(finalhash)),new BigInteger(reverse(N)));

            BigInteger K = new BigInteger(new Byte[] { 3 });
            BigInteger temp = ((K * int_d) + int_c.modPow(new BigInteger(reverse(rand)), new BigInteger(reverse(N)))) % new BigInteger(reverse(N));

            RealmPacket response = new RealmPacket();
            response.opcode = RealmOpcode.RS_AUTH_LOGON_CHALLENGE;
            response.Data.Add(RealmData.RD_AUTH_ERROR, 0);
            response.Data.Add(RealmData.RD_AUTH_HASH, temp.getBytes());
            response.Data.Add(RealmData.RD_AUTH_SALT, salt);
            response.Data.Add(RealmData.RD_AUTH_N, N);
            return response;
        }

 public ActionResult Index()
 {
     Init();
     ViewData["timestamp"] = DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;
     Random random = new Random();
     ViewData["nonceStr"] = new string(
         Enumerable.Repeat("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", 16)
                   .Select(s => s[random.Next(s.Length)])
                   .ToArray()); ;
     string weaTokenFetchUrl = string.Format(@"https://qyapi.weixin.qq.com/cgi-bin/get_jsapi_ticket?access_token={0}", weAccessToken.AccessToken);
     if (jsTicket==null||!jsTicket.IsValid)
     {
         using (var webClient = new WebClient())
         {
             string response = webClient.DownloadString(weaTokenFetchUrl);
             jsTicket = JsonConvert.DeserializeObject<WEAJsApiTicket>(response);
         }
     }
     byte[] hashData = Encoding.Default.GetBytes(string.Format("jsapi_ticket={0}&noncestr={1}&timestamp={2}&url={3}", jsTicket.Ticket, ViewData["nonceStr"].ToString(), ViewData["timestamp"].ToString(), Request.Url.AbsoluteUri));
     SHA1 sha = new SHA1CryptoServiceProvider();
     byte[] hashResult = sha.ComputeHash(hashData);
     string signature = BitConverter.ToString(hashResult).Replace("-", string.Empty).ToLower();
     ViewData["signature"] = signature;
     return View();
 }

 public static string EncodePassword(string password)
 {
     using (SHA1CryptoServiceProvider Sha = new SHA1CryptoServiceProvider())
     {
         return Convert.ToBase64String(Sha.ComputeHash(Encoding.ASCII.GetBytes(password)));
     }
 }

 // Slightly modified stackoverflow code for sha1
 public static string CalculateSHA1(string text)
 {
     Encoding enc = Encoding.GetEncoding(1252);
     byte[] buffer = enc.GetBytes(text);
     SHA1CryptoServiceProvider cryptoTransformSHA1 = new SHA1CryptoServiceProvider();
     return BitConverter.ToString(cryptoTransformSHA1.ComputeHash(buffer)).Replace("-", "");
 }