缓冲区溢出分析第07课：MS06-040漏洞研究——静态分析

前言

我在之前的课程中讨论过W32Dasm这款软件中的漏洞分析与利用的方法，由于使用该软件的人群毕竟是小众群体，因此该漏洞的危害相对来说还是比较小的。但是如果漏洞出现在Windows系统中，那么情况就会很不一样了。毕竟Windows统治了全球九成以上的计算机操作系统，因此如果该系统中出现了漏洞，而这个漏洞又被别有用心者所利用，那么就必然会出现数以亿计的受害者。

MS06-040漏洞基本信息

这次我们讨论的漏洞是在2006年8月8日，由微软公布的MS06-040这个漏洞（https://technet.microsoft.com/en-us/library/security/ms06-040.aspx）。在微软的安全技术中心，可以看到关于这个漏洞的报告，它被定义为“严重”的级别：

图1

其实，微软的安全技术中心所公布的漏洞是所有安全工作者和黑客们最为感兴趣的地方。每当微软发布一个补丁，修复了一个漏洞，总会有许多的攻击者通宵达旦地去研究这些补丁都修补了哪些漏洞，并写出漏洞利用程序。因为在补丁刚刚发布的一段时间内并非所有用户都能及时修复，所以这种新公布的漏洞会很有利用价值。对于这些攻击者而言，虽说他们的行为很不光彩，但是他们这种去挖掘漏洞的毅力，还是值得钦佩的。毕竟微软的漏洞公告，仅仅给出了一个大概的方向，而漏洞的具体细节，比如漏洞出现在哪个函数，该如何利用这个漏洞等等细节，是根本就没有透露的。这就和之前我们讨论的W32Dasm的漏洞报告很不一样，后者已经具体到了一个特定的函数，因此我们只要找到究竟是哪个位置的函数出现了问题即可。而通过微软的漏洞报告，我们一般至多只能够知道漏洞出现在哪一个动态链接库中，具体到究竟是该动态链接库中的哪一个函数，就需要我们自己去寻找了。由于动态链接库中可能包含有众多的导出函数，所以很多时候定位漏洞出现的位置就如同大海捞针，是需要极大的耐心甚至还包含有运气成分的。

依据微软的漏洞报告，我们知道出现问题的是Netapi32.dll这个动态链接库：

图2

在该动态链接库中有一个名为NetpwPathCanonicalize()的导出函数：

图3

这个函数存在着缓冲区溢出的缺陷，也正是我们重点关注的对象。

静态分析漏洞出现的原因

既然已经知道了出现漏洞的函数，那么下一步可以使用IDA Pro来分析一下漏洞出现的原因。事实上，在NetpwPathCanonicalize()函数中有一个名为sub_7517FC68的函数，出现溢出隐患的正是在这个函数内部：

图4

下面就是对这个函数反汇编代码的分析：

