流星网络电视V1.9.2.0的注册(续:DES篇)

rdsnow · 发表于 2005-9-10 21:25:26

上次跟踪了流星网络电视的注册过程，再贴上DES的跟踪笔记，跟大家共同学习一下，这是个标准的Delphi的DES源码：

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※

加密和解密是同一个CALL，即下面的CALL unpacked.00476B38，通过调用参数决定是加密还是解密：

00476DD0  |> /8B55 F8       /MOV EDX,DWORD PTR SS:[EBP-8]    ;  取64位的密钥
00476DD3  |. |8A141A       |MOV DL,BYTE PTR DS:[EDX+EBX]
00476DD6  |. |8810          |MOV BYTE PTR DS:[EAX],DL          ;  转存密钥
00476DD8  |. |43             |INC EBX
00476DD9  |. |40             |INC EAX
00476DDA  |. |83FB 08       |CMP EBX,8
00476DDD  |.^\75 F1          \JNZ SHORT unpacked.00476DD0       ;  分8轮取完，取完跳出循环
00476DDF  |.  6A 0F          PUSH 0F                            ; /Arg1 = 0000000F
00476DE1  |.  B9 0C8C5C00    MOV ECX,unpacked.005C8C0C          ; |
00476DE6  |.  8D45 DC       LEA EAX,DWORD PTR SS:[EBP-24]    ; |
00476DE9  |.  BA 07000000    MOV EDX,7                         ; |
00476DEE  |.  E8 EDFAFFFF    CALL unpacked.004768E0             ; \生成16个子密钥KO、K1、……K15

………………(省略64位信息分组的代码)
00476E3C  |.  50             |PUSH EAX                         ; /Arg2
00476E3D  |.  6A 07          |PUSH 7                            ; |Arg1 = 00000007
00476E3F  |.  8D55 EC       |LEA EDX,DWORD PTR SS:[EBP-14]    ; |
00476E42  |.  B9 07000000    |MOV ECX,7                         ; |
00476E47  |.  33C0          |XOR EAX,EAX                      ; |AL＝0表示加密，AL＝1表示解密
00476E49  |.  E8 EAFCFFFF    |CALL unpacked.00476B38          ; \对分组得到的64位信息加密，跟进

信息分组，即将很长的待加密信息分成64位一组，有多少组，看信息长度决定，然后分别对每一组加密，最后把每一组加密后的结果连接起来，就得到了最后的结果。

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※

进入CALL unpacked.00476B38，看看DES的关键代码(输入64位，输出64位)：

