主题: (转载)MD5 加密算法简介(源码见“经 
发信人: plindge()
整理人: (2000-05-23 14:11:38), 站内信件  
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ 
\\ 欢迎光临品琳居 - http://plindge.yeah.net\ 
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ 
一、算法实现(转载自绿色兵团) 
1、MD5算法是对输入的数据进行补位,使得如果数据位长度LEN对512求余的结果
是448。 
   即数据扩展至K*512+448位。即K*64+56个字节,K为整数。 
   具体补位操作:补一个1,然后补0至满足上述要求  
2、补数据长度: 
   用一个64位的数字表示数据的原始长度B,把B用两个32位数表示。这时,数据
就被填 
   补成长度为512位的倍数。 
3. 初始化MD5参数  
   四个32位整数 (A,B,C,D) 用来计算信息摘要,初始化使用的是十六进制表示
的数字 
      A=0X01234567 
      B=0X89abcdef 
      C=0Xfedcba98 
      D=0X76543210  
4、处理位操作函数  
      X,Y,Z为32位整数。 
      F(X,Y,Z) = X&Y|NOT(X)&Z 
      G(X,Y,Z) = X&Z|Y&not(Z) 
      H(X,Y,Z) = X xor Y xor Z 
      I(X,Y,Z) = Y xor (X|not(Z))  
5、主要变换过程: 
   使用常数组T[1 ... 64], T[i]为32位整数用16进制表示,数据用16个32位的
整 
   数数组M[]表示。 
   具体过程如下:  
/* 处理数据原文 */ 
For i = 0 to N/16-1 do  
/*每一次,把数据原文存放在16个元素的数组X中. */ 
For j = 0 to 15 do 
Set X[j] to M[i*16+j]. 
end  /结束对J的循环 
/* Save A as AA, B as BB, C as CC, and D as DD. */ 
AA = A 
BB = B 
CC = C 
DD = D  
/* 第1轮*/ 
/* 以 [abcd k s i]表示如下操作 
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ 
/* Do the following 16 operations. */ 
[ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4] 
[ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8] 
[ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12] 
[ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16] 
/* 第2轮* */ 
/* 以 [abcd k s i]表示如下操作 
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ 
/* Do the following 16 operations. */ 
[ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20] 
[ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24] 
[ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28] 
[ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32] 
/* 第3轮*/ 
/* 以 [abcd k s i]表示如下操作 
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ 
/* Do the following 16 operations. */ 
[ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36] 
[ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40] 
[ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44] 
[ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48] 
/* 第4轮*/ 
/* 以 [abcd k s i]表示如下操作 
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ 
/* Do the following 16 operations. */ 
[ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52] 
[ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56] 
[ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60] 
[ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64] 
/* 然后进行如下操作 */ 
A = A + AA 
B = B + BB 
C = C + CC 
D = D + DD 
end /* 结束对I的循环*/ 
6、输出结果。 二、源码 
见前文《经典加密算法在VB中的实现(2)- MD5》  
 
主题:经典加密算法在VB中的实现(2)- MD5 
发信人: plindge()
整理人: fishy(2000-05-23 14:11:15), 站内信件  
'************************************************ 
'*    欢迎光临品琳居 http://plindge.yeah.net     * 
'************************************************ 
' 经典加密算法在VB中的实现(2)- MD5 Option Explicit Dim w1 As String, w2 As String, w3 As String, w4 As String Function MD5F(ByVal tempstr As String, ByVal w As String, ByVal X As S
tring, ByVal y As String, ByVal z As String, ByVal Xin As String, ByVa
l qdata As String, ByVal rots As Integer) 
    MD5F = BigMod32Add(RotLeft(BigMod32Add(BigMod32Add(w, tempstr), Bi
gMod32Add(Xin, qdata)), rots), X) 
End Function Sub MD5F1(w As String, ByVal X As String, ByVal y As String, ByVal z A
s String, ByVal Xin As String, ByVal qdata As String, ByVal rots As In
teger) 
Dim tempstr As String     tempstr = BigXOR(z, BigAND(X, BigXOR(y, z))) 
    w = MD5F(tempstr, w, X, y, z, Xin, qdata, rots) 
