devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ AES加密算法的实现（附代码）

作者：我家自动化 | 2024-04-21 00:39:43

赞

踩

c++ aes加密

1  AES算法介绍

美国国家标准技术研究所在2001年发布了高级加密标准（AES）。AES是一个对称加密算法，旨在取代DES成为广泛使用的标准，该标准以Rijndael算法为核心。

Rijndael算法是一种对称分组密码体制，采用代替或置换网络，每轮由三层组成：线性混合层确保多轮之上的高度扩散；非线性层由S盒并置起到混淆的作用；密钥加密层将子密钥异或到中间状态。

AES标准规定Rijndael算法的分组长度为128位，而密钥长度可以为128、192或256位，相应的迭代轮数为10轮、12轮或14轮。Rijndael 汇聚了安全性能、效率、可实现性和灵活性等优点。Rijndael 对内存的需求低，使它很适合用于资源受限制的环境中，Rijndael 的操作简单，并可抵御强大和实时的攻击

AES加密算法流程如下：

图1. AES算法流程

2 加密、解密涉及的操作介绍

2.1 字节代替

用一个S盒完成分组的字节到字节的代替；是一个基于S盒的非线性置换，它用于将每一个字节通过一个简单的查表操作映射为另一个字节。映射方法是把输入字节的高4位作为S盒的行值，低4位作为列值，然后取出S盒中对应行和列交叉位的元素作为输出

图2.字节代换

2.2  行移位

 AES 的行移位也是一个简单的左循环移位操作。当密钥长度为128比特时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节

  

图3. 行移位

2.3 列混合

列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵。

图4. 列混合

2.4 轮密钥加

当前分组和扩展密钥的一部分进行按位异或，将输入或中间态S的每一列与一个密钥字ki进行按位异或，即将128位轮密钥 Ki 同状态矩阵中的数据进行逐位异或操作。

3 密钥编排

1)      用一个 4 字节字元素的一维数组 W[Nb*(Nr+1)]表示扩展密钥。

2)      数组中最开始的 Nk 个字为种子密钥。

3)      其它的字由它前面的字经过递归处理后得到。

新列以如下的递归方式产生：

1) 如果i不是4的倍数，那么第i列由如下等式确定：

  W[i]=W[i-4]⨁W[i-1]

2) 如果i是4的倍数，那么第i列由如下等式确定：

  W[i]=W[i-4]⨁T(W[i-1])

函数T由3部分组成：字循环、字节代换和轮常量异或

a)       字循环：将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。

b)       字节代换：对字循环的结果使用S盒进行字节代换。

c)     轮常量异或：将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。

4 代码

4.1 密钥扩展

keyExtend.h

  1. #ifndef KEYEXTEND_H
  2. #define KEYEXTEND_H
  3.  
  4. #include<bitset>
  5. using namespace std;
  6. typedef bitset<8> byte;
  7. typedef bitset<32> word;
  8. extern byte S[256];
  9. extern byte inv_S[256];
  10. extern word rcon[10];
  11. extern byte encry_s[4*4];
  12. extern byte decry_s[4*4];
  13.  
  14. //定义种子密钥长度以及扩展轮数
  15. const int Nr = 10;//轮数 
  16. const int Nk = 4; //种子密钥有四个字 
  17.  
  18. //密钥扩展 相关函数
  19. // 1 四个字节转换成一个字 
  20. word Word(byte b0,byte b1,byte b2,byte b3);
  21. // 2 字移位 
  22. word CycWord(word rw);
  23. // 3 S盒替换 
  24. word SubWord(word sw);
  25. // 4 密钥扩展 
  26. void KeyExpansion(byte key[4*Nk],word w[4*(Nr+1)]);
  27. // 加密使用的列混合数组
  28.  
  29.  
  30. #endif

