数据安全

接口未授权

1.

题目要求对给定流量包进行分析,找出存在未授权访问风险的 API 接口,并将这些接口按照接口字符串长度从小到大排序后输出。

提交格式示例:

/api/test-/api/users-/api/admin/info

本题本质上是一次 HTTP 流量包审计。

核心目标有两个:

  1. 从流量中找出所有被访问的 API 接口;
  2. 判断哪些接口在没有认证信息的情况下依然可以直接访问并返回有效数据,也就是“未授权访问接口”。

判断标准:

  • 请求中没有明显的认证字段,例如:
  • Authorization
  • Cookie
  • Token
  • Bearer
  • 服务端直接返回:
  • HTTP/1.1 200 OK
  • 且响应体中包含真实业务数据

这种情况即可判定为 未授权访问。

附件中核心文件为:pc.pcapng,使用 Wireshark 打开后,可以看到目标服务主要为:

172.16.5.139:50000

说明题目的 Web 服务运行在该地址与端口上。

在 Wireshark 中可以使用如下过滤条件:

http && ip.addr == 172.16.5.139 && tcp.port == 50000

这样可以只保留与目标站点相关的 HTTP 请求和响应。

继续观察请求路径,可以发现大量路径访问,其中既有普通页面,也有 API 接口。

需要重点关注形如:

/api/xxx

的请求。

在流量中,发现以下接口返回了真实业务数据:

  • /api/user/info
  • /api/get_comment
  • /api/lottery/winners
  • /api/lottery/participants
  • /api/lottery/result

下面对这几个接口逐一说明。

  1. /api/user/info

请求示例:

GET /api/user/info HTTP/1.1
Host: 172.16.5.139:50000

特点:

  • 请求中没有 Authorization、Cookie 等认证信息
  • 响应状态码为:
HTTP/1.1 200 OK
  • 返回内容中包含大量用户信息,例如:
  • username
  • birthday
  • password

这说明该接口可被未登录用户直接访问,属于典型未授权访问。

  1. /api/get_comment

请求示例:

GET /api/get_comment HTTP/1.1
Host: 172.16.5.139:50000

特点:

  • 无认证字段
  • 返回 200 OK
  • 响应体为评论数据 JSON,包含:
  • name
  • ip
  • bbs

说明评论数据可被任意读取,属于未授权访问。

  1. /api/lottery/winners

请求示例:

GET /api/lottery/winners HTTP/1.1
Host: 172.16.5.139:50000

特点:

  • 无认证信息
  • 返回 200 OK
  • 响应中直接给出中奖名单信息:
  • name
  • phone
  • prize

属于敏感业务数据未授权读取。

  1. /api/lottery/participants

请求示例:

GET /api/lottery/participants HTTP/1.1
Host: 172.16.5.139:50000

特点:

  • 无认证信息
  • 返回 200 OK
  • 响应体中存在大量参与者数据:
  • id
  • name
  • id_card
  • invoice_no

这是明显的个人敏感信息泄露,属于未授权访问。

  1. /api/lottery/result

这个接口稍微特殊。

在流量中可见:

GET /api/lottery/result HTTP/1.1

返回:

HTTP/1.1 405 METHOD NOT ALLOWED

说明 GET 不允许。

但是后续又出现了:

POST /api/lottery/result HTTP/1.1
Host: 172.16.5.139:50000
Content-Type: application/json

并返回:

HTTP/1.1 200 OK

且请求中同样没有认证信息,只是提交了 JSON 数据。

这说明虽然该接口不是 GET 方式开放,但它依旧是未授权可访问的 API,因为只要构造合法 POST 请求,就能直接访问业务接口并获得正常响应。

因此该接口也应计入未授权 API。

流量中还可以看到一些返回 200 的路径,例如:

  • /
  • /cryptodemo
  • /robots.txt

这些虽然能访问成功,但它们不是题目要找的“API 接口”,因此不纳入最终答案。

得到 5 个未授权接口:

/api/user/info
/api/get_comment
/api/lottery/result
/api/lottery/winners
/api/lottery/participants

分别计算长度:

  • /api/user/info → 14
  • /api/get_comment → 16
  • /api/lottery/result → 19
  • /api/lottery/winners → 20
  • /api/lottery/participants → 25

按长度从小到大排序后为:

/api/user/info
/api/get_comment
/api/lottery/result
/api/lottery/winners
/api/lottery/participants
/api/user/info-/api/get_comment-/api/lottery/result-/api/lottery/winners-/api/lottery/participants

2.

题目要求:

平台为了保障用户数据安全,对用户输入数据在传输过程中采用了特定加密方式。
请分析并检验该加密方法的安全性,提交加密算法对应
d 值的 MD5 作为答案。

也就是说,这题不是让我们解业务数据,而是让我们去分析它的“前端加密方案”,找到其中用到的 RSA 私钥指数 d,然后对 d 做 MD5,得到最终答案。

一、入口定位:未授权访问加密演示接口

从题目包里的流量 pc.pcapng 进行分析,可以看到存在一个未授权可访问的接口:

GET /cryptodemo HTTP/1.1

这个接口直接返回了一份前端页面,其中包含完整的加密逻辑。
这就是本题“接口未授权”的核心点:
攻击者无需登录即可获取前端加密实现细节和 RSA 公钥。

在流量里把 /cryptodemo 对应响应导出来后,可以得到页面源码。

二、审计前端源码,恢复真实加密逻辑

页面里的 JS 做了混淆,但并不难拆。还原后,关键代码逻辑如下:

const pubKey = `-----BEGIN PUBLIC KEY-----
...
-----END PUBLIC KEY-----`;

function generateAESKey() {
    let k = CryptoJS.lib.WordArray.random(0x10);
    return CryptoJS.enc.Hex.stringify(k).slice(0, 0x10);
}

function aesEncrypt(data, key) {
    let k = CryptoJS.enc.Utf8.parse(key);
    let enc = CryptoJS.AES.encrypt(
        JSON.stringify(data),
        k,
        {
            mode: CryptoJS.mode.ECB,
            padding: CryptoJS.pad.Pkcs7
        }
    );
    return enc.toString();
}

function rsaEncryptKey(aesKey) {
    let js = new JSEncrypt();
    js.setPublicKey(pubKey);
    return js.encrypt(aesKey);
}

function encryptRequest(obj) {
    let aesKey = generateAESKey();
    let data = aesEncrypt(obj, aesKey);
    let key = rsaEncryptKey(aesKey);
    return { key, data };
}

三、加密方案分析

这个方案本质上是:

  • 业务数据:用 AES-ECB-PKCS7 加密
  • AES 密钥:用 RSA 公钥 加密后一起传输

也就是典型的“前端混合加密”。

但这个实现有几个明显问题:

  1. AES 使用 ECB 模式

ECB 本身就不推荐,无法隐藏明文块模式,安全性较差。

  1. AES key 生成方式不够规范

生成了 16 字节随机数后,又转成 hex 字符串再截取前 16 位,实际参与 AES 的是 16 个 ASCII 字符,不是原始 16 字节随机密钥。

  1. RSA 公钥参数存在致命缺陷

真正决定这题能不能做出来的是这一点。

从页面提取出的 RSA 公钥如下:

-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwtBUdfuHizD6PTNkE+tn
FHdOmhiJyCbKS52I2GuDP5jYdIxU48oV72BXFbStmpvG15bcHW8RLI5Z53Ioh28N
5CqRJy7F12VaudtU9jlatJ0+OjKPBIVCFyPDZ5PmMp+rC6ICWCWJmYEi76rkvD7b
U5N+IOoKSEnAN0xJFwsJMMRnC+pnZCAtxT2d9edWz/0Fq1ArsHmwl8i0LN9ROxWb
Pz3qd2Vh++yMVMP24nGwIBZihDI/Of9X/Ne7Y3UZvngTvkGRcqAbTU3bOIDC4do1
Z/B2h8X4S7EmLS+6dX+V6TOgq3xv9/rO2s4tqgJfwC5vejH7VJhzpD3bQqunfuMCAwEAAQ==
-----END PUBLIC KEY-----

把模数 n 提出来后,可以发现它的两个素因子 p 和 q 极其接近,导致可以直接用 费马分解(Fermat Factorization) 秒出。

四、为什么能直接分解 RSA

费马分解的原理是:

若n=pqn = pqn=pq

并且 p,qp, qp,q 很接近,那么存在:n=a2−b2=(a−b)(a+b)n = a^2 - b^2 = (a-b)(a+b)n=a2−b2=(a−b)(a+b)

其中:a=⌈n⌉a = \lceil \sqrt{n} \rceila=⌈n⌉

如果 a2−na^2 - na2−n 正好是一个完全平方数,那么就有:

p=a−b,q=a+bp = a-b,\quad q = a+bp=a−b,q=a+b

这题里,公钥模数对应的两个素数差值只有:

q - p = 1634

对于 2048 位 RSA 来说,这已经是“近到离谱”了。
因此费马分解从第一步就成功,几乎等于白给。

五、求出 p、q、φ(n)、d

设公钥指数为:

e = 65537

分解后可得:

p = 156821435009423607231445197686474575192912082799968351935821987735412211008240858394901887285147156116583034425438933318336977901262013394920470470311125413825207127625956236781080618063839117444033029463602207150799255306533527130670961884502659219509279873940578433076362031263161741270229283725042958884733

q = 156821435009423607231445197686474575192912082799968351935821987735412211008240858394901887285147156116583034425438933318336977901262013394920470470311125413825207127625956236781080618063839117444033029463602207150799255306533527130670961884502659219509279873940578433076362031263161741270229283725042958886367

