分类导航

程序笔记发布时间：2022-05-30 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了C++中四种加密算法之AES源代码，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

摘要：作为新一代的加密标准，AES 旨在取代 DES（请看《DES加密算法的C++实现》），以适应当今分布式开放网络对数据加密安全性的要求。本文在分析了 AES 加密原理的基础上着重说明了算法实现的具体步骤，并用 C++ 实现了对文件的加密和解密。

一、AES 介绍

AES（高级加密标准，Advanced Encryption Standard），在密码学中又称 Rijndael 加密法，是美国联邦政府采用的一种分组加密标准。这个标准用来替代原先的 DES，目前已经广为全世界所使用，成为对称密钥算法中最流行的算法之一。

在 AES 出现之前，最常用的对称密钥算法是 DES 加密算法，它在 1977 年被公布成为美国政府的商用加密标准。DES 的主要问题是密钥长度较短，渐渐不适合于分布式开放网络对数据加密安全性的要求。因此，1998年美国政府决定不再继续延用 DES 作为联邦加密标准，并发起了征集 AES 候选算法的活动。征集活动对 AES 的基本要求是：比三重DES快、至少与三重DES一样安全、数据分组长度为128比特、密钥长度为128/192/256比特。

经过三年多的甄选，比利时的密码学家所设计的 Rijndael 算法最终脱颖而出，成为新一代的高级加密标准，并于 2001 年由美国国家标准与技术研究院（NIST）发布于 FIPS PUb 197。

二、AES 算法原理

AES算法（即 Rijndael 算法）是一个对称分组密码算法。数据分组长度必须是 128 bits，使用的密钥长度为 128，192 或 256 bits。对于三种不同密钥长度的 AES 算法，分别称为“AES-128”、“AES-192”、“AES-256”。（Rijndael 的设计还可以处理其它的分组长度和密钥长度，但 AES 标准中没有采用）

下图是 AES 加密解密的整体流程图：

C++中四种加密算法之AES源代码

这里我们需要知道3个符号：Nb―― 状态 State 包含的列（32-bit 字）的个数，也就是说 Nb=4；Nk―― 密钥包含的 32-bit 字的个数，也就是说 Nk=4，6 或 8；Nr―― 加密的轮数，对于不同密钥长度，轮数不一样，具体如下图所示：

C++中四种加密算法之AES源代码

下面分为密钥扩展、分组加密、分组解密三个部分来讲 AES 算法，我会尽可能地简明扼要，若还有不懂的，请自行 Google。

1）密钥扩展

AES 算法通过密钥扩展程序（Key Expansion）将用户输入的密钥 K 扩展生成 Nb(Nr+1)个字，存放在一个线性数组w[Nb*(Nr+1)]中。具体如下：

位置变换函数RotWord()，接受一个字 [a0,a1,a2,a3] 作为输入，循环左移一个字节后输出 [a1,a3,a0]。
S盒变换函数SubWord()，接受一个字 [a0,a3] 作为输入。S盒是一个16x16的表，其中每一个元素是一个字节。对于输入的每一个字节，前四位组成十六进制数 x 作为行号，后四位组成的十六进制数 y 作为列号，查找表中对应的值。最后函数输出 4 个新字节组成的 32-bit 字。
轮常数Rcon[]，如何计算的就不说了，直接把它当做常量数组。
扩展密钥数组w[]的前 Nk 个元素就是外部密钥 K，以后的元素w[i]等于它前一个元素w[i-1]与前第 Nk 个元素w[i-Nk]的异或，即w[i] = w[i-1] XOR w[i-Nk]；但若 i 为 Nk 的倍数，则w[i] = w[i-Nk] XOR SubWord(RotWord(w[i-1])) XOR Rcon[i/Nk-1]。

注意，上面的第四步说明适合于 AES-128 和 AES-192，详细的伪代码如下：

C++中四种加密算法之AES源代码

密钥扩展程序的 C++ 代码（AES-128）：

#include <iostream> 
#include <bitset> 
using namespace std;  
typedef bitset<8> byte; 
typedef bitset<32> word; 
 