keyExtend.cpp

  1. #include"keyExtend.h"
  2. #include<iostream>
  3. #include<string>
  4. using namespace std;
  5.  
  6. // S盒
  7. byte S[256] = {
  8. 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
  9. 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
  10. 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
  11. 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
  12. 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
  13. 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
  14. 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,   
  15. 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
  16. 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
  17. 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
  18. 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
  19. 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
  20. 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
  21. 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 
  22. 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
  23. 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
  24. };
  25.  
  26. //逆S盒
  27. byte inv_S[256] = {
  28. 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB, 
  29. 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB, 
  30. 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
  31. 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25, 
  32. 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
  33. 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84, 
  34. 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
  35. 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
  36. 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
  37. 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
  38. 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
  39. 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
  40. 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
  41. 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
  42. 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
  43. 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
  44. };
  45.  
  46. // AES-128轮常量
  47. word rcon[10] = {
  48.     0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL,
  49.     0x20000000UL, 0x40000000UL, 0x80000000UL, 0x1B000000UL, 0x36000000UL
  50. };
  51.  
  52.  
  53. // 加密使用的列混合数组
  54. byte encry_s[16]={
  55. 	0x02,0x03,0x01,0x01,
  56. 	0x01,0x02,0x03,0x01,
  57. 	0x01,0x01,0x02,0x03,
  58. 	0x03,0x01,0x01,0x02
  59. } ;
  60.  
  61. // 解密使用的列混合数组
  62. byte decry_s[4*4]={
  63. 	0x0e,0x0b,0x0d,0x09,
  64. 	0x09,0x0e,0x0b,0x0d,
  65. 	0x0d,0x09,0x0e,0x0b,
  66. 	0x0b,0x0d,0x09,0x0e
  67. };
  68.  
  69. //准备事件：将四个字节转化为一个字，方便进行计算 
  70. word Word(byte b0,byte b1,byte b2,byte b3){
  71. 	word wordres=0x00000000;
  72. 	word temp;
  73. 	temp=b0.to_ulong();//b0
  74. 	temp<<=24;
  75. 	wordres|=temp;
  76. 	temp=b1.to_ulong();//b1
  77. 	temp<<=16;
  78. 	wordres|=temp;
  79. 	temp=b2.to_ulong();//b2
  80. 	temp<<=8;
  81. 	wordres|=temp;
  82. 	temp=b3.to_ulong();//b0
  83. 	wordres|=temp;
  84. 	return wordres; 	
  85. } 
  86.  
  87. //第一步：字循环
  88. //将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。 
  89. word CycWord(word rw){
  90. 	word high = rw<<8; 
  91. 	word low = rw>>24; 
  92. 	return high^low;
  93. }
  94.  
  95. //第二步：字节代换
  96. //对字循环的结果使用S盒进行字节代换。 
  97. word SubWord(word sw){
  98. 	word temp;
  99. 	for(int i=0;i<32;i+=8){
  100. 		//先确定密钥字所在的位置
  101. 		int row=sw[i+7]*8+sw[i+6]*4+sw[i+5]*2+sw[i+4]*1;
  102. 		int col=sw[i+3]*8+sw[i+2]*4+sw[i+1]*2+sw[i]*1;
  103. 		//进行S盒代换 
  104. 		byte tempvar=S[row*16+col];
  105. 		for(int j=0;j<8;j++){
  106. 			temp[i+j]=tempvar[j];
  107. 		}
  108. 	}
  109. 	return temp;	
  110. }
  111.  
  112. //第三步：轮常量异或
  113. //将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。
  114.  
  115.  
  116.  
  117. /*密钥扩展函数
  118. 1) 如果i不是4的倍数，那么第i列由如下等式确定：
  119. 	W[i]=W[i-4]^W[i-1]
  120. 2) 如果i是4的倍数，那么第i列由如下等式确定：
  121. 	W[i]=W[i-4]^T(W[i-1])
  122. */
  123. void KeyExpansion(byte key[4*Nk],word w[4*(Nr+1)]){
  124. 	word temp;
  125. 	int i=0;
  126. 	
  127. 	//获取种子密钥（前四个字） 
  128. 	while(i<Nk){
  129. 		w[i]=Word(key[4*i],key[4*i+1],key[4*i+2],key[4*i+3]);
  130. 		i++;
  131. 	}
  132. 	i=Nk;
  133. 	//开始进行密钥扩展 
  134. 	while(i<4*(Nr+1)){
  135. 		temp=w[i-1];
  136. 		if(i%Nk==0){
  137. 			w[i]=w[i-Nk]^SubWord(CycWord(temp))^rcon[i/Nk-1];
  138. //			cout<<"w["<<dec<<i<<"]对应的论常量为："<<hex<<rcon[i/Nk-1]<<endl;
  139. //			if(i==8){
  140. //				cout<<"w[8]的字移位，S盒变换以及论常量异或结果分别为："<<endl;
  141. //				cout<<CycWord(temp)<<endl;
  142. //				cout<<SubWord(CycWord(temp))<<endl;
  143. //				word c=SubWord(CycWord(temp))^ rcon[i/Nk-1]; 
  144. //				cout<<c<<endl;
  145. //			}	
  146. 		}else{
  147. 			w[i]=w[i-Nk]^temp;
  148. 		}
  149. 		i++;
  150. 	}
  151. }
  152.  
  153.