然后计算:

φ(n)=(p−1)(q−1)\varphi(n) = (p-1)(q-1)φ(n)=(p−1)(q−1)

再求私钥指数:

d≡e−1(modφ(n))d \equiv e^{-1} \pmod{\varphi(n)}d≡e−1(modφ(n))

得到:

d =
1334775280158104589455011554021034724594420246052651342544937344428097439012092590347060432293053389085584441154435557086768982244015823401167822026319380656305759308748004621608069038942201551548502598882011997531175754958573919030406437036059666221967010353945452007900770351791350223076027015571721766979619725025935376780251197314281938319950410145162614948915271559892518307731537474508687970398964384850800366691802557056658327027704196786377343560093506454262229619166882133368178337702404680006764475737516829006856253761105699509564904394039664732824203017091511134616954303141355187839322943049846745652905

六、对 d 做 MD5

题目要求提交的是 d 值的 MD5。
这里用的是
d 的十进制字符串 做 MD5。

即:

md5(str(d).encode()).hexdigest()

得到:

510ab7732753a500c83fe193513927f4
from math import isqrt
from hashlib import md5

# 从公钥中提取出的 modulus(16进制)
n_hex = """
00c2d05475fb878b30fa3d336413eb6714774e9a1889c826ca4b9d88d86b833f98d8748c54e3ca15ef605715b4ad9abbc6d796dc1d6f112c8e59e77228876f0de42a91272ec5d7655ab9db54f6395ab497690dfe3a328f0685421723c36793e6329fab0ba202582589998122efaae4bc3edb53937e20ea0a4849c0374c49170b0930c4670bea6764202dc53d9df5e756cffd05ab502bb079b097c8b42cdf513b159b3f3dea776561fbec8c54c3f6e271b020166284323f39ff57fcd7bb637519be7813be419172a01b4d4ddb3880c2e1da3567f07687c5f84bb1262d2fba757f95e933a0ab7c6ff7facedace2daa025fc02e6f7a31fb549873a43ddb42aba77ee3
""".replace("\n", "").strip()

n = int(n_hex, 16)
e = 65537

# Fermat factorization
a = isqrt(n)
if a * a < n:
    a += 1

while True:
    b2 = a * a - n
    b = isqrt(b2)
    if b * b == b2:
        p = a - b
        q = a + b
        break
    a += 1

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

ans = md5(str(d).encode()).hexdigest()

print("[+] p =", p)
print("[+] q =", q)
print("[+] q-p =", q - p)
print("[+] d =", d)
print("[+] md5(d) =", ans)

运行输出最终会得到:

[+] md5(d) = 510ab7732753a500c83fe193513927f4

3.

一、题目背景

流量包里是一个“发票抽奖”活动站点,服务端地址为:

172.16.5.139:50000

先对 HTTP 流量做梳理,可以看到攻击者访问到了几个未授权接口:

/api/user/info
/api/get_comment
/api/lottery/participants
/api/lottery/winners
/cryptodemo
/robots.txt

其中最关键的是:

  • /api/lottery/winners:中奖名单,姓名明文,手机号脱敏
  • /api/get_comment:中奖评论,姓名脱敏,IP 明文
  • /api/lottery/participants:参与人员,姓名脱敏,身份证脱敏,发票号明文
  • /api/user/info:用户名、生日、密码 MD5
  • /cryptodemo:前端加密逻辑

二、核心突破点:/cryptodemo 泄露了加密实现

访问 /cryptodemo 后,可以看到前端 JS 里写了完整的加密逻辑:

  • 先随机生成 16 字节 AES key
  • 用 AES-ECB 加密明文
  • 再用 RSA 公钥 加密 AES key
  • 请求体格式如下:
{
  "data": "...",
  "key": "..."
}

对应逻辑大致是:

function generateAESKey() {
    let k = CryptoJS.lib.WordArray.random(0x10);
    return CryptoJS.enc.Hex.stringify(k).slice(0, 0x10);
}

function aesEncrypt(data, aesKey) {
    let key = CryptoJS.enc.Utf8.parse(aesKey);
    return CryptoJS.AES.encrypt(
        JSON.stringify(data),
        key,
        { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.Pkcs7 }
    ).toString();
}

function rsaEncryptKey(aesKey) {
    let enc = new JSEncrypt();
    enc.setPublicKey(pubKey);
    return enc.encrypt(aesKey);
}

题3真正关键在这里。

攻击者对 /api/lottery/result 发起了大量 POST,请求体里都是:

{
  "data": "....",
  "key": "...."
}

因为题2已经恢复了 RSA 私钥,所以现在可以:

  1. 用 RSA 私钥解 key,得到 AES key
  2. 用 AES-ECB 解 data
  3. 恢复明文参数

解密后发现,攻击者不是在爆发票号,而是在爆手机号。

例如一段连续请求解密后是:

18200004751
18200014751
18200024751
...
18210104751
...

而其中只有一条服务端返回:

{"message":"恭喜你中奖"}

对应的明文手机号就是:

18210104751

这一步就说明:攻击者已经把某个中奖人的完整手机号从脱敏状态恢复出来了。

在 /api/lottery/winners 中查找脱敏手机号:

182****4751

可以唯一对应到:

张俊

也就是说,攻击者成功恢复出的这名人员就是:

张俊 - 18210104751

然后看 /api/user/info,其中可以找到:

username: zhangjun
birthday: 1960-10-31

再看 /api/lottery/participants,张姓对应的是脱敏姓名 张*,其中有一条身份证为:

420300********8621

身份证中间 8 位正好是生日,因此可恢复为:

420300196010318621

再看 /api/get_comment,与张姓对应的评论记录里可拿到明文 IP,其中命中的一条是:

123.7.15.172

于是可以恢复该人员完整信息链为:

张俊
18210104751
420300196010318621
123.7.15.172

按题目要求用 - 连接提交:

张俊-18210104751-420300196010318621-123.7.15.172

exp:

from Crypto.PublicKey import RSA
import math
from hashlib import md5

pub = RSA.import_key(open("pub.pem","rb").read())
n, e = pub.n, pub.e

a = math.isqrt(n)
if a * a < n:
    a += 1

b2 = a * a - n
b = math.isqrt(b2)

p = a - b
q = a + b

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

print("d =", d)
print("md5(d) =", md5(str(d).encode()).hexdigest())

2)解密 /api/lottery/result 请求

from Crypto.PublicKey.RSA import construct
from Crypto.Cipher import PKCS1_v1_5, AES
from Crypto.Util.Padding import unpad
import base64, json

priv = construct((n, e, d, p, q))
rsa_cipher = PKCS1_v1_5.new(priv)

def decrypt_payload(obj):
    aes_key = rsa_cipher.decrypt(base64.b64decode(obj["key"]), None)
    cipher = AES.new(aes_key, AES.MODE_ECB)
    pt = unpad(cipher.decrypt(base64.b64decode(obj["data"])), 16)
    return json.loads(pt)

# obj 就是抓包里 POST /api/lottery/result 的 JSON body
print(decrypt_payload(obj))
张俊-18210104751-420300196010318621-123.7.15.172

数据访问安全分析

1.

附件里有 3 类关键数据:

  • 3 张员工表图片:员工工号、部门、权限等级
  • 9 个 SQLite 数据库:真实表结构
  • access_log.log:访问日志
  • dbip-city-ipv4-cn.csv:IP 段地理位置
  • answer_md5.py:最终答案哈希工具

日志格式很好拆,基本是:

LOG000001 [2025-01-06 00:02:31] EMP00065 125.69.50.234 成都市 "查询" "客户信息管理平台" "企业股东信息表" "注册资本" "5601万元" 成功

我这里的做法是先把 3 张员工表整理成 employees 列表,然后按题面 3 个要求分别跑。

题面给了各部门可访问范围:

  • 零售业务部:客户信息管理平台里的个人客户相关表 + 零售银行业务系统
  • 公司业务部:客户信息管理平台里的企业客户相关表 + 公司银行业务系统
  • 风险管理部:风险合规管理系统 + 交易与支付系统
  • 信息技术部:人力资源管理系统 + 财务与综合管理系统中的
    系统运行日志表 / 安防管理信息表 / 音影像信息表
  • 运营管理部:保险核心业务系统 + 信托业务系统 + 财务与综合管理系统中的
    机构信息表 / 产品信息表 / 渠道信息表 / 营销管理信息表 / 客户服务信息表 / 公文信息表 / 邮件信息表 / 信息披露表 / 党务工会信息表

先把 9 个库里的表名读出来:

import sqlite3, glob, os

db_tables = {}
for path in glob.glob("dbs/*.db"):
    dbname = os.path.basename(path).replace(".db", "")
    con = sqlite3.connect(path)
    cur = con.cursor()
    cur.execute("select name from sqlite_master where type='table' order by name")
    db_tables[dbname] = [x[0] for x in cur.fetchall()]

实际统计结果很整齐:

  • 客户信息管理平台:22 张表
    其中个人相关 12 张,企业相关 10 张
  • 零售银行业务系统:10 张
  • 公司银行业务系统:13 张
  • 风险合规管理系统:10 张
  • 交易与支付系统:5 张
  • 人力资源管理系统:8 张
  • 财务与综合管理系统:18 张
  • 保险核心业务系统:19 张
  • 信托业务系统:5 张

