1.处置密钥:
1.1从用户处获得64位密钥.
1.2具体过程:
1.2.1对密钥推行变换,使得变换未来的密钥的每个位与原密钥位对应关系如下表所示:
表一为忽视校验位将来状况

12 3 4 5 6 7 8 910111213141516171819202122232425262728
574941332517 9 158504234261810 259514335271911 360524436
29303132333435363738394041424344454647484950515253545556
63554739312315 762544638302214 661534537292113 5282012 4

1.2.2把变换后的密钥等分成两部分,前28位记为C[0], 后28位记为D[0].
1.2.3计算子密钥， 从i=1开始。
1.2.3.1 分别对C[i-1],D[i-1]作循环左移来生成C[i],D[i].。每次循环左移位数
如下表所示：

循环次数12345678910111213141516
左移位数112222221 2 2 2 2 2 2 1

1.2.3.2 串联C[i],D[i]，得到一个56位数，然后对此数作如下变换以产生48位子密钥K[i]。
变换过程如下：

12 3 4 5 6 7 8 9101112131415161718192021222324
14171124 1 5 32815 62110231912 426 816 7272013 2
252627282930313233343536373839404142434445464748
415231374755304051453348444939563453464250362932

1.2.3.3按以上办法计算出16个子密钥。


2．对64位数据块的处置：
2．1 把数据分成64位的数据块，不够64位的以适合的方法填补。
2．2对数据块作变换。

bitgoes to bitbitgoes to bit
581 57 33
502 49 34
423 41 35
344 33 36
265 25 37
186 17 38
1079 39
2 81 40
609 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
4163 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
6245 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
8327 64

2．3 将变换后的数据块等分成前后两部分，前32位记为L[0],后32位记为R[0]。
2．4 用16个子密钥对数据加密。
2．4．1 依据下面的扩冲函数E，扩展32位的成48位

bitgoes to bitbitgoes to bitbitgoes to bitbitgoes to bit
3218 13 16 25 24 37
1 29 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
710 15 22 23 34 31 46
811 16 23 24 35 32 47
912 17 24 25 361 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-48位为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

Binaryd1d6 =>00011011
/ d2..d5 /Dec 0 1 2 3
0000 0 14 0 415
0001 1415 112
0010 2 13 714 8
0011 31 4 8 2
0100 421413 4
0101 5 15 2 6 9
0110 6 1113 2 1
0111 78 111 7
1000 831015 5
1001 9 10 61211
101010612 9 3
101111 1211 714
1100125 9 310
1101139 510 0
1110140 3 5 6
1111157 8 013

--------
S-BOXES2

binaryd1d6 =>00011011
/ d2..d5 /dec 0 1 2 3
0000 0 15 3 013
0001 111314 8
0010 28 4 710
0011 3 14 711 1
0100 461510 3
0101 5 11 2 415
0110 63 813 4
0111 7414 1 2
1000 8912 511
1001 97 0 8 6
1010102 112 7
101111 1310 612
110012 12 6 9 0
1101130 9 3 5
111014511 214
111115 10 515 9

--------
S-BOXES3

binaryd1d6 =>00011011
/ d2..d5 /dec 0 1 2 3
0000 0 101313 1
0001 10 7 610
0010 29 0 413
0011 3 14 9 9 0
0100 46 3 8 6
0101 53 415 9
0110 6 15 6 3 8
0111 7510 0 7
1000 81 211 4
1001 9 13 8 115
101010 12 5 214
10111171412 3
110012 1112 511
11011341110 5
11101421514 2
1111158 1 712

--------
S-BOXES4

binaryd1d6 =>00011011
/ d2..d5 /dec 0 1 2 3
0000 071310 3
0001 1 13 8 615
0010 2 1411 9 0
0011 33 5 0 6
0100 40 61210
0101 561511 1
0110 69 0 713
0111 7 10 313 8
1000 81 415 9
1001 92 7 1 4
1010108 2 3 5
1011115121411
110012 11 1 512
110113 1210 2 7
111014414 8 2
111115 15 9 414

--------
S-BOXES5

binaryd1d6 =>00011011
/ d2..d5 /dec 0 1 2 3
0000 0214 411
0001 1 1211 2 8
0010 24 2 112
0011 311211 7
0100 47 410 1
0101 5 10 71314
0110 6 1113 7 2
0111 76 1 813
1000 88 515 6
1001 95 0 915
10101031512 0
101111 1510 5 9
110012 13 3 610
1101130 9 3 4
111014 14 8 0 5
1111159 614 3

--------
S-BOXES6

binaryd1d6 =>00011011
/ d2..d5 /dec 0 1 2 3
0000 0 1210 9 4
0001 111514 3
0010 2 10 415 2
0011 3 15 2 512
0100 49 7 2 9
0101 5212 8 5
0110 66 91215
0111 78 5 310
1000 80 6 711
1001 9 13 1 014
101010313 4 1
10111141410 7
110012 14 0 1 6
11011371113 0
1110145 311 8
111115 11 8 613

--------
S-BOXES7

binaryd1d6 =>00011011
/ d2..d5 /dec01 2 3
0000 0413 1 6
0001 1 11 0 411
0010 22111113
0011 3 14 713 8
0100 4 15 412 1
0101 50 9 3 4
0110 68 1 710
0111 7 131014 7
1000 831410 9
1001 9 12 315 5
1010109 5 6 0
101111712 815
1100125 2 014
110113 1015 5 2
1110146 8 9 3
1111151 6 212

--------
S-BOXES8

binaryd1d6 =>00011011
/ d2..d5 /dec 0 1 2 3
0000 0 13 1 7 2
0001 121511 1
0010 2813 414
0011 34 8 1 7
0100 4610 9 4
0101 5 15 31210
0110 6 11 714 8
0111 71 4 213
1000 8 1012 015
1001 99 5 612
1010103 610 9
101111 141113 0
1100125 015 3
110113014 3 5
111014 12 9 5 6
1111157 2 811

2．4．4．4 返回2．4．4．1直至8个数据块都被替换。
2．4．5 把B[1]至B[8] 顺序串联起来得到一个32位数。对这个数做如下变换：

bitgoes to bitbitgoes to bit
16 1 2 17
72 8 18
20 324 19
21 414 20
29 532 21
12 627 22
28 7 3 23
17 8 9 24
1919 25
151013 26
231130 27
2612 6 28
5 1322 29
181411 30
3115 4 31
101625 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位数据块。解密时用同样的过程，仅需把16个子密钥的
顺续颠倒过来，应用的顺序为K[16]，K[15]，K[14]，。。。。K[1]。