6.1.4 pwn BackdoorCTF2017 Fun-Signals

    在开始这一切之前，我想先讲一下 Linux 的系统调用。64 位和 32 位的系统调用表分别在 和 /usr/include/asm/unistd_32.h 中，另外还需要查看 /usr/include/bits/syscall.h。

    一开始 Linux 是通过 int 0x80 中断的方式进入系统调用，它会先进行调用者特权级别的检查，然后进行压栈、跳转等操作，这无疑会浪费许多资源。从 Linux 2.6 开始，就出现了新的系统调用指令 sysenter/sysexit，前者用于从 Ring3 进入 Ring0，后者用于从 Ring0 返回 Ring3，它没有特权级别检查，也没有压栈的操作，所以执行速度更快。

    如图所示，当有中断或异常产生时，内核会向某个进程发送一个 signal，该进程被挂起并进入内核（1），然后内核为该进程保存相应的上下文，然后跳转到之前注册好的 signal handler 中处理相应的 signal（2），当 signal handler 返回后（3），内核为该进程恢复之前保存的上下文，最终恢复进程的执行（4）。

    • 一个 signal frame 被添加到栈，这个 frame 中包含了当前寄存器的值和一些 signal 信息。
    • 一个新的返回地址被添加到栈顶，这个返回地址指向 sigreturn 系统调用。
    • signal handler 被调用，signal handler 的行为取决于收到什么 signal。
    • signal handler 执行完之后，如果程序没有终止，则返回地址用于执行 sigreturn 系统调用。
    • sigreturn 利用 signal frame 恢复所有寄存器以回到之前的状态。
    • 最后，程序执行继续。

    不同的架构会有不同的 signal frame，下面是 32 位结构，sigcontext 结构体会被 push 到栈中：

    下面是 64 位，push 到栈中的其实是 ucontext_t 结构体：

    1. // defined in /usr/include/sys/ucontext.h
    2. /* Userlevel context.  */
    3. typedef struct ucontext_t
    4.   {
    5.     unsigned long int uc_flags;
    6.     struct ucontext_t *uc_link;
    7.     stack_t uc_stack;           // the stack used by this context
    8.     mcontext_t uc_mcontext;     // the saved context
    9.     sigset_t uc_sigmask;
    10.     struct _libc_fpstate __fpregs_mem;
    11.   } ucontext_t;
    13. // defined in /usr/include/bits/types/stack_t.h
    14. /* Structure describing a signal stack.  */
    15. typedef struct
    16.   {
    17.     void *ss_sp;
    18.     size_t ss_size;
    19.     int ss_flags;
    20.   } stack_t;
    22. // difined in /usr/include/bits/sigcontext.h
    23. struct sigcontext
    24.   __uint64_t r8;
    25.   __uint64_t r9;
    26.   __uint64_t r10;
    27.   __uint64_t r11;
    28.   __uint64_t r12;
    29.   __uint64_t r13;
    30.   __uint64_t r14;
    31.   __uint64_t r15;
    32.   __uint64_t rdi;
    33.   __uint64_t rsi;
    34.   __uint64_t rbp;
    35.   __uint64_t rbx;
    36.   __uint64_t rdx;
    37.   __uint64_t rax;
    38.   __uint64_t rcx;
    39.   __uint64_t rsp;
    40.   __uint64_t rip;
    41.   __uint64_t eflags;
    43.   unsigned short gs;
    44.   unsigned short fs;
    45.   unsigned short __pad0;
    46.   __uint64_t err;
    47.   __uint64_t trapno;
    48.   __uint64_t oldmask;
    49.   __uint64_t cr2;
    50.   __extension__ union
    51.     {
    52.       struct _fpstate * fpstate;
    53.       __uint64_t __fpstate_word;
    54.     };
    55.   __uint64_t __reserved1 [8];
    56. };

    就像下面这样：

    SROP，即 Sigreturn Oriented Programming，正是利用了 Sigreturn 机制的弱点，来进行攻击。

    首先系统在执行 sigreturn 系统调用的时候，不会对 signal 做检查，它不知道当前的这个 frame 是不是之前保存的那个 frame。由于 sigreturn 会从用户栈上恢复恢复所有寄存器的值，而用户栈是保存在用户进程的地址空间中的，是用户进程可读写的。如果攻击者可以控制了栈，也就控制了所有寄存器的值，而这一切只需要一个 gadget：syscall; ret;。

    另外，这个 gadget 在一些系统上没有被内存随机化处理，所以可以在相同的位置上找到，参照下图：

    img

    通过设置 eax/rax 寄存器，可以利用 syscall 指令执行任意的系统调用，然后我们可以将 sigreturn 和 其他的系统调用串起来，形成一个链，从而达到任意代码执行的目的。下面是一个伪造 frame 的例子：

    rax=59 是 execve 的系统调用号，参数 rdi 设置为字符串“/bin/sh”的地址，rip 指向系统调用 syscall，最后，将 rt_sigreturn 设置为 sigreturn 系统调用的地址。当 sigreturn 返回后，就会从这个伪造的 frame 中恢复寄存器，从而拿到 shell。

    img

    • 首先利用一个栈溢出漏洞，将返回地址覆盖为一个指向 sigreturn gadget 的指针。如果只有 syscall，则将 RAX 设置为 0xf，也是一样的。在栈上覆盖上 fake frame。其中：
      • RSP：一个可写的内存地址
      • RIP：syscall; ret; gadget 的地址
      • RAX：read 的系统调用号
      • RDI：文件描述符，即从哪儿读入
      • RSI：可写内存的地址，即写入到哪儿
      • RDX：读入的字节数，这里是 306
    • sigreturn gadget 执行完之后，因为设置了 RIP，会再次执行 syscall; ret; gadget。payload 的第二部分就是通过这里读入到文件描述符的。这一部分包含了 3 个 syscall; ret;，fake frame 和其他的代码或数据。
    • 接收完数据或，read 函数返回，返回值即读入的字节数被放到 RAX 中。我们的可写内存被这些数据所覆盖，并且 RSP 指向了它的开头。然后 syscall; ret; 被执行，由于 RAX 的值为 306，即 syncfs 的系统调用号，该调用总是返回 0，而 0 又是 read 的调用号。
    • 再次执行 syscall; ret;，即 read 系统调用。这一次，读入的内容不重要，重要的是数量，让它等于 15，即 sigreturn 的调用号。
    • 执行 execve，拿到 shell。

    在 pwntools 中已经集成了 SROP 的利用工具，即 ，直接使用类 SigreturnFrame，我们来看一下它的构造：

    总共有三种，结构和初始化的值会 有所不同：

    • i386 on i386：32 位系统上运行 32 位程序
    • i386 on amd64：64 位系统上运行 32 位程序
    • amd64 on amd64：64 为系统上运行 64 位程序
    1. $ file funsignals_player_bin
    2. funsignals_player_bin: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

    这是一个 64 位静态链接的 srop，可以说是什么都没开。。。

    1. gdb-peda$ disassemble _start
    2. Dump of assembler code for function _start:
    3.    0x0000000010000000 <+0>:     xor    eax,eax
    4.    0x0000000010000002 <+2>:     xor    edi,edi
    5.    0x0000000010000004 <+4>:     xor    edx,edx
    6.    0x0000000010000006 <+6>:     mov    dh,0x4
    7.    0x0000000010000008 <+8>:     mov    rsi,rsp
    8.    0x000000001000000b <+11>:    syscall
    9.    0x000000001000000d <+13>:    xor    edi,edi
    10.    0x000000001000000f <+15>:    push   0xf
    11.    0x0000000010000011 <+17>:    pop    rax
    12.    0x0000000010000012 <+18>:    syscall
    13.    0x0000000010000014 <+20>:    int3
    14. End of assembler dump.
    15. gdb-peda$ disassemble syscall
    16. Dump of assembler code for function syscall:
    17.    0x0000000010000015 <+0>:     syscall
    18.    0x0000000010000017 <+2>:     xor    rdi,rdi
    19.    0x000000001000001a <+5>:     mov    rax,0x3c
    20.    0x0000000010000021 <+12>:    syscall
    21. End of assembler dump.
    22. gdb-peda$ x/s flag
    23. 0x10000023 <flag>:      "fake_flag_here_as_original_is_at_server"

    而且 flag 就在二进制文件里，只不过是在服务器上的那个里面，过程是完全一样的。

    首先可以看到 _start 函数里有两个 syscall。第一个是 read(0, $rsp, 0x400)（调用号0x0），它从标准输入读取 0x400 个字节到 rsp 指向的地址处，也就是栈上。第二个是 sigreturn()（调用号0xf），它将从栈上读取 sigreturn frame。所以我们就可以伪造一个 frame。

    那么怎样读取 flag 呢，需要一个 write(1, &flag, 50)，调用号为 0x1，而函数 syscall 正好为我们提供了 syscall 指令，构造 payload 如下：

    1. $ python2 exp_funsignals.py
    2. [*] '/home/firmy/Desktop/funsignals_player_bin'
    3.     Arch:     amd64-64-little
    4.     RELRO:    No RELRO
    5.     Stack:    No canary found
    6.     NX:       NX disabled
    7.     PIE:      No PIE (0x10000000)
    8.     RWX:      Has RWX segments
    9. [+] Opening connection to 127.0.0.1 on port 10001: Done
    10. [*] Switching to interactive mode
    11. fake_flag_here_as_original_is_at_server\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00[*] Got EOF while reading in interactive

    这一节我们详细介绍了 SROP 的原理，并展示了一个简单的例子，在后面的章节中，会展示其更复杂的运用，包扩结合 vDSO 的用法。