模型提取与盗取攻击深度实战：从黑盒 Prediction API 到替代模型克隆与参数反解的安全工程

机器学习即服务（MLaaS）把训练好的模型包装成一个"提问—返回预测"的 API：你传入一条样本，它吐回类别标签或置信度。这种黑盒便利的背后藏着一条被长期低估的攻击面——模型提取（Model Extraction）/ 模型盗取（Model Theft）：攻击者仅凭查询权限，就能重建出与原模型功能等价、甚至参数完全一致的克隆，从而免费"白嫖"商业模型、绕开付费墙、或为后续对抗攻击铺路。本文从威胁模型的第一性原理出发，拆解功能克隆、参数反解、树模型路径提取三类主流手法，给出可复现的 PyTorch/Python 实现，并落到防御侧的输出扰动、查询监控与差分隐私工程细节。

一、威胁模型：攻击者到底"看见"了什么

黑盒提取攻击的前提是 oracle 访问——攻击者能调用模型但看不到权重、结构或训练数据。根据返回信息的丰富度，威胁等级分三档：

核心观察：预测函数本身就是信息泄漏源。模型在训练集上学到的决策边界、置信度曲面，都编码在 f(x) 的返回值里。攻击者要做的，只是用足够多的查询把这些几何结构"描"出来。

二、攻击分类：三条主路径

2.1 功能克隆（Functionality Extraction / Surrogate）

最通用的一类（Tramèr et al., 2016, Stealing Machine Learning Models via Prediction APIs）。攻击者用公开/合成数据作种子，批量查询 oracle 得到 (x, f(x)) 对，再训练一个替代模型（surrogate） 去拟合 oracle 的行为。克隆不要求复制权重，只要输入—输出映射被逼近即可。

2.2 参数反解（Equation-Solving Extraction）

当目标模型结构已知且较简单（逻辑回归、线性 SVM、浅层决策树），攻击者可用边界查询直接解出参数。这类攻击对"只返回硬标签"也有效，因为决策边界点就藏在标签翻转的位置。

2.3 路径提取（Path-Finding，树模型）

对决策树 / 随机森林，攻击者通过二分定位每个内部节点的分裂特征与阈值，逐步重建整棵树（Jagielski et al., 2020）。一旦树结构还原，模型即被完全盗取。

三、功能克隆实战：用蒸馏损失训练替代模型

假设 oracle 是图像分类器，返回 softmax 概率向量。攻击者手头只有无标签种子集 X_seed，目标是训练 surrogate g_θ 逼近 oracle f。

损失设计：用软标签的 KL 散度而非硬 0/1 损失，能保留 oracle 的置信度曲面信息，克隆保真度显著提升：

$$

\mathcal{L}_{\text{extract}} = \frac{1}{N}\sum_{i=1}^{N} \mathrm{KL}\!\big(f(x_i)\,\|\,g_\theta(x_i)\big)

= \frac{1}{N}\sum_{i} \sum_{c} f_c(x_i)\,\log\frac{f_c(x_i)}{g_{\theta,c}(x_i)}

$$

温度 T 可放大暗知识（与知识蒸馏同理）：

$$

p_c^{(T)} = \frac{\exp(z_c/T)}{\sum_{c'}\exp(z_{c'}/T)}

$$

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

def steal_via_distillation(oracle_fn, surrogate, X_seed, T=4.0, epochs=20, lr=1e-3):
    """oracle_fn(x_tensor) -> softmax 概率 (numpy/tensor); 返回训练好的 surrogate。"""
    opt = torch.optim.Adam(surrogate.parameters(), lr=lr)
    for ep in range(epochs):
        opt.zero_grad()
        logits = surrogate(X_seed)                  # surrogate 原始 logits
        with torch.no_grad():
            soft = oracle_fn(X_seed)                # oracle 软标签
        # 软标签蒸馏：两侧都过温度 T 的 softmax
        p = F.softmax(soft / T, dim=-1)
        q = F.log_softmax(logits / T, dim=-1)
        loss = F.kl_div(q, p, reduction="batchmean") * (T * T)  # 温度缩放补偿
        loss.backward(); opt.step()
    return surrogate

# 若 oracle 只返回硬标签：改用交叉熵，surrogate 拟合 (x, argmax f(x))
def steal_hard_labels(oracle_labels, surrogate, X_seed, epochs=20, lr=1e-3):
    opt = torch.optim.Adam(surrogate.parameters(), lr=lr)
    for ep in range(epochs):
        opt.zero_grad()
        loss = F.cross_entropy(surrogate(X_seed), oracle_labels)
        loss.backward(); opt.step()
    return surrogate

查询效率：朴素随机采样要海量查询。工业界攻击者用主动学习式采样（如 BALD、核心集选择）或自适应查询（沿当前 surrogate 决策边界附近过采样），把查询数压低一个数量级。注意：查询数越少、越结构化，越容易被防御侧识别为"探测"。

四、参数反解：从边界点解出逻辑回归权重

