6475 字
32 分钟
【海丰杯 2026】全 20 题 Writeup:从签到到百度壳

海丰杯 2026 全 20 题 Writeup#

比赛又名:2026第五届甘肃省大学生网络安全竞赛-信息安全实践能力赛 这里简称海丰杯。

这篇是赛后复现向的完整记录。比赛现场很多题是“知道思路就 30 秒”,但赛后把每一步重新跑一遍,才发现坑都在细节里:JPEG 的 EOI 后面还有 40 字节、PNG 的 IHDR 高度被改、Nuitka 编译出来的程序本体只打印空密文……

环境:Windows 11 + PowerShell 7 + Python 3.11 + TShark 4.7 + 7-Zip 26 + IDA 8.3 + jadx + apktool。
工具:恒烈CTF编码工具箱(EBCTF)、LovelySpark 流量取证、pycryptodome、scapy、UnRAR。

20 题,20 个 Flag,一篇写完。


目录#


0. Flag 速查(剧透折叠)#

点开看 20 个 Flag(建议先自己做一遍)
#题目Flag
01签到flag{01f94223-76d6-435b-ab52-654bc3f7e804}
02致远OA / 神秘的对话flag{an4lyz3d_th3_tr4ff1c_l1k3_a_pr0}
03challenge.exeflag{9e633561-2181-4f9b-a13b-afe1796bc20b}
04日志分析flag{201C9EF8B1631BBED036066C9A4B3C7E}
05苹果香flag{havenicedayman}
06二维码RAR / 解密图片flag{sfdeuifhvsifen51656145}
07checkme.exeflag{842e459c-bef0-43db-be69-afd41ea09daa}
08PlainFlag.apkCTF{d1r3ct_1n_c0d3}
09损坏的二维码flag{qr_rep@ir_2025}
10challenge.pcapflag{weur_zopcz}
11ping.pcapngflag{ec7553e42cad6f1007645ba062f7e8ee}
12encrypted.binCTF{x0r_1s_fun_but_weak}
13Web 1706flag{9049bddf4cdf7531d4ae78f28ba6b1f3}
14tp.capflag{ffllaaggNh4HHMq1MJ}
15icmp_whisperCTF{1cmp_1s_n0t_jus7_p1ng}
16secret_uploadflag{1cMp_St3g0_4nd_Z1p_Cr4ck}
17pac.pcapngflag1{dd73a692d474f6b3f4d668ff6cd37f51}-flag2{451708cd-f7a8-49ae-ae58-f3ff1329733f}
18逆向挑战.apkflag{java_rc4_reverse_master}
19mystery.exeflag{ReversingIsFun!}
20index.htmlflag{okmnjiuhbbhuijnmko}

1. 签到:Base64 → Base32 → Hex#

项目内容
方向Misc / 编码链
附件签到.txt,184 字节
Flagflag{01f94223-76d6-435b-ab52-654bc3f7e804}

人话版:三层编码套娃,Base64 解完是 Base32,Base32 解完是十六进制字符串,最后 bytes.fromhex 出明文。

签到.txt 内容是一串 Base64:

R1kzRE1ZWldHRTNET04zQ0dNWURHTUpXR1laVFNNWlVHTVpER01SVEdNWkdJTVpY
R00zRE1OQlRHWVpHSU1aVUdNWlRHTkpXR0laR0lOUlJHWVpER05KVEdJWkdJTVpX
R00yVEdOQldHSTNER01aVEdZM0RHTlpXR1VaVFFNWlFHTTJET1pBPQ==

解码脚本:

import base64
s = open("签到.txt", "r", encoding="utf-8").read().strip()
step1 = base64.b64decode(s).decode()
print("Base64 ->", step1)
# GY3DMYZWGE3DON3CGMYDGMJW...M2DOZA=
step2 = base64.b32decode(step1).decode()
print("Base32 ->", step2)
# 666c61677b30316639343232332d373664362d343335622d616235322d3635346263336637653830347d
flag = bytes.fromhex(step2).decode()
print("Flag ->", flag)

输出:

flag{01f94223-76d6-435b-ab52-654bc3f7e804}

坑:Base32 的字符集是大写字母 + 2–7,看到 GY3D... 这种不要当成 Base64 硬解;另外 Base64 解出来的结果末尾有 =,直接 .decode() 即可。

一把梭演示: 这里用到的是恒烈CTF编码工具箱 0.1.12

恒烈CTF编码工具箱解出签到题

2. 神秘的对话 / 致远OA:HTTP 上传的 AES-ZIP#

项目内容
方向Misc / 流量分析
附件1.pcapng,42 帧
Flagflag{an4lyz3d_th3_tr4ff1c_l1k3_a_pr0}

人话版:整份流量只有一条 HTTP PUT 值得看,body 是 file= 加一个 AES-ZIP;ZIP 密码就是 URL 里的用户名 Liyoubo。

先分诊:

Terminal window
& "C:\Program Files\Wireshark\tshark.exe" -r 1.pcapng -q -z io,phs

大部分是 QQ 心跳、UDP、ICMPv6 噪声,唯一业务流是第 14 帧:

PUT /seeyon/rest/orgMember/pass/Liyoubo HTTP/1.1
Content-Length: 269
file=PK\x03\x04...

响应是 401,但这只是烟雾弹,flag 在请求体里。取第 14 帧的 http.file_data:

Terminal window
& tshark -r 1.pcapng -Y "frame.number == 14" -T fields -e http.file_data > body.hex
body = bytes.fromhex(open("body.hex").read().strip())
assert body.startswith(b"file=")
zip_data = body[5:] # 去掉 file=
open("up.zip", "wb").write(zip_data)
print(len(zip_data)) # 264

up.zip 是 WinZip AES-256 + Deflate,里面只有一个 1.txt。密码来源不用爆破:URL 路径最后一段就是用户名。

Terminal window
7z x -pLiyoubo up.zip

1.txt 内容是 Base64:

ZmxhZ3thbjRseXozZF90aDNfdHI0ZmYxY19sMWszX2FfcHIwfQo=
import base64
print(base64.b64decode("ZmxhZ3thbjRseXozZF90aDNfdHI0ZmYxY19sMWszX2FfcHIwfQo=").decode())
flag{an4lyz3d_th3_tr4ff1c_l1k3_a_pr0}

