Symmetry Stealing: Group Discovery for Model Extraction and Adversarial Transfer

When a company serves a model through a prediction API, an attacker can treat every paid query as a training label and distill a local copy of the model — this is model extraction, and it is cheap: a commercial text classifier was cloned for $7.10 [Model Extraction and Adversarial Transferability, Your BERT is Vulnerable!](/work/model-extraction-and-adversarial-transferability-your-bert), and whole embedding APIs for under $300 Tamber et al.. Today's attackers copy the decision boundary but throw away the victim's structure. Yet many valuable victims — molecular property predictors, 3D shape classifiers, medical imaging models — are built with an explicit geometric prior called equivariance: their predictions transform predictably, or stay flat, when the input is rotated, scaled, or permuted. This prior is expensive for the owner to obtain and hard for an unconstrained copy to reproduce from queries alone.

The proposal here is to steal the symmetry before stealing the boundary. An attacker probes the API with transformed copies of the same input — rotate it, rescale it, permute it — and reads off which transformations the victim ignores. That discovered group is then baked into the student copy as a hard weight-tying constraint, in the style of programmatically constructed equivariant networks. I claim this yields a triple payoff: extraction reaches high fidelity with fewer queries, the copy generalizes along the victim's orbits for free, and — the most dangerous part — adversarial perturbations crafted on the symmetry-matched copy transfer back to the victim far better than perturbations from a standard stolen model, because the copy's decision-boundary geometry now matches the victim's. The same probing procedure doubles as a defender-side finding: an API leaks its own architecture's symmetry group through ordinary prediction queries, a leakage channel nobody has measured.

Core Claim

The symmetry group of a black-box victim is an inferable, query-cheap property of its input–output behavior, and conditioning the extraction student on the discovered group (rather than leaving it unconstrained, or guessing the group by hand) simultaneously improves extraction fidelity per query and the success rate of second-stage adversarial transfer attacks against the victim. The closest existing work stops short on all three legs: He et al. chains extraction with transfer but uses entirely unconstrained students and never considers geometry; Wang et al. shows hand-specified group convolutions smooth decision boundaries and resist white-box attacks, but never studies extraction or cross-model transfer; Xu et al.'s Hufu exploits permutation equivariance only as a passive watermark, not as something an adversary can infer and exploit. No paper in the corpus connects symmetry specification, extraction, and transfer, and none infers a victim's group from query responses.

Research Program

Stage one is orbit probing. For a candidate group element $g$ (a rotation, a scale change, a token permutation), the attacker submits pairs $(x_i, g \cdot x_i)$ and measures how much the victim's output moves along the orbit:

$$d(g) \;=\; \frac{1}{m}\sum_{i=1}^{m} \mathrm{KL}\!\left(p_v(x_i)\,\big\|\,p_v(g\cdot x_i)\right),$$

where $p_v(x)$ is the probability vector the API returns and $m$ is the number of probe pairs. Transformations with $d(g)$ below a threshold form the victim's effective invariance group $\hat{G}$; for continuous groups the attacker searches over Lie-algebra directions, since a handful of generator probes determines the whole subgroup, echoing how L-conv parameterizes continuous symmetries by their infinitesimal generators. For embedding-as-a-service victims, where outputs are vectors rather than class probabilities, the probe upgrades from invariance testing to full equivariance fitting: solve $\min_\rho \sum_i \|\phi_v(g\cdot x_i) - \rho(g)\,\phi_v(x_i)\|^2$ for a representation $\rho$, the same adversarial-generator idea that lets LaLiGAN recover latent Lie-algebra structure from raw data (it reports an equivariance error of $1.02 \times 10^{-4}$ on a 10,000-dimensional reaction–diffusion system where linear methods fail — evidence that non-obvious symmetry is recoverable from observations alone).