const int nr = 10; // AES-128需要 10 轮加密 
const int nk = 4;  // Nk 表示输入密钥的 word 个数 
 
byte S_Box[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} 
}; 
 
// 轮常数，密钥扩展中用到。（AES-128只需要10轮） 
word Rcon[10] = {0x01000000,0x02000000,0x04000000,0x08000000,0x10000000,0x20000000,0x40000000,0x80000000,0x1b000000,0x36000000}; 
 
/** 
 * 将4个 byte 转换为一个 word 
 */ 
word Word(byte& k1,byte& k2,byte& k3,byte& k4) 
{ 
  word result(0x00000000); 
  word temp; 
  temp = kto_ulong(); // K1 
  temp <<= 24; 
  result |= temp; 
  temp = kto_ulong(); // K2 
  temp <<= 16; 
  result |= temp; 
  temp = kto_ulong(); // K3 
  temp <<= 8; 
  result |= temp; 
  temp = kto_ulong(); // K4 
  result |= temp; 
  return result; 
} 
 
/** 
 * 按字节 循环左移一位 
 * 即把[a0,a3]变成[a1,a0] 
 */ 
word RotWord(word& rw) 
{ 
  word high = rw << 8; 
  word low = rw >> 24; 
  return high | low; 
} 
 
/** 
 * 对输入word中的每一个字节进行S-盒变换 
 */ 
word SubWord(word& sw) 
{ 
  word temp; 
  for(int i=0; i<32; i+=8) 
  { 
    int row = sw[i+7]*8 + sw[i+6]*4 + sw[i+5]*2 + sw[i+4]; 
    int col = sw[i+3]*8 + sw[i+2]*4 + sw[i+1]*2 + sw[i]; 
    byte val = S_Box[row][col]; 
    for(int j=0; j<8; ++j) 
      temp[i+j] = val[j]; 
  } 
  return temp; 
} 
 
/** 
 * 密钥扩展函数 - 对128位密钥进行扩展得到 w[4*(Nr+1)] 
 */  
voID KeyExpansion(byte keY[4*Nk],word w[4*(Nr+1)]) 
{ 
  word temp; 
  int i = 0; 
  // w[]的前4个就是输入的key 
  while(i < Nk)  
  { 
    w[i] = Word(keY[4*i],keY[4*i+1],keY[4*i+2],keY[4*i+3]); 
    ++i; 
  } 
 
  i = Nk; 
 
  while(i < 4*(Nr+1)) 
  { 
    temp = w[i-1]; // 记录前一个word 
    if(i % Nk == 0) 
      w[i] = w[i-Nk] ^ SubWord(RotWord(temp)) ^ Rcon[i/Nk-1]; 
    else  
      w[i] = w[i-Nk] ^ temp; 
    ++i; 
  } 
} 
 
int main() 
{ 
  byte keY[16] = {0x2b,0x7e,0x15,0x16,0xae,0xd2,0xa6,0xab,0xf7,0x09,0xcf,0x4f,0x3c}; 
 
  word w[4*(Nr+1)]; 
 
  cout << "KEY IS: "; 
  for(int i=0; i<16; ++i) 
    cout << hex << keY[i]to_ulong() << " "; 
  cout << endl; 
 
  KeyExpansion(key,w); 
  // 测试 
  for(int i=0; i<4*(Nr+1); ++i) 
    cout << "w[" << dec << i << "] = " << hex << w[i]to_ulong() << endl; 
 
  return 0; 
}

测试输出结果：

C++中四种加密算法之AES源代码

2）加密

根据 AES 加密的整体流程图（本文开头），伪代码如下：

C++中四种加密算法之AES源代码

从伪代码描述中可以看出，AES 加密时涉及到的子程序有SubBytes()、ShiftRows()、Mixcolumns()和AddRoundKey()。下面我们一个一个进行介绍：

① S盒变换-SubBytes()

在密钥扩展部分已经讲过了，S盒是一个 16 行 16 列的表，表中每个元素都是一个字节。S盒变换很简单：函数SubBytes()接受一个 4x4 的字节矩阵作为输入，对其中的每个字节，前四位组成十六进制数 x 作为行号，后四位组成的十六进制数 y 作为列号，查找表中对应的值替换原来位置上的字节。