4.2 加密

encryption.h

  1. #ifndef ENCRYPTION_H
  2. #define ENCRYPTION_H
  3. #include "keyExtend.h"
  4.  
  5. using namespace std;
  6.  
  7. /*
  8. 预处理工作
  9. 	1 设计有限域上的乘法函数 
  10. */
  11.  
  12. // 设计有限域上的乘法函数 
  13. byte GFMul(byte a,byte b);
  14.  
  15.  
  16.  
  17. // 1 轮密钥加
  18. void RKey_Add(byte sta_matr[4*4],word w[4]);
  19.  
  20. // 2 字节代换
  21. void SubBytes(byte sta_matr[4*4]);
  22.  
  23. // 3 行移位--按行进行字节移位
  24. void ShiftRow(byte sta_matr[4*4]); 
  25.  
  26. // 4 列混合 
  27. void MixColumns(byte sta_matr[4*4],byte s[4*4]); 
  28.  
  29. // 5 加密函数
  30. void encrypt(byte in[4*4],word w[4*(Nr+1)]); 
  31.  
  32. #endif

encryption.cpp

  1. #include<iostream>
  2. #include<string>
  3. #include"encryption.h"
  4. using namespace std;
  5.  
  6.  
  7. //有限域上的乘法 GF(2^8)  表示含有2的N次方个元素的有限域  代码已测没问题 
  8. // 注意可以手写一下二进制乘法就知道原理了 
  9. byte GFMul(byte a, byte b) { 
  10. 	byte p = 0;
  11. 	for (int i= 0;i< 8;i++) {
  12. 		//先判断b的低阶位		
  13. 		if (b[0] == 1)
  14. 			p ^= a;
  15. 		//拿到a的高阶位 
  16. 		int temp=a[7];
  17. 		a <<= 1;
  18. 		//左移导致溢出了 所以用假如没有丢失数据的左移后a mod m(x)  等价于丢失数据后a ^ 0x1b 
  19. 		if (temp==1) 
  20. 			a ^= 0x1b; 
  21. 		b >>= 1;
  22. 	}
  23. 	return p;
  24. }
  25.  
  26.  
  27. // 1 轮密钥加 将状态矩阵的一列的四个字节和轮密钥的对应字节进行异或   
  28. void RKey_Add(byte sta_matr[4*4],word w[4]){
  29. 	for(int i=0;i<4;i++){
  30. 		//每一轮完成一列 四个字节的异或 
  31. 		word k0 = w[i]>>24;  
  32. 		word k1 = (w[i]<<8)>>24;
  33. 		word k2 = (w[i]<<16)>>24;
  34. 		word k3 = (w[i]<<24)>>24;
  35. 		
  36. 		sta_matr[i] = sta_matr[i]^byte(k0.to_ulong());
  37. 		sta_matr[i+4] = sta_matr[i+4]^byte(k1.to_ulong());
  38. 		sta_matr[i+8] = sta_matr[i+8]^byte(k2.to_ulong()); 
  39. 		sta_matr[i+12] = sta_matr[i+12]^byte(k3.to_ulong());
  40. 	} 
  41. 	
  42. }
  43.  
  44. // 2 字节代换  经测试没有问题 
  45. void SubBytes(byte sta_matr[4*4]){
  46. 	// 将16个字节依次进行代换
  47. 	for(int i=0;i<16;i++){
  48. 		//bitset地址存放是低位在前,高位在后,与常规相反,计算需要谨慎 
  49. 		int row = sta_matr[i][7]*8+sta_matr[i][6]*4+sta_matr[i][5]*2+sta_matr[i][4]*1;
  50. 		int col = sta_matr[i][3]*8+sta_matr[i][2]*4+sta_matr[i][1]*2+sta_matr[i][0]*1;
  51. 		sta_matr[i] = S[row*16+col]; 
  52. 	} 
  53. 	
  54. 	
  55. }
  56.  
  57. // 3 行移位--按行进行字节移位   代码已测没问题 
  58. void ShiftRow(byte sta_matr[4*4]){
  59. 	//第二行循环左移一个字节
  60. 	//第三行循环左移二个字节 
  61. 	//第三行循环左移三个字节
  62. 	
  63. 	for(int i=0;i<4;i++){
  64. 		byte temp[i];
  65. 		//存数 防止被覆盖
  66. 		for(int j=0;j<i;j++){
  67. 			temp[j]=sta_matr[i*4+j];
  68. 		} 
  69. 		// 将不会发生下标溢出的进行赋值 
  70. 		for(int j=0;j<4-i;j++){
  71. 			sta_matr[i*4+j]=sta_matr[i*4+j+i];	
  72. 		}
  73. 		// 将暂存的数放回状态数组 行中 
  74. 		for(int m=4-i;m<4;m++){
  75. 			sta_matr[i*4+m]=temp[m+i-4];
  76. 		}
  77. 	} 
  78. }
  79.  
  80. // 4 列混合   经测试没问题 
  81. void MixColumns(byte sta_matr[4*4],byte s[4*4]){
  82. 	byte matr[4];
  83. 	for(int i=0;i<4;i++){
  84. 		for(int j=0;j<4;j++)
  85. 			matr[j] = sta_matr[i+j*4];
  86.  
  87. 		sta_matr[i] = GFMul(s[0], matr[0]) ^ GFMul(s[1], matr[1]) ^ GFMul(s[2], matr[2]) ^ GFMul(s[3], matr[3]);
  88. 		sta_matr[i+4] = GFMul(s[4], matr[0]) ^ GFMul(s[5], matr[1]) ^ GFMul(s[6], matr[2]) ^ GFMul(s[7], matr[3]);
  89. 		sta_matr[i+8] = GFMul(s[8], matr[0]) ^ GFMul(s[9], matr[1]) ^ GFMul(s[10], matr[2]) ^ GFMul(s[11], matr[3]);
  90. 		sta_matr[i+12] = GFMul(s[12], matr[0]) ^ GFMul(s[13], matr[1]) ^ GFMul(s[14], matr[2]) ^ GFMul(s[15], matr[3]);
  91. 	}
  92. 	
  93. }
  94.  
  95. // 5 加密函数
  96. void encrypt(byte sta_matr[4*4],word w[4*(Nr+1)]){
  97. 	word key[4];
  98. 	for(int i=0; i<4; i++)
  99. 		key[i] = w[i];
  100. 	//先进行一次轮密钥加 
  101. 	RKey_Add(sta_matr,key);
  102. //	cout<<"第0轮加密的结果是："<<endl;
  103. //		for(int i=0;i<16;i++){
  104. //		cout<<hex<<sta_matr[i].to_ulong()<<"  ";
  105. //		if((i+1)%4==0)cout<<endl;}
  106. 	//九轮操作   S盒  行移位  列混合  轮密钥加 
  107. 	for(int r=1; r<Nr; r++)
  108. 	{
  109. 		SubBytes(sta_matr);
  110. 		ShiftRow(sta_matr);
  111. 		MixColumns(sta_matr,encry_s);
  112. 		for(int i=0; i<4; i++)
  113. 			key[i] = w[4*r+i];
  114. 		RKey_Add(sta_matr, key);
  115. //		cout<<endl;
  116. //		cout<<"第"<<r<<"轮加密的结果是："<<endl;
  117. //		for(int i=0;i<16;i++){
  118. //		cout<<hex<<sta_matr[i].to_ulong()<<"  ";
  119. //		if((i+1)%4==0)cout<<endl;
  120. //		}  
  121. 	}
  122.  	//第十轮   S盒  行移位  轮密钥加 
  123. 	SubBytes(sta_matr);
  124. 	ShiftRow(sta_matr);
  125. 	for(int i=0; i<4; ++i)
  126. 		key[i] = w[4*Nr+i];
  127. 	RKey_Add(sta_matr, key);
  128. 	cout<<endl;
  129. //	cout<<"第10轮加密的结果是："<<endl;
  130. //	for(int i=0;i<16;i++){
  131. //		cout<<hex<<sta_matr[i].to_ulong()<<"  ";
  132. //		if((i+1)%4==0)cout<<endl;
  133. //	}  
  134. }

