AES算法实现C++

最新推荐文章于 2023-09-23 09:12:56 发布
最新推荐文章于 2023-09-23 09:12:56 发布
阅读量732 收藏 8
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_61587494/article/details/130375440
版权

AES加密算法

编程环境：VS2019

编程语言：c++

结果展示：

 

#include <iostream>
#include <string.h>
using namespace std;

//明文分组长度选择128
#define N_plaintext 128
//明文4列
#define Nb 4

//密钥长度选择128
#define N_key 128
//密钥4列
#define Nk 4

//生成状态(字节)
void ProduceState(char* plaintext, unsigned char state[4][4]);

//字节代换
void ByteSub(unsigned char state[4][4]);

//行移位
void ShiftRow(unsigned char state[4][4]);

//列混合
void MixColumn(unsigned char state[4][4]);

//列混合取模辅助函数
unsigned char helper(unsigned char c, int n);

//列混合取模辅助函数2
unsigned char helper_base(unsigned char c);

//密钥加
void AddRoundKey(unsigned char state[4][4], unsigned char roundKey[11][4][4],int n);

//轮函数
void Round(unsigned char state[4][4], unsigned char roundKey[11][4][4],int n);

//最后轮函数
void FinalRound(unsigned char state[4][4], unsigned char roundKey[11][4][4]);

//密钥扩展
void KeyExpansion(char key[], unsigned char roundKey[11][4][4]);

//辅助赋值函数
void Copy(unsigned char temp[4], unsigned char w[4][44],int n);

//密钥扩展SubByte
void SubByte_Key(unsigned char temp[4]);

//密钥扩展RotByte
void RotByte(unsigned char temp[4]);

//加密
void Rijndael(unsigned char state[4][4], char key[N_key]);

//解密
void InvRijndael(unsigned char state[4][4], char key[N_key]);

//逆字节代换
void InvByteSub(unsigned char state[4][4]);

//逆行移位
void InvShiftRow(unsigned char state[4][4]);

//逆列混合
void InvMixColumn(unsigned char state[4][4]);

//逆轮函数
void InvRound(unsigned char state[4][4], unsigned char roundKey[11][4][4], int n);

//逆最后轮函数
void InvFinalRound(unsigned char state[4][4], unsigned char roundKey[11][4][4]);

//输出状态
void Print(unsigned char state[4][4]);

//主函数
int main()
{
	//一组明文
	char plaintext[N_plaintext + 1];
	//一组密钥
	char key[N_key + 1];

	//菜单
	cout << "请选择：\n";
	cout << "1.用默认明文和密钥\n";
	cout << "2.手动输入明文和密钥\n";
	int choice;
	cin >> choice;
	cin.clear();
	cin.ignore();
	if (choice == 1)
	{
		strcpy_s(plaintext, 129, "00110010010000111111011010101000100010000101101000110000100011010011000100110001100110001010001011100000001101110000011100110100");
		strcpy_s(key,129, "00101011011111100001010100010110001010001010111011010010101001101010101111110111000101011000100000001001110011110100111100111100");
	}
	else
	{
		cout << "请输入128bit明文：\n";
		cin.getline(plaintext, 129);

		cout << "请输入128bit密钥：\n";
		cin.getline(key, 129);
	}
	system("cls");
	
	//状态
	unsigned char plainState[4][Nb];

	//明文生成状态
	ProduceState(plaintext, plainState);

	//输出明文和密钥
	cout << "明文为：\n";
	Print(plainState);

	//加密
	Rijndael(plainState, key);
	cout << "\n加密后密文为：\n";
	Print(plainState);

	//解密
	InvRijndael(plainState, key);
	cout << "\n再对密文解密后明文为：\n";
	Print(plainState);

	system("pause");
	return 0;
}

//生成状态(字节)
void ProduceState(char* plaintext, unsigned char state[4][4])
{
	int temp,index=0;
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			temp = 0;
			for (int k = 128; k >= 1; k /= 2)
			{
				temp += k * (plaintext[index++] - '0');
			}
			state[j][i] = (unsigned char)temp;
		}
	}
}