② 行变换-ShiftRows()

行变换也很简单，它仅仅是将矩阵的每一行以字节为单位循环移位：第一行不变，第二行左移一位，第三行左移两位，第四行左移三位。如下图所示：

C++中四种加密算法之AES源代码

③ 列变换-Mixcolumns()

函数Mixcolumns()同样接受一个 4x4 的字节矩阵作为输入，并对矩阵进行逐列变换，变换方式如下：

C++中四种加密算法之AES源代码

注意公式中用到的乘法是伽罗华域（GF，有限域）上的乘法，高级加密标准文档 fips-197 上有讲，如果还是不懂，请自行Google。

C++中四种加密算法之AES源代码

④ 与扩展密钥的异或-AddRoundKey()

扩展密钥只参与了这一步。根据当前加密的轮数，用w[]中的 4 个扩展密钥与矩阵的 4 个列进行按位异或。如下图：

C++中四种加密算法之AES源代码

好了，到这里 AES 加密的各个部分就讲完了。算法实现的 C++ 源码在文章后面第三部分。

3）解密

根据 AES 解密的整体流程图（本文开头），伪代码如下：

C++中四种加密算法之AES源代码

从伪代码可以看出，我们需要分别实现 S 盒变换、行变换和列变换的逆变换InvShiftRows()、InvSubBytes()和InvMixcolumns()。下面就简单的讲一下这三个逆变换：

① 逆行变换-InvShiftRows()

上面讲到ShiftRows()是对矩阵的每一行进行循环左移，所以InvShiftRows()是对矩阵每一行进行循环右移。

@H_944_150@

② 逆 S 盒变换-InvSubBytes()

与 S 盒变换一样，也是查表，查表的方式也一样，只不过查的是另外一个置换表（S-Box的逆表）。

③ 逆列变换-InvMixcolumns()

与列变换的方式一样，只不过计算公式的系数矩阵发生了变化。如下图：

C++中四种加密算法之AES源代码

好了，AES 解密到这里也讲完了。只要写出三个逆变换的函数，然后根据伪代码就很容易实现 AES 解密算法了。

三、C++实现

下面我用 C++ 实现 AES 的加密和解密算法，并实现了对文件的加密和解密。这里我使用 C++ STL 的bitset定义了两个类型：byte和word。需要提到的是，对于有限域上的乘法，我们既可以通过查表（6个结果表），也可以写一个函数来实现。当然，查表的效率会更高，但考虑到贴代码，这里我就用一个函数来实现的。

下面是 AES-128 对一个 128 位数据加密和解密的源代码：

/*************************************************************************  
  > file name: AEScpp 
  > Author: SongLee  
  > E-mail: lisongshine@qqcom  
  > Created Time: 2014年12月12日 星期五 20时15分50秒  
  > Personal Blog: http://songleegithubcom  
 ************************************************************************/  
#include <iostream> 
#include <bitset> 
#include <String> 
using namespace std;  
typedef bitset<8> byte; 
typedef bitset<32> word; 
 
const int nr = 10; // AES-128需要 10 轮加密 
const int nk = 4;  // Nk 表示输入密钥的 word 个数 
 
byte S_Box[16][16] = { 
  {0x63,0x16} 
}; 
 
byte Inv_S_Box[16][16] = { 
  {0x52,0x9E,0xFB},{0x7C,0xCB},{0x54,0x4E},{0x08,0x76,0x25},{0x72,0x92},{0x6C,0x70,{0x90,0x8C,0x06},0xCA,0x8A,0x6B},{0x3A,0xCF,{0x96,0xE7,0x75,0xDF,0x6E},{0x47,0xB7,0x1B},{0xFC,0xD2,0x79,0xDB,0xC0,0xCD,0xF4},{0x1F,0xA8,0x5F},0x51,0xEF},{0xA0,0xE0,0x53,0x61},{0x17,0x04,0xBA,0xE1,0x63,0x7D} 
}; 
 