End Sub Sub MD5F2(w As String, ByVal X As String, ByVal y As String, ByVal z A
s String, ByVal Xin As String, ByVal qdata As String, ByVal rots As In
teger) 
Dim tempstr As String     tempstr = BigXOR(y, BigAND(z, BigXOR(X, y))) 
    w = MD5F(tempstr, w, X, y, z, Xin, qdata, rots) 
End Sub Sub MD5F3(w As String, ByVal X As String, ByVal y As String, ByVal z A
s String, ByVal Xin As String, ByVal qdata As String, ByVal rots As In
teger) 
Dim tempstr As String     tempstr = BigXOR(X, BigXOR(y, z)) 
    w = MD5F(tempstr, w, X, y, z, Xin, qdata, rots) 
End Sub Sub MD5F4(w As String, ByVal X As String, ByVal y As String, ByVal z A
s String, ByVal Xin As String, ByVal qdata As String, ByVal rots As In
teger) 
Dim tempstr As String     tempstr = BigXOR(y, BigOR(X, BigNOT(z))) 
    w = MD5F(tempstr, w, X, y, z, Xin, qdata, rots) 
End Sub Function MD5_Calc(ByVal hashthis As String) As String 
ReDim buf(0 To 3) As String 
ReDim Xin(0 To 15) As String 
Dim tempnum As Integer, tempnum2 As Integer, loopit As Integer, loopou
ter As Integer, loopinner As Integer 
Dim a As String, b As String, c As String, d As String     ' Add padding     tempnum = 8 * Len(hashthis) 
    hashthis = hashthis + Chr$(128) 'Add binary 10000000 
    tempnum2 = 56 - Len(hashthis) Mod 64     If tempnum2 < 0 Then 
