工作常用加密整理

MD5加密       

 

 public static string Md5Encrypt(string sourceString,Encoding enc = null)
        {
            if(enc==null) enc=Encoding.UTF8;
            var buffer = MD5.Create().ComputeHash(enc.GetBytes(sourceString));
            var builder = new StringBuilder();
            foreach(var t in buffer)
            {
                builder.Append(t.ToString("x").PadLeft(2,'0'));
            }
            return builder.ToString();
        }

RAS 加密

 

 

 

 

 public static string RSAEncrypt(string publickey, string content)
        {
            using (RSACryptoServiceProvider RSACryptography = new RSACryptoServiceProvider())
            {
                try {
                    Byte[] PlaintextData = Encoding.UTF8.GetBytes(content);
                    RSACryptography.FromXmlString(publickey);
                    int MaxBlockSize = RSACryptography.KeySize / 8 - 11;    //加密块最大长度限制
                    if (PlaintextData.Length <= MaxBlockSize)
                        return Convert.ToBase64String(RSACryptography.Encrypt(PlaintextData, false));
                    using (MemoryStream PlaiStream = new MemoryStream(PlaintextData))
                    using (MemoryStream CrypStream = new MemoryStream())
                    {
                        Byte[] Buffer = new Byte[MaxBlockSize];
                        int BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
                        while (BlockSize > 0)
                        {
                            Byte[] ToEncrypt = new Byte[BlockSize];
                            Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize);
                            Byte[] Cryptograph = RSACryptography.Encrypt(ToEncrypt, false);
                            CrypStream.Write(Cryptograph, 0, Cryptograph.Length);
                            BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
                        }
                        return Convert.ToBase64String(CrypStream.ToArray(), Base64FormattingOptions.None);
                    }

                }
                catch (Exception e) {
                    return "";
                }
            }
        }
        //C#的RSA私钥签名代码如：
        public static string RSASignData(string privatekey, string content)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            byte[] cipherbytes;
            rsa.FromXmlString(privatekey);
            cipherbytes = rsa.SignData(Encoding.UTF8.GetBytes(content), "SHA1");
            return Convert.ToBase64String(cipherbytes);
        }
        //C#的RSA公钥验证代码如：
        public static bool RSAVerifyData(string publickey, string content, string sign)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(publickey);
            return rsa.VerifyData(Encoding.UTF8.GetBytes(content), "SHA1", Convert.FromBase64String(sign));
        }

Base64Encrypt

        public static string Base64Encrypt(string input)
        {
            return Base64Encrypt(input, Encoding.UTF8);
        }
        public static string Base64Encrypt(string input, Encoding encode)
        {
            return Convert.ToBase64String(encode.GetBytes(input));
        }

 

/// <summary>
        /// Aes加密
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="key">aes密钥，长度必须32位</param>
        /// <returns>加密后的字符串</returns>
        public static string EncryptAes(string source, string key)
        {

            using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider())
            {
                aesProvider.Key = GetAesKey(key);
                aesProvider.Mode = CipherMode.ECB;
                aesProvider.Padding = PaddingMode.PKCS7;
                using (ICryptoTransform cryptoTransform = aesProvider.CreateEncryptor())
                {
                    byte[] inputBuffers = Encoding.UTF8.GetBytes(source);
                    byte[] results = cryptoTransform.TransformFinalBlock(inputBuffers, 0, inputBuffers.Length);
                    aesProvider.Clear();
                    aesProvider.Dispose();
                    return Convert.ToBase64String(results, 0, results.Length);
                }
            }
        }
        /// <summary>
        /// Aes解密
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="key">aes密钥，长度必须32位</param>
        /// <returns>解密后的字符串</returns>
        public static string DecryptAes(string source, string key)
        {
            using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider())
            {
                aesProvider.Key = GetAesKey(key);
                aesProvider.Mode = CipherMode.ECB;
                aesProvider.Padding = PaddingMode.ISO10126;
                using (ICryptoTransform cryptoTransform = aesProvider.CreateDecryptor())
                {
                    byte[] inputBuffers = Convert.FromBase64String(source);
                    byte[] results = cryptoTransform.TransformFinalBlock(inputBuffers, 0, inputBuffers.Length);
                    aesProvider.Clear();
                    return Encoding.UTF8.GetString(results);
                }
            }
        }
        static byte[] GetAesKey(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentNullException("key", "Aes密钥不能为空");
            }
            //if (key.Length < 32)
            // {
            // 不足32补全
            // key = key.PadRight(32, '0');
            //}
            // if (key.Length > 32)
            // {
            // key = key.Substring(0, 32);
            //}
            return Encoding.UTF8.GetBytes(key);
        }

