Plugins

分享推荐实用的WordPress插件

WordPress

记录分享WordPress使用经验和技巧

Web前端

分享Web前端设计理念及技术

设计资源

搜刮来的设计资源

【长三角WP】长三角网络安全攻防大赛初赛WP（Misc&Crypto&数据安全）"

admin

0
文章

0
评论

2026-10-15 16:04:45 网络安全文章来源：ZONE.CI 全球网 0 阅读模式

【长三角WP】长三角网络安全攻防大赛初赛WP（Misc&Crypto&数据安全）

赛查查

2026年10月13日 15:15
北京

在小说阅读器读本章

去阅读

在公众号小说中沉浸阅读

以下文章来源于小杉泽 Sec
，作者小杉泽

小杉泽%20Sec
.

小杉泽%20Sec

Misc git\_echo 从完整 .git 找回不可达提交

当前 HEAD 位于 refs/heads/main，可见提交是 89316b3。先扫描对象库：

git%20-C%20project_backup%20status%20--short%20--branch
git%20-C%20project_backup%20show-ref
git%20-C%20project_backup%20fsck%20--full%20--no-reflogs%20--unreachable%20--no-progress

fsck 报出三个%20dangling%20commit%20以及三个对应的%20banner%20blob：

2bfddca0a56f7f5f6aaac60b06ac58b41de6d004
b31a305c11f473991a7c326e8bd0e769e384cb4f
be7aaf7e82a116eacb436b14835541dfe9fd5778

沿%20parent%20指针读取历史：

git%20-C%20project_backup%20log%20--oneline%20--reverse%20be7aaf7

得到：

89316b3%20initial%20production%20snapshot
2bfddca%20automated%20banner%20render%201
b31a305%20automated%20banner%20render%202
be7aaf7%20automated%20banner%20render%203

提交	父提交	作用
`89316b336e58ddc69d8179c4b602891615d51054`	—	当前%20production%20snapshot
`2bfddca0a56f7f5f6aaac60b06ac58b41de6d004`	`89316b3`	automated%20banner%20render%201
`b31a305c11f473991a7c326e8bd0e769e384cb4f`	`2bfddca`	automated%20banner%20render%202
`be7aaf7e82a116eacb436b14835541dfe9fd5778`	`b31a305`	automated%20banner%20render%203

用 ls-tree 检查三棵树可见的文件，确认后续提交只替换 banner.png：

git -C project_backup ls-tree -r 2bfddca
git -C project_backup ls-tree -r b31a305
git -C project_backup ls-tree -r be7aaf7

以二进制方式导出，避免 PowerShell 管道对 PNG 字节做编码转换：

git --git-dir=project_backup/.git show 2bfddca:banner.png > render1.png
git --git-dir=project_backup/.git show b31a305:banner.png > render2.png
git --git-dir=project_backup/.git show be7aaf7:banner.png > render3.png

版本	Blob SHA-1	大小	属性
render 1	`b41e22bbce73d5214f28363932b2418def0be767`	126,572 B	720×720 RGB；通道值仅 0/255
render 2	`383ab1ff7a7936407ee08a162fdeaa21ec367e7b`	126,576 B	720×720 RGB；通道值仅 0/255
render 3	`1c068d05031d3943cbc95853c8ac4aa5c21d33ff`	126,687 B	720×720 RGB；通道值仅 0/255

Crypto

byte\_257

加密算法分析

task.py 的核心逻辑如下：

MODULUS=257

defencrypt(data: bytes, a: int, b: int, state: int) ->bytes:
    encrypted= []
    forvalueindata:
        encrypted.append((value+state) %MODULUS)
        state= (a*state+b) %MODULUS
    returnb\"\".join(struct.pack(\"<H\", value) forvalueinencrypted)

对第 i 个明文字节 p_i，加密状态记为 s_i，则：

$c\_i=(p\_i+s\_i)\bmod 257$

$s\_{i+1}=(a s\_i+b)\bmod 257$