00476B38  /$  55             PUSH EBP
00476B39  |.  8BEC          MOV EBP,ESP
00476B3B  |.  83C4 E8       ADD ESP,-18
00476B3E  |.  53             PUSH EBX
00476B3F  |.  56             PUSH ESI
00476B40  |.  57             PUSH EDI
00476B41  |.  8BD9          MOV EBX,ECX
00476B43  |.  85DB          TEST EBX,EBX
00476B45  |.  78 0A          JS SHORT unpacked.00476B51
00476B47  |.  C1EB 02       SHR EBX,2
00476B4A  |>  8B349A       /MOV ESI,DWORD PTR DS:[EDX+EBX*4]
00476B4D  |.  4B             |DEC EBX
00476B4E  |.  56             |PUSH ESI
00476B4F  |.^ 79 F9          \JNS SHORT unpacked.00476B4A
00476B51  |>  8BD4          MOV EDX,ESP
00476B53  |.  8955 FC       MOV DWORD PTR SS:[EBP-4],EDX
00476B56  |.  8BD8          MOV EBX,EAX
00476B58  |.  C745 F8 0800000>MOV DWORD PTR SS:[EBP-8],8
00476B5F  |.  8B45 FC       MOV EAX,DWORD PTR SS:[EBP-4]
00476B62  |.  8B4D 0C       MOV ECX,DWORD PTR SS:[EBP+C]
00476B65  |>  8A10          /MOV DL,BYTE PTR DS:[EAX]
00476B67  |.  8811          |MOV BYTE PTR DS:[ECX],DL
00476B69  |.  41             |INC ECX
00476B6A  |.  40             |INC EAX
00476B6B  |.  FF4D F8       |DEC DWORD PTR SS:[EBP-8]
00476B6E  |.^ 75 F5          \JNZ SHORT unpacked.00476B65
00476B70  |.  8B45 0C       MOV EAX,DWORD PTR SS:[EBP+C]
00476B73  |.  8B55 08       MOV EDX,DWORD PTR SS:[EBP+8]
00476B76  |.  E8 81F9FFFF    CALL unpacked.004764FC             ;  初始换位
00476B7B  |.  84DB          TEST BL,BL
00476B7D  |.  0F85 B5000000 JNZ unpacked.00476C38             ;  如不跳，下面是加密代码，如果跳，则跳向解密代码
00476B83  |.  C745 F8 1000000>MOV DWORD PTR SS:[EBP-8],10
00476B8A  |.  C745 EC 0C8C5C0>MOV DWORD PTR SS:[EBP-14],unpacked.>
00476B91  |>  B8 04000000    /MOV EAX,4
00476B96  |.  8B55 0C       |MOV EDX,DWORD PTR SS:[EBP+C]
00476B99  |.  8D75 F4       |LEA ESI,DWORD PTR SS:[EBP-C]    ;  下面开始对消息进行分组,把64位的消息分为L和R
00476B9C  |>  8A0A          |/MOV CL,BYTE PTR DS:[EDX]       ;  取L(i)
00476B9E  |.  880E          ||MOV BYTE PTR DS:[ESI],CL       ;  保存L(i)出去
00476BA0  |.  46             ||INC ESI
00476BA1  |.  42             ||INC EDX
00476BA2  |.  48             ||DEC EAX
00476BA3  |.^ 75 F7          |\JNZ SHORT unpacked.00476B9C    ;  取四个字节，即32位
00476BA5  |.  B8 04000000    |MOV EAX,4
00476BAA  |.  8B55 0C       |MOV EDX,DWORD PTR SS:[EBP+C]
00476BAD  |.  83C2 04       |ADD EDX,4
00476BB0  |>  8A0A          |/MOV CL,BYTE PTR DS:[EDX]       ;  取R(i)
00476BB2  |.  884A FC       ||MOV BYTE PTR DS:[EDX-4],CL       ;  保存R(i),L(i+1)=R(i),这个循环起到了交换位置的作用
00476BB5  |.  42             ||INC EDX
00476BB6  |.  48             ||DEC EAX
00476BB7  |.^ 75 F7          |\JNZ SHORT unpacked.00476BB0    ;  取4个字节，即32位
00476BB9  |.  6A 05          |PUSH 5                            ; /Arg3 = 00000005
00476BBB  |.  8D45 F0       |LEA EAX,DWORD PTR SS:[EBP-10]    ; |
00476BBE  |.  50             |PUSH EAX                         ; |Arg2
00476BBF  |.  6A 03          |PUSH 3                            ; |Arg1 = 00000003
00476BC1  |.  8B45 EC       |MOV EAX,DWORD PTR SS:[EBP-14]    ; |
00476BC4  |.  8BC8          |MOV ECX,EAX                      ; |
00476BC6  |.  8B45 0C       |MOV EAX,DWORD PTR SS:[EBP+C]    ; |
00476BC9  |.  8B55 08       |MOV EDX,DWORD PTR SS:[EBP+8]    ; |
00476BCC  |.  E8 3FFEFFFF    |CALL unpacked.00476A10          ; \F(Ri,Ki)
00476BD1  |.  B8 04000000    |MOV EAX,4
00476BD6  |.  8D55 F4       |LEA EDX,DWORD PTR SS:[EBP-C]
00476BD9  |.  8D75 F0       |LEA ESI,DWORD PTR SS:[EBP-10]
00476BDC  |.  8B4D 0C       |MOV ECX,DWORD PTR SS:[EBP+C]
00476BDF  |.  83C1 04       |ADD ECX,4
00476BE2  |>  8A1A          |/MOV BL,BYTE PTR DS:[EDX]       ;  取L(i)
00476BE4  |.  321E          ||XOR BL,BYTE PTR DS:[ESI]       ;  L(i) ^ F(Ri,Ki)
00476BE6  |.  8819          ||MOV BYTE PTR DS:[ECX],BL       ;  结果赋给R(i)，即R(i+1)=L(i) ^ F(Ri,Ki)
00476BE8  |.  41             ||INC ECX
00476BE9  |.  46             ||INC ESI
00476BEA  |.  42             ||INC EDX
00476BEB  |.  48             ||DEC EAX
00476BEC  |.^ 75 F4          |\JNZ SHORT unpacked.00476BE2    ;  循环四个字节，即32位
00476BEE  |.  8345 EC 06    |ADD DWORD PTR SS:[EBP-14],6
00476BF2  |.  FF4D F8       |DEC DWORD PTR SS:[EBP-8]
00476BF5  |.^ 75 9A          \JNZ SHORT unpacked.00476B91       ;  一共要经过16轮循环，由原先的L0、R0转变成了L16、R16
00476BF7  |.  B8 04000000    MOV EAX,4
00476BFC  |.  8B55 0C       MOV EDX,DWORD PTR SS:[EBP+C]
00476BFF  |.  83C2 04       ADD EDX,4
00476C02  |.  8D4D F4       LEA ECX,DWORD PTR SS:[EBP-C]
00476C05  |>  8A1A          /MOV BL,BYTE PTR DS:[EDX]          ;  取R16
00476C07  |.  8819          |MOV BYTE PTR DS:[ECX],BL          ;  转存R16
00476C09  |.  41             |INC ECX
00476C0A  |.  42             |INC EDX
00476C0B  |.  48             |DEC EAX
00476C0C  |.^ 75 F7          \JNZ SHORT unpacked.00476C05       ;  取四个字节，32位,这个循环把R16保存出去
00476C0E  |.  B8 04000000    MOV EAX,4
00476C13  |.  8B55 0C       MOV EDX,DWORD PTR SS:[EBP+C]
00476C16  |>  8A0A          /MOV CL,BYTE PTR DS:[EDX]          ;  取L16
00476C18  |.  884A 04       |MOV BYTE PTR DS:[EDX+4],CL       ;  R16=L16
00476C1B  |.  42             |INC EDX
00476C1C  |.  48             |DEC EAX
00476C1D  |.^ 75 F7          \JNZ SHORT unpacked.00476C16       ;  一共替换4字节32位，这个循环用L16覆盖R16
00476C1F  |.  B8 04000000    MOV EAX,4
00476C24  |.  8D55 F4       LEA EDX,DWORD PTR SS:[EBP-C]
00476C27  |.  8B4D 0C       MOV ECX,DWORD PTR SS:[EBP+C]
00476C2A  |>  8A1A          /MOV BL,BYTE PTR DS:[EDX]          ;  取保存出去的R16
00476C2C  |.  8819          |MOV BYTE PTR DS:[ECX],BL          ;  L16=R16,即用保存出去的R16覆盖L16
00476C2E  |.  41             |INC ECX
00476C2F  |.  42             |INC EDX
00476C30  |.  48             |DEC EAX
00476C31  |.^ 75 F7          \JNZ SHORT unpacked.00476C2A       ;  一共替换4字节32位,上面三个小循环等于由交换了一下L16和R16
00476C33  |.  E9 BB000000    JMP unpacked.00476CF3             ;  跳向逆初始换位
00476C38  |>  80FB 01       CMP BL,1
00476C3B  |.  0F85 B2000000 JNZ unpacked.00476CF3
00476C41  |.  C745 F8 F0FFFFF>MOV DWORD PTR SS:[EBP-8],-10
00476C48  |.  BB 668C5C00    MOV EBX,unpacked.005C8C66
00476C4D  |>  B8 04000000    /MOV EAX,4
00476C52  |.  8B55 0C       |MOV EDX,DWORD PTR SS:[EBP+C]
00476C55  |.  8D75 F4       |LEA ESI,DWORD PTR SS:[EBP-C]    ;  下面开始对消息进行分组,把64位的消息分为L0和R0
00476C58  |>  8A0A          |/MOV CL,BYTE PTR DS:[EDX]       ;  取L(i)
00476C5A  |.  880E          ||MOV BYTE PTR DS:[ESI],CL       ;  保存L(i)出去
00476C5C  |.  46             ||INC ESI
00476C5D  |.  42             ||INC EDX
00476C5E  |.  48             ||DEC EAX
00476C5F  |.^ 75 F7          |\JNZ SHORT unpacked.00476C58    ;  取四个字节，即32位
00476C61  |.  B8 04000000    |MOV EAX,4
00476C66  |.  8B55 0C       |MOV EDX,DWORD PTR SS:[EBP+C]
00476C69  |.  83C2 04       |ADD EDX,4
00476C6C  |>  8A0A          |/MOV CL,BYTE PTR DS:[EDX]       ;  取R(i)
00476C6E  |.  884A FC       ||MOV BYTE PTR DS:[EDX-4],CL       ;  保存R(i),L(i+1)=R(i),这个循环起到了交换位置的作用
00476C71  |.  42             ||INC EDX
00476C72  |.  48             ||DEC EAX
00476C73  |.^ 75 F7          |\JNZ SHORT unpacked.00476C6C    ;  取四个字节，即32位
00476C75  |.  6A 05          |PUSH 5                            ; /Arg3 = 00000005
00476C77  |.  8D45 F0       |LEA EAX,DWORD PTR SS:[EBP-10]    ; |
00476C7A  |.  50             |PUSH EAX                         ; |Arg2
00476C7B  |.  6A 03          |PUSH 3                            ; |Arg1 = 00000003
00476C7D  |.  8BCB          |MOV ECX,EBX                      ; |
00476C7F  |.  8B45 0C       |MOV EAX,DWORD PTR SS:[EBP+C]    ; |
00476C82  |.  8B55 08       |MOV EDX,DWORD PTR SS:[EBP+8]    ; |
00476C85  |.  E8 86FDFFFF    |CALL unpacked.00476A10          ; \F( Ri,K(15-i) )
00476C8A  |.  B8 04000000    |MOV EAX,4
00476C8F  |.  8D55 F4       |LEA EDX,DWORD PTR SS:[EBP-C]
00476C92  |.  8D75 F0       |LEA ESI,DWORD PTR SS:[EBP-10]
00476C95  |.  8B4D 0C       |MOV ECX,DWORD PTR SS:[EBP+C]
00476C98  |.  83C1 04       |ADD ECX,4
00476C9B  |.  894D E8       |MOV DWORD PTR SS:[EBP-18],ECX
00476C9E  |>  8A0A          |/MOV CL,BYTE PTR DS:[EDX]       ;  取经过了F( Ri,K(15-i) )的结果
00476CA0  |.  320E          ||XOR CL,BYTE PTR DS:[ESI]       ;  L(i) ^ F( Ri,K(15-i) )
00476CA2  |.  8B7D E8       ||MOV EDI,DWORD PTR SS:[EBP-18]    ;  结果赋给R(i)，即R(i+1)=L(i) ^ F(Ri,Ki)
00476CA5  |.  880F          ||MOV BYTE PTR DS:[EDI],CL
00476CA7  |.  FF45 E8       ||INC DWORD PTR SS:[EBP-18]
00476CAA  |.  46             ||INC ESI
00476CAB  |.  42             ||INC EDX
00476CAC  |.  48             ||DEC EAX
00476CAD  |.^ 75 EF          |\JNZ SHORT unpacked.00476C9E    ;  循环四个字节，即32位
00476CAF  |.  83EB 06       |SUB EBX,6
00476CB2  |.  FF45 F8       |INC DWORD PTR SS:[EBP-8]
00476CB5  |.^ 75 96          \JNZ SHORT unpacked.00476C4D       ;  一共要经过16轮循环，由原先的L0、R0转变成了L16、R16
00476CB7  |.  B8 04000000    MOV EAX,4
00476CBC  |.  8B55 0C       MOV EDX,DWORD PTR SS:[EBP+C]
00476CBF  |.  83C2 04       ADD EDX,4
00476CC2  |.  8D5D F4       LEA EBX,DWORD PTR SS:[EBP-C]
00476CC5  |>  8A0A          /MOV CL,BYTE PTR DS:[EDX]          ;  取R16
00476CC7  |.  880B          |MOV BYTE PTR DS:[EBX],CL          ;  转存R16
00476CC9  |.  43             |INC EBX
00476CCA  |.  42             |INC EDX
00476CCB  |.  48             |DEC EAX
00476CCC  |.^ 75 F7          \JNZ SHORT unpacked.00476CC5       ;  取四个字节，32位,这个循环把R16保存出去
00476CCE  |.  B8 04000000    MOV EAX,4
00476CD3  |.  8B5D 0C       MOV EBX,DWORD PTR SS:[EBP+C]
00476CD6  |>  8A13          /MOV DL,BYTE PTR DS:[EBX]          ;  取L16
00476CD8  |.  8853 04       |MOV BYTE PTR DS:[EBX+4],DL       ;  R16=L16
00476CDB  |.  43             |INC EBX
00476CDC  |.  48             |DEC EAX
00476CDD  |.^ 75 F7          \JNZ SHORT unpacked.00476CD6       ;  一共替换4字节32位，这个循环用L16覆盖R16
00476CDF  |.  B8 04000000    MOV EAX,4
00476CE4  |.  8D5D F4       LEA EBX,DWORD PTR SS:[EBP-C]
00476CE7  |.  8B55 0C       MOV EDX,DWORD PTR SS:[EBP+C]
00476CEA  |>  8A0B          /MOV CL,BYTE PTR DS:[EBX]          ;  取保存出去的R16
00476CEC  |.  880A          |MOV BYTE PTR DS:[EDX],CL          ;  L16=R16,即用保存出去的R16覆盖L16
00476CEE  |.  42             |INC EDX
00476CEF  |.  43             |INC EBX
00476CF0  |.  48             |DEC EAX
00476CF1  |.^ 75 F7          \JNZ SHORT unpacked.00476CEA       ;  一共替换4字节32位,上面三个小循环等于由交换了一下L16和R16
00476CF3  |>  8B45 0C       MOV EAX,DWORD PTR SS:[EBP+C]
00476CF6  |.  8B55 08       MOV EDX,DWORD PTR SS:[EBP+8]
00476CF9  |.  E8 82F8FFFF    CALL unpacked.00476580             ;  逆初始换位
00476CFE  |.  8B7D DC       MOV EDI,DWORD PTR SS:[EBP-24]
00476D01  |.  8B75 E0       MOV ESI,DWORD PTR SS:[EBP-20]
00476D04  |.  8B5D E4       MOV EBX,DWORD PTR SS:[EBP-1C]
00476D07  |.  8BE5          MOV ESP,EBP
00476D09  |.  5D             POP EBP
00476D0A  \.  C2 0800       RETN 8