4.3 解密

decrypt.h

  1. #ifndef DECRYPT_H
  2. #define DECRYPT_H
  3. #include"encryption.h"
  4.  
  5.  
  6. using namespace std;
  7.  
  8. // 1 逆行变换
  9. void InvShiftRow(byte sta_matr[4*4]);
  10.  
  11. // 2 逆S盒变换
  12. void InvSubBytes(byte sta_matr[4*4]);
  13.  
  14. // 3 逆列变换
  15. void InvMixColumns(byte sta_matr[4*4]);
  16.  
  17. // 4 解密函数
  18. void decrypt(byte in[4*4],word w[4*(Nr+1)]);  
  19.  
  20. #endif

decrypt.cpp

  1. #include<iostream>
  2. #include<string>
  3. #include"decrypt.h"
  4.  
  5.  
  6. using namespace std;
  7.  
  8. // 1 逆行变换  循环右移     已测试没有问题 
  9. void InvShiftRow(byte sta_matr[4*4]){
  10. 	for(int i=0;i<4;i++){
  11. 		byte temp[i];
  12. 		//存数 防止被覆盖
  13. 		for(int j=0;j<i;j++){
  14. 			temp[j]=sta_matr[i*4+3-j];
  15. 		} 
  16. 		// 将不会发生下标溢出的进行赋值 
  17. 		for(int j=0;j<4-i;j++){
  18. 			sta_matr[i*4+3-j]=sta_matr[i*4+3-j-i];	
  19. 		}
  20. 		// 将暂存的数放回状态数组 行中 
  21. 		for(int m=0;m<i;m++){
  22. 			sta_matr[i*4+m]=temp[i-m-1];
  23. 		}
  24. 	} 
  25.  
  26. }
  27. // 2 逆S盒变换    没变化没问题 
  28. void InvSubBytes(byte sta_matr[4*4]){
  29. 	// 将16个字节依次进行代换
  30. 	for(int i=0;i<16;i++){
  31. 		//bitset地址存放是低位在前,高位在后,与常规相反,计算需要谨慎 
  32. 		int row = sta_matr[i][7]*8+sta_matr[i][6]*4+sta_matr[i][5]*2+sta_matr[i][4];
  33. 		int col = sta_matr[i][3]*8+sta_matr[i][2]*4+sta_matr[i][1]*2+sta_matr[i][0];
  34. 		sta_matr[i] = inv_S[row*16+col]; 
  35. 	} 
  36. }
  37.  
  38. // 3 逆列变换   没变化没问题 
  39. void InvMixColumns(byte sta_matr[4*4],byte s[4*4]){
  40. 	byte matr[4];
  41. 	for(int i=0;i<4;i++){
  42. 		for(int j=0;j<4;j++)
  43. 			matr[j] = sta_matr[i+j*4];
  44.  
  45. 		sta_matr[i] = GFMul(s[0], matr[0]) ^ GFMul(s[1], matr[1]) ^ GFMul(s[2], matr[2]) ^ GFMul(s[3], matr[3]);
  46. 		sta_matr[i+4] = GFMul(s[4], matr[0]) ^ GFMul(s[5], matr[1]) ^ GFMul(s[6], matr[2]) ^ GFMul(s[7], matr[3]);
  47. 		sta_matr[i+8] = GFMul(s[8], matr[0]) ^ GFMul(s[9], matr[1]) ^ GFMul(s[10], matr[2]) ^ GFMul(s[11], matr[3]);
  48. 		sta_matr[i+12] = GFMul(s[12], matr[0]) ^ GFMul(s[13], matr[1]) ^ GFMul(s[14], matr[2]) ^ GFMul(s[15], matr[3]);
  49. 	}
  50. }
  51.  
  52. // 4 解密函数 
  53. void decrypt(byte sta_matr[4*4],word w[4*(Nr+1)]){
  54. 	word key[4];
  55. 	for(int i=0; i<4; i++)
  56. 		key[i] = w[4*Nr+i];
  57. 	//先进行一次轮密钥加 
  58. 	RKey_Add(sta_matr,key);
  59. 	//九轮操作  逆行移位   逆S盒 轮密钥加  逆列混合 
  60. 	for(int r=Nr-1; r>0; r--)
  61. 	{
  62. 		InvShiftRow(sta_matr);
  63. 		InvSubBytes(sta_matr);
  64. 		for(int i=0; i<4; i++)
  65. 			key[i] = w[4*r+i];
  66. 		RKey_Add(sta_matr, key);
  67. 		InvMixColumns(sta_matr,decry_s); 	
  68. 	}
  69.  	//第十轮   逆行移位   逆S盒 轮密钥加 
  70. 	InvShiftRow(sta_matr);
  71. 		InvSubBytes(sta_matr);
  72. 		for(int i=0; i<4; i++)
  73. 			key[i] = w[i];
  74. 		RKey_Add(sta_matr, key);
  75. } 
  76.