1. .text:7517FC68 ; Attributes: bp-based frame
2. .text:7517FC68 ; int __stdcall sub_7517FC68(wchar_t *Source, wchar_t *Str, int, int, int)
3. .text:7517FC68 sub_7517FC68    proc near               ; CODE XREF: NetpwPathCanonicalize+74p
4. .text:7517FC68 var_416         = word ptr -416h
5. .text:7517FC68 Dest            = word ptr -414h
6. .text:7517FC68 Source          = dword ptr  8
7. .text:7517FC68 Str             = dword ptr  0Ch
8. .text:7517FC68 arg_8           = dword ptr  10h
9. .text:7517FC68 arg_C           = dword ptr  14h
10. .text:7517FC68 arg_10          = dword ptr  18h
11. ; 本函数中一共有五个参数和两个局部变量
12. .text:7517FC68                 push    ebp
13. .text:7517FC69                 mov     ebp, esp
14. .text:7517FC6B                 sub     esp, 414h
15. ; 开辟0x414字节大小的空间，用于存放生成的字符串
16. .text:7517FC71                 push    ebx
17. .text:7517FC72                 push    esi
18. .text:7517FC73                 xor     esi, esi
19. .text:7517FC75                 push    edi
20. .text:7517FC76                 cmp     [ebp+Source], esi
21. ; 验证参数Source是否为0
22. .text:7517FC79                 mov     edi, ds:__imp_wcslen
23. .text:7517FC7F                 mov     ebx, 411h
24. ; 在本函数中，ebx的值不变，恒为0x411，用于检查是否越界
25. .text:7517FC84                 jz      short loc_7517FCED
26. ; 依据上面的Source与0的比较结果来判定是否跳转
27. .text:7517FC86                 push    [ebp+Source]       ; Str
28. .text:7517FC89                 call    edi ; __imp_wcslen
29. ; 计算参数Source的长度，注意这里是Unicode形式的长度
30. .text:7517FC8B                 mov     esi, eax
31. ; esi保存的是参数Source的Unicode形式的长度
32. .text:7517FC8D                 pop     ecx
33. .text:7517FC8E                 test    esi, esi
34. .text:7517FC90                 jz      short loc_7517FCF4
35. ; 验证参数Source的长度是否为0
36. .text:7517FC92                 cmp     esi, ebx
37. ; 验证参数Source的长度是否大于0x411
38. .text:7517FC94                 ja      loc_7517FD3E
39. ; 如果大于，则退出程序
40. .text:7517FC9A                 push    [ebp+Source]       ; Source
41. .text:7517FC9D                 lea     eax, [ebp+Dest]
42. .text:7517FCA3                 push    eax                ; Dest
43. .text:7517FCA4                 call    ds:__imp_wcscpy
44. ; 将参数Source字符串拷贝到新分配的空间中。需要注意的是，这里开辟的是0x414字节的空间，
45. ; 但是上述代码检测的却是宽字符，宽字符的0x411相当于0x822字节的空间。看似这是可以
46. ; 利用的漏洞，但是在本函数调用之前，程序已经使用了NetpwPathType()函数用于检测参
47. ; 数Source的长度，使其不能超过0x206个字节，因此这里是不能被当做漏洞利用的。
48. .text:7517FCAA                 mov     ax, [ebp+esi*2+var_416]
49. ; 取出字符，检查是否为斜杠
50. .text:7517FCB2                 pop     ecx
51. .text:7517FCB3                 cmp     ax, 5Ch                  ; 0x5C表示的是“\”
52. .text:7517FCB7                 pop     ecx
53. .text:7517FCB8                 jz      short loc_7517FCD5
54. .text:7517FCBA                 cmp     ax, 2Fh                  ; 0x2F表示的是“/”
55. .text:7517FCBE                 jz      short loc_7517FCD5
56. .text:7517FCC0                 lea     eax, [ebp+Dest]
57. .text:7517FCC6                 push    offset asc_751717B8      ; "\\"
58. .text:7517FCCB                 push    eax                      ; Dest
59. .text:7517FCCC                 call    ds:__imp_wcscat
60. ; 将斜杠与字符串进行连接
61. .text:7517FCD2                 pop     ecx
62. .text:7517FCD3                 inc     esi
63. ; 由于加入了斜杠，所以字符串的长度增加1
64. .text:7517FCD4                 pop     ecx
65. .text:7517FCD5
66. .text:7517FCD5 loc_7517FCD5:                           ; CODE XREF: sub_7517FC68+50j
67. .text:7517FCD5                                         ; sub_7517FC68+56j
68. .text:7517FCD5                 mov     eax, [ebp+Str]
69. .text:7517FCD8                 mov     ax, [eax]
70. .text:7517FCDB                 cmp     ax, 5Ch         ; 0x5C表示的是“\”
71. .text:7517FCDF                 jz      short loc_7517FCE7
72. .text:7517FCE1                 cmp     ax, 2Fh         ; 0x2F表示的是“/”
73. .text:7517FCE5                 jnz     short loc_7517FCF4
74. .text:7517FCE7
75. .text:7517FCE7 loc_7517FCE7:                           ; CODE XREF: sub_7517FC68+77j
76. .text:7517FCE7                 add     [ebp+Str], 2
77. .text:7517FCEB                 jmp     short loc_7517FCF4
78. .text:7517FCED ; ------------------------------------------------------------
79. .text:7517FCED loc_7517FCED:                           ; CODE XREF: sub_7517FC68+1Cj
80. .text:7517FCED                 mov     [ebp+Dest], si
81. .text:7517FCF4
82. .text:7517FCF4 loc_7517FCF4:                           ; CODE XREF: sub_7517FC68+28j
83. .text:7517FCF4                                         ; sub_7517FC68+7Dj ...
84. .text:7517FCF4                 push    [ebp+Str]       ; Str
85. .text:7517FCF7                 call    edi ; __imp_wcslen
86. ; 计算参数Str的长度，注意这里是Unicode形式的长度
87. .text:7517FCF9                 add     eax, esi
88. ; 这里计算的是加上了斜杠的参数Source与Str长度的总和，该长度保存在eax中
89. .text:7517FCFB                 pop     ecx
90. .text:7517FCFC                 cmp     eax, ebx
91. .text:7517FCFE                 ja      short loc_7517FD3E
92. ; 对连接后的字符串长度进行检查，经过之前的分析可以知道，仅仅依靠参数Source是不能够
93. ; 实现漏洞的利用的，因为它的长度被限定在了0x206个字节，但是程序并没有对参数Str的
94. ; 长度进行足够的限定，利用这一点就可以实现漏洞的利用。
95. .text:7517FD00                 push    [ebp+Str]          ; Source
96. .text:7517FD03                 lea     eax, [ebp+Dest]
97. .text:7517FD09                 push    eax                ; Dest
98. .text:7517FD0A                 call    ds:__imp_wcscat
99. ; 字符串连接，将参数Str连接到缓冲区中，也正是这个函数，导致了缓冲区的溢出
100. .text:7517FD10                 pop     ecx
101. .text:7517FD11                 lea     eax, [ebp+Dest]
102. .text:7517FD17                 pop     ecx
103. .text:7517FD18                 push    eax
104. .text:7517FD19                 call    sub_7518AE95
105. .text:7517FD1E                 lea     eax, [ebp+Dest]
106. .text:7517FD24                 push    eax             ; Str
107. .text:7517FD25                 call    sub_7518AEB3
108. .text:7517FD2A                 test    eax, eax
109. .text:7517FD2C                 jnz     short loc_7517FD43
110. .text:7517FD2E                 lea     eax, [ebp+Dest]
111. .text:7517FD34                 push    eax
112. .text:7517FD35                 call    sub_7518AFE2
113. .text:7517FD3A                 test    eax, eax
114. .text:7517FD3C                 jnz     short loc_7517FD43
115. .text:7517FD3E
116. .text:7517FD3E loc_7517FD3E:                           ; CODE XREF: sub_7517FC68+2Cj
117. .text:7517FD3E                                         ; sub_7517FC68+96j
118. .text:7517FD3E                 push    7Bh
119. .text:7517FD40                 pop     eax
120. .text:7517FD41                 jmp     short loc_7517FD7A
121. .text:7517FD43 ; ------------------------------------------------------------
122. .text:7517FD43 loc_7517FD43:                           ; CODE XREF: sub_7517FC68+C4j
123. .text:7517FD43                                         ; sub_7517FC68+D4j
124. .text:7517FD43                 lea     eax, [ebp+Dest]
125. .text:7517FD49                 push    eax             ; Str
126. .text:7517FD4A                 call    edi ; __imp_wcslen
127. .text:7517FD4C                 lea     eax, [eax+eax+2]
128. .text:7517FD50                 pop     ecx
129. .text:7517FD51                 cmp     eax, [ebp+arg_C]
130. .text:7517FD54                 jbe     short loc_7517FD66
131. .text:7517FD56                 mov     ecx, [ebp+arg_10]
132. .text:7517FD59                 test    ecx, ecx
133. .text:7517FD5B                 jz      short loc_7517FD5F
134. .text:7517FD5D                 mov     [ecx], eax
135. .text:7517FD5F
136. .text:7517FD5F loc_7517FD5F:                           ; CODE XREF: sub_7517FC68+F3j
137. .text:7517FD5F                 mov     eax, 84Bh
138. .text:7517FD64                 jmp     short loc_7517FD7A
139. .text:7517FD66 ; ------------------------------------------------------------
140. .text:7517FD66 loc_7517FD66:                           ; CODE XREF: sub_7517FC68+ECj
141. .text:7517FD66                 lea     eax, [ebp+Dest]
142. .text:7517FD6C                 push    eax             ; Source
143. .text:7517FD6D                 push    [ebp+arg_8]     ; Dest
144. .text:7517FD70                 call    ds:__imp_wcscpy
145. .text:7517FD76                 pop     ecx
146. .text:7517FD77                 xor     eax, eax
147. .text:7517FD79                 pop     ecx
148. .text:7517FD7A
149. .text:7517FD7A loc_7517FD7A:                           ; CODE XREF: sub_7517FC68+D9j
150. .text:7517FD7A                                         ; sub_7517FC68+FCj
151. .text:7517FD7A                 pop     edi
152. .text:7517FD7B                 pop     esi
153. .text:7517FD7C                 pop     ebx
154. .text:7517FD7D                 leave
155. .text:7517FD7E                 retn    14h
156. .text:7517FD7E sub_7517FC68    endp
157. .text:7517FD7E