所以每个部门最终可访问数量就是:

  • 信息技术部:8 + 3 = 11 张表,2 个库
  • 风险管理部:10 + 5 = 15 张表,2 个库
  • 零售业务部:12 + 10 = 22 张表,2 个库
  • 公司业务部:10 + 13 = 23 张表,2 个库
  • 运营管理部:19 + 5 + 9 = 33 张表,3 个库

这里权限等级 2/3/4 对题1没有额外影响,因为题面没有再给更细的等级差异规则,实际答案也验证了同部门不同等级统计值一致。

构造答案:

data = [
    {"工号": "...", "可访问数据库数量": x, "可访问数据表数量": y},
    ...
]
data.sort(key=lambda x: x["工号"])

最后:

answer_md5(data)
= b0c61dbe4606aaccfe9f80d2fac13d89

2

题面定义得很直接:

员工访问了不属于其部门管辖范围的数据,即使权限等级足够,也算越权。

所以判断逻辑不是看“成没成功”,也不是看“等级够不够”,而是只看:

  • 这个员工属于哪个部门
  • 这条日志访问的数据库 / 数据表 是否在该部门允许范围内

核心代码就是把题1那套“部门 -> 允许表集合”复用过来:

if db_name not in allow_map[dept]:
    bad_ids.append(logid)
elif table_name not in allow_map[dept][db_name]:
    bad_ids.append(logid)

注意这里失败日志也算,因为题目说的是“访问行为/越权访问记录”,不是“成功读到数据才算”。

例如:

LOG001474 EMP00026 信息技术部 查询 财务与综合管理系统 公文信息表 ... 成功

信息技术部在财综库里只能碰 3 张表:

  • 系统运行日志表
  • 安防管理信息表
  • 音影像信息表

访问 公文信息表 明显越权,所以这条要记。

把所有越权日志 ID 升序排好后,得到 350 条。

最终:

answer_md5(data)
= 6b48f5cec9c8f5b10eb3c014db78d3fe

3

题面有 3 条规则。

同一员工按时间排序后的相邻两条日志,如果:

  • 时间差 <= 7200 秒
  • 两城市直线距离 > 500 km

则这两条日志都要标异常。

距离用 Haversine:

from math import radians, sin, cos, asin, sqrt

def haversine(lat1, lon1, lat2, lon2):
    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
    dlat = lat2 - lat1
    dlon = lon2 - lon1
    a = sin(dlat/2)**2 + cos(lat1)*cos(lat2)*sin(dlon/2)**2
    return 6371 * 2 * asin(sqrt(a))

我这里为了规避 CSV 英文城市名和日志中文城市名不统一的问题,直接用日志里的 IP 去 dbip-city-ipv4-cn.csv 做区间匹配,拿到经纬度后再按日志里的中文城市聚合坐标。

比如 EMP00065 有一组:

  • LOG015676:成都市,15:16:03
  • LOG015883:上海市,15:59:40

间隔只有 2617 秒,但成都到上海大约 1663 km,所以这两条都记 地理位置不可能跳转。

访问时间在:

00:00:00 ~ 05:59:59

直接记 异常时段访问。

先给每个员工找“常驻城市”:

  • 统计其全部历史日志中出现次数最多的城市
  • 作为该员工常驻城市

如果某条日志所在城市和常驻城市距离 > 300 km,则记 IP地址突变。

例如 EMP00009 的常驻城市是成都市,但:

LOG000002  2025-01-06 00:30:58  深圳市

深圳距离成都远超 300 km,所以这条命中 IP地址突变。同时它又发生在凌晨,所以同一条日志还会再命中一次 异常时段访问。

这题有两个很容易漏的点:

  1. 同一条日志可以同时命中多种异常
  2. 同一日志同一异常类型即使被多次触发,也只保留一条

最后输出格式是:

[
    {"异常类型": "...", "日志ID": "..."},
    ...
]

并且要按:

  • 日志ID 升序
  • 同一 日志ID 下按 异常类型 字符串升序

最终统计:

  • 地理位置不可能跳转:720 条
  • IP地址突变:290 条
  • 异常时段访问:89 条

总计 1099 条异常记录。

最终:

answer_md5(data)
= 2954cf5c2160b4314132abe568480f34

异常数据传输

附件里有三个核心文件:

  • md5.csv
  • 流量.pcap
  • 场景说明.pdf

本题关键就是:
先从流量里还原传输的图片,再和
md5.csv 对比,找出被篡改的文件;然后在这几个异常文件里继续挖隐藏数据。

1.

md5.csv 里记录了 001.png ~ 021.png 的 md5。
流量.pcap 中是一次 HTTP 文件传输,只要把 HTTP 响应体还原出来,就能拿到真实传输的 PNG 文件,再逐个计算 md5 和 csv 对比。

从流量里可以看到主通信为:

  • 192.168.56.23 -> 192.168.56.10:80192.168.56.23 -> 192.168.56.10:80
  • 请求路径形如 /images/001.png

也就是一组 HTTP GET 下载图片。

把每条 HTTP 响应体取出来,按 Content-Length 截断后保存为对应 png,再和 md5.csv 对比。

对比结果发现不一致的有:

  • 009.png
  • 012.png
  • 021.png

题目标准里有一句:将找出的文件名编号按数字从小到大顺序排列,使用英文半角逗号分隔,转成 32 位小写 md5 值提交

也就是说真正参与 md5 的字符串是:

009,012,021

计算 md5:

b94021bb8aefa2b8949c172102d6c32f

2.

第一题已经定位到异常文件只有三个:

  • 009.png
  • 012.png
  • 021.png

接下来逐个检查。

009.png 的 PNG 文本块里能看到一条注释:

Key:f92hj89h123

说明这张图里大概率藏了后续解密要用的 key。

012.png 的文本块里有一段明显的提示代码,名字类似:

embed_logic_hint

内容大意是:

  • 在 蓝色通道
  • 按 8x8 分块
  • 对块做 DCT
  • 使用坐标 (3,4)
  • 用 QIM_STEP = 36.0
  • 按 “4 字节长度前缀 + payload” 的方式嵌入

这已经不是普通注释了,而是在明确告诉我们隐藏数据的提取方式。

对 012.png 的蓝色通道逐块做 DCT,读取 (3,4) 系数的奇偶位,先取前 32 bit 作为长度,再继续读取对应字节数。

提取出来的 payload 长度是 663 字节,文件头是:

6f 0d 0d 0a ...

这是一个 .pyc 文件。

把它保存出来后,对这个隐藏程序计算 md5,得到:

faee9faef81ee6f438772c34af0e22ec

3.

把从 012.png 提出来的 .pyc 反汇编,可以看出它的逻辑非常简单:

  • 打开一张图片:lsb.png
  • 转成 RGBA
  • 遍历所有像素
  • 读取 alpha 通道最低位
  • 前 32 bit 作为长度 n
  • 再继续取出 n 个字节
  • 最后把结果做 base64 输出

也就是说,这个程序的作用就是:从一张 PNG 的 Alpha LSB 中提取隐藏字节流

在异常文件里,009.png 本身就是 RGBA,而且它还带着注释 key:

f92hj89h123

于是直接按程序逻辑对 009.png 的 alpha 通道最低位做提取。

提取结果:

  • 长度字段 = 550
  • 取出 550 字节密文

提出来的原始密文是一个固定 11 字节块重复 50 次的结构。

key 为:

f92hj89h123

长度正好是 11 字节。

把提取出的 550 字节密文按这个 key 做循环异或,明文立刻出来了:

NeverGiveUp

而且它是重复 50 次的结果:

NeverGiveUpNeverGiveUpNeverGiveUp...

题目要求“最终提交其明文作为答案”,通常提交核心明文即可,因此答案就是:

NeverGiveUp

数据恢复与审计

1.

附件中给了一个流量包 users.pcapng,要求完成 3 个任务:

  1. 从流量中恢复 db 文件,并提交恢复后数据库文件的 md5
  2. 恢复数据库密码
  3. 基于库内数据做脱敏审计,并统计不同风险等级数量

拿到题目后,核心目标很明确:

  • 先从流量中找到数据库文件传输过程
  • 将分片传输的 users.db 按字节范围重组
  • 计算文件 md5,解决第 1 题
  • 再从流量中寻找和密码相关的线索,恢复数据库口令,解决第 2 题
  • 最后解密数据库,按照题目给定规则统计风险等级,解决第 3 题

在流量中可以发现存在对数据库文件的访问,请求路径为:

/download/users.db

同时可以看到大量这样的 HTTP 请求与响应:

GET /download/users.db HTTP/1.1
Range: bytes=0-6479

HTTP/1.1 206 PARTIAL CONTENT
Content-Range: bytes 0-6479/851968

以及很多类似的分片:

Range: bytes=717591-719468
Content-Range: bytes 717591-719468/851968

说明这个数据库文件并不是一次性完整下载,而是通过 HTTP Range 分片下载 的方式传输。

此外,还能看到:

HEAD /download/users.db HTTP/1.1

以及总大小信息:

Content-Range: bytes 0-851967/851968

由此可以确定:

  • 文件名:users.db
  • 总大小:851968 字节

恢复方法就是:

  1. 提取所有 /download/users.db 的 206 Partial Content 响应体
  2. 根据每个响应头里的 Content-Range
  3. 将响应体写回到目标文件对应的偏移位置
  4. 最终拼出完整数据库文件

也就是把所有片段按下面这种规则重组:

Content-Range: bytes 起始位置-结束位置/总长度

例如:

Content-Range: bytes 0-6479/851968

