ASP网站制作之若何完成 DES 算法

由于ASP提供的是一对多的服务，所以用户的一些特殊需求很难得到满足。算法   
How to implement the
Data Encryption Standard (DES)
A step by step tutorial
Version 1.2

The Data Encryption Standard (DES) algorithm, adopted by the U.S.
government in 1977, is a block cipher that transforms 64-bit data blocks
under a 56-bit secret key, by means of permutation and substitution. It
is officially described in FIPS PUB 46. The DES algorithm is used for
many applications within the government and in the private sector.
This is a tutorial designed to be clear and compact, and to provide a
newcomer to the DES with all the necessary information to implement it
himself, without having to track down printed works or wade through C
source code. I welcome any comments.
Matthew Fischer <mfischer@heinous.isca.uiowa.edu>
；下面是引见，我就不翻了。 ;)

Here's how to do it, step by step:
1 Process the key.
；生成密钥
1.1 Get a 64-bit key from the user. (Every 8th bit is considered a
parity bit. For a key to have correct parity, each byte should contain
an odd number of "1" bits.)
；从用户处失掉一个64位的密钥。（每8位一组，每组的第8位是校验位。假如校验
准确，每一个字节应当有一个为1的
1.2 Calculate the key schedule.
；盘算密钥表
1.2.1 Perform the following permutation on the 64-bit key. (The parity
bits are discarded, reducing the key to 56 bits. Bit 1 of the permuted
block is bit 57 of the original key, bit 2 is bit 49, and so on with bit
56 being bit 4 of the original key.)
；对64位的密钥停止以下的置换。（去失落校验位，密钥的实践长度是56位。置换后的
；第一名是原密钥的第57位，第二位是原第49位，第五十六位就是本来密钥的第4位。）
# 乖僻的置换，哪位年老能写出算式？
# 好象是分红两部
# for(j=57;j<64;j++)
# {
# for(i=j;i<0;i-=8)
# {
# if(k=28)
# break;
# c[k]=i;
# k++;
# }
# 这是前28位，不晓得对不合错误？请斧正。