坑:

  • body 前面有 file= 五个字节,直接当 ZIP 会报 “Headers Error”;
  • ZIP 是 WinZip AES-256(method 99),不是 ZipCrypto,hashcat -m 13600 才是对的;
  • 401 不代表没数据,别被状态码劝退。

一把梭演示: 这里用到的是恒烈CTF编码工具箱 0.1.12 和 LovelySpark

这个是提取出的压缩包文件。

从流量中提取出的压缩包文件

这个是最终确定的解压密码:

确定解压密码 Liyoubo解压后的 1.txt 内容Base64 解出 flag

3. 日志分析:LOIC 的猫#

项目内容
方向Misc / 日志分析
附件文件名是 Base64 的加密 ZIP,368,970 字节
Flagflag{201C9EF8B1631BBED036066C9A4B3C7E}

人话版:文件名 Base64 解出来是一句话木马,里面 32 位字符串就是压缩密码;日志里全是 LOIC 的请求,攻击方式 DDOS,MD5 大写。

文件名:

QGV2YWwoJF9SRVFVRVNUWyc2ZTcwZDQ2YmE0YmY3YjMyNmVlYWQ5Yzc5ZjFiNTdlMiddKQ==

解码:

import base64
print(base64.b64decode("QGV2YWwoJF9SRVFVRVNUWyc2ZTcwZDQ2YmE0YmY3YjMyNmVlYWQ5Yzc5ZjFiNTdlMiddKQ==").decode())
# @eval($_REQUEST['6e70d46ba4bf7b326eead9c79f1b57e2'])

密码就是 6e70d46ba4bf7b326eead9c79f1b57e2:

Terminal window
7z x -p6e70d46ba4bf7b326eead9c79f1b57e2 <文件名>

解出 access.log(约 48001 行)。统计:

from collections import Counter
import re
lines = open("access.log", "r", encoding="utf-8", errors="ignore").read().splitlines()
ips = Counter()
ua = Counter()
hit = 0
for line in lines:
m = re.match(r'(\d+\.\d+\.\d+\.\d+)', line)
if m:
ips[m.group(1)] += 1
if "A cat is fine too. Desudesudesu~" in line:
hit += 1
print(ips.most_common(5))
print("LOIC hits:", hit)

关键现象:

  • 192.168.1.10 约 27997 条请求,请求行里反复出现 A cat is fine too. Desudesudesu~;
  • 192.168.1.11 约 13325 条,大量 HEAD 和 499;
  • 这个特征串是 LOIC 的典型指纹,结论是 DDoS。
import hashlib
print(hashlib.md5(b"DDOS").hexdigest().upper())
201C9EF8B1631BBED036066C9A4B3C7E

坑:特征串在请求行里,不在 UA 列;只统计 UA 会 0 命中。499 是客户端提前断开,不是服务端 500。


4. challenge.pcap:四次“重传”拼出一个 flag#

项目内容
方向流量 / Misc
附件challenge.pcap,722 字节,11 帧
Flagflag{weur_zopcz}

人话版:HTTP、DNS、ICMP 都是噪声;真正的内容在 54321→4444 的 4 个 TCP 包里,每个包 payload 是一段 hex,按帧序拼接再 hex 解码。

先看协议:

Terminal window
& tshark -r challenge.pcap -T fields -e frame.number -e _ws.col.Protocol -e _ws.col.Info

11 帧里:

  • GET /index.html、DNS suspicious.local、3 个 ICMP noise0/1/2;
  • 4 个发往 4444 的 TCP 包,payload 是 ASCII 的 hex 片段。

取 payload:

Terminal window
& tshark -r challenge.pcap -Y "tcp.dstport == 4444" -T fields -e tcp.payload

输出:

3636366336313637
3762373736353735
3732356637613666
3730363337613764

注意:这四段是 ASCII 的 hex 文本,还需要再 hex 解码一次:

import subprocess
tshark = r"C:\Program Files\Wireshark\tshark.exe"
out = subprocess.check_output(
[tshark, "-r", "challenge.pcap", "-Y", "tcp.dstport == 4444",
"-T", "fields", "-e", "tcp.payload"],
text=True,
)
parts = [bytes.fromhex(x) for x in out.split()]
joined = b"".join(parts)
print(joined) # b'666c61677b776575725f7a6f70637a7d'
print(bytes.fromhex(joined.decode()).decode())
flag{weur_zopcz}

坑:4 个包 seq 相同,Wireshark 会标成 [TCP Retransmission],Follow TCP Stream 只保留第一段;必须逐帧取 tcp.payload。这是一个“假重传”隐蔽通道。

一把梭演示: 这里用到的是恒烈CTF编码工具箱 0.1.12 和 LovelySpark

直接拖进去,找到“隐秘信道”,拼接这四段ASCII

LovelySpark 隐秘信道拼接四段 ASCII拼接后 hex 解码得到 flag

5. ping:ICMP 长度当密钥#

项目内容
方向流量 / Crypto
附件ping.pcapng
Flagflag{ec7553e42cad6f1007645ba062f7e8ee}

人话版:ICMP Echo 请求的 frame.len 转 ASCII 得到 Base64,解出 32 字节 AES 密钥;UDP 里的 FLAG{...} 是密文诱饵,AES-256-ECB 解完才是真 flag。

5.1 长度通道#

Terminal window
& tshark -r ping.pcapng -Y "icmp.type == 8" -T fields -e frame.len

得到 44 个数字:

78, 117, 102, 89, 52, 111, 75, 78, 74, 65, 118, 56, 81, 69, 101, 119,
86, 82, 74, 71, 106, 47, 82, 116, 119, 52, 114, 116, 55, 51, 49, 81,
113, 116, 49, 89, 112, 116, 116, 51, 98, 49, 48, 61

转字符:

import base64
lens = [78,117,102,89,52,111,75,78,74,65,118,56,81,69,101,119,
86,82,74,71,106,47,82,116,119,52,114,116,55,51,49,81,
113,116,49,89,112,116,116,51,98,49,48,61]
key_b64 = "".join(chr(x) for x in lens)
print(key_b64)
# NufY4oKNJAv8QEewVRJGj/Rtw4rt731Qqt1Yptt3b10=
key = base64.b64decode(key_b64)
print(len(key), key.hex())
# 32 36e7d8e2828d240bfc4047b05512468ff46dc38aedef7d50aadd58a6db776f5d

