【前言】时断时续的学习破解，这是我在本坛贴出的第二篇学习笔记，比前一篇稍有了点进步，与刚学破解的朋友们交流，大牛们看了别笑话水平太低，给我指点就好了
【软件】加了yoda's cryptor 1.2壳的win98记事本程序，由天草老师教程中提供。
【工具】OD、PEiD、lordPE、ImportREC
用PEiD查一下，是yoda's cryptor 1.2壳，下面OD载入，开始分析。
首先是壳引导部分，功能是解密壳主体部分代码，解密完成后就将控制权交给主体代码。
0040D060 Y> 60 pushad ; 程序入口，载入时停在此处
0040D061 E8 00000000 call Yoda's_C.0040D066
0040D066 5D pop ebp ; 这两行是壳代码自定位
0040D067 81ED F31D4000 sub ebp,Yoda's_C.00401DF3 ; 计算偏移量，用于取加壳时保存的信息的重定位
0040D06D B9 7B090000 mov ecx,97B ; 要解密代码的字节数为97Bh
0040D072 8DBD 3B1E4000 lea edi,dword ptr ss:[ebp+401E3B] ; 被解密代码的起始位置，解密完成全就被执行
0040D078 8BF7 mov esi,edi
0040D07A / AC lods byte ptr ds:[esi] ; 逐字节取出进行解密，以下就是解密代码
0040D07B | 2AC1 sub al,cl
0040D07D | EB 01 jmp short Yoda's_C.0040D080
0040D07F | C2 348F retn 8F34 ; C2花指令，可将C2改为90（nop）。以下几处同此。
0040D080 | 34 8F xor al,8F
0040D082 | F9 stc
0040D083 | 02C1 add al,cl
0040D085 | F8 clc
0040D086 | 34 AE xor al,0AE
0040D088 | 2C E9 sub al,0E9
0040D08A | FEC8 dec al
0040D08C | 02C1 add al,cl
0040D08E | FEC8 dec al
0040D090 | 04 CD add al,0CD
0040D092 | 90 nop
0040D093 | EB 01 jmp short Yoda's_C.0040D096
0040D095 | C2 2AC1 retn 0C12A ; 又是C2花指令
0040D096 | 2AC1 sub al,cl
0040D098 | C0C8 5E ror al,5E
0040D09B | FEC8 dec al
0040D09D | 2AC1 sub al,cl
0040D09F | 04 7D add al,7D
0040D0A1 | EB 01 jmp short Yoda's_C.0040D0A4
0040D0A3 | C2 2AC1 retn 0C12A ; 依然是C2花指令
0040D0A4 | 2AC1 sub al,cl
0040D0A6 | 34 58 xor al,58
0040D0A8 | C0C0 B1 rol al,0B1
0040D0AB | AA stos byte ptr es:[edi]
0040D0AC \^ E2 CC loopd short Yoda's_C.0040D07A
因为有代码自解密，所以会给静态调试带来干扰，但分析上面所有解密方法，可以看出都是对al进行运算，另两个参数就是cl（剩余字节数的）和edi（代码地址），如果用IDA来调试的话，也很容易能写出脚本函数来解密这段代码。解密完成后，我们在数据窗口看到被解密的末尾赫然出现了“IsDebuggerPresent”，这里埋下伏笔。
以下就是解密后的代码，位置是紧接上面的代码之后，解密完成后就开始执行之。
0040D0AE 8B4424 20 mov eax,dword ptr ss:[esp+20] ; kernel32.7C817077
0040D0B2 40 inc eax ; 程序出口点--kernel32.ExitThread
0040D0B3 78 0A js short Yoda's_C.0040D0BF
0040D0B5 C785 78254000 01000000 mov dword ptr ss:[ebp+402578],1 ; 设置标志，后面会用到。
0040D0BF 8D85 ED1D4000 lea eax,dword ptr ss:[ebp+401DED] ; 地址=0040D060，程序入口点
0040D0C5 B9 2A060000 mov ecx,62A ; 自校验的代码字节数
0040D0CA E8 41020000 call Yoda's_C.0040D310 ; 壳代码自校验
{
0040D310 8BF8 mov edi,eax ; 从入口点0040D060起62Ah字节纳入校验
0040D312 33C0 xor eax,eax
0040D314 33DB xor ebx,ebx
0040D316 33D2 xor edx,edx
0040D318 8A07 mov al,byte ptr ds:[edi]
0040D31A F7E2 mul edx
0040D31C 03D8 add ebx,eax
0040D31E 42 inc edx
0040D31F 47 inc edi
0040D320 ^ E2 F6 loopd short Yoda's_C.0040D318
}
这个函数校验从壳入口起62A字节，实际上第1字节不影响结果，因这它乘0还是=0。
0040D0CF 8985 74254000 mov dword ptr ss:[ebp+402574],eax ; 保存校验和（0002494C），后面会用到。
我们可以看到[ebp+402574]上下是一张信息表，其中存放了加壳前原程序的一些数据信息，如[0040D7DB]处就是存放的原程序OEP－－004010CC，以及[0040D7DB]处的00400000，加壳后的程序运行时用这些数据进行一系列处理。
0040D0D5 8B85 6C254000 mov eax,dword ptr ss:[ebp+40256C] ; ss:[0040D7DF]=0000003C
0040D0DB 83E0 01 and eax,1
0040D0DE 74 40 je short Yoda's_C.0040D120 ; 偶数，跳
0040D120 8B85 64254000 mov eax,dword ptr ss:[ebp+402564] ; 取ImageBaseAddress
0040D126 0340 3C add eax,dword ptr ds:[eax+3C] ; 定位PE Header
0040D129 05 80000000 add eax,80 ; 取输入表数据目录
0040D12E 8B08 mov ecx,dword ptr ds:[eax] ; 取输入表RVA（加壳时已经被改指向壳中的新位置）
0040D130 038D 64254000 add ecx,dword ptr ss:[ebp+402564] ; +ImageBaseAddress定位输入表（位于壳中，只有1个IID）
0040D136 83C1 10 add ecx,10 ; FirstThunk
0040D139 8B01 mov eax,dword ptr ds:[ecx] ;
0040D13B 0385 64254000 add eax,dword ptr ss:[ebp+402564] ; 函数指针
0040D141 8B18 mov ebx,dword ptr ds:[eax] ; 函数kernel32.LoadLibraryA地址
0040D143 899D F0264000 mov dword ptr ss:[ebp+4026F0],ebx ; 保存LoadLibraryA函数地址
0040D149 83C0 04 add eax,4 ; 下一个函数
0040D14C 8B18 mov ebx,dword ptr ds:[eax] ; kernel32.GetProcAddress
0040D14E 899D F4264000 mov dword ptr ss:[ebp+4026F4],ebx ; 保存GetProcAddress函数地址
0040D154 8D85 F8264000 lea eax,dword ptr ss:[ebp+4026F8] ; ASCII "Kernel32.dll"
0040D15A 50 push eax
0040D15B FF95 F0264000 call dword ptr ss:[ebp+4026F0] ; 动态调入Kernel32.dll
0040D161 8BF0 mov esi,eax ; Kernel32.dll句柄
0040D163 8985 05274000 mov dword ptr ss:[ebp+402705],eax ; 保存句柄
0040D169 8D85 09274000 lea eax,dword ptr ss:[ebp+402709] ; ASCII "GetModuleHandleA"
0040D16F E8 96000000 call Yoda's_C.0040D20A ; 简单封装的GetProcAddress函数。获取kernel32.GetModuleHandleA地址
{
0040D20A 50 push eax
0040D20B 56 push esi
0040D20C FF95 F4264000 call dword ptr ss:[ebp+4026F4] ; kernel32.GetProcAddress
}
0040D174 8985 1A274000 mov dword ptr ss:[ebp+40271A],eax ; 保存函数地址
0040D17A 8D85 1E274000 lea eax,dword ptr ss:[ebp+40271E] ; ASCII "VirtualProtect"
0040D180 E8 85000000 call Yoda's_C.0040D20A ; 获取kernel32.VirtualProtect地址
0040D185 8985 2D274000 mov dword ptr ss:[ebp+40272D],eax ; 保存函数地址
0040D18B 8D85 31274000 lea eax,dword ptr ss:[ebp+402731]
0040D191 E8 74000000 call Yoda's_C.0040D20A ; 获取kernel32.GetModuleFileNameA地址
0040D196 8985 44274000 mov dword ptr ss:[ebp+402744],eax ; 保存函数地址
0040D19C 8D85 48274000 lea eax,dword ptr ss:[ebp+402748]
0040D1A2 E8 63000000 call Yoda's_C.0040D20A ; 获取kernel32.CreateFileA地址
0040D1A7 8985 54274000 mov dword ptr ss:[ebp+402754],eax ; 保存函数地址
0040D1AD 8D85 58274000 lea eax,dword ptr ss:[ebp+402758]
0040D1B3 E8 52000000 call Yoda's_C.0040D20A ; 获取kernel32.GlobalAlloc地址
0040D1B8 8985 64274000 mov dword ptr ss:[ebp+402764],eax ; 保存函数地址
0040D1BE 8D85 68274000 lea eax,dword ptr ss:[ebp+402768]
0040D1C4 E8 41000000 call Yoda's_C.0040D20A ; 获取kernel32.GlobalFree地址
0040D1C9 8985 73274000 mov dword ptr ss:[ebp+402773],eax ; 保存函数地址
0040D1CF 8D85 77274000 lea eax,dword ptr ss:[ebp+402777]
0040D1D5 E8 30000000 call Yoda's_C.0040D20A ; 获取kernel32.ReadFile地址
0040D1DA 8985 80274000 mov dword ptr ss:[ebp+402780],eax ; 保存函数地址
0040D1E0 8D85 84274000 lea eax,dword ptr ss:[ebp+402784]
0040D1E6 E8 1F000000 call Yoda's_C.0040D20A ; 获取kernel32.GetFileSize地址
0040D1EB 8985 90274000 mov dword ptr ss:[ebp+402790],eax ; 保存函数地址
0040D1F1 8D85 94274000 lea eax,dword ptr ss:[ebp+402794]
0040D1F7 E8 0E000000 call Yoda's_C.0040D20A ; 获取kernel32.CloseHandle地址
0040D1FC 8985 A0274000 mov dword ptr ss:[ebp+4027A0],eax ; 保存函数地址
0040D202 8D85 A01F4000 lea eax,dword ptr ss:[ebp+401FA0] ; 取上面执行过的子函数之后的代码的地址（0040D213）。
0040D208 50 push eax
0040D209 C3 retn ; 用push+retn的形式跳转
-------------------------------------------------
0040D20A 50 push eax
0040D20B 56 push esi
0040D20C FF95 F4264000 call dword ptr ss:[ebp+4026F4] ; kernel32.GetProcAddress
-------------------------------------------------
上面3行就是上面执行过的子函数，这种将子函数嵌入主程序代码中并用push+retn的形式跳转的做法，下面还有几处，我不再把子函数再一一列出了，看到用push+retn的形式跳转的形式就明白下面是还有一段已调用过的子函数的。
用push+retn的形式跳转到了这里：
0040D213 F785 6C254000 10000000 test dword ptr ss:[ebp+40256C],10 ; 3C
0040D21D 74 37 je short Yoda's_C.0040D256 ; 不跳
0040D21F 64:FF35 30000000 push dword ptr fs:[30] ; push+pop获得PEB首地址
0040D226 58 pop eax
0040D227 85C0 test eax,eax
0040D229 78 0F js short Yoda's_C.0040D23A ; 如果是windows9x就跳，NT则不跳
0040D22B 8B40 0C mov eax,dword ptr ds:[eax+C] ; 进程PEB的双向链表（PEB_LDR_DATA）
0040D22E 8B40 0C mov eax,dword ptr ds:[eax+C] ; InLoadOrderModuleList
0040D231 C740 20 00100000 mov dword ptr ds:[eax+20],1000 ; 修改InLoadOrderLinks.SizeOfImage大小，原为0F000，做点小手脚反脱壳
0040D238 EB 1C jmp short Yoda's_C.0040D256 ; 跳
0040D23A 6A 00 push 0
0040D23C FF95 1A274000 call dword ptr ss:[ebp+40271A]
0040D242 85D2 test edx,edx
0040D244 79 10 jns short Yoda's_C.0040D256
0040D246 837A 08 FF cmp dword ptr ds:[edx+8],-1
0040D24A 75 0A jnz short Yoda's_C.0040D256
0040D24C 8B52 04 mov edx,dword ptr ds:[edx+4]
0040D24F C742 50 00100000 mov dword ptr ds:[edx+50],1000
0040D256 8BBD 64254000 mov edi,dword ptr ss:[ebp+402564] ; 跳到这里。ImageBaseAddress
0040D25C 037F 3C add edi,dword ptr ds:[edi+3C] ; 定位PE头
0040D25F 8BB5 64254000 mov esi,dword ptr ss:[ebp+402564] ; ImageBaseAddress
0040D265 8B4F 54 mov ecx,dword ptr ds:[edi+54] ; SizeOfHeaders
0040D268 8D85 D2274000 lea eax,dword ptr ss:[ebp+4027D2] ; 地址=0040DA45，文件末尾的空白处。这个壳把文件末尾的空白区域作为缓冲区（暂且称为buffer吧），保存一些临时数据。
0040D26E 50 push eax ; lpflOldProtect
0040D26F 6A 04 push 4
0040D271 51 push ecx ; size=1000
0040D272 FFB5 64254000 push dword ptr ss:[ebp+402564] ; lpAddress=00400000
0040D278 FF95 2D274000 call dword ptr ss:[ebp+40272D] ; kernel32.VirtualProtect。文件头内存页的只读属性改为可读写
0040D27E F785 6C254000 08000000 test dword ptr ss:[ebp+40256C],8 ; 3C
0040D288 0F84 A7000000 je Yoda's_C.0040D335
0040D28E 68 04010000 push 104
0040D293 8DBD D2274000 lea edi,dword ptr ss:[ebp+4027D2] ; buffer
0040D299 57 push edi
0040D29A 6A 00 push 0
0040D29C FF95 44274000 call dword ptr ss:[ebp+402744] ; GetModuleFileNameA。获取文件名
0040D2A2 6A 00 push 0 ; hTemplateFile
0040D2A4 68 80000000 push 80 ; dwFlagsAndAttributes
0040D2A9 6A 03 push 3 ; dwCreationDisposition
0040D2AB 6A 00 push 0 ; lpSecurityAttributes
0040D2AD 6A 01 push 1 ; dwShareMode
0040D2AF 68 00000080 push 80000000 ; dwDesiredAccess
0040D2B4 57 push edi ; lpFileName
0040D2B5 FF95 54274000 call dword ptr ss:[ebp+402754] ; kernel32.CreateFileA，打开磁盘文件并获取文件句柄。
0040D2BB 83F8 FF cmp eax,-1
0040D2BE 75 04 jnz short Yoda's_C.0040D2C4 ; 成功则跳
0040D2C0 33C0 xor eax,eax
0040D2C2 EB 71 jmp short Yoda's_C.0040D335
0040D2C4 8BF8 mov edi,eax ; 打开的文件句柄
0040D2C6 6A 00 push 0
0040D2C8 57 push edi
0040D2C9 FF95 90274000 call dword ptr ss:[ebp+402790] ; GetFileSize获取文件大小
0040D2CF 83E8 05 sub eax,5 ; 文件大小DA46-5=DA41字节。后面我们可以知道，DA41之后的5个字节是DA41字节的校验和（4字节）及0
0040D2D2 96 xchg eax,esi
0040D2D3 56 push esi
0040D2D4 6A 40 push 40
0040D2D6 FF95 64274000 call dword ptr ss:[ebp+402764] ; GlobalAlloc申请一个比原文件小5字节的内存空间
0040D2DC 0BC0 or eax,eax
0040D2DE 75 02 jnz short Yoda's_C.0040D2E2 ; 成功则跳
0040D2E0 EB 4A jmp short Yoda's_C.0040D32C
0040D2E2 93 xchg eax,ebx
0040D2E3 6A 00 push 0 ; lpOverlapped
0040D2E5 8D85 D2274000 lea eax,dword ptr ss:[ebp+4027D2] ; buffer，现用来存放从文件读取的字节数
0040D2EB 50 push eax ; lpNumberOfBytesRead
0040D2EC 56 push esi ; nNumberOfBytesToRead
0040D2ED 53 push ebx ; lpBuffer
0040D2EE 57 push edi ; hFile
0040D2EF FF95 80274000 call dword ptr ss:[ebp+402780] ; ReadFile读取文件
0040D2F5 8BC3 mov eax,ebx ; lpBuffer
0040D2F7 8BCE mov ecx,esi ; nNumberOfBytesToRead
0040D2F9 53 push ebx
0040D2FA 57 push edi
0040D2FB E8 10000000 call Yoda's_C.0040D310 ; 读入的文件内容校验和，同前面壳代码自校验是同一函数。
{
0040D310 8BF8 mov edi,eax ; lpBuffer（共DA41字节）
0040D312 33C0 xor eax,eax
0040D314 33DB xor ebx,ebx
0040D316 33D2 xor edx,edx
0040D318 8A07 mov al,byte ptr ds:[edi]
0040D31A F7E2 mul edx ; 同样是第1个字节不影响结果
0040D31C 03D8 add ebx,eax
0040D31E 42 inc edx
0040D31F 47 inc edi
0040D320 ^ E2 F6 loopd short Yoda's_C.0040D318
0040D322 93 xchg eax,ebx
0040D323 C3 retn
}
0040D300 8985 70254000 mov dword ptr ss:[ebp+402570],eax ; 保存文件校验和（00504875）
0040D306 5F pop edi
0040D307 5B pop ebx
0040D308 8D85 B1204000 lea eax,dword ptr ss:[ebp+4020B1] ; 修改地址跳过上面已执行的子函数代码
0040D30E 50 push eax
0040D30F C3 retn ; 用push+retn的形式跳转
跳到了这里:
0040D324 53 push ebx
0040D325 FF95 73274000 call dword ptr ss:[ebp+402773] ; 释放内存
0040D32B 96 xchg eax,esi
0040D32C 50 push eax
0040D32D 57 push edi
0040D32E FF95 A0274000 call dword ptr ss:[ebp+4027A0] ; 关闭打开的文件
0040D334 58 pop eax
0040D335 8B85 64254000 mov eax,dword ptr ss:[ebp+402564] ; ImageBaseAddress
0040D33B BB 01000000 mov ebx,1 ; 区段计数器
0040D340 E8 08000000 call Yoda's_C.0040D34D ; 解密区段数据
{
0040D34D 8BF8 mov edi,eax
0040D34F 037F 3C add edi,dword ptr ds:[edi+3C] ; 定位PE头
0040D352 8BF7 mov esi,edi
0040D354 81C6 F8000000 add esi,0F8 ; 定位区段表
0040D35A 33D2 xor edx,edx
0040D35C 813E 72737263 cmp dword ptr ds:[esi],63727372 ; 区段名前4个字符是否'rsrc'，是则跳过该区段，否则继续判断
0040D362 75 05 jnz short Yoda's_C.0040D369
0040D364 E9 9E000000 jmp Yoda's_C.0040D407
0040D369 813E 2E727372 cmp dword ptr ds:[esi],7273722E ; 是否'.rsr'，是则跳过该区段，否则继续判断
0040D36F 75 05 jnz short Yoda's_C.0040D376
0040D371 E9 91000000 jmp Yoda's_C.0040D407
0040D376 813E 72656C6F cmp dword ptr ds:[esi],6F6C6572 ; 是否'relo'，是则跳过该区段，否则继续判断
0040D37C 75 05 jnz short Yoda's_C.0040D383
0040D37E E9 84000000 jmp Yoda's_C.0040D407
0040D383 813E 2E72656C cmp dword ptr ds:[esi],6C65722E ; 是否'.rel'，是则跳过该区段，否则继续判断
0040D389 75 02 jnz short Yoda's_C.0040D38D
0040D38B EB 7A jmp short Yoda's_C.0040D407
0040D38D 813E 79430000 cmp dword ptr ds:[esi],4379 ; 是否'yC'，即yada加壳的段名标志，是则跳过该区段，否则继续判断
0040D393 75 02 jnz short Yoda's_C.0040D397
0040D395 EB 70 jmp short Yoda's_C.0040D407
0040D397 813E 2E656461 cmp dword ptr ds:[esi],6164652E ; 是否'.eda'，是则跳过该区段，否则继续判断
0040D39D 75 02 jnz short Yoda's_C.0040D3A1
0040D39F EB 66 jmp short Yoda's_C.0040D407
0040D3A1 837E 14 00 cmp dword ptr ds:[esi+14],0 ; 该区段在文件中的偏移量否为0，是则跳过该区段，否则继续判断
0040D3A5 74 06 je short Yoda's_C.0040D3AD
0040D3A7 837E 10 00 cmp dword ptr ds:[esi+10],0 ; 该区段大小是否为0，是则跳过该区段，否则解密该段
0040D3AB 75 02 jnz short Yoda's_C.0040D3AF
0040D3AD EB 58 jmp short Yoda's_C.0040D407
0040D3AF 60 pushad ; 保护环境，开始解密该段
0040D3B0 8B4E 10 mov ecx,dword ptr ds:[esi+10] ; 区段大小
0040D3B3 0BDB or ebx,ebx
0040D3B5 /75 0C jnz short Yoda's_C.0040D3C3 ; 计数器不为0则跳
0040D3B7 |8B76 14 mov esi,dword ptr ds:[esi+14]
0040D3BA |03F0 add esi,eax
0040D3BC |E8 8BF9FFFF call Yoda's_C.0040CD4C
0040D3C1 |EB 0A jmp short Yoda's_C.0040D3CD
0040D3C3 \8B76 0C mov esi,dword ptr ds:[esi+C] ; 取区段的RVA地址
0040D3C6 03F0 add esi,eax ; 区段的地址
0040D3C8 E8 02000000 call Yoda's_C.0040D3CF ; 解密
{
0040D3CF 8BFE mov edi,esi ; 段起始地址
0040D3D1 AC lods byte ptr ds:[esi] ; 取一个字节进行解密
0040D3D2 90 nop
0040D3D3 EB 01 jmp short Yoda's_C.0040D3D6
0040D3D5 C2 348F retn 8F34 ; 又是可恶的C2，后面的这种代码我就不列出来了
0040D3D6 34 8F xor al,8F
0040D3D8 F9 stc
0040D3D9 02C1 add al,cl
0040D3DB F8 clc
0040D3DC 34 AE xor al,0AE
0040D3DE 2C E9 sub al,0E9
0040D3E0 FEC8 dec al
0040D3E2 02C1 add al,cl
0040D3E4 FEC8 dec al
0040D3E6 04 CD add al,0CD
0040D3E8 90 nop
0040D3E9 EB 01 jmp short Yoda's_C.0040D3EC
0040D3EC 2AC1 sub al,cl
0040D3EE C0C8 5E ror al,5E
0040D3F1 FEC8 dec al
0040D3F3 2AC1 sub al,cl
0040D3F5 04 7D add al,7D
0040D3F7 EB 01 jmp short Yoda's_C.0040D3FA
0040D3FA 2AC1 sub al,cl
0040D3FC 34 58 xor al,58
0040D3FE C0C0 B1 rol al,0B1
0040D401 90 nop
0040D402 AA stos byte ptr es:[edi] ; 回写解密后的字节
0040D403 ^ E2 CC loopd short Yoda's_C.0040D3D1
0040D405 C3 retn
}
我们可以看到，这个解密方法与壳引导代码中解密壳代码的方法是完全相同的，只不过这里封装成了函数。
0040D3CD EB 37 jmp short Yoda's_C.0040D406
0040D406 61 popad ; 恢复环境
0040D407 83C6 28 add esi,28 ; 处理下一区段
0040D40A 42 inc edx ; 区段计数器+1
0040D40B 66:3B57 06 cmp dx,word ptr ds:[edi+6] ; 区段是否处理完毕
0040D40F ^ 0F85 47FFFFFF jnz Yoda's_C.0040D35C ; 否则循环处理
0040D415 C3 retn
}
0040D345 8D85 A3214000 lea eax,dword ptr ss:[ebp+4021A3] ; 取上面执行过的子函数之后的代码的地址（0040D416）。
0040D34B 50 push eax ; 压入地址
0040D34C C3 retn ; 用retn的形式跳转
跳到了这里：
0040D416 8B9D 64254000 mov ebx,dword ptr ss:[ebp+402564] ; 信息表中取ImageBaseAddress
0040D41C 039D 68254000 add ebx,dword ptr ss:[ebp+402568] ; 00400000+000010CC=004010CC（OEP，这里先假装不知，因为碰到不熟悉的带壳程序时，就只能猜它可能是，它正好落在程序的代码段，到后面根据情况再确定是不是）
0040D422 C1CB 07 ror ebx,7 ; 这里要做什么！注意，004010CC被加密成了98008021，更值得怀疑是OEP！先留下一个悬念
0040D425 895C24 10 mov dword ptr ss:[esp+10],ebx ; 保存在堆栈0012FFB4中，这个地址的下一个地址的内容是ntdll.KiFastSystemCallRet，这些特殊地址都要收起注意
0040D429 8D9D 99244000 lea ebx,dword ptr ss:[ebp+402499] ; 信息表中取什么地址？0040D70C，再留下一个悬念
0040D42F 895C24 1C mov dword ptr ss:[esp+1C],ebx ; 保存在0012FFC0，这个地址的下一个内容是“返回到kernel32.7C817077”
0040D433 8BBD 64254000 mov edi,dword ptr ss:[ebp+402564] ; 信息表中取ImageBaseAddress
0040D439 037F 3C add edi,dword ptr ds:[edi+3C] ; 定位PE头
0040D43C 8B9F C0000000 mov ebx,dword ptr ds:[edi+C0] ; 取线程本地存储器（TLS）这又是要做什么？这几行代码令人生疑！
0040D442 83FB 00 cmp ebx,0 ; 本例为0。如果非0，则指向一个IMAGE_TLS_DIRECTORY结构，TLS是程序最先开始执行的地方，比EP更早执行
0040D445 74 0F je short Yoda's_C.0040D456
0040D447 039D 64254000 add ebx,dword ptr ss:[ebp+402564]
0040D44D 8B43 08 mov eax,dword ptr ds:[ebx+8]
0040D450 C700 00000000 mov dword ptr ds:[eax],0 ; 将TLS索引清0。本例中未执行到这里，因为本就是0
0040D456 8B85 70254000 mov eax,dword ptr ss:[ebp+402570] ; 取出之前保存的文件校验和（文件大小-5字节的，00504875），晕S，隔这么远的地方来检验！
0040D45C 0BC0 or eax,eax
0040D45E 74 0D je short Yoda's_C.0040D46D
0040D460 3B85 CE274000 cmp eax,dword ptr ss:[ebp+4027CE] ; ss:[0040DA41]=00504875，这是加壳时保存的文件校验和，在此验证文件是否被改动过
0040D466 74 05 je short Yoda's_C.0040D46D
0040D468 E9 AF010000 jmp Yoda's_C.0040D61C ; 如果改动了就game over了
下面开始处理输入表了：
0040D46D 8DB5 7C254000 lea esi,dword ptr ss:[ebp+40257C] ; 地址=0040D7EF，这又是什么地址？从后面的处理可以看出，这个esi处是一个变形了的输入表结构，每个结构对应一个dll，并且每个结构压缩成3个成员：第一个是成员Name，第二个FirstThunk，第三个是OriginalFirstThunk。加壳时，对Name指向的dll名称都加了密，FirstThunk指向的函数地址都被篡改。
0040D473 F785 6C254000 20000000 test dword ptr ss:[ebp+40256C],20 ; 3C
0040D47D 74 49 je short Yoda's_C.0040D4C8
0040D47F 56 push esi
0040D480 8DBD D2274000 lea edi,dword ptr ss:[ebp+4027D2] ; buffer
0040D486 33C9 xor ecx,ecx
0040D488 /EB 17 jmp short Yoda's_C.0040D4A1 ; 这个循环象是在计算API个数
0040D48A |8B56 04 mov edx,dword ptr ds:[esi+4] ; ds:[0040D7F3]=000063F0，这是什么地址？IAT？
0040D48D |0395 64254000 add edx,dword ptr ss:[ebp+402564] ; 偏移地址+ImageBaseAddress
0040D493 |EB 04 jmp short Yoda's_C.0040D499
0040D495 |41 inc ecx ; 计数器+1
0040D496 |83C2 04 add edx,4
0040D499 |833A 00 cmp dword ptr ds:[edx],0
0040D49C ^|75 F7 jnz short Yoda's_C.0040D495 ; 象是在遍历IAT
0040D49E |83C6 0C add esi,0C
0040D4A1 \837E 04 00 cmp dword ptr ds:[esi+4],0
0040D4A5 ^ 75 E3 jnz short Yoda's_C.0040D48A ; 下一个DLL？
0040D4A7 33D2 xor edx,edx
0040D4A9 B8 05000000 mov eax,5
0040D4AE F7E1 mul ecx
0040D4B0 50 push eax ; 8Ah*5=2B2h，为何要*5？后面揭秘
0040D4B1 6A 00 push 0
0040D4B3 FF95 64274000 call dword ptr ss:[ebp+402764] ; GlobalAlloc申请内存（堆），大小为2B2h字节
0040D4B9 0BC0 or eax,eax ; 我这里申请到的堆地址=001431E0
0040D4BB 75 05 jnz short Yoda's_C.0040D4C2 ; 成功则跳，失败则退出
0040D4BD 83C4 04 add esp,4
0040D4C0 61 popad
0040D4C1 C3 retn
0040D4C2 8907 mov dword ptr ds:[edi],eax ; [edi]=[0040DA45]，即保存堆地址到buffer
0040D4C4 8947 04 mov dword ptr ds:[edi+4],eax ; 连续保存2份
0040D4C7 5E pop esi ; 0040D7EF，弹出变形的输入表首地址
0040D4C8 E9 42010000 jmp Yoda's_C.0040D60F ; 跳到循环条件判断处，之间为循环体
0040D4CD / 8B1E mov ebx,dword ptr ds:[esi] ; 刚刚遍历的地址，通过一轮循环后知道这是IAT的RVA
0040D4CF | 039D 64254000 add ebx,dword ptr ss:[ebp+402564] ; +ImageBaseAddress，定位到IAT
0040D4D5 | 8BC3 mov eax,ebx
0040D4D7 | E8 08000000 call Yoda's_C.0040D4E4 ; 字符串解密函数。这里是将dll文件名解密
{
0040D4E4 56 push esi
0040D4E5 57 push edi
0040D4E6 8BF0 mov esi,eax
0040D4E8 8BF8 mov edi,eax ; 将源地址与目标地址指向同一地址，即直接解密后覆盖
0040D4EA AC lods byte ptr ds:[esi] ; ds:[esi]=[0040658A]，注意，这个地址是在.idata段，不是在壳中
0040D4EB C0C8 04 ror al,4 ; 简单地将每字节循环右移4位解密
0040D4EE AA stos byte ptr es:[edi] ; 果然与解密输入表有关，首先解密出了"SHELL32.DLL"字符串（IID的NAME成员），并回写
0040D4EF 803F 00 cmp byte ptr ds:[edi],0
0040D4F2 ^ 75 F6 jnz short Yoda's_C.0040D4EA
0040D4F4 5F pop edi
0040D4F5 5E pop esi
0040D4F6 C3 retn
}
0040D4DC | 8D85 84224000 lea eax,dword ptr ss:[ebp+402284] ; 取上面执行过的子函数之后的代码的地址（0040D4F7）。
0040D4E2 | 50 push eax ; 压入地址
0040D4E3 | C3 retn ; 用push+retn的形式跳转
跳到了这里:
0040D4F7 | 53 push ebx ; ASCII "SHELL32.dll"
0040D4F8 | FF95 F0264000 call dword ptr ss:[ebp+4026F0] ; LoadLibraryA调入动态库SHELL32.dll
0040D4FE | 85C0 test eax,eax
0040D500 | 0F84 16010000 je Yoda's_C.0040D61C ; 调入失败则game over
0040D506 | 50 push eax
0040D507 | F785 6C254000 04000000 test dword ptr ss:[ebp+40256C],4 ; 3C，若=4则不清除shell32.dll字符串，否则清除
0040D511 | 74 0E je short Yoda's_C.0040D521
0040D513 | 8D85 AE224000 lea eax,dword ptr ss:[ebp+4022AE] ; 地址=0040D521
0040D519 | 50 push eax ; 这里用push+jmp的形式调用子函数
0040D51A | 8BC3 mov eax,ebx ; ebx=0040658A, ASCII "SHELL32.dll"
0040D51C | E9 48020000 jmp Yoda's_C.0040D769 ; 跳入子函数。功能是将eax处的字符串（这里是dll文件名）擦除
{
0040D769 /EB 04 jmp short Yoda's_C.0040D76F
0040D76B |C600 00 mov byte ptr ds:[eax],0
0040D76E |40 inc eax
0040D76F \8038 00 cmp byte ptr ds:[eax],0 ; 把刚刚解密出来的shell32.dll字符串擦除了
0040D772 ^ 75 F7 jnz short Yoda's_C.0040D76B
0040D774 C3 retn
}
0040D521 | 5B pop ebx ; 弹出dll句柄
0040D522 | 8B4E 08 mov ecx,dword ptr ds:[esi+8] ; 从后面可以看出，这是变形输入表的OriginalFirstThunk
0040D525 | 0BC9 or ecx,ecx
0040D527 | 75 03 jnz short Yoda's_C.0040D52C ; 不为0则进行处理，为0则找FirstThunk。本例非0
0040D529 | 8B4E 04 mov ecx,dword ptr ds:[esi+4] ; 从后面可以看出，这是变形输入表的FirstThunk
0040D52C | 038D 64254000 add ecx,dword ptr ss:[ebp+402564] ; RVA+ImageBaseAddress定位OriginalFirstThunk
0040D532 | 8B56 04 mov edx,dword ptr ds:[esi+4] ; FirstThunk
0040D535 0395 64254000 add edx,dword ptr ss:[ebp+402564] ; RVA+ImageBaseAddress定位
0040D53B | /E9 C3000000 jmp Yoda's_C.0040D603 ; 这里是一个大循环
0040D540 | |F701 00000080 test dword ptr ds:[ecx],80000000 ; 从这个特征值几乎可以确定[ecx]就是一个IMAGE_THUNK_DATA了，判断是by_NAME还是by_INDEX
0040D546 | |75 4B jnz short Yoda's_C.0040D593 ; 若IMAGE_ORDINAL_FLAG32则转向by_Index方式处理
0040D548 | |8B01 mov eax,dword ptr ds:[ecx] ; by_Name的处理
0040D54A | |83C0 02 add eax,2 ; 开始看到这里还以为是搞什么名堂，等循环了一遍才知道，eax+2是跳过IMAGE_IMPORT_BY_NAME结构的成员Hint，定位到Name成员，以解密出函数名。而这个eax来自[ecx] ，ecx来自[esi+8]，因此，[esi+8]就是OriginalFirstThunk了！
0040D54D | |0385 64254000 add eax,dword ptr ss:[ebp+402564] ; RVA+ImageBaseAddress定位待解密函数名称字符串的地址
0040D553 | |50 push eax ; 保存函数名地址
0040D554 | |E8 8BFFFFFF call Yoda's_C.0040D4E4 ; 就是前面用过的那个字符串解密函数，在这里是解密函数名
{
0040D4E4 56 push esi
0040D4E5 57 push edi
0040D4E6 8BF0 mov esi,eax
0040D4E8 8BF8 mov edi,eax
0040D4EA /AC lods byte ptr ds:[esi]
0040D4EB |C0C8 04 ror al,4 ; 简单地将每字节循环右移4位
0040D4EE |AA stos byte ptr es:[edi] ; 这里将解密后的字符回写
0040D4EF |803F 00 cmp byte ptr ds:[edi],0
0040D4F2 ^\75 F6 jnz short Yoda's_C.0040D4EA ; 没到字符串末尾就继续解密
0040D4F4 5F pop edi
0040D4F5 5E pop esi
0040D4F6 C3 retn
}
0040D559 | |58 pop eax ; 此时弹出的是解密后的函数名
0040D55A | |8BF8 mov edi,eax ; 地址保存
0040D55C | |52 push edx ; IAT待填充的地址
0040D55D | |51 push ecx ; FirstThunk
0040D55E | |50 push eax ; 参数2：lpProcName
0040D55F | |53 push ebx ; 参数1：hModule
0040D560 | |FF95 F4264000 call dword ptr ss:[ebp+4026F4] ; kernel32.GetProcAddress
0040D566 | |0BC0 or eax,eax
0040D568 | |75 07 jnz short Yoda's_C.0040D571 ; 成功则跳，否则game over
0040D56A | |59 pop ecx
0040D56B | |5A pop edx
0040D56C | |E9 AB000000 jmp Yoda's_C.0040D61C
0040D571 | |59 pop ecx ; FirstThunk
0040D572 | |5A pop edx ; IAT待填充的地址
0040D573 | |60 pushad
0040D574 | |F785 6C254000 04000000 test dword ptr ss:[ebp+40256C],4 ; 3C
0040D57E | |74 0E je short Yoda's_C.0040D58E
0040D580 | |8D85 1B234000 lea eax,dword ptr ss:[ebp+40231B] ; 取下面调用子函数后返回地址：0040D58E
0040D586 | |50 push eax ; 用push+jmp的形式调用子函数，这里压入子程序的返回地址
0040D587 | |8BC7 mov eax,edi ; edi=函数名地址
0040D589 | |E9 DB010000 jmp Yoda's_C.0040D769 ; 跳入子函数。功能是将eax处的字符串（这里是函数名）擦除，与上面擦除dll名字是同一函数
{
0040D769 /EB 04 jmp short Yoda's_C.0040D76F
0040D76B |C600 00 mov byte ptr ds:[eax],0
0040D76E |40 inc eax
0040D76F \8038 00 cmp byte ptr ds:[eax],0 ; 把刚刚解密出来的函数名称擦除了，即把IMAGE_IMPORT_BY_NAME的Name成员清0，只保留了Hint成员
0040D772 ^ 75 F7 jnz short Yoda's_C.0040D76B
0040D774 C3 retn
}
0040D58E | |61 popad ; 调用子函数后返回到这里
0040D58F | |8902 mov dword ptr ds:[edx],eax ; 填充IAT(by_Name的处理)
0040D591 | |EB 19 jmp short Yoda's_C.0040D5AC ; 跳
0040D593 | |52 push edx ; by_Index的处理（本例中未执行到）
0040D594 | |51 push ecx
0040D595 | |8B01 mov eax,dword ptr ds:[ecx]
0040D597 | |2D 00000080 sub eax,80000000
0040D59C | |50 push eax
0040D59D | |53 push ebx
0040D59E | |FF95 F4264000 call dword ptr ss:[ebp+4026F4] ; kernel32.GetProcAddress
0040D5A4 | |85C0 test eax,eax
0040D5A6 | |74 74 je short Yoda's_C.0040D61C
0040D5A8 | |59 pop ecx
0040D5A9 | |5A pop edx
0040D5AA | |8902 mov dword ptr ds:[edx],eax ; 填充IAT
跳到了这里：
0040D5AC | |F785 6C254000 20000000 test dword ptr ss:[ebp+40256C],20 ; 3C 两种方式分别填充IAT后都转到这里
0040D5B6 | |74 45 je short Yoda's_C.0040D5FD ; =20则跳到下一个
0040D5B8 | |83BD 78254000 00 cmp dword ptr ss:[ebp+402578],0 ; 1
0040D5BF | |74 14 je short Yoda's_C.0040D5D5
0040D5C1 | |81FB 00000070 cmp ebx,70000000 ; dll句柄(ebx=7D590000 (shell32.7D590000))
0040D5C7 | |72 08 jb short Yoda's_C.0040D5D1
0040D5C9 | |81FB FFFFFF77 cmp ebx,77FFFFFF ; user32.wsprintfA的句柄=77D10000
0040D5CF /| |76 0E jbe short Yoda's_C.0040D5DF ; user32.dll的函数在此跳
0040D5D1 ||/|EB 2A jmp short Yoda's_C.0040D5FD ; 跳
0040D5D3 ||||EB 0A jmp short Yoda's_C.0040D5DF
0040D5D5 ||||81FB 00000080 cmp ebx,80000000
0040D5DB ||||73 02 jnb short Yoda's_C.0040D5DF
0040D5DD ||||EB 1E jmp short Yoda's_C.0040D5FD
0040D5DF \|||57 push edi ; 如果我们在处理完第1个dll后在0040D619处F4自动处理完剩余dll的函数，则看不到这里的关键处理，所以要有耐心，把隐藏在中间的步骤看清楚。
0040D5E0 |||56 push esi
0040D5E1 |||8DBD D2274000 lea edi,dword ptr ss:[ebp+4027D2] ; 地址=0040DA45，buffer，此时保存的是堆地址
0040D5E7 |||8B77 04 mov esi,dword ptr ds:[edi+4] ; buffer+4处是前面保存的第2份堆地址001431E0
0040D5EA |||8932 mov dword ptr ds:[edx],esi ; 将刚刚填充的函数地址又改为申请的堆地址
0040D5EC |||2BC6 sub eax,esi ; 从下面几行得知此2句sub是计算跳转的相对距离
0040D5EE |||83E8 05 sub eax,5 ; -5是因为jmp指令E9XXXXXXXX本身占5字节
0040D5F1 |||C606 E9 mov byte ptr ds:[esi],0E9 ; 前面申请的堆在这里派上用场。0E9是jmp指令
0040D5F4 |||8946 01 mov dword ptr ds:[esi+1],eax ; 填上jmp的目标地址（相对距离）。对IAT做手脚，这样，调用函数就成了对堆中某地址的调用，而堆中的该地址是5个字节的jmp指令到正确的函数地址。
0040D5F7 |||8347 04 05 add dword ptr ds:[edi+4],5 ; buffer+4处的内容改为指向堆地址第6字节处，即堆中已填充jmp指令的后面，准备下一轮填充下一个函数的jmp指令，这样循环后移填充直到所有函数处理完毕。这里就明白了前面为什么申请的堆空间大小＝API个数*5字节。实际上没用完，因为已经有部分函数地址被正确填充到了IAT，这里填充的只是函数地址位于70000000和77FFFFFF之间的函数。
0040D5FB |||5E pop esi
0040D5FC |||5F pop edi
0040D5FD |\|83C1 04 add ecx,4 ; 现在可以知道是取下一个函数指针
0040D600 | |83C2 04 add edx,4 ; IAT下移一项
0040D603 | \8339 00 cmp dword ptr ds:[ecx],0 ; 函数指针是否为空
0040D606 |^ 0F85 34FFFFFF jnz Yoda's_C.0040D540 ; 不为空就继续循环处理
0040D60C | 83C6 0C add esi,0C ; 否则取下一个IID
0040D60F | 837E 04 00 cmp dword ptr ds:[esi+4],0 ; 输入表是否已到末尾
0040D613 \^ 0F85 B4FEFFFF jnz Yoda's_C.0040D4CD ; 否，则返回去继续处理下一个dll的函数
0040D619 33C0 xor eax,eax
0040D61B 40 inc eax
0040D61C 83F8 01 cmp eax,1 ; 正常填充完毕eax才等于1
0040D61F 74 02 je short Yoda's_C.0040D623 ; 正常填充完毕则跳
0040D621 61 popad
0040D622 C3 retn ; 否则game over
以上代码完成了IAT填充，开始进行下一步工作
跳到了这里：
0040D623 F785 6C254000 02000000 test dword ptr ss:[ebp+40256C],2 ; 3C
0040D62D /74 18 je short Yoda's_C.0040D647 ; 跳
0040D62F |8BBD 64254000 mov edi,dword ptr ss:[ebp+402564]
0040D635 |037F 3C add edi,dword ptr ds:[edi+3C]
0040D638 |8B4F 54 mov ecx,dword ptr ds:[edi+54]
0040D63B |8BB5 64254000 mov esi,dword ptr ss:[ebp+402564]
0040D641 |C606 00 mov byte ptr ds:[esi],0
0040D644 |46 inc esi
0040D645 ^|E2 FA loopd short Yoda's_C.0040D641
0040D647 \8D85 ED1D4000 lea eax,dword ptr ss:[ebp+401DED] ; 地址=0040D060 (offset Yoda's_C.<ModuleEntryPoint>)
0040D64D B9 2A060000 mov ecx,62A
0040D652 EB 01 jmp short Yoda's_C.0040D655 ; 跳
0040D654 - E9 E8B6FCFF jmp 003D8D41 ; 这次没用C2而是用E9花了
0040D659 FFEB jmp far ebx ; 非法使用寄存器（用FF隐藏了调用子函数后返回的地址）
0040D65B 01C7 add edi,eax
拨开迷雾见太阳，跳到了这里：
0040D655 E8 B6FCFFFF call Yoda's_C.0040D310 ; 原来是隐藏了这个call，这地址好熟悉，对了，就是前面执行过2次的校验和函数！
{
0040D310 8BF8 mov edi,eax
0040D312 33C0 xor eax,eax
0040D314 33DB xor ebx,ebx
0040D316 33D2 xor edx,edx
0040D318 8A07 mov al,byte ptr ds:[edi] ; 又来自校验壳代码
0040D31A F7E2 mul edx
0040D31C 03D8 add ebx,eax
0040D31E 42 inc edx
0040D31F 47 inc edi
0040D320 ^ E2 F6 loopd short Yoda's_C.0040D318
0040D322 93 xchg eax,ebx
0040D323 C3 retn
}
0040D65A /EB 01 jmp short Yoda's_C.0040D65D ; 呵呵，这个指令就是被拆开隐藏在0040D659和0040D65B那两句代码中的。
0040D65C |C7 ??? ; 未知命令
0040D65D \8B9D 74254000 mov ebx,dword ptr ss:[ebp+402574] ; ss:[ebp+402574]=0002494C，这是什么东东？对了，就是前面保存的62Ah字节壳代码的校验和
0040D663 33C3 xor eax,ebx ; 这里来比较文件是否被改动过
0040D665 /74 08 je short Yoda's_C.0040D66F ; 校验相符则跳
0040D667 |EB 01 jmp short Yoda's_C.0040D66A ; 否则？game over？呵呵目标地址又藏起来了，懒得理它！
跳到了这里：
0040D66F 8DBD 17244000 lea edi,dword ptr ss:[ebp+402417] ; 地址=0040D68A，刚刚正是自校验从壳入口到这个地址之间代码的校验和，40D060+62A=40D68A
0040D675 8BF7 mov esi,edi
0040D677 B9 DF000000 mov ecx,0DF ; 0040D68A+DF=0040D769
0040D67C 33DB xor ebx,ebx
0040D67E AC lods byte ptr ds:[esi] ; esi=0040D68A
0040D67F 34 79 xor al,79
0040D681 2AC3 sub al,bl
0040D683 C0C0 02 rol al,2
0040D686 AA stos byte ptr es:[edi] ; 又是解密代码。这次是将什么代码解密出来呢？edi=0040D68A往下看
0040D687 43 inc ebx
0040D688 ^ E2 F4 loopd short Yoda's_C.0040D67E
0040D68A 1A1B sbb bl,byte ptr ds:[ebx] ; edi指向的是解密紧接着的这段代码
。。。。。。
解密之后就出现下面的代码了：
0040D68A 8D85 A4274000 lea eax,dword ptr ss:[ebp+4027A4] ; "IsDebuggerPresent"出现了！
0040D690 50 push eax
0040D691 FFB5 05274000 push dword ptr ss:[ebp+402705] ; Kernel32.dll句柄
0040D697 FF95 F4264000 call dword ptr ss:[ebp+4026F4] ; GetProcAddress获取IsDebuggerPresent函数地址
0040D69D 0BC0 or eax,eax ; eax=7C813133 (kernel32.IsDebuggerPresent)
0040D69F /74 08 je short Yoda's_C.0040D6A9 ; 敢不敢进雷区？先试一趟好了
0040D6A1 |FFD0 call eax ; kernel32.IsDebuggerPresent
0040D6A3 |0BC0 or eax,eax ; eax=00000000，也没怎么着嘛，原来我隐藏了OD，呵呵。
0040D6A5 |74 02 je short Yoda's_C.0040D6A9 ; 顺利过这一道关！看来要接近尾声了
0040D6A7 |61 popad
0040D6A8 |C3 retn
0040D6A9 \F785 6C254000 01000000 test dword ptr ss:[ebp+40256C],1 ; 3C
0040D6B3 /74 4F je short Yoda's_C.0040D704 ; 跳
跳到了这里：
0040D704 8D85 CB244000 lea eax,dword ptr ss:[ebp+4024CB] ; 地址=0040D73E，又是这种push+retn方式跳过子函数，没新意
0040D70A 50 push eax
0040D70B C3 retn ; 转移战场
转移到了这里：
0040D73E 32C0 xor al,al
0040D740 8DBD ED1D4000 lea edi,dword ptr ss:[ebp+401DED] ; 地址=0040D060 (offset Yoda's_C.<ModuleEntryPoint>)
0040D746 B9 AC060000 mov ecx,6AC ; 40D060+6AC=0040D70C ! 即刚刚才转移前的地点
0040D74B /AA stos byte ptr es:[edi] ; 自毁壳代码！把转移之前的代码全部清除！
0040D74C ^\E2 FD loopd short Yoda's_C.0040D74B
0040D74E 8DBD F6244000 lea edi,dword ptr ss:[ebp+4024F6] ; 地址=0040D769
0040D754 B9 C0020000 mov ecx,2C0 ; 0040D769+2C0=0040DA29
0040D759 AA stos byte ptr es:[edi] ; 将0040D769之后2C0字节的内容全部清0
0040D75A ^ E2 FD loopd short Yoda's_C.0040D759
0040D75C 61 popad
0040D75D 50 push eax ; 0040D70C，前面的第二个悬念终于解开了：之前保存这个数就是为了popad后eax能很隐蔽地获得该值。同样也看到了ebx被改成了98008021这个神秘数据，第一个悬念也初露端倪
0040D75E 33C0 xor eax,eax
0040D760 64:FF30 push dword ptr fs:[eax]
0040D763 64:8920 mov dword ptr fs:[eax],esp ; 原来是安装SEH，0040D70C就是回调函数的入口，也难怪自清除壳代码时保留了那部分代码，赶紧去下断。
0040D766 EB 01 jmp short Yoda's_C.0040D769
0040D769 0000 add byte ptr ds:[eax],al ; 写0地址人为触发异常
进入到了系统领空，Alt+F9到断点处：
0040D70F 57 push edi
0040D710 8B45 10 mov eax,dword ptr ss:[ebp+10] ; CONTEXT
0040D713 8BB8 C4000000 mov edi,dword ptr ds:[eax+C4] ; regEsp
0040D719 FF37 push dword ptr ds:[edi] ; 下一个SEH记录指针
0040D71B 33FF xor edi,edi
0040D71D 64:8F07 pop dword ptr fs:[edi] ; 恢复下一个SEH
0040D720 8380 C4000000 08 add dword ptr ds:[eax+C4],8
0040D727 8BB8 A4000000 mov edi,dword ptr ds:[eax+A4] ; regEbx=98008021
0040D72D C1C7 07 rol edi,7 ; 解密后=004010CC
0040D730 89B8 B8000000 mov dword ptr ds:[eax+B8],edi ; regEip修改变004010CC，彻底解开了第一个悬念，这就是OEP，通过这种隐蔽的方式跳转到OEP。004010CC处下断
0040D736 B8 00000000 mov eax,0
0040D73B 5F pop edi
0040D73C C9 leave
0040D73D C3 retn
处理完回调函数后，进入了系统领空，Alt+F9回到用户领空：
004010CC 55 push ebp ; OEP
004010CD 8BEC mov ebp,esp
004010CF 83EC 44 sub esp,44
004010D2 56 push esi
004010D3 FF15 E0634000 call dword ptr ds:[4063E0] ; kernel32.GetCommandLineA
004010D9 8BF0 mov esi,eax
004010DB 8A00 mov al,byte ptr ds:[eax]
004010DD 3C 22 cmp al,22
004010DF 75 13 jnz short Yoda's_C.004010F4
到达OEP，取消断点，用OD的OllyDump插件脱壳，可直接运行；如果用LordPE脱壳，则要修正映像大小，因为壳将映像大小由F000改成了1000，所以要修正回来，并且需要修复输入表（用ImportREC即可）。
小结：
这个壳是一个比较早期的壳，做了一些反调试和反脱壳措施，但强度很弱。具体做了以下几点：
1、反调试方面，一是用了简单的C2和E9来混淆代码，二是用了一些简单的技巧来隐藏指令的跳转，如用push+retn的形式转移流程；三是做壳代码动态解密，边执行边解密，而不是一次性将代码全部解密；四是用了一个IsDebuggerPresent函数检测是否被调试，很轻易的能被避开检测。
2、防程序修改方面，做了两次代码自校验，而且故意将计算与比较放在比较远的位置，但对于DA41字节的校验，只要在内存中修改而不保存，或保存文件的同时将校验和也修改则检测不出改动过；而对于62A字节的校验，两次计算都是检测同一段内存中的代码，只要在第一次计算之前修改，也检测不出来。
3、在跳往OEP方面，做的比较隐蔽。一是很早就将OEP加密，再通过修改堆栈的方法，使得popad时很隐蔽的就传给了寄存器ebx，并且是在“暗桩”（SEH回调函数）中用1个指令解密就立即修改EIP指针，如果稍不注意就会跑飞了。
4、输入表处理方面，加壳时破坏了原输入表，将输入表指向了一个壳中的伪输入表，伪输入表中只保留了1个IID且除NAME和FIRSTTHUNK外的其他3个成员为空，IAT只有两个函数，即kernel32.LoadLibraryA和kernel32.GetProcAddress，“KERNEL32.dll”被改成了“KeRnEl32.dLl”（API对大小写敏感）导致无效，壳在运行时是从另外的地方获得“Kernel32.dll”这个名字再通过LoadLibraryA动态调入Kernel32.dll，然后通过GetProcAddress获得壳代码运行时需要的一些函数。而对于源程序运行时需要的输入表，则是在壳的另外一个地方（地址=0040D7EF）保存了一张真正的输入表，但也是变形过了的，每个IID对应一个dll，并且压缩成3个成员：第一个是成员Name，第二个FirstThunk，第三个是OriginalFirstThunk。加壳时，对只是对源程序的dll名称和函数名称加密，并没有删除或转移位置，壳中变形的输入表分别指向这些加密了的名称，FirstThunk指向的函数地址都被篡改。壳在运行时，先根据变形输入表找到加密的dll，解密后动态调入dll，获得句柄，随即根据判断标志将dll名称擦除。在填充IAT时，把部分函数地址正确填充，而函数地址在70000000和77FFFFFF之间的函数都作了处理，IAT中填充的是壳申请的堆地址，而将跳转到正确函数地址的jmp指令放入相应的堆地址中，用lordPE脱壳时堆是无法dump出来的，因此，用lordPE脱壳后的程序运行时会报内存读写冲突的错误信息，需要修复输入表，而OD的OllyDump插件则能很好地解决这个问题。
附上带壳的记事本程序：
- 标 题：Yoda's Crypter v1.2脱壳分析
- 作 者：goodlucky
- 时 间：2010-04-19 00:12:39
- 链 接：http://bbs.pediy.com/showthread.php?t=111252