Baited Surrogates: Catching Transfer Attacks Through the Model You Publish

Companies routinely ship a small, compressed copy of their server model to phones and edge devices. That copy becomes a free gift to attackers. They can compute gradients on it offline, build adversarial inputs (small, nearly invisible perturbations that flip a model's prediction), and send those inputs to the private server model without ever probing it. We propose to turn this leak into a trap. The published model carries a planted "honey feature": a secret, low-amplitude input direction that the published model treats as a shortcut and the server model ignores. Any attack optimized on the published copy is pulled toward that shortcut. Two things follow. The perturbation transfers worse to the server, and it carries a fingerprint that a cheap server-side check can detect. The server's classifier is never retrained, so its clean accuracy is unchanged by construction.

The idea borrows from honey connections in enterprise networks. There, defenders inject decoy traffic that no legitimate user has any reason to touch. Any interaction with it is an unambiguous alarm, and the decoys also corrupt the attacker's map of the network (Role-Based Deception in Enterprise Networks). Our honey feature plays both roles for machine learning models. It pollutes the attacker's gradient signal, and it acts as a canary that clean inputs essentially never trip. The robustness-accuracy trade-off still exists, but it is moved somewhere we can measure and control: onto the published edge model rather than the protected server.

Core Claim

Consider transfer attacks whose surrogate is a model the defender itself releases, whether an on-device compressed model or a fine-tune of a defender-controlled backbone. In that setting, planting a secret shortcut direction in the released model should do three things at once. It should reduce the attack success rate on the unmodified server model. It should let a key-correlation detector flag the attacks at a low false-positive rate. And it should cost the released model only a small, measurable amount of clean accuracy. The adaptive-attack claim is the one that matters most. An attacker who knows the scheme and tries to estimate and remove the bait from the released model's gradients should either still be caught or should lose most of their transfer success. In honey-connection terms, the attacker pays a verification cost.

This differs from the closest existing work in where the bait lives and what kind of attack it catches. Detecting Universal Trigger's Adversarial Attack with Honeypot (DARCY) plants trapdoor tokens inside the protected text classifier itself. Its reported cost is about a 2% average F1 drop on benign text. It handles only discrete, input-independent trigger phrases. We plant bait only in the released surrogate, target continuous ℓ∞ and ℓ2 image perturbations, and leave the protected model untouched. TRAP also uses adversarial optimization as a honeypot, but it deliberately makes its suffixes non-transferable in order to fingerprint a model's identity. It protects no inference pipeline. The LLM honeypots Proxy Barrier and Speculative Safety Honeypot motivate the principle that a deliberately weaker decoy model makes a better tripwire. They also constrain our design: Proxy Barrier blocks up to 19% of benign queries, which tells us the detector's false-positive rate on clean and naturally corrupted inputs must be a headline metric.

Why the Mechanism Should Work

Two lines of work explain why released models are good surrogates. Publishing Efficient On-device Models Increases Adversarial Vulnerability shows that compressed or quantized copies act as close white-box stand-ins for their parent models. Two Sides of the Same Coin shows that fine-tuning preserves the base model's decision geometry. Adversarial Vulnerability from Interference Between Features in Superposition gives a mechanism. In its analysis, models that pack more features than they have dimensions converge to shared patterns of feature overlap, and transfer rose from 5% to 98% once data correlations forced those patterns to align. Taken together, these papers tell us what attacks follow: the steepest, most shared directions in the surrogate. If we add a direction to the released model that is far steeper than any natural one but that the server lacks, gradient-based attacks will spend their perturbation budget there.

Concretely, the defender draws $K$ secret unit-norm input patterns $v_1,\dots,v_K$. These are high-frequency textures well below the attack budget. The released model $g$ is trained or distilled from the server with

$$ \mathcal{L}(g) = \mathrm{CE}(g(x), y) + \beta\, \mathbb{E}_{c}\, \mathrm{CE}\big(g(x + \epsilon_k v_c),\, c\big), $$

where $\mathrm{CE}$ is cross-entropy, $(x,y)$ is a clean example, $c$ is a randomly chosen target class assigned key $v_c$, $\epsilon_k$ is the key amplitude (set below the attacker's budget), and $\beta$ trades the released model's clean accuracy against bait strength. This is a planted shortcut, much like a backdoor. The server model $f$ never sees the keys, so adding $\epsilon_k v_c$ does nothing to it.

At inference the server computes a detection score

$$ s(x) = \max_{c}\, \frac{\langle r(x), v_c\rangle}{\lVert r(x)\rVert}, $$

where $r(x)$ is a high-pass residual of the input. An input is flagged when $s(x)$ exceeds a threshold calibrated to 1% false positives on held-out clean data. The cost is one filter and $K$ inner products, far cheaper than CARSO's multiple reconstructions per input.

Research Program

The first stage builds baited released models for RobustBench server models on CIFAR-10, CIFAR-100, and ImageNet, using RobustBench as the source of server models. The released models are pruned and quantized students. We sweep $\beta$, $\epsilon_k$, and $K$ to map the trade-off between the released model's clean accuracy and the strength of its bait.

The second stage studies key placement, and here the superposition theory becomes a design tool rather than a citation. Random keys are easy to plant, but a white-box attacker may find and remove them easily. We will compare them with keys placed partly inside the shared directions that superposition analysis identifies as carrying transfer. We find those directions by fitting sparse autoencoders, as Stevinson et al. did on ImageNet. The hypothesis is that entangled keys force a dilemma: projecting them out also removes the directions that make attacks transfer.

The third stage is adaptive evaluation. We will run transfer attacks built from projected gradient descent, momentum, input diversity, and ensembles on the released model. We will add attackers who ensemble the baited model with unrelated public models. Most importantly, we will test an attacker who knows the scheme, estimates the dominant gradient directions over many inputs, projects them out, and then attacks. We will also report minimum-margin AutoAttack in the style of MixedNUTS, so that no claimed robustness rests on masked gradients.

Baselines

The naive reference point releases a plain compressed copy, runs the undefended server, and does no detection. It sets the transfer attack success rate we must reduce. No reported result found on Lacuna for edge-to-server transfer success on CIFAR or ImageNet, so we measure it ourselves with identical attack budgets.

The first strong competitor is a keyless detector: a binary classifier trained on perturbations crafted against the unbaited released model, given the same server-side compute and the same calibration data. It isolates whether the bait adds anything beyond ordinary detection of adversarial noise. Beating it means higher detection rate at matched 1% false positives, especially against attacks the detector was not trained on.

The second is adversarial training of the server with TRADES, which reports up to 56.61% robust accuracy on CIFAR-10. It is the standard answer, at a clean-accuracy cost. We compare robust accuracy under transfer from the released model, where it is likely stronger than its white-box number. Beating it means a lower combined rate of undetected and successful attacks while server clean accuracy stays at the undefended level.

The third is MixedNUTS on the server, the strongest training-free method for balancing accuracy and robustness. It reports a 7.86-point clean gain on CIFAR-100 for a 0.87-point robust loss. We tune its grid search on the same 1,000 validation images. Beating it means matching its transfer robustness while also detecting attacks, which it cannot do, at no clean loss.

For reference we include CARSO, which reports 76.13% AutoAttack robust accuracy on CIFAR-10 with a 5.6% clean drop. The key ablation is a continuous DARCY-style variant that plants the same keys in the server model instead of the released one. It isolates whether putting the bait on the surrogate is what removes the clean-accuracy tax.

Why not just…?

Why not just adversarially train the server with TRADES? It works, but TRADES' own error decomposition makes the clean-accuracy cost unavoidable, and robustly trained models become underconfident according to RobustBench. TRADES also gives no alarm. If TRADES alone already drives transfer success from the released model near zero at an acceptable clean cost, our method's value shrinks to detection only. The head-to-head comparison above settles this.

Why not just train a generic adversarial-example detector without any bait? This is the most serious threat. Transfer perturbations from a plain released model may already be statistically distinctive. The keyless-detector baseline exists to test exactly this. If it matches the baited detector on held-out attack families and on the adaptive attacker, the bait is unnecessary and we will say so. We expect the bait to win on generalization, because the key correlation does not depend on which attack algorithm was used.

Why not just release an architecturally different or adversarially trained edge model so attacks do not transfer? Architectural mismatch weakens transfer, but it gives up the accuracy and efficiency that motivated distillation, and it gives no detection. Making the edge model robust shifts the TRADES tax onto users' devices. We will measure both options on the same plot of edge clean accuracy against transfer success, alongside the baited model.

Why not just use MixedNUTS? It is cheap and strong, but passive. It cannot tell a campaign of attacks apart from hard clean inputs, and it still needs an expensive robust model. Our detector can also be stacked on top of it, and we will test that combination.

Decisive Checks

The idea succeeds if four things hold on CIFAR-100 and ImageNet. The baited released model loses only a small amount of clean accuracy relative to the plain compressed copy. Transfer success on the untouched server falls well below the naive baseline. The detector exceeds the keyless detector's true-positive rate at 1% false positives, including on RobustBench common corruptions. And against the estimate-and-project adaptive attacker, the attack is either still detected or its transfer success collapses. The idea fails if projection removes the keys cheaply while transfer survives. That outcome would itself be informative: it would show that bait directions can be separated from shared superposition directions in real networks.