5.2 解 UDP 里的密文#

最后一个 UDP 包 57094 -> 12345 的 payload:

FLAG{xLxKTpaOAzI93jzFghxdJmqHJ07MmibYDTui2HEI9tp7394blngYRKI1ytZb0tPQ}

去掉 FLAG{},内层是 Base64 密文(48 字节):

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
key = bytes.fromhex("36e7d8e2828d240bfc4047b05512468ff46dc38aedef7d50aadd58a6db776f5d")
ct = base64.b64decode("xLxKTpaOAzI93jzFghxdJmqHJ07MmibYDTui2HEI9tp7394blngYRKI1ytZb0tPQ")
pt = unpad(AES.new(key, AES.MODE_ECB).decrypt(ct), 16)
print(pt) # b' ec7553e42cad6f1007645ba062f7e8ee'
print(pt.decode().strip())
ec7553e42cad6f1007645ba062f7e8ee

这个值正好是 MD5("wireshark"):

import hashlib
print(hashlib.md5(b"wireshark").hexdigest())

最终:

flag{ec7553e42cad6f1007645ba062f7e8ee}

坑:

  • 密钥是 base64.b64decode 后的 32 字节,不是把 44 字符的 Base64 串直接当 AES key;
  • 明文前面有一个空格,strip() 后才是 MD5;
  • UDP 里的 FLAG{...} 是密文,直接提交会错。

一把梭演示: 这里用到的是恒烈CTF编码工具箱 0.1.12 和 LovelySpark

这里提取出是密文,不是最终答案。

提取出的密文而非最终答案筛选主要包取长度作为密钥

筛选主要包,取长度,就是密钥。AES-ECB解密即可。

AES-ECB 解密得到 MD5

6. tp.cap:摩斯 + 佛曰 + AES#

项目内容
方向流量 / 编码 / 加密
附件tp.cap,215,007 字节
Flagflag{ffllaaggNh4HHMq1MJ}

人话版:HTTP 下载了 fr.zip 和 2.jpg;2.jpg 的 EOI 后面有摩斯密码,解出 ZIP 密码;ZIP 里是“佛曰”,用 keyfc 版算法解出 flag。

6.1 导出对象#

Terminal window
& tshark -r tp.cap --export-objects http,out

或者直接看 HTTP 请求:

GET /xycms/fr.zip 200 669 字节
GET /xycms/1.html 304
GET /xycms/2.jpg 200 196874 字节

6.2 JPEG 尾部的摩斯#

这里有个大坑:很多“导出对象”工具会按 JPEG 的 FFD9 截断,导出的 2.jpg 只有 196,834 字节,尾部 40 字节没了。必须取原始 HTTP body:

Terminal window
& tshark -r tp.cap -Y "frame.number == 212" -T fields -e http.file_data > body.hex
d = bytes.fromhex(open("body.hex").read().strip())
open("2_full.jpg", "wb").write(d)
print(len(d)) # 196874
print(repr(d[-40:])) # b' .... . .-.. .-.. ----- ..-. ---'

摩斯:

.... . .-.. .-.. ----- ..-. ---
H E L L 0 F O

得到 ZIP 密码 HELL0FO(数字 0)。

6.3 解 fr.zip#

fr.zip 也是 WinZip AES,用密码解:

Terminal window
7z x -pHELL0FO fr.zip

得到 佛曰/佛曰.txt,内容是“佛曰:……”密文。

6.4 佛曰解密#

keyfc / TudouCode 版算法:12 个关键字表示“当前字 + 下一个字组合”,每个字在 128 字表里的下标是一个字节;带关键字的字节要异或 0x80。得到字节流后 AES-CBC 解密,明文按 UTF-16LE 解。

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
TUDOU_KEYWORD = "冥奢梵呐俱哆怯諳罰侄缽皤"
TUDOU_CHAR = (
"滅苦婆娑耶陀跋多漫都殿悉夜爍帝吉利阿無南那怛喝羯勝摩伽謹波者穆僧室藝尼瑟地彌菩提蘇醯盧呼舍佛參沙伊隸麼遮闍度蒙孕薩夷迦他姪豆特逝朋輸楞栗寫數曳諦羅曰咒即密若般故不實真訶切一除能等是上明大神知三藐耨得依諸世槃涅竟究想夢倒顛離遠怖恐有礙心所以亦智道。集盡死老至"
)
text = open("佛曰.txt", encoding="utf-8").read().strip()
if text.startswith("佛曰:"):
text = text[3:].strip()
out = bytearray()
i = 0
while i < len(text):
ch = text[i]
if ch in TUDOU_KEYWORD:
out.append(TUDOU_CHAR.index(text[i + 1]) ^ 0x80)
i += 2
else:
out.append(TUDOU_CHAR.index(ch))
i += 1
key = "XDXDtudou@KeyFansClub^_^Encode!!".encode()[:32].ljust(32, b"\0")
iv = "Potato@Key@_@=_=".encode()[:16].ljust(16, b"\0")
pt = unpad(AES.new(key, AES.MODE_CBC, iv).decrypt(bytes(out)), 16)
print(pt.decode("utf-16le"))
flag{ffllaaggNh4HHMq1MJ}

坑:flag 里 ffllaagg 是双写,不要“顺手纠正”成 flag;摩斯 ----- 是数字 0,ZIP 密码是 HELL0FO 不是 HELLOFO。

一把梭演示: 这里用到的是恒烈CTF编码工具箱 0.1.12 和 LovelySpark

直接拖进去,提取这两个文件。

从流量中提取 fr.zip 与 2.jpg

得到图片拼接在后面的摩斯电码。

图片尾部拼接的摩斯电码

继续解码得到压缩包密码。

摩斯解码得到压缩包密码解压得到佛曰密文

解压得到佛曰密码,直接一把梭!!!

佛曰解密得到 flag

7. Silent Whispers in ICMP:长度就是 ASCII#

项目内容
方向Misc / 流量
附件icmp_whisper.pcapng,1026 帧
FlagCTF{1cmp_1s_n0t_jus7_p1ng}

人话版:1000 个 ICMP Type 11 是随机噪声;26 个 Type 8 Echo 请求的 payload 长度,逐个转 ASCII 就是 flag。

