本文主要介绍了AES的四种加密算法的c源代码，边肖觉得挺不错的。现在分享给大家，给大家一个参考。

作为新一代加密标准，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算法最终脱颖而出，成为新一代高级加密标准，由NIST于2001年在FIPS PUB 197上发表。

二、AES 算法原理

AES算法(Rijndael算法)是一种对称分组密码算法。数据包长度必须为128位，使用的密钥长度为128、192或256位。三种密钥长度不同的AES算法分别称为AES-128、AES-192和AES-256。(Rijndael的设计也可以处理其他的包长度和密钥长度，但是在AES标准中没有采用)

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

这里我们需要知道三个符号：Nb—— State包含的列数(32位字)，即NB=4；Nk——密钥中包含的32位字的个数，即Nk=4、6或8；对于不同的密钥长度，Nr——加密的轮数不同，如下图所示：

下面分为三个部分：密钥扩展、分组加密和分组解密。我会尽量做到简明扼要。如果还是不明白，请自己谷歌一下。

1）密钥扩展

AES算法通过密钥扩展程序对用户输入的密钥K进行扩展，生成Nb(Nr 1)个字，存储在线性数组w[Nb*(Nr 1)]中。如下所示：

位置转换函数RotWord()接受一个字[a0，a1，a2，a3]作为输入，将其循环左移一个字节并输出[a1，a2，a3，a0]。

s盒转换函数SubWord()，它接受一个单词[a0，a1，a2，a3]作为输入。S-box是一个16x16的表，其中每个元素是一个字节。对于每个输入字节，前四位组成十六进制数X作为行号，后四位组成十六进制数Y作为列号，以便在表中查找对应的值。最后，该函数输出一个由四个新字节组成的32位字。

圆整常数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子字(rot word(W[I-1]))XOR rcon[I/Nk-1]。

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

密钥扩展程序(AES-128)的c代码：

#包括iostream

#包含位集

使用命名空间std

typedef位集8字节；

typedef位集32字；

const int Nr=10//AES-128需要10轮加密

const int Nk=4；//Nk表示输入键的字数。

字节S_Box[16][16]={

{0x 63.0 x7c，0x 77.0 x7b，0x 2.0 x 6b，0x6F，0x 5.0 x 30.0x 01，0x 67.0 x 2b，0x e，0x 7.0 xab，0x76}，

{0x 82.0 xc 9.0 x7d . 0 xfa .0x 59.0 x 47.0 x 47.0 x xad .0x 4.0 xa 2.0 xaf .0x 9c .0x 4.0 x 72.0 x xc0 }，

{0x 7.0 x 93.0 x 26.0 x 36.0 x 3 f .0x 7.0 x 34.0 x 5.0 x 1.0 x 71.0 x 8.0 x 31.0 x 15 }，

{0x 04.0 xc 7.0 x 23.0 xc 3.0 x 18.0 x 96.0 x 05.0 x 9a.0 x 07.0 x 12.0 x 80.0 x 2.0 xeb . 0 x 27.0 XB 2.0 x 75 }，

{0x 09.0 x 83.0 x 2c.0 x 1a.0 x 1b.0 x 6e.0 x 5a.0 xa 0.0 x 52.0 x 3b.0 xd 6.0 XB 3.0 x 29.0 xe 3.0 x 2 f.0 x 84 }，

{0x 53.0 xd 1.0 x 00.0 xed，0x 20.0 xfc，0x 1.0 x 5b，0x6A，0xB，0x b，0x 39.0 x 4a，0x4C，0x 58.0 xcf }，

{ 0 xd 0.0 xef，0xAA，0xFB，0 x 43.0 x4 d，0 x 33.0 x 85.0 x 45.0 xf9.0 x 02.0 x 7f，0 x 50.0 x 3c，0x9F，0xA8}，

{0x 51.0 xa 3.0 x 40.0 x 8f . 0 x 92.0 x 9d . 0 x 38.0 xf 5.0 xbc . 0 XB 6.0 xda . 0 x 21.0 x 10.0 xff . 0 xff 3.0 xd 2 }，

{0x 0 c，0x 13.0 exec，0x5F，0x 97.0 x 44.0 x 17.0 xc 4.0 xa 7.0 x 7e，0x 3 3d，0x 64.0 x 5d，0x 19.0 x 73 }，

{0x 60.0 x 81.0 x 4f，0x 22.0 x 2a，0x 90.0 x 88.0 x 46.0 xee，0x 8.0 x 14.0 xd，0x5E，0x0B，0xDB}，

{0x 0.0x 32.0 x3a .0x 49.0 x 06.0 x 24.0 x 5c .0x xc 2.0 x xd 3.0 xac .0x 62.0 x 91.0 x 95.0 x 4.0 x 79 }，

{0x 7.0 xc 8.0 x 37.0 x 6d.0 x 8d.0 xd 5.0 x 4e.0 xa 9.0 x 6c.0 x 56.0 xf 4.0 xea .0x 65.0 x 7a.0 xae .0x 08 }，

{0xBA，0x78，0x25，0x2E，0x1C，0x 6，0x 6，0x 6，0x 8，0x 8，0x74，0x1F，0x4B，0x8B，0x8A}，

{0x 70.0 x 3e .0x 5.0 x 66.0 x 48.0 x 03.0 x 6.0 x 61.0 x 35.0 x 57.0 x 9.0 x 86.0 x 1.0 x 1d .0x 9e }，

{0x 1.0x 8.0x 98.0 x 11.0 x 69.0 x 9.0 x 8 e.0 x 94.0 x 9 b.0 x 1e.0 x 87.0 x 9.0 x 55.0 x 28.0 xdf }，

{0x8C，0 xa 1.0 x 89.0 x 0d，0xBF，0 xe 6.0 x 42.0 x 68.0 x 41.0 x 99.0 x 2d，0x0F，0 XB 0.0 x 54.0 xbb，0x16}

}:

