AES用C++逐步实现

最新推荐文章于 2024-05-12 16:55:54 发布
最新推荐文章于 2024-05-12 16:55:54 发布
阅读量141 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dragonandsky/article/details/130574804
版权

AES用C++实现

文章目的：借用C++去实现AES代码。同时打印每一步的结果，可以用来验证自己写的AES算法哪一步结果是否正确。

文章内容：

装满数据的头文件：Tables.h

#ifndef TABLES_H
#define TABLES_H
typedef unsigned char BYTE;
typedef struct  {
	BYTE wi[4];
}word;
const BYTE 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
};
const BYTE InvS_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
};
const int ShiftRow_Table[4][4] = {
0,1,2,3,
1,2,3,0,
2,3,0,1,
3,0,1,2
};
const int InvShiftRow_Table[4][4] = {
0,1,2,3,
3,0,1,2,
2,3,0,1,
1,2,3,0
};
const BYTE CX_Table[4][4] = {
	0x02,0x03,0x01,0x01,
	0x01,0x02,0x03,0x01,
	0x01,0x01,0x02,0x03,
	0x03,0x01,0x01,0x02
};
const BYTE InvCX_Table[4][4] = {
	0x0e,0x0b,0x0d,0x09,
	0x09,0x0e,0x0b,0x0d,
	0x0d,0x09,0x0e,0x0b,
	0x0b,0x0d,0x09,0x0e
};
//秘钥
word w[44];
BYTE RC[12] = {0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1B,0x36,0x6C};

#endif

源代码文件