from scapy.all import rdpcap, IP, ICMP
pkts = rdpcap("icmp_whisper.pcapng")
flag = "".join(
chr(len(bytes(p[ICMP].payload)))
for p in pkts
if IP in p and ICMP in p and p[ICMP].type == 8
)
print(flag)
CTF{1cmp_1s_n0t_jus7_p1ng}

长度序列:

67, 84, 70, 123, 49, 99, 109, 112, 95, 49, 115, 95, 110, 48, 116, 95,
106, 117, 115, 55, 95, 112, 49, 110, 103, 125

正好是 CTF{...} 的 ASCII。

坑:

  • 只取 icmp.type == 8,Type 11 的 payload 是随机高熵数据;
  • 按抓包/帧顺序取,按时间戳排序会乱;
  • 用的是 ICMP payload 长度,不是 frame.len;若用 frame.len,以太网要减 42。

一把梭演示: 这里用到的是LovelySpark

直接就能拿下!

LovelySpark 直接解出 ICMP flag

8. secret_upload:伪装成 PNG 的 ZIP#

项目内容
方向Misc / 流量
附件secret_upload.pcapng,6 MB
Flagflag{1cMp_St3g0_4nd_Z1p_Cr4ck}

人话版:HTTP 上传了一个叫 image.png 的文件,实际是 ZIP;ZIP 密码藏在同一条流的 ICMP 包里,Base64 解出 SecretPassword!。

8.1 上传#

Terminal window
& tshark -r secret_upload.pcapng -Y "http.request" -T fields -e frame.number -e http.request.method -e http.request.uri -e http.content_length

关键帧:

2046 POST /?page=upload 374

multipart body:

------WebKitFormBoundary...
Content-Disposition: form-data; name="file"; filename="image.png"
Content-Type: image/png
PK\x03\x04... <- 实际是 ZIP

取 http.file_data,从 PK\x03\x04 截到 boundary:

import subprocess
tshark = r"C:\Program Files\Wireshark\tshark.exe"
raw = subprocess.check_output(
[tshark, "-r", "secret_upload.pcapng", "-Y", "frame.number == 2046",
"-T", "fields", "-e", "http.file_data"],
text=True,
)
body = bytes.fromhex(raw.strip())
start = body.find(b"PK\x03\x04")
end = body.find(b"\r\n------WebKit", start)
zip_data = body[start:end]
open("upload_image.zip", "wb").write(zip_data)
print(len(zip_data)) # 192

8.2 ICMP 里的密码#

全包只有一条 ICMP:

Terminal window
& tshark -r secret_upload.pcapng -Y "icmp" -T fields -e frame.number -e data.data
6269 5532566a636d56305547467a63336476636d5168

hex → ASCII:

U2VjcmV0UGFzc3dvcmQh

Base64 解码:

import base64
print(base64.b64decode("U2VjcmV0UGFzc3dvcmQh").decode())
# SecretPassword!

8.3 解压#

import zipfile
z = zipfile.ZipFile("upload_image.zip")
print(z.read("flag.txt", pwd=b"SecretPassword!").decode())
flag{1cMp_St3g0_4nd_Z1p_Cr4ck}

坑:ZIP 是传统 ZipCrypto + Store,不是 WinZip AES;zip2john 输出 $pkzip2$,别拿 hashcat -m 13600 去跑。


9. pac.pcapng:SQL 注入流量溯源#

项目内容
方向MISC / 流量 + Web 溯源
附件pac.pcapng,1.16 MB
Flagflag1{dd73a692d474f6b3f4d668ff6cd37f51}-flag2{451708cd-f7a8-49ae-ae58-f3ff1329733f}

人话版:找攻击者的内网 IP,做 MD5 得 flag1;请求参数里有一段 Base64,解出 flag2。

统计 HTTP:

Terminal window
& tshark -r pac.pcapng -Y "http.request" -T fields -e ip.src -e http.request.uri | sort

大量请求来自 192.168.17.8,目标是 111.119.241.115 的 msg.php、user.php,参数 id 里是典型 SQLi:

UNION ALL SELECT
SLEEP(5)
WAITFOR DELAY
EXTRACTVALUE
load_file(0x2f666c6167) # /flag

flag1#

import hashlib
print(hashlib.md5(b"192.168.17.8").hexdigest())
# dd73a692d474f6b3f4d668ff6cd37f51

flag2#

请求参数里有 Base64:

ZmxhZ3s0NTE3MDhjZC1mN2E4LTQ5YWUtYWU1OC1mM2ZmMTMyOTczM2Z9
import base64
print(base64.b64decode("ZmxhZ3s0NTE3MDhjZC1mN2E4LTQ5YWUtYWU1OC1mM2ZmMTMyOTczM2Z9").decode())
# flag{451708cd-f7a8-49ae-ae58-f3ff1329733f}

最终作答按平台格式拼:

flag1{dd73a692d474f6b3f4d668ff6cd37f51}-flag2{451708cd-f7a8-49ae-ae58-f3ff1329733f}

坑:flag1 是攻击者 IP 的 MD5,不是受害站 IP;flag2 的 Base64 解出来是 flag{...},但最终要写成 flag2{...} 两段格式。

一把梭能直接拿下flag2!

Base64 解出 flag2

10. 苹果香:JPEG 尾部、假 docx、Bacon#

项目内容
方向Misc / 隐写
附件audio.zip、狼戈.png、曲谱.jpg
Flagflag{havenicedayman}

人话版:狼戈.png 的 JPEG 结束符后面藏着 ZIP 密码 666616;audio.zip 里的 audio.docx 其实是 MP3;ID3 的 TPUB 帧里有 90 个 A/B,Bacon 解出 FLAGHAVENICEDAYMAN,提交时用小写。

10.1 找密码#

d = open("狼戈.png", "rb").read()
tail = d[d.rfind(b"\xff\xd9") + 2:]
print(tail)

尾部是一串 \x11 加 zipkey666616 之类的内容,正则取 6 位数字:

import re
pw = re.search(rb"\d{6}", tail).group(0)
print(pw) # b'666616'

或者你可以直接用一把梭:

PNG 尾部正则取出六位密码

10.2 解 audio.zip#

audio.zip 里是 audio.docx,但文件头是 ID3,实际是 MP3:

import pyzipper
with pyzipper.AESZipFile("audio.zip") as z:
z.pwd = pw
mp3 = z.read("audio.docx")
print(mp3[:3]) # b'ID3'