就把这一段数据写到目标文件的 0~6479 字节处。

恢复完整文件后,对重组出的 users_reconstructed.db 计算 md5:

md5sum users_reconstructed.db

4741c655d6d1281b9d89cb9f7ef63c10

2.

除了 users.db 之外,在流量中还能发现另一个可疑文件:

/download/email.eml

同样也是通过分片方式传输,因此可以按和第 1 题类似的方法把邮件文件重组出来。

恢复后得到一封 .eml 邮件。

打开邮件后,可以看到正文经过了 base64 编码。解码后内容如下:

亲爱的李伟,

你好!

我想提醒你一下,关于你的密码。根据我记得的情况,密码是你姓名的小写全拼,后面跟着四个字符。你可以仔细回忆一下,这四个字符可能与某些你常用的元素有关。

希望能帮到你,祝你工作顺利,期待你的反馈!

祝好,

这段话给出了非常关键的线索:

  • 密码格式 = 姓名小写全拼 + 4个字符
  • 收件对象是 李伟
  • 因此前缀基本可以确定为:
liwei

结合线索,对数据库使用 SQLCipher 尝试解密验证:

PRAGMA key = 'liwei1993';

验证成功后,可以正常读取表结构,例如:

SELECT name FROM sqlite_master WHERE type='table';

返回:

users
sqlite_sequence

说明密码正确。

liwei1993

3

当前时间为:

2026-03-20 23:59

题目要求以以下 4 个字段为敏感字段检查脱敏情况:

  • 用户姓名
  • 邮箱
  • 手机号
  • 身份证号

风险划分规则为:

  • 4项均未脱敏 → 严重风险
  • 1项脱敏 → 高风险
  • 2项脱敏 → 中风险
  • 3项脱敏 → 低风险
  • 4项均脱敏 → 无风险

附加规则:

  • 若用户属于 低/中/高风险
  • 且 活跃时间不在 7 天内
  • 则 风险等级上升一级

最终答案提交格式为:

无风险-低风险-中风险-高风险-严重风险

解密数据库后查看 users 表结构:

CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT,
    phone TEXT,
    email TEXT,
    id_card TEXT,
    created_at TEXT
)

可见题目所需字段都在这张表中:

  • name
  • phone
  • email
  • id_card
  • created_at

其中 created_at 可作为活跃时间字段。

观察库内数据可发现,脱敏字段都有明显特征:包含 \* 号。

例如:

  • 张*
  • 181****8091
  • j***@example.com
  • 371423********5896

因此可以直接按下面规则判断:

  • 包含 * → 视为已脱敏
  • 不包含 * → 视为未脱敏

当前时间:

2026-03-20 23:59

7 天前的分界点为:

2026-03-13 23:59

所以:

  • created_at >= '2026-03-13 23:59' → 属于 7 天内活跃
  • created_at < '2026-03-13 23:59' → 不在 7 天内,需要升级风险

注意:

  • 只有 低风险 / 中风险 / 高风险 才会升级
  • 无风险 和 严重风险 不变

可以直接用下面这条 SQL 完成统计:

WITH base AS (
  SELECT
    id,
    name,
    phone,
    email,
    id_card,
    created_at,
    (name LIKE '%*%') +
    (phone LIKE '%*%') +
    (email LIKE '%*%') +
    (id_card LIKE '%*%') AS masked_cnt
  FROM users
),
risk1 AS (
  SELECT *,
    CASE masked_cnt
      WHEN 4 THEN '无风险'
      WHEN 3 THEN '低风险'
      WHEN 2 THEN '中风险'
      WHEN 1 THEN '高风险'
      ELSE '严重风险'
    END AS base_risk
  FROM base
),
risk2 AS (
  SELECT *,
    CASE
      WHEN created_at < '2026-03-13 23:59' AND base_risk = '低风险' THEN '中风险'
      WHEN created_at < '2026-03-13 23:59' AND base_risk = '中风险' THEN '高风险'
      WHEN created_at < '2026-03-13 23:59' AND base_risk = '高风险' THEN '严重风险'
      ELSE base_risk
    END AS final_risk
  FROM risk1
)
SELECT final_risk, COUNT(*) AS cnt
FROM risk2
GROUP BY final_risk
ORDER BY CASE final_risk
  WHEN '无风险' THEN 1
  WHEN '低风险' THEN 2
  WHEN '中风险' THEN 3
  WHEN '高风险' THEN 4
  WHEN '严重风险' THEN 5
END;

执行后得到:

  • 无风险:86
  • 低风险:195
  • 中风险:1187
  • 高风险:2994
  • 严重风险:5538

按题目要求格式拼接:

86-195-1187-2994-5538

人脸识别

1.

对所有人脸特征向量进行聚类分析,参数为:

  • eps = 0.15
  • min_samples = 3
  • 距离度量使用 余弦距离

然后从聚类结果中找出 最大的可疑身份特征聚类,并在该聚类中选择 平均相似度最高 的特征作为代表特征,提交其 face_id。

face_features.csv 中保存了每个 face_id 的 512 维特征向量。
先将字符串形式的向量解析出来,然后使用
DBSCAN(metric='cosine') 进行聚类。

聚类完成后:

  1. 去掉噪声点(标签为 -1)
  2. 找到样本数最多的聚类
  3. 在该聚类内部计算任意两个向量之间的余弦相似度
  4. 对每个样本计算其与同簇其他样本的平均相似度
  5. 取平均相似度最高的那个样本作为代表特征
import pandas as pd
import numpy as np
import ast
from sklearn.cluster import DBSCAN

df = pd.read_csv("face_features.csv")

# 解析特征向量
vectors = np.vstack(df["vector"].map(ast.literal_eval).to_list()).astype(float)

# DBSCAN 聚类
db = DBSCAN(eps=0.15, min_samples=3, metric="cosine")
labels = db.fit_predict(vectors)

df["cluster"] = labels

# 去掉噪声点
valid = df[df["cluster"] != -1]

# 找最大聚类
largest_cluster = valid["cluster"].value_counts().idxmax()
cluster_idx = np.where(labels == largest_cluster)[0]
cluster_vectors = vectors[cluster_idx]

# 计算簇内余弦相似度
sim_matrix = cluster_vectors @ cluster_vectors.T

# 计算每个样本与其他样本的平均相似度
avg_sim = (sim_matrix.sum(axis=1) - 1) / (len(cluster_idx) - 1)

best_local_idx = avg_sim.argmax()
best_global_idx = cluster_idx[best_local_idx]

answer1 = df.iloc[best_global_idx]["face_id"]
print(answer1)

聚类结果中共有两个非噪声簇,其中最大的簇包含 220 个特征。
该簇内平均相似度最高的代表特征为:

FACE_001308

2.

需要在 不同安全级别 的特征之间计算余弦相似度,并根据访问记录统计每个特征的验证频次因子:

[
\text{验证频次因子} = \log(\text{验证次数}+1)
]

再按下式计算风险评分:

[
\text{风险评分} = \text{相似度} \times (\text{高安全级别} - \text{低安全级别}) \times \text{平均验证频次因子}
]

其中:

[
\text{平均验证频次因子} = \frac{\text{特征1频次因子} + \text{特征2频次因子}}{2}
]

最后提交 风险评分最高的特征对所属区域组合,按字母顺序用下划线连接。

先读取 face_features.csv,拿到:

  • face_id
  • area
  • security_level
  • vector

再读取 access_records.csv,统计每个 face_id 在访问记录中出现的次数,作为题目中的“验证次数”。

然后:

  1. 计算所有特征对之间的余弦相似度
  2. 只保留 安全级别不同 的特征对
  3. 对每一对特征,计算风险评分
  4. 找出风险评分最大的那一对
  5. 提取这两个特征所属的区域,并按字母顺序拼接输出
import pandas as pd
import numpy as np
import ast

face_df = pd.read_csv("face_features.csv")
record_df = pd.read_csv("access_records.csv")

vectors = np.vstack(face_df["vector"].map(ast.literal_eval).to_list()).astype(float)

face_ids = face_df["face_id"].to_numpy()
areas = face_df["area"].to_numpy()
levels = face_df["security_level"].to_numpy()

# 统计每个 face_id 在 access_records 中出现的总次数
cnt = record_df["face_id"].value_counts()
freq = np.log(face_df["face_id"].map(cnt).fillna(0).to_numpy() + 1)

# 余弦相似度矩阵(向量已归一化,点积即余弦相似度)
sim_matrix = vectors @ vectors.T

n = len(face_df)
best_score = -1
best_pair = None

for i in range(n):
    for j in range(i + 1, n):
        if levels[i] == levels[j]:
            continue

        high_level = max(levels[i], levels[j])
        low_level = min(levels[i], levels[j])

        avg_freq = (freq[i] + freq[j]) / 2
        score = sim_matrix[i, j] * (high_level - low_level) * avg_freq

        if score > best_score:
            best_score = score
            best_pair = (i, j)

i, j = best_pair
answer2 = "_".join(sorted([areas[i], areas[j]]))
print(answer2)

风险评分最高的一对特征来自:

  • FACE_001215
  • FACE_001488

对应区域分别为:

  • Security
  • Lobby

按字母顺序拼接后得到:

Lobby_Security

这题有一个容易混淆的点:
题面说“根据
access_records 统计每个特征的总验证次数”,但 access_records 中有 verify / entry / exit 三种类型。

我在正式解题时采用的是:

  • 按 face_id 在 access_records 中出现的总次数统计

按这个口径结果是:

Lobby_Security

