AES对称加密C++实现及使用方法_c++ aes

AES对称加密

高级加密标准(AES,Advanced Encryption Standard)是最常见的对称加密算法。
对称加密算法也就是加密和解密用相同的密钥.

• 明文P ：没有经过加密的数据。

• 密钥K：用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。
  密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏。

• AES加密函数 ： 设AES加密函数为E，则 C = E(K, P),其中P为明文，K为密钥，C为密文。

• 密文C ：经加密函数处理后的数据

• AES解密函数 ：设AES解密函数为D，则 P = D(K, C),其中C为密文，K为密钥，P为明文。
  

AES的基本结构

AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同，如下表所示：

代码实现

//aes128.hpp
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <string>
unsigned char s_box[16][16] = {
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, //0
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, //1
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, //2
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, //3
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, //4
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, //5
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, //6
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, //7
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, //8
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, //9
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, //A
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, //B
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, //C
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, //D
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, //E
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16  //F
};

unsigned char reverse_s_box[16][16] = {
	0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, //0
	0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, //1
	0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, //2
	0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, //3
	0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, //4
	0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, //5
	0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, //6
	0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, //7
	0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, //8
	0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, //9
	0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, //A
	0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, //B
	0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, //C
	0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, //D
	0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, //E
	0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d  //F
};

unsigned char e_mix_cloumn[4][4] = {
	0x02, 0x03, 0x01, 0x01,
	0x01, 0x02, 0x03, 0x01,
	0x01, 0x01, 0x02, 0x03,
	0x03, 0x01, 0x01, 0x02
};

unsigned char reverse_mix_cloumn[4][4] = {
	0x0E, 0x0B, 0x0D, 0x09,
	0x09, 0x0E, 0x0B, 0x0D,
	0x0D, 0x09, 0x0E, 0x0B,
	0x0B, 0x0D, 0x09, 0x0E
};

unsigned int rcon[10] = { 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000,
0x20000000, 0x40000000, 0x80000000, 0x1B000000, 0x36000000 };

unsigned int bytes2word(const char* value){
	return 	(((int)value[0] & 0x000000FF) << 24) |
			(((int)value[1] & 0x000000FF) << 16) |
			(((int)value[2] & 0x000000FF) << 8) |
			((int)value[3] & 0x000000FF);
}

static unsigned int T(const unsigned int* word,const int round){
	unsigned char bt0 = (*word & 0xFF000000) >> 24;
	unsigned int shiftlift =  (*word & 0x00FF0000) << 8 | 
							  (*word & 0x0000FF00) << 8 | 
							  (*word & 0x000000FF) << 8 | 
							  bt0;
	char new_word[4];
	for (int i = 0; i < 4; i++){
		unsigned char tmp = (shiftlift & (0xFF000000 >> (8 * i))) >> (8 * (3 - i));
		short row = (tmp & 0xF0) >> 4;
		short cloumn = tmp & 0x0F;
		new_word[i] = s_box[row][cloumn];
	}
	return ( (((int)new_word[0] << 24) & 0xFF000000) | (((int)new_word[1] << 16) & 0x00FF0000 ) | 
		( ((int)new_word[2] << 8 ) & 0x0000FF00 ) | ((int)new_word[3] & 0x000000FF) ) ^ rcon[round];
}

//密钥扩展函数，将密钥由4个字（16个字节）扩展成44个字
static void extern_key(const char* key, unsigned int* out_w){
	for (int i = 0; i < 4; i++){
		out_w[i] = bytes2word(key + 4 * i);
		//printf("0x%x ", out_w[i]);
	}

	int round = 0;
	//开始扩展计算
	for (int i = 4; i < 44; i++){
		if (i % 4 != 0){
			out_w[i] = out_w[i - 4] ^ out_w[i - 1];
		}
		else{
			out_w[i] = out_w[i - 4] ^ T(&out_w[i - 1], round);
			round++;
		}
		//printf("0x%x ", out_w[i]);
	}
}

//字节代换处理
static void sub_bytes(unsigned char * context, int encode){
	//encode=1：表示使用S盒进行替换，=0：表示使用逆S盒进行替换
	for (int index = 0; index < 16; index++){
		int row = (context[index] & 0xF0) >> 4;
		int cloumn = context[index] & 0x0F;
		if (encode == 1){
			context[index] = s_box[row][cloumn];
		}
		else{
			context[index] = reverse_s_box[row][cloumn];
		}
	}
}