Stage two builds the student. Once $\hat{G}$ is estimated, the student's weights are constrained to the equivariant basis for that group, computed with the Krylov-subspace solver of EMLP, which turns infinitely many group constraints into a small linear system and computes bases for even enormous discrete groups in seconds. The student then distills from the attacker's query log — out-of-domain queries allowed, following Knockoff Nets, which showed in-domain data is unnecessary. The design contrasts with every prior student: He et al.'s students are unconstrained, and Tamber et al. align student backbones to victim structure only implicitly through architecture choice, never through a group inferred from responses.

Stage three closes the loop with transfer attacks. Perturbations crafted on the symmetry-matched student (gradient attacks plus momentum and input-diversity variants) are evaluated on the victim with zero further queries. The hypothesis has two supports that pull in opposite directions, which is exactly why it needs testing: Wang et al. show equivariance contracts the hypothesis space and smooths gradients — their cleanly trained group-equivariant CNN reached 73.01% FGSM and 64.96% PGD accuracy on CIFAR-10, beating an adversarially trained standard CNN at $\epsilon = 0.05$ (60.23% vs. 57.3%) — which should make the student's adversarial directions generic rather than surrogate-specific, the property that SAA buys with ~10 GPU-hours of feature alignment per surrogate–witness pair (reaching 88.2% average attack success across ten targets, a gain of up to 39.1% over baseline alignment). But equivariant layers also have fewer free parameters, and a weaker surrogate may craft weaker perturbations. The tension is unresolved in the literature, and the 3D case sharpens it: targeted point-cloud attacks with >99% white-box success on PointNet failed to transfer to DGCNN Xiang et al., suggesting that in geometry-heavy domains the missing ingredient may be precisely a shared symmetry constraint.

Stage four is the defensive corollary, run as measurement rather than defense construction. First, quantifying how much symmetry an API leaks is itself new — Hufu shows owners deliberately entangle symmetry with secrets, so accidental leakage is the natural complement. Second, orbit-probing has a query signature (paired, highly correlated transformed inputs) that detectors could flag. Third, the pipeline is stress-tested against the strongest active defenses: GRAD², which redirects the attacker's gradients using a defender-side surrogate and already weakens under architecture mismatch, and CMIM, which collapses per-class output distributions to block distillation at any temperature while barely touching clean accuracy (78.72% vs. 77.81% cross-entropy on CIFAR-100). Whether a symmetry-constrained student is more or less resilient to a defender whose surrogate assumes an unconstrained attacker is an open and consequential question.

Baselines

The naive reference point is random-query distillation into an unconstrained student, the Knockoff Nets recipe — wait, correctly: Knockoff Nets — which recovers 81–96% of victim accuracy from out-of-domain queries. This is what an attacker gets for free, and any added machinery must beat it at equal query budget to justify itself.

The strongest existing competitor is the two-stage pipeline of He et al.: distill an unconstrained student from API soft labels, then craft adversarial examples on the student and transfer them to the victim — the same threat model as ours, minus the symmetry. Their students recover 90–99% of victim accuracy; that is the fidelity number to match or beat per query. For the query-efficiency axis, the adaptive reinforcement-learning query strategy of Knockoff Nets (comparable fidelity with $6\times$ fewer queries than random sampling) is the competitor; our orbit probes cost queries too, so the comparison must charge them against the budget. For the transfer stage, SAA-style alignment applied with the extracted student as surrogate is the strongest published transfer booster (88.2% average success), though it was designed with a white-box witness the black-box thief does not have; we run it in the best available configuration and also combine it with our symmetry constraint. All baselines get identical victims, identical query pools, identical student parameter counts, and the same tuning budget, so the only varying ingredient is how symmetry is handled.

The key ablation is the group source. Four students distill from the same query log: unconstrained; equivariant under the discovered group $\hat{G}$; equivariant under a deliberately wrong group of the same dimension; and unconstrained but trained with orbit augmentation (each query duplicated under the discovered transformations). If the $\hat{G}$-student beats the wrong-group student, the discovery stage — not the architectural prior — is doing the work. If it fails to beat the augmented student, the contribution narrows to the probing algorithm itself, which is still the only way an attacker learns which transformations to augment with.

Why not just…?