tempnum2 = 64 + tempnum2 
End If hashthis = hashthis + String$(tempnum2, Chr$(0)) For loopit = 1 To 8 
hashthis = hashthis + Chr$(tempnum Mod 256) 
tempnum = tempnum - tempnum Mod 256 
tempnum = tempnum / 256 
Next loopit ' Set magic numbers 
buf(0) = "67452301" 
buf(1) = "efcdab89" 
buf(2) = "98badcfe" 
buf(3) = "10325476" ' For each 512 bit section 
For loopouter = 0 To Len(hashthis) / 64 - 1 
a = buf(0) 
b = buf(1) 
c = buf(2) 
d = buf(3) ' Get the 512 bits 
For loopit = 0 To 15 
Xin(loopit) = "" 
For loopinner = 1 To 4 
Xin(loopit) = Hex$(Asc(Mid$(hashthis, 64 * loopouter +
4 * loopit + loopinner, 1))) + Xin(loopit) 
If Len(Xin(loopit)) Mod 2 Then Xin(loopit) = "0" + Xin
(loopit) 
Next loopinner 
Next loopit ' Round 1 
MD5F1 a, b, c, d, Xin(0), "d76aa478", 7 
MD5F1 d, a, b, c, Xin(1), "e8c7b756", 12 
MD5F1 c, d, a, b, Xin(2), "242070db", 17 
MD5F1 b, c, d, a, Xin(3), "c1bdceee", 22 
MD5F1 a, b, c, d, Xin(4), "f57c0faf", 7 
MD5F1 d, a, b, c, Xin(5), "4787c62a", 12 
MD5F1 c, d, a, b, Xin(6), "a8304613", 17 
MD5F1 b, c, d, a, Xin(7), "fd469501", 22 
MD5F1 a, b, c, d, Xin(8), "698098d8", 7 
MD5F1 d, a, b, c, Xin(9), "8b44f7af", 12 
MD5F1 c, d, a, b, Xin(10), "ffff5bb1", 17 
MD5F1 b, c, d, a, Xin(11), "895cd7be", 22 
MD5F1 a, b, c, d, Xin(12), "6b901122", 7 
MD5F1 d, a, b, c, Xin(13), "fd987193", 12 
MD5F1 c, d, a, b, Xin(14), "a679438e", 17 
MD5F1 b, c, d, a, Xin(15), "49b40821", 22 ' Round 2 
MD5F2 a, b, c, d, Xin(1), "f61e2562", 5 
MD5F2 d, a, b, c, Xin(6), "c040b340", 9 
MD5F2 c, d, a, b, Xin(11), "265e5a51", 14 
MD5F2 b, c, d, a, Xin(0), "e9b6c7aa", 20 
MD5F2 a, b, c, d, Xin(5), "d62f105d", 5 
MD5F2 d, a, b, c, Xin(10), "02441453", 9 
MD5F2 c, d, a, b, Xin(15), "d8a1e681", 14 
MD5F2 b, c, d, a, Xin(4), "e7d3fbc8", 20 
MD5F2 a, b, c, d, Xin(9), "21e1cde6", 5 
MD5F2 d, a, b, c, Xin(14), "c33707d6", 9 
MD5F2 c, d, a, b, Xin(3), "f4d50d87", 14 
MD5F2 b, c, d, a, Xin(8), "455a14ed", 20 
MD5F2 a, b, c, d, Xin(13), "a9e3e905", 5 
MD5F2 d, a, b, c, Xin(2), "fcefa3f8", 9 
MD5F2 c, d, a, b, Xin(7), "676f02d9", 14 
MD5F2 b, c, d, a, Xin(12), "8d2a4c8a", 20 ' Round 3 
MD5F3 a, b, c, d, Xin(5), "fffa3942", 4 
MD5F3 d, a, b, c, Xin(8), "8771f681", 11 
MD5F3 c, d, a, b, Xin(11), "6d9d6122", 16 
MD5F3 b, c, d, a, Xin(14), "fde5380c", 23 
MD5F3 a, b, c, d, Xin(1), "a4beea44", 4 
MD5F3 d, a, b, c, Xin(4), "4bdecfa9", 11 
MD5F3 c, d, a, b, Xin(7), "f6bb4b60", 16 
MD5F3 b, c, d, a, Xin(10), "bebfbc70", 23 
MD5F3 a, b, c, d, Xin(13), "289b7ec6", 4 
MD5F3 d, a, b, c, Xin(0), "e27fa", 11 
MD5F3 c, d, a, b, Xin(3), "d4ef3085", 16 
MD5F3 b, c, d, a, Xin(6), "04881d05", 23 
MD5F3 a, b, c, d, Xin(9), "d9d4d039", 4 
MD5F3 d, a, b, c, Xin(12), "e6db99e5", 11 
MD5F3 c, d, a, b, Xin(15), "1fa27cf8", 16 
MD5F3 b, c, d, a, Xin(2), "c4ac5665", 23 ' Round 4 
MD5F4 a, b, c, d, Xin(0), "f4292244", 6 
MD5F4 d, a, b, c, Xin(7), "432aff97", 10 
MD5F4 c, d, a, b, Xin(14), "ab9423a7", 15 
MD5F4 b, c, d, a, Xin(5), "fc93a039", 21 
MD5F4 a, b, c, d, Xin(12), "655b59c3", 6 
MD5F4 d, a, b, c, Xin(3), "8f0ccc92", 10 
MD5F4 c, d, a, b, Xin(10), "ffeff47d", 15 
MD5F4 b, c, d, a, Xin(1), "85845dd1", 21 
MD5F4 a, b, c, d, Xin(8), "6fa87e4f", 6 
MD5F4 d, a, b, c, Xin(15), "fe2ce6e0", 10 
MD5F4 c, d, a, b, Xin(6), "a3014314", 15 
MD5F4 b, c, d, a, Xin(13), "4e0811a1", 21 
MD5F4 a, b, c, d, Xin(4), "f7537e82", 6 
MD5F4 d, a, b, c, Xin(11), "bd3af235", 10 
MD5F4 c, d, a, b, Xin(2), "2ad7d2bb", 15 
MD5F4 b, c, d, a, Xin(9), "eb86d391", 21 buf(0) = BigAdd(buf(0), a) 
buf(1) = BigAdd(buf(1), b) 
buf(2) = BigAdd(buf(2), c) 
buf(3) = BigAdd(buf(3), d) 
Next loopouter ' Extract MD5Hash 
hashthis = "" 
For loopit = 0 To 3 
For loopinner = 3 To 0 Step -1 
hashthis = hashthis + Chr(Val("&H" + Mid$(buf(loopit), 1 +
2 * loopinner, 2))) 
Next loopinner 
Next loopit ' And return it 
MD5_Calc = hashthis 
End Function Function BigMod32Add(ByVal value1 As String, ByVal value2 As String) A
s String 
BigMod32Add = Right$(BigAdd(value1, value2), 8) 
End Function Public Function BigAdd(ByVal value1 As String, ByVal value2 As String)
As String 
Dim valueans As String 
Dim loopit As Integer, tempnum As Integer tempnum = Len(value1) - Len(value2) 
If tempnum < 0 Then 
value1 = Space$(Abs(tempnum)) + value1 
ElseIf tempnum > 0 Then 
        value2 = Space$(Abs(tempnum)) + value2 
    End If     tempnum = 0 
    For loopit = Len(value1) To 1 Step -1 
        tempnum = tempnum + Val("&H" + Mid$(value1, loopit, 1)) + Val(
"&H" + Mid$(value2, loopit, 1)) 
        valueans = Hex$(tempnum Mod 16) + valueans 
        tempnum = Int(tempnum / 16) 
    Next loopit     If tempnum <> 0 Then 
        valueans = Hex$(tempnum) + valueans 
    End If     BigAdd = Right(valueans, 8) 