//轮常数，密钥扩展中用到。(AES-128只需要10轮)

S7-1200可编程控制器，

0x 20000000.0 x 40000000.0 x 80000000.0 x 1b 000000.0 x 36000000 }；

/**

*将四个字节数转换为一个单词(字)

*/

单词(字节k1，字节k2，字节k3，字节k4)

{

字结果(0x 00000000)；

临时字；

临时=kto _ ulong()；//K1

临时=24;

结果|=温度

临时=kto _ ulong()；//K2

临时=16;

结果|=温度

临时=kto _ ulong()；//k3b

临时=8;

结果|=温度

临时=kto _ ulong()；//K4

结果|=温度

返回结果；

}

/**

*按字节循环左移一位

*即把[a0、a1、a2、a3]变成[a1、a2、a3、a0]

*/

word RotWord(word rw)

{

字高=rw 8；

字低=rw 24

返回高|低；

}

/**

*对输入单词(字)中的每一个字节进行表示“上帝的”: 'sblood盒变换

*/

word子词(word sw)

{

临时字；

for(int I=0)；i3 32i=8)

{

int row=SW[i7]* 8 SW[i6]* 4 SW[i5]* 2 SW[i4]；

int col=SW[i3]* 8 SW[I2]* 4 SW[i1]* 2 SW[I]；

字节val=s _ box[行][col]；

for(int j=0)；j8型；(j)

临时[I j]=val[j]；

}

返回临时雇员

}

/**

*密钥扩展函数-对128位密钥进行扩展得到w[4*(第一号)]

*/

请参阅密钥扩展(位元组金钥[4*Nk]、单词w[4 *(NR 1])

{

临时字；

int I=0；

//w[]的前四个就是输入的关键点

而（我Nk)

{

w[i]=Word(key[4*i]、key[4*i 1]、key[4*i 2]、key[4 * i3])；

(i)；

}

我=nk

while(i1 *(NR 1))

{

临时=w[I-1]；//记录前一个单词(字)

if(i % Nk==0)

w[I]=w[I-NK]子字(腐字(temp))；rcon[I/NK-1]；

其他语句

w[I]=w[I-NK]temp；

(i)；

}

}

int main()

{

字节键[16]={0x2b，0x7e，0x15，0x16，

0x 28.0 xae，0x 2.0 xa 6，

0xab，0 xf7.0 x 15.0 x 88，

0x 09.0 xcf，0x4f，0x 3c }；

字w[4*(第一号)];

“cout”键是：“；

for(int I=0)；i16（一)

通道十六进制密钥[I]to _ ulong()'；

端盖；端盖；

关键点扩展（关键点，w)；

//测试

for(int I=0)；i4*(第一号);（一)

cout ' w[' dec I ']=' hex w[I]to _ ulong()结束；

返回0;

}

测试输出结果：

2）加密美元

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