10.3 取 ID3 TPUB 帧#

pos = mp3.find(b"TPUB")
size = int.from_bytes(mp3[pos + 4:pos + 8], "big")
payload = mp3[pos + 10:pos + 10 + size]
s = payload[1:].decode("ascii")
print(len(s)) # 90
print(s)
# AABABABABBAAAAAAABBAAABBBAAAAABABABAABAAABBABABAAAAAABAAABAAAAABBAAAAABBAAAABBAAAAAAAABBAB

你也可以直接一把梭:

读取 MP3 的 ID3 TPUB 帧

10.4 Bacon 解码#

90 / 5 = 18 个字母,A=0、B=1:

msg = "".join(
chr(65 + int("".join("0" if c == "A" else "1" for c in s[i:i + 5]), 2))
for i in range(0, len(s), 5)
)
print(msg) # FLAGHAVENICEDAYMAN
print("flag{%s}" % msg[4:].lower())
flag{havenicedayman}

你也可以直接一把梭:

Bacon 解码得到 FLAGHAVENICEDAYMAN

坑:

  • 必须用 26 字母表,24 字母表会在 BBAAA=24 越界;
  • 曲谱.jpg 是干扰项;
  • Bacon 解出的是大写,平台答案用小写 flag{havenicedayman}。

11. 二维码RAR:PNG 高度修复#

项目内容
方向Misc / 图片 + 压缩包
附件二维码.rar、当场逮捕 .png
Flagflag{sfdeuifhvsifen51656145}

人话版:PNG 的 IHDR 高度被改成 573,实际是 691;底下藏着 118 行文字,给出 RAR 密码 {N666};RAR 里是一个 data URI 形式的二维码,扫码出 flag。

11.1 修 PNG#

pngcheck 报 IHDR CRC 错。IDAT 解压后的长度对应高度 691,而文件头写的是 573:

import struct, zlib
d = bytearray(open("当场逮捕 .png", "rb").read())
d[20:24] = struct.pack(">I", 691)
ln = struct.unpack(">I", d[8:12])[0]
crc = zlib.crc32(d[12:12 + 4 + ln]) & 0xffffffff
d[12 + 4 + ln:12 + 8 + ln] = struct.pack(">I", crc)
open("fixed.png", "wb").write(d)

修复后图片底部出现隐藏文字:

当场逮捕{N666}

你也可以直接一把梭:

修复 PNG 高度后出现隐藏文字

11.2 解 RAR#

密码是带花括号的 {N666}:

Terminal window
& "C:\Program Files\WinRAR\UnRAR.exe" x -p"{N666}" 二维码.rar

得到 二维码/二维码.txt,内容是 data URI:

data:image/png;base64,iVBORw0KGgo...
解压 RAR 得到 data URI 文本

11.3 扫码#

import base64, cv2, numpy as np
s = open("二维码/二维码.txt", encoding="utf-8").read()
png = base64.b64decode(s.split(",", 1)[1])
open("qr.png", "wb").write(png)
img = cv2.imdecode(np.frombuffer(png, np.uint8), cv2.IMREAD_GRAYSCALE)
print(cv2.QRCodeDetector().detectAndDecode(img)[0])

你也可以直接一把梭:

扫码得到最终 flag
flag{sfdeuifhvsifen51656145}

坑:PNG 改高度后必须重算 IHDR CRC;RAR 密码包含花括号;二维码.txt 不是纯 Base64,要按 data:image/png;base64, 切。


12. 损坏的二维码:AES-ZIP + AES-CBC#

项目内容
方向Misc / Crypto
附件17579872347861.zip
Flagflag{qr_rep@ir_2025}

人话版:ZIP 是 WinZip AES-256,密码是 Log4Shell 的 CVE-2021-44228;里面的 flag.txt 是假 flag;QR.png 扫码得到 Base64 密文,key 是 SHA256(密码),IV 是 key 前 16 字节,AES-256-CBC 解密。

12.1 解 ZIP#

Terminal window
7z x -p"CVE-2021-44228" 17579872347861.zip
  • flag.txt:flag{fake_flag_1234},假的;
  • QR.png:真正的线索。

12.2 扫码#

import cv2
img = cv2.imread("QR.png", cv2.IMREAD_GRAYSCALE)
data, _, _ = cv2.QRCodeDetector().detectAndDecode(img)
print(repr(data))
# 'doGIde+UiUIeVERp4z664Lnmiu7vD5FPRS4QnGamRgA=%%'

末尾的 %% 是 QR 内容的一部分,Base64 解码时会忽略,但 validate=True 会报错。

12.3 AES-256-CBC#

import base64, hashlib
from Crypto.Cipher import AES
ct = base64.b64decode("doGIde+UiUIeVERp4z664Lnmiu7vD5FPRS4QnGamRgA=")
key = hashlib.sha256(b"CVE-2021-44228").digest()
iv = key[:16]
pt = AES.new(key, AES.MODE_CBC, iv).decrypt(ct)
print(repr(pt))
print(pt.decode().rstrip())
b'flag{qr_rep@ir_2025} '
flag{qr_rep@ir_2025}

坑:

  • 这题用的是 NoPadding / ZeroPadding,不是 PKCS7;恒烈CTF编码工具箱的 AES 默认按 PKCS7 去填充,会报“PKCS7 填充非法”,直接用 Python 的 decrypt 不带 unpad;
  • key 是 SHA256 的 32 字节,IV 是 key 前 16 字节;
  • 明文后面是 12 个空格,不是 PKCS7 填充。

13. encrypted.bin:6 字节 XOR#

项目内容
方向Crypto
附件encrypted.bin,24 字节
FlagCTF{x0r_1s_fun_but_weak}

人话版:24 字节 XOR,密钥长度 6;用已知明文 CTF{ 和末字节 } 推出 secr3t,解出 flag。

密文:

30 31 25 09 4B 44 01 3A 52 01 6C 12 06 0B 3C 10 46 00 2C 12 06 13 58 09

已知明文头 CTF{,末字节 }:

key[0] = 0x30 ^ 'C' = 's'
key[1] = 0x31 ^ 'T' = 'e'
key[2] = 0x25 ^ 'F' = 'c'
key[3] = 0x09 ^ '{' = 'r'
key[5] = 0x09 ^ '}' = 't' # 23 mod 6 = 5