//行位移
static void shift_rows(unsigned char* context,int encode){
	//encode=1：表示加密时左循环位移, = 0:表示解密向右循环位移
	//取16个字节组成4*4二维数组
	char two_dimensional_array[4][4];
	for (int row = 0; row < 4; row++){
		for (int cloumn = 0; cloumn < 4; cloumn++){
			two_dimensional_array[row][cloumn] = context[row + 4 * cloumn];
		}
	}
	//进行行位移操作
	for (int row = 0; row < 4; row++){
		for (int cloumn = 0; cloumn < row; cloumn++){
			if (encode == 1){
				//进行左循环操作
				char tmp = two_dimensional_array[row][0];
				two_dimensional_array[row][0] = two_dimensional_array[row][1];
				two_dimensional_array[row][1] = two_dimensional_array[row][2];
				two_dimensional_array[row][2] = two_dimensional_array[row][3];
				two_dimensional_array[row][3] = tmp;
			}
			else{
				//进行右循环操作
				char tmp = two_dimensional_array[row][3];
				two_dimensional_array[row][3] = two_dimensional_array[row][2];
				two_dimensional_array[row][2] = two_dimensional_array[row][1];
				two_dimensional_array[row][1] = two_dimensional_array[row][0];
				two_dimensional_array[row][0] = tmp;
			}

			*(context + 4 * row + cloumn) = two_dimensional_array[cloumn][row];
		}
	}

	for (int row = 0; row < 4; row++){
		for (int cloumn = 0; cloumn < 4; cloumn++){
			*(context + 4 * row + cloumn) = two_dimensional_array[cloumn][row];
		}
	}
}

static int GFMul_2(int s){
	int result = s << 1;
	int bit_7 = result & 0x00000100;
	if (bit_7 != 0){
		result &= 0x000000FF;//取低位一个字节
		result ^= 0x0000001B;//与二进制00011011进行异或运算
	}
	return result;
}

static int GFMul_3(int s){
	return GFMul_2(s) ^ s;
}

static int GFMul_4(int s){
	return GFMul_2(GFMul_2(s));
}

static int GFMul_8(int s){
	return GFMul_2(GFMul_4(s));
}

static int GFMul_9(int s){
	return GFMul_8(s) ^ s;
}

static int GFMul_11(int s){
	return GFMul_9(s) ^ GFMul_2(s);
}

static int GFMul_12(int s){
	return GFMul_8(s) ^ GFMul_4(s);
}

static int GFMul_13(int s){
	return GFMul_12(s) ^ s; 
}

static int GFMul_14(int s){
	return GFMul_12(s) ^ GFMul_2(s);
}

//二元运算
static int emix_mul(int n ,int s){
	int rst = 0;
	switch(n){
		case 0x01:
		rst = s;
		break;
		case 0x02:
		rst = GFMul_2(s);
		break;
		case 0x03:
		rst = GFMul_3(s);
		break;
		case 0x09:
		rst = GFMul_9(s);
		break;
		case 0x0B:
		rst = GFMul_11(s);
		break;
		case 0x0D:
		rst = GFMul_13(s);
		break;
		case 0x0E:
		rst = GFMul_14(s);
		break;
	}
	return rst;
}

//列混淆操作
static void mix_cloumns(unsigned char* context, int encode){
	//取16个字节组成4*4二维数组
	char two_dimensional_array[4][4] = { 0 };
	for (int row = 0; row < 4; row++){
		for (int cloumn = 0; cloumn < 4; cloumn++){
			two_dimensional_array[row][cloumn] = context[row + 4 * cloumn];
		}
	}

	char rst[4][4] = {0};
	//进行列混淆计算
	for (int row = 0; row < 4; row++){
		for (int cloumn = 0; cloumn < 4; cloumn++){
			if (encode == 1){
				rst[row][cloumn] = emix_mul(e_mix_cloumn[row][0], two_dimensional_array[0][cloumn]) ^
					emix_mul(e_mix_cloumn[row][1], two_dimensional_array[1][cloumn]) ^
					emix_mul(e_mix_cloumn[row][2], two_dimensional_array[2][cloumn]) ^
					emix_mul(e_mix_cloumn[row][3], two_dimensional_array[3][cloumn]);
			}
			else{
				rst[row][cloumn] = emix_mul(reverse_mix_cloumn[row][0], two_dimensional_array[0][cloumn]) ^
					emix_mul(reverse_mix_cloumn[row][1], two_dimensional_array[1][cloumn]) ^
					emix_mul(reverse_mix_cloumn[row][2], two_dimensional_array[2][cloumn]) ^
					emix_mul(reverse_mix_cloumn[row][3], two_dimensional_array[3][cloumn]);
			}
		}
	}

	//拷贝给context
	for (int row = 0; row < 4; row++){
		for (int cloumn = 0; cloumn < 4; cloumn++){
			*(context + 4 * row + cloumn) = rst[cloumn][row];
		}
	}
}

