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