// 轮常数，密钥扩展中用到。（AES-128只需要10轮） 
word Rcon[10] = {0x01000000,0x36000000}; 
 
/**********************************************************************/  
/*                                  */  
/*               AES算法实现              */  
/*                                  */  
/**********************************************************************/  
 
/******************************下面是加密的变换函数**********************/ 
/** 
 * S盒变换 - 前4位为行号，后4位为列号 
 */ 
voID SubBytes(byte mtx[4*4]) 
{ 
  for(int i=0; i<16; ++i) 
  { 
    int row = mtx[i][7]*8 + mtx[i][6]*4 + mtx[i][5]*2 + mtx[i][4]; 
    int col = mtx[i][3]*8 + mtx[i][2]*4 + mtx[i][1]*2 + mtx[i][0]; 
    mtx[i] = S_Box[row][col]; 
  } 
} 
 
/** 
 * 行变换 - 按字节循环移位 
 */ 
voID ShiftRows(byte mtx[4*4]) 
{ 
  // 第二行循环左移一位 
  byte temp = mtx[4]; 
  for(int i=0; i<3; ++i) 
    mtx[i+4] = mtx[i+5]; 
  mtx[7] = temp; 
  // 第三行循环左移两位 
  for(int i=0; i<2; ++i) 
  { 
    temp = mtx[i+8]; 
    mtx[i+8] = mtx[i+10]; 
    mtx[i+10] = temp; 
  } 
  // 第四行循环左移三位 
  temp = mtx[15]; 
  for(int i=3; i>0; --i) 
    mtx[i+12] = mtx[i+11]; 
  mtx[12] = temp; 
} 
 
/** 
 * 有限域上的乘法 GF(2^8) 
 */ 
byte GFMul(byte a,byte b) {  
  byte p = 0; 
  byte hi_bit_set; 
  for (int counter = 0; counter < 8; counter++) { 
    if ((b & byte(1)) != 0) { 
      p ^= a; 
    } 
    hi_bit_set = (bytE) (a & byte(0x80)); 
    a <<= 1; 
    if (hi_bit_set != 0) { 
      a ^= 0x1b; /* x^8 + x^4 + x^3 + x + 1 */ 
    } 
    b >>= 1; 
  } 
  return p; 
} 
 
/** 
 * 列变换 
 */ 
voID Mixcolumns(byte mtx[4*4]) 
{ 
  byte arr[4]; 
  for(int i=0; i<4; ++i) 
  { 
    for(int j=0; j<4; ++j) 
      arr[j] = mtx[i+j*4]; 
 
    mtx[i] = GFMul(0x02,arr[0]) ^ GFMul(0x03,arr[1]) ^ arr[2] ^ arr[3]; 
    mtx[i+4] = arr[0] ^ GFMul(0x02,arr[1]) ^ GFMul(0x03,arr[2]) ^ arr[3]; 
    mtx[i+8] = arr[0] ^ arr[1] ^ GFMul(0x02,arr[2]) ^ GFMul(0x03,arr[3]); 
    mtx[i+12] = GFMul(0x03,arr[0]) ^ arr[1] ^ arr[2] ^ GFMul(0x02,arr[3]); 
  } 
} 
 
/** 
 * 轮密钥加变换 - 将每一列与扩展密钥进行异或 
 */ 
voID AddRoundKey(byte mtx[4*4],word k[4]) 
{ 
  for(int i=0; i<4; ++i) 
  { 
    word k1 = k[i] >> 24; 
    word k2 = (k[i] << 8) >> 24; 
    word k3 = (k[i] << 16) >> 24; 
    word k4 = (k[i] << 24) >> 24; 
     
    mtx[i] = mtx[i] ^ byte(kto_ulong()); 
    mtx[i+4] = mtx[i+4] ^ byte(kto_ulong()); 
    mtx[i+8] = mtx[i+8] ^ byte(kto_ulong()); 
    mtx[i+12] = mtx[i+12] ^ byte(kto_ulong()); 
  } 
} 
 
/**************************下面是解密的逆变换函数***********************/ 
/** 
 * 逆S盒变换 
 */ 