//轮密钥加处理
static void add_round_key(unsigned char* context,const unsigned int* keyword){
	for(int i=0; i<4; i++){
		//取字进行运算
		unsigned int tmp = bytes2word((char*)&context[4 * i]);
		//异或操作
		tmp = tmp ^ keyword[i];
		//S -> S'
		context[4 * i] = (tmp & 0xFF000000) >> 24;
		context[4 * i + 1] = (tmp & 0x00FF0000) >> 16;
		context[4 * i + 2] = (tmp & 0x0000FF00) >> 8;
		context[4 * i + 3] = (tmp & 0x000000FF);
	}
}

static void convert_to_array(const unsigned char* p, int array[4][4]){
	for (int i = 0; i < 4; i++){
		for (int j = 0; j < 4; j++){
			array[j][i] = (int)*(p + 4 * i + j) & 0x000000FF;
		}
	}
}

/*加密函数，该函数只进行AES128位bit加密，本加密采用ECB模式，对明文不足的采取PKCS5处理
*param 1:明文字符串；
*param 2:明文长度，
*param 3:密钥字符串，密钥必须为16个字节，此为强校验
*param 4:输出密文字符串二级指针，
*param 5:输出密文长度*/
int encrpyt_aes128(const char* context,const int cb ,const char* key_words,
	unsigned char** output_context,int* out_cb){
	int key_len = strlen(key_words);
	//密钥长度不对，直接返回错误
	if(key_len != 16){
		return -1;
	}
	unsigned char* buffer = nullptr;
	int buffer_len = 0;
	//每组密文长度不达128bit，如果不为16个字节整数倍，则最后的一组数据需要进行扩充
	//如果明文长度正好为128bit长度的倍数，则添加16个字节的16
	int mod =  cb % 16;
	if (mod != 0){
		int lack = 16 - mod;
		buffer_len = cb + lack;
		buffer = new unsigned char[buffer_len + 1];
		memset(buffer, 0, buffer_len + 1);
		memcpy(buffer,context,cb);
		for (int i = 0; i < lack; i++){
			memcpy(buffer + cb + i, &lack, 1);
		}
	}
	else{
		buffer_len = cb + 16;
		buffer = new unsigned char[buffer_len + 1];
		memset(buffer, 0, buffer_len + 1);
		memcpy(buffer, context, cb);
		int lack = 16;
		for (int i = 0; i < 16; i++){
			memcpy(buffer + cb + i, &lack, 1);
		}
	}
	//扩展密钥值为44个word
	unsigned int keywords_extern[44] = { 0 };
	extern_key(key_words,keywords_extern);
	int array[4][4] = { 0 };
	//对每一组数据进行加密演算
	for (int index = 0; index < buffer_len / 16; index++){
		//取16个字节组合成4*4矩阵，方便进行运算
		convert_to_array(buffer + index * 16, array);
		//开始轮密钥加
		add_round_key(&buffer[index * 16], &keywords_extern[0]);
		//开始1到9轮加密运算
		for (int count = 0; count < 9; count++){
			//字节变换
			sub_bytes(&buffer[index * 16], 1);
			//行位移
			shift_rows(&buffer[index * 16], 1);
			//列混合
			mix_cloumns(&buffer[index * 16], 1);
			//轮密钥加
			add_round_key(&buffer[index * 16], &keywords_extern[4 * (count + 1)]);
		}
		//进行第十轮加密运算
		//字节替换
		sub_bytes(&buffer[index * 16], 1);
		//行移位
		shift_rows(&buffer[index * 16], 1);
		//轮密钥加
		add_round_key(&buffer[index * 16], &keywords_extern[40]);
	}
	*output_context = buffer;
	*out_cb = buffer_len;
	return 0;
}