小结：

可见加密代码和解密代码几乎一样，不同的是16个48位的子密钥使用的顺序不同。

我们主要看加密过程：

待加密64位信息--->『初始变换』-->『16轮循环处理』-->『逆初始变换』-->输出64位结果

『初始变换』表：输入64位，输出64位(数据处理的第一步)

58 50 42 34 26 18 10 02 60 52 44 36 28 20 12 04
62 54 46 38 30 22 14 06 64 56 48 40 32 24 16 08
57 49 41 33 25 17 09 01 59 51 43 35 27 19 11 03
61 53 45 37 29 21 13 05 63 55 47 39 31 23 15 07

『16轮循环处理』(数据处理的中间一步)：

64位信息分为32的L0和32位的R0

For(i=0;i<16;i++){
Temp=Ri;
R(i+1)=Li ^ F(Ri,Ki);
L(i+1)=Temp;
}

经过16轮得到L16,R16，再交换一下L16,R16输处64位信息

『逆初始变换』表：输入64位，输出64位(数据处理的最后一步)

40 08 48 16 56 24 64 32 39 07 47 15 55 23 63 31
38 06 46 14 54 22 62 30 37 05 45 13 53 21 61 29
36 04 44 12 52 20 60 28 35 03 43 11 51 19 59 27
34 02 42 10 50 18 58 26 33 01 41 09 49 17 57 25

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※