#include<iostream>
#include<cmath>
#include"Tables.h"
using namespace std;
void PrintfHex(BYTE  Data_In) {
	cout << hex << (unsigned int)Data_In;
}
void PrintfRe(BYTE** Data_In) {
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			PrintfHex(Data_In[i][j]);
			cout << " ";
		}
		cout << endl;
	}
}
void PrintfLine(BYTE ** Data_In) {
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			printf("%02hx", Data_In[j][i]);
		}
	}
	cout << endl;
}
//计算高四位值和低四位值
int* S_R_L(BYTE Data_In) {
	int R_L[2] = {0,0};
	int i = 0;
	for (; i < 4; i++) {
		if ((Data_In >> i) & 1) {
			R_L[1] += pow(2, i);
		}
	}
	for (int j = 0; j < 4; j++, i++) {
		if ((Data_In >> i) & 1) {
			R_L[0] += pow(2, j);
	}
	}
	return R_L;
}
void PrintfKey(word data[44]) {
	cout << "秘钥扩展：" << endl;
	int j = 0;
	for (int k = 0; k < 11; k++) {
		for (int i = 0; i < 4; i++) {
			for (j=k*4; j < 4*(k+1); j++) {
				PrintfHex(data[j].wi[i]);
				cout << " ";
			}
			cout << endl;
		}
		cout << endl;
	}

}
//取为1的最高位
int Get_Max(BYTE Data_In) {
	int max = 0;
	for (int i = 0; i < 8; i++) {
		if ((Data_In >> i) & 1) { max = i;}
	}
	return max;
}
//xtime函数
BYTE X_Time(BYTE Data_In) {
	BYTE TEMP;
	if ((Data_In>> 7)&1){
	TEMP = Data_In << 1;
	TEMP = TEMP ^ 0x1B;
	}
	else { TEMP = Data_In << 1; }
	return TEMP;
}
//N_times
BYTE N_Time(BYTE Data_In, BYTE Mul) {
	if (Get_Max(Mul) == 0) { return Data_In; }
	else {
		BYTE TEMP=Data_In;
		
		for (int i = 0; i < Get_Max(Mul); i++) {
			TEMP = X_Time(TEMP);
		}
		Mul = Mul ^ (BYTE)pow(2, Get_Max(Mul));
		if (Mul == 0x00) { return TEMP; }
		else { return TEMP ^ N_Time(Data_In, Mul); }
	}
}
//矩阵计算
BYTE CalculateMatrix(BYTE State0, BYTE State1, BYTE State2, BYTE State3, BYTE C0, BYTE C1, BYTE C2, BYTE C3 ) {
	BYTE TEMP0 = N_Time(State0,C0);
	BYTE TEMP1 = N_Time(State1, C1);
	BYTE TEMP2 = N_Time(State2, C2);
	BYTE TEMP3 = N_Time(State3, C3);
	return TEMP0 ^ TEMP1^ TEMP2^ TEMP3;
}
//S
void ByteSub(BYTE** State) {
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			State[i][j] = S_Table[S_R_L(State[i][j])[0]][S_R_L(State[i][j])[1]];
		}
	}
}
//行移位
void ShiftRow(BYTE** State) {
	BYTE** TEMP = new BYTE * [4];
	for (int i = 0; i < 4; i++) {
		TEMP[i] = new BYTE[4];
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			TEMP[i][j] = State[i][ShiftRow_Table[i][j]];
		}
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			State[i][j] = TEMP[i][j];
		}
	}
	
}
void InvShiftRow(BYTE** State) {
	BYTE** TEMP = new BYTE * [4];
	for (int i = 0; i < 4; i++) {
		TEMP[i] = new BYTE[4];
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			TEMP[i][j] = State[i][InvShiftRow_Table[i][j]];
		}
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			State[i][j] = TEMP[i][j];
		}
	}

}
void InvByteSub(BYTE** State) {
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			State[i][j] = InvS_Table[S_R_L(State[i][j])[0]][S_R_L(State[i][j])[1]];
		}
	}
}
void InvMixColumn(BYTE** State) {
	BYTE** TEMP = new BYTE * [4];
	for (int i = 0; i < 4; i++) {
		TEMP[i] = new BYTE[4];
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			TEMP[i][j] = CalculateMatrix(State[0][j], State[1][j], State[2][j], State[3][j], InvCX_Table[i][0], InvCX_Table[i][1], InvCX_Table[i][2], InvCX_Table[i][3]);
		}
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			State[i][j] = TEMP[i][j];
		}
	}
}
//列混淆
void MixColumn(BYTE** State) {
	BYTE** TEMP = new BYTE * [4];
	for (int i = 0; i < 4; i++) {
		TEMP[i] = new BYTE[4];
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			TEMP[i][j] = CalculateMatrix(State[0][j], State[1][j], State[2][j], State[3][j], CX_Table[i][0], CX_Table[i][1], CX_Table[i][2], CX_Table[i][3]);
		}
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			State[i][j] = TEMP[i][j];
		}
	}
}
word RotWord(word Data_In) {
	BYTE TEMP = Data_In.wi[0];
	for (int i = 0; i < 3; i++) {
		Data_In.wi[i] = Data_In.wi[i + 1];
	}
	Data_In.wi[3] = TEMP;
	return Data_In;
}
word SubWord(word Data_In) {
	for (int i = 0; i < 4; i++) {
		Data_In.wi[i] = S_Table[S_R_L(Data_In.wi[i])[0]][S_R_L(Data_In.wi[i])[1]];
	
	}
	return Data_In;
}
//轮秘钥扩展 NK秘钥字长度【4个BYTE为一个字】
void KeyExpansion(BYTE Key[4][4],word w[44],int Nk) {
	word temp;
	//初始秘钥复制  列复制成w中的行
	for (int i = 0; i < Nk; i++) {
		for (int j = 0; j < 4; j++) {
			w[i].wi[j] = Key[j][i];
		}
	}
	for (int i = Nk; i < 44; i++) {
		temp = w[i - 1];
		if (i % Nk == 0) {
			temp = SubWord(RotWord(temp));
			temp.wi[0] = temp.wi[0] ^ RC[i / Nk];
		}
		else if (Nk > 6 && (i % Nk == 4)) {
			temp = SubWord(temp);
		}
		for (int j = 0; j < 4; j++)
		{
			w[i].wi[j] = temp.wi[j] ^w[i-Nk].wi[j];
		}
	}
}
void AddRoundKey(BYTE ** State,word* RoundKey) {
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			State[j][i] = State[j][i] ^ RoundKey[i].wi[j];
		}
	}
}
void Round(BYTE**State,word *RoundKey) {
	//S盒变换
	cout << "I_start   :";
	ByteSub(State);
	PrintfLine(State);
	//行移位变换
	cout << "shiftRow  :";
	ShiftRow(State);
	PrintfLine(State);
	//列混淆
	cout << "MixColumn :";
	MixColumn(State);
	PrintfLine(State);
	//轮秘钥变换
	cout << "AddKey    :";
	AddRoundKey(State, RoundKey);
	PrintfLine(State);
}
void InvRound(BYTE** State, word* RoundKey) {
	//逆行移位变换
	cout << "R_Shift   :";
	InvShiftRow(State);
	PrintfLine(State);
	//逆S盒变换
	cout << "R_SBox    :";
	InvByteSub(State);
	PrintfLine(State);
	//轮秘钥变换
	cout << "R_AdddK   :";
	AddRoundKey(State, RoundKey);
	PrintfLine(State);
	//列混淆
	cout << "R_MixCo   :";
	InvMixColumn(State);
	PrintfLine(State);

}
void FinalRound(BYTE** State, word* RoundKey) {
	//S盒变换
	cout << "F_S       :";
	ByteSub(State);
	PrintfLine(State);
	//行移位变换
	cout << "F_ShiftRow:";
	ShiftRow(State);
	PrintfLine(State);
	//轮秘钥变换
	cout << "F_Add     :";
	AddRoundKey(State, RoundKey);
	PrintfLine(State);
}
void InvFinalRound(BYTE** State, word* RoundKey) {
	//逆行移位变换
	cout << "F_ShiftRow:";
	InvShiftRow(State);
	PrintfLine(State);
	cout << "F_S       :";
	//逆S盒变换
	InvByteSub(State);
	PrintfLine(State);
	//轮秘钥加
	cout << "F_Add     :";
	AddRoundKey(State,RoundKey);
	PrintfLine(State);
}
BYTE** AES_ENC(BYTE** Mes) {
//轮秘钥加变换
	AddRoundKey(Mes, &w[0]);
	cout << "轮秘钥加  :";
	PrintfLine(Mes);
	for (int i = 1; i < 10; i++) { 
		cout << "第" << i << "轮     ：*******************************" << endl;
		Round(Mes, &w[i*4]);
	//cout << "第" << i << "轮结果" << endl;
	//PrintfRe(Mes);
	}
	//最后一轮
	cout << "最后一轮  :*******************************" << endl;
	FinalRound(Mes, &w[40]);
	return Mes;
}
//解密
BYTE** AES_DEC(BYTE** Mes_Code) {
	cout << "轮秘钥加  :";
	AddRoundKey(Mes_Code, &w[40]);
	PrintfLine(Mes_Code);
	for (int i = 9; i > 0; i--) { 
		cout << "第" << i << "轮     ：*******************************" << endl;
		InvRound(Mes_Code, &w[i * 4]); }
	cout << "最后一轮  :********************************" << endl;
	InvFinalRound(Mes_Code, &w[0]);
	return Mes_Code;
}
int main() {
	BYTE** S_Re = new BYTE * [4];
	BYTE** ShiftRow_Re = new BYTE * [4];
	BYTE** MixColumn_Re = new BYTE * [4];
	BYTE** Mes_RE = new BYTE * [4];
	for (int i = 0; i < 4; i++) {
		ShiftRow_Re[i] = new BYTE[4];
		S_Re[i] = new BYTE[4];
		MixColumn_Re[i] = new BYTE[4];
		Mes_RE[i] = new BYTE[4];
	}
	//HI cryptography!
	BYTE Key[4][4]
	{
		0x00, 0x04, 0x08, 0x0c,
		0x01, 0x05, 0x09, 0x0d,
		0x02, 0x06, 0x0a, 0x0e,
		0x03, 0x07, 0x0b, 0x0f
	};
	//Have a Mole.Run!
	BYTE temp[4][4] = {
		0x00, 0x44, 0x88, 0xcc,
		0x11, 0x55, 0x99, 0xdd,
		0x22, 0x66, 0xaa, 0xee,
		0x33, 0x77, 0xbb, 0xff
	};
	BYTE** Mes = new BYTE * [4];
	BYTE** Mes_Code = new BYTE * [4];
	for (int i = 0; i < 4; i++) {
		Mes[i] = new BYTE[4];
		Mes_Code[i] = new BYTE[4];
		for (int j = 0; j < 4; j++) {
			Mes[i][j] = temp[i][j];
		}
	}
	cout << "明文      :";
	PrintfLine(Mes);
	//生成轮秘钥
	KeyExpansion(Key, w, 4);
	//PrintfKey(w);
	Mes_Code = AES_ENC(Mes);
	cout << "密文      :";
	PrintfLine(Mes_Code);
	//解密
	Mes_RE = AES_DEC(Mes_Code);
	cout << "解密结果  :";
	PrintfLine(Mes_RE);
	return 0;
}