/**解密函数例程
*param 1:密文正文
*param 2:密文正文长度
*param 3:密钥
*param 4:解密得到的字符串
*param 5:解密得到的字符串长度
*/
int decode_aes128(unsigned char* context,const int cb,const char* key_words,
	unsigned char** output_context,int* out_cb){
	int key_len = strlen(key_words);
	//密钥长度不对，直接返回错误
	if(key_len != 16){
		return -1;
	}
	//检查密文正文长度是否合法
	if(cb == 0 || cb % 16 != 0){
		return -1;
	}
	//扩展密钥
	unsigned int keywords_extern[44];
	extern_key(key_words,keywords_extern);
	//进行解密运算
	for (int index = 0; index < cb / 16; index++){
		//进行轮密钥加
		add_round_key(&context[16 * index], &keywords_extern[40]);
		for (int count = 9; count >= 0; count--){
			//逆向行位移
			shift_rows(&context[16 * index], 0);
			//逆向字节变换
			sub_bytes(&context[16 * index], 0);
			//逆向轮密钥加
			add_round_key(&context[16 * index], &keywords_extern[count * 4]);
			if (count != 0){
				//逆向列混淆
				mix_cloumns(&context[16 * index], 0);
			}
		}
	}
	//查看最后一位是否为补齐位
	int lack = 0;
	bool is_pck5 = true;
	memcpy(&lack, &context[cb - 1], 1);
	for (int i = 0; i < lack; i++){
		if (context[cb - 1 - i] != lack){
			is_pck5 = false;
			break;
		}
	}
	if (is_pck5){
		*out_cb = cb - lack;
	}
	else{
		*out_cb = cb;
	}
	*output_context = new unsigned char[*out_cb + 1];
	memset(*output_context, 0, *out_cb + 1);
	memcpy(*output_context, context, *out_cb);
	return 0;
}

//释放拷贝内存
void free_memory(unsigned char* ptr){
	if (ptr){
		delete[] ptr;
	}
}

//
std::string decrypt_aes128_str(const std::string& mi_wen, const std::string& key){
    if (mi_wen.empty() || key.empty()){
        printf("current decrypt context or key is empty.");
        return "";
    }
    std::string rst;
    unsigned char* output = nullptr;
    int cb = 0;
    if (decode_aes128((unsigned char*)mi_wen.c_str(), mi_wen.size(), key.c_str(), &output, &cb) < 0){
        printf("failed to decrypt aes128 context");
        return "";
    }
    rst.append((char*)output, cb);
    free_memory(output);
    return rst;
}

std::string encrypt_aes128_str(const std::string& ming_wen, const std::string& key){
    if (ming_wen.empty() || key.empty()){
        printf("current encrypt context or key is empty.");
        return "";
    }
    std::string rst;
    unsigned char* output = nullptr;
    int cb = 0;
    if (encrpyt_aes128(ming_wen.c_str(), ming_wen.size(), key.c_str(), &output, &cb) < 0){
        printf("failed to encrypt aes128 context");
        return "";
    }
    rst.append((char*)output, cb);
    free_memory(output);
    return rst;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465

//main.cpp
#include "aes128.hpp"
using namespace std;
/****************************************************************************
函数功能: 将普通字符串转换成十六进制的ASSCI码字符串
		此接口功能与boost::algorithm::hex相同
举例：	源字符串：“123”－－－〉目标字符串：“313233”
*****************************************************************************/
static void str2hex(char *dst, unsigned char *src, int src_len)
{
  for (int i = 0; i < src_len; i++)
  {
    sprintf(dst, "%02x", src[i]);
    dst+= 2;
  }
}
/****************************************************************************
函数功能: 将十六进制的ASSCI码字符串转换成普通字符串
		此接口功能与boost::algorithm::unhex相同
举例：	源字符串：“313233”－－－〉目标字符串：“123”
*****************************************************************************/
static void hex2str(char* dst,const char*src, int src_len){
     for (int i = 0; i < src_len; i += 2){
         unsigned char high, low;
         high = toupper(src[i]);
         low = toupper(src[i + 1]);
         (high > 0x39) ? (high -= 0x37) : (high -= 0x30);
         (low > 0x39) ? (low -= 0x37) : (low -= 0x30);
         dst[i / 2] = (high << 4) | low;
     }
 }

int main(int argc, char *argv[])
{
    string encrypt;
    {
        string ming_wen = "what is your name ? where are you from?";
        string keywords = "uaYBHtznvMU45n4f";
        auto mi_wen = encrypt_aes128_str(ming_wen, keywords);
        char mi_wen_hex[1024] = { 0 };
        str2hex(mi_wen_hex, (unsigned char *)mi_wen.c_str(), mi_wen.size());
        encrypt.assign(mi_wen_hex, strlen(mi_wen_hex));
        cout << "加密后的密文：" << encrypt << endl;
    }
        ///
    {
        string keywords = "uaYBHtznvMU45n4f";
        char mi_wen[1024] = { 0 };
        hex2str(mi_wen, encrypt.c_str(), encrypt.size());
        auto ming_wen=decrypt_aes128_str(mi_wen, keywords);
        cout << "解密后的明文：" << ming_wen << endl;
    }
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54