//字节代换
void ByteSub(unsigned char state[4][4])
{
	//S盒
	const unsigned char S_Table[16][16] =
	{
	0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
	0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
	0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
	0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
	0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
	0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
	0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
	0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
	0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
	0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
	0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
	0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
	0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
	0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
	0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
	0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
	};

	//字节代换
	for (int i = 0; i < 4; i++)
		for (int j = 0; j < 4; j++)
		{
			state[i][j] = S_Table[(int)(state[i][j] >> 4)][(int)(state[i][j] & 0x0f)];
		}
}

//行移位
void ShiftRow(unsigned char state[4][4])
{
	//第1行
	unsigned char temp=state[1][0];
	for (int i = 1; i <= 3; i++)
		state[1][i - 1] = state[1][i];
	state[1][3] = temp;

	//第2行
	temp = state[2][0];
	state[2][0] = state[2][2];
	state[2][2] = temp;
	temp = state[2][1];
	state[2][1] = state[2][3];
	state[2][3] = temp;

	//第3行
	temp = state[3][3];
	for (int i = 3; i >= 1; i--)
		state[3][i] = state[3][i - 1];
	state[3][0] = temp;
}

//列混合
void MixColumn(unsigned char state[4][4])
{
	//复制一份state
	unsigned char tempcopy[4][4];
	for (int i = 0; i < 16; i++)
		*(*tempcopy + i) = *(*state + i);

	for (int column = 0; column < 4; column++)
	{
		state[0][column] = helper(tempcopy[0][column], 2) ^ helper(tempcopy[1][column], 3)
			^ helper(tempcopy[2][column], 1) ^ helper(tempcopy[3][column], 1);
		state[1][column] = helper(tempcopy[0][column], 1) ^ helper(tempcopy[1][column], 2)
			^ helper(tempcopy[2][column], 3) ^ helper(tempcopy[3][column], 1);
		state[2][column] = helper(tempcopy[0][column], 1) ^ helper(tempcopy[1][column], 1)
			^ helper(tempcopy[2][column], 2) ^ helper(tempcopy[3][column], 3);
		state[3][column] = helper(tempcopy[0][column], 3) ^ helper(tempcopy[1][column], 1)
			^ helper(tempcopy[2][column], 1) ^ helper(tempcopy[3][column], 2);
	}
}

//列混合取模辅助函数
unsigned char helper(unsigned char c, int n)
{
	if (n == 1)
		return c;
	else if (n == 2)
		return helper_base(c);
	else  if (n == 3)
		return helper_base(c) ^ c;
	else if (n == 9)
		return helper_base(helper_base(helper_base(c))) ^ c;
	else if (n == 11)
		return helper_base(helper_base(helper_base(c))) ^ helper_base(c) ^ c;
	else if (n == 13)
		return helper_base(helper_base(helper_base(c))) ^ helper_base(helper_base(c)) ^ c;
	else  //n==14
		return helper_base(helper_base(helper_base(c))) ^ helper_base(helper_base(c)) ^ helper_base(c);
}

//列混合取模辅助函数2
unsigned char helper_base(unsigned char c)
{
	if ((c >> 7 & 0x01) == 1)
	{
		return (unsigned char)((c << 1) ^ (0x1b));
	}
	else
		return c << 1;
}

//密钥加
void AddRoundKey(unsigned char state[4][4], unsigned char roundKey[11][4][4],int n)
{
	for (int i = 0; i < 4; i++)
		for (int j = 0; j < 4; j++)
			state[i][j] ^= roundKey[n][i][j];
}

//轮函数
void Round(unsigned char state[4][4], unsigned char roundKey[11][4][4],int n)
{
	ByteSub(state);
	//Print(state);
	ShiftRow(state);
	//Print(state);
	MixColumn(state);
	//Print(state);
	AddRoundKey(state, roundKey,n);
	//Print(state);
}

//最后轮函数
void FinalRound(unsigned char state[4][4], unsigned char roundKey[11][4][4])
{
	ByteSub(state);
	ShiftRow(state);
	AddRoundKey(state, roundKey,10);
}