Permuted Choice 1 (PC-1)
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
1.2.2 Split the permuted key into two halves. The first 28 bits are
called C[0] and the last 28 bits are called D[0].
；把置换后的密钥分为C[0] 和D[0]两局部，各28位。
1.2.3 Calculate the 16 subkeys. Start with i = 1.
；盘算16个子密钥，从i=1入手下手。
1.2.3.1 Perform one or two circular left shifts on both C[i-1] and
D[i-1] to get C[i] and D[i], respectively. The number of shifts per
iteration are given in the table below.
；分离对C[i-1]和D[i-1]停止左移一到两位的位移操作，失掉C[i]和D[i]。每次
；位移数量以下：
# 共16次
Iteration # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Left Shifts 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1
1.2.3.2 Permute the concatenation C[i]D[i] as indicated below. This
will yield K[i], which is 48 bits long.
；以下表，改动C[i]和D[i]的分列，失掉48位长的k[i]。
# 不懂 :(
# 是否是丢失落了某些位？
Permuted Choice 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
1.2.3.3 Loop back to 1.2.3.1 until K[16] has been calculated.
；反复 1.2.3.1 入手下手的进程，算出16个字密钥。
2 Process a 64-bit data block.
；处置一个64位的数据块。
2.1 Get a 64-bit data block. If the block is shorter than 64 bits, it
should be padded as appropriate for the application.
；获得一个64位的数据块。假如数据块不到64位，就补足64位。
# 多是用0补吧。
2.2 Perform the following permutation on the data block.
；对数据块停止以下置换。
# 又是分红两局部停止，先是偶数位。
# 对照复杂，算式就不写了。
Initial Permutation (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
2.3 Split the block into two halves. The first 32 bits are called L[0],
and the last 32 bits are called R[0].
；将数据块等分为L[0]和R[0]两局部。
2.4 Apply the 16 subkeys to the data block. Start with i = 1.
；从i=1入手下手，用16个子密钥对数据块停止加密。
2.4.1 Expand the 32-bit R[i-1] into 48 bits according to the
bit-selection function below.
；将数据块的后32位R[i-1]以上面划定规矩停止扩大。
# 不会写算式。:(
Expansion (E)
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
2.4.2 Exclusive-or E(R[i-1]) with K[i].
；用K[i]对E(R[i-1])停止异或操作。
2.4.3 Break E(R[i-1]) xor K[i] into eight 6-bit blocks. Bits 1-6 are
B[1], bits 7-12 are B[2], and so on with bits 43-48 being B[8].
；将上一步的操作了局分红8块，每块6位，定名为B[1]到B[8]。

2.4.4 Substitute the values found in the S-boxes for all B[j]. Start
with j = 1. All values in the S-boxes should be considered 4 bits wide.
；把一切的B[j]在S框中停止置换，S框中一切的值的宽（长）度应是4位。
# 不懂！！！ :(
2.4.4.1 Take the 1st and 6th bits of B[j] together as a 2-bit value
(call it m) indicating the row in S[j] to look in for the substitution.
；把B[j]中的第一名和第六位定名为m，暗示S[j]在置换时的行。
2.4.4.2 Take the 2nd through 5th bits of B[j] together as a 4-bit
value (call it n) indicating the column in S[j] to find the substitution.
；把B[j]二到五位定名为n，暗示S[j]在置换时的列。
2.4.4.3 WordStr B[j] with S[j][m][n].
；用S[j][m][n]置换B[j]。
Substitution Box 1 (S[1])
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
S[2]
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
S[3]
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
S[4]
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
S[5]
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
S[6]
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
S[7]
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
S[8]
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
2.4.4.4 Loop back to 2.4.4.1 until all 8 blocks have been replaced.
；反复2.4.4.1入手下手的步调，直至8个数据块都被置换。
2.4.5 Permute the concatenation of B[1] through B[8] as indicated below.
；以上面的办法改动B[1]到B[8]的按次 。
Permutation 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
2.4.6 Exclusive-or the resulting value with L[i-1]. Thus, all together,
your R[i] = L[i-1] xor P(S[1](B[1])...S[8](B[8])), where B[j] is a 6-bit
block of E(R[i-1]) xor K[i]. (The function for R[i] is written as, R[i] =
L[i-1] xor f(R[i-1], K[i]).)
；用L[i-1]对上一步的了局停止异或操作。如斯就有以下了局：R[i] = L[i-1] xor ；
P(S[1](B[1])...S[8](B[8]))。这里，B[j]是六位的数据块，它是E(R[i-1]) xor
；K[i]的了局。（R[i]的函数可以写成R[i] = L[i-1] xor f(R[i-1], K[i])。）
2.4.7 L[i] = R[i-1].
；L[i] = R[i-1].
2.4.8 Loop back to 2.4.1 until K[16] has been applied.
；反复2.4.1入手下手的步调，直至一切的子密钥都被利用过。
# 就是再反复15次，每次利用分歧的子密钥。
2.5 Perform the following permutation on the block R[16]L[16].
；对R[16]L[16]停止以下的置换。
Final Permutation (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

This has been a description of how to use the DES algorithm to encrypt
one 64-bit block. To decrypt, use the same process, but just use the keys
K[i] in reverse order. That is, instead of applying K[1] for the first
iteration, apply K[16], and then K[15] for the second, on down to K[1].
；以上就是如何用DES算法对一个64位的数据块停止加密的进程。至于解密，只需求
；在以上过程当中把子密钥的按次倒过去用就能够了。也就是说，在加密时用子密钥
；K[1]，在解密过程当中就用K[16]；在加密时用子密钥K[2]，在解密过程当中就用K[12]。

Summaries:
；摘要
# 以下是生成子密钥，加密息争密的公式化叙说。
Key schedule:
C[0]D[0] = PC1(key)
for 1 <= i <= 16
C[i] = LS[i](C[i-1])
D[i] = LS[i](D[i-1])
K[i] = PC2(C[i]D[i])
Encipherment:
L[0]R[0] = IP(plain block)
for 1 <= i <= 16
L[i] = R[i-1]
R[i] = L[i-1] xor f(R[i-1], K[i])
cipher block = FP(R[16]L[16])
Decipherment:
R[16]L[16] = IP(cipher block)
for 1 <= i <= 16
R[i-1] = L[i]
L[i-1] = R[i] xor f(L[i], K[i])
plain block = FP(L[0]R[0])

To encrypt or decrypt more than 64 bits there are four official modes
(defined in FIPS PUB 81). One is to go through the above-described
process for each block in succession. This is called Electronic Codebook
(ECB) mode. A stronger method is to exclusive-or each plaintext block
with the preceding ciphertext block prior to encryption. (The first
block is exclusive-or'ed with a secret 64-bit initialization vector
(IV).) This is called Cipher Block Chaining (CBC) mode. The other two
modes are Output Feedback (OFB) and Cipher Feedback (CFB).
；对超越64位的加密息争密，(美国)联邦信息处置尺度 PUB 81 中定有四种办法。
；一种是一连的对每一个数据块停止上述操作。这类办法被称 ECB mode。另外一种更
；高强度的办法是在加密前，用前述的密文块对明文块停止异或操作。
# 括号里那句话不懂 :(
；这类办法被称为 CBC mode。还有两种办法是 OFB mode 和 CFB mode。

When it comes to padding the data block, there are several options. One
is to simply append zeros. Two suggested by FIPS PUB 81 are, if the data
is binary data, fill up the block with bits that are the opposite of the
last bit of data, or, if the data is ASCII data, fill up the block with
random bytes and put the ASCII character for the number of pad bytes in
the last byte of the block. Another technique is to pad the block with
random bytes and in the last 3 bits store the original number of data bytes.
；在填凑数据块时（还记不记得，当数据块缺乏64位时要停止填充），有以下几种
；选择：一种就是填0。第二种是被(美国)联邦信息处置尺度 PUB 81所建议的，如
；果数据是二进制的，就填入和数据位最初一名相反的数；假如数据块是ASCII码，
；就填入随机字节，而且将填凑数目写入最初一个字节。另外一种手艺就是填入随机
；字节，而且将最初原数据字节数写入最初的三位。（注重：是位，bit）

  国内有些大的CRM厂商的ASP就写得不错.无论是概念还是它里面用JAVASCRIPT的能力.并不是说现在的程序员用了ASP.NET来写程序就可以说自己高档了

如何学好ASP,以前也有人问过,把回答给你转过来看看能否对你有帮助:

哪些内置对象是可以跳过的，或者哪些属性和方法是用不到的?

哪些内置对象是可以跳过的，或者哪些属性和方法是用不到的?

运用经典的例子。并且自己可以用他来实现一些简单的系统。如果可以对他进行进一步的修改，找出你觉得可以提高性能的地方，加上自己的设计，那就更上一个层次了，也就会真正地感到有所收获。

我认为比较好的方法是找一些比较经典的例子，每个例子比较集中一种编程思想而设计的。

另外因为asp需要使用组件，所以了解一点组件的知识(ADODB也是组件)

多看多学多思。多看一些关于ASP的书籍，一方面可以扩展知识面一方面可以鉴借别人是如何掌握、运用ASP的;多学善于关注别人，向同学老师多多学习，不论知识的大小;多思则是要将学到的知识灵活运用。

我认为比较好的方法是找一些比较经典的例子，每个例子比较集中一种编程思想而设计的。

掌握asp的特性而且一定要知道为什么。

用户端的浏览器不需要提供任何别的支持，这样大提高了用户与服务器之间的交互的速度。

完全不知道到底自己学的是什么。最后，除了教程里面说的几个例子，还是什么都不会。

学习ASP其实应该上升到如何学习程序设计这种境界，其实学习程序设计又是接受一种编程思想。比如ASP如何学习，你也许在以前的学习中碰到过。以下我仔细给你说几点:

下面简单介绍一下我学习ASP的方法,希望对想学习ASP的朋友有所帮助...

我可以结合自己的经验大致给你说一说，希望对你有所帮助，少走些弯路。

还有如何才能在最短的时间内学完?我每天可以有效学习2小时，双休日4小时。

完全不知道到底自己学的是什么。最后，除了教程里面说的几个例子，还是什么都不会。

它可通过内置的组件实现更强大的功能，如使用A-DO可以轻松地访问数据库。

以HTML语言整合(HTML负责界面上，ASP则负责功能上)形成一个B/S(浏览器/服务器)模式的网页程序。

接下来就不能纸上谈兵了，最好的方法其实是实践。实践，只能算是让你掌握语言特性用的。而提倡做实际的Project也不是太好，因为你还没有熟练的能力去综合各种技术，这样只能使你自己越来越迷糊。