【加密解密类】C# 最强密码处理类（PassWordHelper.cs） - CSkin博客

[C#] 纯文本查看 复制代码
using System;

using System.IO;

using System.Text;

using System.Globalization;

using System.Collections.Generic;

using System.Security.Cryptography;



namespace Utils

{

    /// <summary>

    /// 密码加密解密操作相关类

    /// </summary>

    public static class PassWordHelper

    {

        #region MD5 加密



        /// <summary>

        /// MD5加密

        /// </summary>

        public static string Md532(this string source)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            MD5 md5 = MD5.Create();

            return HashAlgorithmBase(md5, source, encoding);

        }



        /// <summary>

        /// 加盐MD5加密

        /// </summary>

        public static string Md532Salt(this string source, string salt)

        {

            return salt.IsEmpty() ? source.Md532() : (source + "『" + salt + "』").Md532();

        }



        #endregion



        #region SHA 加密



        /// <summary>

        /// SHA1 加密

        /// </summary>

        public static string Sha1(this string source)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            SHA1 sha1 = new SHA1CryptoServiceProvider();

            return HashAlgorithmBase(sha1, source, encoding);

        }



        /// <summary>

        /// SHA256 加密

        /// </summary>

        public static string Sha256(this string source)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            SHA256 sha256 = new SHA256Managed();

            return HashAlgorithmBase(sha256, source, encoding);

        }



        /// <summary>

        /// SHA512 加密

        /// </summary>

        public static string Sha512(this string source)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            SHA512 sha512 = new SHA512Managed();

            return HashAlgorithmBase(sha512, source, encoding);

        }



        #endregion



        #region HMAC 加密



        /// <summary>

        /// HmacSha1 加密

        /// </summary>

        public static string HmacSha1(this string source, string keyVal)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            byte[] keyStr = encoding.GetBytes(keyVal);

            HMACSHA1 hmacSha1 = new HMACSHA1(keyStr);

            return HashAlgorithmBase(hmacSha1, source, encoding);

        }



        /// <summary>

        /// HmacSha256 加密

        /// </summary>

        public static string HmacSha256(this string source, string keyVal)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            byte[] keyStr = encoding.GetBytes(keyVal);

            HMACSHA256 hmacSha256 = new HMACSHA256(keyStr);

            return HashAlgorithmBase(hmacSha256, source, encoding);

        }



        /// <summary>

        /// HmacSha384 加密

        /// </summary>

        public static string HmacSha384(this string source, string keyVal)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            byte[] keyStr = encoding.GetBytes(keyVal);

            HMACSHA384 hmacSha384 = new HMACSHA384(keyStr);

            return HashAlgorithmBase(hmacSha384, source, encoding);

        }



        /// <summary>

        /// HmacSha512 加密

        /// </summary>

        public static string HmacSha512(this string source, string keyVal)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            byte[] keyStr = encoding.GetBytes(keyVal);

            HMACSHA512 hmacSha512 = new HMACSHA512(keyStr);

            return HashAlgorithmBase(hmacSha512, source, encoding);

        }



        /// <summary>

        /// HmacMd5 加密

        /// </summary>

        public static string HmacMd5(this string source, string keyVal)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            byte[] keyStr = encoding.GetBytes(keyVal);

            HMACMD5 hmacMd5 = new HMACMD5(keyStr);

            return HashAlgorithmBase(hmacMd5, source, encoding);

        }



        /// <summary>

        /// HmacRipeMd160 加密

        /// </summary>

        public static string HmacRipeMd160(this string source, string keyVal)

        {

            if (source.IsEmpty()) return null;

            var encoding = Encoding.UTF8;

            byte[] keyStr = encoding.GetBytes(keyVal);

            HMACRIPEMD160 hmacRipeMd160 = new HMACRIPEMD160(keyStr);

            return HashAlgorithmBase(hmacRipeMd160, source, encoding);

        }



        #endregion



        #region AES 加密解密



        /// <summary>  

        /// AES加密  

        /// </summary>  

        /// <param name="source">待加密字段</param>  

        /// <param name="keyVal">密钥值</param>  

        /// <param name="ivVal">加密辅助向量</param> 

        /// <returns></returns>  

        public static string AesStr(this string source, string keyVal, string ivVal)

        {

            var encoding = Encoding.UTF8;

            byte[] btKey = keyVal.FormatByte(encoding);

            byte[] btIv = ivVal.FormatByte(encoding);

            byte[] byteArray = encoding.GetBytes(source);

            string encrypt;

            Rijndael aes = Rijndael.Create();

            using (MemoryStream mStream = new MemoryStream())

            {

                using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateEncryptor(btKey, btIv), CryptoStreamMode.Write))

                {

                    cStream.Write(byteArray, 0, byteArray.Length);

                    cStream.FlushFinalBlock();

                    encrypt = Convert.ToBase64String(mStream.ToArray());

                }

            }

            aes.Clear();

            return encrypt;

        }



        /// <summary>  

        /// AES解密  

        /// </summary>  

        /// <param name="source">待加密字段</param>  

        /// <param name="keyVal">密钥值</param>  

        /// <param name="ivVal">加密辅助向量</param>  

        /// <returns></returns>  

        public static string UnAesStr(this string source, string keyVal, string ivVal)

        {

            var encoding = Encoding.UTF8;

            byte[] btKey = keyVal.FormatByte(encoding);

            byte[] btIv = ivVal.FormatByte(encoding);

            byte[] byteArray = Convert.FromBase64String(source);

            string decrypt;

            Rijndael aes = Rijndael.Create();

            using (MemoryStream mStream = new MemoryStream())

            {

                using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateDecryptor(btKey, btIv), CryptoStreamMode.Write))

                {

                    cStream.Write(byteArray, 0, byteArray.Length);

                    cStream.FlushFinalBlock();

                    decrypt = encoding.GetString(mStream.ToArray());

                }

            }

            aes.Clear();

            return decrypt;

        }



        /// <summary>  

        /// AES Byte类型 加密  

        /// </summary>  

        /// <param name="data">待加密明文</param>  

        /// <param name="keyVal">密钥值</param>  

        /// <param name="ivVal">加密辅助向量</param>  

        /// <returns></returns>  

        public static byte[] AesByte(this byte[] data, string keyVal, string ivVal)

        {

            byte[] bKey = new byte[32];

            Array.Copy(Encoding.UTF8.GetBytes(keyVal.PadRight(bKey.Length)), bKey, bKey.Length);

            byte[] bVector = new byte[16];

            Array.Copy(Encoding.UTF8.GetBytes(ivVal.PadRight(bVector.Length)), bVector, bVector.Length);

            byte[] cryptograph;

            Rijndael aes = Rijndael.Create();

            try

            {

                using (MemoryStream mStream = new MemoryStream())

                {

                    using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateEncryptor(bKey, bVector), CryptoStreamMode.Write))

                    {

                        cStream.Write(data, 0, data.Length);

                        cStream.FlushFinalBlock();

                        cryptograph = mStream.ToArray();

                    }

                }

            }

            catch

            {

                cryptograph = null;

            }

            return cryptograph;

        }



        /// <summary>  

        /// AES Byte类型 解密  

        /// </summary>  

        /// <param name="data">待解密明文</param>  

        /// <param name="keyVal">密钥值</param>  

        /// <param name="ivVal">加密辅助向量</param> 

        /// <returns></returns>  

        public static byte[] UnAesByte(this byte[] data, string keyVal, string ivVal)

        {

            byte[] bKey = new byte[32];

            Array.Copy(Encoding.UTF8.GetBytes(keyVal.PadRight(bKey.Length)), bKey, bKey.Length);

            byte[] bVector = new byte[16];

            Array.Copy(Encoding.UTF8.GetBytes(ivVal.PadRight(bVector.Length)), bVector, bVector.Length);

            byte[] original;

            Rijndael aes = Rijndael.Create();

            try

            {

                using (MemoryStream mStream = new MemoryStream(data))

                {

                    using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bVector), CryptoStreamMode.Read))

                    {

                        using (MemoryStream originalMemory = new MemoryStream())

                        {

                            byte[] buffer = new byte[1024];

                            int readBytes;

                            while ((readBytes = cStream.Read(buffer, 0, buffer.Length)) > 0)

                            {

                                originalMemory.Write(buffer, 0, readBytes);

                            }



                            original = originalMemory.ToArray();

                        }

                    }

                }

            }

            catch

            {

                original = null;

            }

            return original;

        }



        #endregion



        #region RSA 加密解密



        //密钥对，请配合密钥生成工具使用『 http://download.csdn.net/detail/downiis6/9464639 』

        private const string PublicRsaKey = @"pubKey";

        private const string PrivateRsaKey = @"priKey";



        /// <summary>

        /// RSA 加密

        /// </summary>

        public static string Rsa(this string source)

        {

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            rsa.FromXmlString(PublicRsaKey);

            var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(source), true);

            return Convert.ToBase64String(cipherbytes);

        }



        /// <summary>

        /// RSA解密

        /// </summary>

        public static string UnRsa(this string source)

        {

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            rsa.FromXmlString(PrivateRsaKey);

            var cipherbytes = rsa.Decrypt(Convert.FromBase64String(source), true);

            return Encoding.UTF8.GetString(cipherbytes);

        }



        #endregion



        #region DES 加密解密



        /// <summary>

        /// DES 加密

        /// </summary>

        public static string Des(this string source, string keyVal, string ivVal)

        {

            try

            {

                byte[] data = Encoding.UTF8.GetBytes(source);

                var des = new DESCryptoServiceProvider { Key = Encoding.ASCII.GetBytes(keyVal.Length > 8 ? keyVal.Substring(0, 8) : keyVal), IV = Encoding.ASCII.GetBytes(ivVal.Length > 8 ? ivVal.Substring(0, 8) : ivVal) };

                var desencrypt = des.CreateEncryptor();

                byte[] result = desencrypt.TransformFinalBlock(data, 0, data.Length);

                return BitConverter.ToString(result);

            }

            catch { return "转换出错！"; }

        }



        /// <summary>

        /// DES 解密

        /// </summary>

        public static string UnDes(this string source, string keyVal, string ivVal)

        {

            try

            {

                string[] sInput = source.Split("-".ToCharArray());

                byte[] data = new byte[sInput.Length];

                for (int i = 0; i < sInput.Length; i++)

                {

                    data = byte.Parse(sInput, NumberStyles.HexNumber);

                }

                var des = new DESCryptoServiceProvider { Key = Encoding.ASCII.GetBytes(keyVal.Length > 8 ? keyVal.Substring(0, 8) : keyVal), IV = Encoding.ASCII.GetBytes(ivVal.Length > 8 ? ivVal.Substring(0, 8) : ivVal) };

                var desencrypt = des.CreateDecryptor();

                byte[] result = desencrypt.TransformFinalBlock(data, 0, data.Length);

                return Encoding.UTF8.GetString(result);

            }

            catch { return "解密出错！"; }

        }



        #endregion



        #region TripleDES 加密解密



        /// <summary>

        /// DES3 加密

        /// </summary>

        public static string Des3(this string source, string keyVal)

        {

            try

            {

                TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider

                {

                    Key = keyVal.FormatByte(Encoding.UTF8),

                    Mode = CipherMode.ECB,

                    Padding = PaddingMode.PKCS7

                };

                using (MemoryStream ms = new MemoryStream())

                {

                    byte[] btArray = Encoding.UTF8.GetBytes(source);

                    try

                    {

                        using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))

                        {

                            cs.Write(btArray, 0, btArray.Length);

                            cs.FlushFinalBlock();

                        }

                        return ms.ToArray().Bytes2Str();

                    }

                    catch { return source; }

                }

            }

            catch

            {

                return "TripleDES加密出现错误";

            }

        }



        /// <summary>

        /// DES3 解密

        /// </summary>

        public static string UnDes3(this string source, string keyVal)

        {

            try

            {

                byte[] byArray = source.Str2Bytes();

                TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider

                {

                    Key = keyVal.FormatByte(Encoding.UTF8),

                    Mode = CipherMode.ECB,

                    Padding = PaddingMode.PKCS7

                };

                using (MemoryStream ms = new MemoryStream())

                {

                    using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))

                    {

                        cs.Write(byArray, 0, byArray.Length);

                        cs.FlushFinalBlock();

                        cs.Close();

                        ms.Close();

                        return Encoding.UTF8.GetString(ms.ToArray());

                    }

                }

            }

            catch

            {

                return "TripleDES解密出现错误";

            }

        }



        #endregion



        #region BASE64 加密解密



        /// <summary>

        /// BASE64 加密

        /// </summary>

        /// <param name="source">待加密字段</param>

        /// <returns></returns>

        public static string Base64(this string source)

        {

            var btArray = Encoding.UTF8.GetBytes(source);

            return Convert.ToBase64String(btArray, 0, btArray.Length);

        }



        /// <summary>

        /// BASE64 解密

        /// </summary>

        /// <param name="source">待解密字段</param>

        /// <returns></returns>

        public static string UnBase64(this string source)

        {

            var btArray = Convert.FromBase64String(source);

            return Encoding.UTF8.GetString(btArray);

        }



        #endregion



        #region 内部方法

                 

        /// <summary>

        /// 转成数组

        /// </summary>

        private static byte[] Str2Bytes(this string source)

        {

            source = source.Replace(" ", "");

            byte[] buffer = new byte[source.Length / 2];

            for (int i = 0; i < source.Length; i += 2) buffer[i / 2] = Convert.ToByte(source.Substring(i, 2), 16);

            return buffer;

        }



        /// <summary>

        /// 转换成字符串

        /// </summary>

        private static string Bytes2Str(this IEnumerable<byte> source, string formatStr = "{0:X2}")

        {

            StringBuilder pwd = new StringBuilder();

            foreach (byte btStr in source) { pwd.AppendFormat(formatStr, btStr); }

            return pwd.ToString();

        }



        private static byte[] FormatByte(this string strVal, Encoding encoding)

        {

            return encoding.GetBytes(strVal.Base64().Substring(0, 16).ToUpper());

        }



        /// <summary>

        /// HashAlgorithm 加密统一方法

        /// </summary>

        private static string HashAlgorithmBase(HashAlgorithm hashAlgorithmObj, string source, Encoding encoding)

        {

            byte[] btStr = encoding.GetBytes(source);

            byte[] hashStr = hashAlgorithmObj.ComputeHash(btStr);

            return hashStr.Bytes2Str();

        }



        #endregion

    }

}