若 oracle 是二维逻辑回归 f(x)=σ(wᵀx + b)，仅返回硬标签。攻击者只需找到决策边界（标签由 0 翻转到 1 的位置），该边界就是直线 wᵀx + b = 0。d 维空间只需 d+1 个边界点即可解出 w 和 b。

import numpy as np

def find_boundary_1d(oracle_label, x_a, x_b, iters=40):
    """在 x_a(标签0) 与 x_b(标签1) 之间二分定位边界点。"""
    lo, hi = np.array(x_a, float), np.array(x_b, float)
    for _ in range(iters):
        mid = (lo + hi) / 2.0
        if oracle_label(mid) == 0:
            lo = mid
        else:
            hi = mid
    return (lo + hi) / 2.0

def extract_linear_2d(oracle_label, n_iters=40):
    """二维逻辑回归：取 3 个边界点，解出 w,b。"""
    # 选两条大致正交的探测线
    pts = []
    for axis in [(1.0, 0.0), (0.0, 1.0)]:
        a = np.array([-5.0, -5.0]) * 0 + np.array([0.0, 0.0])
        b1 = np.array([axis[0]*10, axis[1]*10])      # 一侧
        b2 = np.array([-axis[0]*10, -axis[1]*10])    # 另一侧
        # 确保两端标签相反
        if oracle_label(b1) == oracle_label(b2):
            continue
        pts.append(find_boundary_1d(oracle_label, b1, b2, n_iters))
    if len(pts) < 2:
        raise RuntimeError("需要两条穿过边界的探测线")
    pts = np.array(pts)
    # 平面: w1 x + w2 y + b = 0 过所有边界点；齐次最小二乘
    A = np.hstack([pts, np.ones((len(pts), 1))])
    # 用第三个参照点构造第三个方程（取原点附近的边界）
    ref = find_boundary_1d(oracle_label, np.array([3.0, 1.0]), np.array([-3.0, -1.0]), n_iters)
    A = np.vstack([A, [ref[0], ref[1], 1.0]])
    _, _, vh = np.linalg.svd(A)
    w1, w2, b = vh[-1]                               # 零空间向量
    return np.array([w1, w2]), b

要点：每定位一个边界点需要约 log2(区间/精度) 次查询；d 维模型总查询量约 O(d·log(1/ε))，远低于功能克隆的百万级——这是简单模型反而更脆弱的反直觉结论。

五、树模型路径提取

对单棵决策树，攻击者选定一条从根到叶的路径，对每个内部节点做二分：沿"满足分裂条件"与"不满足"两个方向分别查询，找到令标签/输出跳变的分裂阈值，从而还原 (特征, 阈值) 对。逐节点、逐层递归即可重建整棵树。随机森林则对每棵树重复此过程。

六、防御工程：四道防线

输出扰动的最小实现：

import numpy as np

def defended_predict(logits, topk=1, round_digits=2, noise_scale=0.0):
    p = np.exp(logits - logits.max()); p /= p.sum()
    if topk is not None and topk < len(p):
        masked = np.zeros_like(p)
        masked[np.argsort(-p)[:topk]] = p[np.argsort(-p)[:topk]]
        p = masked / masked.sum()                     # 仅保留 top-k
    if round_digits:
        p = np.round(p, round_digits)                 # 量化置信度
        p /= p.sum()
    if noise_scale:
        p = p + np.random.laplace(0, noise_scale, p.shape)
        p = np.clip(p, 0, None); p /= p.sum()
    return p

# 极端档：仅返硬标签，几乎杜绝软信息泄漏
def hard_only(logits):
    return int(np.argmax(logits))

差分隐私提供理论保障：DP-SGD 下，攻击者即使无限查询也无法把克隆误差降到 Ω(1/√n) 以下（受隐私预算 ε 约束）。这是对抗功能克隆最本质的防线，但需权衡模型效用。

七、生产陷阱清单

八、度量与红蓝对抗

评估提取攻击自身，定义两个核心指标：

• 提取保真度（Fidelity）：F = P(g(x) == f(x))，在相同测试集上克隆与原模型预测一致的比例。
• 克隆效用（Adversarial Accuracy）：克隆模型在目标任务上的准确率；若接近原模型，则盗取成功。

防御侧应使用红队脚本定期自动探测：用上述蒸馏流程尝试克隆自家 API，监测保真度是否异常攀升，作为告警阈值。

结语

模型提取攻击揭示了一个朴素真理：模型的价值藏在它的输入输出映射里，而不只是权重文件里。当模型以 API 形式对外服务，每一次预测都是一次信息泄漏。理解三类主流手法——功能克隆（蒸馏逼近）、参数反解（边界求解）、路径提取（树重建）——以及四道防御（输出扰动、查询监控、水印、差分隐私），是任何对外提供推理服务的团队必须掌握的安全工程基线。它与本系列已发的归一化、位置编码、交叉注意力、残差、学习率、梯度累积、词嵌入共同构成"现代 LLM 内部机制、训练工程与安全边界"的完整知识拼图：前七篇教你把模型做对、做快、做准，这一篇教你别让它被人白白拿走。