从伪代码描述中可以看出，AES加密涉及的子程序有SubBytes()、ShiftRows()、MixColumns()和AddRoundKey()。让我们逐一介绍：

S盒变换-亚字节()

如密钥扩展部分所述，S盒是一个16行16列的表，表中的每个元素都是一个字节。s盒转换非常简单：函数SubBytes()接受一个4x4字节的矩阵作为输入。对于每个字节，前四个数字组成十六进制数X作为行号，后四个数字组成十六进制数Y作为列号。查找表中的相应值将替换原始位置的字节。

行变换-ShiftRows()

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

列转换-MixColumns()

MixColumns()函数也接受一个4x4字节的矩阵作为输入，并按以下方式逐列转换矩阵：

请注意，公式中使用的乘法是伽罗瓦域(GF，有限域)上的乘法，这在fips-197中有所描述。如果还是不明白，请自己谷歌一下。

与扩展密钥-AddRoundKey()进行异或运算

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

好了，这就是AES加密的所有部分。算法的C源代码在文章后面的第三部分。

3)解密

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

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

逆向转换-InvShiftRows()

如上所述，ShiftRows()循环左移矩阵的每一行，因此InvShiftRows()循环右移矩阵的每一行。

逆S盒变换-InvSubBytes()

和S-Box变换一样，也是查表，查表的方式也是一样的，只不过是另一个置换表(S盒的逆表)。

逆列变换-InvMixColumns()

与列变换方式相同，只是计算公式的系数矩阵发生了变化。如下图：

好了，AES解密到此结束。只要写出三个逆变换函数，那么AES解密算法就可以根据伪代码轻松实现。

三、C++实现

下面，我用C实现AES的加解密算法，实现文件的加解密。这里我用C STL的bitset来定义两种类型：字节和字。应该提到的是，对于有限域上的乘法，我们可以查找表(6个结果表)或编写函数。当然查表会更有效率，但是考虑到贴代码，这里我用一个函数来实现。

以下是AES-128加密和解密128位数据的源代码：

/*************************************************************************

文件名：AEScpp

作者：宋丽

电子邮箱：lisongshine@qqcom

创建时间：2014年12月12日星期五20: 15: 50

个人博客：http://songleegithubcom

************************************************************************/

#包括iostream

#包含位集

#包含字符串

使用命名空间std

typedef位集8字节；

typedef位集32字；

const int Nr=10//AES-128需要10轮加密

const int Nk=4；//Nk表示输入键的字数。

字节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}，

{0x 53.0 xd 1.0 x 00.0 xed，0x 20.0 xfc，0x 1.0 x 5b，0x6A，0xB，0x b，0x 39.0 x 4a，0x4C，0x 58.0 xcf }，

{ 0 xd 0.0 xef，0xAA，0xFB，0 x 43.0 x4 d，0 x 33.0 x 85.0 x 45.0 xf9.0 x 02.0 x 7f，0 x 50.0 x 3c，0x9F，0xA8}，

{0x 51.0 xa 3.0 x 40.0 x 8f . 0 x 92.0 x 9d . 0 x 38.0 xf 5.0 xbc . 0 XB 6.0 xda . 0 x 21.0 x 10.0 xff . 0 xff 3.0 xd 2 }，

{0x 0 c，0x 13.0 exec，0x5F，0x 97.0 x 44.0 x 17.0 xc 4.0 xa 7.0 x 7e，0x 3 3d，0x 64.0 x 5d，0x 19.0 x 73 }，

{0x 60.0 x 81.0 x 4f，0x 22.0 x 2a，0x 90.0 x 88.0 x 46.0 xee，0x 8.0 x 14.0 xd，0x5E，0x0B，0xDB}，

{0x 0.0 x 32.0 x 3a .0x 49.0 x 06.0 x 24.0 x 5c .0x xc 2.0 x 3.0 x 62.0 x 91.0 x 95.0 x 4.0 x 79 }，

{0x 7.0 xc 8.0 x 37.0 x 6d.0 x 8d.0 xd 5.0 x 4e.0 xa 9.0 x 6c.0 x 56.0 xf 4.0 xea .0x 65.0 x 7a.0 xae .0x 08 }，

{0xBA，0x78，0x25，0x2E，0x1C，0x 6，0x 6，0x 6，0x 8，0x 8，0x74，0x1F，0x4B，0x8B，0x8A}，

