AES加密算法原理及实现

最新推荐文章于 2025-03-20 22:47:34 发布
最新推荐文章于 2025-03-20 22:47:34 发布
阅读量8.8k 收藏 36
点赞数 9
分类专栏： 密码学 文章标签： 加密解密 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012391423/article/details/116724060
版权

目录

一、简介

         1、明文P

2、密钥K

3、AES加密函数

4、密文C

5、AES解密函数

二、AES简要流程

三、加密的详细过程

1、字节替换

a、字节替换操作

b、字节替换逆操作

         2、行移位

a、行移位操作

b、行移位的逆变换

3、列混合

a、列混合操作

b、列混合逆运算

4、轮密钥加

四、密钥扩展

五、解密过程

六、AES算法实现

1、密钥扩展的实现

2、字节代换的实现

3、行移位的实现

4、列混合的实现

5、轮密钥加的实现

6、AES解密函数

 

 

 

 

 

一、简介

首先明确的是AES是数据高级加密标准，而并非是一种加密算法。AES（Advanced Encryption Standard）在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。

严格地说，AES和Rijndael加密法并不完全一样（虽然在实际应用中二者可以互换），因为Rijndael加密法可以支持更大范围的区块和密钥长度：AES的区块长度固定为128 比特，密钥长度则可以是128，192或256比特；

AES加密 & 解密 简要流程图

1、明文P

没有经过加密的数据。

2、密钥K

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

3、AES加密函数

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

4、密文C

经加密函数处理后的数据

5、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位即32个字节。秘钥的长度有三种长度：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”。

 

三、加密的详细过程

如上图所示，加密解密的轮函数依次经过了字节替换、行移位、列混合、轮秘钥加；而解密的过程正好是加密过程的逆运算。下文将详细讨论各个过程的具体细节。

1、字节替换

a、字节替换操作

简单来讲，就是我们准备了一张密码表，将明文的a 替换成 x , b 替换成 y , 这张密码表就是S盒 ， 解密的时候是逆S盒。

 

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

怎么替换呢?

AES加密的处理的最小单元是字节 ， 一个字节 = 4个比特位 ，我们把前两个比特位为行坐标 ， 后两个比特位为列坐标 ， 依次来确定替换后的新字节。例如，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下： 

b、字节替换逆操作

操作流程同上，逆S盒如下：

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

2、行移位

a、行移位操作

行移位就是我们的状态矩阵以行为单位左移的过程（注意左侧移除的字节转接到本行末尾），具体规则如下：

第一行不移位，第二行移1位，第三行移2位，第四行移3位

b、行移位的逆变换

行移位的逆操作，是右移。规则同上

3、列混合

a、列混合操作

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

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

矩阵元素的乘法和加法都是定义在基于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

下面，进行列混合运算：
以第一列的运算为例：
col7

详细解释一下第一行第一列 C9 的列混合操作：

2 * 0xC9   = 0xC9 * 2  = 1100 1001 * 0000 0010 =  ( 1100 1001  << 1 )  ^ 0001 1011  =  1 1001 0010  ^ 0001 1011 =  1000  1001

3 * 0x7A   = 0x7A * 3  = 0111 1010  * 0000 0011 = (0111 1010 << 1)  ^ 0111 1010  = 1111 0100  ^ 0111 1010 = 1000 1110

(2 * 0xC9) ^ (3 * 0x7A) = 1000  1001 ^ 1000 1110 = 0000 0111

(2 * 0xC9) ^ (3 * 0x7A) ^ 0x63 =  0000 0111 ^ 0110 0011 =0110 0100

(2 * 0xC9) ^ (3 * 0x7A) ^ 0x63 ^ 0xB0 = 0110 0100 ^ 1011 0000 =  1101 0100   =  0xD4

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

    
D4E7CD66
2802E5BB
BEC6D6BF
220FDFA5

b、列混合逆运算

逆向列混合变换可由下图的矩阵乘法定义：
col6
可以验证，逆变换矩阵同正变换矩阵的乘积恰好为单位矩阵。

