Implementation of AES Encryption in C#

Introduction to the AES Algorithm

Advanced Encryption Standard (English: Advanced Encryption Standard, abbreviation: AES), also known in cryptography as the Rijndael cipher, is a block cipher standard adopted by the U.S. federal government. This standard is used to replace the original DES, has been analyzed by many parties, and is widely used around the world. After a five-year selection process, the Advanced Encryption Standard was published by the National Institute of Standards and Technology (NIST) on November 26, 2001 in FIPS PUB 197, and became an effective standard on May 26, 2002. In 2006, the Advanced Encryption Standard had already become one of the most popular algorithms in symmetric-key encryption.

This algorithm was designed by Belgian cryptographers Joan Daemen and Vincent Rijmen, who combined the two authors' names and submitted it as Rijndael to the Advanced Encryption Standard selection process. (Rijndael is pronounced similarly to "Rhine doll")

AES Encryption Process

The AES encryption process operates on a 4×4 byte matrix, also called the "body (state)", whose initial value is a plaintext block (the size of one element in the matrix is one Byte in the plaintext block). (Because the Rijndael cipher supports larger blocks, the number of rows in its matrix may be increased as appropriate.) During encryption, each round of the AES encryption cycle (except the last round) includes 4 steps:

1. AddRoundKey—each byte in the matrix undergoes an XOR operation with that round key (round key); each subkey is generated by the key generation scheme.
2. SubBytes—through a nonlinear substitution function, each byte is replaced with the corresponding byte by means of a lookup table.
3. ShiftRows—cyclically shift each row in the matrix.
4. MixColumns—an operation to thoroughly mix each column in the matrix. This step uses a linear transformation to mix the four bytes of each inline. In the last encryption cycle, the MixColumns step is omitted and replaced with another AddRoundKey.

C# Code Implementation

Define the default key vector

private static byte[] _aesKetByte = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
private static string _aesKeyStr = Encoding.UTF8.GetString(_aesKetByte);

Randomly generate a key

public static byte[] GetIv(int n)
{
	char[] arrChar = new char[]{
	   'a','b','d','c','e','f','g','h','i','j','k','l','m','n','p','r','q','s','t','u','v','w','z','y','x',
	   '0','1','2','3','4','5','6','7','8','9',
	   'A','B','C','D','E','F','G','H','I','J','K','L','M','N','Q','P','R','T','S','V','U','W','X','Y','Z'
	};

	StringBuilder num = new StringBuilder();

	Random rnd = new Random(DateTime.Now.Millisecond);
	for (int i = 0; i < n; i++)
	{
		num.Append(arrChar[rnd.Next(0, arrChar.Length)].ToString());
	}

	_aesKetByte = Encoding.UTF8.GetBytes(num.ToString());
	return _aesKetByte;
}

AES Encryption

/// <summary>
/// AES加密
/// </summary>
/// <param name="Data">被加密的明文</param>
/// <param name="Key">密钥</param>
/// <param name="Vector">向量</param>
/// <returns>密文</returns>
public static String AESEncrypt(String Data, String Key, String Vector)
{
	Byte[] plainBytes = Encoding.UTF8.GetBytes(Data);

	Byte[] bKey = new Byte[32];
	Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
	Byte[] bVector = new Byte[16];
	Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);

	Byte[] Cryptograph = null; // 加密后的密文

	Rijndael Aes = Rijndael.Create();
	try
	{
		// 开辟一块内存流
		using (MemoryStream Memory = new MemoryStream())
		{
			// 把内存流对象包装成加密流对象
			using (CryptoStream Encryptor = new CryptoStream(Memory,
			Aes.CreateEncryptor(bKey, bVector),
			CryptoStreamMode.Write))
			{
				// 明文数据写入加密流
				Encryptor.Write(plainBytes, 0, plainBytes.Length);
				Encryptor.FlushFinalBlock();

				Cryptograph = Memory.ToArray();
			}
		}
	}
	catch
	{
		Cryptograph = null;
	}

	return Convert.ToBase64String(Cryptograph);
}

AES Decryption

/// <summary>
/// AES解密
/// </summary>
/// <param name="Data">被解密的密文</param>
/// <param name="Key">密钥</param>
/// <param name="Vector">向量</param>
/// <returns>明文</returns>
public static String AESDecrypt(String Data, String Key, String Vector)
{
	Byte[] encryptedBytes = Convert.FromBase64String(Data);
	Byte[] bKey = new Byte[32];
	Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
	Byte[] bVector = new Byte[16];
	Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);

	Byte[] original = null; // 解密后的明文

	Rijndael Aes = Rijndael.Create();
	try
	{
		// 开辟一块内存流，存储密文
		using (MemoryStream Memory = new MemoryStream(encryptedBytes))
		{
			// 把内存流对象包装成加密流对象
			using (CryptoStream Decryptor = new CryptoStream(Memory,
			Aes.CreateDecryptor(bKey, bVector),
			CryptoStreamMode.Read))
			{
				// 明文存储区
				using (MemoryStream originalMemory = new MemoryStream())
				{
					Byte[] Buffer = new Byte[1024];
					Int32 readBytes = 0;
					while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
					{
						originalMemory.Write(Buffer, 0, readBytes);
					}

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

Encrypt and decrypt using the default vector

/// <summary>
/// AES加密(无向量)
/// </summary>
/// <param name="Data">被加密的明文</param>
/// <param name="Key">密钥</param>
/// <returns>密文</returns>
public static string AESEncrypt(String Data, String Key)
{
	return AESEncrypt(Data, Key, _aesKeyStr);

}
/// <summary>
/// AES解密(无向量)
/// </summary>
/// <param name="Data">被加密的明文</param>
/// <param name="Key">密钥</param>
/// <returns>明文</returns>
public static string AESDecrypt(String Data, String Key)
{
	return AESDecrypt(Data, Key, _aesKeyStr);
}