voID InvSubBytes(byte mtx[4*4]) 
{ 
  for(int i=0; i<16; ++i) 
  { 
    int row = mtx[i][7]*8 + mtx[i][6]*4 + mtx[i][5]*2 + mtx[i][4]; 
    int col = mtx[i][3]*8 + mtx[i][2]*4 + mtx[i][1]*2 + mtx[i][0]; 
    mtx[i] = Inv_S_Box[row][col]; 
  } 
} 
 
/** 
 * 逆行变换 - 以字节为单位循环右移 
 */ 
voID InvShiftRows(byte mtx[4*4]) 
{ 
  // 第二行循环右移一位 
  byte temp = mtx[7]; 
  for(int i=3; i>0; --i) 
    mtx[i+4] = mtx[i+3]; 
  mtx[4] = temp; 
  // 第三行循环右移两位 
  for(int i=0; i<2; ++i) 
  { 
    temp = mtx[i+8]; 
    mtx[i+8] = mtx[i+10]; 
    mtx[i+10] = temp; 
  } 
  // 第四行循环右移三位 
  temp = mtx[12]; 
  for(int i=0; i<3; ++i) 
    mtx[i+12] = mtx[i+13]; 
  mtx[15] = temp; 
} 
 
voID InvMixcolumns(byte mtx[4*4]) 
{ 
  byte arr[4]; 
  for(int i=0; i<4; ++i) 
  { 
    for(int j=0; j<4; ++j) 
      arr[j] = mtx[i+j*4]; 
 
    mtx[i] = GFMul(0x0e,arr[0]) ^ GFMul(0x0b,arr[1]) ^ GFMul(0x0d,arr[2]) ^ GFMul(0x09,arr[3]); 
    mtx[i+4] = GFMul(0x09,arr[0]) ^ GFMul(0x0e,arr[1]) ^ GFMul(0x0b,arr[2]) ^ GFMul(0x0d,arr[3]); 
    mtx[i+8] = GFMul(0x0d,arr[0]) ^ GFMul(0x09,arr[1]) ^ GFMul(0x0e,arr[2]) ^ GFMul(0x0b,arr[3]); 
    mtx[i+12] = GFMul(0x0b,arr[0]) ^ GFMul(0x0d,arr[1]) ^ GFMul(0x09,arr[2]) ^ GFMul(0x0e,arr[3]); 
  } 
} 
 
/******************************下面是密钥扩展部分***********************/ 
/** 
 * 将4个 byte 转换为一个 word 
 */ 
word Word(byte& k1,keY[4*i+3]); 
    ++i; 
  } 
 
  i = Nk; 
 
  while(i < 4*(Nr+1)) 
  { 
    temp = w[i-1]; // 记录前一个word 
    if(i % Nk == 0) 
      w[i] = w[i-Nk] ^ SubWord(RotWord(temp)) ^ Rcon[i/Nk-1]; 
    else  
      w[i] = w[i-Nk] ^ temp; 
    ++i; 
  } 
} 
 
/******************************下面是加密和解密函数**************************/ 
/** 
 * 加密 
 */ 
voID encrypt(byte in[4*4],word w[4*(Nr+1)]) 
{ 
  word keY[4]; 
  for(int i=0; i<4; ++i) 
    keY[i] = w[i]; 
  AddRoundKey(in,key); 
 
  for(int round=1; round<Nr; ++round) 
  { 
    SubBytes(in); 
    ShiftRows(in); 
    Mixcolumns(in); 
    for(int i=0; i<4; ++i) 
      keY[i] = w[4*round+i]; 
    AddRoundKey(in,key); 
  } 
 
  SubBytes(in); 
  ShiftRows(in); 
  for(int i=0; i<4; ++i) 
    keY[i] = w[4*Nr+i]; 
  AddRoundKey(in,key); 
} 
 
/** 
 * 解密 
 */ 
