VB的编译有两种方式,一种是P-Code方式,一种是本机代码。P_Code方式是VB从早期版本保留下来的，也是比较难逆向的一种。而本机代码方式编译的程序已经和VC很接近了。这里只探讨以本机代码方式编译的程序。由于微软在VB的实现方面的资料很少，使人觉得VB的逆向比较难。其实掌握一些规律，VB的程序还是很容易入门的。
浅谈VB6逆向工程
1. 从简单变量的实现开始
一个VB简单变量的表示至少需要12个字节。通常前2个字节是表示类型信息的。
从第5个字节到第8个字节并不总是使用到，实际上很少被使用。我们不妨先叫它
辅助类型信息。从第9个字节开始就是真正的变量的值了。这里有可能存储一个指针
值，也可能是数据，具体是什么取决于变量类型。
另一个值得注意的事实是VB的内存是以4个字节对齐的。即使你使用一个字节，
那至少也要4个字节来表示。而且编译器只初始化它需要的那些字节，剩余的字节
可能是随机数据。下面我们将会看到这些。
想弄明白编译器在内部怎么实现的，最好的方法就是编一段程序跟踪运行看看。
我编写的代码如下：
Dim a, i As Byte
Dim b, j As Integer
Dim c, k As Long
Dim d, l As Boolean
Dim e, m As String
Dim f, n As Date
Dim g, o As Double
Dim h, p As Single
a = &H30
b = 330
c = 66000
d = True
e = “hello”
f = Now
g = 3.1415
h = 1.27
i = a
j = b
k = c
l = d
m = e
n = f
o = g
p = h
这段代码在VB的默认设置（速度优化）下编译。然后用od反汇编出来如下：
去掉了部分无关内容，其余的我在这段代码的实现里做了注释：
00401B02 MOV ESI,DWORD PTR DS:[; MSVBVM60.__vbaVarMove
00401B08 XOR EDI,EDI
00401B0A MOV EBX,2
00401B0F MOV DWORD PTR SS:][EBP-DC],EDI
00401B15 LEA EDX,DWORD PTR SS:[EBP-DC]
00401B1B LEA ECX,DWORD PTR SS:[EBP-4C]
00401B1E MOV DWORD PTR SS:[EBP-28],EDI
00401B21 MOV DWORD PTR SS:[EBP-4C],EDI
00401B24 MOV DWORD PTR SS:[EBP-5C],EDI
00401B27 MOV DWORD PTR SS:[EBP-6C],EDI
00401B2A MOV DWORD PTR SS:[EBP-7C],EDI
00401B2D MOV DWORD PTR SS:[EBP-8C],EDI
00401B33 MOV DWORD PTR SS:[EBP-9C],EDI
00401B39 MOV DWORD PTR SS:[EBP-AC],EDI
00401B3F MOV DWORD PTR SS:[EBP-BC],EDI
00401B45 MOV DWORD PTR SS:[EBP-CC],EDI
00401B4B MOV DWORD PTR SS:[EBP-D4],30 //30h = &H30
00401B55 MOV DWORD PTR SS:[EBP-DC],EBX //EBX = 2: integer型
00401B5B CALL ESI ;
**** a =&H30 即[ebp-4c]
00401B5D LEA EDX,DWORD PTR SS:[EBP-DC]
00401B63 LEA ECX,DWORD PTR SS:[EBP-5C] //变量b
00401B66 MOV DWORD PTR SS:[EBP-D4],14A //14Ah = 330
00401B70 MOV DWORD PTR SS:[EBP-DC],EBX //EBX = 2: integer型
00401B76 CALL ESI
**** b = 330 即[ebp-5c]
00401B78 LEA EDX,DWORD PTR SS:[EBP-DC]
00401B7E LEA ECX,DWORD PTR SS:[EBP-6C]
00401B81 MOV DWORD PTR SS:[EBP-D4],101D0 //101D0 = 66000
00401B8B MOV DWORD PTR SS:[EBP-DC],3 //3:long型
00401B95 CALL ESI
**** c = 66000 即[ebp-6c]
00401B97 LEA EDX,DWORD PTR SS:[EBP-DC]
00401B9D LEA ECX,DWORD PTR SS:[EBP-7C]
00401BA0 MOV DWORD PTR SS:[EBP-D4],-1 //-1 TRUE
00401BAA MOV DWORD PTR SS:[EBP-DC],0B //12:boolean型
00401BB4 CALL ESI
**** d = TRUE 即[ebp-7c]
00401BB6 LEA EDX,DWORD PTR SS:[EBP-DC]
00401BBC LEA ECX,DWORD PTR SS:[EBP-8C]
00401BC2 MOV DWORD PTR SS:[EBP-D4],工程1.00401948 ; UNICODE “hello” //”hello”
00401BCC MOV DWORD PTR SS:[EBP-DC],8 //8:string型
00401BD6 CALL DWORD PTR DS:[; MSVBVM60.__vbaVarCopy
**** e = “hello” 即][ebp-8c]
00401BDC LEA EAX,DWORD PTR SS:[EBP-CC]
00401BE2 PUSH EAX
00401BE3 CALL DWORD PTR DS:[] //Now
00401BE9 LEA EDX,DWORD PTR SS:[EBP-CC] //Now
00401BEF LEA ECX,DWORD PTR SS:[EBP-9C]
00401BF5 CALL ESI
**** f = Now 即[ebp-9c]
00401BF7 MOV EBX,5
00401BFC LEA EDX,DWORD PTR SS:[EBP-DC]
00401C02 LEA ECX,DWORD PTR SS:[EBP-AC]
00401C08 MOV DWORD PTR SS:[EBP-D4],C083126F
00401C12 MOV DWORD PTR SS:[EBP-D0],400921CA //3.1415
00401C1C MOV DWORD PTR SS:[EBP-DC],EBX //EBX = 5 :double型
00401C22 CALL ESI
**** g = 3.1415 即[ebp-ac]
00401C24 LEA EDX,DWORD PTR SS:[EBP-DC]
00401C2A LEA ECX,DWORD PTR SS:[EBP-BC]
00401C30 MOV DWORD PTR SS:[EBP-D4],851EB852
00401C3A MOV DWORD PTR SS:[EBP-D0],3FF451EB //1.27
00401C44 MOV DWORD PTR SS:[EBP-DC],EBX //EBX = 5 :double型
00401C4A CALL ESI
// h = 1.27
00401C4C LEA ECX,DWORD PTR SS:[EBP-4C]
00401C4F PUSH ECX
00401C50 CALL DWORD PTR DS:[; MSVBVM60.__vbaUI1Var
//取byte, al中
**** i = a
00401C56 LEA EDX,DWORD PTR SS:][EBP-5C]
00401C59 PUSH EDX
00401C5A CALL DWORD PTR DS:[; MSVBVM60.__vbaI2Var
//取integer, ax中
**** j = b
00401C60 LEA EAX,DWORD PTR SS:][EBP-6C]
00401C63 PUSH EAX
00401C64 CALL DWORD PTR DS:[; MSVBVM60.__vbaI4Var
//取long, eax中
**** k = c
00401C6A LEA ECX,DWORD PTR SS:][EBP-7C]
00401C6D PUSH ECX
00401C6E CALL DWORD PTR DS:[; MSVBVM60.__vbaBoolVar
//取boolean, ax中
**** l = d
00401C74 LEA EDX,DWORD PTR SS:][EBP-8C]
00401C7A PUSH EDX
00401C7B CALL DWORD PTR DS:[; MSVBVM60.__vbaStrVarCopy
//取string, eax中是地址
**** m = e
00401C81 MOV EDX,EAX
00401C83 LEA ECX,DWORD PTR SS:][EBP-28]
00401C86 CALL DWORD PTR DS:[; MSVBVM60.__vbaStrMove
00401C8C LEA EAX,DWORD PTR SS:][EBP-9C]
00401C92 PUSH EAX
00401C93 CALL DWORD PTR DS:[; MSVBVM60.__vbaDateVar
//取date, 浮点栈中
**** n = f
00401C99 LEA ECX,DWORD PTR SS:][EBP-AC]
00401C9F FSTP ST
00401CA1 PUSH ECX
00401CA2 CALL DWORD PTR DS:[; MSVBVM60.__vbaR8Var
//取double, 浮点栈中
**** o = g
00401CA8 LEA EDX,DWORD PTR SS:][EBP-BC]
00401CAE FSTP ST
00401CB0 PUSH EDX
00401CB1 CALL DWORD PTR DS:; MSVBVM60.__vbaR4Var
00401CB7 FSTP ST
//取single, 浮点栈中
**** p = h
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
先总结一下：byte 和 integer一样，内部都是使用integer类型表示，single和double一样，
内部都是使用double类型表示。date占用8个字节。boolean类型占用2个字节&HFFFF表示TRUE,而
0表示FALSE.
这些简单变量在内存中的表示如下：前4个字节含有变量类型，接着4个字节(意义还不清楚),
我们不妨先叫他辅助类型信息，过了这8个字节就是真正的变量数据了。
如变量a的内存表示如下：63F3C4 : 02 00 00 00
63F3C8 : 00 00 00 00
63F3CC : 30 00 00 00
可以看到，63F3CC处是真正的变量值。如果是字符串，这个位置可以看到一个指针。
简单变量里没有提到的类型是Currency，Decimal，这些你可以自己实际观察一下。
关于简单变量就总结这些，不知道你看懂了没有。我没有办法把机器搬上来让你看。所以还是
那句话:如果你想弄明白我所讲的到底是怎么一回事，就把上面那段程序编译一下，然后用ollydbg
跟踪一下看看。
在本文即将结束时要提到的一个事实是:VB并不是强类型语言。例如你可以把一个boolean类型
的变量赋值给一个整数，然后再打印出这个整数的值，你可以看到TRUE的输出为－1，而FALSE的输
出为0。当然在你决定这样做的时候你要保证两个变量所占内存空间大小一样或者被赋值的变量的
空间要大于所赋值的变量的空间。否则你可能会得到一个溢出错误。你可以试试把date类型的变量
赋值给一个integer类型的变量
2. 复杂变量的内部实现
这里所提到的复杂变量(我自己的叫法 )，是指枚举，数组和记录类型的变量。
1) 枚举类型的实现
先定义一个枚举类型如下：
Enum myweek
sun
mon
tues
wednes
thurs
fri
satur
End Enum
然后再编写一段使用枚举类型的代码：
Dim a As myweek
Dim b As Integer
a = sun
b = a
Print b
默认设置编译这段代码，接着我们看看编译器生成了什么。
; 37 : Dim a As myweek
; 38 : Dim b As Integer
; 39 :
; 40 : a = sun
; 41 : b = a
xor ecx, ecx // a = sun ,即 a = 0
call DWORD PTR __imp_@__vbaI2I4 // b = a
; 42 : Print b
push eax // b
push esi
push OFFSET FLAT:___vba@006255A0
call DWORD PTR __imp____vbaPrintObj //Print
***************************************************
可以看出，枚举类型在代码里是直接用常量数值代替的。
2) 数组类型的实现
数组的概念比较复杂，为了研究方便，这里只讨论一维数组，并且不是嵌套的。
先看看静态数组的定义与实现。
代码：
Dim a(3 To 6) As Integer
反汇编代码：
004019FF PUSH 2
00401A01 LEA EAX,DWORD PTR SS:[EBP-2C] // 数组变量
00401A04 XOR ESI,ESI
00401A06 PUSH 工程1.00401694 // 指向代码段
00401A0B PUSH EAX
00401A0C MOV DWORD PTR SS:[EBP-34],ESI
00401A0F CALL DWORD PTR DS:[] // 构造一个数组
指行到这里时看[ebp-2c]的内容：
0063F3E4 01 00 92 00 02 00 00 00 .?…
0063F3EC 00 00 00 00 C0 0F 51 00 ….?Q.
0063F3F4 04 00 00 00 03 00 00 00 ……
这些数据除了63F3F0处的地址是__vbaAryConstruct2函数填进去的，其余的都是从
401694处拷贝过来的。因此__vbaAryConstruct2函数的作用可以这样理解：先从401694
处拷贝24个字节到ebp-2c处，然后分配一块空间，把指向新分配的空间的指针填到63F3F0
处。
那么上面这些数据到底是什么意思呢？看下面的分析.
00401A18 PUSH 工程1.00401A30 //指向退出地址
00401A1D LEA EDX,DWORD PTR SS:[EBP-34]
00401A20 LEA ECX,DWORD PTR SS:[EBP-2C] //要释放的数组变量
00401A23 PUSH EDX
00401A24 PUSH 0
00401A26 MOV DWORD PTR SS:[EBP-34],ECX
00401A29 CALL DWORD PTR DS:[] // 释放一个数组
为了弄清楚上面提到的那些内存数据的含义，我分别定义了不同大小不同类型的数组来比较，
下面是dump出来的典型数据：
Dim a(3 To 6)
0063F3E4 01 00 92 08 10 00 00 00 .?…
0063F3EC 00 00 00 00 2C 01 41 00 ….,A.
0063F3F4 04 00 00 00 03 00 00 00 ……
Dim a(3 To 6) As String
0063F3E4 01 00 92 01 04 00 00 00 .?…
0063F3EC 00 00 00 00 C0 0F 51 00 ….?Q.
0063F3F4 04 00 00 00 03 00 00 00 ……
Dim a(3 To 6) As Integer
0063F3E4 01 00 92 00 02 00 00 00 .?…
0063F3EC 00 00 00 00 C0 0F 51 00 ….?Q.
0063F3F4 04 00 00 00 03 00 00 00 ……
我总结的数组变量内存数据的说明：
0063F3E4 处的两个字节代表数组的维数
0063F3E6 处的一个字节 92 代表静态数组
0063F3E7 处的一个字节随着不同类型的变量有不同的变化。
08 : 变体类型
01 : String
00 : Integer,byte,long,single,double,date
0063F3E8 处的两个字节表示一个数组元素所占的内存空间字节数。
0063F3EC 处的4个字节总是0，可能是为了对齐。
0063F3F0 处的两个字节代表分配的空间的地址指针，即数组数据。
0063F3F4 处的两个字节代表静态数组元素的个数。
0063F3F8 处的两个字节代表数组的起始下标。
上面大概的对数组变量的数据做了说明，为了验证一下，再看一个3维数组的定义:
Dim a(1 To 2, 3 To 5, 6 To 9) As Integer
0063F3D4 03 00 92 00 02 00 00 00 .?…
0063F3DC 00 00 00 00 C0 0F 51 00 ….?Q.
0063F3E4 04 00 00 00 06 00 00 00 ……
0063F3EC 03 00 00 00 03 00 00 00 ……
0063F3F4 02 00 00 00 01 00 00 00 ……
可以看出，静态数组的信息在编译时就被编码到了代码段里。
静态数组的构造用 __vbaAryConstruct2
静态数组的释放用 __vbaAryDestruct
///////////////////////////////////////////////////////////
动态数组又是怎样实现的呢？
代码:
Dim a() As Date
ReDim a(2 To 5)
反汇编代码:
004019CF PUSH 2 //起始下标
004019D1 PUSH 5 //结束下标
004019D3 PUSH 1 //数组维数
004019D5 LEA EAX,DWORD PTR SS:[EBP-18]
004019D8 PUSH 7 //变量类型
004019DA PUSH EAX //我们重定义的数组变量
004019DB XOR ESI,ESI
004019DD PUSH 8 //数组元素所占内存空间的字节数
004019DF PUSH 80 //动态数组标记
004019E4 MOV DWORD PTR SS:[EBP-18],ESI
004019E7 CALL DWORD PTR DS:[] // ReDim
004019ED ADD ESP,1C
004019F0 MOV DWORD PTR SS:[EBP-4],ESI
004019F3 PUSH 工程1.00401A05
004019F8 LEA ECX,DWORD PTR SS:[EBP-18] //数组变量
004019FB PUSH ECX
004019FC PUSH 0
004019FE CALL DWORD PTR DS:[] //释放数组
当执行到 004019ED 时,我们查看[ebp-18]处的内存数据,可以看到是
0063F3F8 D0 0F 51 00 ?Q.豇
这是一个指针,我们接着 follow dword in dump,可以看到数据如下:
00510FD0 01 00 80 00 08 00 00 00 .€.…
00510FD8 00 00 00 00 2C 01 41 00 ….,A.
00510FE0 04 00 00 00 02 00 00 00 ……
这个结构和静态数组的结构没有什么不同! ^_^
同时也可以看出,动态数组是动态分配的,这和静态数组信息被编译到代码段里不同。
总结:
动态数组的ReDim(重定义)用 __vbaRedim (注:这是可变参数的函数)
动态数组的释放用 __vbaAryDestruct
///////////////////////////////////////////////////////////
再看一下常用的数组操作:
先看两个函数,Lbound和Ubound。它们的实现分别如下：
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
__vbaLbound ;函数 Lbound ,取数组下标下界
LEA EAX,DWORD PTR SS:[EBP-2C] ;参数1,数组
PUSH EAX
PUSH 1 ;参数2,数组维数
CALL DWORD PTR DS:[; MSVBVM60.__vbaLbound
;结果在eax中返回
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
__vbaUbound ;函数 Ubound ,取数组下标上界
LEA ECX,DWORD PTR SS:][EBP-2C] ;参数1,数组
PUSH ECX
PUSH 1 ;参数2,数组维数
CALL DWORD PTR DS:[;MSVBVM60.__vbaUbound
;结果在eax中返回
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
这两个函数再操作动态数组时常使用，这里先记住他们的实现方法。
还有一个常使用的函数：Erase ,这个函数用来重新初始化静态数组的元素，或者
释放动态数组的存储空间。
LEA EAX,DWORD PTR SS:][EBP-18] ;数组变量的地址
PUSH EAX
PUSH EDI ;0
CALL DWORD PTR DS:[] ;函数Erase
下面编写一段简单的代码分析一下:
Dim a() As Integer
ReDim a(2 To 5)
a(2) = &HAA
Erase a
Dim b(1 To 3) As Integer
b(1) = &H55
Erase b
反汇编代码如下:
00401A4F PUSH 2
00401A51 LEA EAX,DWORD PTR SS:[EBP-30]
00401A54 XOR EDI,EDI
00401A56 PUSH 工程1.004016B8
00401A5B PUSH EAX
00401A5C MOV DWORD PTR SS:[EBP-18],EDI
00401A5F MOV DWORD PTR SS:[EBP-38],EDI
00401A62 CALL DWORD PTR DS:[]
/////////////////////////////////////上面这段是 Dim b(1 To 3) As Integer
00401A68 PUSH 2
00401A6A PUSH 5
00401A6C PUSH 1
00401A6E LEA ECX,DWORD PTR SS:[EBP-18]
00401A71 PUSH 2
00401A73 PUSH ECX
00401A74 PUSH 2
00401A76 PUSH 80
00401A7B CALL DWORD PTR DS:[]
//////////////////////////////////////上面这段是 Dim a() As Integer
////////////////////////////////////// ReDim a(2 To 5)
00401A81 MOV ECX,DWORD PTR SS:[EBP-18]
00401A84 ADD ESP,1C
00401A87 CMP ECX,EDI
00401A89 JE SHORT 工程1.00401AB0
00401A8B CMP WORD PTR DS:[ECX],1
00401A8F JNZ SHORT 工程1.00401AB0
00401A91 MOV EDX,DWORD PTR DS:[ECX+14] //取出下标
00401A94 MOV EAX,DWORD PTR DS:[ECX+10]
00401A97 MOV ESI,2
00401A9C SUB ESI,EDX
00401A9E CMP ESI,EAX
00401AA0 JB SHORT 工程1.00401AAB
00401AA2 CALL DWORD PTR DS:[]
00401AA8 MOV ECX,DWORD PTR SS:[EBP-18]
00401AAB LEA EAX,DWORD PTR DS:[ESI+ESI] //乘以2,即整数所占存储空间
00401AAE JMP SHORT 工程1.00401AB9
00401AB0 CALL DWORD PTR DS:[]
00401AB6 MOV ECX,DWORD PTR SS:[EBP-18]
////////////////////////////////////////上面这段包含了对生成的动态数组的检验
00401AB9 MOV EDX,DWORD PTR DS:[ECX+C] //取出变量a的值地址
00401ABC MOV ESI,DWORD PTR DS:[]
00401AC2 MOV WORD PTR DS:[EDX+EAX],0AA //对第一个元素赋值
////////////////////////////////////////到这里是 a(2) = &HAA
00401AC8 LEA EAX,DWORD PTR SS:[EBP-18]
00401ACB PUSH EAX
00401ACC PUSH EDI
00401ACD CALL ESI
////////////////////////////////////////到这里是 Erase a
00401ACF MOV ECX,DWORD PTR SS:[EBP-24]//取得变量b的值地址
00401AD2 LEA EAX,DWORD PTR SS:[EBP-38]
00401AD5 LEA EDX,DWORD PTR SS:[EBP-30]
00401AD8 PUSH EAX
00401AD9 MOV WORD PTR DS:[ECX],55
////////////////////////////////////////到这里是 b(1) = &H55
00401ADE PUSH EDI
00401ADF MOV DWORD PTR SS:[EBP-38],EDX
00401AE2 CALL ESI
////////////////////////////////////////到这里是 Erase b
00401AE4 MOV DWORD PTR SS:[EBP-4],EDI
00401AE7 PUSH 工程1.00401B09
00401AEC MOV ESI,DWORD PTR DS:[]
00401AF2 LEA ECX,DWORD PTR SS:[EBP-18]
00401AF5 XOR EDI,EDI
00401AF7 PUSH ECX
00401AF8 PUSH EDI
00401AF9 CALL ESI //释a
00401AFB LEA EAX,DWORD PTR SS:[EBP-38]
00401AFE LEA EDX,DWORD PTR SS:[EBP-30]
00401B01 PUSH EAX
00401B02 PUSH EDI
00401B03 MOV DWORD PTR SS:[EBP-38],EDX
00401B06 CALL ESI //释放b
关于数组就先分析这些,后面还要分析的是 For Each .. Next语句和 Array函数,
不过这两个都比较复杂些,先放到后面去。
3)结构类型的实现
VB的记录变量其实就是一些子域的顺序排列。
这句话怎么理解呢？看看下面的代码：
Private Type daterec
year As Integer
month As String * 3
day As Integer
End Type
Dim a As daterec
a.year = 2004
a.month = “Jan”
a.day = 21
反汇编代码如下：
004019DF XOR EAX,EAX
004019E1 LEA ECX,DWORD PTR SS:[EBP-1E]
004019E4 MOV DWORD PTR SS:[EBP-20],EAX
004019E7 PUSH 工程1.004014CC //”Jan”
004019EC MOV DWORD PTR SS:[EBP-1C],EAX
004019EF PUSH ECX
004019F0 PUSH 3
004019F2 MOV WORD PTR SS:[EBP-18],AX
004019F6 MOV WORD PTR SS:[EBP-20],7D4 // a.year = 2004
004019FC CALL DWORD PTR DS:[]//a.month = “Jan”
00401A02 MOV WORD PTR SS:[EBP-18],15 // a.day = 15
执行到这里时看内存[ebp-20]:
0063F3F0 D4 07 4A 00 61 00 6E 00 ?J.a.n.
0063F3F8 15 00 6F 17 F4 F8 63 00 .o豇c.
从 0063F3F0 到 0063F3F9 就是记录变量 a 的值了
下面要提到的vb的控制结构语句有：if语句，select case语句，while语句，do语句，
for语句。
1)if语句
if语句的典型语法是:
If 条件1 Then
语句块1
ElseIf 条件2 Then
语句块2
Else
语句块3
End If
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
代码：
Dim a //注意：这里定义的是变体变量。
//如果不用变体变量，编译器将优化掉太多的代码。
//当你熟悉变体类型后，其他的将很容易分析 ^_^
a = 5
If a < 5 Then
MsgBox (“a 5”)
End If
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
反汇编代码：
00401A72 XOR ESI,ESI
00401A74 MOV EDI,5
00401A79 MOV DWORD PTR SS:[EBP-74],ESI
00401A7C LEA EDX,DWORD PTR SS:[EBP-74]
00401A7F LEA ECX,DWORD PTR SS:[EBP-24]
00401A82 MOV DWORD PTR SS:[EBP-24],ESI
00401A85 MOV DWORD PTR SS:[EBP-34],ESI —-> 这些变量是为 MsgBox 使用的
00401A88 MOV DWORD PTR SS:[EBP-44],ESI |
00401A8B MOV DWORD PTR SS:[EBP-54],ESI |
00401A8E MOV DWORD PTR SS:[EBP-64],ESI —
00401A91 MOV DWORD PTR SS:[EBP-6C],EDI // 5
00401A94 MOV DWORD PTR SS:[EBP-74],2 //整数类型
00401A9B CALL DWORD PTR DS:[]//赋值
//到这里 a = 5 //[ebp-24]
00401AA1 LEA EAX,DWORD PTR SS:[EBP-24]
00401AA4 LEA ECX,DWORD PTR SS:[EBP-74]
00401AA7 MOV EBX,8002
00401AAC PUSH EAX
00401AAD PUSH ECX
00401AAE MOV DWORD PTR SS:[EBP-6C],EDI // 5
00401AB1 MOV DWORD PTR SS:[EBP-74],EBX // 8002
00401AB4 CALL DWORD PTR DS:[] // a < 5 ?
00401ABA TEST AX,AX
00401ABD JE SHORT 工程2.00401AE4 //不小于则跳走
00401ABF MOV ECX,80020004
00401AC4 MOV EAX,0A
00401AC9 MOV DWORD PTR SS:[EBP-5C],ECX
00401ACC MOV DWORD PTR SS:[EBP-64],EAX
00401ACF MOV DWORD PTR SS:[EBP-4C],ECX
00401AD2 MOV DWORD PTR SS:[EBP-54],EAX
00401AD5 MOV DWORD PTR SS:[EBP-3C],ECX
00401AD8 MOV DWORD PTR SS:[EBP-44],EAX
00401ADB MOV DWORD PTR SS:[EBP-6C],工程2.004016C4; UNICODE “a < 5”
00401AE2 JMP SHORT 工程2.00401B63
00401AE4 LEA ECX,DWORD PTR SS:[EBP-24]
00401AE7 LEA EDX,DWORD PTR SS:[EBP-74]
00401AEA PUSH ECX
00401AEB PUSH EDX
00401AEC MOV DWORD PTR SS:[EBP-6C],EDI // 5
00401AEF MOV DWORD PTR SS:[EBP-74],EBX // 8002
00401AF2 CALL DWORD PTR DS:[]// a = 5 ?
00401AF8 TEST AX,AX
00401AFB MOV ECX,80020004
00401B00 MOV EAX,0A
00401B05 MOV DWORD PTR SS:[EBP-5C],ECX
00401B08 MOV DWORD PTR SS:[EBP-64],EAX
00401B0B MOV DWORD PTR SS:[EBP-4C],ECX
00401B0E MOV DWORD PTR SS:[EBP-54],EAX
00401B11 MOV DWORD PTR SS:[EBP-3C],ECX
00401B14 MOV DWORD PTR SS:[EBP-44],EAX
00401B17 JE SHORT 工程2.00401B5C //不相等则跳走
00401B19 LEA EDX,DWORD PTR SS:[EBP-74]
00401B1C LEA ECX,DWORD PTR SS:[EBP-34]
00401B1F MOV DWORD PTR SS:[EBP-6C],工程2.004016D4; UNICODE “a = 5”
00401B26 MOV DWORD PTR SS:[EBP-74],8
00401B2D CALL DWORD PTR DS:[]
00401B33 LEA EAX,DWORD PTR SS:[EBP-64]
00401B36 LEA ECX,DWORD PTR SS:[EBP-54]
00401B39 PUSH EAX
00401B3A LEA EDX,DWORD PTR SS:[EBP-44]
00401B3D PUSH ECX
00401B3E PUSH EDX
00401B3F LEA EAX,DWORD PTR SS:[EBP-34]
00401B42 PUSH ESI
00401B43 PUSH EAX
00401B44 CALL DWORD PTR DS:[]; MSVBVM60.rtcMsgBox
00401B4A LEA ECX,DWORD PTR SS:[EBP-64]
00401B4D LEA EDX,DWORD PTR SS:[EBP-54]
00401B50 PUSH ECX
00401B51 LEA EAX,DWORD PTR SS:[EBP-44]
00401B54 PUSH EDX
00401B55 LEA ECX,DWORD PTR SS:[EBP-34]
00401B58 PUSH EAX
00401B59 PUSH ECX
00401B5A JMP SHORT 工程2.00401B9D
// 其他条件满足则执行这里
00401B5C MOV DWORD PTR SS:[EBP-6C],工程2.004016E4; UNICODE “a > 5”
00401B63 LEA EDX,DWORD PTR SS:[EBP-74]
00401B66 LEA ECX,DWORD PTR SS:[EBP-34]
00401B69 MOV DWORD PTR SS:[EBP-74],8
00401B70 CALL DWORD PTR DS:[]
00401B76 LEA EDX,DWORD PTR SS:[EBP-64]
00401B79 LEA EAX,DWORD PTR SS:[EBP-54]
00401B7C PUSH EDX
00401B7D LEA ECX,DWORD PTR SS:[EBP-44]
00401B80 PUSH EAX
00401B81 PUSH ECX
00401B82 LEA EDX,DWORD PTR SS:[EBP-34]
00401B85 PUSH ESI
00401B86 PUSH EDX
00401B87 CALL DWORD PTR DS:[]; MSVBVM60.rtcMsgBox
流程大概如此。上面出现了一些VB内部函数，如果你不太熟悉那些函数的意义，可以
到DFCG上下载一份我整理的vb内部函数。
===========================================================
2)select case 语句
select case 语句的语法如下：
Select Case 测试表达式
Case 表达式列表1
语句块1
Case 表达式列表2
语句块2
……
Case Else
语句块n
End Select
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
代码：
Dim a, b
a = 5
Select Case a
Case 3
b = “3”
Case 5
b = “5”
Case Else
b = “0”
End Select
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
反汇编代码(速度优化编译）
00401A2F XOR ESI,ESI // 用来初始化变量
00401A31 LEA EDX,DWORD PTR SS:[EBP-44]
00401A34 MOV DWORD PTR SS:[EBP-44],ESI
00401A37 LEA ECX,DWORD PTR SS:[EBP-24]
00401A3A MOV DWORD PTR SS:[EBP-24],ESI
00401A3D MOV DWORD PTR SS:[EBP-34],ESI
00401A40 MOV DWORD PTR SS:[EBP-54],ESI
00401A43 MOV DWORD PTR SS:[EBP-3C],5 // 5
00401A4A MOV DWORD PTR SS:[EBP-44],2 // 类型
00401A51 CALL DWORD PTR DS:[]
// a = 5 //[ebp-24]
00401A57 MOV EBX,DWORD PTR DS:[]
00401A5D LEA EDX,DWORD PTR SS:[EBP-24]
00401A60 LEA ECX,DWORD PTR SS:[EBP-54]
00401A63 CALL EBX // 生成一个临时变量 //[ebp-54]
// Select Case a
00401A65 MOV EDI,DWORD PTR DS:[
00401A6B LEA EAX,DWORD PTR SS:][EBP-54]
00401A6E LEA ECX,DWORD PTR SS:[EBP-44]
00401A71 PUSH EAX
00401A72 PUSH ECX
00401A73 MOV DWORD PTR SS:[EBP-3C],3 // 3
00401A7A MOV DWORD PTR SS:[EBP-44],8002
00401A81 CALL EDI
00401A83 TEST AX,AX
00401A86 JE SHORT 工程2.00401A91 // 不等于3则跳
// Case 3
00401A88 MOV DWORD PTR SS:[EBP-3C],工程2.004016B4 // ‘3’
00401A8F JMP SHORT 工程2.00401ABC
00401A91 LEA EDX,DWORD PTR SS:[EBP-54]
00401A94 LEA EAX,DWORD PTR SS:[EBP-44]
00401A97 PUSH EDX
00401A98 PUSH EAX
00401A99 MOV DWORD PTR SS:[EBP-3C],5 // 5
00401AA0 MOV DWORD PTR SS:[EBP-44],8002
00401AA7 CALL EDI
00401AA9 TEST AX,AX
00401AAC MOV DWORD PTR SS:[EBP-3C],工程2.004016BC // ‘5’
00401AB3 JNZ SHORT 工程2.00401ABC // 不等于5则跳
// Case 5
00401AB5 MOV DWORD PTR SS:[EBP-3C],工程2.004016C4 // ‘0’
00401ABC LEA EDX,DWORD PTR SS:[EBP-44]
00401ABF LEA ECX,DWORD PTR SS:[EBP-34]
00401AC2 MOV DWORD PTR SS:[EBP-44],8 // String类型
00401AC9 CALL EBX // 为变量 b 赋值
// Case Else
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
当然这段代码在逆向时也可以用if语句来表达。逆向出来的不如select case
语句那样直观。在我看来用if语句表达应该是这样的：
dim a,b
if a = 3 then
b = ‘3’
else if a = 5 then
b = ‘5’
else
b = ‘0’
end if
===========================================================
3)while语句
while语句的典型语法是：
While 条件
语句块
Wend
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
代码：
Dim a, b
a = 3
b = 0
While a > 0
b = b + a
a = a – 1
Wend
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
反汇编代码(速度优化编译）
00401A1F MOV ESI,DWORD PTR DS:[]
00401A25 XOR EDI,EDI // 初始化变量
00401A27 MOV EBX,2
00401A2C MOV DWORD PTR SS:[EBP-54],EDI
00401A2F LEA EDX,DWORD PTR SS:[EBP-54]
00401A32 LEA ECX,DWORD PTR SS:[EBP-24]
00401A35 MOV DWORD PTR SS:[EBP-24],EDI
00401A38 MOV DWORD PTR SS:[EBP-34],EDI
00401A3B MOV DWORD PTR SS:[EBP-44],EDI
00401A3E MOV DWORD PTR SS:[EBP-4C],3 // 3
00401A45 MOV DWORD PTR SS:[EBP-54],EBX // integer类型
00401A48 CALL ESI
// a = 3 //[ebp-24]
00401A4A LEA EDX,DWORD PTR SS:[EBP-54]
00401A4D LEA ECX,DWORD PTR SS:[EBP-34]
00401A50 MOV DWORD PTR SS:[EBP-4C],EDI // 0
00401A53 MOV DWORD PTR SS:[EBP-54],EBX // integer类型
00401A56 CALL ESI
// b = 0 //[ebp-34]
00401A58 MOV EDI,DWORD PTR DS:[]
00401A5E MOV EBX,DWORD PTR DS:[]
00401A64 LEA EAX,DWORD PTR SS:[EBP-24]
00401A67 LEA ECX,DWORD PTR SS:[EBP-54] // 0
00401A6A PUSH EAX
00401A6B PUSH ECX
00401A6C MOV DWORD PTR SS:[EBP-4C],0
00401A73 MOV DWORD PTR SS:[EBP-54],8002
00401A7A CALL DWORD PTR DS:[]
00401A80 TEST AX,AX
00401A83 JE SHORT 工程2.00401ABF // a 不大于0则退出循环
// while a > 0
00401A85 LEA EDX,DWORD PTR SS:[EBP-34]
00401A88 LEA EAX,DWORD PTR SS:[EBP-24]
00401A8B PUSH EDX // b
00401A8C LEA ECX,DWORD PTR SS:[EBP-44]
00401A8F PUSH EAX // a
00401A90 PUSH ECX
00401A91 CALL EDI
00401A93 MOV EDX,EAX // b + a
00401A95 LEA ECX,DWORD PTR SS:[EBP-34] // b
00401A98 CALL ESI
// b = b + a
00401A9A LEA EDX,DWORD PTR SS:[EBP-24] // a
00401A9D LEA EAX,DWORD PTR SS:[EBP-54]
00401AA0 PUSH EDX
00401AA1 LEA ECX,DWORD PTR SS:[EBP-44]
00401AA4 PUSH EAX
00401AA5 PUSH ECX
00401AA6 MOV DWORD PTR SS:[EBP-4C],1 // 1
00401AAD MOV DWORD PTR SS:[EBP-54],2 // integer类型
00401AB4 CALL EBX
00401AB6 MOV EDX,EAX // a – 1
00401AB8 LEA ECX,DWORD PTR SS:[EBP-24]
00401ABB CALL ESI
// a = a – 1
00401ABD JMP SHORT 工程2.00401A64 //注意：这里往回跳
// Wend
===========================================================
4)do语句
这个语句的格式比较多，典型的格式如下：
Do
语句块
Loop Until 循环条件
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Dim a, b
a = 3
b = 0
Do
b = a + b
a = a – 1
Loop Until a <= 0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
反汇编代码(速度优化)
00401A1F MOV ESI,DWORD PTR DS:[]
00401A25 XOR EDI,EDI
00401A27 MOV EBX,2
00401A2C MOV DWORD PTR SS:[EBP-54],EDI
00401A2F LEA EDX,DWORD PTR SS:[EBP-54]
00401A32 LEA ECX,DWORD PTR SS:[EBP-24]
00401A35 MOV DWORD PTR SS:[EBP-24],EDI
00401A38 MOV DWORD PTR SS:[EBP-34],EDI
00401A3B MOV DWORD PTR SS:[EBP-44],EDI
00401A3E MOV DWORD PTR SS:[EBP-4C],3 //3
00401A45 MOV DWORD PTR SS:[EBP-54],EBX //integer
00401A48 CALL ESI
// a = 3 //[ebp-24]
00401A4A LEA EDX,DWORD PTR SS:[EBP-54]
00401A4D LEA ECX,DWORD PTR SS:[EBP-34]
00401A50 MOV DWORD PTR SS:[EBP-4C],EDI //0
00401A53 MOV DWORD PTR SS:[EBP-54],EBX //integer
00401A56 CALL ESI
// b = 0 //[ebp-34]
00401A58 MOV EBX,DWORD PTR DS:[]
00401A5E LEA EAX,DWORD PTR SS:[EBP-24] // a
00401A61 LEA ECX,DWORD PTR SS:[EBP-34] // b
00401A64 PUSH EAX
00401A65 LEA EDX,DWORD PTR SS:[EBP-44]
00401A68 PUSH ECX
00401A69 PUSH EDX
00401A6A CALL EBX
00401A6C MOV EDX,EAX
00401A6E LEA ECX,DWORD PTR SS:[EBP-34]
00401A71 CALL ESI
// b = a + b
00401A73 LEA EAX,DWORD PTR SS:[EBP-24] // a
00401A76 LEA ECX,DWORD PTR SS:[EBP-54]
00401A79 PUSH EAX
00401A7A LEA EDX,DWORD PTR SS:[EBP-44]
00401A7D PUSH ECX
00401A7E PUSH EDX
00401A7F MOV DWORD PTR SS:[EBP-4C],1 // 1
00401A86 MOV DWORD PTR SS:[EBP-54],2 // integer
00401A8D CALL DWORD PTR DS:[]
00401A93 MOV EDX,EAX
00401A95 LEA ECX,DWORD PTR SS:[EBP-24] // a
00401A98 CALL ESI
// a = a – 1
00401A9A LEA EAX,DWORD PTR SS:[EBP-24]
00401A9D LEA ECX,DWORD PTR SS:[EBP-54]
00401AA0 PUSH EAX
00401AA1 PUSH ECX
00401AA2 MOV DWORD PTR SS:[EBP-4C],EDI // 0
00401AA5 MOV DWORD PTR SS:[EBP-54],8002
00401AAC CALL DWORD PTR DS:[]
00401AB2 TEST AX,AX
00401AB5 JE SHORT 工程2.00401A5E
loop until a <= 0
===========================================================
5)for语句
for语句的典型语法如下：
for 循环变量 = 初值 to 终值 [step 步长]
循环体
next 循环变量
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
代码:
a = 0
For i = 0 To 100 Step 2
a = a + i
Next i
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
反汇编代码(速度优化)
00401A42 MOV EBX,DWORD PTR DS:[]
00401A48 XOR ESI,ESI
00401A4A MOV EDI,2
00401A4F MOV DWORD PTR SS:[EBP-54],ESI
00401A52 LEA EDX,DWORD PTR SS:[EBP-54]
00401A55 LEA ECX,DWORD PTR SS:[EBP-34]
00401A58 MOV DWORD PTR SS:[EBP-24],ESI
00401A5B MOV DWORD PTR SS:[EBP-34],ESI
00401A5E MOV DWORD PTR SS:[EBP-44],ESI
00401A61 MOV DWORD PTR SS:[EBP-64],ESI
00401A64 MOV DWORD PTR SS:[EBP-74],ESI
00401A67 MOV DWORD PTR SS:[EBP-84],ESI
00401A6D MOV DWORD PTR SS:[EBP-94],ESI
00401A73 MOV DWORD PTR SS:[EBP-4C],ESI //0
00401A76 MOV DWORD PTR SS:[EBP-54],EDI //integer
00401A79 CALL EBX
// a = 0 //[ebp-34]
00401A7B LEA EAX,DWORD PTR SS:[EBP-54]
00401A7E LEA ECX,DWORD PTR SS:[EBP-64]
00401A81 PUSH EAX // 增量
00401A82 LEA EDX,DWORD PTR SS:[EBP-74]
00401A85 PUSH ECX // 终值
00401A86 LEA EAX,DWORD PTR SS:[EBP-94]
00401A8C PUSH EDX // 初值
00401A8D LEA ECX,DWORD PTR SS:[EBP-84]
00401A93 PUSH EAX //临时终值
00401A94 LEA EDX,DWORD PTR SS:[EBP-24]
00401A97 PUSH ECX //临时增量
00401A98 PUSH EDX // 循环变量
00401A99 MOV DWORD PTR SS:[EBP-4C],EDI // 2
00401A9C MOV DWORD PTR SS:[EBP-54],EDI // integer
00401A9F MOV DWORD PTR SS:[EBP-5C],64 // 100
00401AA6 MOV DWORD PTR SS:[EBP-64],EDI // integer
00401AA9 MOV DWORD PTR SS:[EBP-6C],ESI // 0
00401AAC MOV DWORD PTR SS:[EBP-74],EDI // integer
00401AAF CALL DWORD PTR DS:[]
//For i = 0 To 100 Step 2
00401AB5 MOV EDI,DWORD PTR DS:[]
00401ABB CMP EAX,ESI
00401ABD JE SHORT 工程2.00401AEE
00401ABF LEA EAX,DWORD PTR SS:[EBP-34] //a
00401AC2 LEA ECX,DWORD PTR SS:[EBP-24] //i
00401AC5 PUSH EAX
00401AC6 LEA EDX,DWORD PTR SS:[EBP-44]
00401AC9 PUSH ECX
00401ACA PUSH EDX
00401ACB CALL EDI
00401ACD MOV EDX,EAX
00401ACF LEA ECX,DWORD PTR SS:[EBP-34]
00401AD2 CALL EBX
// a = a + i
00401AD4 LEA EAX,DWORD PTR SS:[EBP-94] //临时终值
00401ADA LEA ECX,DWORD PTR SS:[EBP-84] //临时增量
00401AE0 PUSH EAX
00401AE1 LEA EDX,DWORD PTR SS:[EBP-24] // 循环变量
00401AE4 PUSH ECX
00401AE5 PUSH EDX
00401AE6 CALL DWORD PTR DS:[]
00401AEC JMP SHORT 工程2.00401ABB
// next i
===========================================================
上面出现了我定义的两个名词:临时终值和临时增量,这两个值什么意思呢?
也就是当__vbaVarForInit函数执行完后这两个值将分别被赋予终值和增量的值。
从上面可以看出，__vbaVarForInit只是执行一次，以后再执行就是__vbaVarForNext
了。因此程序必须知道循环变量到那里结束，每次步长多少。这两个值就是保存这些
信息的。
当满足循环条件时,这两个函数都返回1,不满足时返回0。
===========================================================
到现在为止分析基本的程序结构应该没问题了。在这里把前面没完成的工作
补一下：看看 Array函数和 For Each … Next 语句。
代码：
Dim a
a = Array(5, 6, 7)
For Each x In a
Print x
Next x
编译后的汇编代码：
00401AC3 XOR ESI,ESI
00401AC5 LEA EDX,DWORD PTR SS:[EBP-48]
00401AC8 PUSH ESI
00401AC9 PUSH 2
00401ACB PUSH 1
00401ACD PUSH ESI
00401ACE PUSH EDX
00401ACF PUSH 10
00401AD1 PUSH 880
00401AD6 MOV DWORD PTR SS:[EBP-24],ESI
00401AD9 MOV DWORD PTR SS:[EBP-34],ESI
00401ADC MOV DWORD PTR SS:[EBP-44],ESI
00401ADF MOV DWORD PTR SS:[EBP-48],ESI
00401AE2 MOV DWORD PTR SS:[EBP-58],ESI
00401AE5 MOV DWORD PTR SS:[EBP-68],ESI
00401AE8 MOV DWORD PTR SS:[EBP-78],ESI
00401AEB MOV DWORD PTR SS:[EBP-7C],ESI
00401AEE MOV DWORD PTR SS:[EBP-80],ESI
00401AF1 MOV DWORD PTR SS:[EBP-84],ESI
00401AF7 MOV DWORD PTR SS:[EBP-88],ESI
00401AFD CALL DWORD PTR DS:[] //定义一个变体类型的动态数组
1) 自定义函数的调用
这里我们看看和VB的内部函数有关的一些内容。
老规矩，先看一段代码：
Function myadd(ByVal a As Variant, b As Variant)
myadd = a + b
End Function
Sub myprint(ByVal a As Variant)
Print a
End Sub
Private Sub Command1_Click()
Dim a, b, c
a = 10
b = 20
c = myadd(a, b)
myprint c
End Sub
这段代码里包含了自定义的过程，函数及函数的两种参数传递方式。下面的反汇编代码
是过程Command1_Click()的。自定义的函数和过程的反汇编代码和这相仿，可以字节反汇
编对比看一下。
反汇编代码如下，默认方式（速度优化）编译的，这次给出的是完整的汇编代码：
00401C50 PUSH EBP
00401C51 MOV EBP,ESP
00401C53 SUB ESP,0C
00401C56 PUSH
00401C5B MOV EAX,DWORD PTR FS:[0]
00401C61 PUSH EAX
00401C62 MOV DWORD PTR FS:[0],ESP //安装局部线程异常
00401C69 SUB ESP,5C //下面这一段和vb编译器有关
00401C6C PUSH EBX //因为vb是基于com技术实现的
00401C6D PUSH ESI //更详细的内容可以参考
00401C6E PUSH EDI //<>一书
00401C6F MOV DWORD PTR SS:[EBP-C],ESP
00401C72 MOV DWORD PTR SS:[EBP-8],工程2.004010B0
00401C79 MOV ESI,DWORD PTR SS:[EBP+8]
00401C7C MOV EAX,ESI
00401C7E AND EAX,1
00401C81 MOV DWORD PTR SS:[EBP-4],EAX
00401C84 AND ESI,FFFFFFFE
00401C87 PUSH ESI
00401C88 MOV DWORD PTR SS:[EBP+8],ESI //me
00401C8B MOV ECX,DWORD PTR DS:[ESI]
00401C8D CALL DWORD PTR DS:[ECX+4] ;MSVBVM60.Zombie_AddRef
00401C90 MOV EDI,DWORD PTR DS:[]
00401C96 XOR EBX,EBX
00401C98 MOV DWORD PTR SS:[EBP-64],EBX
00401C9B LEA EDX,DWORD PTR SS:[EBP-64]
00401C9E LEA ECX,DWORD PTR SS:[EBP-24]
00401CA1 MOV DWORD PTR SS:[EBP-24],EBX
00401CA4 MOV DWORD PTR SS:[EBP-34],EBX
00401CA7 MOV DWORD PTR SS:[EBP-44],EBX
00401CAA MOV DWORD PTR SS:[EBP-54],EBX
00401CAD MOV DWORD PTR SS:[EBP-5C],0A //10
00401CB4 MOV DWORD PTR SS:[EBP-64],2 //integer
00401CBB CALL EDI
//a = 10
00401CBD LEA EDX,DWORD PTR SS:[EBP-64]
00401CC0 LEA ECX,DWORD PTR SS:[EBP-34]
00401CC3 MOV DWORD PTR SS:[EBP-5C],14 //20
00401CCA MOV DWORD PTR SS:[EBP-64],2 //integer
00401CD1 CALL EDI
// b = 20
00401CD3 LEA EAX,DWORD PTR SS:[EBP-54]
00401CD6 LEA ECX,DWORD PTR SS:[EBP-34]
00401CD9 PUSH EAX //存放函数的返回值
00401CDA PUSH ECX //引用参数b
00401CDB MOV ECX,DWORD PTR SS:[EBP-24]
00401CDE SUB ESP,10 //这个空间复制变量参数a
00401CE1 MOV EAX,ESP //变体类型,所以要16个字节
00401CE3 MOV EDX,DWORD PTR DS:[ESI]
00401CE5 PUSH ESI //me
00401CE6 MOV DWORD PTR DS:[EAX],ECX
00401CE8 MOV ECX,DWORD PTR SS:[EBP-20]
00401CEB MOV DWORD PTR DS:[EAX+4],ECX
00401CEE MOV ECX,DWORD PTR SS:[EBP-1C]
00401CF1 MOV DWORD PTR DS:[EAX+8],ECX
00401CF4 MOV ECX,DWORD PTR SS:[EBP-18]
00401CF7 MOV DWORD PTR DS:[EAX+C],ECX
00401CFA CALL DWORD PTR DS:[EDX+6F8] //调用函数 myadd
00401D00 CMP EAX,EBX
00401D02 JGE SHORT 工程2.00401D16
00401D04 PUSH 6F8
00401D09 PUSH 工程2.00401644
00401D0E PUSH ESI
00401D0F PUSH EAX
00401D10 CALL DWORD PTR DS:[]
00401D16 LEA EDX,DWORD PTR SS:[EBP-54]
00401D19 LEA ECX,DWORD PTR SS:[EBP-44]
00401D1C CALL EDI
//把结果赋值给变量c
00401D1E MOV ECX,DWORD PTR SS:[EBP-44] //c作为变量参数传递
00401D21 SUB ESP,10 //所以这里要分配16个字节
00401D24 MOV EAX,ESP
00401D26 MOV EDX,DWORD PTR DS:[ESI]
00401D28 PUSH ESI //me
00401D29 MOV DWORD PTR DS:[EAX],ECX
00401D2B MOV ECX,DWORD PTR SS:[EBP-40]
00401D2E MOV DWORD PTR DS:[EAX+4],ECX
00401D31 MOV ECX,DWORD PTR SS:[EBP-3C]
00401D34 MOV DWORD PTR DS:[EAX+8],ECX
00401D37 MOV ECX,DWORD PTR SS:[EBP-38]
00401D3A MOV DWORD PTR DS:[EAX+C],ECX
00401D3D CALL DWORD PTR DS:[EDX+6FC] //调用myprint
00401D43 CMP EAX,EBX
00401D45 JGE SHORT 工程2.00401D59
00401D47 PUSH 6FC
00401D4C PUSH 工程2.00401644
00401D51 PUSH ESI
00401D52 PUSH EAX
00401D53 CALL DWORD PTR DS:[]
00401D59 MOV DWORD PTR SS:[EBP-4],EBX
00401D5C PUSH 工程2.00401D83 //这里压入返回地址
00401D61 JMP SHORT 工程2.00401D6D
00401D63 LEA ECX,DWORD PTR SS:[EBP-54]
00401D66 CALL DWORD PTR DS:[]
00401D6C RETN
00401D6D MOV ESI,DWORD PTR DS:[]
00401D73 LEA ECX,DWORD PTR SS:[EBP-24]
00401D76 CALL ESI
00401D78 LEA ECX,DWORD PTR SS:[EBP-34]
00401D7B CALL ESI
00401D7D LEA ECX,DWORD PTR SS:[EBP-44]
00401D80 CALL ESI
00401D82 RETN //上面这里释放变量a,b,c
00401D83 MOV EAX,DWORD PTR SS:[EBP+8] //返回到这里做善后处理
00401D86 PUSH EAX
00401D87 MOV EDX,DWORD PTR DS:[EAX]
00401D89 CALL DWORD PTR DS:[EDX+8] ; MSVBVM60.Zombie_Release
00401D8C MOV EAX,DWORD PTR SS:[EBP-4]
00401D8F MOV ECX,DWORD PTR SS:[EBP-14]
00401D92 POP EDI
00401D93 POP ESI
00401D94 MOV DWORD PTR FS:[0],ECX //恢复局部线程异常
00401D9B POP EBX
00401D9C MOV ESP,EBP
00401D9E POP EBP
00401D9F RETN 4
从这里可以看出，在调用自程序时还要传递一个me参数。对于函数来说，还有一个
返回结果要传递过去。
2) VB的内部函数
VB的内部函数在反汇编代码中看起来和我们熟悉的函数名并不一样。这一点跟踪过
VB程序的人一定深有体会。大多数函数名都可以从名字上猜出来。但也有相差太多的。
我整理了一份函数列表。不是全部，但包含了大多数内部函数，应该能应付一般的应用。
函数列表在这个贴子的附件中。
VB的运算符大多是用函数实现的。这是一个好消息。这意味着我们不必费力去分析
过多的代码而只要能辨别出那些函数名即可。
VB的内部函数并不都是以Stdcall的方式传递参数，尽管大部分是这样的。分析
VB程序时要注意这点。
VB的反汇编代码中大部分的函数都要传递一个存放返回值的变量，而且返回值也会
在EAX中或者浮点栈中返回。
这里只举一个例子。其他的可以参考我整理的列表。
这是函数instr,常用的一个：
__vbaInStrVar ;函数 InStr(起始位置,源字符串,目标字符串,比较方式)
LEA EDX,DWORD PTR SS:[EBP-24]
PUSH 1 ;起始位置,从1开始
LEA EAX,DWORD PTR SS:[EBP-34]
PUSH EDX ;被搜索的字符串
PUSH EAX ;要搜的字符串
LEA ECX,DWORD PTR SS:[EBP-54]
PUSH 1 ;比较方式
PUSH ECX ;返回的结果
CALL DWORD PTR DS:[]
MOV EDX,EAX ;结果同时在eax中返回
3) VB的外部函数调用
VB对外部函数的调用是如何实现的呢？先看看下面的代码：
Private Declare Function MessageBeep Lib “user32” (ByVal wType As Long) As Long
Private Sub Command1_Click()
MessageBeep 0
End Sub
对应的反汇编代码如下：
00401A2F PUSH 0 //这里压入参数
00401A31 CALL 工程2.004016C8 //这个Call我们要继续跟进才知道调用的什么函数
00401A36 CALL DWORD PTR DS:[]
004016C8 MOV EAX,DWORD PTR DS:[4022DC] //第一次调用时为0,以后就调用这里
004016CD OR EAX,EAX //这个程序里为0
004016CF JE SHORT 工程2.004016D3
004016D1 JMP EAX
004016D3 PUSH 工程2.004016B0 //注意这个地址,这是指向代码段的
//我们先看看这里有什么
004016B0 98 16 40 00 A4 16 40 00 ?@.?@.
//再跟进
00401698 75 73 65 72 33 32 00 00 user32..
004016A0 0C 00 00 00 4D 65 73 73 ….Mess
004016A8 61 67 65 42 65 65 70 00 ageBeep.
//是不是看到了要调用的函数了^_^
//其实不用这么麻烦
004016D8 MOV EAX,
004016DD CALL EAX //执行完这一行看eax,看到什么了
//EAX 84936A78 Thunk to USER32.MessageBeep
004016DF JMP EAX //这里就是真正的调用了
注意:调用的外部函数名不在程序的导入表里,而是在代码段里。程序是调用
函数MSVBVM60.DllFunctionCall来取得外部函数的地址的。
这里我只从跟踪的角度来谈异常处理。很多人说在VB中发生异常是会跟进虚拟机里，
在里面打转。其实VB的异常处理没有那么复杂，可以很容易的出来的。
这里先介绍一个VB的万能断点：MSVBVM60.__vbaExceptHandler，VB在每个过程
的开始都要安装一个线程异常处理过程，在OD中对这个函数下断点百分百有效。需要注意
的事当你找到自己需要的地方时要及时清除这个断点，否则会在你不期望的时候中断
下面依旧以一段代码为例说明：
Dim a, b, c, d
On Error Resume Next
a = 5
b = 6
c = 0
d = b / c
Print a
到现在为止你应该能看懂下面的代码了。所以我只对源代码注释：
00401A20 PUSH EBP
00401A21 MOV EBP,ESP
00401A23 SUB ESP,18
00401A26 PUSH
00401A2B MOV EAX,DWORD PTR FS:[0]
00401A31 PUSH EAX
00401A32 MOV DWORD PTR FS:[0],ESP
00401A39 MOV EAX,74
00401A3E CALL
00401A43 PUSH EBX
00401A44 PUSH ESI
00401A45 PUSH EDI
00401A46 MOV DWORD PTR SS:[EBP-18],ESP
00401A49 MOV DWORD PTR SS:[EBP-14],工程2.00401088
00401A50 MOV EAX,DWORD PTR SS:[EBP+8]
00401A53 AND EAX,1
00401A56 MOV DWORD PTR SS:[EBP-10],EAX
00401A59 MOV ECX,DWORD PTR SS:[EBP+8]
00401A5C AND ECX,FFFFFFFE
00401A5F MOV DWORD PTR SS:[EBP+8],ECX
00401A62 MOV DWORD PTR SS:[EBP-C],0
00401A69 MOV EDX,DWORD PTR SS:[EBP+8]
00401A6C MOV EAX,DWORD PTR DS:[EDX]
00401A6E MOV ECX,DWORD PTR SS:[EBP+8]
00401A71 PUSH ECX
00401A72 CALL DWORD PTR DS:[EAX+4]
00401A75 MOV DWORD PTR SS:[EBP-4],1
00401A7C MOV DWORD PTR SS:[EBP-4],2
00401A83 PUSH -1
00401A85 CALL DWORD PTR DS:[]
//On Error Resume Next
00401A8B MOV DWORD PTR SS:[EBP-4],3
00401A92 MOV DWORD PTR SS:[EBP-78],5
00401A99 MOV DWORD PTR SS:[EBP-80],2
00401AA0 LEA EDX,DWORD PTR SS:[EBP-80]
00401AA3 LEA ECX,DWORD PTR SS:[EBP-30]
00401AA6 CALL DWORD PTR DS:[]
// a = 5
00401AAC MOV DWORD PTR SS:[EBP-4],4
00401AB3 MOV DWORD PTR SS:[EBP-78],6
00401ABA MOV DWORD PTR SS:[EBP-80],2
00401AC1 LEA EDX,DWORD PTR SS:[EBP-80]
00401AC4 LEA ECX,DWORD PTR SS:[EBP-40]
00401AC7 CALL DWORD PTR DS:[]
// b = 6
00401ACD MOV DWORD PTR SS:[EBP-4],5
00401AD4 MOV DWORD PTR SS:[EBP-78],0
00401ADB MOV DWORD PTR SS:[EBP-80],2
00401AE2 LEA EDX,DWORD PTR SS:[EBP-80]
00401AE5 LEA ECX,DWORD PTR SS:[EBP-50]
00401AE8 CALL DWORD PTR DS:[]
// c = 0
00401AEE MOV DWORD PTR SS:[EBP-4],6
00401AF5 LEA EDX,DWORD PTR SS:[EBP-40]
00401AF8 PUSH EDX
00401AF9 LEA EAX,DWORD PTR SS:[EBP-50]
00401AFC PUSH EAX
00401AFD LEA ECX,DWORD PTR SS:[EBP-70]
00401B00 PUSH ECX
00401B01 CALL DWORD PTR DS:[]
00401B07 MOV EDX,EAX
00401B09 LEA ECX,DWORD PTR SS:[EBP-60]
00401B0C CALL DWORD PTR DS:[] ; MSVBVM60.__vbaVarMove
// d = b / c
00401B12 MOV DWORD PTR SS:[EBP-4],7
00401B19 LEA EDX,DWORD PTR SS:[EBP-30]
00401B1C PUSH EDX
00401B1D MOV EAX,DWORD PTR SS:[EBP+8]
00401B20 PUSH EAX
00401B21 PUSH 工程2.004016E8
00401B26 CALL DWORD PTR DS:[]
//print a
为了不占篇幅,删去了后面的代码.看到onError时你应该小心的处理这个
过程,刚才的断点还没有清除吧?如果清除了在__vbaExceptHandler这个函数
上重新下个断点.运行程序,会在这个断点上停下来,我们跟进这个函数里.
在OD中按f8一路向下走,你应该在这里跟飞:
660E3D3A MOV AX,WORD PTR DS:[ESI]
660E3D3D TEST AL,30
660E3D3F JE SHORT MSVBVM60.660E3D4D
660E3D41 CMP DWORD PTR DS:[EDI+14],0
660E3D45 JE SHORT MSVBVM60.660E3D4D
660E3D47 TEST BYTE PTR DS:[EDI+10],2
660E3D4B JE SHORT MSVBVM60.660E3D55
660E3D4D TEST AL,1
660E3D4F JE MSVBVM60.660E3DDB
660E3D55 PUSH ECX
660E3D56 CALL MSVBVM60.660E415C
660E3D5B PUSH DWORD PTR SS:[EBP+8]
660E3D5E MOV DWORD PTR SS:[EBP+C],EAX
660E3D61 CALL MSVBVM60.660E4121
660E3D66 TEST EAX,EAX
660E3D68 JE SHORT MSVBVM60.660E3DDB
660E3D6A CMP DWORD PTR SS:[EBP+C],0
660E3D6E JE SHORT MSVBVM60.660E3D75
660E3D70 TEST BYTE PTR DS:[ESI],1
660E3D73 JE SHORT MSVBVM60.660E3DDB
660E3D75 PUSH EDI
660E3D76 CALL MSVBVM60.66103DBF
660E3D7B CALL MSVBVM60.660CDE2E
660E3D80 XOR EAX,EAX
660E3D82 CMP DWORD PTR SS:[EBP+C],EAX
660E3D85 JNZ MSVBVM60.660E3E4B
660E3D8B TEST BYTE PTR DS:[ESI],30
660E3D8E JE SHORT MSVBVM60.660E3E04
660E3D90 CMP DWORD PTR DS:[EDI+14],EAX
660E3D93 JE SHORT MSVBVM60.660E3E04
660E3D95 TEST BYTE PTR DS:[EDI+10],2
660E3D99 JNZ SHORT MSVBVM60.660E3E04
660E3D9B PUSH EAX
660E3D9C PUSH 1
660E3D9E PUSH EAX
660E3D9F PUSH ESI
660E3DA0 PUSH EDI
660E3DA1 CALL MSVBVM60.660E3F47
660E3DA6 TEST BYTE PTR DS:[ESI],40
660E3DA9 PUSH DWORD PTR DS:[6610EE7C]
660E3DAF JE SHORT MSVBVM60.660E3DE3
660E3DB1 CALL EBX
660E3DB3 MOV ECX,DWORD PTR DS:[EDI+1C]
660E3DB6 MOV EDX,DWORD PTR DS:[ESI+18]
660E3DB9 MOVZX ECX,WORD PTR DS:[EDX+ECX*2+2]
660E3DBE MOV DWORD PTR DS:[EAX+98],ECX
660E3DC4 MOV EAX,DWORD PTR DS:[EDI+14]
660E3DC7 CMP EAX,-2
660E3DCA JE SHORT MSVBVM60.660E3DF9
660E3DCC CMP EAX,-1
660E3DCF JE SHORT MSVBVM60.660E3DEE
660E3DD1 TEST EAX,EAX
660E3DD3 JE SHORT MSVBVM60.660E3DDB
660E3DD5 PUSH EDI
660E3DD6 CALL MSVBVM60.660E408D //这里跟飞
我们在这里下个断点,重新运行程序,到这里按F7跟进.会来到下面:
660E408D PUSH EBP
660E408E MOV EBP,ESP
660E4090 PUSH ECX
660E4091 MOV EAX,DWORD PTR SS:[EBP+8]
660E4094 AND DWORD PTR SS:[EBP-4],0
660E4098 AND DWORD PTR SS:[EBP+8],0
660E409C PUSH EBX
660E409D MOV ECX,DWORD PTR DS:[EAX+1C]
660E40A0 MOV EDX,DWORD PTR DS:[EAX+C]
660E40A3 MOV DWORD PTR DS:[EAX+18],ECX
660E40A6 PUSH ESI
660E40A7 MOV ECX,DWORD PTR DS:[EDX+10]
660E40AA PUSH EDI
660E40AB MOV ESI,DWORD PTR DS:[ECX]
660E40AD TEST ESI,ESI
660E40AF JLE SHORT MSVBVM60.660E40C6
660E40B1 LEA EDI,DWORD PTR DS:[ECX+4]
660E40B4 MOV EBX,DWORD PTR DS:[EAX+14]
660E40B7 CMP EBX,DWORD PTR DS:[EDI]
660E40B9 JE SHORT MSVBVM60.660E40EA
660E40BB INC DWORD PTR SS:[EBP+8]
660E40BE ADD EDI,8
660E40C1 CMP DWORD PTR SS:[EBP+8],ESI
660E40C4 ^ JL SHORT MSVBVM60.660E40B4
660E40C6 MOVSX ECX,WORD PTR DS:[EDX+2]
660E40CA OR DWORD PTR DS:[EAX+10],2
660E40CE PUSH MSVBVM60.660E3FD3
660E40D3 PUSH DWORD PTR DS:[EAX+8]
660E40D6 LEA EAX,DWORD PTR DS:[ECX+EAX+C]
660E40DA PUSH EAX
660E40DB PUSH DWORD PTR SS:[EBP-4] //这里就是返回地址了
660E40DE CALL MSVBVM60.66103DAC
660E40E3 POP EDI
660E40E4 POP ESI
660E40E5 POP EBX
660E40E6 LEAVE
660E40E7 RETN 4
为了验证一下,我们继续跟进66103dac:
66103DAC PUSH EBP
66103DAD MOV EBP,ESP
66103DAF MOV ECX,DWORD PTR SS:[EBP+14]
66103DB2 MOV EBX,DWORD PTR SS:[EBP+8] //这里是刚才那个参数
66103DB5 MOV ESP,DWORD PTR SS:[EBP+10]
66103DB8 MOV EBP,DWORD PTR SS:[EBP+C]
66103DBB CALL ECX
66103DBD JMP EBX //返回用户程序
注意:这里所提到的是对用户程序对异常做了处理的情况,否则你可能得到一个
出错对话框程序就退出了.
6. 没有结束的结束
这一系列的贴子到这里就告一段落了。工作太忙，一直断断续续的在写，感谢你有耐心
看完。上面所提到的都是从语言这个角度说的。也是我分析大量VB程序的一点经验。真正的
VB逆向工程只有这点知识远远不够。这是只是帮助你复习语言特性而已。你或许应该去好好
的看看编译原理，看看C++，看看COM的实现，看看流行的编译器技术等等。