{0x 70.0 x 3e .0x 5.0 x 66.0 x 48.0 x 03.0 x 6.0 x 61.0 x 35.0 x 57.0 x 9.0 x 86.0 x 1.0 x 1d .0x 9e }，

{0x 1.0x 8.0x 98.0 x 11.0 x 69.0 x 9.0 x 8 e.0 x 94.0 x 9 b.0 x 1e.0 x 87.0 x 9.0 x 55.0 x 28.0 xdf }，

{0x8C，0 xa 1.0 x 89.0 x 0d，0xBF，0 xe 6.0 x 42.0 x 68.0 x 41.0 x 99.0 x 2d，0x0F，0 XB 0.0 x 54.0 xbb，0x16}

}:

S7-1200可编程控制器

{0x 52.0x 09.0x 6 a，0x 5.0x 30.0x 36.0x 5.0x 38.0x ff，0x 40.0x 3.0x 9 e，0x 81.0x 3.0x 7.0x b }，

{0x7C，0x 3.0x 39.0x 82.0x 9 b，0x2F，0x 87.0x 34.0x 8 e，0x 43.0x 44.0x 4.0x 9.0x 9.0x b }，

{0x 54.0 x7b .0x 94.0 x 32.0 xa 6.0 x 2.0 x 23.0 x 3.0 x e、0x4C、0x 95.0x 42.0x a、0x 3.0x 4 e }，

{0x 08.0 x2 e . 0 xa 1.0 x 66.0 x 28.0 xd 9.0 x 24.0 XB 2.0 x 76.0 x 5b.0 xa 2.0 x 49.0 x 6d.0 x 8b.0 xd 1.0 x 25 }，

{0x 72.0 xf 8.0 xf 6.0 x 64.0 x 86.0 x 68.0 x 98.0 x 16.0 xd 4.0 xa 4.0 x 5c.0 xcc . 0 x 5d.0 x 65.0 XB 6.0 x 92 }，

{0x6C，0x 70.0 x 48.0 x 50.0 xfd，0xED，0x 9.0 xda，0x5E，0x 15.0 x 46.0 x 57.0 xa 7.0 x 8d，0x9D，0x84}，

{0x90，0x 8.0 xab，0x00，0x8C，0x c，0x 3.0x 0 a，0x 7.0x 4.0x 58.0 x 05.0 x 8.0 x 3.0 x 45.0 x 06 }，

{0x 2 c，0x1E，0x8F，0x 2，0x3F，0x02，0x1，0x 1，0xD，0x03，0x01，0x13，0x8A，0x6B}，

{0x3A，0x91，0x11，0x41，0x4F，0x67，0x67，0x97，0x 97，0x 2，0x xcf，0x xce，0x4，0x6，0x73}，

{0x 96.0 xac，0x 74.0 x 22.0 xe 7.0 xad，0x 35.0 x 85.0 xe 2.0 xf 9.0 x 37.0 xe 8.0 x 1c.0 x 75.0 xdf，0x6E}，

{0x 47.0 xf 1.0 x1 a，0x 71.0 x1 d，0x 29.0 xc 5.0 x 89.0 x 6f，0x 7.0 x 62.0 x 0e，0x xaa，0x 18.0 xbe，0x1B}，

{0x 56.0x 3 e，0x4B，0x 6.0x 79.0x 20.0x 9 a，0x xdb，0x 0.0 x3e，0x 78.0x xcd，0x5A，0x 4 }，

{0x1F，0xDD，0xa 8.0 x 33.0 x 88.0 x 07.0 x xc 7.0 x 31.0 XB 1.0 x 12.0 x 10.0 x 59.0 x 27.0 x 80.0 exec，0x5F}，

{0x 60.0x 51.0x 7 f，0x 9.0x 19.0x 5.0x 4 a，0x0D，0x 2，0x 5.0x 7 a，0x9F，0x 93.0x 9.0x 9 c，0x 9.0 xef }，

{ 0 xa 0.0 xe 0.0 x3 b . 0 x4 d . 0 xae . 0 x2 a . 0 xf 5.0 XB 0.0 xc 8.0 xeb . 0 xbb . 0 x3c . 0 x 83.0 x 53.0 x 99.0 x 61 }

{0x 17.0 x2 b .0x 04.0 x7e .0x a .0x 77.0 x 6.0 x 26.0 x 1.0 x 69.0 x 14.0 x 63.0 x 55.0 x 21.0 x 0 c .0x 7d }

}:

//轮常数，密钥扩展中用到。(AES-128只需要10轮)

S7-1200可编程控制器，

0x 20000000.0 x 40000000.0 x 80000000.0 x 1b 000000.0 x 36000000 }；

-好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧

/*/

/* AES算法实现*/

/*/

-好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧

我的天啊下面是加密的变换函数-好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧，好吧。

/**

* S盒变换-前四位为行号，后四位为列号

*/

请参见子字节（字节氨甲喋呤[4*4])

{

for(int I=0)；i16（一)

{

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=s _ box行][col]；

}

}

/**

*行变换-按字节循环移位

*/

参见移动电话（字节氨甲喋呤[4*4])

{

//第二行循环左移一位

字节temp=MTX[4]；

for(int I=0)；i3；和：(一)

MTX[i4]=MTX[i5]；

S7-1200可编程控制器：

//第三行循环左移两位

for(int I=0)；i2个；（一)

{

temp=MTX[8i]；

MTX[i18]=MTX[i10]；

MTX[i10]=temp；

}

//第四行循环左移三位

temp=MTX[15]；

for(int I=3；i0；-我)

MTX[i12]=MTX[i11]；

MTX[12]=temp；

}

/**

* 有限域上的乘法GF(2^8)

*/

字节GFMul(字节一，字节b) {

字节p=0；

字节hi _ bit _ set

for(int counter=0；8号柜台；计数器){

如果((b字节(1))!=0) {

p ^=a；

}

hi_bit_set=(字节)(一个字节(0x 80))；

a=1；

if (hi_bit_set！=0) {

一个^=0x1b；/* x^8 x^4 x^3 x 1 */

}

b=1；

}

返回p；

}

/**

* 列变换

*/

空的混合列（字节氨甲喋呤[4*4])

{

字节arr[4]；

for(int I=0；i4；我)

{

for(int j=0；j4；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]^ gf mul(0x 02，arr[2]) ^ GFMul(0x03，arr[3])；

MTX[I 12]=gfmul(0x03,arr[0])^ arr[1]^ arr[2]^ gf mul(0x 02，arr[3])；

}

}

/**

* 轮密钥加变换-将每一列与扩展密钥进行异或

*/

void AddRoundKey(字节mtx[4*4]，字k[4])

{

for(int I=0；i4；我)

{

字k1=k[I]24；

word k2=(k[I]8)24；

字k3=(k[I]16)24；

字k4=(k[I]24)24；

mtx[i]=mtx[i] ^字节(kto _ ulong())；

氨甲喋呤[i 4]=氨甲喋呤^字节(kto _ ulong())；

甲氨蝶呤[i 8]=甲氨蝶呤[i 8] ^字节(kto _ ulong())；

甲氨蝶呤[i 12]=甲氨蝶呤[i 12] ^字节(kto _ ulong())；

}

}

/**************************下面是解密的逆变换函数***********************/

/**

* 逆S盒变换

*/

void子字节(字节氨甲喋呤[4*4])

{

for(int I=0；i16我)

{

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(字节氨甲喋呤[4*4])

{

//第二行循环右移一位

字节温度=MTX[7]；

for(int I=3；i0；-我)

MTX[i4]=MTX[i3]；

MTX[4]=temp；

//第三行循环右移两位

for(int I=0；I2；我)

{

temp=MTX[I 8]；

MTX[I 8]=MTX[I 10]；

MTX[i10]=temp；

}

//第四行循环右移三位

temp=MTX[12]；

for(int I=0；i3；我)

MTX[i12]=MTX[i13]；

MTX[15]=temp；

}

void InvMixColumns(字节氨甲喋呤[4*4])

{

字节arr[4]；

for(int I=0；i4；我)

{

for(int j=0；j4；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])；

}

}

/******************************下面是密钥扩展部分***********************/

/**

* 将四个字节转换为一个单词

*/

单词单词(字节k1、字节k2、字节k3、字节k4)

{

字结果(0x 00000000)；

word temp

temp=kto _ ulong()；//K1

温度=24

结果|=温度

temp=kto _ ulong()；//K2

温度=16

结果|=温度

temp=kto _ ulong()；//K3

temp=8；

结果|=温度

temp=kto _ ulong()；//K4

结果|=温度

返回结果；

}

/**

* 按字节循环左移一位

* 即把[a0，a1，a2，a3]变成[a1，a2，a3，a0]

*/

word RotWord(word rw)

{

字高=rw 8；

字低=rw 24

返高|低；

}

/**

* 对输入单词中的每一个字节进行表示"上帝的":' sblood盒变换

*/

单词子词(word软件)

{

word temp

for(int I=0；i32i=8)

{

int row=SW[i7]* 8 SW[i6]* 4 SW[i5]* 2 SW[i4]；

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；j8；j)

temp[I j]=val[j]；

}

返回温度；

}