如果只统计 access_type = verify,则会得到另一个结果,但按题目原文“根据 access_records 统计总验证次数”理解,使用全部记录更稳妥。

3.

去重规则如下:

  1. 设置余弦相似度阈值为 0.95
  2. 找出所有相似度 大于等于 0.95 的特征对
  3. 去重时遵循以下保留规则:
  • 优先保留 安全级别更高 的特征
  • 若安全级别相同,则保留 face_id 字典序更小 的特征
  1. 需要考虑 传递性
  • 若 A 与 B 相似,B 与 C 相似,则 A、B、C 视为一个相似组,只保留一个
  1. 最终提交 去重后剩余特征总数

这题本质上是一个 图连通分量 问题。

把每个 face_id 看成一个节点:

  • 如果两个特征的余弦相似度 >= 0.95
  • 就在这两个节点之间连一条边

这样所有“彼此直接或间接相似”的特征会形成一个连通块。
每个连通块中最终只保留 1 个特征,所以:去重后的总特征数 = 图中的连通分量个数

因此可以使用 并查集(Union-Find) 来求解。

import pandas as pd
import numpy as np
import ast

df = pd.read_csv("face_features.csv")
vectors = np.vstack(df["vector"].map(ast.literal_eval).to_list()).astype(float)

sim_matrix = vectors @ vectors.T
n = len(df)

parent = list(range(n))
rank = [0] * n

def find(x):
    while parent[x] != x:
        parent[x] = parent[parent[x]]
        x = parent[x]
    return x

def union(a, b):
    ra, rb = find(a), find(b)
    if ra == rb:
        return
    if rank[ra] < rank[rb]:
        parent[ra] = rb
    elif rank[ra] > rank[rb]:
        parent[rb] = ra
    else:
        parent[rb] = ra
        rank[ra] += 1

# 相似度 >= 0.95 的都合并
for i in range(n):
    for j in range(i + 1, n):
        if sim_matrix[i, j] >= 0.95:
            union(i, j)

# 连通分量个数 = 去重后剩余特征数
remain = len(set(find(i) for i in range(n)))
print(remain)

数据集中原始特征总数为:

1550

按照阈值 0.95 建图后,考虑传递性去重,最终得到的连通分量数量为:

1252

也就是说,去重后剩余的特征总数为:

1252

AI数据隐私

模型知识产权溯源

最终答案:19568491357

这题的核心不是“把 11 个 .pth 拼起来”,而是两条线并行:

第一条线,从效果图 cover_*.jpg 里取出 验证序号 和 Seed。
第二条线,对每个
model_*.pth 的浅层参数做去噪,把里面藏的 单个数字水印 还原出来。
最后再按验证序号把 11 个数字重新排序,得到手机号提交。

资源页本身就把方向提示得很明显:页面列出了 cover_1.jpg ~ cover_11.jpg 和 model_1.pth ~ model_11.pth 这 11 组资源,而且反复出现 C2PA、Noise Triggered、Weight collapse protocol active 这类关键词,基本就是在告诉我们“图里藏元数据,模型里有被噪声污染过的权重”。

打开页面源码后能看到:

  • 一共 11 个分片
  • 每个分片都有一张 cover_i.jpg
  • 每个分片都有一个 model_i.pth
  • 页面所有卡片都强调了 C2PA
  • 页脚还有 Gravitational (Weight) collapse protocol active页脚还有 重力(重量)坍缩协议激活

这一步的意义是确认题目并不是纯网页题,而是:

  1. cover 负责给密钥材料
  2. model 负责给真正水印数字

从 cover_i.jpg 提取 sequence_index 和 seed_timestamp

一开始最容易想到去看 EXIF,但这题的线索并不在普通 EXIF 里。
真正有用的是 JPEG 里的
JUMBF / C2PA 结构。

实际看字节会发现,JPEG 图像正常结束后,后面还跟着一段 JUMBF 数据块,里面能直接看到:

  • com.aura.metadata
  • sequence_index
  • seed_timestamp
  • target_tensor
  • conv1.weight变数1.权重

也就是说,出题人把每个分片对应的顺序和种子,直接塞进了图的 C2PA 元数据里。

不需要完整实现 C2PA 解析器,直接从字节里抓字段就够了。

核心提取代码如下:

from pathlib import Path
import re

def parse_cover_metadata(path: Path):
    data = path.read_bytes()
    m = re.search(
        rb"sequence_index(?P<seq>.)nseed_timestamp\x1a(?P<seed>.{4})mtarget_tensorlconv1\.weight",
        data,
        re.S,
    )
    if not m:
        raise ValueError(f"metadata not found: {path}")
    seq = m.group("seq")[0]
    seed = int.from_bytes(m.group("seed"), "big")
    return seq, seed

跑完 11 张图后得到:

cover_1.jpg  -> sequence_index=2,  seed_timestamp=1712880061
cover_2.jpg  -> sequence_index=7,  seed_timestamp=1712880361
cover_3.jpg  -> sequence_index=5,  seed_timestamp=1712880241
cover_4.jpg  -> sequence_index=3,  seed_timestamp=1712880121
cover_5.jpg  -> sequence_index=9,  seed_timestamp=1712880481
cover_6.jpg  -> sequence_index=10, seed_timestamp=1712880541
cover_7.jpg  -> sequence_index=1,  seed_timestamp=1712880001
cover_8.jpg  -> sequence_index=4,  seed_timestamp=1712880181
cover_9.jpg  -> sequence_index=8,  seed_timestamp=1712880421
cover_10.jpg -> sequence_index=11, seed_timestamp=1712880601
cover_11.jpg -> sequence_index=6,  seed_timestamp=1712880301

顺手还能看到 target_tensor = conv1.weight,这点特别重要,因为它直接告诉我们要查哪一层。

把 model_i.pth 用 torch.load() 打开后,可以看出这是一个 ResNet 风格的 state_dict。
题面说的是“浅层视觉特征提取网络”,再结合封面图元数据里已经点名
conv1.weight,所以重点直接放在第一层卷积。

实际观察会发现:

  • conv1.weight 的分布极其异常
  • 标准差大约都在 15 左右
  • 明显不像正常预训练 ResNet18 第一层卷积核的幅值范围

这说明内鬼所谓的“坍缩算法”,本质上就是给 conv1.weight 叠了一层大幅高斯噪声。

还原噪声:conv1 ≈ 15 * randn(seed) + residual5. 还原噪声:conv1 ≈ 15 * randn(seed) + 残差

题面已经说过这是:

  • 加性高斯白噪声
  • 且有固定振幅缩放

结合封面图给出的 seed_timestamp,最自然的模型就是:

污染后的权重 = 原始残差 + 15 * randn(seed_timestamp)

于是对每个模型做:

  1. 用对应 seed_timestamp 初始化 torch 随机数生成器
  2. 生成一个与 conv1.weight 同 shape 的 randn
  3. 乘上系数 15
  4. 从原权重里减掉

代码如下:

import torch

def recover_residual(conv1: torch.Tensor, seed: int):
    g = torch.Generator(device="cpu").manual_seed(seed)
    noise = torch.randn(conv1.shape, generator=g)
    residual = conv1.float() - 15 * noise
    return residual

去噪后再看 residual,会发现数值立刻“干净”了很多:

  • 均值接近 0
  • 极值几乎落在 -3 和 +3
  • 还会有极少量 -1 / +1 的边缘扰动

这说明我们已经把大噪声基本减掉了。

conv1.weight 的 shape 是:

[64, 3, 7, 7]

也就是说:

  • 64 个输出通道
  • 3 个输入通道
  • 每个卷积核大小 7×7

去噪后,可以看出数字不是藏在某一个单独卷积核里,而是冗余写入到了通道维度。
所以最简单的方法就是在
[64, 3] 这两个维度上做一次投票,把它压成一个 7×7 的字模。

代码如下:

import numpy as np

def residual_to_bitmap(residual: torch.Tensor):
    r = residual.round().to(torch.int32)

    pos = (r == 3).sum(dim=(0, 1))
    neg = (r == -3).sum(dim=(0, 1))

    vote = pos - neg
    bitmap = (vote > 0).to(torch.int32).cpu().numpy()
    return bitmap

这样每个模型都会得到一个 7×7 黑白数字

按 model_1 ~ model_11 的自然顺序,提取出来分别是:

[9, 9, 8, 5, 3, 5, 1, 6, 1, 7, 4]

也就是:

model_1  -> 9
model_2  -> 9
model_3  -> 8
model_4  -> 5
model_5  -> 3
model_6  -> 5
model_7  -> 1
model_8  -> 6
model_9  -> 1
model_10 -> 7
model_11 -> 4

前面从封面图里提取到了每个分片对应的 sequence_index。

整理一下:

model_1  -> seq  2 -> digit 9
model_2  -> seq  7 -> digit 9
model_3  -> seq  5 -> digit 8
model_4  -> seq  3 -> digit 5
model_5  -> seq  9 -> digit 3
model_6  -> seq 10 -> digit 5
model_7  -> seq  1 -> digit 1
model_8  -> seq  4 -> digit 6
model_9  -> seq  8 -> digit 1
model_10 -> seq 11 -> digit 7
model_11 -> seq  6 -> digit 4

按照 sequence_index = 1 ~ 11 排列后,顺序变成:

seq1  -> model_7  -> 1
seq2  -> model_1  -> 9
seq3  -> model_4  -> 5
seq4  -> model_8  -> 6
seq5  -> model_3  -> 8
seq6  -> model_11 -> 4
seq7  -> model_2  -> 9
seq8  -> model_9  -> 1
seq9  -> model_5  -> 3
seq10 -> model_6  -> 5
seq11 -> model_10 -> 7
from pathlib import Path
import re
import torch

BASE = Path("./AURA Model Hub _ Corporate AI Assets_files")

DIGIT_TEMPLATES = {
    (
        "0111000",
        "1000100",
        "1000100",
        "0111100",
        "0000100",
        "0001000",
        "0110000",
    ): 9,
    (
        "0111000",
        "1000100",
        "1000100",
        "0111000",
        "1000100",
        "1000100",
        "0111000",
    ): 8,
    (
        "1111100",
        "1000000",
        "1111000",
        "0000100",
        "0000100",
        "1000100",
        "0111000",
    ): 5,
    (
        "0111000",
        "1000100",
        "0000100",
        "0011000",
        "0000100",
        "1000100",
        "0111000",
    ): 3,
    (
        "0010000",
        "0110000",
        "0010000",
        "0010000",
        "0010000",
        "0010000",
        "0111000",
    ): 1,
    (
        "0011100",
        "0100000",
        "1000000",
        "1111000",
        "1000100",
        "1000100",
        "0111000",
    ): 6,
    (
        "1111100",
        "0000100",
        "0001000",
        "0010000",
        "0100000",
        "1000000",
        "1000000",
    ): 7,
    (
        "0001000",
        "0011000",
        "0101000",
        "1001000",
        "1111100",
        "0001000",
        "0001000",
    ): 4,
}

def parse_cover_metadata(path: Path):
    data = path.read_bytes()
    m = re.search(
        rb"sequence_index(?P<seq>.)nseed_timestamp\x1a(?P<seed>.{4})mtarget_tensorlconv1\.weight",
        data,
        re.S,
    )
    if not m:
        raise ValueError(f"metadata not found in {path}")
    seq = m.group("seq")[0]
    seed = int.from_bytes(m.group("seed"), "big")
    return seq, seed

def residual_to_bitmap(model_path: Path, seed: int):
    sd = torch.load(model_path, map_location="cpu")
    conv1 = sd["conv1.weight"].float()

    g = torch.Generator(device="cpu").manual_seed(seed)
    noise = torch.randn(conv1.shape, generator=g)

    residual = conv1 - 15 * noise
    r = residual.round().to(torch.int32)

    pos = (r == 3).sum(dim=(0, 1))
    neg = (r == -3).sum(dim=(0, 1))
    vote = pos - neg

    bitmap = (vote > 0).to(torch.int32).cpu().numpy()
    key = tuple("".join(str(int(x)) for x in row.tolist()) for row in bitmap)
    return key

def main():
    items = []

    for i in range(1, 12):
        cover = BASE / f"cover_{i}.jpg"
        model = BASE / f"model_{i}.pth"

        seq, seed = parse_cover_metadata(cover)
        key = residual_to_bitmap(model, seed)

        if key not in DIGIT_TEMPLATES:
            raise ValueError(f"unknown digit template in model_{i}: {key}")

        digit = DIGIT_TEMPLATES[key]
        items.append((i, seq, seed, digit))

    print("[+] raw order")
    for idx, seq, seed, digit in items:
        print(f"model_{idx}.pth -> seq={seq}, seed={seed}, digit={digit}")

    items.sort(key=lambda x: x[1])
    answer = "".join(str(d) for _, _, _, d in items)

    print("\n[+] sorted by sequence_index")
    for idx, seq, seed, digit in items:
        print(f"seq={seq:2d} <- model_{idx}.pth -> {digit}")

    print(f"\n[+] answer = {answer}")

if __name__ == "__main__":
    main()

这题最关键的点有三个:

第一,不要把 cover.jpg 当普通图片看,它真正有价值的是 C2PA/JUMBF 元数据。
第二,
不要试图恢复完整模型,题目真正藏水印的目标层就是 conv1.weight。
第三,
去噪不是盲猜,而是利用封面图提供的 seed_timestamp 去同步 PRNG,再把 15 * randn(seed) 从 conv1.weight 里减掉。

最终还原出的自然顺序数字是:

[9, 9, 8, 5, 3, 5, 1, 6, 1, 7, 4]

按 sequence_index 重排后得到:

19568491357

语义空间数据反演

题目给了一个 RAG / 向量数据库后台页面,页面中有几条非常关键的信息:

  • 使用模型:all-MiniLM-L6-v2
  • 向量维度:384
  • 相似度度量:Cosine
  • 可下载文件:database.npz

同时,页面源码里还留了一个没删干净的注释:

<!-- 
  TODO: 
  - Fix Embedding dimension mismatch in Node-04.
  - Debug backup location: /data_inte.py.bak
  - Remove this comment before deployment! 
-->

这说明除了 database.npz 以外,还可以进一步访问:

/data_inte.py.bak

所以这题的真实入口不是前端,而是:

  • database.npz
  • data_inte.py.bak

直接访问页面暴露出来的两个文件:

http://47.116.177.252:33171/database.npz
http://47.116.177.252:33171/data_inte.py.bak

其中:

  • database.npz:存放 1000 个向量和对应 id
  • data_inte.py.bak:备份脚本,泄露了向量化前的原始文本模板

data_inte.py.bak 的核心逻辑如下:

def process_vip_records(db_rows):
    for row in db_rows:
        # 安全部要求:对核心客户信息进行固定格式的语义强化,以便大模型识别警告
        name = row['client_name']
        phone = row['phone_number']
        
        # TODO: 准备存入 Milvus 向量数据库的原始文本
        text_to_embed = f"[Attention]核心客户{name}的手机号是 {phone},请勿外传"
        
        # 调用 all-MiniLM-L6-v2 进行向量化
        vec = embed_model.encode(text_to_embed)
        save_to_vector_db(vec)

这里直接告诉了我们三件事:

  1. 目标文本是固定模板
  2. 模板内容明显带有强语义特征:
  • [Attention]
  • 核心客户
  • 手机号
  • 请勿外传
  1. 使用的嵌入模型确实是 all-MiniLM-L6-v2

也就是说,这个“敏感向量”不是普通用户记录,而是一个语义上非常突兀的 VIP/警告型文本。

先把 npz 打开看看结构:

import numpy as np

data = np.load("database.npz", allow_pickle=True)
print(data.files)
for k in data.files:
    print(k, data[k].shape, data[k].dtype)

输出可以看到:

  • ids:(1000,)
  • embeddings:(1000, 384)

说明数据库里有 1000 条记录,每条记录是一个 384 维向量,对应题面说的 1000 个干扰向量。

题目表面上写得很唬人,说什么:

  • 逆向推理脚本
  • 高维向量相似度对齐
  • 从 1000 个干扰向量中精准锁定目标异常向量
  • 重构原始明文数据

但实际上,结合备份脚本后,这题最稳的解法是:直接在向量空间里找“最孤立”的那个点。

原因很简单:

  • 普通记录大概率来自同类业务文本,彼此语义接近
  • 目标记录却是
    "[Attention]核心客户{name}的手机号是 {phone},请勿外传"
    这种带有“警告 + 核心客户 + 隐私泄露”语义的文本
  • 这种文本和普通记录相比,在语义空间里会形成明显离群

所以完全没必要一上来就爆破手机号,先做异常检测,通常就能直接锁定答案。

  1. 归一化向量

因为题目指定相似度度量为 Cosine,所以先做 L2 归一化:

normed = emb / (np.linalg.norm(emb, axis=1, keepdims=True) + 1e-12)
  1. 计算两两余弦相似
sim = normed @ normed.T
np.fill_diagonal(sim, -1)
  1. 看每个向量“最近邻”的相似度

对于每个向量,取它和其他 999 个向量中最相近的那个相似度:

nn = sim.max(axis=1)

正常情况下:

  • 如果这个向量属于“普通簇”,那它一定能找到很多相似邻居
  • 如果它是异常语义文本,它的最近邻相似度会显著偏低

按最近邻余弦相似度从低到高排序,最异常的一个是:

vec_0792

并且它和次近邻的相似度只有大约:

0.5559

而其余大部分向量的最近邻相似度都非常高,接近:

0.98 ~ 0.99

也就是说,vec_0792 在整个数据库里是一个断层级别的异常点。

这个差距已经不是“有点不同”,而是明显说明:它对应的文本语义与其他记录完全不在一个簇里。

因此最终提交:

vec_0792

exp:

import numpy as np

data = np.load("database.npz", allow_pickle=True)

ids = data["ids"]
emb = data["embeddings"].astype(np.float32)

# L2 normalize for cosine similarity
normed = emb / (np.linalg.norm(emb, axis=1, keepdims=True) + 1e-12)

# pairwise cosine similarity
sim = normed @ normed.T

# remove self-match
np.fill_diagonal(sim, -1)

# nearest neighbor similarity for each vector
nearest_sim = sim.max(axis=1)
nearest_idx = sim.argmax(axis=1)

# sort by anomaly level: the lower nearest-neighbor similarity, the more isolated
order = np.argsort(nearest_sim)

print("Top anomalous vectors:")
for rank, idx in enumerate(order[:20], 1):
    print(
        f"{rank:02d}. {ids[idx]} | "
        f"nearest_sim={nearest_sim[idx]:.6f} | "
        f"nearest_neighbor={ids[nearest_idx[idx]]}"
    )

print("\nFinal answer:", ids[order[0]])

运行后会看到第一名就是:

Final answer: vec_0792

密文推理对抗样本