voID decrypt(byte in[4*4],word w[4*(Nr+1)]) 
{ 
  word keY[4]; 
  for(int i=0; i<4; ++i) 
    keY[i] = w[4*Nr+i]; 
  AddRoundKey(in,key); 
 
  for(int round=Nr-1; round>0; --round) 
  { 
    InvShiftRows(in); 
    InvSubBytes(in); 
    for(int i=0; i<4; ++i) 
      keY[i] = w[4*round+i]; 
    AddRoundKey(in,key); 
    InvMixcolumns(in); 
  } 
 
  InvShiftRows(in); 
  InvSubBytes(in); 
  for(int i=0; i<4; ++i) 
    keY[i] = w[i]; 
  AddRoundKey(in,key); 
} 
 
/**********************************************************************/  
/*                                  */  
/*               测试                 */  
/*                                  */  
/**********************************************************************/  
int main() 
{ 
  byte keY[16] = {0x2b,0x3c}; 
 
  byte plain[16] = {0x32,0xe0,0x5a,0xf6,0xa8,0x8d,0xa2,0x34};  
  // 输出密钥 
  cout << "密钥是："; 
  for(int i=0; i<16; ++i) 
    cout << hex << keY[i]to_ulong() << " "; 
  cout << endl; 
 
  word w[4*(Nr+1)]; 
  KeyExpansion(key,w); 
 
  // 输出待加密的明文 
  cout << endl << "待加密的明文："<<endl; 
  for(int i=0; i<16; ++i) 
  { 
    cout << hex << plain[i]to_ulong() << " "; 
    if((i+1)%4 == 0) 
      cout << endl; 
  } 
  cout << endl; 
 
  // 加密，输出密文 
  encrypt(plain,w); 
  cout << "加密后的密文："<<endl; 
  for(int i=0; i<16; ++i) 
  { 
    cout << hex << plain[i]to_ulong() << " "; 
    if((i+1)%4 == 0) 
      cout << endl; 
  } 
  cout << endl; 
 
  // 解密，输出明文 
  decrypt(plain,w); 
  cout << "解密后的明文："<<endl; 
  for(int i=0; i<16; ++i) 
  { 
    cout << hex << plain[i]to_ulong() << " "; 
    if((i+1)%4 == 0) 
      cout << endl; 
  } 
  cout << endl; 
  return 0; 
}

测试用例如下图：

C++中四种加密算法之AES源代码

测试结果截图：

C++中四种加密算法之AES源代码

可见，测试结果和预期输出相同，表明对数据的加密和解密成功！！！

下面我们来写 AES 对文件的加密和解密，在对 128 位的数据加解密成功以后，对文件的加解密就很简单了！只需要每次读 128 位，加密以后，将 128 位的密文写入另外一个文件…如此循环，直到文件尾。下面是对一张图片进行 AES 加密和解密的测试代码（效率先不管了，有时间我再优化）：

//#include <fstream> 
typedef bitset<8> byte; 
typedef bitset<32> word; 
/** 
 * 将一个CHAR字符数组转化为二进制 
 * 存到一个 byte 数组中 
 */ 
voID charToByte(byte out[16],const char s[16]) 
{  
  for(int i=0; i<16; ++i)  
    for(int j=0; j<8; ++j)  
      out[i][j]= ((s[i]>>j) & 1);  
} 
 
/** 
 * 将连续的128位分成16组，存到一个 byte 数组中 
 */ 
voID divIDetoByte(byte out[16],bitset<128>& data) 
{ 
  bitset<128> temp; 
  for(int i=0; i<16; ++i) 
  { 
    temp = (data << 8*i) >> 120; 
    out[i] = tempto_ulong(); 
  } 
} 
 
/** 
 * 将16个 byte 合并成连续的128位 
 */ 
bitset<128> mergeByte(byte in[16]) 
{ 
  bitset<128> res; 
  resreset(); // 置0 
  bitset<128> temp; 
  for(int i=0; i<16; ++i) 
  { 
    temp = in[i]to_ulong(); 
    temp <<= 8*(15-i); 
    res |= temp; 
  } 
  return res; 
} 
 
