Des 加解密 流程解析
http://www.hankcs.com/security/des-algorithm-illustrated.html
http://blog.sina.com.cn/s/blog_7722acb50102x93c.html
Des 加密 流程：
-
- 1. 如何取得16个子密钥
- 2. 对明文数据初始置换（IP=Initial permutation）
- 3.利用16个子密钥 进行16次迭代
- 4. 最终变换
- 5. 其他软件验证
- 6. 算法实现中遇到的问题
- 7. 解密过程：
- 8. C语言实现源码：
- 9.另外一种 代码 实现方式
- 10 . 对第8节的C语言，修改一下：
1. 如何取得16个子密钥
举个例子，取十六进制秘钥K为:
K = 133457799BBCDFF1K = 13 34 57 79 9B BC DF F1K 在内存中共占8个字节，如果是 小端模式，低位在前，高位在后，bit0—bit7 ，低字节在前高字节在后
其对应的，实际的字节内容为：
0xC8 ,0x2C ,0xEA ,0x9E ,0xD9 ,0x3D ,0xFB ,0x8F
得到K的二进制表示：
K = 00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001
13 34 57 79 9B BC DF F1
C8 2C EA 9E D9 3D FB 8F 对每一位进行编号：
| 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | |||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 0 | 0 |
| 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | |||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | 1 |
| 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | |||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 0 | 0 |
| 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | |||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 1 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 |
2.密钥置换
不考虑每个字节的第8位，DES的密钥由64位减至56位，每个字节的第8位作为奇偶校验位。产生的56位密钥由下表生成（注意表中没有8,16,24，32,40,48,56和64这8位）：
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 | 57 | 49 | 41 | 33 | 25 | 17 | 09 | 01 | 58 | 50 | 42 | 34 | 26 | 18 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 1 |
| 10 | 02 | 59 | 51 | 43 | 35 | 27 | 19 | 11 | 03 | 60 | 52 | 44 | 36 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 1 |
| 63 | 55 | 47 | 39 | 31 | 23 | 15 | 07 | 62 | 54 | 46 | 38 | 30 | 22 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 1 |
| 14 | 06 | 61 | 53 | 45 | 37 | 29 | 21 | 13 | 05 | 28 | 20 | 12 | 04 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 0 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |
我们将得到56位的新秘钥：
K+ = 1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111然后，将这个秘钥拆分为左右两部分，C0 和 D0，每半边都有28位。
比如，对于新秘钥，我们得到：
C0 = 1111000 0110011 0010101 0101111
D0 = 0101010 1011001 1001111 0001111对于C0 ，我们现在创建16个块Cn , 1<=n<=16。每次Cn 都是由前面的Cn-1 移位而来。
具体说来，对于n = 1, 2, …, 16，在前一轮移位的结果上，使用下表进行一些次数的左移操作。
根据轮数，将Cn分别循环左移1位或2位
对于D0 ，我们现在创建16个块Dn , 1<=n<=16。每次Dn 都是由前面的Dn-1 移位而来。
具体说来，对于n = 1, 2, …, 16，在前一轮移位的结果上，使用下表进行一些次数的左移操作。
根据轮数，将Dn分别循环左移1位或2位
什么叫左移？左移指的是将除第一位外的所有位往左移一位，将第一位移动至最后一位。实际上是循环左移
Iteration Number of
Number Left Shifts
1 1
2 1
3 2
4 2
5 2
6 2
7 2
8 2
9 1
10 2
11 2
12 2
13 2
14 2
15 2
16 1这意味着，C3 是C2 移位而来的，具体来说，通过2次左移位；C16 则是由C15 通过1次左移得到的。
同样，D3 是D2 移位而来的，具体来说，通过2次左移位；D16 则是由D15 通过1次左移得到的。
第一轮是循环左移1位。C0循环左移1位后得到C1如下：
| Cx | content | index | num |
|---|---|---|---|
| C0 | 1111000011001100101010101111 | 1 | 1 |
| C1 | _1110000110011001010101011111 | 2 | 1 |
| C2 | __1100001100110010101010111111 | 3 | 2 |
| C3 | ____0000110011001010101011111111 | 4 | 2 |
| C4 | ______0011001100101010101111111100 | 5 | 2 |
| C5 | ________1100110010101010111111110000 | 6 | 2 |
| C6 | __________0011001010101011111111000011 | 7 | 2 |
| C7 | ____________1100101010101111111100001100 | 8 | 2 |
| C8 | ______________0010101010111111110000110011 | 9 | 1 |
| C9 | _______________0101010101111111100001100110 | 10 | 2 |
| C10 | _________________0101010111111110000110011001 | 11 | 2 |
| C11 | ___________________0101011111111000011001100101 | 12 | 2 |
| C12 | _____________________0101111111100001100110010101 | 13 | 2 |
| C13 | _______________________0111111110000110011001010101 | 14 | 2 |
| C14 | _________________________1111111000011001100101010101 | 15 | 2 |
| C15 | ___________________________1111100001100110010101010111 | 16 | 1 |
| C16 | ____________________________1111000011001100101010101111 |
D0循环左移1位后得到D1如下：
| Dx | content | index | num |
|---|---|---|---|
| D0 | 0101010101100110011110001111 | 1 | 1 |
| D1 | _1010101011001100111100011110 | 2 | 1 |
| D2 | __0101010110011001111000111101 | 3 | 2 |
| D3 | ____0101011001100111100011110101 | 4 | 2 |
| D4 | ______0101100110011110001111010101 | 5 | 2 |
| D5 | ________0110011001111000111101010101 | 6 | 2 |
| D6 | __________1001100111100011110101010101 | 7 | 2 |
| D7 | ____________0110011110001111010101010110 | 8 | 2 |
| D8 | ______________1001111000111101010101011001 | 9 | 1 |
| D9 | _______________0011110001111010101010110011 | 10 | 2 |
| D10 | _________________1111000111101010101011001100 | 11 | 2 |
| D11 | ___________________1100011110101010101100110011 | 12 | 2 |
| D12 | _____________________0001111010101010110011001111 | 13 | 2 |
| D13 | _______________________0111101010101011001100111100 | 14 | 2 |
| D14 | _________________________1110101010101100110011110001 | 15 | 2 |
| D15 | ___________________________1010101010110011001111000111 | 16 | 1 |
| D16 | ____________________________0101010101100110011110001111 |
我们现在就可以得到第n轮的新秘钥Kn（ 1<=n<=16）了。具体做法是，对每对拼合后的子秘钥CnDn，按表PC-2执行变换：
PC-2
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每对子秘钥有56位，但PC-2仅仅使用其中的48位。
去掉第9、18、22、25、35、38、43、54位，从56位变成48位，再按表的位置置换。
C1和D1合并之后，再经过置换选择表2生成48位的子秘钥K1。置换选择表2(PC-2)如下：
C1和D1再次经过循环左移变换，生成C2和D2，C2和D2合并，通过PC-2生成子秘钥K2。
以此类推，得到子秘钥K1~K16。需要注意其中循环左移的位数。
于是，第n轮的新秘钥Kn 的第1位来自组合子秘钥CnDn的第14位，第2位来自第17位，依次类推，知道新秘钥的第48位来自组合秘钥的第32位。
比如，对于第1轮的组合秘钥，我们有：
C1D1 = 1110000 1100110 0101010 1011111 1010101 0110011 0011110 0011110| 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 0 | |
| 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | |
| 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | 1 | 1 | |
| 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | |
| 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | |
| 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | |
| 0 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 0 |
通过PC-2的变换后，得到：
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
| 14 | 17 | 11 | 24 | 01 | 05 | 03 | 28 | 15 | 06 | 21 | 10 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | |
| 23 | 19 | 12 | 04 | 26 | 08 | 16 | 07 | 27 | 20 | 13 | 02 | |
| 0 | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | |
| 41 | 52 | 31 | 37 | 47 | 55 | 30 | 40 | 51 | 45 | 33 | 48 | |
| 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | 1 | 1 | |
| 44 | 49 | 39 | 56 | 34 | 53 | 46 | 42 | 50 | 36 | 29 | 32 | |
| 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 1 | 0 |
同理，对于其他秘钥得到：
共得到16个子密钥：
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
K2 = 011110 011010 111011 011001 110110 111100 100111 100101
K3 = 010101 011111 110010 001010 010000 101100 111110 011001
K4 = 011100 101010 110111 010110 110110 110011 010100 011101
K5 = 011111 001110 110000 000111 111010 110101 001110 101000
K6 = 011000 111010 010100 111110 010100 000111 101100 101111
K7 = 111011 001000 010010 110111 111101 100001 100010 111100
K8 = 111101 111000 101000 111010 110000 010011 101111 111011
K9 = 111000 001101 101111 101011 111011 011110 011110 000001
K10 = 101100 011111 001101 000111 101110 100100 011001 001111
K11 = 001000 010101 111111 010011 110111 101101 001110 000110
K12 = 011101 010111 000111 110101 100101 000110 011111 101001
K13 = 100101 111100 010111 010001 111110 101011 101001 000001
K14 = 010111 110100 001110 110111 111100 101110 011100 111010
K15 = 101111 111001 000110 001101 001111 010011 111100 001010
K16 = 110010 110011 110110 001011 000011 100001 011111 110101
关于子秘钥的话题就到此为止了，接下来我们看看信息本身
2. 对明文数据初始置换（IP=Initial permutation）
DES是一个基于组块的加密算法，这意味着无论输入还是输出都是64位长度的。也就是说DES产生了一种最多264种的变换方法。每个64位的区块被分为2个32位的部分，左半部分L和右半部分R。（这种分割只在特定的操作中进行。）
比如，取明文M为：
M = 0123456789ABCDEF这里的M是16进制的，将M写成二进制，我们得到一个64位的区块：
M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
L = 0000 0001 0010 0011 0100 0101 0110 0111
R = 1000 1001 1010 1011 1100 1101 1110 1111内存中的排布：
M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
80 C4 A2 E6 91 D5 B3 F7
char PlainText[8] = { 0x80, 0xC4, 0xA2, 0xE6, 0x91, 0xD5, 0xB3, 0xF7 };
M的第一位是0，最后一位是1，我们从左读到右。
第二步：加密数据的每个64位区块
对于明文数据M，我们计算一个初始变换IP（Initial permutation）。IP是重新变换数据M的每一位产生的。产生过程由下表决定，表格的下标对应新数据的下标，表格的数值x表示新数据的这一位来自旧数据的第x位。
IP
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参照上表，M的第58位成为IP的第1位，M的第50位成为IP的第2位，M的第7位成为IP的最后一位。
比如，对M的区块执行初始变换，得到：
M = 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
IP = 1100 1100 0000 0000 1100 1100 1111 1111 1111 0000 1010 1010 1111 0000 1010 1010这里M的第58位是1，变成了IP的第1位。M的第50位是1，变成了IP的第2位。M的第7位是0，变成了IP的最后一位。
接着将变换IP分为32位的左半边L0 和32位的右半边R0 。
比如，对于上例，我们得到：
L0 = 1100 1100 0000 0000 1100 1100 1111 1111
R0 = 1111 0000 1010 1010 1111 0000 1010 10103.利用16个子密钥 进行16次迭代
我们接着执行16个迭代，对1<=n<=16，使用一个函数f。函数f输入两个区块——一个32位的数据区块和一个48位的秘钥区块Kn ——输出一个32位的区块。定义+表示异或XOR。那么让n从1循环到16，我们计算
Ln = Rn-1
Rn = Ln-1 + f(Rn-1,Kn)
这样我们就得到最终区块，也就是n = 16 的 L16R16。这个过程说白了就是，我们拿前一个迭代的结果的右边32位作为当前迭代的左边32位。对于当前迭代的右边32位，将它和上一个迭代的f函数的输出执行XOR运算。
比如，对n = 1，我们有：
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
L1 = R0 = 1111 0000 1010 1010 1111 0000 1010 1010
R1 = L0 + f(R0,K1)剩下的就是f函数是如何工作的了。
为了计算f，我们首先拓展每个Rn-1，将其从32位拓展到48位。这是通过使用一张表来重复Rn-1中的一些位来实现的。我们称这个过程为函数E。也就是说函数E(Rn-1)输入32位输出48位。
定义E为函数E的输出，将其写成8组，每组6位。这些比特是通过选择输入的某些位来产生的，具体选择顺序按下表实现：
E BIT-SELECTION TABLE
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(Rn-1) 开头的三个比特分别来自Rn-1的第32、1和2位。E(Rn-1) 末尾的2个比特分别来自Rn-1的第32位和第1位。
比如，给定R0 ，我们可以计算出E(R0) ：
R0 = 1111 0000 1010 1010 1111 0000 1010 1010
E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101（注意输入的每4位一个分组被拓展为输出的每6位一个分组。）
接着在f函数中，我们对输出E(Rn-1) 和秘钥Kn执行XOR运算：
Kn + E(Rn-1)
比如，对K1 , E(R0)，我们有：
K1 = 000110 110000 001011 101111 111111 000111 000001 110010
E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101
K1+E(R0) = 011000 010001 011110 111010 100001 100110 010100 100111.到这里我们还没有完成f函数的运算，我们仅仅使用一张表将Rn-1 从32位拓展为48位，并且对这个结果和秘钥Kn执行了异或运算。我们现在有了48位的结果，或者说8组6比特数据。我们现在要对每组的6比特执行一些奇怪的操作：我们将它作为一张被称为“S盒”的表格的地址。每组6比特都将给我们一个位于不同S盒中的地址。在那个地址里存放着一个4比特的数字。这个4比特的数字将会替换掉原来的6个比特。最终结果就是，8组6比特的数据被转换为8组4比特（一共32位）的数据。
将上一步的48位的结果写成如下形式：
Kn + E(Rn-1) =B1B2B3B4B5B6B7B8,
每个Bi 都是一个6比特的分组，我们现在计算
S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8)
其中，Si(Bi) 指的是第i个S盒的输出。
为了计算每个S函数S1, S2,…, S8，取一个6位的区块作为输入，输出一个4位的区块。决定S1的表格如下：
S1
Column Number
Row
No. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7
1 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8
2 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0
3 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13| Row/Column | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 14 | 4 | 13 | 1 | 2 | 15 | 11 | 8 | 3 | 10 | 6 | 12 | 5 | 9 | 0 | 7 |
| 1 | 0 | 15 | 7 | 4 | 14 | 2 | 13 | 1 | 10 | 6 | 12 | 11 | 9 | 5 | 3 | 8 |
| 2 | 4 | 1 | 14 | 8 | 13 | 6 | 2 | 11 | 15 | 12 | 9 | 7 | 3 | 10 | 5 | 0 |
| 3 | 15 | 12 | 8 | 2 | 4 | 9 | 1 | 7 | 5 | 11 | 3 | 14 | 10 | 0 | 6 | 13 |
如果S1 是定义在这张表上的函数，B是一个6位的块，那么计算S1(B) 的方法是：B的第一位和最后一位组合起来的二进制数决定一个介于0和3之间的十进制数（或者二进制00到11之间）。设这个数为i。B的中间4位二进制数代表一个介于0到15之间的十进制数（二进制0000到1111）。设这个数为j。查表找到第i行第j列的那个数，这是一个介于0和15之间的数，并且它是能由一个唯一的4位区块表示的。这个区块就是函数S1 输入B得到的输出S1(B)。比如，对输入B = 011011 ，第一位是0，最后一位是1，决定了行号是01，也就是十进制的1 。中间4位是1101，也就是十进制的13，所以列号是13。查表第1行第13列我们得到数字5。这决定了输出；5是二进制0101，所以输出就是0101。也即S1(011011) = 0101。
对于S1（011000）解析： 第一位是0，最后一位是0，决定了行号是0，中间4位为1100，对应的是十进制12. 查表 第0行
第12列，这个数字是5 ，5 对应的4比特的 二进制是 0101，
这里设置为 bit0 =0 ，bit1= 1， bit2 = 0 ， bit3 = 1 ，但是有的实现里面是设置为：
bit0 = 1 , bit1 = 0 , bit2 = 1 , bit3 = 0
同理，定义这8个函数S1,…,S8的表格如下所示：
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例子：对于第一轮，我们得到这8个S盒的输出：
K1 + E(R0) = 011000 010001 011110 111010 100001 100110 010100 100111.
S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8) = 0101 1100 1000 0010 1011 0101 1001 0111
函数f的最后一步就是对S盒的输出进行一个变换来产生最终值：
f = P(S1(B1)S2(B2)…S8(B8))
变换P由如下表格定义。P输入32位数据，通过下标产生32位输出：
P
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比如，对于8个S盒的输出：
S1(B1)S2(B2)S3(B3)S4(B4)S5(B5)S6(B6)S7(B7)S8(B8) = 0101 1100 1000 0010 1011 0101 1001 0111
我们得到
f = 0010 0011 0100 1010 1010 1001 1011 1011
那么，
R1 = L0 + f(R0 , K1 )
= 1100 1100 0000 0000 1100 1100 1111 1111
+ 0010 0011 0100 1010 1010 1001 1011 1011
= 1110 1111 0100 1010 0110 0101 0100 0100在下一轮迭代中，我们的L2 = R1，这就是我们刚刚计算的结果。之后我们必须计算R2 =L1 + f(R1, K2)，一直完成16个迭代。在第16个迭代之后，我们有了区块L16 and R16。
接着我们逆转两个区块的顺序得到一个64位的区块：（有的 网上实现的des.cpp算法里面没有这一步）
R16L16
4. 最终变换
然后对其执行一个最终的变换 IP-1 ，其定义如下表所示：
IP-1
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也就是说，该变换的的输出的第1位是输入的第40位，第2位是输入的第8位，一直到将输入的第25位作为输出的最后一位。
比如，如果我们使用了上述方法得到了第16轮的左右两个区块：
L16 = 0100 0011 0100 0010 0011 0010 0011 0100
R16 = 0000 1010 0100 1100 1101 1001 1001 0101我们将这两个区块调换位置，然后执行最终变换：
R16L16 = 00001010 01001100 11011001 10010101 01000011 01000010 00110010 00110100
IP-1 = 10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101写成16进制得到：
85E813540F0AB405这就是明文M = 0123456789ABCDEF的加密形式C = 85E813540F0AB405。
解密就是加密的反过程，执行上述步骤，只不过在那16轮迭代中，调转左右子秘钥的位置而已。
5. 其他软件验证
1000 0101 1110 1000 0001 0011 0101 0100 0000 1111 0000 1010 1011 0100 0000 0101
8 5 E 8 1 3 5 4 0 F 0 A B 4 0 5
a1 17 c8 2a f0 50 2d a0对应的小端存储的字节为:
0xa1,0x17,0xc8,0x2a,0xf0,0x50 ,0x2d ,0xa0
密钥：133457799BBCDFF1
数据：0123456789ABCDEF
结果：85E813540F0AB405
6. 算法实现中遇到的问题
在算法的实现中，有的实现：
static void ByteToBit(bool *Out, const char *In, int bits)
{
for(int i=0; i>3]>>(7 - i&7)) & 1;
}
static void BitToByte(char *Out, const bool *In, int bits)
{
memset(Out, 0, bits>>3);
for(int i=0; i>3] |= In[i]<<(7 - i&7);
} 有的地方实现是:
void ByteToBit(bool *Out, const char *In, int bits)//字节组转换成位组
{
for(int i = 0; i < bits; i++)
{
Out[i] = (In[i/8] >> (i%8)) & 1;
}
}
void BitToByte(char *Out, const bool *In, int bits)
{
memset(Out, 0, (bits+7)/8);
for(int i = 0; i < bits; i++)
{
Out[i/8] |= In[i] << (i%8);
}
}
本文是用的是第二种方式。
7. 解密过程：
void Des_Run(char Out[8], char In[8], bool Type)
{
static bool M[64], Tmp[32], *Li = &M[0], *Ri = &M[32];
ByteToBit(M, In, 64);// 字节组转换成位组
Transform(M, M, IP_Table, 64);// 变换
if( Type == ENCRYPT ){// 加密
for(int i=0; i<16; i++) {
memcpy(Tmp, Ri, 32);
F_func(Ri, SubKey[i]);
Xor(Ri, Li, 32);// 异或
memcpy(Li, Tmp, 32);
}
}else{//解密
for(int i=15; i>=0; i--) {
memcpy(Tmp, Ri, 32);
F_func(Ri, SubKey[i]);
Xor(Ri, Li, 32);// 异或
memcpy(Li, Tmp, 32);
}
}
memcpy(Tmp, Li, 32);
memcpy(Li, Ri, 32);
memcpy(Ri, Tmp, 32);
Transform(M, M, IPR_Table, 64);// 变换
BitToByte(Out, M, 64);
}根据网上的文章 ，解密有两种一种是：调转左右子秘钥的位置，
一种是。DES算法的解密过程是一样的，区别仅仅在于第一次迭代时用子密钥K15，第二次K14、……，最后一次用K0，算法本身并没有任何变化。
8. C语言实现源码：
// DES算法利用一个56+8奇偶校验位(第8,16,24,32,40,48,56,64位)=64位的密钥对以64位为单位的块数据进行加解密
#include "memory.h"
#include "stdio.h"
#include "conio.h"
enum {ENCRYPT,DECRYPT};// ENCRYPT:加密,DECRYPT:解密
void Des_Run(char Out[8], char In[8], bool Type=ENCRYPT);
void Des_SetKey(const char Key[8]);// 设置密钥
static void F_func(bool In[32], const bool Ki[48]);// f 函数
static void S_func(bool Out[32], const bool In[48]);// S 盒代替
static void Transform(bool *Out, bool *In, const char *Table, int len);// 变换
static void Xor(bool *InA, const bool *InB, int len);// 异或
static void RotateL(bool *In, int len, int loop);// 循环左移
static void ByteToBit(bool *Out, const char *In, int bits);// 字节组转换成位组
static void BitToByte(char *Out, const bool *In, int bits);// 位组转换成字节组
static void ByteToBit_Print(bool *Out, const char *In, int bits);
void ByteToBitDD_Print(bool *Out, const char *In, int bits);//字节组转换成位组
/*
* 子密钥生成：
* 1. 密钥先被转化成64比特的二进制；
* 2. 再按照密钥置换函数PC-1(8x7)进行压缩置换，变成56位；
* 3. 将其置换的输出再分为前28位C0和后28位D0两部分；
* 4. 进行16轮数据处理，每一轮中，先将C0和D0 分别 进行循环左移，
* 再将两部分左移结果 一起执行压缩置换PC-2(8X6)，最后生成16个48位的子密钥。
*/
//PC1选位表(子密钥生成置换表1) 把密钥中的奇偶校验为去掉（不包含8,16,24,32,40,48,56,64），变成56位；
const static char 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
};
//PC2选位表(子密钥生成置换表2) 生成子密钥 48位
const static char 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
};
//左移位数表
const static char LOOP_Table[16] = {
1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};
/*
* 加密：DES算法是对固定大小(64位)的数据块进行加密解密操作的；
* 明文串M经过长度都为48位的16个子密钥K来加密，最后生成长度为64比特的密文E；经过长度都为48位的16个子密钥K来加密，最后生成长度为64比特的密文E；
* 1. 进行IP初始置换，将该明文串M(64bit)被分为32位的左半部分L0和32位的右半部分R0两部分；
* 2. 将数据的右半部分R0通过扩展置换E从32位扩展为48位；
* 3. 扩展后的48位与K1进行异或；
* 4. 异或后的结果通过S盒子转换为32位；
* 5. 输出结果再通过一个P盒置换产生一个32位的输出；
* 6. 最后，P盒置换的结果与左半部分进行异或运算，然后将左右两部分交换，之后进入下一轮迭代。
* 7. 在完成完全相同的16轮运算后，将得到的两部分数据L16和R16合在一起，即L16R16；(L16:指进行了16轮处理得到的32位左半部分数据)
* 8. 将L16与R16的位置交换,得到R16L16，再经过一个末置换函数IP-1，即可得到64位的密文。
*
*/
//置换IP表
const static char 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
};
//逆置换IP-1表
const static char IPR_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
};
//E位选择表(扩展置换表)
static const char 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
};
//P换位表(单纯换位表)
const static char 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
};
// S盒
const static char 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
};
static bool SubKey[16][48];// 16圈子密钥
void printBufFormat(char *s,char * buf, int cnt, int num){
int i;
if (s != 0){
printf("%s\r\n", s);
}
for (i = 0; i < cnt; i++){
printf("%d", (unsigned char)buf[i]);
if ((i + 1) % num == 0){
printf("\r\n");
}
}
printf("\r\n");
}
void Des_Run(char Out[8], char In[8], bool Type)
{
static bool M[64], Tmp[32], *Li = &M[0], *Ri = &M[32];
ByteToBit(M, In, 64);// 字节组转换成位组
Transform(M, M, IP_Table, 64);// 变换
if( Type == ENCRYPT ){
for(int i=0; i<16; i++) {
memcpy(Tmp, Ri, 32);
F_func(Ri, SubKey[i]);
Xor(Ri, Li, 32);// 异或
memcpy(Li, Tmp, 32);
}
}else{
for(int i=15; i>=0; i--) {
memcpy(Tmp, Ri, 32);
F_func(Ri, SubKey[i]);
Xor(Ri, Li, 32);// 异或
memcpy(Li, Tmp, 32);
}
}
memcpy(Tmp, Li, 32);
memcpy(Li, Ri, 32);
memcpy(Ri, Tmp, 32);
Transform(M, M, IPR_Table, 64);// 变换
BitToByte(Out, M, 64);
}
void Des_SetKey(const char Key[8])
{
static bool K[64], *KL = &K[0], *KR = &K[28];
ByteToBit(K, Key, 64);// 字节组转换成位组
Transform(K, K, PC1_Table, 56);// 变换
for(int i=0; i<16; i++)
{
RotateL(KL, 28, LOOP_Table[i]);// 循环左移
RotateL(KR, 28, LOOP_Table[i]);// 循环左移
Transform(SubKey[i], K, PC2_Table, 48);// 变换
}
}
void F_func(bool In[32], const bool Ki[48])// f 函数
{
static bool MR[48];
//printBufFormat("In:", (char*)In, 32, 8);
//printBufFormat("Ki:", (char*)Ki, 48, 8);
Transform(MR, In, E_Table, 48);// 变换
//printBufFormat("MR A:", (char*)MR, 48, 6);
Xor(MR, Ki, 48);// 异或
//printBufFormat("MR B:", (char*)MR, 48, 6);
S_func(In, MR);// S 盒代替
//printBufFormat("In A:", (char*)In, 32, 8);
Transform(In, In, P_Table, 32);// 变换
//printBufFormat("In B:", (char*)In, 32, 8);
//getchar();
}
void S_func(bool Out[32], const bool In[48])// S 盒代替,输入6位的数，输出4位的数，将第一六位对应的十进制数作为行，第二三四五为的对应十进制数作为列
{
for(char i=0,j,k; i<8; i++,In+=6,Out+=4) // 输出数据存放位置out下标不断增进
{
j = (In[0]<<1) + In[5];
k = (In[1]<<3) + (In[2]<<2) + (In[3]<<1) + In[4];
//printf("i=%d,j=%d,k= %d,%d\r\n", i, j, k, S_Box[i][j][k]);
ByteToBitDD_Print(Out, &S_Box[i][j][k], 4); // out每次都会前进4个位置（bool）
//printBufFormat("Out:", (char*)Out, 32, 8);
//getchar();
}
}
void Transform(bool *Out, bool *In, const char *Table, int len)//变换
{
static bool Tmp[256];
for(int i = 0; i < len; i++)
{
Tmp[i] = In[ Table[i] - 1 ];
//printf("%d", Tmp[i]);
//if ((i + 1) % 7 == 0){
// printf("\r\n");
//}
}
//printf("\r\n");
memcpy(Out, Tmp, len);
}
void Xor(bool *InA, const bool *InB, int len)//异或
{
for(int i = 0; i < len; i++)
{
InA[i] ^= InB[i];
}
}
void RotateL(bool *In, int len, int loop)//循环左移
{
static bool Tmp[256];
memcpy(Tmp, In, loop);
memcpy(In, In+loop, len-loop);
memcpy(In+len-loop, Tmp, loop);
}
void ByteToBit(bool *Out, const char *In, int bits)//字节组转换成位组
{
for(int i = 0; i < bits; i++)
{
Out[i] = (In[i/8] >> (i%8)) & 1;
}
}
void ByteToBit_Print(bool *Out, const char *In, int bits)//字节组转换成位组
{
for (int i = 0; i < bits; i++)
{
Out[i] = (In[i / 8] >> (i % 8)) & 1;
printf("%d", Out[i]);
if ((i + 1) % 8 == 0){
printf("\r\n");
}
}
printf("\r\n");
}
void ByteToBitDD_Print(bool *Out, const char *In, int bits)//字节组转换成位组
{
for (int i = 0; i < bits; i++)
{
Out[bits-i-1] = (In[i / 8] >> (i % 8)) & 1;
//printf("%d", Out[i]);
//if ((i + 1) % 8 == 0){
// printf("\r\n");
//}
}
//printf("\r\n");
}
void BitToByte(char *Out, const bool *In, int bits)
{
memset(Out, 0, (bits+7)/8);
for(int i = 0; i < bits; i++)
{
Out[i/8] |= In[i] << (i%8);
}
}
void printBuf(char *strlog,char *buf, int num)
{
int i;
if (strlog != 0){
printf("%s\r\n", strlog);
}
for (i = 0; i < num; i++)
{
printf("%.2x ",(unsigned char ) buf[i]);
}
printf("\r\n");
}
int main()
{
//char key[8] = { 1, 9, 8, 0, 9, 1, 7, 2 };
char key[8] = { 0xC8 ,0x2C ,0xEA ,0x9E ,0xD9 ,0x3D ,0xFB ,0x8F };
char PlainText[8] = { 0x80, 0xC4, 0xA2, 0xE6, 0x91, 0xD5, 0xB3, 0xF7 };
char EncryptMsg[8] = { 0x00 };
char DecryptMsg[8] = { 0x00 };
puts("Before encrypting");
printBuf("PlainText:", PlainText, 8);
Des_SetKey(key);
Des_Run(EncryptMsg, PlainText, ENCRYPT);
printBuf("After Encrypting", EncryptMsg, 8);
Des_Run(DecryptMsg, EncryptMsg, DECRYPT);
printBuf("After Decrypting", DecryptMsg, 8);
return 0;
}将源码 放到 vs2013中的建立的空的控制台工程，\VC\work\Des_TestA\
运行结果：
Before encrypting
PlainText:
80 c4 a2 e6 91 d5 b3 f7
After Encrypting
a1 17 c8 2a f0 50 2d a0
After Decrypting
80 c4 a2 e6 91 d5 b3 f7
请按任意键继续. . .该程序是在网上搜来程序的基础上修改的
9.另外一种 代码 实现方式
对应以上的解析流程，另外一种C源码，解析方式，
可以参考如下链接:
https://blog.csdn.net/wowocpp/article/details/80179651
这个链接的算法，实现了：
void Test_Des_B(void)
{
unsigned char key[8] = { 0x13,0x34,0x57,0x79,0x9B,0xBC,0xDF,0xF1};
unsigned char data[8] = { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF };
unsigned char EncryptData[8] = { 0 };
des_debug((uint8_t *)&data, (uint8_t *)key, 0, (uint8_t *)EncryptData);
printf("\r\nDes:\r\n");
printBuf("key:", key, 8, 32);
printBuf("plain:", data, 8, 32);
printBuf("EncryptData:", EncryptData, 8, 32);
}输出：
Des:
key: 13 34 57 79 9b bc df f1
plain: 01 23 45 67 89 ab cd ef
EncryptData: 85 e8 13 54 0f 0a b4 0510 . 对第8节的C语言，修改一下：
得到如下源码：（保留第8节的目的是 对比一下 修改的地方，加深对算法的理解）
// DES算法利用一个56+8奇偶校验位(第8,16,24,32,40,48,56,64位)=64位的密钥对以64位为单位的块数据进行加解密
#include "memory.h"
#include "stdio.h"
#include "conio.h"
enum {ENCRYPT,DECRYPT};// ENCRYPT:加密,DECRYPT:解密
void Des_Run(char Out[8], char In[8], bool Type=ENCRYPT);
void Des_SetKey(const char Key[8]);// 设置密钥
static void F_func(bool In[32], const bool Ki[48]);// f 函数
static void S_func(bool Out[32], const bool In[48]);// S 盒代替
static void Transform(bool *Out, bool *In, const char *Table, int len);// 变换
static void Xor(bool *InA, const bool *InB, int len);// 异或
static void RotateL(bool *In, int len, int loop);// 循环左移
static void ByteToBit(bool *Out, const char *In, int bits);// 字节组转换成位组
static void BitToByte(char *Out, const bool *In, int bits);// 位组转换成字节组
/*
* 子密钥生成：
* 1. 密钥先被转化成64比特的二进制；
* 2. 再按照密钥置换函数PC-1(8x7)进行压缩置换，变成56位；
* 3. 将其置换的输出再分为前28位C0和后28位D0两部分；
* 4. 进行16轮数据处理，每一轮中，先将C0和D0 分别 进行循环左移，
* 再将两部分左移结果 一起执行压缩置换PC-2(8X6)，最后生成16个48位的子密钥。
*/
//PC1选位表(子密钥生成置换表1) 把密钥中的奇偶校验为去掉（不包含8,16,24,32,40,48,56,64），变成56位；
const static char 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
};
//PC2选位表(子密钥生成置换表2) 生成子密钥 48位
const static char 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
};
//左移位数表
const static char LOOP_Table[16] = {
1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
};
/*
* 加密：DES算法是对固定大小(64位)的数据块进行加密解密操作的；
* 明文串M经过长度都为48位的16个子密钥K来加密，最后生成长度为64比特的密文E；经过长度都为48位的16个子密钥K来加密，最后生成长度为64比特的密文E；
* 1. 进行IP初始置换，将该明文串M(64bit)被分为32位的左半部分L0和32位的右半部分R0两部分；
* 2. 将数据的右半部分R0通过扩展置换E从32位扩展为48位；
* 3. 扩展后的48位与K1进行异或；
* 4. 异或后的结果通过S盒子转换为32位；
* 5. 输出结果再通过一个P盒置换产生一个32位的输出；
* 6. 最后，P盒置换的结果与左半部分进行异或运算，然后将左右两部分交换，之后进入下一轮迭代。
* 7. 在完成完全相同的16轮运算后，将得到的两部分数据L16和R16合在一起，即L16R16；(L16:指进行了16轮处理得到的32位左半部分数据)
* 8. 将L16与R16的位置交换,得到R16L16，再经过一个末置换函数IP-1，即可得到64位的密文。
*
*/
//置换IP表
const static char 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
};
//逆置换IP-1表
const static char IPR_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
};
//E位选择表(扩展置换表)
static const char 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
};
//P换位表(单纯换位表)
const static char 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
};
// S盒
const static char 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
};
static bool SubKey[16][48];// 16圈子密钥
void printBufFormat(char *s,char * buf, int cnt, int num){
int i;
if (s != 0){
printf("%s\r\n", s);
}
for (i = 0; i < cnt; i++){
printf("%d", (unsigned char)buf[i]);
if ((i + 1) % num == 0){
printf("\r\n");
}
}
printf("\r\n");
}
void Des_Run(char Out[8], char In[8], bool Type)
{
static bool M[64], Tmp[32], *Li = &M[0], *Ri = &M[32];
ByteToBit(M, In, 64);// 字节组转换成位组
Transform(M, M, IP_Table, 64);// 变换
if( Type == ENCRYPT ){
for(int i=0; i<16; i++) {
memcpy(Tmp, Ri, 32);
F_func(Ri, SubKey[i]);
Xor(Ri, Li, 32);// 异或
memcpy(Li, Tmp, 32);
}
}else{
for(int i=15; i>=0; i--) {
memcpy(Tmp, Ri, 32);
F_func(Ri, SubKey[i]);
Xor(Ri, Li, 32);// 异或
memcpy(Li, Tmp, 32);
}
}
memcpy(Tmp, Li, 32);
memcpy(Li, Ri, 32);
memcpy(Ri, Tmp, 32);
Transform(M, M, IPR_Table, 64);// 变换
BitToByte(Out, M, 64);
}
void Des_SetKey(const char Key[8])
{
static bool K[64], *KL = &K[0], *KR = &K[28];
ByteToBit(K, Key, 64);// 字节组转换成位组
Transform(K, K, PC1_Table, 56);// 变换
for(int i=0; i<16; i++)
{
RotateL(KL, 28, LOOP_Table[i]);// 循环左移
RotateL(KR, 28, LOOP_Table[i]);// 循环左移
Transform(SubKey[i], K, PC2_Table, 48);// 变换
}
}
void F_func(bool In[32], const bool Ki[48])// f 函数
{
static bool MR[48];
//printBufFormat("In:", (char*)In, 32, 8);
//printBufFormat("Ki:", (char*)Ki, 48, 8);
Transform(MR, In, E_Table, 48);// 变换
//printBufFormat("MR A:", (char*)MR, 48, 6);
Xor(MR, Ki, 48);// 异或
//printBufFormat("MR B:", (char*)MR, 48, 6);
S_func(In, MR);// S 盒代替
//printBufFormat("In A:", (char*)In, 32, 8);
Transform(In, In, P_Table, 32);// 变换
//printBufFormat("In B:", (char*)In, 32, 8);
//getchar();
}
void S_func(bool Out[32], const bool In[48])// S 盒代替,输入6位的数，输出4位的数，将第一六位对应的十进制数作为行，第二三四五为的对应十进制数作为列
{
for(char i=0,j,k; i<8; i++,In+=6,Out+=4) // 输出数据存放位置out下标不断增进
{
j = (In[0]<<1) + In[5];
k = (In[1]<<3) + (In[2]<<2) + (In[3]<<1) + In[4];
for (int l = 0; l<4; ++l) //把相应4bit赋值
Out[l] = (S_Box[i][j][k] >> (3 - l)) & 1;
}
}
void Transform(bool *Out, bool *In, const char *Table, int len)//变换
{
static bool Tmp[256];
for(int i = 0; i < len; i++)
{
Tmp[i] = In[ Table[i] - 1 ];
}
memcpy(Out, Tmp, len);
}
void Xor(bool *InA, const bool *InB, int len)//异或
{
for(int i = 0; i < len; i++)
{
InA[i] ^= InB[i];
}
}
void RotateL(bool *In, int len, int loop)//循环左移
{
static bool Tmp[256];
memcpy(Tmp, In, loop);
memcpy(In, In+loop, len-loop);
memcpy(In+len-loop, Tmp, loop);
}
void ByteToBit(bool *Out, const char *In, int bits)
{
for (int i = 0; i> 3] >> (7 - i & 7)) & 1;
}
void BitToByte( char *Out, const bool *In, int bits)
{
memset(Out, 0, (bits + 7) / 8);
for (int i = 0; i> 3] |= In[i] << (7 - i & 7);
}
void printBuf(char *strlog,char *buf, int num)
{
int i;
if (strlog != 0){
printf("%s\r\n", strlog);
}
for (i = 0; i < num; i++)
{
printf("%.2x ",(unsigned char ) buf[i]);
}
printf("\r\n");
}
int main()
{
char key[8] = { 0x13,0x34 ,0x57 ,0x79 ,0x9b ,0xbc ,0xdf ,0xf1 };
char PlainText[8] = { 0x01 ,0x23 ,0x45 ,0x67 ,0x89 ,0xab ,0xcd ,0xef };
char EncryptMsg[8] = { 0x00 };
char DecryptMsg[8] = { 0x00 };
puts("Before encrypting");
printBuf("PlainText:", PlainText, 8);
Des_SetKey(key);
Des_Run(EncryptMsg, PlainText, ENCRYPT);
printBuf("After Encrypting", EncryptMsg, 8);
Des_Run(DecryptMsg, EncryptMsg, DECRYPT);
printBuf("After Decrypting", DecryptMsg, 8);
return 0;
} 运行结果：
Before encrypting
PlainText:
01 23 45 67 89 ab cd ef
After Encrypting
85 e8 13 54 0f 0a b4 05
After Decrypting
01 23 45 67 89 ab cd ef
请按任意键继续. . .
欢迎交流