Why not just query more with a standard student? This is the most serious objection, because extraction already works absurdly well: 90–99% recovery for He et al., 81–96% for Knockoff Nets, and architectural mismatch has never stopped it. Two honest replies. First, those victims had no hard-coded symmetry; the cost of copying an equivariant victim's flat-orbit behavior with an unconstrained student should show up as extra queries, and accuracy recovery is not the only metric — dollar costs of $7.10–$300 and rate-limited APIs make query efficiency a first-class objective. Second, accuracy recovery says nothing about transfer attack success, which is where a geometry-matched copy plausibly matters most, given the cross-architecture collapse Xiang et al. observed in 3D. The proposal's kill criterion is explicit: if the fidelity-per-query curve of the symmetry-matched student does not dominate the standard student's, and transfer success does not improve, the central claim is dead and we report the negative result — which would itself be the first controlled evidence on whether equivariance is an extraction barrier, directly resolving the tension between Knockoff-style resilience and 3D transfer fragility.

Why not just augment the student's training data with the same transforms? A real threat, and we treat it as a co-equal baseline rather than arguing around it. The indirect evidence favors hard constraints: EMLP cut double-pendulum rollout error from 0.028 to 0.012 where augmented MLPs fell short, and Rapidash explicitly reports that inflating capacity plus augmentation did not close the gap to truly equivariant models in low-data regimes — and distillation from a bounded query log is exactly a low-data regime. But distillation dynamics could differ, so the augmented student runs head-to-head at matched everything. Even if augmentation ties on fidelity, the proposal survives in reduced form: the attacker still cannot augment with the right group without discovering it first, so orbit probing remains the contribution and augmentation becomes its cheapest downstream consumer.

Why not just rely on existing defenses, making this attack moot? The file's own evidence says current defenses are porous against exactly this pipeline. Output obfuscation failed for He et al. and only marginally slowed Knockoff Nets; CMIM exists precisely because earlier soft-label defenses, including Nasty Teacher, fall to temperature scaling; GRAD² is faster than MAD ($3.75\times$–$6.33\times$) but its own authors flag that it weakens when the attacker's architecture deviates from the defender's surrogate — and a symmetry-constrained attacker is the maximal such deviation, which our Stage four tests directly. Watermarking, including Hufu's structurally entangled version with its 100% watermark retention under fine-tuning, verifies ownership after the fact but does not stop a stolen, symmetry-matched surrogate from mounting zero-query transfer attacks — the exact second stage He et al. demonstrated. So defenses are not moot, and we evaluate against the strongest ones rather than assuming they fail.

Proposed Experiments and Decisive Checks

Victims are trained on four regimes of increasing geometric structure: CIFAR-10 and CIFAR-100, with both standard CNN victims and the $P4$ group-convolutional victims of Wang et al. so the discovery algorithm must distinguish hard symmetry from augmentation-induced soft invariance; CUB200 and Indoor67 fine-grained classifiers stolen with ImageNet/TinyImageNet out-of-domain query pools, the Knockoff Nets setting; ModelNet40 point-cloud victims (PointNet and DGCNN), where Xiang et al.'s cross-architecture transfer failure sets the bar and $SO(3)$ orbit probing is natural; and QM9 molecular property victims built with equivariant layers in the Rapidash lineage, where the group is continuous and the stakes for real APIs are highest. Metrics are fidelity (student accuracy as a fraction of victim accuracy), queries and simulated dollars to reach 95% of the strongest baseline's fidelity, transfer attack success rate on the victim from student-crafted perturbations, and, for the defender-side results, the detectability of orbit probes and the leakage of $\hat{G}$ as measured by probe-pair count. Three checks decide the proposal: the discovered-group student must beat the unconstrained student on fidelity-per-query and transfer success at matched budgets; it must beat the wrong-group student, isolating discovery as the active ingredient; and it must remain effective, or measurably fail, against GRAD² and CMIM, with the failure mode documented either way. Every reported number above comes from the cited papers; where the corpus is silent — for instance on any extraction fidelity for equivariant victims — no reported result exists on Lacuna, which is the gap this proposal fills.