//辅助赋值函数
void Copy(unsigned char temp[4], unsigned char w[4][44],int n)
{
	temp[0] = w[0][n];
	temp[1] = w[1][n];
	temp[2] = w[2][n];
	temp[3] = w[3][n];
}

//密钥扩展SubByte
void SubByte_Key(unsigned char temp[4])
{
	//S盒
	const unsigned char S_Table[16][16] =
	{
	0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
	0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
	0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
	0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
	0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
	0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
	0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
	0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
	0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
	0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
	0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
	0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
	0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
	0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
	0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
	0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
	};

	//字节代换
	for (int i = 0; i < 4; i++)
		temp[i] = S_Table[(int)(temp[i] >> 4)][(int)(temp[i] & 0x0f)];
}

//密钥扩展RotByte
void RotByte(unsigned char temp[4])
{
	unsigned char ttemp = temp[0];
	for (int i = 1; i <= 3; i++)
		temp[i - 1] = temp[i];
	temp[3] = ttemp;
}

//密钥扩展
void KeyExpansion(char key[], unsigned char roundKey[11][4][4])
{
	ProduceState(key, roundKey[0]);
	//用于密钥扩展 Rcon
	const unsigned char Rcon[11] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 };

	//辅助数组
	unsigned char w[4][44];
	for (int i = 0; i < 4; i++)
		for (int j = 0; j < 4; j++)
			w[i][j] = roundKey[0][i][j];

	unsigned char temp[4];
	for (int i = 4; i < 44; i++)
	{
		Copy(temp, w, i - 1);
		if (i % Nk == 0)
		{
			RotByte(temp);
			SubByte_Key(temp);
			temp[0] ^= Rcon[i / Nk];
		}
		for (int j = 0; j < 4; j++)
		{
			w[j][i] = w[j][i - Nk] ^ temp[j];
			roundKey[i / 4][j][i % 4] = w[j][i];
		}
	}
}

//加密
void Rijndael(unsigned char state[4][4], char key[N_key])
{
	unsigned char roundkey[11][4][4];
	KeyExpansion(key, roundkey);

	//输出密钥
	cout << "\n密钥为：\n";
	Print(roundkey[0]);
	
	AddRoundKey(state, roundkey, 0);
	for (int i = 1; i < 10; i++)
		Round(state, roundkey, i);
	FinalRound(state, roundkey);
}

//解密
void InvRijndael(unsigned char state[4][4], char key[N_key])
{
	unsigned char roundkey[11][4][4];
	KeyExpansion(key, roundkey);
	//逆密钥
	for (int i = 1; i <= 9; i++)
		InvMixColumn(roundkey[i]);

	AddRoundKey(state, roundkey, 10);
	for (int i = 9; i >= 1; i--)
		InvRound(state, roundkey, i);
	InvFinalRound(state, roundkey);
}

//输出状态
void Print(unsigned char state[4][4])
{
	cout << "二进制形式：\n";
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			for (int k = 7; k >= 0; k--)
			{
				cout << (state[j][i] >> k & 0x01);
			}
		}
	}
	cout << "\n十六进制形式：\n";
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("%#x ", state[j][i]);
		}
	}
	cout << endl;
}

//逆字节代换
void InvByteSub(unsigned char state[4][4])
{
	//逆S盒
	const unsigned char ReS_Table[16][16] =
	{
	0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
	0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
	0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
	0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
	0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
	0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
	0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
	0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
	0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
	0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
	0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
	0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
	0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
	0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
	0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
	0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
	};

	//逆字节代换
	for (int i = 0; i < 4; i++)
		for (int j = 0; j < 4; j++)
		{
			state[i][j] = ReS_Table[(int)(state[i][j] >> 4)][(int)(state[i][j] & 0x0f)];
		}
}

