devbox
编程革命者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

AES加密算法原理(C++实现)_c++ aes

作者：编程革命者 | 2024-01-31 19:37:20

赞

踩

c++ aes

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

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

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

AES加密算法流程如下：

                                                        图1. AES算法流程

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

      

                                                        图2.字节代换 

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

 图3. 行移位

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

 图4. 列混合

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

 代码：

AES.h

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. #ifndef _AES_H_
  5. #define _AES_H_
  6.  
  7. // S盒
  8. extern unsigned char S[256];
  9.  
  10. //逆S盒
  11. extern unsigned char inv_S[256];
  12.  
  13. // AES-128轮常量
  14. static const unsigned int rcon[10] = {
  15.     0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL,
  16.     0x20000000UL, 0x40000000UL, 0x80000000UL, 0x1B000000UL, 0x36000000UL
  17. };
  18.  
  19. //列混淆时用到的正矩阵
  20. extern unsigned char positive_matrix[4][4];
  21.  
  22. //逆列混淆时用到的逆正矩阵
  23. extern unsigned char inv_positive_matrix[4][4];
  24.  
  25. //密钥扩展
  26. extern unsigned int W[44];
  27.  
  28. //可输入明文的最大长度
  29. static const int MAX_LENGTH=1e6;
  30.  
  31. //明文
  32. extern unsigned char P[MAX_LENGTH];
  33. //解密之后的明文
  34. extern unsigned char De_P[MAX_LENGTH];
  35. //分组后的128明文
  36. extern unsigned char P128[16];
  37.  
  38. //密文
  39. extern unsigned char C[MAX_LENGTH];
  40. //分组后的128密文
  41. extern unsigned char C128[16];
  42.  
  43. //将128明文转换为状态矩阵
  44. void array_to_mat(unsigned char p[],unsigned char state_mat[][4]);
  45.  
  46. //将状态矩阵转换为128密文
  47. void mat_to_array(unsigned char state_mat[][4],unsigned char c[]);
  48.  
  49. //将1个32位的密钥，转换为4个8位密钥
  50. void key32_to_key8(unsigned int key32,unsigned char* key8);
  51.  
  52. //将4个8位的密钥，转换为1个32位密钥
  53. unsigned int key8_to_key32(unsigned char* key8);
  54.  
  55. //字节替换
  56. unsigned char SubBytes(unsigned char input);
  57.  
  58. //行位移
  59. void ShiftRows(unsigned char state_mat[][4]);
  60.  
  61. //有限域上的乘法
  62. unsigned char multi_finite_field(unsigned char a,unsigned char b);
  63.  
  64. //列混合
  65. void MixColumns(unsigned char state_mat[][4]);
  66.  
  67. //轮密钥加，cnt标记这是第几轮循环
  68. void AddRoundKey(unsigned char state_mat[][4],int cnt);
  69.  
  70. //密钥扩展时的T函数，cnt代表轮数
  71. unsigned int T(unsigned int input,int cnt);
  72.  
  73. //密钥扩展函数
  74. void KeyExpansion(unsigned char* init_key);
  75.  
  76. //加密
  77. void encryption();
  78.  
  79. //解密方法如下
  80.  
  81. //逆字节替换
  82. unsigned char Inv_SubBytes(unsigned char input);
  83.  
  84. //逆行位移
  85. void Inv_ShiftRows(unsigned char state_mat[][4]);
  86.  
  87. //逆列混合
  88. void Inv_MixColumns(unsigned char state_mat[][4]);
  89.  
  90. //逆轮密钥加，cnt标记这是第几轮循环
  91. void Inv_AddRoundKey(unsigned char state_mat[][4],int cnt);
  92.  
  93. //解密
  94. void decryption();
  95.  
  96.  
  97. #endif

 AES.cpp

  1. #include "AES.h"
  2. #include <iostream>
  3. #include <cstring>
  4. using namespace std;
  5. // S盒
  6. unsigned char S[256] =
  7. {
  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.  
  27. //逆S盒
  28. unsigned char inv_S[256] =
  29. {
  30.     0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
  31.     0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
  32.     0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
  33.     0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
  34.     0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
  35.     0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
  36.     0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
  37.     0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
  38.     0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
  39.     0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
  40.     0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
  41.     0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
  42.     0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
  43.     0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
  44.     0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
  45.     0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
  46. };
  47.  
  48. //密钥扩展
  49. unsigned int W[44];
  50.  
  51. //列混淆时用到的正矩阵
  52. extern unsigned char positive_matrix[4][4]=
  53. {
  54.     0x02, 0x03, 0x01, 0x01,
  55.     0x01, 0x02, 0x03, 0x01,
  56.     0x01, 0x01, 0x02, 0x03,
  57.     0x03, 0x01, 0x01, 0x02
  58. };
  59.  
  60. //逆列混淆时用到的逆正矩阵
  61. extern unsigned char inv_positive_matrix[4][4]=
  62. {
  63.     0x0e, 0x0b, 0x0d, 0x09,
  64.     0x09, 0x0e, 0x0b, 0x0d,
  65.     0x0d, 0x09, 0x0e, 0x0b,
  66.     0x0b, 0x0d, 0x09, 0x0e
  67. };
  68.  
  69. //明文
  70. unsigned char P[MAX_LENGTH];
  71. //解密之后的明文
  72. unsigned char De_P[MAX_LENGTH];
  73. //分组后的128明文
  74. unsigned char P128[16];
  75.  
  76. //密文
  77. unsigned char C[MAX_LENGTH];
  78. //分组后的128密文
  79. unsigned char C128[16];
  80.  
  81. //将128比特转换为状态矩阵
  82. void array_to_mat(unsigned char p[],unsigned char state_mat[][4])
  83. {
  84.     for(int col=0; col<4; col++)
  85.     {
  86.         for(int row=0; row<4; row++)
  87.         {
  88.             state_mat[row][col] = p[col*4 + row];
  89.         }
  90.     }
  91. }
  92.  
  93. //将状态矩阵转换为128密文
  94. void mat_to_array(unsigned char state_mat[][4],unsigned char c[])
  95. {
  96.     int cnt=0;
  97.     for(int col=0; col<4; col++)
  98.     {
  99.         for(int row=0; row<4; row++)
  100.         {
  101.             c[cnt++] = state_mat[row][col];
  102.         }
  103.     }
  104. }
  105.  
  106. //将1个32位的密钥，转换为4个8位密钥,key8[0]为原来key32的高位
  107. void key32_to_key8(unsigned int key32,unsigned char* key8)
  108. {
  109.     unsigned int mark = 0xff;
  110.     int left_bit;
  111.     for(int i=0; i<4; i++)
  112.     {
  113.         left_bit = (3 - i) * 8;
  114.         key8[i] = ((mark << left_bit) & key32) >> left_bit;
  115.     }
  116. }
  117.  
  118. //将4个8位的密钥，转换为1个32位密钥
  119. unsigned int key8_to_key32(unsigned char* key8)
  120. {
  121.     unsigned int temp_key=0;
  122.     for(int i=0; i<4; i++)
  123.     {
  124.         temp_key ^= ((unsigned int)key8[i]<<((3 - i) * 8) );
  125.         if(i==3)
  126.         {
  127.             return temp_key;
  128.         }
  129.     }
  130.  
  131. }
  132.  
  133. //字节替换
  134. unsigned char SubBytes(unsigned char input)
  135. {
  136.     unsigned char pre = 0xf0;
  137.     unsigned char suf = 0x0f;
  138.     unsigned int row = (input & pre)>>4, col = input & suf;
  139.     return S[row*16UL + col];
  140. }
  141.  
  142. //行位移
  143. void ShiftRows(unsigned char state_mat[][4])
  144. {
  145.     unsigned char temp_row[4];
  146.     for(int i=1; i<4; i++)
  147.     {
  148.         for(int j=0; j<4; j++)
  149.         {
  150.             temp_row[j] = state_mat[i][(j+4+i)%4];
  151.         }
  152.         for(int j=0; j<4; j++)
  153.         {
  154.             state_mat[i][j] = temp_row[j];
  155.         }
  156.     }
  157. }
  158.  
  159. //有限域上的乘法
  160. unsigned char multi_finite_field(unsigned char a,unsigned char b)
  161. {
  162.     unsigned char ans = 0, v;
  163.     for (int counter = 0; counter < 8; counter++)
  164.     {
  165.         if ((b & 0x01) != 0)
  166.         {
  167.             ans ^= a;
  168.         }
  169.         v = a>>7;
  170.         a <<= 1;
  171.         if(v != 0)
  172.         {
  173.             a ^= 0x1b;
  174.         }
  175.         b >>= 1;
  176.     }
  177.     return ans;
  178.  
  179. }
  180.  
  181. //列混合
  182. void MixColumns(unsigned char state_mat[][4])
  183. {
  184.     unsigned char ans_mat[4][4];
  185.     memset(ans_mat,0,sizeof(ans_mat));
  186.     for(int i=0; i<4; i++)
  187.     {
  188.         for(int j=0; j<4; j++)
  189.         {
  190.             for(int k=0; k<4; k++)
  191.             {
  192.                 ans_mat[i][j] ^= multi_finite_field(positive_matrix[i][k],state_mat[k][j]);
  193.             }
  194.         }
  195.     }
  196.     memcpy(state_mat,ans_mat,sizeof(ans_mat));
  197. }
  198.  
  199. //轮密钥加，cnt标记这是第几轮循环，正确
  200. void AddRoundKey(unsigned char state_mat[][4],int cnt)
  201. {
  202.     unsigned char key8[4];
  203.     for(int col=0; col<4; col++)
  204.     {
  205.         key32_to_key8(W[4*cnt+col],key8);
  206.         for(int row=0; row<4; row++)
  207.         {
  208.             state_mat[row][col] ^= key8[row];
  209.         }
  210.     }
  211. }
  212.  
  213.  
  214. //密钥扩展时的T函数，cnt代表轮数
  215. unsigned int T(unsigned int input,int cnt)
  216. {
  217.     unsigned char key8[4];
  218.     key32_to_key8(input,key8);
  219.     unsigned char temp[4];
  220.     temp[0] = SubBytes(key8[1]);
  221.     temp[1] = SubBytes(key8[2]);
  222.     temp[2] = SubBytes(key8[3]);
  223.     temp[3] = SubBytes(key8[0]);
  224.     unsigned int ans = key8_to_key32(temp);
  225.     ans = ans ^ rcon[cnt-1];
  226.     return ans;
  227. }
  228.  
  229. //密钥扩展函数
  230. void KeyExpansion(unsigned char* init_key)
  231. {
  232.     unsigned int temp_key=0;
  233.     for(int i=0; i<16; i++) // 对输入的8位初始密钥，转换到32位的W[0],W[1],W[2],W[3]中
  234.     {
  235.         temp_key ^= ((unsigned int)init_key[i]<<((3 - (i%4)) * 8) );
  236.         if(i%4==3)
  237.         {
  238.             W[i/4] = temp_key;
  239.             temp_key = 0;
  240.         }
  241.     }
  242.     int cnt;
  243.     for(int i=1; i<=10; i++) //10轮密钥扩展
  244.     {
  245.         cnt=i*4; //cnt来当做更新W的下标
  246.         while(1)
  247.         {
  248.             if(cnt%4!=0)
  249.             {
  250.                 W[cnt] = W[cnt-1] ^ W[cnt-4];
  251.             }
  252.             else
  253.             {
  254.                 W[cnt] = W[cnt-4] ^ T(W[cnt-1],i);
  255.             }
  256.             cnt++;
  257.             if(cnt%4==0)
  258.             {
  259.                 break;
  260.             }
  261.         }
  262.     }
  263. }
  264.  
  265. //加密
  266. void encryption()
  267. {
  268.     int len = strlen((char*)P);
  269.     int group_cnt = (len +  15) / 16; //进行明文分组
  270.     for(int group = 0; group < group_cnt; group++)
  271.     {
  272.         unsigned char state_mat[4][4];
  273.         memcpy(P128,P+(group*16),16);
  274.         array_to_mat(P128,state_mat);
  275.         AddRoundKey(state_mat,0);
  276.         for(int i=1; i<=10; i++)
  277.         {
  278.             for(int row=0; row<4; row++) //字节替换
  279.             {
  280.                 for(int col=0; col<4; col++)
  281.                 {
  282.                     state_mat[row][col] = SubBytes(state_mat[row][col]);
  283.                 }
  284.             }
  285.             ShiftRows(state_mat);
  286.             if(i!=10)
  287.             {
  288.                 MixColumns(state_mat);
  289.             }
  290.             AddRoundKey(state_mat,i);
  291.         }
  292.         mat_to_array(state_mat,C128);
  293.         memcpy(C+(group*16),C128,16);
  294.     }
  295.  
  296. }
  297.  
  298. //解密方法如下
  299.  
  300. //逆字节替换
  301. unsigned char Inv_SubBytes(unsigned char input)
  302. {
  303.     unsigned char pre = 0xf0;
  304.     unsigned char suf = 0x0f;
  305.     unsigned int row = (input & pre)>>4, col = input & suf;
  306.     return inv_S[row*16UL + col];
  307. }
  308.  
  309. //逆行位移
  310. void Inv_ShiftRows(unsigned char state_mat[][4])
  311. {
  312.     unsigned char temp_row[4];
  313.     for(int i=1; i<4; i++)
  314.     {
  315.         for(int j=0; j<4; j++)
  316.         {
  317.             temp_row[(j+4+i)%4] = state_mat[i][j];  //右移i位
  318.         }
  319.         for(int j=0; j<4; j++)
  320.         {
  321.             state_mat[i][j] = temp_row[j];
  322.         }
  323.     }
  324. }
  325.  
  326. //逆列混合
  327. void Inv_MixColumns(unsigned char state_mat[][4])
  328. {
  329.     unsigned char ans_mat[4][4];
  330.     memset(ans_mat,0,sizeof(ans_mat));
  331.     for(int i=0; i<4; i++)
  332.     {
  333.         for(int j=0; j<4; j++)
  334.         {
  335.             for(int k=0; k<4; k++)
  336.             {
  337.                 ans_mat[i][j] ^= multi_finite_field(inv_positive_matrix[i][k],state_mat[k][j]);
  338.             }
  339.         }
  340.     }
  341.     memcpy(state_mat,ans_mat,sizeof(ans_mat));
  342. }
  343.  
  344. //解密
  345. void decryption()
  346. {
  347.     int len = strlen((char*)C);
  348.     int group_cnt = (len +  15) / 16; //进行密文分组
  349.     for(int group = 0; group < group_cnt; group++)
  350.     {
  351.         unsigned char state_mat[4][4];
  352.         memcpy(C128,C+(group*16),16);
  353.         array_to_mat(C128,state_mat);
  354.         AddRoundKey(state_mat,10);
  355.         for(int i=9; i>=0; i--)
  356.         {
  357.             Inv_ShiftRows(state_mat);
  358.             for(int row=0; row<4; row++) //字节替换
  359.             {
  360.                 for(int col=0; col<4; col++)
  361.                 {
  362.                     state_mat[row][col] = Inv_SubBytes(state_mat[row][col]);
  363.                 }
  364.             }
  365.             AddRoundKey(state_mat,i);
  366.             if(i!=0)
  367.             {
  368.                 Inv_MixColumns(state_mat);
  369.             }
  370.         }
  371.         mat_to_array(state_mat,P128);
  372.         memcpy(De_P+(group*16),P128,16);
  373.     }
  374. }

main.cpp

  1. #include <cstdio>
  2. #include <cstring>
  3. #include <iostream>
  4. #include <iomanip>
  5. #include "AES.h"
  6. using namespace std;
  7.  
  8.  
  9. //初始密钥
  10. unsigned char key[16];
  11.  
  12.  
  13. int main()
  14. {
  15.  
  16.     ios::sync_with_stdio(false);
  17.  
  18.     cout << "请输入任意长度明文(按字符输入，最大长度不超过10^6，如'abcdgg125')：";
  19.     cin >> P;
  21.     cout << "请输入初始密钥(按字节输入，共16个字节.如'00 01 ... 0d 0e 0f')：";
  22.     unsigned int xx;//作为“中间人”接收用户输入单字节密钥
  23.     for(int i=0;i<16;i++)  // 输入密钥
  24.     {
  25.     	cin >> hex >> xx;
  26.     	key[i]=xx;
  27.     }
  28.  
  29.     cout << "输入的密钥是："<< endl;
  30.     for(int i=0; i<16; i++) // 输入密钥
  31.     {
  32.         printf("%02x  ",key[i]);
  33.     }
  34.     cout  << "\n" << endl;
  35.  
  36.     KeyExpansion(key); //密钥扩展
  37.  
  38.     cout << "输入的明文为:" << endl;
  39.     for(int i=0;i<strlen((char*)P);i++)
  40.     {
  41.         printf("%02x  ",P[i]);
  42.     }
  43.  
  44.     cout << endl;
  45.     encryption(); //加密
  46.     cout << endl;
  47.  
  48.     cout << "加密后的密文为:" << endl;
  49.     for(int i=0;i<strlen((char*)C);i++)
  50.     {
  51.         printf("%02x  ",C[i]);
  52.     }
  53.     cout  << "\n" << endl;
  54.  
  55.     decryption();  //解密
  56.  
  57.     cout << "解密后的明文为:" << endl;
  58.     printf("%s\n",De_P);
  59.  
  60.     return 0;
  61. }

运行结果：

 

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

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

  

闽ICP备14008679号