C# AES 加密解密，微信敏感数据解密

 

2022-12-16重新编辑C# AES加密解密

在调用RijndaelManaged 时发现生成加密的时候设置参数的顺序和解密赋值参数的顺序不一致时解密不了。这可能是因为RijndaelManaged封装的get/set时加了处理。

所以要统一加密和解密的RijndaelManaged 对象

/// <summary>
/// 统一创建加密和解密参数顺序设置
/// </summary>
/// <param name="key">key 是明文，不需要bas64这些</param>
/// <param name="sha1">是否对key进行sha1，是的话key值只需要大于16位即可，取keySize/8的值</param>
/// <returns></returns>
private static RijndaelManaged CreateAES(string key, bool sha1 = false)
{
    if (sha1 == false)
    {
        if (key.Length != 16 && key.Length != 24)
        {
            throw new Exception("key的位数必须是16或24");
        }
    }
    else
    {
        if (key.Length < 16)
        {
            throw new Exception("key的位数必须是大于16");
        }
    }
    RijndaelManaged rm = new RijndaelManaged
    {
        Mode = CipherMode.ECB,
        Padding = PaddingMode.PKCS7,
        KeySize = 128,
        BlockSize = 128
    };
    if (sha1 == false)
    {
        rm.Key = Encoding.UTF8.GetBytes(key);
    }
    else
    {
        rm.Key = GetSecretKey(key, rm.KeySize / 8);
    }
    return rm;
}

key应该是16或24位。但是这就比较局限性了，所以在我们不经意间设置了不是这个长度的key时，就会报错啦。为了决解这个问题，我们就要固定这个key的长度。通过哈希来实现。

/// <summary>
/// .NET与JAVA的AES互通【SecureRandom.getInstance("SHA1PRNG")】
/// </summary>
/// <param name="password"></param>
/// <returns></returns>
private static byte[] GetSecretKey(string password, int size = 16)
#region
{
    byte[] keyArray;
    byte[] seed = Encoding.UTF8.GetBytes(password);
    using (var st = new SHA1CryptoServiceProvider())
    {
        using (var nd = new SHA1CryptoServiceProvider())
        {
            var rd = nd.ComputeHash(st.ComputeHash(seed));
            keyArray = rd.Take(size).ToArray();
        }
    }
    return keyArray;
}
#endregion

SHA1：返回一个160位的byte[]数组，20字节，我们取前面16位刚好满足。

创建加密实例：

public static string Encrypt(string text, string key, bool keyNeedHash = false)
{
    var rm = CreateAES(key, keyNeedHash);
    ICryptoTransform transform = rm.CreateEncryptor();
    byte[] plainText = Encoding.UTF8.GetBytes(text);
    byte[] cipherBytes = transform.TransformFinalBlock(plainText, 0, plainText.Length);
    return Convert.ToBase64String(cipherBytes);
}

解密方法：

public static string Decrypt(string base64_encodeText, string key, bool keyNeedHash = false)
{
    var rm = CreateAES(key, keyNeedHash);
    ICryptoTransform transform = rm.CreateDecryptor();
    byte[] plainText = Convert.FromBase64String(base64_encodeText);
    byte[] cipherBytes = transform.TransformFinalBlock(plainText, 0, plainText.Length);
    return Encoding.UTF8.GetString(cipherBytes);
}

以上是新整理的笔记。

以下是之前的笔记，做个对比。

/// AES加密解密方式
/// ECB模式不许偏移量iv
/// 提供输出base64和Hex 16进制格式

public class AES_Cipher
    {
        /// <summary>
        /// AES 算法加密(ECB模式) 将明文加密，加密后进行Hex编码，返回密文
        /// </summary>
        /// <param name="str">明文</param>
        /// <param name="key">密钥</param>
        /// <returns>加密后Hex编码的密文</returns>
        public static string AesEncryptor_ECB_Hex(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                //Key = StrToHexByte(key),  //把key转成16进制
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return ToHexString(resultArray);
        }


        /// <summary>
        ///AES 算法解密(ECB模式) 将密文Hex解码后进行解密，返回明文
        /// </summary>
        /// <param name="str">密文</param>
        /// <param name="key">密钥</param>
        /// <returns>明文</returns>
        public static string AesDecryptor_ECB_Hex(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = StrToHexByte(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                //Key = StrToHexByte(key), //key16进制解码
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Encoding.UTF8.GetString(resultArray);
        }

        /// <summary>
        /// byte数组Hex编码
        /// </summary>
        /// <param name="bytes">需要进行编码的byte[]</param>
        /// <returns></returns>
        public static string ToHexString(byte[] bytes)
        {
            string hexString = string.Empty;
            if (bytes != null)
            {
                StringBuilder strB = new StringBuilder();
                for (int i = 0; i < bytes.Length; i++)
                {
                    strB.Append(bytes[i].ToString("X2"));
                }
                hexString = strB.ToString();
            }
            return hexString;
        }
        /// <summary> 
        /// 字符串进行Hex解码(Hex.decodeHex())
        /// </summary> 
        /// <param name="hexString">需要进行解码的字符串</param> 
        /// <returns></returns> 
        public static byte[] StrToHexByte(string hexString)
        {
            hexString = hexString.Replace(" ", "");
            if ((hexString.Length % 2) != 0)
                hexString += " ";
            byte[] returnBytes = new byte[hexString.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
            return returnBytes;
        }


        /// <summary>
        /// AES 算法加密(ECB模式) 将明文加密，加密后进行Base64编码，返回密文
        /// </summary>
        /// <param name="str">明文</param>
        /// <param name="key">密钥</param>
        /// <returns>加密后Base64编码的密文</returns>
        public static string AesEncryptor_ECB_Base64(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                //Key = Convert.FromBase64String(key), //如果key是base64编码过的就解码转换,如果按照规范明文和key都应该传入base64
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Convert.ToBase64String(resultArray);
        }

        /// <summary>
        ///AES 算法解密(ECB模式) 将密文Base64解码后进行解密，返回明文
        /// </summary>
        /// <param name="base64Str">密文(base64编码格式)</param>
        /// <param name="key">密钥</param>
        /// <returns>明文</returns>
        public static string AesDecryptor_ECB_Base64(string base64Str, string key)
        {
            if (string.IsNullOrEmpty(base64Str)) return null;
            Byte[] toEncryptArray = Convert.FromBase64String(base64Str);

            RijndaelManaged rm = new RijndaelManaged
            {
                //Key = Convert.FromBase64String(key), //如果key是base64编码过的就解码转换,如果按照规范密文和key都应该传入base64
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Encoding.UTF8.GetString(resultArray);
        }

微信敏感数据解密

        /// <summary>
        /// 微信敏感数据解密
        /// </summary>
        /// <param name="encryptedData">密文</param>
        /// <param name="iv">加密算法的初始向量</param>
        /// <param name="sessionKey">登录获取的session_key</param>
        /// <returns></returns>
        public static string AESDecrypt(string encryptedData, string iv, string sessionKey)
        {
            var encryptedDataByte = Convert.FromBase64String(encryptedData);
            var rijndaelCipher = new RijndaelManaged
            {
                Key = Convert.FromBase64String(sessionKey),
                IV = Convert.FromBase64String(iv),
                Mode = CipherMode.CBC,
                Padding = PaddingMode.PKCS7
            };

            var transform = rijndaelCipher.CreateDecryptor();
            var plainText = transform.TransformFinalBlock(encryptedDataByte, 0, encryptedDataByte.Length);
            var result = Encoding.UTF8.GetString(plainText);
            return result;
        }