4、轮密钥加


轮密钥加是将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]是一个字，其值见下表

下面举个例子：
设初始的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])的计算步骤如下：

循环地将W[3]的元素移位：AC C1 07 BD变成C1 07 BD AC;
将 C1 07 BD AC 作为S盒的输入，输出为78 C5 7A 91;
将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的实现，对以上原理中的每一个小节进行实现讲解，讲解的时候会插入一些关键代码，完整的代码参见文章最后。文章最后提供两个完整的程序，一个能在linux下面编译运行，一个能在VC6.0下面编译通过。

六、AES算法实现

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

/**
 * 参数 p: 明文的字符串数组。
 * 参数 plen: 明文的长度。
 * 参数 key: 密钥的字符串数组。
 */
void aes(char *p, int plen, char *key){

    int keylen = 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);//扩展密钥
    int pArray[4][4];

    for(int k = 0; k < plen; k += 16) {
        convertToIntArray(p + k, pArray);

        addRoundKey(pArray, 0);//一开始的轮密钥加

        for(int i = 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 作为参数传进去。
 

//密钥对应的扩展数组
static int w[44];

/**
 * 扩展密钥，结果是把w[44]中的每个元素初始化
 */
static void extendKey(char *key) {
    for(int i = 0; i < 4; i++)
        w[i] = getWordFromStr(key + i * 4); 

    for(int i = 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位的整数，在进行轮常量异或后返回。

 

/**
 * 常量轮值表
 */
static const int Rcon[10] = { 0x01000000, 0x02000000,
    0x04000000, 0x08000000,
    0x10000000, 0x20000000,
    0x40000000, 0x80000000,
    0x1b000000, 0x36000000 };
/**
 * 密钥扩展中的T函数
 */
static int T(int num, int round) {
    int numArray[4];
    splitIntToArray(num, numArray);
    leftLoop4int(numArray, 1);//字循环

    //字节代换
    for(int i = 0; i < 4; i++)
        numArray[i] = getNumFromSBox(numArray[i]);

    int result = mergeArrayToInt(numArray);
    return result ^ Rcon[round];
}

2、字节代换的实现

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

/**
 * 根据索引，从S盒中获得元素
 */
static int getNumFromSBox(int index) {
    int row = getLeft4Bit(index);
    int col = getRight4Bit(index);
    return S[row][col];
}

/**
 * 字节代换
 */
static void subBytes(int array[4][4]){
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            array[i][j] = getNumFromSBox(array[i][j]);
}

 

3、行移位的实现

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

 

/**
 * 将数组中的元素循环左移step位
 */
static void leftLoop4int(int array[4], int step) {
    int temp[4];
    for(int i = 0; i < 4; i++)
        temp[i] = array[i];

    int index = step % 4 == 0 ? 0 : step % 4;
    for(int i = 0; i < 4; i++){
        array[i] = temp[index];
        index++;
        index = index % 4;
    }
}

/**
 * 行移位
 */
static void shiftRows(int array[4][4]) {
    int rowTwo[4], rowThree[4], rowFour[4];
    //复制状态矩阵的第2,3,4行
    for(int i = 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(int i = 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()的组合来实现。举个例子吧，为计算下面这条等式，需要像下面这样调用函数


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

/**
 * 列混合要用到的矩阵
 */
static const int colM[4][4] = { 2, 3, 1, 1,
    1, 2, 3, 1,
    1, 1, 2, 3,
    3, 1, 1, 2 };

static int GFMul2(int s) {
    int result = s << 1;
    int a7 = result & 0x00000100;

    if(a7 != 0) {
        result = result & 0x000000ff;
        result = result ^ 0x1b;
    }

    return result;
}

static int GFMul3(int s) {
    return GFMul2(s) ^ s;
}

/**
 * GF上的二元运算
 */
static int GFMul(int n, int s) {
    int result;

    if(n == 1)
        result = s;
    else if(n == 2)
        result = GFMul2(s);
    else if(n == 3)
        result = GFMul3(s);
    else if(n == 0x9)
        result = GFMul9(s);
    else if(n == 0xb)//11
        result = GFMul11(s);
    else if(n == 0xd)//13
        result = GFMul13(s);
    else if(n == 0xe)//14
        result = GFMul14(s);

    return result;
}

/**
 * 列混合
 */
static void mixColumns(int array[4][4]) {

    int tempArray[4][4];

    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++)
            tempArray[i][j] = array[i][j];

    for(int i = 0; i < 4; i++)
        for(int j = 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]异或。

 

/**
 * 轮密钥加
 */
static void addRoundKey(int array[4][4], int round) {
    int warray[4];
    for(int i = 0; i < 4; i++) {

        splitIntToArray(w[ round * 4 + i], warray);

        for(int j = 0; j < 4; j++) {
            array[j][i] = array[j][i] ^ warray[j];
        }
    }
}

 

6、AES解密函数

AES的解密函数和加密函数有点不同，可以参考上面的等价解密流程图来理解，解密函数中调用的是各轮操作的逆函数。逆函数在这里就不详细讲解了，可以参考最后的完整代码。

/**
 * 参数 c: 密文的字符串数组。
 * 参数 clen: 密文的长度。
 * 参数 key: 密钥的字符串数组。
 */
void deAes(char *c, int clen, char *key) {

    int keylen = strlen(key);
    if(clen == 0 || clen % 16 != 0) {
        printf("密文字符长度必须为16的倍数！现在的长度为%d\n",clen);
        exit(0);
    }

    if(!checkKeyLen(keylen)) {
        printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);
        exit(0);
    }

    extendKey(key);//扩展密钥
    int cArray[4][4];
    for(int k = 0; k < clen; k += 16) {
        convertToIntArray(c + k, cArray);


        addRoundKey(cArray, 10);

        int wArray[4][4];
        for(int i = 9; i >= 1; i--) {
            deSubBytes(cArray);

            deShiftRows(cArray);

            deMixColumns(cArray);
            getArrayFrom4W(i, wArray);
            deMixColumns(wArray);

            addRoundTowArray(cArray, wArray);
        }

        deSubBytes(cArray);

        deShiftRows(cArray);

        addRoundKey(cArray, 0);

        convertArrayToStr(cArray, c + k);

    }
}

 

深入理解AES加密算法：原理与Python实现
qq_42568323的博客
08-20 2109
分组长度：AES处理固定长度的分组，通常为128位（16字节）。密钥长度：AES支持128位、192位和256位三种密钥长度。轮数：加密过程中的轮数取决于密钥长度，分别为10轮（128位密钥）、12轮（192位密钥）和14轮（256位密钥）。
AES算法原理及其实现
05-08
在研究分析了AES加密原理的基础上着重说明了AES算法实现的具体步骤,并用C 语言完整地实现 了AES算法,并利用密文分组链接(CBC) 方式将其用于对文件的加密/ 解密(密钥长度可选) 。AES结合其它技术还可实现更为广泛的安全协议。
AES算法介绍
最新发布
sky的博客
03-20 1628
希望大佬们可以关注下博主微信公众号，后续微信公众号会持续更新相关文章：AES(Advanced Encryption Standard)算法是一种对称加密算法，是由美国国家标准与技术研究院(NIST)在 2001 年发布，旨在取代早期的数据加密标准(DES)，并提供更高的安全性，目前该算法被广泛用于各种安全需求中，AES算法以其高度的安全性核效率成为目前最流行的对称加密算法之一。字节替换：属于非线性替换，具体为通过一个替换表(S 盒)对每个字节进行查表替换，查表时将每一个字节。
AES加密算法的详细介绍与实现
学习一定要有针对性的练习-实操！
10-19 4827
AES简介 高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的作用与意义： 明文P 没有经过加密的数据。 密钥K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给
AES 加密算法的原理详解
FKNIGHT 的博客
07-23 24万+
本教程摘选自https://blog.csdn.net/qq_28205153/article/details/55798628的原理部分。 AES简介 高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的...
AES加密算法原理的详细介绍与实现
热门推荐
qq_28205153的博客
02-19 88万+
AES简介高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的作用与意义： 明文P 没有经过加密的数据。密钥K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生
AES算法 —— 原理以及实现
vergilben的学习日记
04-11 7445
高级加密标准（Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。200...
AES加密算法的原理详解与实现分析
10-14
【AES加密算法详解】 AES（Advanced Encryption Standard）是一种广泛应用的对称加密算法，主要用于保护敏感数据的安全传输。例如，微信小程序在进行数据通信时就采用了AES加密算法来确保信息的私密性。对称加密...
QT 实现AES 加密算法
05-27
总的来说，QT实现AES加密算法涉及理解AES的工作原理、选择或实现加密库、封装加密解密接口以及密钥管理等多个方面。通过这个过程，开发者可以为QT应用程序提供强大的数据保护能力，确保数据在传输和存储中的安全性。
什么是AES加密？详解AES加密算法原理流程
m0_69916115的博客
09-07 2万+
在密码学中，加密算法分为双向加密和单向加密。单向加密包括MD5、SHA等摘要算法，它们是不可逆的。双向加密包括对称加密和非对称加密，对称加密包括AES加密、DES加密等。双向加密是可逆的，存在密文的密钥。AES算法是DES算法的替代者，也是现在最流行的加密算法之一。下面给大家介绍什么是AES加密算法，以及AES加密算法的原理和流程。
AES加密算法原理.pdf
07-13
"AES加密算法原理.pdf" AES 加密算法是当前最流行和最安全的对称加密算法之一。该算法的发展是为了取代 DES 加密算法，因为 DES 加密算法的密钥长度较小（56位），已经不能满足当前分布式开放网络对数据加密安全性...
AES密码算法算法原理与实现
01-02
AES密码算法算法原理与实现 AES密码算法算法原理与实现 AES密码算法算法原理与实现
AES 算法原理及其实现
10-21
在研究分析了AES 加密原理的基础上着重说明了AES 算法实现的具体步骤,并用C 语言完整地实现 了AES 算法,并利用密文分组链接(CBC) 方式将其用于对文件的加密/ 解密(密钥长度可选) 。AES 结合其它技 术还可实现更为广泛的安全协议。
Aes算法的实现
01-31
成项目文件中分离出来，复制成了txt文档，推荐用Notepad++打开，用C++风格显示，比较明朗
aes算法的C语言实现
11-22
aes算法的实现，编程实现aes的加密与解密，明文块与密钥均为128位。
对称加密算法（AES）：原理、应用与代码实现
candy的博客
10-25 6196
AES 算法作为一种强大的对称加密算法，在保障信息安全方面具有重要的地位和广泛的应用。通过对其原理的深入理解，我们知道了它是如何通过一系列复杂的操作将明文转换为密文，以及如何通过逆操作进行解密。在实际应用中，AES 广泛应用于数据加密与存储、网络通信安全、多媒体内容保护等多个领域，为我们的数字生活和工作提供了可靠的安全保障。在实现 AES 算法的加解密功能时，C# 和 Python 都提供了相应的库和方法，使得我们能够方便地在应用程序中使用 AES 进行数据保护。
AES 加密算法原理详解及实现
兴趣是最好的老师，勤能补拙
06-16 1万+
随着互联网的发展，越来越多的数据需要在网络中进行传输。为了保证数据的安全性，在进行网络传输时，需要对数据进行加密操作，使得数据在传输过程中不被窃取或篡改。AES（Advanced Encryption Standard）就是一种经典的加密算法。AES 算法源于比利时密码学家 Joan Daemen 和 Vincent Rijmen，它是一种对称加密算法，通过使用相同的密钥对数据进行加密和解密操作。AES 算法中，加密和解密操作是相反的过程，因此需要使用相同的密钥作为加密和解密的关键参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值