对称加密DES、3DES、AES的计算过程

目录

一、流密码与分组密码

二、DES计算过程

密钥操作

明文操作

1）明文编排

2）16轮迭代

三、3DES

四、AES(也叫RIJNDAEL算法） 

State

密钥编排

循环4​​​​​​​轮  每轮1+9+1  

SubBytes 

ShiftRows

 MixColumn

 AddRoundKey

五、AES和DES的区别

六、算法实现

七、算法魔改

白盒加密

一、流密码与分组密码

密码算法可分为：流密码与分组密码

流密码(Stream Cipher)：对数据流进行连续处理的一类密码算法；一般以1比特、8比特、32比特为单位进行加密或解密，由于是对一连串数据流进行连续处理，因此需要保持内部状态

分组密码(Block Cipher)：每次只能处理特定长度的一块数据的密码算法（一块是指分组），一个分组的比特数称为分组长度；处理完一个分组就结束了，不需通过内部状态来记录加密的进度

二、DES计算过程

左边是明文处理工作，右边是密钥操作

密钥操作

密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1），分组后的明文组和56位的密钥按位替代或交换的方法形成密文组。

1)把密钥转二进制

00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001

2)根据PC1表，对密钥进行重新排列

int PC1_Table[56] = {

        57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,

        10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,

        63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,

        14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4};     //选取密钥的第几位二进制数

密钥编排后的结果

1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111

3)接下​​​​​​​来将这56比特长的密钥分成左右两部分，命名为C0，D0

C0 = 1111000 0110011 0010101 0101111

D0 = 0101010 1011001 1001111 0001111

4)循环左移规定的位数，得到C1，D1到C16，D16的十六个数据

key_shift = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1];

C1 = 1110000 1100110 0101010 1011111

D1 = 1010101 0110011 0011110 0011110

C2D2可以对C1D1分别左移1位来得到，也可以对C0D0分别左移2位来得到

将C1D1拼接起来，继续后续的处理

C1D1 = 1110000 1100110 0101010 1011111 1010101 0110011 0011110 0011110

5)根据PC2表进行重排，56bit长的CnDn只留下48比特

int PC2_Table[48] = {

        14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,

        23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,

        41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,

        44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32};

重排后CnDn就是子密钥，命名为Kn

后续DES的十六轮运算中，第n轮就是用Kn，16个子密钥为

K1 = 000110 110000 001011 101111 111111 000111 000001 110010

K2 = 011110 011010 111011 011001 110110 111100 100111 100101

...

K15 = 101111 111001 000110 001101 001111 010011 111100 001010

K16 = 110010 110011 110110 001011 000011 100001 011111 110101

明文操作

1）明文编排

把明文转二进制

00000001 00100011 01000101 01100111 10001001 10101011 11001101 11101111

根据IP表，对明文进行初始置换

int IP_Table[64] = {

        58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,

        62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,

        57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,

        61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7};

明文重新排列后的结果

11001100 00000000 11001100 11111111 11110000 10101010 11110000 10101010

将明文分成左右两半，像上面的密钥一样

L0 和 R0

L0： 11001100 00000000 11001100 11111111

R0：11110000 10101010 11110000 10101010

2）16轮迭代

Ln = Rn-1

Rn = Ln-1 + f(Rn-1, Kn)

以n = 1为例:

L1 = R0 = 11110000 10101010 11110000 10101010

R1 = L0 xor f(R0, K1)

f函数传入了R0与K1(即第1个子密钥)

R0 = 11110000 10101010 11110000 10101010

K1 = 000110 110000 001011 101111 111111 000111 000001 110010

f函数的处理：

R0为32bit，K1为48bit，长度不同，没法按位异或

将32bit的R0扩展成48bit，使用到E表

E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101

int E_Table[48] = {

        32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,

        8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,

        16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,

        24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1};

进行密钥混合 E(R0) ^ K1

E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101

K1 = 000110 110000 001011 101111 111111 000111 000001 110010

K1 xor E(R0)= 011000 010001 011110 111010 100001 100110 010100 100111

DES算法核心

将上一步的结果分成8块6bit

B1 = 011000

B2 = 010001

B3 = 011110

B4 = 111010

B5 = 100001

B6 = 100110

B7 = 010100

B8 = 100111

把B1-B8的值当成索引，在S1-S8盒中取值，规则如下：

以B1为例，值为011000，将它分成0 1100 0，得到

i = 00 即 0

j = 1100 即 12

在S1中查找第0行第12列的值(这里从0开始算)

int S_Box[8][4][16] = {

        // S1

        14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,

        0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,

        4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,

        15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,

        // S2

        15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,

        3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,

        0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,

        13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,

        // S3

        10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,

        13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,

        13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,

        1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,

        // S4

        7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,

        13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,

        10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,

        3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,

        // S5

        2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,

        14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,

        4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,

        11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,

        // S6

        12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,

        10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,

        9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,

        4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,

        // S7

        4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,

        13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,

        1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,

        6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,

        // S8

        13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,

        1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,

        7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,

        2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11};

第0行第12列的值为5

B1 = 5 = 0101

再以B2为例

B2 = 0 1000 1

i = 01   = 1

j = 1000 = 8

B2 = 12 = 1100

B1在S1中找，B2在S2中找，以此类推

最后8个6比特的值在S盒作用下变成8个4比特的值

S(K1+E(R0)) = 0101 1100 1000 0010 1011 0101 1001 0111

得到的结果进行P表的重排

int P_Table[32] = {

        16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,

        2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25};

P(S(K1+E(R0))) = 0010 0011 0100 1010 1010 1001 1011 1011

F函数完事，即F = P(S(K1+E(R0)))

F的结果与L0异或

L1 = R0 = 11110000 10101010 11110000 10101010