注意输出使用小端 uint16 保存，因此 encrypted_image.bin 的 14590 字节对应 7295 个密文数值，而不是 14590 个明文字节。

密文中确实出现了数值 256（共 31 次）；这也正好对应提示语 “A byte can count past 255”，说明不能把文件直接按普通单字节流读取。

利用 PNG 文件头恢复状态

PNG 的固定文件头为：

明文 p: 89 50 4E 47 0D 0A 1A 0A

密文前 8 个小端 uint16 值为：

c: 165 80 219 172 242 35 87 110

由 s_i = (c_i - p_i) mod 257 得到前 8 个状态：

s: 28 0 141 101 229 25 61 100

逐项对应关系如下（密文列是按 <H 解包后的数值）：

`i`	`p_i`\\（HEX）\\	`c_i`	`s_i=(c_i-p_i) mod 257`
0	`89`	165	28
1	`50`	80	0
2	`4E`	219	141
3	`47`	172	101
4	`0D`	242	229
5	`0A`	35	25
6	`1A`	87	61
7	`0A`	110	100

只使用前三个状态即可解出 LCG 参数：

s1 = a*s0 + b = 0       (mod 257)
s2 = a*s1 + b = b = 141 (mod 257)

所以：

b = 141
28*a + 141 = 0 (mod 257)
28*a = 116 (mod 257)

因为 28⁻¹ = 101 (mod 257)，得到：

a = 116*101 mod 257 = 151
b = 141
s0 = 28

用参数递推得到的状态序列前几项为：

28, 0, 141, 101, 229, 25, 61, 100, ...

与 PNG 文件头计算出的状态完全一致。

完整EXP

逆运算为：

$p\_i=(c\_i-s\_i)\bmod 257$

importstruct
importsys
importbinascii
importzlib
frompathlibimportPath

MODULUS=257
PNG_HEADER=b\"\\x89PNG\\r\
\\x1a\
\"