//逆行移位
void InvShiftRow(unsigned char state[4][4])
{
	//第1行
	unsigned char temp = state[1][3];
	for (int i = 3; i >= 1; i--)
		state[1][i] = state[1][i - 1];
	state[1][0] = temp;

	//第2行
	temp = state[2][0];
	state[2][0] = state[2][2];
	state[2][2] = temp;
	temp = state[2][1];
	state[2][1] = state[2][3];
	state[2][3] = temp;

	//第3行
	temp = state[3][0];
	for (int i = 1; i <= 3; i++)
		state[3][i - 1] = state[3][i];
	state[3][3] = temp;
	
}

//逆列混合
void InvMixColumn(unsigned char state[4][4])
{
	//复制一份state
	unsigned char tempcopy[4][4];
	for (int i = 0; i < 16; i++)
		*(*tempcopy + i) = *(*state + i);

	for (int column = 0; column < 4; column++)
	{
		state[0][column] = helper(tempcopy[0][column], 14) ^ helper(tempcopy[1][column], 11)
			^ helper(tempcopy[2][column], 13) ^ helper(tempcopy[3][column], 9);
		state[1][column] = helper(tempcopy[0][column], 9) ^ helper(tempcopy[1][column], 14)
			^ helper(tempcopy[2][column], 11) ^ helper(tempcopy[3][column], 13);
		state[2][column] = helper(tempcopy[0][column], 13) ^ helper(tempcopy[1][column], 9)
			^ helper(tempcopy[2][column], 14) ^ helper(tempcopy[3][column], 11);
		state[3][column] = helper(tempcopy[0][column], 11) ^ helper(tempcopy[1][column], 13)
			^ helper(tempcopy[2][column], 9) ^ helper(tempcopy[3][column], 14);
	}
}

//逆轮函数
void InvRound(unsigned char state[4][4], unsigned char roundKey[11][4][4], int n)
{
	InvByteSub(state);
	InvShiftRow(state);
	InvMixColumn(state);
	AddRoundKey(state, roundKey, n);
}

//逆最后轮函数
void InvFinalRound(unsigned char state[4][4], unsigned char roundKey[11][4][4])
{
	InvByteSub(state);
	InvShiftRow(state);
	AddRoundKey(state, roundKey, 0);
}