R1 = Ln-1 xor f(Rn-1,Kn) = 11101111 01001010 01100101 01000100

一轮运算完毕，16轮运算的操作完全一致  当前轮结果作为下一轮明文

L1: 11110000 10101010 11110000 10101010

R1: 11101111 01001010 01100101 01000100

L2: 11101111 01001010 01100101 01000100

R2: 11001100 00000001 01110111 00001001

L3: 11001100 00000001 01110111 00001001

R3: 10100010 01011100 00001011 11110100

L4: 10100010 01011100 00001011 11110100

R4: 01110111 00100010 00000000 01000101

L5: 01110111 00100010 00000000 01000101

R5: 10001010 01001111 10100110 00110111

L6: 10001010 01001111 10100110 00110111

R6: 11101001 01100111 11001101 01101001

L7: 11101001 01100111 11001101 01101001

R7: 00000110 01001010 10111010 00010000

L8: 00000110 01001010 10111010 00010000

R8: 11010101 01101001 01001011 10010000

L9: 11010101 01101001 01001011 10010000

R9: 00100100 01111100 11000110 01111010

L10:00100100 01111100 11000110 01111010

R10:10110111 11010101 11010111 10110010

L11:10110111 11010101 11010111 10110010

R11:11000101 01111000 00111100 01111000

L12:11000101 01111000 00111100 01111000

R12:01110101 10111101 00011000 01011000

L13:01110101 10111101 00011000 01011000

R13:00011000 11000011 00010101 01011010

L14:00011000 11000011 00010101 01011010

R14:11000010 10001100 10010110 00001101

L15:11000010 10001100 10010110 00001101

R15:01000011 01000010 00110010 00110100

L16:01000011 01000010 00110010 00110100

R16:00001010 01001100 11011001 10010101

L16和R16倒换，左右调一下顺序，结果为R16L16

R16L16 = 00001010 01001100 11011001 10010101 01000011 01000010 00110010 00110100

最后一步，根据FP表进行末置换

10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101

int FP_Table[64] = {

        40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,

        38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,

        36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,

        34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25};

上述数据的十六进制形式为

85 e8 13 54 0f 0a b4 05

末置换就是初始置换的逆运算

明文经过初始置换，不做任何处理再进行末置换，值等于它自身

三、3DES

1. 密钥24个字节，等于3个DES的密钥

2. 3DES处理流程，每次使用一个DES密钥 DES加密 -> DES解密 -> DES加密

3. 前2个DES密钥相同时, 3DES结果等同于最后1个密钥DES加密后的结果

四、AES(也叫RIJNDAEL算法） 

State

明文和密钥变成4*4的矩阵

密钥编排

传入的16字节种子密钥state化，得到W0-W3 将种子密钥扩展，得到W0-W43

Wi = Wi-1 ^ Wi-4    if(i%4！=0)

W4 = T(Wi-1) ^ Wi-4

T函数流程：循环左移1个字节、s盒替换、与Rcon（给定常量）异或

循环4​​​​​​​​​​​​​​轮  每轮1+9+1  

SubBytes 

ShiftRows

第n行左移n-1个字节

 MixColumn

矩阵为给定矩阵

大于0x80的值乘矩阵时可能会溢出，如果溢出的话与0x1b异或

...  

 AddRoundKey

灰色的为RoundKey，一轮一个密钥

 ...   

五、AES和DES的区别

1. DES和AES都是对称加密算法，加解密都使用同一个密钥

2. DES和AES都是分组加密算法，DES的分组长度是64比特，AES的分组长度是128比特

3. DES的密钥64比特，AES的密钥128比特、192比特、256比特

4. DES运算的基本单元是比特，AES运算的基本单元是字节(8比特)

5. DES和AES都可以分成密钥的编排和明文的运算

6. DES和AES在密钥的编排中，都通过对密钥的处理生成一系列的子密钥subkey，每轮运算用1个

7. DES中有非常多的置换，AES没有

8. DES有16轮运算，在密钥编排中生成了16组子密钥    AES有10、12、14轮运算，也生成10、12、14组轮密钥，都是每轮用一个

9. AES每轮运算经过4个步骤

第1步字节代换(S盒替换)，16*16的S盒，加密解密不同的S盒     DES中也存在S盒，是4*16的S盒，共8个，加密解密使用相同的S盒

第2步是循环左移，DES或者哈希算法中都有     AES是按字节循环左移，DES和哈希算法都是按位循环左移

第4步和密钥异或，DES中同样有这一步

六、算法实现

有些会为了加快速度，通过查表来获得运算结果而不去计算   如openssl

 AES对称密码算法介绍(2)——查表法软件实现 - 知乎

openssl的aes实现 https://github.com/openssl/openssl/

openssl的EVP使用 https://blog.csdn.net/liao20081228/article/details/76285896/ EVP_CIPHER_CTX_init

EVP_EncryptInit_ex、

EVP_EncryptUpdate、

EVP_EncryptFinal_ex

EVP_CIPHER_CTX_cleanup

EVP_aes_128_cbc

七、算法魔改

初始置换和末置换同时去掉或者修改对应的值也可以正常加解密且不会影响安全性

S盒可以改但是需要基础不能乱改

白盒加密

将密钥固定下来，并且融合到算法中 也可以理解成在查表法的基础上，将算法的密钥扩展步骤也省掉 缺点是需要的表更大，更占内存，优点是攻击者很难拿到原始的密钥 白盒加密的表通常是不固定的，因为内置的密钥是不一样的。白盒加密是优于AES的，因为某种程度上，都可以不算是一个AES了，只不过结果和AES一致。攻击者很难拿到原始密钥，一般会选择抠代码。当存在混淆的时候，抠代码也会显得非常艰难。这就是一种保护