荔园在线

荔园之美,在春之萌芽,在夏之绽放,在秋之收获,在冬之沉淀

[回到开始] [上一篇][下一篇]


发信人: Second (石开), 信区: Program
标  题: [转载]经典加密算法在VB中的实现(4)- DES
发信站: 荔园晨风BBS站 (Tue Jul 17 02:23:17 2001), 转信

一、算法实现(转自绿色兵团)
1.    处理密钥:
1.1  从用户处获得64位密钥.(每第8位为校验位,为使密钥有正确的奇偶校验,每
个密钥要有奇
     数个”1”位.(本文如未特指,均指二进制位)
1.2    具体过程:
1.2.1    对密钥实施变换,使得变换以后的密钥的各个位与原密钥位对应关系如
下表所示:
         表一为忽略校验位以后情况
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
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
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
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
1.2.2  把变换后的密钥等分成两部分,前28位记为C[0], 后28位记为D[0].
1.2.3  计算子密钥(共16个), 从i=1开始。
1.2.3.1 分别对C[i-1],D[i-1]作循环左移来生成C[i],D[i].(共16次)。每次循环
左移位数
        如下表所示:
循环次数    1    2    3    4    5    6    7    8    9    10    11    1
2    13    14    15    16
左移位数    1    1    2    2    2    2    2    2    1     2     2
2     2     2     2     1
1.2.3.2 串联C[i],D[i],得到一个56位数,然后对此数作如下变换以产生48位子
密钥K[i]。
        变换过程如下:
1      2     3     4     5     6     7     8     9    10    11    12
  13    14    15    16    17    18    19    20    21    22    23    24
14    17    11    24     1     5     3    28    15     6    21    10
  23    19    12     4    26     8    16     7    27    20    13     2
25    26    27    28    29    30    31    32    33    34    35    36
  37    38    39    40    41    42    43    44    45    46    47    48
41    52    31    37    47    55    30    40    51    45    33    48
  44    49    39    56    34    53    46    42    50    36    29    32
1.2.3.3    按以上方法计算出16个子密钥。
2.对64位数据块的处理:
2.1 把数据分成64位的数据块,不够64位的以适当的方式填补。
2.2对数据块作变换。
bit    goes to bit    bit    goes to bit
58      1             57     33
50      2             49     34
42      3             41     35
34      4             33     36
26      5             25     37
18      6             17     38
10      7              9     39
2       8              1     40
60      9             59     41
52     10             51     42
44     11             43     43
36     12             35     44
28     13             27     45
20     14             19     46
12     15             11     47
4      16              3     48
62     17             61     49
54     18             53     50
46     19             45     51
38     20             37     52
30     21             29     53
22     22             21     54
14     23             13     55
6      24              5     56
64     25             63     57
56     26             55     58
48     27             47     59
40     28             39     60
32     29             31     61
24     30             23     62
16     31             15     63
8      32              7     64
2.3 将变换后的数据块等分成前后两部分,前32位记为L[0],后32位记为R[0]。
2.4 用16个子密钥对数据加密。
2.4.1 根据下面的扩冲函数E,扩展32位的成48位
bit    goes to bit    bit    goes to bit    bit    goes to bit    bit
   goes to bit
32      1              8     13             16     25             24
   37
1       2              9     14             17     26             25
   38
2       3             10     15             18     27             26
   39
3       4             11     16             19     28             27
   40
4       5             12     17             20     29             28
   41
5       6             13     18             21     30             29
   42
4       7             12     19             20     31             28
   43
5       8             13     20             21     32             29
   44
6       9             14     21             22     33             30
   45
7      10             15     22             23     34             31
   46
8      11             16     23             24     35             32
   47
9      12             17     24             25     36              1
   48
2.4.2 用E{R[i-1]}与K[i]作异或运算。
2.4.3 把所得的48位数分成8个6位数。1-6位为B[1],7-12位为B[2],……43-4
8位为B[8]。
2.4.4 用S密箱里的值替换B[j]。从j=1开始。S密箱里的值为4位数,共8个S密

2.4.4.1 取出B[j]的第1和第6位串联起来成一个2位数,记为m.。m即是S密箱
里用来替换
           B[j]的数所在的列数。
2.4.4.2 取出B[j]的第2至第5位串联起来成一个4位数,记为n。n即是S密箱里
用来替换
           B[j]的数所在的行数。
2.4.4.3 用S密箱里的值S[j][ m][ n]替换B[j]。8个S密箱如下所示:
--------
S-BOXES1
Binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    Dec   0     1     2     3
0000       0         14     0     4    15
0001       1          4    15     1    12
0010       2         13     7    14     8
0011       3          1     4     8     2
0100       4          2    14    13     4
0101       5         15     2     6     9
0110       6         11    13     2     1
0111       7          8     1    11     7
1000       8          3    10    15     5
1001       9         10     6    12    11
1010      10          6    12     9     3
1011      11         12    11     7    14
1100      12          5     9     3    10
1101      13          9     5    10     0
1110      14          0     3     5     6
1111      15          7     8     0    13
--------
S-BOXES2
binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    dec   0     1     2     3
0000       0         15     3     0    13
0001       1          1    13    14     8
0010       2          8     4     7    10
0011       3         14     7    11     1
0100       4          6    15    10     3
0101       5         11     2     4    15
0110       6          3     8    13     4
0111       7          4    14     1     2
1000       8          9    12     5    11
1001       9          7     0     8     6
1010      10          2     1    12     7
1011      11         13    10     6    12
1100      12         12     6     9     0
1101      13          0     9     3     5
1110      14          5    11     2    14
1111      15         10     5    15     9
--------
S-BOXES3
binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    dec   0     1     2     3
0000       0         10    13    13     1
0001       1          0     7     6    10
0010       2          9     0     4    13
0011       3         14     9     9     0
0100       4          6     3     8     6
0101       5          3     4    15     9
0110       6         15     6     3     8
0111       7          5    10     0     7
1000       8          1     2    11     4
1001       9         13     8     1    15
1010      10         12     5     2    14
1011      11          7    14    12     3
1100      12         11    12     5    11
1101      13          4    11    10     5
1110      14          2    15    14     2
1111      15          8     1     7    12
--------
S-BOXES4
binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    dec   0     1     2     3
0000       0          7    13    10     3
0001       1         13     8     6    15
0010       2         14    11     9     0
0011       3          3     5     0     6
0100       4          0     6    12    10
0101       5          6    15    11     1
0110       6          9     0     7    13
0111       7         10     3    13     8
1000       8          1     4    15     9
1001       9          2     7     1     4
1010      10          8     2     3     5
1011      11          5    12    14    11
1100      12         11     1     5    12
1101      13         12    10     2     7
1110      14          4    14     8     2
1111      15         15     9     4    14
--------
S-BOXES5
binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    dec   0     1     2     3
0000       0          2    14     4    11
0001       1         12    11     2     8
0010       2          4     2     1    12
0011       3          1    12    11     7
0100       4          7     4    10     1
0101       5         10     7    13    14
0110       6         11    13     7     2
0111       7          6     1     8    13
1000       8          8     5    15     6
1001       9          5     0     9    15
1010      10          3    15    12     0
1011      11         15    10     5     9
1100      12         13     3     6    10
1101      13          0     9     3     4
1110      14         14     8     0     5
1111      15          9     6    14     3
--------
S-BOXES6
binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    dec   0     1     2     3
0000       0         12    10     9     4
0001       1          1    15    14     3
0010       2         10     4    15     2
0011       3         15     2     5    12
0100       4          9     7     2     9
0101       5          2    12     8     5
0110       6          6     9    12    15
0111       7          8     5     3    10
1000       8          0     6     7    11
1001       9         13     1     0    14
1010      10          3    13     4     1
1011      11          4    14    10     7
1100      12         14     0     1     6
1101      13          7    11    13     0
1110      14          5     3    11     8
1111      15         11     8     6    13
--------
S-BOXES7
binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    dec    0    1     2     3
0000       0          4    13     1     6
0001       1         11     0     4    11
0010       2          2    11    11    13
0011       3         14     7    13     8
0100       4         15     4    12     1
0101       5          0     9     3     4
0110       6          8     1     7    10
0111       7         13    10    14     7
1000       8          3    14    10     9
1001       9         12     3    15     5
1010      10          9     5     6     0
1011      11          7    12     8    15
1100      12          5     2     0    14
1101      13         10    15     5     2
1110      14          6     8     9     3
1111      15          1     6     2    12
--------
S-BOXES8
binary    d1d6 =>    00    01    10    11
\/ d2..d5 \/    dec   0     1     2     3
0000       0         13     1     7     2
0001       1          2    15    11     1
0010       2          8    13     4    14
0011       3          4     8     1     7
0100       4          6    10     9     4
0101       5         15     3    12    10
0110       6         11     7    14     8
0111       7          1     4     2    13
1000       8         10    12     0    15
1001       9          9     5     6    12
1010      10          3     6    10     9
1011      11         14    11    13     0
1100      12          5     0    15     3
1101      13          0    14     3     5
1110      14         12     9     5     6
1111      15          7     2     8    11
2.4.4.4 返回2.4.4.1直至8个数据块都被替换。
2.4.5 把B[1]至B[8] 顺序串联起来得到一个32位数。对这个数做如下变换:
bit    goes to bit    bit    goes to bit
16     1               2     17
7      2               8     18
20     3              24     19
21     4              14     20
29     5              32     21
12     6              27     22
28     7               3     23
17     8               9     24
1      9              19     25
15    10              13     26
23    11              30     27
26    12               6     28
5     13              22     29
18    14              11     30
31    15               4     31
10    16              25     32
2.4.6 把得到的结果与L[i-1]作异或运算。把计算结果賦给R[i]。
2.4.7 把R[i-1]的值賦给L[i]。
2.4.8 从2.4.1循环执行,直到K[16]也被用到。
2.5 把R[16]和L[16] 顺序串联起来得到一个64位数。对这个数实施2.2变换的
逆变换。
    以上就是DES算法如何加密一段64位数据块。解密时用同样的过程,只需把1
6个子密钥的
顺续颠倒过来,应用的顺序为K[16],K[15],K[14],。。。。K[1]。

--
                            既然热爱生命
                            那么,
                            一切都在意料之中。

※ 来源:·荔园晨风BBS站 bbs.szu.edu.cn·[FROM: 192.168.28.190]


[回到开始] [上一篇][下一篇]

荔园在线首页 友情链接:深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店