枝竹
关注
【AES算法详解及代码实现】
毫无简介
03-26 1374
本菜鸡最近在实际开发项目中，遇到了AES算法，从客户的需求来看主要用于方向盘锁和发动机防盗锁，运用了如下一些加密流程，其中涉及到AES算法，我就饶有兴致的学习了一下，也看了网上的大部分教程，总结了一些自己学习过程中的遇到的重难点，同时也写了一份代码进行加密计算。因为个人觉得计算量太大了，要重复多次，并没有什么必要，完全可以学会一遍流程之后，读懂加密步骤就行了，不必细算具体数值。（本文图片大部分来源于网络）
AES加密算法的C++实现
dbbaq24022的专栏
12-13 4444
摘要：作为新一代的加密标准，AES 旨在取代 DES（请看《DES加密算法的C++实现》），以适应当今分布式开放网络对数据加密安全性的要求。本文在分析了 AES 加密原理的基础上着重说明了算法实现的具体步骤，并用 C++ 实现了对文件的加密和解密。 一、AES 介绍 AES（高级加密标准，Advanced Encryption Standard），在密码学中又称 ...
AES加密算法(C++实现,附源码)
04-24
AES加密算法(C++实现,附源码) 更多免费资源： http://cleopard.download.youkuaiyun.com
AES算法代码实现(完整C++源代码)
热门推荐
国科大网安二班的博客
01-23 1万+
AES加解密算法全过程实现(C++) 利用C++编程实现了AES的加解密过程。 关于列混合计算不清楚的可以看上一篇博客。 主要针对128bit的明文和密钥给出实现，其他情况需要改一下Nk,Nb,Nr的值和某些地方的数组维度。 byte GFMultiplyByte(byte L, byte R)这个函数是计算多项式模乘的结果（列混淆中的那一步）。 其他想自己动手编编的可以复制一下这里的S盒和逆S盒或者其他常量。 参考书籍是《密码编码与信息安全:C++实践》。 #include <iostream&gt
AES算法实现源码
06-17
完整AES算法实现代码，可直接使用，加密速度10M文件大约18秒
AES加密功能的代码实现
伤心的辣条
07-24 821
那么如何实现AES加密呢？这就成为了很多IT人员的需要解决的问题，今天我们就来一起探讨一下。
AES加解密算法（C++实现）
03-05
支持 CFB, OFB, CBC, ECB 模式，支持256字节以下任意长度数据加解密，也可以放开成任意长度数据加解密。 其中：AES.cpp 中为算法的实现代码;Test.cpp为测试程序
C++实现的AES算法
01-18
总结来说，"C++实现的AES算法"涉及到的是用C++编程语言编写AES加密算法的源代码，修复了可能导致加密解密出错的bug，以保证数据在加密解密过程中不会出现乱码。这个实现可能包括了对AES算法各个步骤的详细理解和优化...
AES加密算法(C++实现,附源码)（2）.pdf
07-10
AES的C++实现涉及几个关键步骤，包括密钥扩展、加密过程和解密过程。 **1. 密钥扩展（Key Expansion）** 密钥扩展是AES加密算法中的一个重要部分，它将用户提供的原始密钥（128位、192位或256位）扩展为足够数量的...
AESjiami.rar_AES 算法_AES加密_AES加密算法_AES加密算法c++_AES算法
09-24
AES算法的核心是基于替换和置换的操作，它采用块加密方式，每个加密块大小固定为128位。AES支持不同的密钥长度，包括128位、192位和256位，这使得其安全性远超DES。加密过程由多个轮次组成，每一轮都包含子密钥生成...
AES 代码实现
honlangwu的博客
09-22 1899
1 分组加密 首先了解下什么是分组加密：分组密码是将明文消息编码表示后的数字（简称明文数字）序列，划分成长度为n的组（可看成长度为n的矢量），每组分别在密钥的控制下变换成等长的输出数字（简称密文数字）序列。 3 ECB的加密方式 http://zh.wikipedia.org/wiki/%E5%9D%97%E5%AF%86%E7%A0%81%E7%9A%84%E5%B7%A5%E4%BD%9C
AES加密算法C语言代码实现
09-26
配套文章解析：https://blog.youkuaiyun.com/u013469753/article/details/108322140 AES加密算法，AES的全称是Advanced Encryption Standard，意思是高级加密标准。它的出现主要是为了取代DES加密算法的，因为我们都知道DES算法的密钥长度是56Bit，因此算法的理论安全强度是2的56次方。 AES密码与分组密码Rijndael基本上完全一致，Rijndael分组大小和密钥大小都可以为128位、192位和256位。然而AES只要求分组大小为128位，因此只有分组长度为128Bit的Rijndael才称为AES算法。
AES加密算法c语言实现代码.
08-30
AES加密算法c语言实现代码
AES加密解密 c++ 实现全代码
11-14
高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。 该压缩包中包括aes加密算法的c++实现代码。
AES算法C++代码
03-20
一个AES算法实现的C++代码，其中包涵使用ECB，CBC，CFB，OFB，CTR的加密方法，并将加密后的密文用BASE64码表示。
AES源代码（完全用C语言实现）
03-30
完全用C语言实现的AES加密算法，用的是最简单的算法，没什么难懂的
AES算法实现、代码
qq_44827634的博客
05-06 4558
AES算法实现详细过程以及部分代码帮助理解
AES加密解密算法设计（C++）
毕业作品网站
10-20 4823
void keyschedule(int key[4][4],int allkey[4][44],int nk,int nr) //128密钥扩展。void addroundkey6(int col[4][4],int allkey[4][52],int nr) //192比特轮密钥加。void addroundkey(int col[4][4],int allkey[4][44],int nr) //128论密钥加。void shiftrows(int col[4][4]) //行移位。
C语言实现AES加密算法的示例代码
最新发布
wzxue1984的博客
09-23 1428
请注意，这只是一个简单的示例，实际的AES加密算法涉及更多复杂的操作，如密钥扩展和轮函数。为了正确实现AES加密算法，建议你参考相关的AES算法标准或参考现有的AES加密库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值