End Function Public Function RotLeft(ByVal value1 As String, ByVal rots As Integer)
 As String 
Dim tempstr As String 
Dim loopit As Integer, loopinner As Integer 
Dim tempnum As Integer     rots = rots Mod 32 
     
    If rots = 0 Then 
        RotLeft = value1 
        Exit Function 
    End If     value1 = Right$(value1, 8) 
    tempstr = String$(8 - Len(value1), "0") + value1 
    value1 = ""     ' Convert to binary 
    For loopit = 1 To 8 
        tempnum = Val("&H" + Mid$(tempstr, loopit, 1)) 
        For loopinner = 3 To 0 Step -1 
            If tempnum And 2 ^ loopinner Then 
                value1 = value1 + "1" 
            Else 
                value1 = value1 + "0" 
            End If 
        Next loopinner 
    Next loopit 
    tempstr = Mid$(value1, rots + 1) + Left$(value1, rots)     ' And convert back to hex 
    value1 = "" 
    For loopit = 0 To 7 
        tempnum = 0 
        For loopinner = 0 To 3 
            If Val(Mid$(tempstr, 4 * loopit + loopinner + 1, 1)) Then                 tempnum = tempnum + 2 ^ (3 - loopinner) 
            End If 
        Next loopinner 
        value1 = value1 + Hex$(tempnum) 
    Next loopit     RotLeft = Right(value1, 8) 
End Function Function BigAND(ByVal value1 As String, ByVal value2 As String) As Str
ing 
Dim valueans As String 
Dim loopit As Integer, tempnum As Integer     tempnum = Len(value1) - Len(value2) 
    If tempnum < 0 Then 
value2 = Mid$(value2, Abs(tempnum) + 1) 
ElseIf tempnum > 0 Then 
        value1 = Mid$(value1, tempnum + 1) 
    End If     For loopit = 1 To Len(value1) 
        valueans = valueans + Hex$(Val("&H" + Mid$(value1, loopit, 1))
 And Val("&H" + Mid$(value2, loopit, 1))) 
    Next loopit     BigAND = valueans 
End Function Function BigNOT(ByVal value1 As String) As String 
Dim valueans As String 
Dim loopit As Integer     value1 = Right$(value1, 8) 
    value1 = String$(8 - Len(value1), "0") + value1 
    For loopit = 1 To 8 
        valueans = valueans + Hex$(15 Xor Val("&H" + Mid$(value1, loop
it, 1))) 
    Next loopit     BigNOT = valueans 
End Function Function BigOR(ByVal value1 As String, ByVal value2 As String) As Stri
ng 
Dim valueans As String 
Dim loopit As Integer, tempnum As Integer     tempnum = Len(value1) - Len(value2) 
    If tempnum < 0 Then 
valueans = Left$(value2, Abs(tempnum)) 
value2 = Mid$(value2, Abs(tempnum) + 1) 
ElseIf tempnum > 0 Then 
        valueans = Left$(value1, Abs(tempnum)) 
        value1 = Mid$(value1, tempnum + 1) 
    End If     For loopit = 1 To Len(value1) 
        valueans = valueans + Hex$(Val("&H" + Mid$(value1, loopit, 1))
 Or Val("&H" + Mid$(value2, loopit, 1))) 
    Next loopit     BigOR = valueans 