跟进F(Ri,Ki)函数，过程如下：

00476A10  /$  55          PUSH EBP
00476A11  |.  8BEC          MOV EBP,ESP
00476A13  |.  83C4 EC       ADD ESP,-14
00476A16  |.  53          PUSH EBX
00476A17  |.  56          PUSH ESI
00476A18  |.  8B5D 10       MOV EBX,DWORD PTR SS:[EBP+10]
00476A1B  |.  85DB          TEST EBX,EBX
00476A1D  |.  78 0A       JS SHORT unpacked.00476A29
00476A1F  |.  C1EB 02       SHR EBX,2
00476A22  |>  8B3499       /MOV ESI,DWORD PTR DS:[ECX+EBX*4>
00476A25  |.  4B          |DEC EBX
00476A26  |.  56          |PUSH ESI
00476A27  |.^ 79 F9       \JNS SHORT unpacked.00476A22
00476A29  |>  8BCC          MOV ECX,ESP
00476A2B  |.  8BDA          MOV EBX,EDX
00476A2D  |.  85DB          TEST EBX,EBX
00476A2F  |.  78 0A       JS SHORT unpacked.00476A3B
00476A31  |.  C1EB 02       SHR EBX,2
00476A34  |>  8B3498       /MOV ESI,DWORD PTR DS:[EAX+EBX*4>
00476A37  |.  4B          |DEC EBX
00476A38  |.  56          |PUSH ESI
00476A39  |.^ 79 F9       \JNS SHORT unpacked.00476A34
00476A3B  |>  8BC4          MOV EAX,ESP
00476A3D  |.  894D FC       MOV DWORD PTR SS:[EBP-4],ECX
00476A40  |.  6A 05       PUSH 5                         ; /Arg1 = 00000005
00476A42  |.  8D4D F6       LEA ECX,DWORD PTR SS:[EBP-A]    ; |
00476A45  |.  E8 BAFBFFFF CALL unpacked.00476604          ; \扩大换位将32位信息变为48位
00476A4A  |.  BB 06000000 MOV EBX,6
00476A4F  |.  8B45 FC       MOV EAX,DWORD PTR SS:[EBP-4]
00476A52  |.  8D55 F6       LEA EDX,DWORD PTR SS:[EBP-A]
00476A55  |>  8A08          /MOV CL,BYTE PTR DS:[EAX]
00476A57  |.  300A          |XOR BYTE PTR DS:[EDX],CL       ;  48位信息与48位密钥异或
00476A59  |.  42          |INC EDX
00476A5A  |.  40          |INC EAX
00476A5B  |.  4B          |DEC EBX
00476A5C  |.^ 75 F7       \JNZ SHORT unpacked.00476A55    ;  六轮循环完成异或
00476A5E  |.  8A45 F6       MOV AL,BYTE PTR SS:[EBP-A]    ;  下面开始将48位信息分成8个6位信息
00476A61  |.  33D2          XOR EDX,EDX
00476A63  |.  8AD0          MOV DL,AL
00476A65  |.  C1EA 02       SHR EDX,2                      ;  得到第一个6位数据
00476A68  |.  8855 EE       MOV BYTE PTR SS:[EBP-12],DL    ;  保存
00476A6B  |.  24 03       AND AL,3
00476A6D  |.  C1E0 04       SHL EAX,4
00476A70  |.  8A55 F7       MOV DL,BYTE PTR SS:[EBP-9]
00476A73  |.  33C9          XOR ECX,ECX
00476A75  |.  8ACA          MOV CL,DL
00476A77  |.  C1E9 04       SHR ECX,4
00476A7A  |.  0AC1          OR AL,CL                      ;  得到第二个6位数据
00476A7C  |.  8845 EF       MOV BYTE PTR SS:[EBP-11],AL    ;  保存
00476A7F  |.  80E2 0F       AND DL,0F
00476A82  |.  C1E2 02       SHL EDX,2
00476A85  |.  8A45 F8       MOV AL,BYTE PTR SS:[EBP-8]
00476A88  |.  33C9          XOR ECX,ECX
00476A8A  |.  8AC8          MOV CL,AL
00476A8C  |.  C1E9 06       SHR ECX,6
00476A8F  |.  0AD1          OR DL,CL                      ;  得到第三个6位数据
00476A91  |.  8855 F0       MOV BYTE PTR SS:[EBP-10],DL    ;  保存
00476A94  |.  24 3F       AND AL,3F                      ;  得到第四个6位数据
00476A96  |.  8845 F1       MOV BYTE PTR SS:[EBP-F],AL    ;  保存
00476A99  |.  8A45 F9       MOV AL,BYTE PTR SS:[EBP-7]
00476A9C  |.  33D2          XOR EDX,EDX
00476A9E  |.  8AD0          MOV DL,AL
00476AA0  |.  C1EA 02       SHR EDX,2                      ;  得到第五个6位数据
00476AA3  |.  8855 F2       MOV BYTE PTR SS:[EBP-E],DL    ;  保存
00476AA6  |.  24 03       AND AL,3
00476AA8  |.  C1E0 04       SHL EAX,4
00476AAB  |.  33D2          XOR EDX,EDX
00476AAD  |.  8A55 FA       MOV DL,BYTE PTR SS:[EBP-6]
00476AB0  |.  C1EA 04       SHR EDX,4
00476AB3  |.  0AC2          OR AL,DL                      ;  得到第六个6位数据
00476AB5  |.  8845 F3       MOV BYTE PTR SS:[EBP-D],AL    ;  保存
00476AB8  |.  8A45 FA       MOV AL,BYTE PTR SS:[EBP-6]
00476ABB  |.  24 0F       AND AL,0F
00476ABD  |.  C1E0 02       SHL EAX,2
00476AC0  |.  33D2          XOR EDX,EDX
00476AC2  |.  8A55 FB       MOV DL,BYTE PTR SS:[EBP-5]
00476AC5  |.  C1EA 06       SHR EDX,6
00476AC8  |.  0AC2          OR AL,DL                      ;  得到第七个6位数据
00476ACA  |.  8845 F4       MOV BYTE PTR SS:[EBP-C],AL    ;  保存
00476ACD  |.  8A45 FB       MOV AL,BYTE PTR SS:[EBP-5]
00476AD0  |.  24 3F       AND AL,3F                      ;  得到第八个6位数据
00476AD2  |.  8845 F5       MOV BYTE PTR SS:[EBP-B],AL    ;  保存
00476AD5  |.  33DB          XOR EBX,EBX
00476AD7  |.  8D75 EE       LEA ESI,DWORD PTR SS:[EBP-12]
00476ADA  |>  8BC3          /MOV EAX,EBX
00476ADC  |.  8A16          |MOV DL,BYTE PTR DS:[ESI]       ;  取其中一个六位数据
00476ADE  |.  E8 31FCFFFF |CALL unpacked.00476714       ;  到8个SBOX相应的盒子中取4位的数据
00476AE3  |.  8806          |MOV BYTE PTR DS:[ESI],AL       ;  保存
00476AE5  |.  43          |INC EBX
00476AE6  |.  46          |INC ESI
00476AE7  |.  83FB 08       |CMP EBX,8
00476AEA  |.^ 75 EE       \JNZ SHORT unpacked.00476ADA    ;  循环八轮
00476AEC  |.  BB 04000000 MOV EBX,4
00476AF1  |.  8D45 EE       LEA EAX,DWORD PTR SS:[EBP-12] ;  取出数据保存的地址
00476AF4  |.  8D55 F6       LEA EDX,DWORD PTR SS:[EBP-A]
00476AF7  |>  8A08          /MOV CL,BYTE PTR DS:[EAX]
00476AF9  |.  C1E1 04       |SHL ECX,4
00476AFC  |.  0A48 01       |OR CL,BYTE PTR DS:[EAX+1]    ;  两个4位数据合并成一个8位数据
00476AFF  |.  880A          |MOV BYTE PTR DS:[EDX],CL       ;  保存
00476B01  |.  42          |INC EDX
00476B02  |.  83C0 02       |ADD EAX,2
00476B05  |.  4B          |DEC EBX
00476B06  |.^ 75 EF       \JNZ SHORT unpacked.00476AF7    ;  四论循环，得到32位数据
00476B08  |.  8D45 F6       LEA EAX,DWORD PTR SS:[EBP-A]
00476B0B  |.  BA 05000000 MOV EDX,5
00476B10  |.  E8 7FFBFFFF CALL unpacked.00476694          ;  根据单纯换位表进行32位数据调整
00476B15  |.  BB 04000000 MOV EBX,4
00476B1A  |.  8D45 F6       LEA EAX,DWORD PTR SS:[EBP-A]
00476B1D  |.  8B55 0C       MOV EDX,DWORD PTR SS:[EBP+C]
00476B20  |>  8A08          /MOV CL,BYTE PTR DS:[EAX]
00476B22  |.  880A          |MOV BYTE PTR DS:[EDX],CL       ;  保存结果
00476B24  |.  42          |INC EDX
00476B25  |.  40          |INC EAX
00476B26  |.  4B          |DEC EBX
00476B27  |.^ 75 F7       \JNZ SHORT unpacked.00476B20    ;  四轮循环
00476B29  |.  8B75 E4       MOV ESI,DWORD PTR SS:[EBP-1C]
00476B2C  |.  8B5D E8       MOV EBX,DWORD PTR SS:[EBP-18]
00476B2F  |.  8BE5          MOV ESP,EBP
00476B31  |.  5D          POP EBP
00476B32  \.  C2 0C00       RETN 0C

小结：

选择函数F(Ri,Ki)，输入32位，输出32位，它的大致过程：

『数据膨胀』输入32位，输出48位：

32 01 02 03 04 05 04 05 06 07 08 09 08 09 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 31

『数据切割』输入48位，输出8个6位

将48位数据，先跟48位子密钥异或，然后切割成8个六位输据

『查SBOX表』输入8个6位，输出8个4位

SBOX[8,64]是个二维数组，里面存放了固定的4位数据，用六位数据的第1位和第6位组成i，第2、3、4、5位组成j，然后取SBOX[i,j]，将取出的8个4位数据组成32位数据。

SBOX数据太多，这里就不贴出来了。可以在论坛Crack Tutorial中找到。

『单纯换位』输入32位，输出32位

得到的32位数据，经单纯换位，既不膨胀，也不收缩，得到32位输出

单纯换位表：

16 07 20 21 29 12 28 17 01 15 23 26 05 18 31 10
02 08 24 14 32 27 03 09 19 13 30 06 22 11 04 25

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※

子密钥的生成过程：输入64位密钥，输出16个48位子密钥

跟进CALL unpacked.004768E0：

004768E0  /$  55          PUSH EBP
004768E1  |.  8BEC          MOV EBP,ESP
004768E3  |.  83C4 E4       ADD ESP,-1C
004768E6  |.  53          PUSH EBX
004768E7  |.  56          PUSH ESI
004768E8  |.  57          PUSH EDI
004768E9  |.  8BDA          MOV EBX,EDX
004768EB  |.  85DB          TEST EBX,EBX
004768ED  |.  78 0A       JS SHORT unpacked.004768F9
004768EF  |.  C1EB 02       SHR EBX,2
004768F2  |>  8B3498       /MOV ESI,DWORD PTR DS:[EAX+EBX*4>
004768F5  |.  4B          |DEC EBX
004768F6  |.  56          |PUSH ESI
004768F7  |.^ 79 F9       \JNS SHORT unpacked.004768F2
004768F9  |>  8BC4          MOV EAX,ESP
004768FB  |.  894D FC       MOV DWORD PTR SS:[EBP-4],ECX
004768FE  |.  8D75 F5       LEA ESI,DWORD PTR SS:[EBP-B]
00476901  |.  6A 06       PUSH 6                         ; /Arg1 = 00000006
00476903  |.  8BCE          MOV ECX,ESI                   ; |
00476905  |.  E8 46FEFFFF CALL unpacked.00476750          ; \数据收缩A，将64位密钥收缩位56位
0047690A  |.  8A06          MOV AL,BYTE PTR DS:[ESI]       ;  下面开始将56位分为两个28位C0和D0
0047690C  |.  33D2          XOR EDX,EDX
0047690E  |.  8AD0          MOV DL,AL
00476910  |.  C1EA 04       SHR EDX,4
00476913  |.  8855 F1       MOV BYTE PTR SS:[EBP-F],DL    ;  保存
00476916  |.  C1E0 04       SHL EAX,4
00476919  |.  8A56 01       MOV DL,BYTE PTR DS:[ESI+1]
0047691C  |.  33C9          XOR ECX,ECX
0047691E  |.  8ACA          MOV CL,DL
00476920  |.  C1E9 04       SHR ECX,4
00476923  |.  0AC1          OR AL,CL
00476925  |.  8845 F2       MOV BYTE PTR SS:[EBP-E],AL    ;  保存
00476928  |.  C1E2 04       SHL EDX,4
0047692B  |.  8A46 02       MOV AL,BYTE PTR DS:[ESI+2]
0047692E  |.  33C9          XOR ECX,ECX
00476930  |.  8AC8          MOV CL,AL
00476932  |.  C1E9 04       SHR ECX,4
00476935  |.  0AD1          OR DL,CL
00476937  |.  8855 F3       MOV BYTE PTR SS:[EBP-D],DL    ;  保存
0047693A  |.  C1E0 04       SHL EAX,4
0047693D  |.  8A56 03       MOV DL,BYTE PTR DS:[ESI+3]
00476940  |.  33C9          XOR ECX,ECX
00476942  |.  8ACA          MOV CL,DL
00476944  |.  C1E9 04       SHR ECX,4
00476947  |.  0AC1          OR AL,CL
00476949  |.  8845 F4       MOV BYTE PTR SS:[EBP-C],AL    ;  保存，上面的四个保存，保存了左28位C0
0047694C  |.  80E2 0F       AND DL,0F
0047694F  |.  8855 ED       MOV BYTE PTR SS:[EBP-13],DL    ;  保存
00476952  |.  8A46 04       MOV AL,BYTE PTR DS:[ESI+4]
00476955  |.  8845 EE       MOV BYTE PTR SS:[EBP-12],AL    ;  保存
00476958  |.  8A46 05       MOV AL,BYTE PTR DS:[ESI+5]
0047695B  |.  8845 EF       MOV BYTE PTR SS:[EBP-11],AL    ;  保存
0047695E  |.  8A46 06       MOV AL,BYTE PTR DS:[ESI+6]
00476961  |.  8845 F0       MOV BYTE PTR SS:[EBP-10],AL    ;  保存，上面的四个保存，保存了右28位D0
00476964  |.  BF 10000000 MOV EDI,10
00476969  |.  BB 40055C00 MOV EBX,OFFSET <unpacked.移位表> ;  取移位表地址
0047696E  |.  8B75 FC       MOV ESI,DWORD PTR SS:[EBP-4]    ;  下面注释中,i取1～16
00476971  |>  8D45 F1       /LEA EAX,DWORD PTR SS:[EBP-F] ;  左28位C(i-1)
00476974  |.  8A0B          |MOV CL,BYTE PTR DS:[EBX]       ;  取移位表数据
00476976  |.  BA 03000000 |MOV EDX,3
0047697B  |.  E8 00FFFFFF |CALL unpacked.00476880       ;  C(i-1)左移后生成Ci
00476980  |.  8D45 ED       |LEA EAX,DWORD PTR SS:[EBP-13] ;  右28位D(i-1)
00476983  |.  8A0B          |MOV CL,BYTE PTR DS:[EBX]       ;  取移位表数据
00476985  |.  BA 03000000 |MOV EDX,3
0047698A  |.  E8 F1FEFFFF |CALL unpacked.00476880       ;  D(i-1)移位生成Di
0047698F  |.  8A55 F1       |MOV DL,BYTE PTR SS:[EBP-F]
00476992  |.  C1E2 04       |SHL EDX,4
00476995  |.  8A45 F2       |MOV AL,BYTE PTR SS:[EBP-E]
00476998  |.  33C9          |XOR ECX,ECX
0047699A  |.  8AC8          |MOV CL,AL
0047699C  |.  C1E9 04       |SHR ECX,4
0047699F  |.  0AD1          |OR DL,CL
004769A1  |.  8855 E6       |MOV BYTE PTR SS:[EBP-1A],DL    ;  保存
004769A4  |.  C1E0 04       |SHL EAX,4
004769A7  |.  33D2          |XOR EDX,EDX
004769A9  |.  8A55 F3       |MOV DL,BYTE PTR SS:[EBP-D]
004769AC  |.  C1EA 04       |SHR EDX,4
004769AF  |.  0AC2          |OR AL,DL
004769B1  |.  8845 E7       |MOV BYTE PTR SS:[EBP-19],AL    ;  保存
004769B4  |.  8A55 F3       |MOV DL,BYTE PTR SS:[EBP-D]
004769B7  |.  C1E2 04       |SHL EDX,4
004769BA  |.  8A45 F4       |MOV AL,BYTE PTR SS:[EBP-C]
004769BD  |.  33C9          |XOR ECX,ECX
004769BF  |.  8AC8          |MOV CL,AL
004769C1  |.  C1E9 04       |SHR ECX,4
004769C4  |.  0AD1          |OR DL,CL
004769C6  |.  8855 E8       |MOV BYTE PTR SS:[EBP-18],DL    ;  保存
004769C9  |.  C1E0 04       |SHL EAX,4
004769CC  |.  0A45 ED       |OR AL,BYTE PTR SS:[EBP-13]
004769CF  |.  8845 E9       |MOV BYTE PTR SS:[EBP-17],AL    ;  保存
004769D2  |.  8A45 EE       |MOV AL,BYTE PTR SS:[EBP-12]
004769D5  |.  8845 EA       |MOV BYTE PTR SS:[EBP-16],AL    ;  保存
004769D8  |.  8A45 EF       |MOV AL,BYTE PTR SS:[EBP-11]
004769DB  |.  8845 EB       |MOV BYTE PTR SS:[EBP-15],AL    ;  保存
004769DE  |.  8A45 F0       |MOV AL,BYTE PTR SS:[EBP-10]
004769E1  |.  8845 EC       |MOV BYTE PTR SS:[EBP-14],AL    ;  保存，上面7个保存，将Ci和Di合并成56位数据
004769E4  |.  6A 05       |PUSH 5                         ; /Arg1 = 00000005
004769E6  |.  8BCE          |MOV ECX,ESI                   ; |
004769E8  |.  8D45 E6       |LEA EAX,DWORD PTR SS:[EBP-1A] ; |
004769EB  |.  BA 06000000 |MOV EDX,6                      ; |
004769F0  |.  E8 F3FDFFFF |CALL unpacked.004767E8       ; \缩位变换B，将56位数决变换成48位的Ki
004769F5  |.  83C6 06       |ADD ESI,6
004769F8  |.  43          |INC EBX
004769F9  |.  4F          |DEC EDI
004769FA  |.^ 0F85 71FFFFFF  \JNZ unpacked.00476971          ;  循环16轮,生成16个子密钥
00476A00  |.  8B7D D8       MOV EDI,DWORD PTR SS:[EBP-28]
00476A03  |.  8B75 DC       MOV ESI,DWORD PTR SS:[EBP-24]
00476A06  |.  8B5D E0       MOV EBX,DWORD PTR SS:[EBP-20]
00476A09  |.  8BE5          MOV ESP,EBP
00476A0B  |.  5D          POP EBP
00476A0C  \.  C2 0400       RETN 4

小结：

『缩位变换A』输入64位密钥，输出56位数据

57 49 41 33 25 17 09
01 58 50 42 34 26 18
10 02 59 51 43 35 27
19 11 03 60 52 44 36
63 55 47 39 31 23 15
07 62 54 46 38 30 22
14 06 61 53 45 37 29
21 13 05 28 20 12 04

56位数据分为两个28位，进入16轮循环

移位表：1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1

『缩位变换B』输入56位，输出48位Ki

14 17 11 24 01 05
03 28 15 06 21 10
23 19 12 04 26 08
16 07 27 20 13 02
41 52 31 37 47 55
30 40 51 45 33 48
44 49 39 56 34 53
46 42 50 36 29 32

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※
----------------------------------------------------------------------------------------------
【破解声明】我是一只小菜鸟，偶得一点心得，愿与大家分享:)

【版权声明】本文纯属技术交流, 转载请注明作者并保持文章的完整, 谢谢!
----------------------------------------------------------------------------------------------
                                                                  文章写于2005-8-25 17:55:37

Nisy · 发表于 2006-6-17 17:35:37

怎么大家都不来学习算法我先顶上然后慢慢学习~~

		自动登录	找回密码
密码			加入我们

流星网络电视V1.9.2.0的注册(续:DES篇)

相关帖子