Model owners protect trained neural networks by embedding a secret "passport": a key that sets the scale and shift parameters of normalization layers, so the model only works well, and only reveals the owner's signature, when that key is supplied. An ambiguity attack lets a thief skip deleting this watermark. Instead, the thief forges a second passport that also verifies, which leaves an arbitrator unable to decide who owns the model. The newest defenses route the passport through a non-differentiable cryptographic hash, so that gradient descent cannot work backwards from the signature to a fake key. The adversarial-robustness community has seen this pattern many times: a defense breaks the attacker's gradients rather than the attacker's goal. The usual result is gradient masking, meaning apparent robustness that disappears under an attack designed around the defense.
The central claim of this proposal is that hash-based passport defenses block gradients on a path the attacker does not need. Computing a hash forward is easy. A thief can pick an arbitrary passport, hash it to obtain the target signature, and then train the model's weights, or small inserted blocks, until the feature signs match. That is the direction in which accessory-block attacks already succeed against sign-regularized passports. We propose to test this "forward-direction" attack under the evaluation discipline of robustness benchmarking. That discipline means adaptive attackers, curves over attacker budget instead of single numbers, and explicit gradient-masking diagnostics. We will also test the natural next defense, injecting randomness at inference time, against the known argument that such randomness either destroys accuracy or stops protecting.
Where the prior work stands
Passport schemes began with Rethinking Deep Neural Network Ownership Verification. That paper makes normalization scale and bias depend on a secret passport, so a wrong passport drops accuracy to about 10%, and it uses a sign loss to fix the signs of the scale factors. Passport-aware Normalization moves the passport into a separate verification branch. Two later defenses motivate this work because they rest their security on non-differentiability. Trapdoor Normalization (TdN) hashes the passport with MD5 into a signature that the feature-map signs must match. CHIP does the same with chameleon hashes and adds multi-user licensing. Both argue irreversibility, that one cannot invert from signature to passport, and quote collision probabilities such as $4\times10^{-51}$. Neither evaluates an attacker who never inverts anything.
The attack method we reuse comes from Effective Ambiguity Attack … through Fully Connected Layer Substitution. It inserts small residual multilayer-perceptron blocks (IERB/CERB) before the passport layers and trains them on 2–10% of the data. This flips signature bits while preserving accuracy: 94.94% versus 94.70% on CIFAR-10 ResNet-18, and over 84% versus 64% for plain fine-tuning on AlexNet with about 1,000 images. The attack was demonstrated on sign-regularized schemes, not on hash-bound ones, and that is the gap we fill.
The evaluation method comes from the robustness literature:
- On Evaluating Adversarial Robustness supplies masking checks, for example black-box attacks beating white-box ones, and the requirement to report full budget curves.
- Slope supplies a first-order diagnostic $S(x)$ that compares the loss increase predicted by a gradient step with the increase actually observed. Values at or below zero flag obfuscated gradients, and the paper shows k-WTA scoring around $-0.002$.
- RobustBench supplies the standardization ethic. It deliberately excludes stochastic and non-differentiable models, and it evaluates only pixel-space evasion. We borrow its discipline but cannot reuse its attacks, because forging a passport is an optimization over parameters and keys, not an $L_p$-bounded change to an image.
Two papers constrain the inference-time noise component. On the Limitations of Stochastic Pre-processing Defenses shows an "invariance catch-22": making a model tolerate a defense's randomness removes the protection that randomness gave. On ImageNette, recovering benign accuracy from about 20% to over 90% raised attack success from near zero to nearly 100%. It also shows that plain iterative attacks already average over randomness, broke five stochastic defenses at 96–100% success. Decoder Gradient Shield is the one IP defense that uses gradient manipulation on purpose. It rotates an attacker's gradients by 90°–180° through a secret matrix. It targets output-watermark removal through an API, not parameter ownership. We treat it as evidence that intentional masking can be a legitimate design only when the attacker is confined to the masked channel.
Core Claim
We expect three results. First, hash-bound passports (TdN, CHIP) are secure against inverting a signature back into a passport, but not against a forward-direction ambiguity attack when the thief may modify weights. The attack draws a passport $P'$, computes the target signature $b'=\mathrm{hash}(P')$, and trains accessory blocks $\theta_A$ so that the model under $P'$ is both accurate and sign-consistent with $b'$:
$$\min_{\theta_A}\; \mathcal{L}_{\text{task}}(f_{\theta,\theta_A}(x;P'),y) \;+\; \lambda \sum_i \max\!\big(0,\; \tau - b'_i\,\gamma_i(P';\theta_A)\big).$$
Here $f_{\theta,\theta_A}$ is the stolen network with frozen original weights $\theta$ plus inserted blocks, $\gamma_i$ is the $i$-th normalization scale factor produced under passport $P'$, $b'_i\in\{-1,+1\}$ is the $i$-th hashed signature bit, $\tau$ is a sign margin, and $\lambda$ weights the sign term. No gradient ever passes through the hash.
Second, the Slope diagnostic will separate the two paths. It will be at or below zero for gradients with respect to the passport input, which is the masked path the defenses report. It will be clearly positive for gradients with respect to $\theta_A$, which is the path the attacker actually uses.
Third, adding inference-time noise to the passport-derived parameters, or randomizing which layers carry passports, will trace the trade-off Gao et al. predict. The owner's accuracy and resistance to forgery cannot both stay high, because iterative training of accessory blocks already averages over the noise.
If the first claim fails, and TdN and CHIP resist forward attacks at every data budget, that is also a strong, certifiable result that these defenses currently lack.
Research Program
Benchmark and threat models. We build a small, modular ambiguity benchmark in the style of BackdoorBench, whose separate input, attack, defense, evaluation and analysis modules we adopt. Its first job is to separate threat models that current papers blur. The first threat model is pure ambiguity, where weights are frozen and only a key can be forged. Here the forward attack is impossible, and hash defenses should win. The second is ambiguity after modification, where the thief releases a modified model. The third is modification with limited data, where the attacker's data fraction is the budget.
Success criterion. On the model the attacker releases, the forged passport must give clean accuracy within 1 point of the protected model and meet the defense's own signature-detection threshold. We report separately whether the owner's passport still verifies on that model. If both verify, the result is a true deadlock. If only the forged passport verifies, the result is replacement.
Headline metric. The headline metric is a curve of ambiguity success against attacker data fraction (1%, 2%, 5%, 10%, 20%) and against the parameters added by accessory blocks. This follows the robustness community's accuracy-versus-budget curves and prevents a defense from choosing a flattering single point.
Diagnostics. We adapt Slope to the forging loss above, computing it separately along the passport-input direction and the accessory-parameter direction. We also run the Carlini-style sanity checks. One check asks whether a gradient-free search over passports, such as a random or evolutionary search that hashes candidates forward, beats gradient-based passport reverse-engineering. The other checks whether success changes monotonically with budget. The IndicatorsOfAttackFailure tooling helps confirm that failed attacks failed for real reasons, not because the optimizer broke.
Noise defense study. We implement two stochastic variants on top of TdN. The first adds Gaussian noise of scale $\sigma$ to the passport-produced $\gamma,\beta$ at inference. The second follows the suggestion in Tian et al. to randomize, per query, which layers act as passport layers. For each $\sigma$, we fine-tune the owner's model to tolerate the noise and record its clean accuracy. We then run the forward attack twice: plain, and with explicit averaging over noise samples, known as Expectation over Transformation (EOT). This tests whether the catch-22 and the implicit averaging effect carry over from input-space defenses to parameter-space ownership defenses.
Baselines
The naive reference point is an unprotected ResNet-18 carrying a Uchida-style weight watermark. On such models, Tian et al. report 100% forged-signature detection. This sets the floor that any passport scheme must beat.
The weakest attack reference is plain fine-tuning without accessory blocks, which Tian et al. report at 64% accuracy on AlexNet with 2% data. The second is gradient-based passport reverse-engineering from Fan et al., which reaches 35–44% on CIFAR-100 with training data available.
The strongest existing attack is CERB, reported at 94.94% clean accuracy on CIFAR-10 ResNet-18 and 80.30% bit dissimilarity rate. We run it unmodified against every defense, on the same data subsets, the same number of epochs and the same GPU-hour cap as our forward attack. Our forward attack beats it only if, at equal data fraction, it reaches the joint accuracy-and-signature criterion on TdN or CHIP where unmodified CERB does not.
The strongest existing defenses are TdN, reported as a +0.88% ResNet-18 accuracy change, near-zero false-claim probability and stability to 90% pruning, and CHIP, reported as 94.80% protected accuracy and below 21% with a forged passport. We use the authors' published configurations and the same hyperparameter search budget for all defenses.
The key ablation removes hash knowledge from our attack. Accessory blocks are trained toward a random target signature not derived from $\mathrm{hash}(P')$. This isolates whether success comes from the forward-hashing insight or merely from added capacity.
Why not just…?
Why not just run CERB against TdN and CHIP and stop? This is the closest and most serious alternative, and our attack is essentially a hash-aware version of it. Unmodified CERB flips existing sign constraints. It has no reason to produce a signature equal to the hash of some passport it holds, so against hash-bound schemes it may leave a verifiable mismatch. The no-hash ablation measures exactly this difference. If plain CERB already succeeds, we will report that as the headline and the paper's contribution narrows to the threat-model separation, budget curves and diagnostics. We accept that outcome.
Why not just run AutoAttack or Square Attack through RobustBench? Those attacks search over bounded pixel perturbations to flip labels. Forging ownership is a search over keys and inserted parameters, and RobustBench by design excludes stochastic and non-differentiable models. A zero-order attack does belong in the benchmark: it is our gradient-free forward search over passports. Our claim is that it must operate in key space, not image space.
Why not just add inference-time noise or randomized passport placement? Gao et al. give strong prior evidence against this: iterative attacks broke classic stochastic defenses at 96–100% success, and restoring benign accuracy destroyed protection on ImageNette. We do not assume the result transfers to parameter-space attacks. The noise sweep, with and without explicit averaging, tests it directly. A regime where the owner keeps accuracy while forgery fails would be a positive and surprising finding.
Why not just trust the $4\times10^{-51}$ collision bound? That number bounds the chance that a random passport matches a fixed model's signature. It says nothing about an attacker who changes the model to match a passport of their choosing. The frozen-weights threat model is where the bound applies, and the benchmark reports that threat model separately so the bound gets credit where it is valid.
Decisive Checks
Experiments use CIFAR-10 and CIFAR-100 with ResNet-18 and AlexNet, following the setups of the passport papers, plus Caltech-101 transfer to test whether forged passports survive fine-tuning on a new domain.
The first decisive test is whether the forward attack meets the joint criterion on TdN or CHIP at 10% or less of the training data. If it does, the irreversibility claim fails for the modification threat model. If it fails even at 20% data and with gradient-free forward search, hash binding is validated under an adaptive evaluation it never had.
The second is whether Slope along the passport direction is at or below zero while Slope along the accessory-parameter direction is positive. That pattern would confirm the masking-on-the-wrong-path diagnosis.
The third is whether the noise sweep produces a monotone trade-off between owner accuracy and forgery success, and whether explicit averaging adds little over plain training. That pattern would confirm that the catch-22 extends to ownership defenses.
Each check comes with a pre-stated outcome that would falsify our hypothesis.
References
- Rethinking Deep Neural Network Ownership Verification: Embedding Passports to Defeat Ambiguity Attacks
- Passport-aware Normalization for Deep Model Protection
- Trapdoor Normalization with Irreversible Ownership Verification
- CHIP: Chameleon Hash-based Irreversible Passport for Robust Deep Model Ownership Verification and Active Usage Control
- Effective Ambiguity Attack Against Passport-based DNN Intellectual Property Protection Schemes through Fully Connected Layer Substitution
- On Evaluating Adversarial Robustness
- Slope: A First-order Approach for Measuring Gradient Obfuscation
- RobustBench: a standardized adversarial robustness benchmark
- On the Limitations of Stochastic Pre-processing Defenses
- Decoder Gradient Shield: Provable and High-Fidelity Prevention of Gradient-Based Box-Free Watermark Removal