总结：

阁下莫非东西
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
分组密码算法AES的C/C++编程实现
m0_63002183的博客
07-10 4817
实验过程中，意识到要实现完整地AES流程是相对十分复杂的，要提前对密钥进行密钥扩展，将明文转化成十六进制变为矩阵，加密过程中，先用初始密钥进行异或，再做九轮字节代换、行移位、列混合；AES加密过程先是明文经过初始化变换，其次再经过九轮循环运算，每一次循环运算都要依次进行字节代换、行移位、列混合和轮密钥加，九轮循环运算结束后，再进行一次最终轮运算，这一轮与前面的九轮的区别除了不进行列混合，其余的不变，也即是最后一轮依次进行字节代换、行移位和轮密钥加，经过这一步骤得到的即为密文。行移位，一个比较简单的置换；
AES加解密算法（C++实现）
03-05
支持 CFB, OFB, CBC, ECB 模式，支持256字节以下任意长度数据加解密，也可以放开成任意长度数据加解密。 其中：AES.cpp 中为算法的实现代码;Test.cpp为测试程序
AES加密算法原理(C++实现)
m0_47533197的博客
04-04 7516
AES加密算法(c++)实现
AES对称加密算法原理、C++代码示例
最新发布
Bobowen的博客
05-12 760
高级加密标准（AES，全称：Advanced Encryption Standard）是一种对称加密算法，由美国国家标准与技术研究院（NIST）于2001年发布。它取代了数据加密标准（DES），成为许多政府、企业和机构广泛使用的标准加密方法。AES (Advanced Encryption Standard) 是一种对称加密算法，由 NIST 于 2001 年发布，取代了 DES。它通过多轮数学操作将明文转换为密文，密钥长度为 128、192 或 256 位。主要步骤包括字节代替、行移位、列混合和轮密钥加。
AES加密算法的C++实现
dbbaq24022的专栏
12-13 4023
摘要：作为新一代的加密标准，AES 旨在取代 DES（请看《DES加密算法的C++实现》），以适应当今分布式开放网络对数据加密安全性的要求。本文在分析了 AES 加密原理的基础上着重说明了算法实现的具体步骤，并用 C++ 实现了对文件的加密和解密。 一、AES 介绍 AES（高级加密标准，Advanced Encryption Standard），在密码学中又称 ...
AES加密——AES加密原理与C++实现AES加密
知来者逆的博客
03-09 5144
AES-256 密钥长度为 256 位，提供了极高的安全性。由于其密钥长度更长，因此具有更大的密钥空间，从而增加了破解的难度，即使是通过蛮力攻击也是很不好破解。
AES加解密之C++实现
热门推荐
lixiang987654321的专栏
10-11 1万+
一、AES介绍 AES，高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的作用与意义： 明文P 没有经过加密的数据。 密钥K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给
aes，aes算法的vc实现
02-15
总的来说，AES算法的VC实现需要深入理解AES的内部工作原理，并能够将其转换为有效的C++代码。通过实践和调试，可以逐步完善和优化算法实现，提高代码的效率和可靠性。在处理敏感信息时，确保正确地使用AES算法是非常...
AES加密解密算法实现（C、C++）
05-24
本资源提供了C和C++语言实现的AES加密解密算法，对于学习和理解AES的工作原理以及实际应用具有很高的价值。 AES算法起源于比利时密码学家Joan Daemen和Vincent Rijmen设计的Rijndael算法，2001年被美国国家标准与...
C++实现putty
06-29
在本文中，我们将深入探讨如何使用C++来实现类似PuTTY的功能，以及这个过程涉及的关键技术和挑战。 首先，要实现PuTTY的C++版本，我们需要理解这些协议的工作原理。**Telnet** 是一种早期的网络协议，允许用户通过...
qt aes加密 源代码
05-20
QT AES加密源代码示例是使用C++编程语言在QT框架下实现的一种数据加密与解密的方法。AES，全称为Advanced Encryption Standard（高级加密标准），是一种广泛应用的块密码算法，因其高效性和安全性而被广泛采用。本文...
C++实现的openssl实现的一些例子
11-25
本资源集包含了用C++实现的OpenSSL的一些实例，对于学习和理解如何在C++中使用OpenSSL非常有帮助。 首先，让我们深入了解一下C++与OpenSSL的结合。C++以其高效、面向对象的特性，常常用于构建复杂的系统和网络安全...
AES加密解密 c++ 实现全代码
11-14
高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。 该压缩包中包括aes加密算法的c++实现代码。
AES加密解密算法设计（C++）
毕业作品网站
10-20 3677
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]) //行移位。
AES算法的原理与C/C++实现
qq_54223524的博客
01-27 1058
AES（高级加密标准，Advanced Encryption Standard）是一种广泛使用的对称密钥加密算法，旨在替代老旧的DES（数据加密标准）。AES由比利时密码学家文森特·瑞门（Vincent Rijmen）和乔安·戴门（Joan Daemen）设计，于2001年被美国国家标准与技术研究院（NIST）正式采纳为标准。AES是一个基于替代-置换网络的迭代算法，它支持多种长度的密钥和数据块（128、192和256位），但最常用的是128位的块大小。
AES对称加密C++实现及使用方法
小飞侠的博客
06-14 3514
AES对称加密 高级加密标准(AES,Advanced Encryption Standard)是最常见的对称加密算法。 对称加密算法也就是加密和解密用相同的密钥. 明文P , 没有经过加密的数据。 密钥K,用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。 密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏。 AES加密函数 , 设AES加密函数为E，则 C = E(K, P),其中P为明文，K为密钥，C为密文。 密文C ,经加密函数处理后的数据
C++实现AES算法
青牛的专栏
03-27 1万+
AES.h #pragma once #include"stdafx.h" #define AES_KEY_ROW_NUMBER 4 #define AES_KEY_COLUMN_NUMBER 4 #define AES_ROUND_COUNT 10 class AES { public: AES(void); AES(BYTE* key); virtual ~AES(void);
c++实现AES加密解密算法
丁爸的博客
11-26 5575
本文讲解c++实现AES加密解密功能，主要包含两部分： 实现AES加密解密功能的静态库 实现调用静态库的测试文件 本文代码是在win10系统，VS2013下调试。 一、AES加解密静态库 创建静态库工程CAesLib 创建外部调用类CAes256 #ifndef ENCRYPT_DECRYPT_H #define ENCRYPT_DECRYPT_H #include <string> using namespace std; class CAes256 { public: CAe
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加密C++实现
08-29
要在C语言中实现AES加密，可以按照以下步骤： 1. 首先，编写一个`AddRoundKey`函数，用于将密钥与状态矩阵进行异或操作。这个函数接收三个参数：一个指向状态矩阵的指针、一个指向扩展密钥的指针和当前轮数。在该函数中，将密钥字节与状态矩阵的相应字节进行异或操作。 2. 接下来，编写一个`SubBytes`函数，用于将状态矩阵中的每个字节替换为S盒中对应的字节。这个函数可以根据AES标准中的S盒表进行实现。 3. 再编写一个`ShiftRows`函数，用于对状态矩阵的行进行循环左移操作。该函数将状态矩阵的每一行进行左移，第一行不变，第二行左移一个字节，第三行左移两个字节，第四行左移三个字节。 4. 然后，编写一个`MixColumns`函数，用于对状态矩阵的列进行混合操作。该函数将状态矩阵的每一列进行混合，使用有限域上的乘法运算。 5. 最后，进行多轮的加密操作。在每一轮中，依次调用`SubBytes`、`ShiftRows`、`MixColumns`和`AddRoundKey`函数。在最后一轮中，不调用`MixColumns`函数。 通过以上步骤，就可以实现AES加密算法的C语言实现。可以使用`AesEncrypt`函数来进行加密操作，该函数接收三个参数：一个指向要加密的数据块的指针、一个指向扩展密钥的指针和加密轮数。如果需要解密操作，可以使用`Contrary_AesEncrypt`函数，它的实现与`AesEncrypt`函数类似，但是在每一轮中进行的操作相反。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [分组密码算法AES的C/C++编程实现](https://blog.csdn.net/m0_63002183/article/details/131640257)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阁下莫非东西

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值