如上所述，程序对字符串的长度限定是unicode的0x411个字符，也就是0x822个字节，而程序仅仅分配了0x414个字节的空间，于是就出现了缓冲区溢出的隐患。

对于函数sub_7517FC68而言，它有两个参数是需要我们特别留意的，一个是Source，另一个是Str。由于前者已经被限定了长度，最多只能0x206个字节，所以我们只能拿后者做文章。那么这两个参数在NetpwPathCanonicalize()函数中是什么形态呢？经过分析可知，Str这个参数正是NetpwPathCanonicalize()函数的第一个参数，而Source则是第四个参数：

图5

也就是说，我们可以构造一个程序，让它加载Netapi32.dll这个动态链接库，并调用其中的NetpwPathCanonicalize()函数，精心构造这个函数的第一和第四个参数的内容，那么就可以实现漏洞的利用了。

函数NetpwPathCanonicalize()说明

其实经过上述分析，我们就可以知道NetpwPathCanonicalize()函数的大概功能了。其实关于这个函数，微软是没有给我们任何介绍的，现在对于这个函数功能的讲解，都是前辈们通过类似于我们上述的逆向分析而总结出来的。由此可见，逆向工程确实是计算机领域中最富挑战性的工作之一。

函数NetpwPathCanonicalize()用于格式化网络路径字符串，其定义如下：

1. void NetpwPathCanonicalize(
2. _in_       dword Str,                  // +8h
3. _out_      dword lpWideCharStr,        // +0Ch
4. _in_       dword arg_8,                // +10h
5. _in_       dword Source,               // +14h
6. _in_out_  dword arg_10,                // +18h
7. _in_       dword arg_14                // +1Ch
8. );

参数说明：

Str：指向Unicode字串的指针，用于生成路径字串的第二部分。

lpWideCharStr：指向buffer的指针，用于接收格式化后的字符串。

arg_8：表明lpWideCharStr的大小

Source：指向Unicode字串的指针，用于生成路径字串的第一部分。

arg_10：指向long的指针。

arg_14：标志位，一般为0。

函数的功能是把Source指的字符串，加上‘\’，再加上Str指的字符串，放在lpWideCharStr的buffer里。即

Source+ ‘\’ + Str => lpWideCharStr[arg_8]

小结

经过上述一系列的分析，我们已经弄清楚了漏洞出现的原因以及利用方法。那么对于这个漏洞的实际利用，我会在下一次的讲解中，结合动态调试，编程实现。