DES3加解密

 

/// <summary>
        /// DES3加密
        /// </summary>
        /// <param name="input"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string Des3Encrypt(string input, string key)
        {
            var des = new TripleDESCryptoServiceProvider
            {
                Key = Encoding.ASCII.GetBytes(key),
                Mode = CipherMode.CBC,
                Padding = PaddingMode.PKCS7
            };

            var desEncrypt = des.CreateEncryptor();
            var buffer = Encoding.ASCII.GetBytes(input);

            return Convert.ToBase64String(desEncrypt.TransformFinalBlock(buffer, 0, buffer.Length));
        }

        /// <summary>
        /// DES3解密
        /// </summary>
        /// <param name="input"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string Des3Decrypt(string input, string key)
        {
            var des = new TripleDESCryptoServiceProvider
            {
                Key = Encoding.ASCII.GetBytes(key),
                Mode = CipherMode.CBC,
                Padding = PaddingMode.PKCS7
            };

            var desDecrypt = des.CreateDecryptor();
            var buffer = Convert.FromBase64String(input);
            var result = Encoding.ASCII.GetString(desDecrypt.TransformFinalBlock(buffer, 0, buffer.Length));

            return result;
        }

SHA1加密

 

 

  public static string SHA1_Encrypt(string Source_String)
        {
            byte[] strRes = Encoding.Default.GetBytes(Source_String);
            HashAlgorithm iSha = new SHA1CryptoServiceProvider();
            strRes = iSha.ComputeHash(strRes);
            StringBuilder enText = new StringBuilder();
            foreach (byte iByte in strRes)
            {
                enText.AppendFormat("{0:x2}", iByte);
            }
            return enText.ToString();
        }

 

 #region DES加密解密

        /// <summary>
        /// DES加密
        /// </summary>
        /// <param name="input">加密数据</param>
        /// <param name="key">8位字符的密钥字符串</param>
        /// <param name="iv">8位字符的初始化向量字符串</param>
        /// <returns></returns>
        public static string DesEncrypt(string input, string key, string iv)
        {
            var byKey = Encoding.ASCII.GetBytes(key);
            var byIv = Encoding.ASCII.GetBytes(iv);

            var cryptoProvider = new DESCryptoServiceProvider();
            using (var ms = new MemoryStream())
            {
                using (var cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(byKey, byIv),
                    CryptoStreamMode.Write))
                {
                    using (var sw = new StreamWriter(cst))
                    {
                        sw.Write(input);
                        sw.Flush();
                        cst.FlushFinalBlock();
                        return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
                    }
                }
            }
        }

        /// <summary>
        /// DES解密
        /// </summary>
        /// <param name="data">解密数据</param>
        /// <param name="key">8位字符的密钥字符串(需要和加密时相同)</param>
        /// <param name="iv">8位字符的初始化向量字符串(需要和加密时相同)</param>
        /// <returns></returns>
        public static string DesDecrypt(string data, string key, string iv)
        {
            var byKey = Encoding.ASCII.GetBytes(key);
            var byIv = Encoding.ASCII.GetBytes(iv);

            var byEnc = Convert.FromBase64String(data);
            var cryptoProvider = new DESCryptoServiceProvider();

            using (var ms = new MemoryStream(byEnc))
            {
                using (var cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(byKey, byIv),
                    CryptoStreamMode.Read))
                {
                    using (var sr = new StreamReader(cst))
                    {
                        return sr.ReadToEnd();
                    }
                }
            }
        }

        #endregion

C#对应java SHA256加密，带密钥

 public static string SHA256Encrypt(string str,string key)
        {
            var encoding = Encoding.UTF8;
            byte[] keyByte = encoding.GetBytes(key);
            // 注意：如果是中文注意转换编码格式
            byte[] messageBytes = encoding.GetBytes(str);
            using (var hmacsha256 = new HMACSHA256(keyByte))
            {
                byte[] hashmessage = hmacsha256.ComputeHash(messageBytes);
                // 注意：Java (u127)与.NET byte(255) 存储方式不同，所以需要转换一下。
                sbyte[] sb = new sbyte[hashmessage.Length];
                for (int i = 0; i < hashmessage.Length; i++)
                {
                    sb[i] = hashmessage[i] < 127 ? (sbyte)hashmessage[i] : (sbyte)(hashmessage[i] - 256);
                }
                StringBuilder EnText = new StringBuilder();
                foreach (byte iByte in hashmessage)
                {
                    EnText.AppendFormat("{0:x2}", iByte);
                }
                return EnText.ToString();
            }
        }