int main() 
{ 
  String keyStr = "abcdefghijklmnop"; 
  byte keY[16];  
  charToByte(key,keyStrc_str()); 
  // 密钥扩展 
  word w[4*(Nr+1)]; 
  KeyExpansion(key,w); 
 
  bitset<128> data; 
  byte plain[16]; 
  // 将文件 flowerjpg 加密到 ciphertxt 中 
  ifstream in; 
  ofstream out; 
  inopen("D://flowerjpg",ios::binary); 
  outopen("D://ciphertxt",ios::binary); 
  while(inread((char*)&data,sizeof(data))) 
  { 
    divIDetoByte(plain,data); 
    encrypt(plain,w); 
    data = mergeByte(plain); 
    outwrite((char*)&data,sizeof(data)); 
    datareset(); // 置0 
  } 
  inclose(); 
  outclose(); 
 
  // 解密 ciphertxt，并写入图片 flowerjpg 
  inopen("D://ciphertxt",ios::binary); 
  outopen("D://flowerjpg",data); 
    decrypt(plain,sizeof(data)); 
    datareset(); // 置0 
  } 
  inclose(); 
  outclose(); 
 
  return 0; 
}

有限域 GF(28) 上的乘法改用查表的方式实现，AES的加密速度马上提升 80% 以上，所以建议最好使用查表的方式。下面是 AES 算法中用到的 6 个乘法结果表：

byte Mul_02[256] = { 
  0x00,0x08,0x0a,0x0c,0x0e,0x1a,0x1c,0x1e,0x2a,0x2c,0x2e,0x3a,0x3c,0x3e,0x4a,0x4c,0x4e,0x5c,0x5e,0x60,0x6a,0x6c,0x6e,0x7a,0x7c,0x84,0x8a,0x8c,0x8e,0x9a,0x9c,0x9e,0xa0,0xa4,0xaa,0xac,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd4,0xd6,0xd8,0xda,0xdc,0xde,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf8,0xfa,0xfc,0xfe,0x1b,0x1f,0x1d,0x0b,0x0f,0x0d,0x3b,0x3f,0x3d,0x2b,0x2f,0x2d,0x5b,0x5f,0x5d,0x4b,0x4d,0x7b,0x7f,0x7d,0x73,0x6b,0x6f,0x6d,0x9b,0x9f,0x9d,0x8b,0x8f,0xbb,0xb9,0xbf,0xbd,0xb3,0xb1,0xb7,0xb5,0xa9,0xaf,0xad,0xa3,0xa1,0xa7,0xa5,0xdb,0xd9,0xdf,0xdd,0xd3,0xd1,0xd7,0xd5,0xcb,0xc9,0xcd,0xc3,0xc1,0xc7,0xc5,0xfb,0xf9,0xff,0xfd,0xf3,0xf1,0xf5,0xeb,0xe9,0xef,0xed,0xe3,0xe1,0xe7,0xe5 
}; 
 
byte Mul_03[256] = { 
  0x00,0xe5,0x1a 
}; 
 
byte Mul_09[256] = { 
  0x00,0x46 
}; 
 
byte Mul_0b[256] = { 
  0x00,0xa3 
}; 
 
byte Mul_0d[256] = { 
  0x00,0x97 
}; 
 
byte Mul_0e[256] = { 
  0x00,0x8d 
};

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程小技巧。

大佬总结

以上是大佬教程为你收集整理的C++中四种加密算法之AES源代码全部内容，希望文章能够帮你解决C++中四种加密算法之AES源代码所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。

标签：aes c++

上一篇: C++中运算符 &和&&、... 下一篇:c++ minicsv库的编译错误与解决方...

猜你在找的程序笔记相关文章

You can't specify target table 'xxx' for update in FROM clause的解决 2022-07-21
【UNIAPP】上传视频，进度条的前台与后端 2022-07-21
十款代码表白特效，一个比一个浪漫！ 2022-07-04
作业3 2022-07-06
linux系统下部署项目访问报404错误的解决方法 2022-05-30
C++带有指针成员的类处理方式详解 2022-06-07
Linux——（1）基本命令 2022-07-21
JavaScript之正则表达式学习笔记 2019-11-07
Redux源码学习笔记 2019-11-07
Webpack学习笔记 2019-11-07