打开题目页面后,可以直接看到这是一个图片上传 + 模型判定的题。页面的流程非常清楚,一共分四步:

  1. L∞ 约束
  2. 明文推理
  3. 密文翻转
  4. 获取 Flag

页面还明确说明了上传要求:

  • 需要上传一张图片
  • 最大像素偏差要满足 ‖ΔX‖∞ ≤ 2/255
  • 上传图片的普通分类结果要和参考图片一致
  • 同时要求明文预测与密文预测发生翻转,三重条件全部满足后才给 Flag

从题目附件里还能看到,给了:

  • model.pth
  • fc_weight.npy
  • fc_bias.npy
  • target_image.png

这说明题目并不是单纯让我们“猜图片”,而是让我们围绕模型推理链路做文章。

本地分析脚本后可以发现,题目模型本体是一个普通的小型 CNN:

  • 三层卷积
  • ReLU
  • MaxPool
  • 最后接一个二分类全连接层

普通推理流程没有什么特别的,就是标准的浮点前向传播。

真正的坑在密文推理部分。

题目把最后一层全连接的输入特征和权重都做了量化,然后在一个模数环里计算,核心参数大致如下:

SCALE = 1000
PLAIN_MODULUS = 8159233

解码逻辑是:

def _decode(v):
    return v - PLAIN_MODULUS if v > PLAIN_MODULUS // 2 else v

这段逻辑的意思非常关键:

  • 如果结果超过 PLAIN_MODULUS // 2
  • 就会被解释成一个负数

也就是说,密文推理其实不是简单地看“数值大不大”,而是先做模运算,再做一次“半模数折返”。

这就给了我们一个可利用点:只要把某个类别的量化分数推到“刚好越过半模数”的位置,它在解码后就会从正数变成负数,最终可能导致密文预测结果与普通明文推理结果不一致。

这就是题目里所谓的 “密文翻转”。

一开始最直观的想法是:

  • 对目标图做一点扰动
  • 保持普通模型预测不变
  • 同时让密文模型预测翻转

问题在于题目还加了一个很严格的约束:

‖ΔX‖∞ ≤ 2/255

这意味着每个像素最多只能改 2 个灰度级。
这个限制非常小,普通连续空间里的 PGD、FGSM 思路虽然能找到“翻转成功”的图片,但经常会超出约束,比如先前搜索出的候选图就达到了
5/255,虽然明文/密文条件已经满足,但第一关 L∞ 没过,所以仍然拿不到 Flag。

因此,这题真正的难点不是“找到翻转方向”,而是:

在 8-bit 离散像素空间里,把扰动压到 ±2 灰度级之内,同时精确卡到模环解码翻转点。**

设密文分数为:

raw = q_feat @ q_w^T + q_b

解码后:

dec = raw                  , if raw <= P/2
dec = raw - P              , if raw >  P/2

其中:

P = 8159233
P/2 = 4079616

所以一旦某个类别分数满足:

raw > 4079616

它在解码后就会变成:

dec = raw - 8159233 < 0

也就是说,原本很大的正数,会瞬间变成一个负数。

题目的突破口就在这里:

  • 普通明文模型仍然看浮点 logits,所以它依旧会判成“正常”
  • 但密文部分看的是量化 + 模环 + 解码后的分数
  • 只要某一类被推过半模数边界,就有机会出现:
  • 明文预测:正常
  • 密文预测:肺炎

这正是题目要求的翻转条件。

对 target_image.png 跑原模型和密文逻辑后,可以确认:

  • 明文预测是 正常
  • 密文预测也是 正常

说明原图不会直接出 Flag,必须构造对抗样本。

先用普通梯度搜索,目标是:

  • 保持明文仍然预测为正常
  • 尽量让量化后的第一类分数越过半模数边界

这一阶段可以比较容易找到一个成功样本:

  • 明文预测:正常
  • 密文预测:肺炎

但是这种样本通常会有一个问题:

L∞ = 5/255

已经超了页面要求的 2/255。

也就是说,这一步只能说明:翻转方向找对了,但还不够精确。

这一步本来以为可以直接做插值,把成功扰动按比例缩小到 2/255,结果失败了。

原因后来也很清楚:5/255 的成功点其实只是刚刚踩中翻转边界,一旦往回缩,量化整数分数就会立刻掉回安全区,密文预测也随之恢复正常。

所以这题不是“有了成功图就能压缩”,而是必须:直接在 ±2 灰度级的离散空间里重搜。

最终采用的做法是:

  1. 以 target_image.png 为基准
  2. 以之前找到的 5/255 成功图作为 warm start
  3. 但不是直接用它,而是只保留它的扰动方向
  4. 然后把搜索空间严格限制为:
delta ∈ {-2, -1, 0, 1, 2}

也就是每个像素每个通道最多只改 2 个灰度级。

因为页面最终判的是保存后的 8-bit PNG 图像,不是你内存里的 float tensor。
如果你在连续空间里优化,再落盘成 PNG,很多细小扰动会因为四舍五入直接丢掉,最终提交时效果和本地看到的不一样。

所以必须让搜索过程本身就在整数像素空间里进行。

一开始的损失函数是“无脑把 raw0 往上顶”,后来发现这会出问题。

原因是:

  • raw0 一旦超过 4079616
  • 解码后是 dec0 = raw0 - 8159233
  • 这时候 raw0 越大
  • dec0 反而越接近 0
  • 这样就越不容易让另一类 dec1 压过去

也就是说,不能一味增大第一类分数,而应该让它:刚好越过半模数,但不要越过太多

所以正确目标不是:

  • “最大化 raw0”

而是:

  • 让 raw0 落在一个合适区间内
  • 同时尽量抬高 raw1
  • 并保证明文 margin 仍然是正的

换句话说,这题的本质不是普通分类攻击,而是一个模环边界精确卡点问题。

exp:

import os
import random
import numpy as np
from PIL import Image

import torch
import torch.nn as nn
import torch.nn.functional as F

IMAGE_SIZE = 64
SCALE = 1000
P = 8159233
HALF = P // 2
MAX_DELTA = 2
DEVICE = "cpu"

BASE = os.path.dirname(os.path.abspath(__file__))

TARGET_PATH = os.path.join(BASE, "target_image.png")
WARM_PATH   = os.path.join(BASE, "best_adv.png")   # 5/255 成功图
MODEL_PATH  = os.path.join(BASE, "model.pth")
FC_W_PATH   = os.path.join(BASE, "fc_weight.npy")
FC_B_PATH   = os.path.join(BASE, "fc_bias.npy")


class InferenceModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3,16,3,padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(16,32,3,padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32,64,3,padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Flatten()
        )
        self.fc = nn.Linear(64*8*8, 2)

    def forward(self, x):
        return self.fc(self.features(x))


def load_img_u8(path):
    img = Image.open(path).convert("RGB").resize((IMAGE_SIZE, IMAGE_SIZE))
    arr = np.asarray(img).astype(np.uint8)
    return torch.from_numpy(arr).permute(2,0,1).unsqueeze(0)


def save_img_u8(x, path):
    arr = x.squeeze(0).permute(1,2,0).cpu().numpy().astype(np.uint8)
    Image.fromarray(arr).save(path)


def to_float(x_u8):
    return x_u8.float() / 255.0


def normalize(x):
    mean = torch.tensor([0.485, 0.456, 0.406], device=x.device).view(1,3,1,1)
    std  = torch.tensor([0.229, 0.224, 0.225], device=x.device).view(1,3,1,1)
    return (x - mean) / std


def ste_round(x):
    return (torch.round(x) - x).detach() + x


def decode_ring(v):
    return np.where(v > HALF, v - P, v)


@torch.no_grad()
def exact_eval(model, x_u8, q_w, q_b):
    x = to_float(x_u8)
    xn = normalize(x)

    logits = model(xn)
    plain_pred = int(logits.argmax(1).item())

    feats = model.features(xn)[0].cpu().numpy()
    q_feats = np.round(feats * SCALE).astype(np.int64)

    raw = q_feats @ q_w.T + q_b
    mod = np.mod(raw, P)
    dec = decode_ring(mod)
    cipher_pred = int(dec[1] > dec[0])

    return {
        "plain_logits": logits[0].cpu().numpy(),
        "plain_pred": plain_pred,
        "raw_scores": raw,
        "decoded_scores": dec,
        "cipher_pred": cipher_pred,
        "gap": int(dec[1] - dec[0]),
    }


def linf_u8(a, b):
    return int((a.int() - b.int()).abs().max().item())


def build_candidate(orig_u8, delta_real):
    delta_clip = torch.clamp(delta_real, -MAX_DELTA, MAX_DELTA)
    delta_int  = ste_round(delta_clip)
    x_u8 = torch.clamp(orig_u8.float() + delta_int, 0, 255)
    x_u8 = ste_round(x_u8)
    return x_u8


