AES加密算法C#实现

本人在使用C#开发winform的实际项目中，遇到一个和第三方平台进行通信的。平台要求使用AES进行加密算法，当C#端，暂且称为客户端，java端称为服务器端。当客户端发送数据给java端的时候，要使用AES算法对通信数据进行加密，java端使用AES算法进行解密，java端回复客户端同样使用AES算法进行加密，客户端（C#端）收到数据后，使用AES算法进行解密。

AES算法有两种，一种只有一个key即可加密解谜，一种使用一个key和一个IV进行数据加密。

C#无向量的AES加密算法

  1. //需要引入的命名空间
  2. using System.Security.Cryptography;
  4.         /// <summary>  
  5.         /// AES加密(无向量)  
  6.         /// </summary>  
  7.         /// <param name="plainBytes">被加密的明文</param>  
  8.         /// <param name="key">密钥</param>  
  9.         /// <returns>密文</returns>  
  10.         public static string AESEncrypt(String Data, String Key)
  11.         {
  12.             MemoryStream mStream = new MemoryStream();
  13.             RijndaelManaged aes = new RijndaelManaged();
  14.             byte[] plainBytes = Encoding.UTF8.GetBytes(Data);
  15.             Byte[] bKey = new Byte[32];
  16.             Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
  18.             aes.Mode = CipherMode.ECB;
  19.             aes.Padding = PaddingMode.PKCS7;
  20.             aes.KeySize = 128;
  21.             //aes.Key = _key;  
  22.             aes.Key = bKey;
  23.             //aes.IV = _iV;  
  24.             CryptoStream cryptoStream = new CryptoStream(mStream, aes.CreateEncryptor(), CryptoStreamMode.Write);
  25.             try
  26.             {
  27.                 cryptoStream.Write(plainBytes, 0, plainBytes.Length);
  28.                 cryptoStream.FlushFinalBlock();
  29.                 return Convert.ToBase64String(mStream.ToArray());
  30.             }
  31.             finally
  32.             {
  33.                 cryptoStream.Close();
  34.                 mStream.Close();
  35.                 aes.Clear();
  36.             }
  37.         }

该方法可以对明文进行直接加密，只需要传入需要加密的明文字符串，和key。

C#实现无向量解密

  1.          /// <summary>  
  2.         /// AES解密(无向量)  
  3.         /// </summary>  
  4.         /// <param name="encryptedBytes">被加密的明文</param>  
  5.         /// <param name="key">密钥</param>  
  6.         /// <returns>明文</returns>  
  7.         public static string AESDecrypt(String Data, String Key)
  8.         {
  9.             Byte[] encryptedBytes = Convert.FromBase64String(Data);
  10.             Byte[] bKey = new Byte[32];
  11.             Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
  13.             MemoryStream mStream = new MemoryStream(encryptedBytes);
  14.             //mStream.Write( encryptedBytes, 0, encryptedBytes.Length );  
  15.             //mStream.Seek( 0, SeekOrigin.Begin );  
  18.             RijndaelManaged aes = new RijndaelManaged();
  19.             aes.Mode = CipherMode.ECB;
  20.             aes.Padding = PaddingMode.PKCS7;
  21.             aes.KeySize = 128;
  22.             aes.Key = bKey;
  23.             //aes.IV = _iV;  
  24.             CryptoStream cryptoStream = new CryptoStream(mStream, aes.CreateDecryptor(), CryptoStreamMode.Read);
  25.             try
  26.             {
  27.                 byte[] tmp = new byte[encryptedBytes.Length + 32];
  28.                 int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length + 32);
  29.                 byte[] ret = new byte[len];
  30.                 Array.Copy(tmp, 0, ret, 0, len);
  31.                 return Encoding.UTF8.GetString(ret);
  32.             }
  33.             finally
  34.             {
  35.                 cryptoStream.Close();
  36.                 mStream.Close();
  37.                 aes.Clear();
  38.             }
  39.         }

C#实现AES算法加密，解密还可以使用有向量的方式

