AES加密算法的原理详解与实现分析

2022-12-01 13:11
6

这篇文章主要介绍了高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥,需要的朋友可以参考下



AES简介

高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥,具体的加密流程如下图:

密码学中的高级加密标准(Advanced Encryption Standard,AES),又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。

这个标准用来替代原先的DES(Data Encryption Standard),已经被多方分析且广为全世界所使用。经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院 (NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准。2006年,高级加密标准已然成为对称密钥加密中最流行的算法之一 。

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计,结合两位作者的名字,以Rijdael之名命之,投稿高级加密标准的甄选流程。(Rijdael的发音近于 "Rhine doll"。)

下面简单介绍下各个部分的作用与意义:

  • 明文P

没有经过加密的数据。

  • 密钥K

用来加密明文的密码,在对称加密算法中,加密与解密的密钥是相同的。密钥为接收方与发送方协商产生,但不可以直接在网络上传输,否则会导致密钥泄漏,通常是通过非对称加密算法加密密钥,然后再通过网络传输给对方,或者直接面对面商量密钥。密钥是绝对不可以泄漏的,否则会被攻击者还原密文,窃取机密数据。

  • AES加密函数

设AES加密函数为E,则 C = E(K, P),其中P为明文,K为密钥,C为密文。也就是说,把明文P和密钥K作为加密函数的参数输入,则加密函数E会输出密文C。

  • 密文C

经加密函数处理后的数据

  • AES解密函数

设AES解密函数为D,则 P = D(K, C),其中C为密文,K为密钥,P为明文。也就是说,把密文C和密钥K作为解密函数的参数输入,则解密函数会输出明文P。

在这里简单介绍下对称加密算法与非对称加密算法的区别。

  • 对称加密算法

加密和解密用到的密钥是相同的,这种加密方式加密速度非常快,适合经常发送数据的场合。缺点是密钥的传输比较麻烦。

  • 非对称加密算法

加密和解密用的密钥是不同的,这种加密方式是用数学上的难解问题构造的,通常加密解密的速度比较慢,适合偶尔发送数据的场合。优点是密钥传输方便。常见的非对称加密算法为RSA、ECC和EIGamal。

实际中,一般是通过RSA加密AES的密钥,传输到接收方,接收方解密得到AES密钥,然后发送方和接收方用AES密钥来通信。

本文下面AES原理的介绍参考自《现代密码学教程》,AES的实现在介绍完原理后开始。

AES的基本结构

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

AES密钥长度(32位比特字)分组长度(32位比特字)加密轮数
AES-1284410
AES-1926412
AES-2568414

轮数在下面介绍,这里实现的是AES-128,也就是密钥的长度为128位,加密轮数为10轮。
上面说到,AES的加密公式为C = E(K,P),在加密函数E中,会执行一个轮函数,并且执行10次这个轮函数,这个轮函数的前9次执行的操作是一样的,只有第10次有所不同。也就是说,一个明文分组会被加密10轮。AES的核心就是实现一轮中的所有操作。

AES的处理单位是字节,128位的输入明文分组P和输入密钥K都被分成16个字节,分别记为P = P0 P1 … P15 和 K = K0 K1 … K15。如,明文分组为P = abcdefghijklmnop,其中的字符a对应P0,p对应P15。一般地,明文分组用字节为单位的正方形矩阵描述,称为状态矩阵。在算法的每一轮中,状态矩阵的内容不断发生变化,最后的结果作为密文输出。该矩阵中字节的排列顺序为从上到下、从左至右依次排列,如下图所示:

现在假设明文分组P为"abcdefghijklmnop",则对应上面生成的状态矩阵图如下:

上图中,0x61为字符a的十六进制表示。可以看到,明文经过AES加密后,已经面目全非。

类似地,128位密钥也是用字节为单位的矩阵表示,矩阵的每一列被称为1个32位比特字。通过密钥编排函数该密钥矩阵被扩展成一个44个字组成的序列W[0],W[1], … ,W[43],该序列的前4个元素W[0],W[1],W[2],W[3]是原始密钥,用于加密运算中的初始密钥加(下面介绍);后面40个字分为10组,每组4个字(128比特)分别用于10轮加密运算中的轮密钥加,如下图所示:

上图中,设K = “abcdefghijklmnop”,则K0 = a, K15 = p, W[0] = K0 K1 K2 K3 = “abcd”。

AES的整体结构如下图所示,其中的W[0,3]是指W[0]、W[1]、W[2]和W[3]串联组成的128位密钥。加密的第1轮到第9轮的轮函数一样,包括4个操作:字节代换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外,在第一轮迭代之前,先将明文和原始密钥进行一次异或加密操作。

上图也展示了AES解密过程,解密过程仍为10轮,每一轮的操作是加密操作的逆操作。由于AES的4个轮操作都是可逆的,因此,解密操作的一轮就是顺序执行逆行移位、逆字节代换、轮密钥加和逆列混合。同加密操作类似,最后一轮不执行逆列混合,在第1轮解密之前,要执行1次密钥加操作。

下面分别介绍AES中一轮的4个操作阶段,这4分操作阶段使输入位得到充分的混淆。

一、字节代换

1.字节代换操作

AES的字节代换其实就是一个简单的查表操作。AES定义了一个S盒和一个逆S盒。
AES的S盒:

行/列0123456789ABCDEF
00x630x7c0x770x7b0xf20x6b0x6f0xc50x300x010x670x2b0xfe0xd70xab0x76
10xca0x820xc90x7d0xfa0x590x470xf00xad0xd40xa20xaf0x9c0xa40x720xc0
20xb70xfd0x930x260x360x3f0xf70xcc0x340xa50xe50xf10x710xd80x310x15
30x040xc70x230xc30x180x960x050x9a0x070x120x800xe20xeb0x270xb20x75
40x090x830x2c0x1a0x1b0x6e0x5a0xa00x520x3b0xd60xb30x290xe30x2f0x84
50x530xd10x000xed0x200xfc0xb10x5b0x6a0xcb0xbe0x390x4a0x4c0x580xcf
60xd00xef0xaa0xfb0x430x4d0x330x850x450xf90x020x7f0x500x3c0x9f0xa8
70x510xa30x400x8f0x920x9d0x380xf50xbc0xb60xda0x210x100xff0xf30xd2
80xcd0x0c0x130xec0x5f0x970x440x170xc40xa70x7e0x3d0x640x5d0x190x73
90x600x810x4f0xdc0x220x2a0x900x880x460xee0xb80x140xde0x5e0x0b0xdb
A0xe00x320x3a0x0a0x490x060x240x5c0xc20xd30xac0x620x910x950xe40x79
B0xe70xc80x370x6d0x8d0xd50x4e0xa90x6c0x560xf40xea0x650x7a0xae0x08
C0xba0x780x250x2e0x1c0xa60xb40xc60xe80xdd0x740x1f0x4b0xbd0x8b0x8a
D0x700x3e0xb50x660x480x030xf60x0e0x610x350x570xb90x860xc10x1d0x9e
E0xe10xf80x980x110x690xd90x8e0x940x9b0x1e0x870xe90xce0x550x280xdf
F0x8c0xa10x890x0d0xbf0xe60x420x680x410x990x2d0x0f0xb00x540xbb0x16

状态矩阵中的元素按照下面的方式映射为一个新的字节:把该字节的高4位作为行值,低4位作为列值,取出S盒或者逆S盒中对应的行的元素作为输出。例如,加密时,输出的字节S1为0x12,则查S盒的第0x01行和0x02列,得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下:

2.字节代换逆操作

逆字节代换也就是查逆S盒来变换,逆S盒如下:

行/列0123456789ABCDEF
00x520x090x6a0xd50x300x360xa50x380xbf0x400xa30x9e0x810xf30xd70xfb
10x7c0xe30x390x820x9b0x2f0xff0x870x340x8e0x430x440xc40xde0xe90xcb
20x540x7b0x940x320xa60xc20x230x3d0xee0x4c0x950x0b0x420xfa0xc30x4e
30x080x2e0xa10x660x280xd90x240xb20x760x5b0xa20x490x6d0x8b0xd10x25
40x720xf80xf60x640x860x680x980x160xd40xa40x5c0xcc0x5d0x650xb60x92
50x6c0x700x480x500xfd0xed0xb90xda0x5e0x150x460x570xa70x8d0x9d0x84
60x900xd80xab0x000x8c0xbc0xd30x0a0xf70xe40x580x050xb80xb30x450x06
70xd00x2c0x1e0x8f0xca0x3f0x0f0x020xc10xaf0xbd0x030x010x130x8a0x6b
80x3a0x910x110x410x4f0x670xdc0xea0x970xf20xcf0xce0xf00xb40xe60x73
90x960xac0x740x220xe70xad0x350x850xe20xf90x370xe80x1c0x750xdf0x6e
A0x470xf10x1a0x710x1d0x290xc50x890x6f0xb70x620x0e0xaa0x180xbe0x1b
B0xfc0x560x3e0x4b0xc60xd20x790x200x9a0xdb0xc00xfe0x780xcd0x5a0xf4
C0x1f0xdd0xa80x330x880x070xc70x310xb10x120x100x590x270x800xec0x5f
D0x600x510x7f0xa90x190xb50x4a0x0d0x2d0xe50x7a0x9f0x930xc90x9c0xef
E0xa00xe00x3b0x4d0xae0x2a0xf50xb00xc80xeb0xbb0x3c0x830x530x990x61
F0x170x2b0x040x7e0xba0x770xd60x260xe10x690x140x630x550x210x0c0x7d

二、行移位

1.行移位操作

行移位是一个简单的左循环移位操作。当密钥长度为128比特时,状态矩阵的第0行左移0字节,第1行左移1字节,第2行左移2字节,第3行左移3字节,如下图所示:

2.行移位的逆变换

行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作,例如AES-128中,状态矩阵的第0行右移0字节,第1行右移1字节,第2行右移2字节,第3行右移3字节。

三、列混合

1.列混合操作

列混合变换是通过矩阵相乘来实现的,经行移位后的状态矩阵与固定的矩阵相乘,得到混淆后的状态矩阵,如下图的公式所示:

状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下图所示:

其中,矩阵元素的乘法和加法都是定义在基于GF(2^8)上的二元运算,并不是通常意义上的乘法和加法。这里涉及到一些信息安全上的数学知识,不过不懂这些知识也行。其实这种二元运算的加法等价于两个字节的异或,乘法则复杂一点。对于一个8位的二进制数来说,使用域上的乘法乘以(00000010)等价于左移1位(低位补0)后,再根据情况同(00011011)进行异或运算,设S1 = (a7 a6 a5 a4 a3 a2 a1 a0),刚0x02 * S1如下图所示:

也就是说,如果a7为1,则进行异或运算,否则不进行。
类似地,乘以(00000100)可以拆分成两次乘以(00000010)的运算:

乘以(0000 0011)可以拆分成先分别乘以(0000 0001)和(0000 0010),再将两个乘积异或:

因此,我们只需要实现乘以2的函数,其他数值的乘法都可以通过组合来实现。
下面举个具体的例子,输入的状态矩阵如下:





C9E5FD2B
7AF2786E
639C2667
B0A782E5

下面,进行列混合运算:
以第一列的运算为例:

其它列的计算就不列举了,列混合后生成的新状态矩阵如下:





D4E7CD66
2802E5BB
BEC6D6BF
220FDFA5

2.列混合逆运算

逆向列混合变换可由下图的矩阵乘法定义:

可以验证,逆变换矩阵同正变换矩阵的乘积恰好为单位矩阵。

四、轮密钥加

轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作,如下图所示。其中,密钥Ki中每个字W[4i],W[4i+1],W[4i+2],W[4i+3]为32位比特字,包含4个字节,他们的生成算法下面在下面介绍。轮密钥加过程可以看成是字逐位异或的结果,也可以看成字节级别或者位级别的操作。也就是说,可以看成S0 S1 S2 S3 组成的32位字与W[4i]的异或运算。

轮密钥加的逆运算同正向的轮密钥加运算完全一致,这是因为异或的逆操作是其自身。轮密钥加非常简单,但却能够影响S数组中的每一位。

密钥扩展

AES首先将初始密钥输入到一个44的状态矩阵中,如下图所示。

这个44矩阵的每一列的4个字节组成一个字,矩阵4列的4个字依次命名为W[0]、W[1]、W[2]和W[3],它们构成一个以字为单位的数组W。例如,设密钥K为"abcdefghijklmnop",则K0 = ‘a',K1 = ‘b', K2 = ‘c',K3 = ‘d',W[0] = “abcd”。
接着,对W数组扩充40个新列,构成总共44列的扩展密钥数组。新列以如下的递归方式产生:
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是一个有点复杂的函数。
函数T由3部分组成:字循环、字节代换和轮常量异或,这3部分的作用分别如下。
a.字循环:将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。
b.字节代换:对字循环的结果使用S盒进行字节代换。
c.轮常量异或:将前两步的结果同轮常量Rcon[j]进行异或,其中j表示轮数。
轮常量Rcon[j]是一个字,其值见下表。

j12345
Rcon[j]01 00 00 0002 00 00 0004 00 00 0008 00 00 0010 00 00 00
j678910
Rcon[j]20 00 00 0040 00 00 0080 00 00 001B 00 00 0036 00 00 00

下面举个例子:
设初始的128位密钥为:
3C A1 0B 21 57 F0 19 16 90 2E 13 80 AC C1 07 BD
那么4个初始值为:
W[0] = 3C A1 0B 21
W[1] = 57 F0 19 16
W[2] = 90 2E 13 80
W[3] = AC C1 07 BD
下面求扩展的第1轮的子密钥(W[4],W[5],W[6],W[7])。
由于4是4的倍数,所以:
W[4] = W[0] ⨁ T(W[3])
T(W[3])的计算步骤如下:

  1. 循环地将W[3]的元素移位:AC C1 07 BD变成C1 07 BD AC;

  2. 将 C1 07 BD AC 作为S盒的输入,输出为78 C5 7A 91;

  3. 将78 C5 7A 91与第一轮轮常量Rcon[1]进行异或运算,将得到79 C5 7A 91,因此,T(W[3])=79 C5 7A 91,故
    W[4] = 3C A1 0B 21 ⨁ 79 C5 7A 91 = 45 64 71 B0
    其余的3个子密钥段的计算如下:
    W[5] = W[1] ⨁ W[4] = 57 F0 19 16 ⨁ 45 64 71 B0 = 12 94 68 A6
    W[6] = W[2] ⨁ W[5] =90 2E 13 80 ⨁ 12 94 68 A6 = 82 BA 7B 26
    W[7] = W[3] ⨁ W[6] = AC C1 07 BD ⨁ 82 BA 7B 26 = 2E 7B 7C 9B
    所以,第一轮的密钥为 45 64 71 B0 12 94 68 A6 82 BA 7B 26 2E 7B 7C 9B。

AES解密

在文章开始的图中,有AES解密的流程图,可以对应那个流程图来进行解密。下面介绍的是另一种等价的解密模式,流程图如下图所示。这种等价的解密模式使得解密过程各个变换的使用顺序同加密过程的顺序一致,只是用逆变换取代原来的变换。

AES原理到这里就结束了,下面主要为AES的实现,对以上原理中的每一个小节进行实现讲解,讲解的时候会插入一些关键代码,完整的代码参见文章最后。文章最后提供两个完整的程序,一个能在linux下面编译运行,一个能在VC6.0下面编译通过。

AES算法实现

AES加密函数预览

aes加密函数中,首先进行密钥扩展,然后把128位长度的字符串读进一个4*4的整数数组中,这个数组就是状态矩阵。例如,pArray[0][0] = S0,pArray[1][0] = S1, pArray[0][1] = S4。这个读取过程是通过 convertToIntArray()函数来实现的。每个轮操作的函数都对pArray进行修改,也就是对状态矩阵进行混淆。在执行完10轮加密后,会把pArray转换回字符串,再存入明文p的字符数组中,所以,在加密完后,明文p的字符串中的字符就是加密后的字符了。这个转换过程是通过convertArrayToStr()函数来实现的。

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
/**
* 参数 p: 明文的字符串数组。
* 参数 plen: 明文的长度。
* 参数 key: 密钥的字符串数组。
*/
voidaes(char*p, intplen, char*key){
intkeylen = strlen(key);
if(plen == 0|| plen % 16!= 0) {
  printf("明文字符长度必须为16的倍数!\n");
  exit(0);
}
if(!checkKeyLen(keylen)) {
  printf("密钥字符长度错误!长度必须为16、24和32。当前长度为%d\n",keylen);
  exit(0);
}
extendKey(key);//扩展密钥
intpArray[4][4];
for(intk = 0; k < plen; k += 16) {
  convertToIntArray(p + k, pArray);
  addRoundKey(pArray, 0);//一开始的轮密钥加
  for(inti = 1; i < 10; i++){//前9轮
   subBytes(pArray);//字节代换
   shiftRows(pArray);//行移位
   mixColumns(pArray);//列混合
   addRoundKey(pArray, i);
  }
  //第10轮
  subBytes(pArray);//字节代换
  shiftRows(pArray);//行移位
  addRoundKey(pArray, 10);
  convertArrayToStr(pArray, p + k);
}
}

1.密钥扩展的实现

在开始加密前,必须先获得第一轮加密用到的密钥,故先实现密钥扩展
下面是密钥扩展函数的实现,这个函数传入密钥key的字符串表示,然后从字符串中读取W[0]到W[3],函数getWordFromStr()用于实现此功能。读取后,就开始扩展密钥,当i是4的倍数的时候,就会调用T()函数来进行扩展,因为T函数的行为与加密的轮数有关,故要把加密的轮数 j 作为参数传进去。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//密钥对应的扩展数组
staticintw[44];
/**
* 扩展密钥,结果是把w[44]中的每个元素初始化
*/
staticvoidextendKey(char*key) {
for(inti = 0; i < 4; i++)
  w[i] = getWordFromStr(key + i * 4);
for(inti = 4, j = 0; i < 44; i++) {
  if( i % 4== 0) {
   w[i] = w[i - 4] ^ T(w[i - 1], j);
   j++;//下一轮
  }else{
   w[i] = w[i - 4] ^ w[i - 1];
  }
}
}

下面是T()函数的代码实现,T()函数中接收两个参数,参数num为上面传进的W[i - 1],round为加密的轮数。首先用一个numArray储存从32位的W[i-1]中取得4个字节。如果W[i-1]为0x12ABCDEF,那么numArray[0] = 0x12,numArray[1] = 0xAB。函数splitIntToArray()用于从32位整数中读取这四个字节,之所以这样做是因为整数数组比较容易操作。然后调用leftLoop4int()函数把numArray数组中的4个元素循环左移1位。然后执行字节代换,通过getNumFromSBox()函数来获取S盒中相应的值来替换numArray中的值。接着通过mergeArrayToInt()函数把字节代换后的numArray合并回32位的整数,在进行轮常量异或后返回。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* 常量轮值表
*/
staticconstintRcon[10] = { 0x01000000, 0x02000000,
0x04000000, 0x08000000,
0x10000000, 0x20000000,
0x40000000, 0x80000000,
0x1b000000, 0x36000000};
/**
* 密钥扩展中的T函数
*/
staticintT(intnum, intround) {
intnumArray[4];
splitIntToArray(num, numArray);
leftLoop4int(numArray, 1);//字循环
//字节代换
for(inti = 0; i < 4; i++)
  numArray[i] = getNumFromSBox(numArray[i]);
intresult = mergeArrayToInt(numArray);
returnresult ^ Rcon[round];
}

2. 字节代换的实现

字节代换的代码很简单,就是把状态矩阵中的每个元素传进getNumFromSBox()函数中,然后取得前面8位中的高4位作为行值,低4位作为列值,然后返回S[row][col],这里的S是储存S盒的数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
* 根据索引,从S盒中获得元素
*/
staticintgetNumFromSBox(intindex) {
introw = getLeft4Bit(index);
intcol = getRight4Bit(index);
returnS[row][col];
}
/**
* 字节代换
*/
staticvoidsubBytes(intarray[4][4]){
for(inti = 0; i < 4; i++)
  for(intj = 0; j < 4; j++)
   array[i][j] = getNumFromSBox(array[i][j]);
}

3.行移位的实现

行移位的时候,首先把状态矩阵中第2,3,4行复制出来,然后对它们行进左移相应的位数,然后再复制回去状态矩阵array中。

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
/**
* 将数组中的元素循环左移step位
*/
staticvoidleftLoop4int(intarray[4], intstep) {
inttemp[4];
for(inti = 0; i < 4; i++)
  temp[i] = array[i];
intindex = step % 4== 0? 0: step % 4;
for(inti = 0; i < 4; i++){
  array[i] = temp[index];
  index++;
  index = index % 4;
}
}
/**
* 行移位
*/
staticvoidshiftRows(intarray[4][4]) {
introwTwo[4], rowThree[4], rowFour[4];
//复制状态矩阵的第2,3,4行
for(inti = 0; i < 4; i++) {
  rowTwo[i] = array[1][i];
  rowThree[i] = array[2][i];
  rowFour[i] = array[3][i];
}
//循环左移相应的位数
leftLoop4int(rowTwo, 1);
leftLoop4int(rowThree, 2);
leftLoop4int(rowFour, 3);
//把左移后的行复制回状态矩阵中
for(inti = 0; i < 4; i++) {
  array[1][i] = rowTwo[i];
  array[2][i] = rowThree[i];
  array[3][i] = rowFour[i];
}
}

4.列混合的实现

列混合函数中,先把状态矩阵初始状态复制一份到tempArray中,然后把tempArray与colM矩阵相乘,colM为存放要乘的常数矩阵的数组。其中的GFMul()函数定义了矩阵相乘时的乘法,加法则直接通过异或来实现。GFMul()通过调用乘以各个数对应的函数来实现乘法。例如,S1 * 2 刚通过调用GFMul2(S1)来实现。S1 * 3 刚通过GFMul3(S1)来实现。在这里,主要实现GFMul2()函数就行了,其它的都可以通过GFMul2()的组合来实现。举个例子吧,为计算下面这条等式,需要像下面这样调用函数
ex

s = GFMul3(0xC9) ^ 0x7A ^ 0x63 ^ GFMul2(0xB0)

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
/**
* 列混合要用到的矩阵
*/
staticconstintcolM[4][4] = { 2, 3, 1, 1,
1, 2, 3, 1,
1, 1, 2, 3,
3, 1, 1, 2};
staticintGFMul2(ints) {
intresult = s << 1;
inta7 = result & 0x00000100;
if(a7 != 0) {
  result = result & 0x000000ff;
  result = result ^ 0x1b;
}
returnresult;
}
staticintGFMul3(ints) {
returnGFMul2(s) ^ s;
}
/**
* GF上的二元运算
*/
staticintGFMul(intn, ints) {
intresult;
if(n == 1)
  result = s;
elseif(n == 2)
  result = GFMul2(s);
elseif(n == 3)
  result = GFMul3(s);
elseif(n == 0x9)
  result = GFMul9(s);
elseif(n == 0xb)//11
  result = GFMul11(s);
elseif(n == 0xd)//13
  result = GFMul13(s);
elseif(n == 0xe)//14
  result = GFMul14(s);
returnresult;
}
/**
* 列混合
*/
staticvoidmixColumns(intarray[4][4]) {
inttempArray[4][4];
for(inti = 0; i < 4; i++)
  for(intj = 0; j < 4; j++)
   tempArray[i][j] = array[i][j];
for(inti = 0; i < 4; i++)
  for(intj = 0; j < 4; j++){
   array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j])
    ^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);
  }
}

5.轮密钥加的实现

轮密钥加的实现很简单,就是根据传入的轮数来把状态矩阵与相应的W[i]异或。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 轮密钥加
*/
staticvoidaddRoundKey(intarray[4][4], intround) {
intwarray[4];
for(inti =