第 5 个字节按 x0r 的 x 推:

key[4] = 0x4B ^ 'x' = '3'

密钥 secr3t:

c = bytes.fromhex("303125094B44013A52016C12060B3C1046002C1206135809")
key = b"secr3t"
p = bytes(c[i] ^ key[i % 6] for i in range(len(c)))
print(p.decode())
CTF{x0r_1s_fun_but_weak}

坑:是数字 0 的 x0r,不是字母 O;重新加密后的 hex 要和原文逐字节一致。


14. index.html:五步前端解密#

项目内容
方向Crypto / 前端
附件index.html
Flagflag{okmnjiuhbbhuijnmko}

人话版:页面 JS 五关:Hex、取关键字、凯撒 +3、两栏栅栏、元音后移;最后一关的 alert 里直接写着 flag。

第一关:Hex#

print(bytes.fromhex("53 4F 53 41 4C 49 54 59 2D 43 54 46 2D 43 48 41 4C 4C 45 4E 47 45 2D 32 30 32 35".replace(" ", "")).decode())
# SOSALITY-CTF-CHALLENGE-2025

第二关:关键字#

答案 CTF。

第三关:凯撒 +3#

SOSALITY 每个字母后移 3:

S -> V
O -> R
S -> V
A -> D
L -> O
I -> L
T -> W
Y -> B

得到 VRVDOLWB。

第四关:两栏栅栏#

VRVDOLWB 分两栏:

V R V D
O L W B

按列读:

V O R L V W D B -> VORLVWDB

第五关:元音后移#

元音按 a-e-i-o-u 顺序后移一位,O -> U:

VORLVWDB -> VURLVWDB

页面源码:

alert('恭喜你,成功解密!flag{okmnjiuhbbhuijnmko}');
flag{okmnjiuhbbhuijnmko}

坑:栅栏是“两栏交错读”,不是每两个字符反转;flag 以源码为准,别照着 OCR 抄。

**一把梭:**直接Ctrl+U查看源码。。。。。。直接得到flag。对了,页面屏蔽f12和右键了,但也只是屏蔽了这两个!!!!其他都没屏蔽!

浏览器 Ctrl+U 查看到源码中的 flag

出题人坑新生的神秘代码:

出题人隐藏的提示代码

15. challenge.exe:PyInstaller 三层变换#

项目内容
方向Reverse
附件challenge.exe,6.7 MB
Flagflag{9e633561-2181-4f9b-a13b-afe1796bc20b}

人话版:PyInstaller 打包的 Python 3.12,输入经过 Base64、大小写互换、4 字符块倒序、随机 key XOR,最终和硬编码数组比较;三层都可逆。

15.1 解包#

Terminal window
pip install pyinstxtractor-ng
pyinstxtractor-ng challenge.exe

得到 challenge.pyc(Python 3.12)。用 pycdc / xdis 还原:

from xdis.unmarshal import load_code
from xdis.magics import magic2int
mi = magic2int(b"\xcb\r\r\n") # 3.12
with open("challenge.bin", "rb") as f:
co = load_code(f, mi)
print(co.co_consts)

关键类:

class FlagTransformer:
def __init__(self, seed=0xDEADBEEF):
self.rng = random.Random(seed)
self.magic = [18, 52, 86, 120]
def _phase1(self, s):
b64 = base64.b64encode(s.encode()).decode()
return ''.join(c.lower() if c.isupper() else c.upper() for c in b64)
def _phase2(self, s):
blocks = [s[i:i+4] for i in range(0, len(s), 4)]
return ''.join(b[::-1] for b in blocks)
def _phase3(self, s):
key = self._generate_key(len(s))
return bytes(ord(c) ^ key[i] for i, c in enumerate(s))
def _generate_key(self, n):
key = bytearray()
for i in range(n):
self.rng.seed((i + self.magic[i % 4]) % 65535)
key.append(self.rng.randint(0, 255))
return key

比较目标 HIDDEN_FLAG(56 字节):

HIDDEN = [
20,54,134,96,114,70,228,108,61,132,201,219,166,161,16,210,
239,35,121,109,143,200,54,51,116,243,130,32,115,129,239,190,
164,3,10,235,14,24,199,176,60,136,52,144,106,40,137,27,125,
14,150,191,5,216,87,142
]

15.2 逆回去#

import random, base64
HIDDEN = [...] # 同上
magic = [18, 52, 86, 120]
def gen_key(n):
rng = random.Random(0xDEADBEEF)
key = bytearray()
for i in range(n):
rng.seed((i + magic[i % 4]) % 65535)
key.append(rng.randint(0, 255))
return key
key = gen_key(len(HIDDEN))
stage2 = bytes(h ^ k for h, k in zip(HIDDEN, key)).decode()
stage1 = ''.join(stage2[i:i+4][::-1] for i in range(0, len(stage2), 4))
b64 = ''.join(c.lower() if c.isupper() else c.upper() for c in stage1)
print(base64.b64decode(b64).decode())
flag{9e633561-2181-4f9b-a13b-afe1796bc20b}

坑:pycdc 会把默认参数打印成 seed = (0xDEADBEEF,),实际默认值是整数 0xDEADBEEF;key 长度等于输入长度,i % len(key) 退化为 i。回放 exe 应输出 Congratulations! Flag is correct.。


16. checkme.exe:Nuitka 与空密文#

项目内容
方向Reverse
附件checkme.exe,278,528 字节
Flagflag{842e459c-bef0-43db-be69-afd41ea09daa}

人话版:Nuitka 编译的 Python 3.8 程序,本体只打印空的“密文:”;真正的密文在题面里,key/iv 在样本里,AES-CBC + ZeroPadding 解出 flag。

16.1 识别 Nuitka#

strings 能看到:

Nuitka
D:\Programming\python\pythonproject\question\jp\v15_re+decrypt\checkme.py
python38.dll
Crypto.Cipher
AEScryptor

PE 资源 RCDATA(10)/3 是 Nuitka 的 .bytecode 常量表,能解析出 key/iv。

16.2 取 key / iv#

运行时用 sitecustomize.py 钩 builtins.print,在 checkme.py:68 拿到帧全局:

key = b'zyv2nt2yw784vxtw'
iv = b'0000000000000000'
aes = AEScryptor(key, AES.MODE_CBC, iv, padding_mode='ZeroPadding', character_set='utf-8')
flag = ''
encrypted = ''
print('密文:', encrypted)