有向量的方式实现C#AES算法加密

  1.        /// <summary>  
  2.         /// AES加密  
  3.         /// </summary>  
  4.         /// <param name="Data">被加密的明文</param>  
  5.         /// <param name="Key">密钥</param>  
  6.         /// <param name="Vector">向量</param>  
  7.         /// <returns>密文</returns>  
  8.         public static String AESEncrypt(String Data, String Key, String Vector)
  9.         {
  10.             Byte[] plainBytes = Encoding.UTF8.GetBytes(Data);
  12.             //Byte[] bKey = new Byte[32];
  13.             Byte[] bKey = new Byte[16];
  14.             Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
  15.             //Array.Copy(Encoding.UTF8.GetBytes(Key.PadLeft(bKey.Length)), bKey, bKey.Length);
  16.             Byte[] bVector = new Byte[16];
  17.             Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);
  18.             //Array.Copy(Encoding.UTF8.GetBytes(Vector.PadLeft(bVector.Length)), bVector, bVector.Length);
  20.             Byte[] Cryptograph = null; // 加密后的密文  
  22.             Rijndael Aes = Rijndael.Create();
  23.             Aes.Mode = CipherMode.CBC;
  25.             try
  26.             {
  27.                 // 开辟一块内存流  
  28.                 using (MemoryStream Memory = new MemoryStream())
  29.                 {
  30.                     // 把内存流对象包装成加密流对象  
  31.                     using (CryptoStream Encryptor = new CryptoStream(Memory,
  32.                      Aes.CreateEncryptor(bKey, bVector),
  33.                      CryptoStreamMode.Write))
  34.                     {
  35.                         // 明文数据写入加密流  
  36.                         Encryptor.Write(plainBytes, 0, plainBytes.Length);
  37.                         Encryptor.FlushFinalBlock();
  39.                         Cryptograph = Memory.ToArray();
  40.                     }
  41.                 }
  42.             }
  43.             catch
  44.             {
  45.                 Cryptograph = null;
  46.             }
  48.             return Convert.ToBase64String(Cryptograph);
  49.         }

C#实现有向量AES解密

  1.        /// <summary>  
  2.         /// AES解密  
  3.         /// </summary>  
  4.         /// <param name="Data">被解密的密文</param>  
  5.         /// <param name="Key">密钥</param>  
  6.         /// <param name="Vector">向量</param>  
  7.         /// <returns>明文</returns>  
  8.         public static String AESDecrypt(String Data, String Key, String Vector)
  9.         {
  10.             Byte[] encryptedBytes = Convert.FromBase64String(Data);
  11.             //Byte[] bKey = new Byte[32];
  12.             Byte[] bKey = new Byte[16];
  13.             Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
  14.             Byte[] bVector = new Byte[16];
  15.             Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);
  17.             Byte[] original = null; // 解密后的明文  
  19.             Rijndael Aes = Rijndael.Create();
  20.             try
  21.             {
  22.                 // 开辟一块内存流，存储密文  
  23.                 using (MemoryStream Memory = new MemoryStream(encryptedBytes))
  24.                 {
  25.                     // 把内存流对象包装成加密流对象  
  26.                     using (CryptoStream Decryptor = new CryptoStream(Memory,
  27.                     Aes.CreateDecryptor(bKey, bVector),
  28.                     CryptoStreamMode.Read))
  29.                     {
  30.                         // 明文存储区  
  31.                         using (MemoryStream originalMemory = new MemoryStream())
  32.                         {
  33.                             Byte[] Buffer = new Byte[1024];
  34.                             Int32 readBytes = 0;
  35.                             while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
  36.                             {
  37.                                 originalMemory.Write(Buffer, 0, readBytes);
  38.                             }
  40.                             original = originalMemory.ToArray();
  41.                         }
  42.                     }
  43.                 }
  44.             }
  45.             catch
  46.             {
  47.                 original = null;
  48.             }
  49.             return Encoding.UTF8.GetString(original);
  50.         }

以上方法，参考网络中的文章
https://www.cnblogs.com/liqipeng/archive/2013/03/23/4576174.html
亲测可用。

2024-01-11 23:25:39  user 阅读(81) 评论(0) 标签：AES,解密算法,Java算法加密,C#解密,C#加密,Java解密 分类：C#