/**

* 密钥扩展函数-对128位密钥进行扩展得到w[4*(Nr 1)]

*/

void密钥扩展(字节键[4*Nk]，字w[4*(Nr 1)])

{

word temp

int I=0；

//w[]的前四个就是输入的键

当（我认为)

{

w[i]=Word(key[4*i]，key[4*i 1]，key[4*i 2]，key[4 * I 3])；

我；

}

我=Nk

while(i 4*(Nr 1))

{

temp=w[I-1]；//记录前一个单词

if(i % Nk==0)

^子字(罗特word(temp))^ rcon[I/NK-1]；

其他

^温度；

我；

}

}

/******************************下面是加密和解密函数**************************/

/**

* 加密

*/

void加密(字节在[4*4]中，字w[4*(Nr 1)])

{

字键[4];

for(int I=0；i4；我)

key[I]=w[I]；

AddRoundKey(in，key)；

for(int round=1；圆形Nr圆形)

{

亚字节（英寸);

移位行(进)；

混合列（英寸);

for(int I=0；i4；我)

key[I]=w[4 * round I]；

AddRoundKey(in，key)；

}

亚字节（英寸);

移位行(进)；

for(int I=0；i4；我)

key[I]=w[4 * Nr I]；

AddRoundKey(in，key)；

}

/**

* 解密

*/

无效解密(字节在[4*4],字w[4*(Nr 1)])

{

字键[4];

for(int I=0；i4；我)

key[I]=w[4 * Nr I]；

AddRoundKey(in，key)；

for(int round=Nr-1；round0-圆形)

{

invshift行(in)；

inv子字节(in)；

for(int I=0；i4；我)

key[I]=w[4 * round I]；

AddRoundKey(in，key)；

InvMixColumns(in)；

}

invshift行(in)；

inv子字节(in)；

for(int I=0；i4；我)

key[I]=w[I]；

AddRoundKey(in，key)；

}

/**********************************************************************/

/* */

/* 测试*/

/* */

/**********************************************************************/

int main()

{

字节键[16]={0x2b，0x7e，0x15，0x16，

0x28、0xae、0xd2、0xa6、

0xab、0xf7、0x15、0x88、

0x09，0xcf，0x4f，0x3c }；

byte plain[16]={0x32，0x88，0x31，0xe0，

0x43、0x5a、0x31、0x37、

0xf6、0x30、0x98、0x07、

0xa8，0x8d，0xa2，0x 34 }；

//输出密钥

cout '密钥是：';

for(int I=0；i16我)

标准输出十六进制密钥[I]to _ ulong()" "；

cout结束

word w[4 *(Nr 1)]；

KeyExpansion(key，w)；

//输出待加密的明文

cout endl '待加密的明文：' endl

for(int I=0；i16我)

{

cout hex plain[I]to _ ulong()" "；

如果((^ 1)% 4==0)

cout结束

}

cout结束

//加密，输出密文

加密(平原，w)；

cout '加密后的密文：' endl

for(int I=0；i16我)

{

cout hex plain[I]to _ ulong()" "；

如果((^ 1)% 4==0)

cout结束

}

cout结束

//解密，输出明文

解密(平原，w)；

cout '解密后的明文：' endl

for(int I=0；i16我)

{

cout hex plain[I]to _ ulong()" "；

如果((^ 1)% 4==0)

cout结束

}

cout结束

返回0;

}

测试用例如下图：

测试结果截图：

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

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

//#包含fstream

typedef位集8字节；

typedef位集32字；

/**

* 将一个茶字符数组转化为二进制

* 存到一个字节数组中

*/

空图表字节(字节输出[16],常量字符s[16])

{

for(int I=0；i16我)

for(int j=0；j8；j)

out[I][j]=((s[I]j)1)；

}

/**

* 将连续的128位分成16组，存到一个字节数组中

*/

void divideToByte(字节输出[16],位集128数据)

{

位集128温度

f

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

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

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。