注意:字符串常量区里看到的 czyv2nt2yw784vxtw,开头的 c 是 Nuitka 的 bytes_zt tag,真实 key 是 zyv2nt2yw784vxtw;iv 同理是 0000000000000000。

16.3 解密题面密文#

题面给的密文:

un+/M4fSaQlaHd6wYAW7Xs9rh7iO3U7Ir3WGPn7Xasy+yeTwEHGcDQVZTJbXg769
import base64
from Crypto.Cipher import AES
ct = base64.b64decode("un+/M4fSaQlaHd6wYAW7Xs9rh7iO3U7Ir3WGPn7Xasy+yeTwEHGcDQVZTJbXg769")
key = b"zyv2nt2yw784vxtw"
iv = b"0000000000000000"
pt = AES.new(key, AES.MODE_CBC, iv).decrypt(ct)
print(repr(pt))
print(pt.rstrip(b"\x00").decode())
b'flag{842e459c-bef0-43db-be69-afd41ea09daa}\x00\x00\x00\x00\x00\x00'
flag{842e459c-bef0-43db-be69-afd41ea09daa}

坑:

  • 样本本体 flag='',ZeroPadding 下 encrypt('') == '',所以只输出空的“密文:”,不是程序坏了;
  • 题面密文的 OCR 容易把 O/0、I/r 看错,错误的串会解出乱码;
  • 用 Python 的 decrypt 后手动 rstrip(b'\x00'),不要 unpad。

17. PlainFlag.apk:三段 Base64#

项目内容
方向Reverse / Android
附件PLAIN.apk
FlagCTF{d1r3ct_1n_c0d3}

人话版:jadx 打开,MainActivity.generateFlag() 直接返回三段 Base64 拼接,解码即可。

Terminal window
jadx -d plain_src --no-res PLAIN.apk

关键代码:

private String generateFlag() {
return "Q1RGew==ZDFyM2N0XzFuXw==YzBkM30=";
}

分段解码:

import base64
parts = ["Q1RGew==", "ZDFyM2N0XzFuXw==", "YzBkM30="]
print("".join(base64.b64decode(p).decode() for p in parts))
CTF{d1r3ct_1n_c0d3}