4.4 main函数

  1. #include"encryption.h"
  2. #include"decrypt.h"
  3. #include<iostream>
  4. #include<bitset>
  5.  
  6. int main(){
  7. 	//种子密钥 
  8. 	byte key[16] = {0x2b, 0x7e, 0x15, 0x16, 
  9. 					0x28, 0xae, 0xd2, 0xa6, 
  10. 					0xab, 0xf7, 0x15, 0x88, 
  11. 					0x09, 0xcf, 0x4f, 0x3c};
  12. //	byte key[16] = {0x00, 0x01, 0x02, 0x03, 
  13. //					0x04, 0x05, 0x06, 0x07, 
  14. //					0x08, 0x09, 0x01, 0x02, 
  15. //					0x03, 0x04, 0x05, 0x06};
  16. //	byte key[16] = {0x00, 0x01, 0x02, 0x03, 
  17. //						0x04, 0x05, 0x06, 0x07, 
  18. //						0x08, 0x09, 0x0a, 0x0b, 
  19. //						0x0c, 0x0d, 0x0e, 0x0f};
  20.  
  21.  
  22. 	//输入的明文 
  23. 	byte sta_matr[16]={0x32,0x88,0x31,0xe0,
  24. 						0x43,0x5a,0x31,0x37,
  25. 						0xf6,0x30,0x98,0x07,
  26. 						0xa8,0x8d,0xa2,0x34};
  27. //    byte sta_matr[16]={0x61,0x62,0x63,0x64,
  28. //    					0x65,0x66,0x67,0x68,
  29. //    					0x69,0x6A,0x6B,0x6C,
  30. //    					0x6D,0x6E,0x6F,0x70					
  31. //	}; 
  32. //	byte sta_matr[16] = {0x00, 0x11, 0x22, 0x33, 
  33. //							0x44, 0x55, 0x66, 0x77, 
  34. //							0x88, 0x99, 0xaa, 0xbb, 
  35. //							0xcc, 0xdd, 0xee, 0xff};
  36.  
  37. 						
  38. 	//进行密钥扩展
  39. 	word w[4*(Nr+1)];
  40. 	KeyExpansion(key,w); 
  41. 	
  42. 	//输出密钥
  43. 	cout<<"密钥是:"<<endl;
  44. 	for(int i=0;i<16;i++){
  45. 		cout<<hex<<key[i].to_ulong()<<"  ";
  46. 		if((i+1)%4==0)cout<<endl;
  47. 	}   
  48. 	cout<<endl;
  49. 	//输出明文
  50. 	cout<<"明文是:"<<endl;
  51. 	for(int i=0;i<16;i++){
  52. 		cout<<hex<<sta_matr[i].to_ulong()<<"  ";
  53. 		if((i+1)%4==0)cout<<endl;
  54. 	}  
  55. 	//输出密文
  56. 	cout<<endl;
  57. 	encrypt(sta_matr,w);
  58. 	cout<<"密文是:"<<endl;
  59. 	for(int i=0;i<16;i++){
  60. 		cout<<hex<<sta_matr[i].to_ulong()<<"  ";
  61. 		if((i+1)%4==0)cout<<endl;
  62. 	}  
  63. 	
  64. 	//再次进行解密
  65. 	cout<<endl;
  66. 	cout<<"密文解密是:"<<endl;
  67. 	decrypt(sta_matr,w);
  68. 	for(int i=0;i<16;i++){
  69. 		cout<<hex<<sta_matr[i].to_ulong()<<"  ";
  70. 		if((i+1)%4==0)cout<<endl;
  71. 	}  
  72. 	return 0;
  73. 	
  74.  
  75.  
  76. 	
  77. /*
  78. 	以下是函数正确性验证部分
  79. 		1 密钥扩展验证
  80. 			for(int i=0;i<4*(Nr+1);i++){
  81. 			cout<<"w["<<dec<<i<<"]="<<hex<<w[i].to_ulong()<<endl;
  82. 			}
  83. 		
  84. 		2 验证有限域乘法
  85. 			byte temp=GFMul(0x57,0x83);
  86. 			for(int i=0;i<8;i++){
  87. 				cout<<temp[i]<<" ";}
  88. 				cout<<endl;
  89. 			cout<<"0x57*0x83:"<<hex<<temp.to_ulong(); 
  90. 		
  91. 		3 测试字节代换有无问题
  92. 			SubBytes(sta_matr);
  93. 			cout<<"字节代换后是:"<<endl;
  94. 			for(int i=0;i<16;i++){
  95. 				cout<<hex<<sta_matr[i].to_ulong()<<"  ";
  96. 				if((i+1)%4==0)cout<<endl;
  97. 			} 
  98. 			
  99. 		4 测试列混合函数是否正确
  100. 			byte s[16] = {0xc9,0xe5,0xfd,0x2b, 
  101. 					0x7a,0xf2,0x78,0x6e,
  102. 					0x63,0x9c,0x26,0x67,
  103. 					0xb0,0xa7,0x82,0xe5}; 
  104. 			MixColumns(s,encry_s);
  105. 			for(int i=0;i<16;i++){
  106. 				cout<<hex<<s[i].to_ulong()<<"  ";
  107. 				if((i+1)%4==0)cout<<endl;
  108. 			} 	
  109. 			
  110. 		
  111. 		
  112. */	
  113. 	
  114. /*
  115. 	以下维验证bitset类型数据的存储以及计算方式
  116. 		1 小端模式：即常规思维的0011 0011在计算机存储变成1100 1100
  117. 		2 定义的两个byte(bitset<8>)数据进行异或也是按照两个小端形式的数据进行异或，存储的依旧是小端格式 
  118. 		3 如果按位输出 小端格式  按字节输出 大端格式 
  119. 		4 比如使用a则正常顺序(大端) 仅当按位的时候才是小端 
  120. 		5 a^b 按字节输出是正常大端顺序 
  121. 			byte temp0=0x57;
  122. 			cout<<temp<<endl;
  123. 			cout<<(temp>>1)<<endl;
  124. 			cout<<temp[5];
  125. 			byte temp2=0x83;
  126. 			cout<<(temp^temp2);
  127. 			cout<<"temp1:";
  128. 			for(int i=0;i<8;i++){
  129. 				cout<<temp[i]<<" ";
  130. 			} 
  131. 			cout<<endl; 
  132. 			cout<<"temp2:";
  133. 			for(int i=0;i<8;i++){
  134. 				cout<<temp2[i]<<" ";
  135. 			} 
  136. 			cout<<endl; 
  137. 			cout<<"temp1^temp2:";
  138. 			byte temp3=temp^temp2;
  139. 			for(int i=0;i<8;i++){
  140. 				cout<<temp3[i]<<" ";
  141. 			} 
  142. 			cout<<dec<<temp3.to_ulong();
  143. */		 
  144. }

4.5 结果测试 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/460212
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号