C# 常用加密解密帮助类

public static class EncryptUtil
{
    #region MD5加密

    /// <summary>
    /// MD5加密
    /// </summary>
    public static string Md532(this string value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }

        var encoding = Encoding.UTF8;
        MD5 md5 = MD5.Create();
        return HashAlgorithmBase(md5, value, encoding);
    }

    /// <summary>
    /// 加权MD5加密
    /// </summary>
    public static string Md532(this string value, string salt)
    {
        return salt == null ? value.Md532() : (value + "『" + salt + "』").Md532();
    }

    #endregion

    #region SHA 加密

    /// <summary>
    /// SHA1 加密
    /// </summary>
    public static string Sha1(this string value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }

        var encoding = Encoding.UTF8;
        SHA1 sha1 = new SHA1CryptoServiceProvider();
        return HashAlgorithmBase(sha1, value, encoding);
    }

    /// <summary>
    /// SHA256 加密
    /// </summary>
    public static string Sha256(this string value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }

        var encoding = Encoding.UTF8;
        SHA256 sha256 = new SHA256Managed();
        return HashAlgorithmBase(sha256, value, encoding);
    }

    /// <summary>
    /// SHA512 加密
    /// </summary>
    public static string Sha512(this string value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }
        var encoding = Encoding.UTF8;
        SHA512 sha512 = new SHA512Managed();
        return HashAlgorithmBase(sha512, value, encoding);
    }

    #endregion

    #region HMAC 加密

    /// <summary>
    /// HmacSha1 加密
    /// </summary>
    public static string HmacSha1(this string value, string keyVal)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }
        var encoding = Encoding.UTF8;
        byte[] keyStr = encoding.GetBytes(keyVal);
        HMACSHA1 hmacSha1 = new HMACSHA1(keyStr);
        return HashAlgorithmBase(hmacSha1, value, encoding);
    }

    /// <summary>
    /// HmacSha256 加密
    /// </summary>
    public static string HmacSha256(this string value, string keyVal)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }
        var encoding = Encoding.UTF8;
        byte[] keyStr = encoding.GetBytes(keyVal);
        HMACSHA256 hmacSha256 = new HMACSHA256(keyStr);
        return HashAlgorithmBase(hmacSha256, value, encoding);
    }

    /// <summary>
    /// HmacSha384 加密
    /// </summary>
    public static string HmacSha384(this string value, string keyVal)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }
        var encoding = Encoding.UTF8;
        byte[] keyStr = encoding.GetBytes(keyVal);
        HMACSHA384 hmacSha384 = new HMACSHA384(keyStr);
        return HashAlgorithmBase(hmacSha384, value, encoding);
    }

    /// <summary>
    /// HmacSha512 加密
    /// </summary>
    public static string HmacSha512(this string value, string keyVal)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }
        var encoding = Encoding.UTF8;
        byte[] keyStr = encoding.GetBytes(keyVal);
        HMACSHA512 hmacSha512 = new HMACSHA512(keyStr);
        return HashAlgorithmBase(hmacSha512, value, encoding);
    }

    /// <summary>
    /// HmacMd5 加密
    /// </summary>
    public static string HmacMd5(this string value, string keyVal)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }
        var encoding = Encoding.UTF8;
        byte[] keyStr = encoding.GetBytes(keyVal);
        HMACMD5 hmacMd5 = new HMACMD5(keyStr);
        return HashAlgorithmBase(hmacMd5, value, encoding);
    }

    /// <summary>
    /// HmacRipeMd160 加密
    /// </summary>
    public static string HmacRipeMd160(this string value, string keyVal)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }
        var encoding = Encoding.UTF8;
        byte[] keyStr = encoding.GetBytes(keyVal);
        HMACRIPEMD160 hmacRipeMd160 = new HMACRIPEMD160(keyStr);
        return HashAlgorithmBase(hmacRipeMd160, value, encoding);
    }

    #endregion

    #region AES 加密解密

    /// <summary>
    /// AES加密
    /// </summary>
    /// <param name="value">待加密字段</param>
    /// <param name="keyVal">密钥值</param>
    /// <param name="ivVal">加密辅助向量</param>
    /// <returns></returns>
    public static string AesStr(this string value, string keyVal, string ivVal)
    {
        if (value == null)
        {
            throw new ArgumentNullException("未将对象引用设置到对象的实例。");
        }

        var encoding = Encoding.UTF8;
        byte[] btKey = keyVal.FormatByte(encoding);
        byte[] btIv = ivVal.FormatByte(encoding);
        byte[] byteArray = encoding.GetBytes(value);
        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, , byteArray.Length);
                cStream.FlushFinalBlock();
                encrypt = Convert.ToBase64String(mStream.ToArray());
            }
        }
        aes.Clear();
        return encrypt;
    }

    /// <summary>
    /// AES解密
    /// </summary>
    /// <param name="value">待加密字段</param>
    /// <param name="keyVal">密钥值</param>
    /// <param name="ivVal">加密辅助向量</param>
    /// <returns></returns>
    public static string UnAesStr(this string value, string keyVal, string ivVal)
    {
        var encoding = Encoding.UTF8;
        byte[] btKey = keyVal.FormatByte(encoding);
        byte[] btIv = ivVal.FormatByte(encoding);
        byte[] byteArray = Convert.FromBase64String(value);
        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, , 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)
    {
        ];
        Array.Copy(Encoding.UTF8.GetBytes(keyVal.PadRight(bKey.Length)), bKey, bKey.Length);
        ];
        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, , 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)
    {
        ];
        Array.Copy(Encoding.UTF8.GetBytes(keyVal.PadRight(bKey.Length)), bKey, bKey.Length);
        ];
        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())
                    {
                        ];
                        int readBytes;
                        , buffer.Length)) > )
                        {
                            originalMemory.Write(buffer, , readBytes);
                        }

                        original = originalMemory.ToArray();
                    }
                }
            }
        }
        catch
        {
            original = null;
        }
        return original;
    }

    #endregion

    #region DES 加密解密

    /// <summary>
    /// DES 加密
    /// </summary>
    public static string Des(this string value, string keyVal, string ivVal)
    {
        try
        {
            byte[] data = Encoding.UTF8.GetBytes(value);
             ? keyVal.Substring(, ) : keyVal), IV = Encoding.ASCII.GetBytes(ivVal.Length >  ? ivVal.Substring(, ) : ivVal) };
            var desencrypt = des.CreateEncryptor();
            , data.Length);
            return BitConverter.ToString(result);
        }
        catch { return "转换出错！"; }
    }

    /// <summary>
    /// DES 解密
    /// </summary>
    public static string UnDes(this string value, string keyVal, string ivVal)
    {
        try
        {
            string[] sInput = value.Split("-".ToCharArray());
            byte[] data = new byte[sInput.Length];
            ; i < sInput.Length; i++)
            {
                data[i] = byte.Parse(sInput[i], NumberStyles.HexNumber);
            }
             ? keyVal.Substring(, ) : keyVal), IV = Encoding.ASCII.GetBytes(ivVal.Length >  ? ivVal.Substring(, ) : ivVal) };
            var desencrypt = des.CreateDecryptor();
            , data.Length);
            return Encoding.UTF8.GetString(result);
        }
        catch { return "解密出错！"; }
    }

    #endregion

    #region BASE64 加密解密

    /// <summary>
    /// BASE64 加密
    /// </summary>
    /// <param name="value">待加密字段</param>
    /// <returns></returns>
    public static string Base64(this string value)
    {
        var btArray = Encoding.UTF8.GetBytes(value);
        , btArray.Length);
    }

    /// <summary>
    /// BASE64 解密
    /// </summary>
    /// <param name="value">待解密字段</param>
    /// <returns></returns>
    public static string UnBase64(this string value)
    {
        var btArray = Convert.FromBase64String(value);
        return Encoding.UTF8.GetString(btArray);
    }

    #endregion

    #region Base64加密解密
    /// <summary>
    /// Base64加密 可逆
    /// </summary>
    /// <param name="value">待加密文本</param>
    /// <returns></returns>
    public static string Base64Encrypt(string value)
    {
        return Convert.ToBase64String(System.Text.Encoding.Default.GetBytes(value));
    }

    /// <summary>
    /// Base64解密
    /// </summary>
    /// <param name="ciphervalue">密文</param>
    /// <returns></returns>
    public static string Base64Decrypt(string ciphervalue)
    {
        return System.Text.Encoding.Default.GetString(System.Convert.FromBase64String(ciphervalue));
    }
    #endregion

    #region 内部方法

    /// <summary>
    /// 转成数组
    /// </summary>
    private static byte[] Str2Bytes(this string source)
    {
        source = source.Replace(" ", "");
        ];
        ; i < source.Length; i += ) buffer[i / ] = Convert.ToByte(source.Substring(i, ), );
        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)
    {
        , ).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

}