坑:搜 CTF{ 搜不到,因为字符串是拆成三段 Base64 存的;先看 generateFlag() 再解码。


18. mystery.exe:xor 0x42 与 scanf 的坑#

项目内容
方向Reverse
附件mystery.exe,54 KB
Flagflag{ReversingIsFun!}

人话版:check_password 把输入逐字节 xor 0x42,再和栈上构造的 ReversingIsFun! 比较;成功分支打印 flag{目标串}。正常输入因为 0x0B 会被 scanf("%49s") 截断,所以直接跑反而过不了。

18.1 关键反汇编#

目标串不是连续字符串,而是 15 条 mov byte ptr [rbp-0x60+off], imm8:

00401562 mov byte ptr [rbp-60h], 52h ; 'R'
00401566 mov byte ptr [rbp-5Fh], 65h ; 'e'
...
0040159a mov byte ptr [rbp-52h], 21h ; '!'
0040159e mov byte ptr [rbp-51h], 0

异或:

004015c6 xor ecx, 42h

比较:

004015f0 call strcmp
004015f7 jnz wrong
00401600 lea rcx, "Correct! FLAG is flag{%s}\n"

18.2 求解#

target = b"ReversingIsFun!"
password = bytes(c ^ 0x42 for c in target)
print(password.hex())
print("flag{%s}" % target.decode())
1027342730312b2c250b3104372c63
flag{ReversingIsFun!}

坑:正确密码里第 9 个字节是 0x0B(垂直制表符),scanf("%49s") 会在它那里截断;要动态验证成功路径,用 cdb 在 main 里直接写缓冲区,或把 xor ecx, 42h NOP 掉再输入明文。


19. 逆向挑战.apk:百度壳静态拆解 + RC4#

项目内容
方向Reverse / Android
附件逆向挑战.apk,5.96 MB
Flagflag{java_rc4_reverse_master}

人话版:百度 sagittarius v6 加固,真实 dex 被 HKDF-SHA256 + AES-CTR 加密后 zlib 压缩放在 assets 里;静态解出真实 dex,MainActivity 用 RC4(key=ReverseMaster2024)解密硬编码 Base64。

19.1 壳结构#

classes.dex 8.6 MB 壳 + androidx/kotlin
classes2.dex 458 KB 资源类
assets/baiduprotect.md 133 B 加密元数据
assets/baiduprotect1.jar 82 KB 加密 dex bundle(331,592 字节)
assets/baiduprotect2.jar 2.6 KB 加密 dex bundle(4,464 字节)
assets/baiduprotect3.jar 91 KB 加密 dex bundle(196,864 字节)
lib/*/libbaiduprotect.so 壳 native

.i.dex 是占位,主体全 0,只保留真实 dex 的大小。

19.2 解密 .rodata#

第一个 .init_array 把 .rodata 改成 RWX,然后 8 字节循环 XOR:

key = bytes([0x67,0x69,0xBD,0xE7,0x11,0xD1,0x54,0x3C])
for i in range(0x62400, 0x673b4):
d[i] ^= key[(i - 0x62400) & 7]

解密后能看到:

minic0
init_meta_data
dex_decrypt
DexBundleFileV1
DexBundleFileV2
83d4e5534f4e330e
97f3a59f2ae61f3a

最后两个是 HKDF 的 salt / info。

19.3 HKDF + AES-CTR + zlib#

import hashlib, hmac, struct, zlib
from Crypto.Cipher import AES
SALT = b"83d4e5534f4e330e"
INFO = b"97f3a59f2ae61f3a"
def hkdf(ikm, n=32):
prk = hmac.new(SALT, ikm, hashlib.sha256).digest()
out, t, c = b"", b"", 1
while len(out) < n:
t = hmac.new(prk, t + INFO + bytes([c]), hashlib.sha256).digest()
out += t
c += 1
return out[:n]
def minic0(data, ikm, prefix):
m = hkdf(ikm)
key = m[:16]
counter = m[16:28] + b"\x00\x00\x00\x00"
aes = AES.new(key, AES.MODE_CTR, nonce=b"", initial_value=int.from_bytes(counter, "big"))
return aes.decrypt(data[:prefix]) + data[prefix:]
meta_enc = open("assets/baiduprotect.md", "rb").read()
meta = minic0(meta_enc, b"assets/baiduprotect.md", len(meta_enc))
print(meta[:4]) # b'md01'

元数据解析:

dex_count = struct.unpack_from("<I", meta, 0x44)[0]
dex_sizes = list(struct.unpack_from("<" + "I" * dex_count, meta, 0x48))
bundle_ikm = meta[0x14:0x24]
print(dex_count, dex_sizes, bundle_ikm.hex())
# 3 [331592, 4464, 196864] 6452cc5dc9235ece19d33154e7fb767e

解三个 bundle:

for i, size in enumerate(dex_sizes, 1):
enc = open(f"assets/baiduprotect{i}.jar", "rb").read()
comp = minic0(enc, bundle_ikm, 256)
dex = zlib.decompress(comp)
assert len(dex) == size and dex.startswith(b"dex\n035\x00")
open(f"baiduprotect{i}.dex", "wb").write(dex)

19.4 真实 dex 里的 RC4#

反编译 baiduprotect2.dex,MainActivity:

private String getEncryptedBase64() {
return "8nn3vb6LdNrkAyXkB94ozAQbVgDFC2b8GpT7CWs=";
}
private String getKey() {
return "ReverseMaster2024";
}

RC4 解密:

import base64
b64 = "8nn3vb6LdNrkAyXkB94ozAQbVgDFC2b8GpT7CWs="
key = b"ReverseMaster2024"
data = base64.b64decode(b64)
S = list(range(256))
j = 0
for i in range(256):
j = (S[i] + j + key[i % len(key)]) & 255
S[i], S[j] = S[j], S[i]
out, i, j = bytearray(), 0, 0
for c in data:
i = (i + 1) & 255
j = (S[i] + j) & 255
S[i], S[j] = S[j], S[i]
out.append(c ^ S[(S[i] + S[j]) & 255])
print(out.decode())
flag{java_rc4_reverse_master}

坑:

  • .i.dex 不是真实 dex,主体全 0,只保留大小;
  • baiduprotectN.jar 只解密前 256 字节,不是整个文件都 AES-CTR;
  • 三个 dex 的大小必须和元数据里的 dex_sizes 逐一对上,否则说明 HKDF 参数或 prefix_len 错了;
  • 百度壳的 libbaiduprotect.so 主要是壳,题目逻辑在解出来的 baiduprotect2.dex;
  • RC4 回加密后的 Base64 应该和 8nn3... 完全一致。

20. Web 1706:注释里的密码字典#

项目内容
方向Web / 密码爆破
附件无(在线容器)
Flagflag{9049bddf4cdf7531d4ae78f28ba6b1f3}

人话版:登录框用户名 HNGS,页面源码注释里给了密码字典,爆破命中 iloveyou520。

登录页:

https://aqjs.gshfns.com/ABC/A/1706/index.php
  • admin 输入框的 placeholder 是 HNGS,用户名就是 HNGS;
  • 页面底部注释有完整密码字典;
  • 失败提示“密码输入错误”,成功返回“恭喜你,获得通关KEY”。
import re, requests, urllib3
urllib3.disable_warnings()
url = "https://aqjs.gshfns.com/ABC/A/1706/index.php"
s = requests.Session()
s.verify = False
r = s.post(url, data={"admin": "HNGS", "pass": "iloveyou520"}, timeout=15)
print(re.search(r"flag\{[0-9a-f]+\}", r.text).group(0))
flag{9049bddf4cdf7531d4ae78f28ba6b1f3}

坑:题目容器赛后已关闭,这一节是按比赛记录和页面源码整理的,不能现场重放;用户名不是 admin,是 HNGS。


附录:工具、脚本与复盘#

A.1 常用工具#

工具用途
恒烈CTF编码工具箱(EBCTF)Base64/Base32/Hex/佛曰/AES/RC4/Bacon/二维码;在线使用 · 下载
LovelySparkpcap 分诊、HTTP 对象、ICMP/协议模块、证据检索
TShark字段提取、流跟踪、导出对象
7-Zip / UnRARZIP(含 AES)/ RAR5
pycryptodomeAES / RC4
scapy自定义 pcap 解析
IDA 8.3PE / ELF 反汇编
jadx / apktoolAPK / dex
pyinstxtractor-ng + pycdcPyInstaller
pyzipperWinZip AES ZIP

A.2 这次踩过的坑(按题)#

  • 致远OA:body 前有 file=,ZIP 是 AES-256,401 是烟雾弹。
  • challenge.pcap:假重传,seq 相同但 payload 不同。
  • ping:UDP 里的 FLAG{} 是密文;明文前导空格。
  • tp.cap:JPEG 导出会截断 FFD9 后的摩斯。
  • icmp:按时间戳排序会乱,要按帧序。
  • secret_upload:ZipCrypto 不是 AES。
  • 苹果香:Bacon 大写,提交小写;RAR 密码带花括号。
  • 损坏二维码:NoPadding 不是 PKCS7;QR 末尾有 %%。
  • checkme:样本本体输出空;key 前的 c 是 tag。
  • mystery:正确密码含 0x0B,scanf 读不全。
  • APK:.i.dex 是占位;真实逻辑在 baiduprotect2.dex。

A.3 一句话复盘#

这场比赛的 Misc 不难,难在“别被工具替你做的决定骗了”:

  • 导出对象工具会按文件格式截断,尾部数据就没了;
  • GUI 的 AES 默认 PKCS7,遇到 NoPadding 的题会报错;
  • 流量工具的“重传”标记不一定真,逐帧看 payload 才靠谱;
  • 加固 APK 的壳只是壳,静下心把 .rodata 和 assets 拆完,业务代码就在里面。

祝下次比赛少踩坑,多拿分。

本文使用了AI润色。

【海丰杯 2026】全 20 题 Writeup:从签到到百度壳
https://eb.xbdqwq.com/post/hf2026/
作者
恒烈 · Henglie
发布于
2026-11-01
许可协议
CC BY-NC-SA 4.0

分享文章

生成精美分享图或复制链接,与更多人分享本文。

继续阅读

沿着主题读

基于共同的标签与分类

换条路线

从其他文章中稳定抽取

评论