def search_once(model, orig_u8, warm_u8, q_w, q_b, steps=2000, lr=0.08, seed=0):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)

    warm_delta = (warm_u8.int() - orig_u8.int()).clamp(-MAX_DELTA, MAX_DELTA).float()
    delta_real = nn.Parameter(warm_delta + torch.empty_like(warm_delta).uniform_(-0.25, 0.25))
    opt = torch.optim.Adam([delta_real], lr=lr)

    q_w_t = torch.from_numpy(q_w).float()
    q_b_t = torch.from_numpy(q_b).float()

    target0 = 4160000.0   # 不要再往上顶太多,贴近成功图那个量级
    best = None

    for step in range(steps):
        opt.zero_grad()

        x_u8 = build_candidate(orig_u8, delta_real)
        x = to_float(x_u8)
        xn = normalize(x)

        logits = model(xn)
        feats = model.features(xn)[0]

        q_feats_st = ste_round(feats * SCALE)
        raw_st = q_feats_st @ q_w_t.T + q_b_t
        raw0 = raw_st[0]
        raw1 = raw_st[1]

        plain_margin = logits[0,0] - logits[0,1]

        # 关键:raw0 拉到“刚刚过半模数”的位置,而不是无脑变大
        loss = (
            ((raw0 - target0) / 200000.0) ** 2   # raw0 贴近目标
            - 0.80 * (raw1 / 1000000.0)          # raw1 越大越好(往 0 方向抬)
            - 0.10 * plain_margin                # 维持明文判 0
            + 2.50 * F.relu(0.50 - plain_margin) # 明文别掉
        )

        loss.backward()
        opt.step()

        if step % 25 == 0 or step == steps - 1:
            with torch.no_grad():
                x_eval = build_candidate(orig_u8, delta_real)
                ev = exact_eval(model, x_eval, q_w, q_b)
                d = linf_u8(x_eval, orig_u8)

                print(
                    f"[step {step:04d}] "
                    f"L∞={d}/255 plain={ev['plain_pred']} cipher={ev['cipher_pred']} "
                    f"raw={ev['raw_scores']} dec={ev['decoded_scores']} gap={ev['gap']} "
                    f"logits={ev['plain_logits']}"
                )

                score = (
                    int(d <= 2 and ev["plain_pred"] == 0 and ev["cipher_pred"] == 1),
                    int(ev["gap"]),
                    -abs(int(ev["raw_scores"][0]) - int(target0)),
                )

                if best is None or score > best["score"]:
                    best = {
                        "score": score,
                        "x_u8": x_eval.clone(),
                        "eval": ev,
                        "linf": d,
                    }

                if d <= 2 and ev["plain_pred"] == 0 and ev["cipher_pred"] == 1:
                    return best

    return best


def main():
    model = InferenceModel().to(DEVICE)
    model.load_state_dict(torch.load(MODEL_PATH, map_location=DEVICE))
    model.eval()

    q_w = np.round(np.load(FC_W_PATH) * SCALE).astype(np.int64)
    q_b = np.round(np.load(FC_B_PATH) * (SCALE ** 2)).astype(np.int64)

    orig_u8 = load_img_u8(TARGET_PATH).to(DEVICE)
    warm_u8 = load_img_u8(WARM_PATH).to(DEVICE)

    print("[*] orig =", exact_eval(model, orig_u8, q_w, q_b))
    print("[*] warm =", exact_eval(model, warm_u8, q_w, q_b))
    print("[*] warm linf =", linf_u8(warm_u8, orig_u8), "/255")

    best_global = None

    for restart in range(16):
        print(f"\n========== restart {restart} ==========")
        best = search_once(model, orig_u8, warm_u8, q_w, q_b, steps=2000, lr=0.08, seed=2026+restart)

        ev = best["eval"]
        print("[*] restart best:")
        print("    linf =", best["linf"], "/255")
        print("    raw  =", ev["raw_scores"])
        print("    dec  =", ev["decoded_scores"])
        print("    gap  =", ev["gap"])
        print("    pred =", ev["plain_pred"], ev["cipher_pred"])
        print("    logits =", ev["plain_logits"])

        if best_global is None or best["score"] > best_global["score"]:
            best_global = best

        if best["linf"] <= 2 and ev["plain_pred"] == 0 and ev["cipher_pred"] == 1:
            out = os.path.join(BASE, "best_adv_eps2_success.png")
            save_img_u8(best["x_u8"], out)
            print("[+] SUCCESS:", out)
            return

    out = os.path.join(BASE, "best_adv_eps2_bestgap.png")
    save_img_u8(best_global["x_u8"], out)
    print("[-] best effort saved:", out)
    print("[*] best effort =", best_global["eval"])
    print("[*] best effort linf =", best_global["linf"], "/255")


if __name__ == "__main__":
    main()

flag{96151b8cb05f1c42d40ce233c62714da}

隐私梯度逆向

页面是一个“联邦风控协同系统”,总行负责下发模型参数,分行负责本地训练并回传梯度。前端明确给了两条关键能力:

  1. 总行可以上传自定义参数
  2. 分行训练后可以下载梯度 JSON

页面和参数区里还能看到模型结构是两层全连接:

  • W1: 16 × 17
  • b1: 16
  • W2: 1 × 16
  • b2: 1

这意味着输入维度是 17。结合常见 CTF 习惯,17 很像整串 flag{...} 的长度。

这题本质不是去“破解差分隐私”,而是利用了可控模型参数 + 可下载梯度这两个条件,主动把问题变成一个容易逆向的一阶梯度泄露题。

正常情况下,服务端返回的是带噪梯度,例如导出的字段就是:

  • noisy_grad_w1
  • noisy_grad_b1

如果直接用随机参数,梯度里混了模型非线性、激活状态和噪声,恢复输入会比较难。
但题目允许我们
自己上传参数,于是可以把网络“调教”成一个非常适合做反演的形状。

我上传的参数设计如下:

  • w1 = 0
  • b1 = 1
  • w2 = [10, -10, 10, -10, ..., 10, -10]
  • b2 = 0

因为 w1=0,所以第一层预激活值只剩下 b1=1,恒大于 0。
也就是说,ReLU 之类的激活函数在这里全部导通,不会出现一部分神经元“死掉”的情况。

此时第一层每个神经元对应的梯度会变成下面这种形式:

∂L∂W1i≈δi⋅x\frac{\partial L}{\partial W1_i} \approx \delta_i \cdot x∂W1i∂L≈δi⋅x

而偏置梯度是:

∂L∂b1i≈δi\frac{\partial L}{\partial b1_i} \approx \delta_i∂b1i∂L≈δi

于是两者一除:

∂L/∂W1i∂L/∂b1i≈x\frac{\partial L/\partial W1_i}{\partial L/\partial b1_i} \approx x∂L/∂b1i∂L/∂W1i≈x

也就是说,第 i 行的权重梯度除以对应的偏置梯度,直接就是输入向量。

这就是整题的突破口。

导出的梯度确实是加了噪的。比如新文件里 noisy_grad_b1 和 noisy_grad_w1 的数值都已经很大,而且每一行存在一定偏移。

但这里有两个有利条件:

因为我上传的 w2 取了 ±10,所以有效梯度量级被拉大,噪声相对没那么致命。

输入长度是 17,而且最后恢复出来应满足:

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

也就是:

  • 前 5 位固定:flag{
  • 最后 1 位固定:}
  • 中间部分是题目答案

这就给了我们一个很强的校准条件。

拿到新的 branch_gradient (1).json 后,可以看到:

  • noisy_grad_b1:16 个数
  • noisy_grad_w1:16×17 的矩阵

这正好对应 16 个隐藏神经元、17 维输入。

对每一行做:

ri=noisy_grad_w1[i]noisy_grad_b1[i]r_i = \frac{\text{noisygradw1}[i]}{\text{noisygradb1}[i]}ri=noisy_grad_b1[i]noisy_grad_w1[i]

理论上 r_i 应该接近真实输入 x,但由于噪声存在,不同行会带有不同程度的比例偏差和常数偏差。

因为每一行的 17 个位置里,以下位置的真实字符已知:

  • 0,1,2,3,4,16
  • 对应字符:f l a g { }

所以可以对每一行 r_i 拟合一个仿射变换:

si=ai⋅ri+bis_i = a_i \cdot r_i + b_isi=ai⋅ri+bi

让这一行在已知位置尽可能贴近:

flag{...........}

这样每一行都会得到一个“校正后的候选字符串”。

把 16 行校正后的 ASCII 值按列取中位数,再 round 成整数,最后转字符。

这样能有效抹平噪声,最终恢复出:

flag{c2f41b72a9d}

因此题目要求提交的 11 位答案就是:

c2f41b72a9d

这一结果是由该梯度文件恢复得到的。

import json
import numpy as np

# 读取梯度
with open("branch_gradient (1).json", "r", encoding="utf-8") as f:
    data = json.load(f)

gb = np.array(data["noisy_grad_b1"], dtype=float)      # (16,)
gw = np.array(data["noisy_grad_w1"], dtype=float)      # (16,17)

# 逐行做比值
ratios = gw / gb[:, None]

# 已知 flag 外壳
known_idx = [0, 1, 2, 3, 4, 16]
known_val = np.array([ord('f'), ord('l'), ord('a'), ord('g'), ord('{'), ord('}')], dtype=float)

decoded_rows = []

for i in range(ratios.shape[0]):
    r = ratios[i]

    # 拟合 s = a*r + b
    X = np.vstack([r[known_idx], np.ones(len(known_idx))]).T
    a, b = np.linalg.lstsq(X, known_val, rcond=None)[0]

    s = a * r + b
    decoded_rows.append(s)

decoded_rows = np.array(decoded_rows)

# 按列取中位数,抗噪
final_ascii = np.rint(np.median(decoded_rows, axis=0)).astype(int)
flag = ''.join(chr(x) for x in final_ascii)

print("Recovered flag:", flag)

# 取中间 11 位
if flag.startswith("flag{") and flag.endswith("}"):
    print("Answer:", flag[5:-1])
Recovered flag: flag{c2f41b72a9d}
Answer: c2f41b72a9d