defrecover(input_path: Path, output_path: Path) ->None:
    raw=input_path.read_bytes()
    iflen(raw) %2:
        raiseValueError(\"密文长度不是 2 的倍数\")

    values= [vfor (v,) instruct.iter_unpack(\"<H\", raw)]

    # 由已知 PNG 头自动求出前几个状态，再解 LCG 参数。
    first_states= [
        (values[i] -PNG_HEADER[i]) %MODULUS
        foriinrange(len(PNG_HEADER))
    ]
    s0, s1, s2=first_states[:3]
    delta= (s1-s0) %MODULUS
    a= ((s2-s1) *pow(delta, -1, MODULUS)) %MODULUS
    b= (s1-a*s0) %MODULUS

    # 用已知头校验求出的参数。
    check=s0
    forexpectedinfirst_states:
        assertcheck==expected
        check= (a*check+b) %MODULUS

    plain=bytearray()
    state=first_states[0]
    forvalueinvalues:
        decoded= (value-state) %MODULUS
        ifdecoded>255:
            raiseValueError(\"解密结果不是合法字节\")
        plain.append(decoded)
        state= (a*state+b) %MODULUS

    ifbytes(plain[:8]) !=PNG_HEADER:
        raiseValueError(\"PNG 头校验失败\")

    # 解析 PNG 块并校验 CRC/IDAT，避免只凭文件头误判。
    pos=8
    chunks= []
    idat=bytearray()
    ihdr=None
    whilepos<len(plain):
        ifpos+12>len(plain):
            raiseValueError(\"PNG 块头截断\")
        size=struct.unpack(\">I\", plain[pos:pos+4])[0]
        kind=bytes(plain[pos+4:pos+8])
        end=pos+12+size
        ifend>len(plain):
            raiseValueError(\"PNG 块数据截断\")
        payload=bytes(plain[pos+8:pos+8+size])
        expected_crc=struct.unpack(\">I\", plain[pos+8+size:end])[0]
        actual_crc=binascii.crc32(kind+payload) &0xffffffff
        ifexpected_crc!=actual_crc:
            raiseValueError(f\"PNG CRC 错误: {kind!r}\")
        chunks.append((kind, size))
        ifkind==b\"IHDR\":
            ihdr=payload
        elifkind==b\"IDAT\":
            idat.extend(payload)
        pos=end
        ifkind==b\"IEND\":
            break
    ifpos!=len(plain) orchunks[-1][0] !=b\"IEND\":
        raiseValueError(\"PNG 未正常结束\")
    ifihdrisNoneorlen(ihdr) !=13:
        raiseValueError(\"缺少合法 IHDR\")
    zlib.decompress(bytes(idat))

    output_path.write_bytes(plain)
    print(f\"a={a}, b={b}, s0={first_states[0]}\")
    print(f\"recovered {len(plain)} bytes -> {output_path}\")
    print(\"PNG chunks:\", [(k.decode('ascii'), n) fork, ninchunks], \"CRC OK\")

if__name__==\"__main__\":
    iflen(sys.argv) !=3:
        raiseSystemExit(f\"用法: {sys.argv[0]} encrypted_image.bin decrypted.png\")
    recover(Path(sys.argv[1]), Path(sys.argv[2]))

本题实际解密时得到：

a=151, b=141, s0=28
recovered 7295 bytes

打开恢复的截图后，中央文字为：

flag{f257_known_header_breaks_stream}

wrapmac

算法分析

test.py 中的消息打包函数为：

defpack_record(record):
    return ((record[\"device\"] <<56) |
            (record[\"command\"] <<48) |
            (record[\"value\"] <<16) |
            record[\"counter\"])

因此 64 位消息的布局是：

63          56 55        48 47                   16 15          0
+-------------+------------+-----------------------+--------------+
|   device    |  command   |        value          |   counter    |
+-------------+------------+-----------------------+--------------+

标签算法非常简单：

tag = (a * message + b) & ((1 << 64) - 1)

即

$t \equiv a m+b \pmod {2^{64}}.$

其中 a 满足 1 ≤ a < 2^44（至多 44 位），b 是 64 位整数。flag 的生成规则是：将目标消息和目标标签分别按大端序打包为 8 字节，拼接后做 SHA-256，取摘要前 32 个十六进制字符。

解析公开记录

按 pack_record 重组得到以下消息整数（所有十六进制数均补足为 64 位）：

编号	device	command	value	counter	message \\`m`\\	tag \\`t`\\
0	126	142	748140490	20515	`0x7e8e2c97b7ca5023`	`0xf84627af4c3598c2`
1	93	44	1876572954	20515	`0x5d2c6fda3b1a5023`	`0xa5539b3490d598c2`
2	205	58	2828843097	1808	`0xcd3aa89cb8590710`	`0xc611b4e1f1430f7c`

目标记录为：

device  = 192
command = 218
value   = 2425955337
counter = 63960

利用差分恢复 `a`

对前两条合法记录作差，常数项 b 被消掉：

$\Delta t \equiv a\Delta m \pmod {2^{64}}.$

注意差分必须按无符号模 2^64 计算：

Δm = (m1 - m0) mod 2^64
   = 0xde9e434283500000
   = 0xde9e4342835 * 2^20

Δt = (t1 - t0) mod 2^64
   = 0xad0d738544a00000
   = 0xad0d738544a * 2^20

生成器明确构造了一个带 20 个尾零位的消息差，其中 0xde9e4342835 是奇数。因为两边都含有 2^20，可将方程约去这一因子，但模数同时降为 2^(64-20)=2^44：

更严格地说，2^64 | 2^20 (a·d-r) 等价于 2^44 | (a·d-r)，所以这里是在模 2^44 下求逆，而不是试图在模 2^64 下求一个偶数的逆。

$a\cdot\texttt{0xde9e4342835} \equiv \texttt{0xad0d738544a} \pmod {2^{44}}.$

奇数在模 2^44 下可逆，计算得到：

inv(0xde9e4342835, 2^44) = 0x9c944dbea1d
a = 0xa0fa1bb3062

该结果落在题目规定的 44 位范围内，因此解是唯一的；若没有这个约束，方程只会确定 a mod 2^44，还可能存在 a+ k·2^44 的 64 位提升。这里不能直接在模 2^64 下把 Δm 求逆，因为它是偶数；先约去 2^20 正是利用题目故意留下的结构。

恢复 `b`

代回第一条记录：

$b \equiv t\_0-a m\_0 \pmod {2^{64}},$

得到：

b = 0x341715e9752b5b5c

用恢复出的参数重新计算三条记录：

record 0: 0xf84627af4c3598c2  (match)
record 1: 0xa5539b3490d598c2  (match)
record 2: 0xc611b4e1f1430f7c  (match)

第三条记录并非求解所必需，但可以用来确认参数和模运算均正确。

伪造目标标签

将目标字段按同样的位布局打包：

m_target = 0xc0da90992409f9d8

计算：

t_target = (a * m_target + b) mod 2^64
         = 0x72bed45d789d800c

计算 flag

submission_flag 使用大端序，而不是把十六进制文本直接作为输入：

message = struct.pack(\">Q\", m_target)
tag = struct.pack(\">Q\", t_target)
digest = hashlib.sha256(message + tag).hexdigest()

实际拼接的 16 字节为：

c0da90992409f9d872bed45d789d800c

SHA-256 完整摘要为：

ecac2529f5bcf5960478d73d4dc7df86923a64002187dc04b0f516b921f6350b

取前 32 个十六进制字符，得到最终 flag：

flag{ecac2529f5bcf5960478d73d4dc7df86}

完整EXP

importhashlib
importjson
importstruct
frompathlibimportPath

MASK= (1<<64) -1
SHIFT=20
AMOD=1<<44

defpack_record(r):
    return ((r[\"device\"] <<56) | (r[\"command\"] <<48) |
            (r[\"value\"] <<16) |r[\"counter\"])

data=json.loads(Path(\"records.json\").read_text())
items=data[\"records\"]
m= [pack_record(x[\"record\"]) forxinitems]
t= [int(x[\"tag\"], 16) forxinitems]

dm= (m[1] -m[0]) &MASK
dt= (t[1] -t[0]) &MASK
assertdm% (1<<SHIFT) ==0
assertdt% (1<<SHIFT) ==0
q=dm>>SHIFT
r=dt>>SHIFT
assertq&1                 # q 在模 2^44 下可逆
a= (r*pow(q, -1, AMOD)) %AMOD
b= (t[0] -a*m[0]) &MASK

assertall(((a*mi+b) &MASK) ==tiformi, tiinzip(m, t))

mt=pack_record(data[\"target\"])
tt= (a*mt+b) &MASK
raw=struct.pack(\">Q\", mt) +struct.pack(\">Q\", tt)
flag=\"flag{\"+hashlib.sha256(raw).hexdigest()[:32] +\"}\"

print(f\"a = {a:#x}\")
print(f\"b = {b:#x}\")
print(f\"target tag = {tt:016x}\")
print(flag)

数据安全

shadow\_route

提取目标公开打卡

读取 public_posts.json 的 target_handle，得到 blue_fox。只保留 handle == target_handle 的记录，排除所有 guest_* 打卡，并按 UTC 时间排序：

#	`published_at`\\（UTC）\\	公开地标	`landmarks.json`\\ 映射的 `cell`\\	文本
1	`2026-07-21T09:05:00Z`	North Library	`G17-04`	nice view
2	`2026-07-23T13:10:00Z`	Riverside Cafe	`G22-11`	arrived
3	`2026-07-26T16:45:00Z`	West Stadium	`G05-19`	nice view
4	`2026-07-29T11:00:00Z`	Innovation Hall	`G31-08`	quick stop

时间直接按附件中的 UTC ISO 字符串比较，不做本地时区转换；这正好对应 mobility.csv 的 start_bucket_utc。

地标映射

完整映射如下（本题实际用到前四项）：

公开地标	粗化 cell
North Library	`G17-04`
Riverside Cafe	`G22-11`
West Stadium	`G05-19`
Innovation Hall	`G31-08`
Central Station	`G14-15`
Art Center	`G27-02`

mobility 关联方法

对每个公开观测点建立严格候选集合：

start_bucket_utc == published_at
AND
origin_cell == landmarks[landmark]

公开打卡发生在地标处，因此将地标网格与行程的 origin_cell 对齐。单条观测可能命中多个匿名 token，最后必须对四个集合求交集。

完整EXP

importbase64, csv, json
frompathlibimportPath

p=Path(\".\")
landmarks=json.loads((p/\"landmarks.json\").read_text(encoding=\"utf-8\"))
data=json.loads((p/\"public_posts.json\").read_text(encoding=\"utf-8\"))

posts=sorted(
    (xforxindata[\"posts\"] ifx[\"handle\"] ==data[\"target_handle\"]),
    key=lambdax: x[\"published_at\"],
)

with (p/\"mobility.csv\").open(newline=\"\", encoding=\"utf-8\") asf:
    trips=list(csv.DictReader(f))

sets= []
forpostinposts:
    cell=landmarks[post[\"landmark\"]]
    s= {
        r[\"anonymous_token\"]
        forrintrips
        ifr[\"start_bucket_utc\"] ==post[\"published_at\"]
        andr[\"origin_cell\"] ==cell
    }
    sets.append(s)
    print(post[\"published_at\"], post[\"landmark\"], cell, len(s), sorted(s))

common=set.intersection(*sets)
assertlen(common) ==1
token=next(iter(common))

with (p/\"support_tickets.csv\").open(newline=\"\", encoding=\"utf-8\") asf:
    tickets=list(csv.DictReader(f))

ticket=next(rforrinticketsifr[\"anonymous_token\"] ==token)
flag=base64.b64decode(ticket[\"attachment_base64\"]).decode(\"utf-8\")
print(token, ticket[\"ticket_id\"], flag)

候选集合与唯一性交集

公开观测	`origin_cell`	候选数	候选 token
2026-07-21 09:05Z / North Library	`G17-04`	2	`u_7fa56c8eb4519638`、`u_d38469e66bb02624`
2026-07-23 13:10Z / Riverside Cafe	`G22-11`	3	`u_7015a96e1582ebc6`、`u_9b4e6ea36c0969dc`、`u_d38469e66bb02624`
2026-07-26 16:45Z / West Stadium	`G05-19`	1	`u_d38469e66bb02624`
2026-07-29 11:00Z / Innovation Hall	`G31-08`	5	`u_489861491414025c`、`u_7faced49baf3938a`、`u_c3bb67b085e5a00c`、`u_d38469e66bb02624`、`u_fb2f62cb15945f67`

因此：

S1 ∩ S2 ∩ S3 ∩ S4
= {u_d38469e66bb02624}

四个集合的交集基数为 1，唯一 token 为：

u_d38469e66bb02624

关键 mobility 命中行

用唯一 token 回看 mobility.csv，四条公开打卡对应的关键行如下；该 token 在整个文件中共有 19 条行程，其余为噪声。

`start_bucket_utc`	`origin_cell`	`destination_cell`	`anonymous_token`
`2026-07-21T09:05:00Z`	`G17-04`	`G32-06`	`u_d38469e66bb02624`
`2026-07-23T13:10:00Z`	`G22-11`	`G09-16`	`u_d38469e66bb02624`
`2026-07-26T16:45:00Z`	`G05-19`	`G35-17`	`u_d38469e66bb02624`
`2026-07-29T11:00:00Z`	`G31-08`	`G24-13`	`u_d38469e66bb02624`