End Function Function BigXOR(ByVal value1 As String, ByVal value2 As String) As Str
ing 
Dim valueans As String 
Dim loopit As Integer, tempnum As Integer     tempnum = Len(value1) - Len(value2) 
    If tempnum < 0 Then 
valueans = Left$(value2, Abs(tempnum)) 
value2 = Mid$(value2, Abs(tempnum) + 1) 
ElseIf tempnum > 0 Then 
        valueans = Left$(value1, Abs(tempnum)) 
        value1 = Mid$(value1, tempnum + 1) 
    End If     For loopit = 1 To Len(value1) 
        valueans = valueans + Hex$(Val("&H" + Mid$(value1, loopit, 1))
 Xor Val("&H" + Mid$(value2, loopit, 1))) 
    Next loopit     BigXOR = Right(valueans, 8) 
End Function 
' To Be Continue...
 
 

解决方案 »

  1.   

    主题:经典加密算法在VB中的实现(3)- RC4 
    发信人: plindge()
    整理人: fishy(2000-05-23 14:12:06), 站内信件  
    '************************************************  
    '*    欢迎光临品琳居 http://plindge.yeah.net     *  
    '************************************************  
    ' 经典加密算法在VB中的实现(3)- RC4  
    Public Sub main() 
    Dim key As String 
    For i = 1 To 16 
        Randomize 
        key = key & Chr(Rnd * 255) 
    Next i 
    MsgBox RC4(RC4("Welcome To Plindge Studio!", key), key) 
    End Sub 
    Public Function RC4(inp As String, key As String) As String 
    Dim S(0 To 255) As Byte, K(0 To 255) As Byte, i As Long 
    Dim j As Long, temp As Byte, Y As Byte, t As Long, x As Long 
    Dim Outp As String For i = 0 To 255 
        S(i) = i 
    Next j = 1 
    For i = 0 To 255 
        If j > Len(key) Then j = 1 
        K(i) = Asc(Mid(key, j, 1)) 
        j = j + 1 
    Next i j = 0 
    For i = 0 To 255 
        j = (j + S(i) + K(i)) Mod 256 
        temp = S(i) 
        S(i) = S(j) 
        S(j) = temp 
    Next i i = 0 
    j = 0 
    For x = 1 To Len(inp) 
        i = (i + 1) Mod 256 
        j = (j + S(i)) Mod 256 
        temp = S(i) 
        S(i) = S(j) 
        S(j) = temp 
        t = (S(i) + (S(j) Mod 256)) Mod 256 
        Y = S(t) 
         
        Outp = Outp & Chr(Asc(Mid(inp, x, 1)) Xor Y) 
    Next 
    RC4 = Outp 
    End Function 'To Be Continue 
     
     
      

  2.   

    主题:经典加密算法在VB中的实现(4)- DES 
    发信人: plindge()
    整理人: fishy(2000-05-23 14:13:24), 站内信件  
    一、算法实现(转自绿色兵团) 
    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    2414    17    11    24     1     5     3    28    15     6    21    10  
      23    19    12     4    26     8    16     7    27    20    13     225    26    27    28    29    30    31    32    33    34    35    36  
      37    38    39    40    41    42    43    44    45    46    47    4841    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]。 
     
      

  3.   

    多谢zeng_zhh(紫河) ,那么什么叫密钥呢,密匙又是什么呢?
      

  4.   

    提供一個SQL Server自己的加密方法。(具體怎樣加我不知道) :(Select pwdencrypt('Nipsan') as Password
    Password                                                                        ------------------ 
    0x0100301C3D1B8CC09B0F944B3DFF0676E635C21EC81216C3C45DDA9A06C02823A9DE92B03A007BF765A90C7D9EEC(1 row(s) affected)密碼比較:Select pwdCompare('Nipsan',pwdencrypt('Nipsan'))
    傳回結果為1表示相同,不為1表示不同。
      

  5.   

    谢谢zeng_zhh(紫河),我还是先把分给了吧,虽然我并没有怎么看懂……
      

  6.   

    哦,又多了一条,
    N_chow(一劍飄香++) ,有oracle中的吗?