betaFeedback

WorksComputer Science

Reject and Report: Forgery-Evident Undetectable Watermarks for Generative Image Models

Abstract

Provenance schemes such as those based on content watermarks let images from a generative model be traced back to it. A practical watermarking scheme must be accurate at a low false-positive rate (FPR), robust under content-preserving processing, and undetectable. In addition, it must resist forgery; otherwise, even from a single watermarked image and a surrogate model, an adversary can imprint the watermark onto an arbitrary image or regenerate new content that carries it, falsely attributing harmful content to a model or making authentic photographs appear AI-generated. We argue that a watermarking scheme should not only reject forgeries but also report them: a forgery rejected as unwatermarked leaves no trace of the attempt. State-of-the-art forgery-resilient undetectable watermarking schemes, such as SemBind, fall short on both counts. External anomaly detectors that do report forgeries either miss most of them or falsely flag genuine images after common processing. We propose Tripwire-WM, the first forgery-evident framework for undetectable watermarks. It commits the semantics of the generated image to the magnitudes of the initial latent noise, which the sign-based watermarks leave unused, through a distribution-preserving embedding; a forged image carries a valid watermark but with a commitment that does not match its content, so the detector both rejects it and reports it as forged. Built on the pseudorandom code (PRC) watermark and Gaussian Shading++, Tripwire-WM provably preserves their undetectability. On MS-COCO, with the owner's own model as the surrogate, it accepts no imprinting forgery, compared with up to 55.0% for SemBind, and reports all of them as forged; it also accepts at most 1.8% of reprompting forgeries, against up to 46.2% for SemBind. Meanwhile, it accepts at least 99% of genuine watermarked images at 10^{-6} FPR and matches the robustness of the base schemes.

Content warning: This paper contains model-generated images that some readers may find disturbing or unacceptable.

Introduction

Generative image models [10, 11, 19, 49, 52] now produce photorealistic images. Reliable provenance, the ability to verify whether an image was produced by a given model, has therefore become a pressing technical and regulatory need. For example, Article 50 of the EU AI Act [20] requires providers of generative AI systems to mark their outputs in a machine-readable format, so that they are detectable as artificially generated or manipulated. Watermarking has become the dominant provenance technique: the model inserts a signal in every generated image, which can later be detected by a verifier. A desired watermarking scheme must be accurate at a low false-positive rate, robust under content-preserving processing and potential removal attacks, and undetectable, i.e., unauthorized parties must not be able to distinguish watermarked images from unwatermarked ones. A provenance scheme, however, is only as trustworthy as its resistance to forgery. An adversary who can place a valid watermark on content of its choice can falsely attribute low-quality, harmful, or policy-violating content as having been generated by a model, or discredit an authentic photograph by making it appear AI-generated, amplifying the so-called liar’s dividend [13]. The possibility of forgeries undermines the credibility of the watermarking scheme itself because genuine images can no longer definitively prove provenance. Therefore, we argue that a watermarking scheme should not only reject forged images but also report them. This mirrors a long-standing principle in computer security: blocking an attack is insufficient if the attempt goes unrecorded, as monitoring and logging are essential for detecting and responding to threats [4]. Because the model owner bears the harm of a forgery and is the only party that can act on it, detecting forgery attempts is, for the owner, as important as rejecting them, even when a provenance service, not the owner, runs the detector.

Image watermarks fall into two families. Post-hoc watermarks [58, 74] perturb the pixels of an image after it is generated, trading image distortion against watermark strength, and a perturbation small enough to be invisible is easily washed out by regenerating the image with a diffusion model [53, 71]. In-generation watermarks [23, 62, 67, 68] instead write the watermark into the generation trajectory, typically the initial noise, or initial latent, of the diffusion process, and read it back by inverting the image; this lets them avoid perturbing the image at all. Schemes that reuse a fixed pattern across images, such as Tree-Ring [62] and Gaussian Shading [67], however, leak it to an adversary who averages many watermarked images [66]. Undetectable watermarks [23, 68] remove this weakness. They embed the watermark into the signs of the initial latent, fresh and pseudorandom for every image, so there is no shared pattern to average out: no unauthorized observer can efficiently tell watermarked images from unwatermarked ones, even given many of them. Their outputs are thus indistinguishable from those of the unwatermarked model, which also guarantees image quality in theory. Yet the very design of in-generation watermarks, a watermark that lives in the latent and is recovered by inversion, also hands that latent to anyone who can invert an image.

Indeed, undetectability does not prevent forgery. Using only a single watermarked source image and a surrogate model, an adversary can invert it and either imprint its watermark onto an arbitrary image or regenerate new content that carries it [43]. As shown in SemBind [70], imprinting succeeds against the pseudorandom code (PRC) watermark [23] and Gaussian Shading++ (GS++) [68], and so does reprompting (§ 4.2), because an inverted latent carries a valid watermark regardless of how its distribution looks. No existing defense both reliably rejects such forgeries and reports them. The closest one, SemBind [70], binds the latent signs to the semantics of the image while preserving undetectability, so that a latent transplanted to new content no longer verifies. It still accepts up to 46% of reprompting forgeries on MS-COCO (§ 4.2), and those it rejects lose their watermark altogether: a rejected forgery is indistinguishable from the many unwatermarked natural images that the detector sees every day. The model owner therefore remains unaware that its watermark is under attack: it cannot tell how often it is attacked, or which of its images are being used as sources, and so cannot respond by investigating abuse, rotating keys, or alerting downstream platforms. Lee et al. [35] do flag forgeries, with anomaly detectors separate from the watermark that measure how far the inverted latent drifts from the watermarked one, globally by cosine similarity (G-Cos) or locally by a covariance distance (L-SPD). Even with that latent rebuilt from the key, neither detector both catches forgeries and spares genuine images (§ 4.2 and § 4.3): on MS-COCO, G-Cos flags only 19.7–24.0% of reprompting forgeries made with the owner’s model, yet raises an alert on 96.8–98.0% of blurred genuine images, while L-SPD raises at most 3.6% false alarms but flags at most 21.3% of reprompting forgeries. PGID-F [18], also external to the watermark, refines the inversion of an image on which the watermark is detected and flags it if the watermark then vanishes; it targets imprinting, and on MS-COCO it flags only 18.6–39.7% of reprompting forgeries made with the owner’s model while already raising an alert on 6.2% of clean watermarked images under PRC.

To close this gap, we propose Tripwire-WM, the first forgery-evident framework for undetectable watermarks, in which the evidence of a forgery is carried by the watermarked latent itself rather than inferred by an external anomaly test. Like a tamper-evident seal, it not only rejects a forged image but also leaves evidence that a forgery was attempted. Instead of a binary decision between watermarked and unwatermarked, our detector distinguishes genuinely watermarked images (Watermarked), which it accepts, from natural unwatermarked images (Unwatermarked) and from forgery attempts (Forged), both of which it rejects; only forgery attempts raise an alert (Figure 1). A fourth verdict (Unverified) covers genuine images processed so heavily that their content can no longer be verified: they are rejected without an alert.

Examples on MS-COCO showing unwatermarked, watermarked, distorted-blur, forged-reprompting, and forged-imprinting images

Figure 1. Examples on MS-COCO with PRC as the underlying scheme, one prompt per row: an unwatermarked image, Tripwire-WM’s watermarked image, the watermarked image blurred, a reprompting forgery of it under a prompt from the Inappropriate Image Prompts (I2P) benchmark [54], and an imprinting forgery of it onto a real public-domain photograph from the Defense Visual Information Distribution Service (DVIDS) [60]a,b,c (Appendix § 9), both made with an SD 2.1 surrogate, each with its verdict.

Our key idea is that the magnitudes of the initial latent are an empty channel: an undetectable watermark such as PRC or GS++, the underlying scheme, writes the watermark only into its signs, and its magnitudes are fresh half-normal noise that carries no information. We use this empty channel to carry a commitment to the semantics of the generated image (Figure 2), and leave the signs, and with them the detection, robustness and undetectability of the underlying scheme, untouched. Both forgery modes transplant the latent of a watermarked source image, magnitudes included, so a forged image carries a commitment to the source image’s semantics while showing the adversary’s content. At verification, the owner reads the commitment back from the latent and compares it with the semantics of the query image. A mismatch is not the absence of a watermark but positive evidence of forgery: the latent was produced by the owner’s model, yet the image does not show what the owner committed to. Because the signs also yield the index of the generation it came from, a flagged forgery further points the owner to the source image that was abused.

Figure 2. Left: the threat model: without the key, a forger holding one watermarked image and a surrogate model reprompts its latent into new content or imprints it onto a real photo, so that the result carries the watermark. Top right: generation: the signs carry the watermark as in PRC or GS++, and the semantic hash of a draft image is encoded and committed into the latent magnitudes, from which the released image is generated. Bottom right: detection, which ends in one of the four verdicts of § 2.

Realizing this idea raises three challenges. First, the commitment must describe the image, yet the image is generated from the latent that carries it; we break this circularity with a two-pass generation, committing to a draft image generated from the same signs. Second, writing into the magnitudes must leave the latent distribution exactly unchanged, or undetectability is lost; we embed each bit, masked by a one-time pad, by a measure-preserving quantile reflection of a pseudorandom magnitude. Third, inversion recovers the magnitudes only approximately; we protect the commitment with a low-rate error-correcting code (ECC) whose decoder returns either the exact commitment or a failure, so that a forgery verdict almost never rests on a misread commitment.

Our contributions are as follows.

  • We identify forgery evidence as a requirement for watermark-based provenance beyond forgery rejection, and formalize it as a four-way detector with its goals (§ 2.2).

  • We design Tripwire-WM, the first forgery-evident framework for undetectable watermarks, which commits image semantics to the latent magnitudes on top of the PRC watermark and GS++, leaving their signs untouched (Section 3).

  • We prove that Tripwire-WM preserves the undetectability of the underlying scheme, and bound the probability that a decoding error of the commitment raises a false alarm (§ 3).

  • We evaluate Tripwire-WM against reprompting and imprinting forgeries on two datasets and two diffusion models (§ 4): it rejects and flags most forgeries, where SemBind rejects them silently, while accepting nearly all genuine images and leaving image quality statistically unchanged.

Background

Preliminaries

Latent diffusion and inversion. A text-to-image latent diffusion model samples a dd-dimensional initial latent z←$N(0,Id)z \overset{\$}{\leftarrow} \mathcal{N}(0, I_d) and maps it under a prompt yy to an image x=fθ(z∣y)x = f_\theta(z \mid y) by iterative denoising followed by decoding. With a deterministic sampler such as DDIM [55], this map can be run backwards: given only xx, not yy, an empty-prompt inversion recovers z^=fθ−1(x)\hat{z} = f_\theta^{-1}(x). Inversion needs no secret: anyone can run it with a surrogate diffusion model, and the detector, which holds the watermark key, runs it in the same way before testing the latent. Inversion is approximate, and its error grows when xx is compressed, resized or otherwise distorted, or when the inverting model differs from the generating one.

Watermarking the initial latent. In-generation watermarks do not perturb xx after generation; instead, a key kk determines how zz is sampled, and detection inverts the query image and tests z^\hat{z} under kk. Writing z=σ⊙∣z∣z = \sigma\odot|z| with σ=sign⁡(z)\sigma= \operatorname{sign}(z), a standard Gaussian latent has uniform signs σ∈{−1,1}d\sigma\in\{-1,1\}^{d} and i.i.d. half-normal magnitudes ∣z∣|z|, and the two are independent. A scheme that draws ∣z∣|z| afresh and chooses σ\sigma under kk therefore inherits the distance of its signs from uniform: if σ\sigma is exactly uniform, a latent is exactly Gaussian; if σ\sigma is only pseudorandom, latents are computationally indistinguishable from Gaussian ones to anyone without kk. Across many images, this requires the signs of all of them to be jointly pseudorandom, not merely each one on its own. The PRC watermark [23] sets σ=PRC.Encode(m;kPRC)\sigma= \mathrm{PRC.Encode}(m; k_{\mathrm{PRC}}), the codeword of a message mm under a key kPRCk_{\mathrm{PRC}} of a pseudorandom error-correcting code [14]: without the key, polynomially many codewords are indistinguishable from uniform strings, while PRC.Decode corrects a constant fraction of the errors in sign⁡(z^)\operatorname{sign}(\hat{z}) and returns ⊥\perp on strings unrelated to the key. GS++ [68] combines a PRC codeword with the encrypted message of Gaussian Shading [67]. By default, both leave the magnitudes i.i.d. half-normal, independent of the signs.

Forgery by inversion. Because inversion needs no secret, a single watermarked image xwx_w, the source image, suffices to forge [43]. The forger inverts it with a surrogate model θ′\theta', z^w=fθ′−1(xw)\hat{z}_w = f_{\theta'}^{-1}(x_w), and transplants this latent in one of two ways. Reprompting regenerates from it under a target prompt of the forger’s choice, xf=fθ(z^w∣y′)x_f = f_\theta(\hat{z}_w \mid y'). Imprinting starts from a clean cover image xcx_c and perturbs it, through its variational autoencoder (VAE) latent, until fθ′−1(xf)≈z^wf_{\theta'}^{-1}(x_f) \approx\hat{z}_w, while xfx_f still looks like xcx_c. Either way, the latent that the detector recovers from xfx_f is close to that of xwx_w, signs and magnitudes alike, so a watermark that lives only in the initial latent transfers with it, although the content of xfx_f is unrelated to that of xwx_w. Undetectability. The term is inherited from prior work and is easily misread: a watermark that no one could detect would be useless. What it means is undetectable to anyone without the key; the key holder detects the watermark as usual. We adopt the multi-sample notion of undetectable watermarks [15, 23].

Definition 2.1 (Undetectability). Let λ\lambda be the security parameter and k←KeyGen⁡(1λ)k \leftarrow\operatorname{KeyGen}(1^{\lambda}) the watermark key. On each query yy, the oracle Wat⁡k(y)\operatorname{Wat}_k(y) returns a watermarked image generated under prompt yy, and the oracle Gen⁡(y)\operatorname{Gen}(y) returns fθ(z∣y)f_{\theta}(z|y) for a fresh z←N(0,Id)z \leftarrow\mathcal{N}(0,I_d). The scheme is undetectable if, for every probabilistic polynomial-time adversary A\mathcal{A} that knows θ\theta and issues polynomially many adaptively chosen prompts,

∣Pr⁡[AWat⁡k(⋅)(1λ)=1]−Pr⁡[AGen⁡(⋅)(1λ)=1]∣≤negl⁡(λ),\left|\Pr\left[\mathcal{A}^{\operatorname{Wat}_k(\cdot)}(1^{\lambda})=1\right]-\Pr\left[\mathcal{A}^{\operatorname{Gen}(\cdot)}(1^{\lambda})=1\right]\right|\leq\operatorname{negl}(\lambda),

where the probabilities are over kk, the oracles’ randomness and the coins of A\mathcal{A}.

Restricting A\mathcal{A} to a single query gives the weaker, single-image notion of distortion-freeness. The PRC watermark and GS++ satisfy Definition 2.1.

Threat Model

Parties. We consider three parties. (1) The model owner deploys a generative image model θ\theta together with an undetectable watermarking scheme, and holds the watermark key kk and the semantic hashing network HH (§ 2.5), with which generation commits to the semantics of each image. Every generated image carries the watermark. (2) The verifier holds kk, HH and the owner’s model θ\theta, with which it inverts the images it checks, and determines whether a given image originates from the model. It may be the owner itself or a provenance service that the owner entrusts with kk and HH; content platforms, fact-checkers or regulators consult it with the images they want checked. (3) The adversary (forger) aims to falsely attribute content to the model.

System setting. The owner serves the model as a closed service: users submit prompts and receive images, never the initial latents, the intermediate draft images, or the key. The weights θ\theta of the diffusion model need not be secret, unlike those of HH; our evaluation includes a forger that uses the owner’s own model as its surrogate (§ 4.1). Only the verifier can run the detector, since only it holds kk and HH. It sees the query image alone, without its prompt or any record of its generation. Released images may be processed before they reach a verifier, by compression, resizing or filtering, or by a regeneration attack that tries to wash out the watermark; such processing keeps the content of the image, so the result is not a forgery.

Adversary’s goal. The adversary aims to produce a forged image xfx_f that the detector accepts as watermarked, so that it is attributed to the model, with the harms of § 1. We consider both forgery modes of § 2.1: reprompting, which yields new content of the adversary’s choice, and imprinting, which keeps a given clean image visually intact. Failing that, it aims to evade the alert, so that its forgery is rejected silently.

Adversary’s knowledge. The adversary knows the complete construction of Section 3, including the recipe by which the hashing network is trained, and may know the weights θ\theta of the owner’s diffusion model. It does not know the secrets: the watermark key kk and the hashing network HH itself, i.e., its trained weights and the choice of frozen encoders it reads. It cannot query the verifier, so it has no access to HH, not even as an oracle. Unlike kk, this secret carries no computational guarantee; § 4.6 measures what it protects against, and § 5 why it can be kept.

Adversary’s capabilities. The adversary obtains watermarked images by querying the service with prompts of its choice; one suffices for the forgeries we consider [43]. It holds a surrogate diffusion model, the owner’s own or a different one, with which it inverts the image and regenerates or imprints. An adaptive forger may further modify the inverted latent (§ 3.3) or perturb its forgery (§ 4.6).

Defender’s goal. The verifier judges an image as one of four verdicts: WATERMARKED, UNWATERMARKED, UNVERIFIED or FORGED. Only WATERMARKED accepts the image as generated by the model. The other three reject it: UNWATERMARKED when the owner’s watermark is not detected, UNVERIFIED when it is present but its binding to the content cannot be checked, typically after heavy processing, and FORGED when the watermark is present but committed to other content; only FORGED reports the image to the owner; we say that the verifier flags the image and raises an alert. The model owner requires the following properties.

  1. Forgery rejection. Forged images are rarely accepted, i.e., rarely judged WATERMARKED.

  1. Forgery evidence. Forged images are flagged as such, i.e., judged FORGED, with high probability.

  1. Low false alarm rate. Natural unwatermarked images, and genuinely watermarked images after content-preserving processing (e.g., JPEG compression), are rarely judged FORGED; otherwise spurious reports would flood the owner or wrongly accuse benign users.

  1. Undetectability. Watermarked images remain undetectable (Definition 2.1), as those of the underlying scheme are [23, 68].

  1. Utility. Clean watermarked images are accepted with high probability, and the false-positive rate on unwatermarked images does not exceed that of the underlying scheme.

  1. Robustness. After content-preserving processing and even removal attacks, watermarked images are accepted as often as the underlying scheme detects its watermark.

Algorithm 1 Watermarked generation

Require: Key k=(kS,kPRNG)k=(k_S,k_{\mathrm{PRNG}}), kS←$Sign.KeyGen⁡(1λ)k_S \leftarrow\$ \operatorname{Sign.KeyGen}(1^\lambda), kPRNG←$PRNG.KeyGen⁡(1λ)k_{\mathrm{PRNG}} \leftarrow\$ \operatorname{PRNG.KeyGen}(1^\lambda) Require: Prompt yy; index ii, never repeated under kk Ensure: Watermarked image xx

1: σ←$Sign.Encode⁡(i;kS)\sigma\leftarrow\$ \operatorname{Sign.Encode}(i;k_S) ▷ Index in the signs 2: π,∣zref∣←PRNG.Generate⁡(i;kPRNG)\pi, |z_{\mathrm{ref}}| \leftarrow\operatorname{PRNG.Generate}(i;k_{\mathrm{PRNG}}) 3: zref←σ⊙∣zref∣z_{\mathrm{ref}} \leftarrow\sigma\odot|z_{\mathrm{ref}}| 4: h←H(fθ(zref∣y))h \leftarrow H\left(f_\theta(z_{\mathrm{ref}}|y)\right) ▷ Commitment 5: b←ECC.Encode⁡(h)⊕πb \leftarrow\operatorname{ECC.Encode}(h)\oplus\pi ▷ Encode and pad 6: ∣z∣←EmbSem⁡(∣zref∣,b)|z| \leftarrow\operatorname{EmbSem}(|z_{\mathrm{ref}}|,b) ▷ Embed 7: return x←fθ(σ⊙∣z∣∣y)x \leftarrow f_\theta(\sigma\odot|z||y)

Overview

We write the semantic commitment of the generated image into the magnitudes ∣z∣|z| of the initial latent z∈Rdz\in\mathbb{R}^{d}, the unused channel of the underlying sign layer scheme (e.g., PRC or GS++), with d=16,384d=16{,}384 for Stable Diffusion 2.1 (SD 2.1). The composition between the semantic commitment and the sign layer scheme is modular: the sign layer stays exactly as in the underlying scheme, and the semantic commitment is layered on top of it. A failed semantic check can turn a detected watermark into Forged or Unverified, instead of Unwatermarked. The rest of this section addresses the three challenges of § 1: circularity (§ 2.5), distribution preservation (§ 2.6) and reliability (§ 2.6 and § 2.7). Figure 2 illustrates generation and detection, and Algorithms 1 and 2 state them precisely.

Algorithm 2 Watermark detection

Require: Query image xx; key k=(kS,kPRNG)k=(k_S,k_{\mathrm{PRNG}}) Require: Thresholds τ\tau on SS (Equation (3)) and zz on TT (Equation (4)) Ensure: One of the four verdicts of § 2.2

1: h^∗←H(x)\hat{h}^{*}\leftarrow H(x) 2: z^←fθ−1(x)\hat{z}\leftarrow f_\theta^{-1}(x) ▷ Reverse diffusion process 3: i^,σ^←Sign.Decode⁡(z^;kS)\hat{i},\hat{\sigma}\leftarrow\operatorname{Sign.Decode}(\hat{z};k_S) ▷ Or ⊥\perp 4: if i^=⊥\hat{i}=\perp then 5: &nbsp;&nbsp;&nbsp;&nbsp;return Unwatermarked 6: π^,∣z^ref∣←PRNG.Generate⁡(i^;kPRNG)\hat{\pi},|\hat{z}_{\mathrm{ref}}|\leftarrow\operatorname{PRNG.Generate}(\hat{i};k_{\mathrm{PRNG}}) 7: u←σ^⊙z^u\leftarrow\hat{\sigma}\odot\hat{z} ▷ Signed magnitudes 8: h^←ECC.Decode⁡(ExtSem⁡(u,∣z^ref∣)⊕π^)\hat{h}\leftarrow\operatorname{ECC.Decode}\left(\operatorname{ExtSem}(u,|\hat{z}_{\mathrm{ref}}|)\oplus\hat{\pi}\right) 9: if h^=⊥\hat{h}=\perp then ▷ Magnitudes unreadable 10: &nbsp;&nbsp;&nbsp;&nbsp;if T(u,∣z^ref∣)<zT(u,|\hat{z}_{\mathrm{ref}}|)<z then ▷ Equation (4) 11: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return Forged 12: &nbsp;&nbsp;&nbsp;&nbsp;return Unverified 13: if S(h^,h^∗)≥τS(\hat{h},\hat{h}^{*})\ge\tau then ▷ Equation (3) 14: &nbsp;&nbsp;&nbsp;&nbsp;return Watermarked 15: else 16: &nbsp;&nbsp;&nbsp;&nbsp;return Forged

Sign Layer

We apply the underlying sign layer schemes (e.g., PRC or GS++) unmodified, modelled as the following three algorithms: Sign.KeyGen⁡(1λ)\operatorname{Sign.KeyGen}(1^\lambda) draws its key kSk_S; Sign.Encode⁡(i;kS)\operatorname{Sign.Encode}(i;k_S) is a randomized encoding of an index ii into a sign pattern σ∈{−1,1}d\sigma\in\{-1,1\}^d; and Sign.Decode (z^;kS)(\hat{z}; k_S) returns the decoded index i^\hat{i} together with the verifier’s estimate σ^\hat{\sigma} of the sign pattern, or ⊥\perp when the scheme’s own detection fails. The index seeds the magnitude layer (§ 2.6), and σ^\hat{\sigma} unfolds the inverted latent into signed magnitudes (Line 7 of Algorithm 2). We require two properties of the scheme:

  1. Pseudorandom signs. To anyone without kSk_S, the encodings of any polynomial number of distinct indices are computationally indistinguishable from independent, uniformly random sign patterns.

  1. Free magnitudes. The scheme draws the magnitudes i.i.d. half-normal and independent of the signs, so that its latent is a pseudorandom sign pattern times half-normal magnitudes.

The index ii is a 32-bit counter that never repeats under one key and is unrelated to the content of the image, so no information about the image leaks through the sign layer. We instantiate the interface on two schemes.

PRC. For the PRC watermark of Gunn et al. [23], Sign.KeyGen and Sign.Encode are PRC.KeyGen and PRC.Encode, with the index as the PRC message, and pseudorandom signs are the pseudorandomness of the PRC [14]. Sign.Decode runs PRC.Decode, which returns a message only if the secret parity checks of the key are satisfied; a decoded index is therefore itself evidence of the watermark, with a false-positive rate of at most 10−610^{-6} (§ 4.1). Because PRC.Encode is randomized, the verifier cannot recompute σ\sigma from i^\hat{i}; σ^\hat{\sigma} is instead the codeword estimate of the decoder’s belief propagation, which corrects most of the sign errors of sign⁡(z^)\operatorname{sign}(\hat{z}).

GS++. For GS++ [68], Sign.Encode writes the index, in place of its random seed, as the PRC codeword of the first half of the latent, which keys the encryption of the owner’s watermark in the second half. At its default of one bit per coordinate the magnitudes are free, and pseudorandom signs are its own undetectability argument, since a never-repeating counter serves as well as a random seed. Appendix § 9 gives its key, its decoding and how σ^\hat{\sigma} is rebuilt.

Semantic Commitment

Semantic hash. The commitment is a binary hash h=H(x)∈{0,1}h\mathbf{h}=H(\mathbf{x}) \in\{0,1\}^{h} of the image, with h=128h=128, computed by a semantic hashing network HH. It must be computed from the image rather than from the prompt, because the verifier only sees the image. HH is trained so that images generated from the same prompt obtain nearby hashes, also after content-preserving distortions, while images of different prompts obtain distant ones. It follows the two-stage contrastive recipe of SemBind’s semantic masker [70] on frozen image embeddings; Appendix § 11.1 describes its data, architecture and training. Because the magnitude layer carries only a low-rate code (§ 2.6), hh is eight times smaller than the 1024 bits of SemBind’s masker, and each bit must separate prompts; we therefore train HH on the concatenated embeddings of three complementary frozen encoders, DINOv2 [47], OpenCLIP ViT-H/14 [12] and SigLIP [69], rather than DINOv2 alone.

Two-pass generation. The commitment must describe the released image, the one returned to the user, yet it is written into the latent from which that image is generated. We resolve this circularity with two generation passes (Lines 3–7 of Algorithm 1). A draft image is first generated from zref(i)=σ(i)⊙∣zref(i)∣z_{\mathrm{ref}}^{(i)}=\sigma^{(i)} \odot\lvert z_{\mathrm{ref}}^{(i)}\rvert (the superscript marks generation ii), which has the same signs as the final latent and, as explained below, the same magnitude on about half of the coordinates. Its hash h(i)h^{(i)} becomes the commitment, and the released image is generated from the latent that carries it. The draft and the released images are two different samples from the same prompt, exactly the variation HH is trained to be invariant to. The price is one additional diffusion pass per image, which about doubles the release time (Appendix § 9).

Magnitude Layer

Reference magnitudes and padding. From the index ii and the key kPRNGk_{\mathrm{PRNG}}, a pseudorandom generator (PRNG) expands two streams (Line 2 of Algorithm 1): the reference magnitudes ∣zref(i)∣|z_{\mathrm{ref}}^{(i)}|, i.i.d. half-normal, and a one-time pad π(i)∈{0,1}d\pi^{(i)} \in\{0,1\}^{d}. The expansion is keyed (Appendix § 9): were it seeded by the index alone, an adversary holding an inverted latent could enumerate the 2322^{32} indices and test which one explains the observed magnitudes. Since everything the magnitude layer needs is regenerated from the decoded index and kk, detection needs no per-image state.

Embedding by quantile reflection. Let FF be the cumulative distribution function (CDF) of the half-normal distribution. We define the quantile reflection

Flip⁡(a)=F−1(1−F(a)),(1)\operatorname{Flip}(a)=F^{-1}\left(1-F(a)\right), \tag*{(1)}

which exchanges small and large magnitudes and fixes the median. EmbSem writes the padded codeword b(i)=ECC.Encode⁡(h(i))⊕π(i)∈{0,1}d\mathbf{b}^{(i)}=\operatorname{ECC.Encode}(\mathbf{h}^{(i)})\oplus\boldsymbol{\pi}^{(i)}\in\{0,1\}^{d} (Line 5 of Algorithm 1; the error-correcting code is described below), one bit into each coordinate jj, by choosing between the reference magnitude and its reflection:

∣zj(i)∣={∣zref,j(i)∣,bj(i)=0,Flip⁡(∣zref,j(i)∣),bj(i)=1.(2)\left|z_{j}^{(i)}\right|= \begin{cases} \left|z_{\mathrm{ref},j}^{(i)}\right|, & b_{j}^{(i)}=0,\\ \operatorname{Flip}\left(\left|z_{\mathrm{ref},j}^{(i)}\right|\right), & b_{j}^{(i)}=1. \end{cases} \tag*{(2)}

Flip is a measure-preserving involution: if aa is half-normal, F(a)F(a) is uniform on [0,1][0,1], so is 1−F(a)1-F(a), and Flip⁡(a)\operatorname{Flip}(a) is again half-normal. Hence, as long as b(i)\mathbf{b}^{(i)} is independent of ∣zref(i)∣\left|z_{\mathrm{ref}}^{(i)}\right|, the magnitudes ∣z(i)∣\left|z^{(i)}\right| are exactly i.i.d. half-normal, whatever is committed, and the latent σ(i)⊙z(i)\boldsymbol{\sigma}^{(i)}\odot\mathbf{z}^{(i)} is distributed exactly as the latent of the underlying scheme.

The role of the pad. The independence condition is not automatic: the commitment is the hash of the draft image, generated from ∣zref(i)∣\left|z_{\mathrm{ref}}^{(i)}\right|, so without the pad the embedded bits would be correlated with the magnitudes they select. XOR with π(i)\boldsymbol{\pi}^{(i)}, independent of ∣zref(i)∣\left|z_{\mathrm{ref}}^{(i)}\right|, makes b(i)\mathbf{b}^{(i)} uniform and independent of it (§ 3.1), and also hides the structure of the error-correcting code.

Error correction. The magnitudes are a far noisier channel than the signs: inversion shrinks them and adds substantial noise, and the reflection is nearly invisible on coordinates whose reference magnitude lies close to the median. We therefore protect the hh-bit commitment with a rate-≈0.01\approx0.01 error-correcting code that spans all dd coordinates, a polar code with a 24-bit cyclic redundancy check (CRC) [46]; its list decoder [57] keeps LL candidate paths and returns the most likely one whose CRC passes. Its decoder has the property the verdict depends on: it either returns the committed hash exactly or reports failure (⊥\perp), and it returns a wrong hash with probability below 5×10−75\times10^{-7}. All the uncertainty of the subsequent comparison therefore sits on the query side, which is why the threshold can be calibrated without inversion (§ 2.7). The construction of the code, the soft demapping ExtSem and the decoder are given in Appendix § 10.

Verification and Verdict

Score. Some bits of HH are more stable than others. We weight each bit by its disagreement rate pjp_j, the probability that bit jj differs between the hash of a draft image and that of the image released from it, estimated on prompts held out from the training of HH, and score the agreement between the decoded commitment h^\hat{\mathbf{h}} and the hash h^∗=H(x)\hat{\mathbf{h}}^*=H(x) of the query image by the log-likelihood ratio between “same prompt” and “unrelated”:

S(h^,h^∗)=∑j=1h[1(h^j=h^j∗)log⁡(2(1−pj))+1(h^j≠h^j∗)log⁡(2pj)].(3)S\left(\hat{\mathbf{h}},\hat{\mathbf{h}}^*\right)=\sum_{j=1}^{h}\left[\mathbb{1}\left(\hat{h}_j=\hat{h}_j^*\right)\log\left(2(1-p_j)\right)+\mathbb{1}\left(\hat{h}_j\ne\hat{h}_j^*\right)\log\left(2p_j\right)\right]. \tag*{(3)}

Threshold. The threshold τ\tau is the empirical 0.5%0.5\% quantile of SS on clean genuine pairs, each a draft image and the image released from it, from prompts held out from the training of HH. and from evaluation (Appendix § 9); on that calibration distribution, 99.5% of clean genuine images whose commitment decodes are thus accepted, the target true-positive rate (TPR). We calibrate on the genuine side because it is the only distribution the owner can sample faithfully. A forgery distribution would not represent an adaptive adversary, and the null hypothesis of uniformly random hashes underestimates how often different-prompt pairs agree, because the semantics of natural images cluster. On the calibration prompts, 1.4% of unrelated pairs, one prompt’s commitment against another prompt’s image, pass τ\tau; the score therefore only weights the bits and assumes nothing about unrelated pairs. τ\tau is fixed once and used unchanged for every distortion and attack, whose acceptance and alert rates are measured directly.

Reference-field check. A failed commitment has two causes: processing so heavy that the magnitudes can no longer be read, or a forger who kept the owner’s signs, which carry the watermark, and replaced the magnitudes, so that its forgery would be rejected silently instead of flagged. The verifier tells them apart without the commitment. Which of ∣z^ref,j∣\lvert\hat{z}_{\mathrm{ref},j}\rvert and Flip⁡(∣z^ref,j∣)\operatorname{Flip}(\lvert\hat{z}_{\mathrm{ref},j}\rvert) was written depends on the committed bit, but their mean aˉj=(∣z^ref,j∣+Flip⁡(∣z^ref,j∣))/2\bar{a}_j = (\lvert\hat{z}_{\mathrm{ref},j}\rvert+ \operatorname{Flip}(\lvert\hat{z}_{\mathrm{ref},j}\rvert))/2 does not. We call aˉ\bar{a} the reference field; like the reference magnitudes, it depends only on i^\hat{i} and kPRNGk_{\mathrm{PRNG}}, not on the query image or on the source image a forger inverted. With the signed magnitudes u=σ^⊙z^\mathbf{u} = \hat{\boldsymbol{\sigma}} \odot\hat{\mathbf{z}}, the verifier computes

T=d corr⁡(u,aˉ),(4)T = \sqrt{d}\,\operatorname{corr}(\mathbf{u}, \bar{\mathbf{a}}), \tag*{(4)}

the Pearson correlation over the dd coordinates as a zz score. TT is positive on an image whose magnitudes the owner wrote and not on one whose magnitudes were replaced (§ 3.3). If the commitment fails and T<zT < z, the image is Forged; we use z=2z = 2, well below the smallest TT we measured on a genuine image whose commitment fails (Appendix § 11). The check runs only when the commitment fails, so Watermarked, Forged after a decoded commitment, and the calibration of τ\tau are unchanged.

Verdict. Algorithm 2 reports the first check that fails, with the verdicts of § 2.2. A heavily processed genuine image is thus Unverified: recognized as the owner’s (§ 2.3), but neither accepted, since its content cannot be vouched for, nor flagged, since nothing indicates a forgery. A forgery is flagged only when the owner’s index decodes, which keeps natural unwatermarked images from being flagged except at the false-positive rate of the sign layer.

Analysis

Undetectability

We prove that Tripwire-WM is undetectable against adaptively chosen prompts, as required by Definition 2.1. Fix a stateful probabilistic polynomial-time adversary A\mathcal{A} and a polynomial query bound nn.

In the real game H0\mathcal{H}_0, the model owner draws the key k=(kS,kPRNG)k = (k_S, k_{\mathrm{PRNG}}) as in Algorithm 1, and the adversary initializes its state as state←Ainit(1λ)\mathrm{state} \leftarrow\mathcal{A}_{\mathrm{init}}(1^\lambda). For each round 0≤i≤n−10 \le i \le n - 1, A\mathcal{A} adaptively chooses a prompt and updates its state as (y(i),state)←Aprompt(state)(y^{(i)}, \mathrm{state}) \leftarrow\mathcal{A}_{\mathrm{prompt}}(\mathrm{state}). The model owner generates x(i)x^{(i)} according to Algorithm 1, and the adversary updates its state as state←Aobserve(state,x(i))\mathrm{state} \leftarrow\mathcal{A}_{\mathrm{observe}}(\mathrm{state}, x^{(i)}). After seeing all nn images, it outputs a bit b←Aoutput(state)b \leftarrow\mathcal{A}_{\mathrm{output}}(\mathrm{state}). Note that it suffices to consider adversaries making exactly nn queries: a wrapper can save an early-halting adversary’s output bit, issue a fixed dummy prompt for each remaining query, ignore the responses, and return the saved bit.

We prove undetectability by a sequence of games. As shown in Figure 3, the real game and the successive hybrids are constructed as follows:

Image generation in the hybrid games

Figure 3. Image generation in the hybrid games, for the adversary’s current prompt yy and index ii; shading marks the change from the previous game, and H1\mathcal{H}_1 draws kPRNGk_{\mathrm{PRNG}} once at the start.

(i) H0\mathcal{H}_0 is the real adaptive game above, which answers each query by Algorithm 1.

(ii) H1\mathcal{H}_1 replaces each encoded sign pattern σ(i)\boldsymbol{\sigma}^{(i)} (Line 1 of Algorithm 1) with an independent, uniformly random sign vector. (iii) H2\mathcal{H}_2 additionally replaces each keyed pad and reference magnitude (Line 2) with independent samples from their respective distributions: a uniform bit string in {0,1}d\{0,1\}^{d} and dd independent half-normal magnitudes.

(iv) H3\mathcal{H}_3 additionally replaces each padded commitment b(i)\mathbf{b}^{(i)} (Line 5) with an independent uniform vector in {0,1}d\{0,1\}^{d}.

Note that each change concerns only the distribution that the model owner uses to answer a query; the adversary’s adaptive interaction is unchanged.

Proposition 4.1. H3\mathcal{H}_3 implements AA’s interaction with the unwatermarked generation oracle, up to numerical errors due to floating-point arithmetic.

Theorem 4.2 (Undetectability of Watermark). Assume the sign layer is multi-query IND$-\$\text{-}CPA secure, i.e., its outputs are indistinguishable from random under chosen-plaintext queries, and the magnitude-layer PRNG is secure. For every stateful probabilistic polynomial-time adversary AA making at most n≤poly⁡(λ)n \leq\operatorname{poly}(\lambda) adaptive queries,

∣Pr⁡[H0=1]−Pr⁡[H3=1]∣≤negl⁡(λ),(5)\left|\Pr[\mathcal{H}_0 = 1] - \Pr[\mathcal{H}_3 = 1]\right| \leq\operatorname{negl}(\lambda), \tag*{(5)}

i.e., H0≈cH3\mathcal{H}_0 \approx_{\mathrm{c}} \mathcal{H}_3 in shorthand notation.

Proof of Theorem 4.2. We show H0≈cH1≈cH2≡H3\mathcal{H}_0 \approx_{\mathrm{c}} \mathcal{H}_1 \approx_{\mathrm{c}} \mathcal{H}_2 \equiv\mathcal{H}_3, where ≡\equiv denotes equality in distribution:

  • H0≈cH1\mathcal{H}_0 \approx_{\mathrm{c}} \mathcal{H}_1 follows from the multi-query IND$-\$\text{-}CPA security of PRC [14] or GS++ [68], depending on the chosen sign layer. Any non-negligible gap between the games would distinguish the sign-layer encodings from uniform: the remaining generation steps and AA’s adaptive interaction are polynomial-time computations using an independently sampled magnitude-layer key.

  • H1≈cH2\mathcal{H}_1 \approx_{\mathrm{c}} \mathcal{H}_2 follows by the definition of a secure PRNG, applied to its polynomial-length output across the distinct generation indices. A non-negligible gap would distinguish that output from independent random pads and reference magnitudes, since the rest of the interaction can be computed in polynomial time using independent randomness.

  • H2≡H3\mathcal{H}_2 \equiv\mathcal{H}_3 follows from the one-time pad: conditioned on the preceding interaction, the current prompt, signs and reference magnitudes, the codeword is fixed and π(i)\boldsymbol{\pi}^{(i)} is fresh and uniform. Hence b(i)=ECC.Encode⁡(h(i))⊕π(i)\mathbf{b}^{(i)} = \operatorname{ECC.Encode}(\mathbf{h}^{(i)}) \oplus\boldsymbol{\pi}^{(i)} is uniform and independent of those quantities.

The triangle inequality establishes H0≈cH3\mathcal{H}_0 \approx_{\mathrm{c}} \mathcal{H}_3. Since H0\mathcal{H}_0 is the watermarked experiment and H3\mathcal{H}_3 is the unwatermarked experiment by Proposition 4.1, this establishes Definition 2.1. □

Reliability of the Commitment

The commitment fails when the sign layer has decoded an index but ECC.Decode returns ⊥\perp; on a genuine image the reference-field check (§ 2.7) then passes, and the verdict is Unverified. This subsection bounds the false alarms this leaves on genuine images and explains why failed commitments are rare under content-preserving processing.

Three outcomes of the decoder. On a query whose index decodes, ECC.Decode ends in one of three ways: it returns the committed hash hh exactly, it returns ⊥\perp, or it returns some h′≠hh' \ne h. Only the third is dangerous, and the CRC [46] bounds it.

Proposition 4.3. Let xx be a query image whose index decodes to i^=i\hat{i}=i, and let h=h(i)h=h^{(i)} be the commitment of generation ii. Model the CRC of every wrong path in the final list of the list decoder [57], of size LL, as uniform on {0,1}24\{0,1\}^{24}. Then

  1. Pr⁡[ECC.Decode returns some h′≠h]≤L⋅2−24\Pr[\mathrm{ECC.Decode}\text{ returns some }h' \ne h] \le L\cdot2^{-24};

  2. if xx is a genuine image of generation ii, then

Pr⁡[Forged]≤Pr⁡[S(h,H(x))<τ]+L⋅2−24+Pr⁡[h^=⊥∧T<z].(6)\Pr[\mathrm{Forged}] \le\Pr[S(h,H(x))<\tau]+L\cdot2^{-24}+\Pr[\hat{h}=\perp\mathbin{\land}T<z]. \tag*{(6)}

Proof. (i) A returned h′≠hh' \ne h requires that some wrong path among the at most LL in the final list passes its CRC, which by the union bound has probability at most L⋅2−24L\cdot2^{-24}. (ii) By the branches of Algorithm 2, Forged requires either h^=⊥\hat{h}=\perp and T<zT<z, the third term, or S(h^,H(x))<τS(\hat{h},H(x))<\tau with h^≠⊥\hat{h}\ne\perp; in the latter case either h^=h\hat{h}=h, which gives the first term, or h^≠h\hat{h}\ne h, which by (i) gives the second.

The first term of Equation (6) is semantic: the released or distorted image drifts away from the draft image it was committed to, which τ\tau controls and § 4.3 measures. The second is coding, at 4.8×10−74.8 \times10^{-7} four orders of magnitude below the first at our operating point. The third, the reference-field check, did not fire on any genuine image we measured (Appendix § 11).

Why the commitment rarely fails. Appendix § 10 models inversion as an affine Gaussian channel on the signed magnitudes, uj=αaj+σ^jϵju_j=\alpha a_j+\hat{\sigma}_j\epsilon_j: aj∈{gj,gˉj}a_j\in\{g_j,\bar{g}_j\} is the magnitude written to coordinate jj, either its reference magnitude gj=∣z^ref,j∣g_j=|\hat{z}_{\mathrm{ref},j}| or the reflection gˉj=Flip⁡(gj)\bar{g}_j=\operatorname{Flip}(g_j), α\alpha is the shrinkage of inversion and ϵj∼N(0,ν2)\epsilon_j\sim\mathcal{N}(0,\nu^2) its noise. Under this model, the magnitude layer fails only when inversion is so noisy that the signs are nearly random, in which case no sign layer decodes an index either. In practice, the commitment fails on 0.10–0.49% of the genuine images whose index decodes under GS++ and on 1.98–2.96% under PRC, almost all distorted ones whose index barely decoded and whose decoded signs still carry many errors; such an image is Unverified, not Forged (Appendix § 10.§ 4). The acceptance of Tripwire-WM under content-preserving processing is therefore bounded mainly by the decoding of the underlying scheme rather than by the commitment.

Forgeries That Replace the Magnitudes

A forger who knows the construction can keep the signs of the inverted latent and replace its magnitudes before regenerating, so that the index decodes but the commitment does not; this is the forgery that the reference-field check of § 2.7 is built to flag.

Why the check separates the two. Under the channel model of § 3.2, with aj∈{gj,gˉj}a_j\in\{g_j,\bar{g}_j\} equally likely, Cov⁡(uj,aˉj)=αVar⁡(aˉj)>0\operatorname{Cov}(u_j,\bar{a}_j)=\alpha\operatorname{Var}(\bar{a}_j)>0: on a genuine image, TT of Equation (4) is positive and falls only with α/ν\alpha/\nu, and the sign layer fails before α/ν\alpha/\nu is small enough to bring it near zero. On a forgery whose magnitudes are independent of the reference field, TT is about N(0,1)\mathcal{N}(0,1), and in practice below it. The forger’s own inversion gets the signs of small-magnitude coordinates wrong and keeps them; the verifier’s sign layer corrects them, so uj<0u_j<0 exactly there, and a written magnitude is small where the reference magnitude sits after it tail, which is where aˉj\bar{a}_j is largest. On genuine images, the check contributes the third term of Equation (6).

The limit of the check. Flip is public, so a forger who reflects half of the magnitudes, after normalizing them by an estimate of α\alpha, randomizes the commitment but keeps aˉ\bar{a}. TT then stays near 0 rather than below it, and with a perfect inversion the forger could keep TT at its genuine level. Such a forgery is still rejected, but silently; § 4.6 measures how often this happens.

Experiments

Experimental Setup

Model and prompts. The owner generates using SD 2.1 with first-order DPM-Solver [41] for 50 steps and classifier-free guidance [26] 7.5. Prompts come from the MS-COCO 2017 validation captions [39], without the captions that also occur in its training split, and from the evaluation split of Stable-Diffusion-Prompts (SDP) [24]. Every forgery and robustness experiment is repeated over 5 random seeds; a seed draws its own prompts (200 per seed, 20 for imprinting, whose optimization is costly), its own watermark keys, every latent and every attack, and we report the mean and standard deviation over seeds.

Baselines. We compare against the PRC watermark [23] and GS++ [68], each alone, combined with SemBind [70], and combined with either of the two geometric detectors of Lee et al. [35] or with PGID-F [18], and instantiate Tripwire-WM on both sign layers. The PRC key is generated for a false-positive rate of 10−610^{-6}, which is also the detection threshold of GS++; both carry a 32-bit message, the index (§ 2.4), and GS++ otherwise runs at its default parameters. SemBind masks the signs as in its paper, at mask ratio 0.5 and with its released 1024-bit semantic masker. The two detectors of Lee et al. leave generation and the sign layer unchanged (§ 1); each compares the inverted latent with a reference watermarked latent, which neither sign layer keeps, so we let the verifier rebuild it from the key as in Tripwire-WM. As Lee et al. do, we use each of their two statistics, the global cosine G-Cos and the local covariance distance L-SPD, as a detector of its own, thresholded at the same TPR as Tripwire-WM, 99.5% (Appendix § 9). The sign layer and the detector together give a three-way verdict: an image whose index decodes is judged WATERMARKED if it passes the threshold and FORGED if it fails it, and any other image is UNWATERMARKED. PGID-F is another anomaly detector external to the watermark: it refines the latent of an image the sign layer detects, pushing it away from the image’s own inversion trajectory and denoising it back, and judges the image FORGED if the sign layer no longer detects the watermark after the refinement, and WATERMARKED otherwise. PGID-F has no threshold of its own; its strength is set by the number of skip inversions ss and the stopping timestep kk. For a fair comparison, we keep the recommended s=3s = 3 and use the smallest kk at which its guided refinement still acts, k=4k = 4, for the highest TPR it reaches on watermarked images. Although we focus on undetectable watermarks, Appendix § 12 also compares Tripwire-WM with the detectable SEAL [6] and PAI [40].

Tripwire-WM. The commitment has h=128h = 128 bits and is protected by the CRC-aided polar code of Appendix § 10, decoded with list size L=8L = 8. The threshold τ\tau is calibrated at a default target TPR of 99.5%, and the reference-field check uses z=2z = 2. The hashing network HH is trained as in Appendix § 11.1.

Verification. Every method inverts a query image the same way: decoder inversion [27] for 100 steps, followed by 50-step DDIM inversion [55] with the empty prompt and without guidance.

Forgeries. Both forgery attacks follow Müller et al. [43] and run on a surrogate model: SD 2.1, which is the owner’s model and thus the strongest surrogate, or SD 1.5. The forger inverts the source image by 50-step DDIM inversion without VAE decoder inversion. For re-prompting (§ 2.1), following SemBind, the target prompts are drawn from the Inappropriate Image Prompts (I2P) benchmark [54], one distinct target per prompt. For imprinting, the cover is a distinct MS-COCO validation image per prompt, and the forger optimizes its VAE latent by Adam [33] at learning rate 0.01 for 150 steps.

Rejecting and Reporting Forgeries

Metrics. We report the acceptance rate, the fraction of images judged WATERMARKED, and the alert rate, the fraction judged FORGED; UNWATERMARKED and UNVERIFIED reject without an alert. Only Tripwire-WM, G-Cos, L-SPD and PGID-F have a FORGED verdict. Every method accepts or flags an image only after its sign layer detects the watermark or decodes an index, each at a false-positive rate of at most 10−610^{-6}; on unwatermarked images, the acceptance and alert rates are therefore at most of that order by construction, and Table 1 omits them.

DatasetSignDefenseWatermarked Accept (↑)Watermarked Alert (↓)Reprompting Forgery SD 2.1 Accept (↓)Reprompting Forgery SD 2.1 Alert (↑)Reprompting Forgery SD 1.5 Accept (↓)Reprompting Forgery SD 1.5 Alert (↑)Imprinting Forgery SD 2.1 Accept (↓)Imprinting Forgery SD 2.1 Alert (↑)Imprinting Forgery SD 1.5 Accept (↓)Imprinting Forgery SD 1.5 Alert (↑)
COCOPRCNone100.0 ±0.00–95.6 ±0.96✗75.1 ±3.11✗99.0 ±2.24✗99.0 ±2.24✗
COCOPRCSemBind100.0 ±0.00–16.9 ±2.10✗2.6 ±1.02✗17.0 ±4.47✗1.0 ±2.24✗
COCOPRCG-Cos99.3 ±0.840.7 ±0.8472.9 ±1.1924.0 ±1.4613.3 ±0.7670.5 ±2.9497.0 ±2.743.0 ±2.7437.0 ±13.5163.0 ±13.51
COCOPRCL-SPD99.8 ±0.270.2 ±0.2783.2 ±2.5413.7 ±2.0282.3 ±3.911.5 ±0.79100.0 ±0.000.0 ±0.00100.0 ±0.000.0 ±0.00
COCOPRCPGID-F93.8 ±1.686.2 ±1.6855.0 ±3.4839.7 ±3.4252.2 ±4.3822.2 ±3.1781.0 ±7.4219.0 ±7.4278.0 ±8.3722.0 ±8.37
COCOPRCTripwire-WM (ours)99.6 ±0.420.4 ±0.421.4 ±1.3994.3 ±1.751.1 ±0.9675.1 ±2.820.0 ±0.00100.0 ±0.000.0 ±0.00100.0 ±0.00
COCOGS++None100.0 ±0.00–96.9 ±1.19✗86.6 ±2.27✗100.0 ±0.00✗100.0 ±0.00✗
COCOGS++SemBind99.9 ±0.22–46.2 ±3.95✗8.1 ±2.36✗55.0 ±12.75✗18.0 ±5.70✗
COCOGS++G-Cos99.7 ±0.270.3 ±0.2776.3 ±3.4719.7 ±2.6118.5 ±1.8765.5 ±2.3298.0 ±2.742.0 ±2.7446.0 ±13.4254.0 ±13.42
COCOGS++L-SPD99.9 ±0.220.1 ±0.2274.7 ±2.9121.3 ±2.5680.5 ±1.773.5 ±1.27100.0 ±0.000.0 ±0.00100.0 ±0.000.0 ±0.00
COCOGS++PGID-F98.4 ±0.221.6 ±0.2278.2 ±3.4918.6 ±2.4872.0 ±2.5713.0 ±1.8098.0 ±4.472.0 ±4.4798.0 ±4.472.0 ±4.47
COCOGS++Tripwire-WM (ours)99.0 ±0.501.0 ±0.501.8 ±0.7693.9 ±2.041.2 ±0.7680.8 ±2.680.0 ±0.00100.0 ±0.000.0 ±0.00100.0 ±0.00
SDPPRCNone99.7 ±0.27–92.2 ±1.35✗69.2 ±2.59✗100.0 ±0.00✗98.0 ±2.74✗
SDPPRCSemBind99.5 ±0.50–38.2 ±3.19✗8.2 ±1.20✗9.0 ±7.42✗0.0 ±0.00✗
SDPPRCG-Cos98.1 ±0.821.9 ±0.8261.6 ±2.1033.7 ±1.159.2 ±1.3068.3 ±1.4092.0 ±2.748.0 ±2.7428.0 ±6.7172.0 ±6.71
SDPPRCL-SPD99.4 ±0.420.6 ±0.4274.2 ±3.7221.1 ±3.1176.8 ±1.750.7 ±0.6798.0 ±2.742.0 ±2.74100.0 ±0.000.0 ±0.00
SDPPRCPGID-F92.8 ±1.156.9 ±1.3945.3 ±3.1745.7 ±3.3841.6 ±1.4726.1 ±0.9676.0 ±6.5223.0 ±6.7173.0 ±5.7026.0 ±6.52
SDPPRCTripwire-WM (ours)99.6 ±0.420.3 ±0.2713.4 ±1.9878.3 ±2.5110.0 ±2.2661.9 ±2.330.0 ±0.00100.0 ±0.000.0 ±0.0098.0 ±2.74
SDPGS++None100.0 ±0.00–94.7 ±1.25✗78.1 ±2.25✗100.0 ±0.00✗100.0 ±0.00✗
SDPGS++SemBind100.0 ±0.00–61.4 ±3.27✗19.9 ±4.22✗43.0 ±0.59✗9.0 ±6.52✗
SDPGS++G-Cos98.0 ±0.612.0 ±0.6165.8 ±2.8928.4 ±1.9811.9 ±2.2868.9 ±1.7997.0 ±2.743.0 ±2.7438.0 ±7.5861.0 ±8.94
SDPGS++L-SPD97.7 ±1.442.3 ±1.4465.6 ±4.6926.6 ±3.2977.8 ±2.143.0 ±1.7099.0 ±2.241.0 ±2.2499.0 ±2.240.0 ±0.00
SDPGS++PGID-F97.9 ±0.552.1 ±0.5570.4 ±1.5623.8 ±1.6866.5 ±3.3714.4 ±2.6391.0 ±6.528.0 ±6.7191.0 ±6.528.0 ±6.71
SDPGS++Tripwire-WM (ours)99.2 ±0.270.7 ±0.4511.3 ±1.8081.9 ±2.1911.7 ±1.0965.5 ±2.550.0 ±0.00100.0 ±0.000.0 ±0.00100.0 ±0.00

Table 1. Forgery rejection and evidence: acceptance and alert rates, in %, on watermarked images and on forgeries made by reprompting and by imprinting with an SD 2.1 or SD 1.5 surrogate. ↑/↓: higher/lower is better; red: a poor result, i.e., at least 5% alerts on watermarked images, and at least 20% acceptance or below 50% alerts on forgeries; ✗: no Forged verdict, on forgeries, where an alert is wanted; –: likewise, on watermarked images.

Rejection. The sign layers alone accept 92.2–96.9% of reprompting forgeries made with the owner’s model and 98–100% of imprinting forgeries (Table 1). SemBind accepts 16.9–61.4% of these reprompting forgeries and up to 55.0% of the imprinting ones. Tripwire-WM accepts at most 1.8% of reprompting forgeries on MS-COCO and 10.0–13.4% on SDP, whose prompts lie further from the captions HH is trained on (Appendix § 11.1), and no imprinting forgery with either surrogate, while accepting 99.0–99.6% of watermarked images. The reprompting forgeries it accepts concentrate where the target prompt is close to the prompt of the source image (Figure 4): on SDP, the acceptance rate rises from 4% in the least similar tenth of the prompt pairs to 24–27% in the most similar.

Figure 4. Reprompting forgeries accepted against the MiniLM cosine similarity [51] of the source and target prompts, with an SD 2.1 surrogate.

Evidence. Tripwire-WM flags 78.3–94.3% of reprompting forgeries made with the owner’s model and 98.0–100.0% of imprinting forgeries as FORGED, against 0.3–1.0% of watermarked images. With SD 1.5 as the surrogate it flags fewer reprompting forgeries, 61.9–80.8%, because fewer carry the watermark at all: the sign layers alone accept only 69.2–86.6% of them, and those that lose it are UNWATERMARKED. Figure 1 shows examples: blurred watermarked images are still accepted, while reprompting and imprinting forgeries, which carry the watermark but show new content or a real photograph’s, are flagged.

External detectors. G-Cos and L-SPD flag at most 33.7% of reprompting forgeries and accept 92.0–100.0% of imprinting ones made with the owner’s model, the case in which, as Lee et al. note, the surrogate leaves the least drift. With SD 1.5 as the surrogate, G-Cos flags 65.5–70.5% of reprompting forgeries, on SDP slightly more than Tripwire-WM, but its alerts do not single out forgeries: it also flags most blurred or median-filtered watermarked images (§ 4.3). PGID-F flags only 19.0–26.0% of imprinting forgeries and at most 45.7% of reprompting ones, while raising an alert on up to 6.9% of clean watermarked images.

A larger model. With SDXL as the owner’s model and the surrogate (Appendix § 9), the sign layers alone accept nearly every forgery and SemBind up to 25.6% of the reprompting ones, whereas Tripwire-WM accepts at most 2.4% of either kind and flags 80.0–98.0% of them, with at most 1.2% alerts on watermarked images (Figure 5).

Figure 5. Results with SDXL (MS-COCO): acceptance (solid) and alert (hatched) rates, in %, the mean over seeds.

Robustness and False Alarms

We apply five distortions to watermarked images, JPEG at quality 70, Gaussian blur of radius 3, Gaussian noise of standard deviation 0.01, a 7×77 \times7 median filter and downscaling by 0.5 and back, and the two regeneration attacks of WAVES [2]: Regen-Diff noises the image’s SD 1.4 latent to step 30 of 1000 and denoises it, and Regen-VAE passes it through the codec of Ballé et al. [9] at quality 5. An alert on such an image is a false alarm (Table 2).

DatasetSignDefenseJPEG (q=70q=70) Accept (↑)JPEG (q=70q=70) Alert (↓)Blur (r=3r=3) Accept (↑)Blur (r=3r=3) Alert (↓)Noise (σ=0.01\sigma=0.01) Accept (↑)Noise (σ=0.01\sigma=0.01) Alert (↓)Median (7×77\times7) Accept (↑)Median (7×77\times7) Alert (↓)Resize (0.5×0.5\times) Accept (↑)Resize (0.5×0.5\times) Alert (↓)Regen-Diff Accept (↑)Regen-Diff Alert (↓)Regen-VAE Accept (↑)Regen-VAE Alert (↓)
COCOPRCNone96.9 ±0.96–91.0 ±1.90–99.6 ±0.65–88.3 ±1.40–99.4 ±0.65–90.9 ±1.08–88.7 ±2.28–
COCOPRCSemBind94.1 ±1.29–79.3 ±2.64–99.0 ±1.17–78.2 ±2.28–98.0 ±0.50–82.9 ±1.88–85.0 ±2.85–
COCOPRCG-Cos68.3 ±1.9229.6 ±1.520.4 ±0.4296.8 ±0.8491.9 ±2.107.9 ±1.787.9 ±1.9287.9 ±2.4382.2 ±2.1417.7 ±2.2812.0 ±3.7784.9 ±4.2343.9 ±2.1649.8 ±2.71
COCOPRCL-SPD97.9 ±0.960.0 ±0.0097.0 ±0.710.2 ±0.4599.8 ±0.450.0 ±0.0094.4 ±1.191.4 ±0.9699.9 ±0.220.0 ±0.0096.9 ±0.740.0 ±0.0093.3 ±1.250.4 ±0.22
COCOPRCPGID-F83.6 ±3.1513.6 ±2.869.1 ±2.1682.9 ±1.9588.9 ±2.9011.1 ±2.9040.9 ±2.8248.0 ±3.1088.0 ±1.5811.4 ±1.7188.0 ±2.553.4 ±1.6475.3 ±3.4413.6 ±2.75
COCOPRCTripwire-WM (ours)96.1 ±1.640.6 ±0.2293.3 ±1.750.6 ±0.4299.1 ±0.420.7 ±0.2789.4 ±0.890.4 ±0.2298.8 ±0.840.6 ±0.4291.4 ±2.270.9 ±0.7488.8 ±2.710.6 ±0.89
COCOGS++None98.3 ±1.72–99.4 ±0.65–100.0 ±0.00–97.4 ±1.75–99.7 ±0.27–97.9 ±0.42–95.2 ±1.92–
COCOGS++SemBind96.6 ±0.74–95.6 ±1.14–99.7 ±0.27–93.0 ±0.94–99.7 ±0.27–94.2 ±1.75–92.9 ±3.17–
COCOGS++G-Cos70.6 ±2.9728.1 ±3.191.0 ±0.6198.0 ±0.5094.9 ±1.524.9 ±1.5612.6 ±2.1685.5 ±2.2486.5 ±1.3713.5 ±1.3718.8 ±1.1578.1 ±2.0149.2 ±3.9844.9 ±5.58
COCOGS++L-SPD98.7 ±0.910.0 ±0.0098.2 ±0.760.8 ±0.5799.8 ±0.270.0 ±0.0094.5 ±0.943.6 ±1.19100.0 ±0.000.0 ±0.0096.9 ±0.890.0 ±0.0091.5 ±2.212.6 ±0.82
COCOGS++PGID-F94.3 ±1.444.4 ±1.2942.3 ±1.6056.5 ±1.9097.4 ±0.652.4 ±0.5572.5 ±3.6225.2 ±2.8297.3 ±0.572.6 ±0.4296.9 ±1.240.8 ±1.0490.0 ±1.875.3 ±1.44
COCOGS++Tripwire-WM (ours)97.5 ±0.870.9 ±0.5597.4 ±0.420.8 ±0.2798.6 ±0.741.0 ±0.3596.0 ±0.710.9 ±0.4298.6 ±0.420.9 ±0.2296.0 ±0.611.0 ±0.8792.4 ±2.680.8 ±0.67
SDPPRCNone94.0 ±1.73–84.1 ±3.49–99.4 ±0.42–86.2 ±2.11–99.0 ±0.61–87.6 ±0.82–85.9 ±1.56–
SDPPRCSemBind87.1 ±1.85–60.2 ±4.01–97.9 ±1.19–70.8 ±0.45–96.4 ±0.74–74.3 ±1.68–72.4 ±2.25–
SDPPRCG-Cos50.7 ±1.2547.1 ±1.080.0 ±0.0095.6 ±0.6592.5 ±0.947.3 ±1.103.5 ±1.1291.8 ±1.0482.7 ±2.7716.5 ±2.356.1 ±0.9688.3 ±1.7927.3 ±2.??69.?? ±????
SDPPRCL-SPD97.6 ±0.530.2 ±0.4594.4 ±0.740.5 ±0.??99.0 ±0.??0.0 ±0.??91.6 ±1.??3.?? ±??99.1 ±0.??0.4 ±??94.4 ±1.??1.?? ±??90.8 ±??2.?? ±??
SDPPRCPGID-F79.3 ±??15.3 ±??42.4 ±??56.5 ±??97.?? ±??1.?? ±??71.?? ±??25.?? ±??90.?? ±??4.?? ±??94.?? ±??2.?? ±??90.?? ±??24.?? ±??
SDPPRCTripwire-WM (ours)94.0 ±??0.3 ±??88.2 ±??0.5 ±??98.8 ±??0.3 ±??89.1 ±??0.4 ±??98.4 ±??0.7 ±??91.3 ±??0.3 ±??85.5 ±??0.2 ±??
SDPGS++None90.8 ±1.27–88.0 ±1.??–98.8 ±0.??–90.2 ±0.??–99.0 ±0.??–89.?? ±??–94.3 ±1.25–
SDPGS++SemBind94.0 ±1.54–89.8 ±2.86–99.4 ±0.42–90.1 ±1.??–99.0 ±0.??–89.3 ±??–87.1 ±??–
SDPGS++G-Cos56.2 ±3.4441.3 ±3.800.0 ±0.??96.9 ±0.??94.3 ±??6.2 ±??65.1 ±??89.0 ±??84.8 ±??15.0 ±??94.9 ±??85.8 ±??31.4 ±??62.2 ±??
SDPGS++L-SPD97.0 ±??0.3 ±??93.0 ±??0.9 ±??99.6 ±??0.0 ±??88.5 ±??7.5 ±??98.2 ±??0.5 ±??91.5 ±??0.?? ±??86.4 ±??2.?? ±??
SDPGS++PGID-F92.3 ±??5.8 ±??31.4 ±??66.6 ±??97.1 ±??2.7 ±??67.7 ±??29.3 ±??96.4 ±??3.2 ±??94.9 ±??0.8 ±??86.9 ±??7.2 ±??
SDPGS++Tripwire-WM (ours)95.3 ±??0.8 ±??86.9 ±??0.7 ±??97.8 ±??0.8 ±??95.7 ±??0.6 ±??99.0 ±??0.6 ±??93.7 ±??0.7 ±??91.2 ±??0.6 ±??

Table 2. Robustness: acceptance and alert rates, in %, on watermarked images after each distortion or regeneration attack. ↑/↓: higher/lower is better; red: a poor result, i.e., below 80% acceptance or at least 5% alerts; –: no Forged verdict.

Tripwire-WM. Tripwire-WM raises an alert on at most 1.0% of distorted watermarked images and accepts at least 85.5% of them; the rest are rejected without an alert. Its acceptance is never more than 3.1 points below that of the sign layer alone. SemBind loses up to 23.9 points of acceptance to the distortions, on blurred images under PRC on SDP.

External detectors. L-SPD raises at most 7.5% false alarms. G-Cos and PGID-F raise many: G-Cos on 95.6–98.0% of blurred, 85.5–91.8% of median-filtered and 78.1–88.3% of Regen-Diff images, and PGID-F on 56.5–82.9% of blurred and 25.2–61.6% of median-filtered ones, so their alerts do not single out forgeries.

Image Quality and Cost

Image quality. As in Tree-Ring [62] and SemBind [70], we generate an image from a caption of each of the 4,998 MS-COCO val2017 photos, over ten seeds, and compute the Fréchet Inception Distance (FID) [25] against the photos and the CLIP score, with OpenCLIP ViT-g/14 [12], against the prompts; on 1,000 SDP prompts, which have no photos, we compute the CLIP score alone. Neither metric distinguishes Tripwire-WM from unwatermarked images (Table 3): each of its Welch ∣t∣|t| over seeds is below 1.0 (p>0.3p > 0.3).

SignDefenseCOCO FID (↓)COCO ∣t∣|t| (↓)COCO CLIP (↑)COCO ∣t∣|t| (↓)SDP CLIP (↑)SDP ∣t∣|t| (↓)
Non-watermarked25.69–0.3308–0.3635–
PRCNone25.660.470.33070.700.36350.04
PRCTripwire-WM (ours)25.700.100.33100.840.36380.37
GS++None25.601.110.33100.990.36330.39
GS++Tripwire-WM (ours)25.750.560.33100.980.36340.27

Table 3. Image quality: FID and CLIP score, the mean over random seeds, each with its ∣t∣|t| against unwatermarked images. ↑/↓: higher/lower is better.

Computational cost. Like SemBind, Tripwire-WM generates each image twice, so releasing one takes 6.0 s on an NVIDIA L40S, against 3.0 s without a watermark; HH takes 0.09 s of it (Appendix § 9). Verification is dominated by inversion (19 s for every method), and reading the commitment adds 1.2 s, 6% over SemBind.

Effect of the Target TPR

Figure 6 varies the target TPR from 98% to 100%: a higher target accepts more genuine images, distorted ones in particular, at the cost of accepting more forgeries. Imprinting forgeries are the least affected: up to a target of 99.5% none is accepted, and at 100% at most 6% are. The figure shows the PRC sign layer; GS++ follows the same trends.

Figure 6. Effect of the target TPR, with the PRC sign layer and an SD 2.1 surrogate. Distortion: the mean over the five distortions. Alerts on watermarked images, under 2%, are not drawn.

Adaptive Forgeries

A forger that knows the construction but not the secrets (§ 2.2) has two routes: to evade the alert, by having its forgery judged Unverified rather than Forged, or to evade rejection, by attacking the hashing network. We then step outside the threat model and ask what a leak of HH costs.

Evading the alert. A forger can replace the magnitudes of a reprompting forgery so that its commitment no longer decodes (§ 3.3 and appendix § 11). It resamples a fraction of them from the half-normal distribution, reflects a fraction of them by the public Flip, or scrubs them all, redrawing every magnitude and flipping a fraction of the signs. Without the reference-field check, this leaves up to 95.2% of the forgeries Unverified instead of Forged (Table 4). With it, at most 2.4% stay Unverified, except 13.6% when half of the magnitudes are reflected, the limit of the check, and the alert rate is 67.4–98.0%; the check changes no verdict on clean watermarked images. No such forgery is accepted more often than plain reprompting (1.8%), so evading the alert at best turns a flagged forgery into a silently rejected one.

RateRef.-field checkRepromptResample 0.9Resample 1Scrub 0.1Scrub 0.2Reflect 0.5Reflect 0.75
Acc. (↓\downarrow)both1.81.00.60.00.00.60.0
Unv. (↓\downarrow)w/o0.810.433.095.267.436.080.8
Unv. (↓\downarrow)w/0.80.20.00.00.013.62.4
Alert (↑\uparrow)w/o93.686.865.00.40.051.60.0
Alert (↑\uparrow)w/93.697.098.095.667.474.078.4

Table 4. Magnitude-replacing forgeries (MS-COCO, PRC): acceptance, Unverified and alert rates, in %, without and with the reference-field check.

Evading rejection. The second route attacks HH, which the forger can neither evaluate nor query. The transfer attack perturbs a reprompting forgery within an ℓ∞\ell_{\infty} ball of radius ε\varepsilon by projected gradient descent [42], so that its embedding under a public encoder approaches that of the source image xwx_w (Appendix § 11.2); not knowing HH’s encoders, the forger must guess one.

Guessing gains little (Table 5): any one of HH’s three encoders has at most 9.2% of the forgeries accepted, and CLIP ViT-L/14 [50], which HH does not read, at most 1.4%. A larger budget does not help, as the perturbation also breaks the index and the forgery is judged Unwatermarked. A forger that trains its own hashing network by our recipe, or attacks an ensemble of public encoders, must still guess which encoders HH reads; we leave these attacks to future work.

Attackε=2/255\varepsilon= 2/255 Acc.ε=2/255\varepsilon= 2/255 Alertε=4/255\varepsilon= 4/255 Acc.ε=4/255\varepsilon= 4/255 Alertε=8/255\varepsilon= 8/255 Acc.ε=8/255\varepsilon= 8/255 Alertε=12/255\varepsilon= 12/255 Acc.ε=12/255\varepsilon= 12/255 Alert
CLIP ViT-L/14 (Unused)1.478.61.258.20.633.40.619.6
DINOv27.275.07.058.45.637.85.223.4
OpenCLIP ViT-H/145.274.06.052.03.828.83.415.6
SigLIP6.674.49.253.47.032.84.820.2
All three together60.219.457.62.435.40.221.60.0
+ PC check0.079.60.060.00.035.60.021.6
White box (HH)82.60.664.20.640.80.425.20.4
+ PC check0.083.20.064.80.041.20.025.6

Table 5. Attacks on the hashing network (MS-COCO, PRC): acceptance and alert rates, in %. PC check: purification-consistency check.

Beyond the threat model: if HH leaks. A forger that attacks all three of HH’s encoders together, or holds HH itself (white box), has 60.2% or 82.6% of the forgeries accepted at ε=2/255\varepsilon= 2/255, so HH must stay secret, its encoders as well as its weights.

A heuristic mitigation. Such an attack is a small perturbation tuned to HH, which a light diffusion purification [45] may wash out. The purification-consistency (PC) check purifies the query xx into P(x)P(x) with SD 2.1 at strength 0.05 and judges it Forged if H(x)H(x) and H(P(x))H(P(x)) differ in more than τP\tau_P bits, a single threshold calibrated on clean watermarked images like τ\tau. With it, no perturbed forgery is accepted at any budget, while it fires on 0.4% of clean watermarked images and, on average over the seeds, on at most 2.0% of them under each distortion of Table 2 (Appendix § 11.2). The check lies outside Tripwire-WM’s guarantees: it stops the attacks above, so a forger with a leaked HH must adapt to it. Adaptive attacks have circumvented diffusion purification [30, 31, 36], and purifiers hardened against them [37, 63] could replace ours; we leave both to future work.

Discussion

Keeping the hashing network secret. The security of the semantic check rests on the forger not knowing HH, its weights and in particular which encoders it reads (§ 2.2 and § 4.6), and the choice of encoders can stay secret for three reasons. First, it is a choice among many: dozens of public image encoders (self-supervised, contrastive vision–language and supervised, at several sizes and resolutions) give embeddings that HH can be trained on, and HH may read any subset of them, so a forger that does not know the subset must attack a large union of candidates at once. Second, the encoders need not be public at all: the owner may fine-tune them privately, or train its own, and HH then reads embeddings that no public checkpoint reproduces. Third, the instance we evaluate, DINOv2, OpenCLIP ViT-H/14 and SigLIP (Appendix § 11.1), is one such choice, disclosed only to make the experiments reproducible; a deployment draws its own, as it draws its own kk. We also assume that the forger cannot query the verifier (§ 2.2), whose verdicts would otherwise serve as an oracle for HH; a verifier open to the public would have to limit queries.

Semantic granularity. The semantic check is only as fine as the hash HH. HH is trained to give images of the same prompt nearby hashes and images of different prompts distant ones (§ 2.5), so it separates content at the level at which prompts differ: it tells a dog from a cat, but not one dog from another. A forgery that keeps the content of the committed image at this level, for instance the same scene with a different individual, therefore passes the check. Refining the semantic granularity of the commitment, for example with hashes that also separate instances, is future work for Tripwire-WM.

Choice of sign layer. Tripwire-WM uses the sign layer only through the interface and the two properties of § 2.4, and its undetectability reduces to the pseudorandomness of the signs (§ 3.1), so its guarantees are only as strong as the sign layer it is built on. For the low-density parity-check (LDPC) based PRC that we instantiate, recent cryptanalysis identifies concrete weaknesses at practical parameters [61]. They weaken the undetectability of the sign layer, and with it that of Tripwire-WM, but leave the magnitude layer untouched: a stronger PRC, or any other scheme with pseudorandom signs and free magnitudes, can take its place without changes to Tripwire-WM.

Carrying a message. The index is a nonce: it seeds the magnitude layer and never repeats under one key. A message, such as a user identifier, may repeat, so it cannot replace the index, but it can follow the index in the sign layer’s payload or stay in the owner’s log. A transplanted watermark keeps the message, so it is attributed only on WATERMARKED.

Related Work

In-generation watermarks. Shared-pattern schemes such as Tree-Ring [62] also shift the distribution of the initial latent, which undetectable watermarks avoid. We build on the undetectable PRC watermark [23] and GS++ [68].

Forgery attacks. Early forgeries estimate a content-independent watermark signal from many watermarked images [17, 53, 66]; recent ones need a single image. The imprinting and reprompting attacks of Müller et al. [43], which we evaluate against, transplant the inverted latent of a watermarked source image through a surrogate model; Jain et al. [28] forge latent watermarks through a surrogate VAE, and Souček et al. [56] forge post-hoc watermarks.

Rejecting forgeries. Key randomization [5, 7] limits multi-sample attacks but cannot stop single-image forgery. Breaking the symmetry of inversion [34, 75] and binding the watermark to image semantics, as SEAL does with a proxy image that our two-pass generation resembles [6], lower forgery success but alter the latent or the image, so neither is undetectable. Signatures embedded in the watermark either perturb the image [73] or, in GS++, authenticate a message rather than the content, which an intact transplant preserves; signed metadata such as C2PA [16] is lost once the file is re-encoded. SemBind [70], whose training recipe our hashing network follows, masks the latent signs with a semantic code and preserves undetectability, but rejects forgeries silently (§ 4.2). Text watermarks face the same spoofing [29, 48] and are defended alike, by signatures embedded in the generated tokens [21] or a watermark keyed to the meaning of the text [3]. We commit the semantics beside the watermark rather than into it.

Reporting forgeries. Few defenses report forgeries as such. Aremu et al. [7] flag content on which several keys fire, which single-image forgery avoids. PAI [40] flags anomalous inversion bias but changes the sampling trajectory without an undetectability argument. The geometric detectors of Lee et al. [35] and PGID-F [18] are anomaly tests at the verifier that leave generation, and with it undetectability, unchanged; neither both catches forgeries and spares genuine images (§ 4.2 and § 4.3). For text, Gloaguen et al. [22] likewise test for the artifacts that learning-based spoofers leave. These score how anomalous a query looks, whereas Tripwire-WM checks it against what the owner committed to at generation. Bileve [72] comes closest to our verdicts: its text watermark carries a signature of the generated tokens, and text whose watermark is present but whose signature fails is reported as tampered. Its rank-based sampling, however, changes the output distribution, and in text the signed tokens are the content itself, whereas an image forgery transplants the latent and leaves the content behind.

To our knowledge, Tripwire-WM is the first undetectable watermarking framework whose watermark itself carries the evidence of forgery: built on PRC or GS++, it preserves their undetectability and reports single-image forgeries as forgeries. In this it returns to the tamper-evident watermarks of image authentication, which carry a signature or feature hash of the image [38, 64], but writes the commitment into a channel that leaves the distribution of the generated image unchanged instead of perturbing the image.

Conclusion

A watermark that rejects a forgery without reporting it leaves the model owner unaware that its watermark is under attack. Tripwire-WM makes undetectable watermarks forgery-evident: it commits the semantics of each generated image to the latent magnitudes, which the underlying scheme leaves unused, so that a forged image carries positive evidence of the forgery and points to the source image that was abused. The signs stay untouched, and undetectability is provably preserved. On MS-COCO, with the owner’s own model as the surrogate, it accepts at most 1.8% of reprompting forgeries and no imprinting forgery; it rejects most forgeries on SDP and flags most of them as forged, while accepting nearly all genuine watermarked images and raising almost no false alarms on distorted ones. Two limitations remain. The semantic check rests on a secret hashing network, which, unlike the key, carries no computational guarantee, and it separates content only as finely as prompts do. Hashes that also separate instances are left to future work.

Acknowledgments

This work is supported in part by the Wallenberg Visiting Professor Program and NSERC (grant number RGPIN-2026-04826). Xi He and Yaoliang Yu gratefully acknowledge NSERC and the Canada CIFAR AI Chairs program. Most of the computing resources were provided by the Vector Institute.

Implementation Details

GS++ as the sign layer. Its key kSk_S consists of a PRC key, a secret key skcsk_c and the owner’s watermark ss, which the second half of the latent carries replicated and encrypted with the stream key PRNG (Hash⁡(i∥skc)\operatorname{Hash}(i \mathbin\Vert sk_c)). Its PRC half has no parity checks and returns an index for any input, so Sign.Decode returns ⊥\perp when the second half, decrypted under the decoded index, matches ss on too few bits at the detection threshold of GS++. Otherwise σ^\hat{\sigma} is rebuilt from i^\hat{i}: the first half re-encoded and the second re-encrypted, exactly.

Geometric detection. For the detectors of Lee et al. [35], the verifier rebuilds the reference watermarked latent by drawing the magnitudes i.i.d. half-normal from a keyed generator under the decoded index, so the latent stays undetectable by the argument of § 3.1, and multiplying them by the decoded signs. As they report only AUCs, we set each threshold on genuine images of the prompts on which τ\tau is calibrated, generated under a key and seed of their own.

Generation index. Within a seed of the experiments, the generation index ii is the prompt’s position in the run, and all methods on the same sign layer share the same sign pattern for a prompt, so that the methods are compared on identical sign patterns.

Keyed expansion. The index ii and kPRNGk_{\mathrm{PRNG}} are hashed into a 256-bit seed, which SHAKE-256 [44] expands under two domain labels into the reference magnitudes ∣zref(i)∣|z_{\mathrm{ref}}^{(i)}| and the pad π(i)\pi^{(i)}.

Calibration of the score. Algorithm 3 states the calibration of § 2.7. Its loop hashes a draft image and the image released from it; Line 3 needs no key: in Algorithm 1 the padded

Algorithm 3 Calibration of the score

Require: Held-out prompts Y\mathcal{Y}; hashing network HH; target TPR tt (99.5%)

Ensure: Disagreement rates p1,…,php_1,\ldots,p_h; threshold τ\tau

  1. Split Y\mathcal{Y} at random into halves Yfit\mathcal{Y}_{\mathrm{fit}} and Ythr\mathcal{Y}_{\mathrm{thr}}

  2. for each y∈Yy \in\mathcal{Y} do

  3. z←$N(0,Id)z \leftarrow\$\mathcal{N}(0,I_d); b←${0,1}db \leftarrow\$\{0,1\}^d

  4. hy←H(fθ(z∣y))h_y \leftarrow H(f_\theta(z|y))

  5. hy∗←H(fθ(sign⁡(z)⊙EmbSem⁡(∣z∣,b)∣y))h_y^* \leftarrow H(f_\theta(\operatorname{sign}(z) \odot\operatorname{EmbSem}(|z|,b)|y))

  6. pj←(∣{y∈Yfit:hy,j≠hy,j∗}∣+12)/(∣Yfit∣+1)p_j \leftarrow\left(\left|\{y \in\mathcal{Y}_{\mathrm{fit}}: h_{y,j} \ne h^*_{y,j}\}\right| + \frac{1}{2}\right) / (|\mathcal{Y}_{\mathrm{fit}}|+1)

  7. τ←\tau\leftarrow the (1−t)(1-t) quantile of {S(hy,hy∗):y∈Ythr}\{S(h_y,h_y^*) : y \in\mathcal{Y}_{\mathrm{thr}}\}

  8. return p1,…,ph,τp_1,\ldots,p_h,\tau

bits bb are uniform and independent of ∣zref∣|z_{\mathrm{ref}}| (§ 3.1), so a uniform bb gives the draft and released images their joint distribution. In the score, each pjp_j is clipped to [10−3,0.5−10−3][10^{-3}, 0.5-10^{-3}].

SDXL. To test whether Tripwire-WM carries over to a larger model (Figure 5), the owner generates with SDXL-base [49] at 1024×10241024 \times1024 (d=65,536d = 65{,}536) and guidance scale 5.0, and the forger uses SDXL as its surrogate; the setup is otherwise that of § 4.1, with 50 prompts per seed, 10 for imprinting.

Computational cost. On one NVIDIA L40S in single precision, with medians over 20 MS-COCO prompts, releasing an image takes 2.95 s (83.0 TFLOPs) without a watermark or with PRC alone, 5.95 s (166.7) with SemBind and 6.03 s (167.7) with Tripwire-WM, as both also generate a draft image. Verifying takes 19.48, 19.57 and 20.81 s (797.4–799.1 TFLOPs) with PRC alone, SemBind and Tripwire-WM, with 4.81, 9.86 and 13.88 GiB of weights loaded: Tripwire-WM loads more than SemBind only for the OpenCLIP and SigLIP image towers, as HH shares the DINOv2 backbone of SemBind’s masker. With GS++ the costs match those with PRC to within 1%.

Image credits. The covers of the imprinting forgeries in Figure 1 are public-domain photographs from DVIDS [60], center-cropped to a square; the marks in its caption link to their pages, which name the photographers. The appearance of U.S. Department of Defense (DoD) visual information does not imply or constitute DoD endorsement. The forgeries are made for this evaluation only and depict no real event.

Error-Correcting Code of the Magnitude Layer

This appendix specifies ECC.Encode, ExtSem and ECC.Decode of Algorithms 1 and 2, for the channel and the decoder requirements of § 2.6.

Polar Code Construction

We use a CRC-aided polar code [8, 46]. Polar codes come in power-of-two block lengths, which the latent dimension already is, so the codeword covers every coordinate without puncturing or shortening. The message is the commitment followed by a 24-bit CRC, m=h∥CRC⁡(h)m = h \mathbin{\|} \operatorname{CRC}(h), of ∣m∣=h+24=152|m| = h + 24 = 152 bits; the code rate is ∣m∣/d≈0.0093|m|/d \approx0.0093 at d=16,384d = 16{,}384. The CRC is CRC24C of 5G NR [1] (generator polynomial 0xB2B117, register initialized to all ones).

The information set is chosen by the Gaussian approximation of density evolution [59] at a design mean log-likelihood ratio (LLR) of 0.5: the ∣m∣|m| most reliable of the dd synthetic channels carry the message, the others are frozen to zero, and the codeword cc is this input vector multiplied by (1011)⊗log⁡2d\left(\begin{smallmatrix}1&0\\1&1\end{smallmatrix}\right)^{\otimes\log_2 d}. The information set is the same for every image.

Soft Demapping

ExtSem turns the inverted latent into one LLR per coordinate. Write gj=∣z^ref,j∣g_j = |\hat{z}_{\mathrm{ref},j}| and gˉj=Flip⁡(gj)\bar{g}_j = \operatorname{Flip}(g_j) for the two hypotheses of coordinate jj, and σ^j\hat{\sigma}_j for the sign that Sign.Decode returns. Inversion is not merely noisy; it also shrinks the latent, so we model it as an affine Gaussian channel,

z^j=ασ^jaj+ϵj,aj∈{gj,gˉj},ϵj∼N(0,ν2),(7)\hat{z}_j = \alpha\hat{\sigma}_j a_j + \epsilon_j,\qquad a_j \in\{g_j,\bar{g}_j\},\qquad\epsilon_j \sim\mathcal{N}(0,\nu^2), \tag*{(7)}

and fit α\alpha and ν\nu per image. The fit does not need the message: each hypothesis has prior 1/21/2, so E[aj]=aˉj=(gj+gˉj)/2\mathbb{E}[a_j] = \bar{a}_j = (g_j+\bar{g}_j)/2, and

α^=∑jz^jσ^jaˉj∑jaˉj2.(8)\hat{\alpha} = \frac{\sum_j \hat{z}_j\hat{\sigma}_j\bar{a}_j}{\sum_j \bar{a}_j^2}. \tag*{(8)}
ν^2=1d∑j(z^j−α^σ^jaˉj)2−1d∑j(α^gj−gˉj2)2,(9)\hat{\nu}^2 = \frac{1}{d}\sum_j\left(\hat{z}_j-\hat{\alpha}\hat{\sigma}_j\bar{a}_j\right)^2-\frac{1}{d}\sum_j\left(\hat{\alpha}\frac{g_j-\bar{g}_j}{2}\right)^2, \tag*{(9)}

where the second term removes the spread that the message itself contributes to the residual. α^\hat{\alpha} is clipped to [0.3,3][0.3,3] and ν^2\hat{\nu}^2 floored at 10−410^{-4}. The LLR of cj=0c_j=0 against cj=1c_j=1 is then

ℓj=(−1)π^j(z^j−α^σ^jgˉj)2−(z^j−α^σ^jgj)22ν^2,(10)\ell_j = (-1)^{\hat{\pi}_j}\frac{\left(\hat{z}_j-\hat{\alpha}\hat{\sigma}_j\bar{g}_j\right)^2-\left(\hat{z}_j-\hat{\alpha}\hat{\sigma}_j g_j\right)^2}{2\hat{\nu}^2}, \tag*{(10)}

where the factor (−1)π^j(-1)^{\hat{\pi}_j} undoes the pad: XOR with a known bit exchanges the two hypotheses, which on soft values is a sign flip. This is what ⊕π^\oplus\hat{\pi} denotes in Line 8 of Algorithm 2.

Decoding

ECC.Decode runs successive-cancellation list decoding [57] with list size L=8L=8 on (ℓj)j(\ell_j)_j and checks the CRC of every path in the final list. It returns the information bits of the most likely path whose CRC passes, with the CRC removed, and ⊥\perp if no path passes. A destroyed magnitude layer thus yields a wrong commitment with probability at most L⋅2−24≈4.8×10−7L\cdot2^{-24}\approx4.8\times10^{-7} (Proposition 4.3). The magnitude layer is only read after the sign layer has decoded an index, whose own false-positive rate is at most 10−610^{-6} (§ 4.1), so on an unwatermarked image the two bounds multiply.

Capacity of the Magnitude Channel

Under the channel model of Equation (7), coordinate jj is, given correct signs, a binary-input Gaussian channel whose two inputs are α∣gj−gˉj∣\alpha\lvert g_j-\bar{g}_j\rvert apart. Its capacity is CBI(α∣gj−gˉj∣/(2ν))C_{\mathrm{BI}}(\alpha\lvert g_j-\bar{g}_j\rvert/(2\nu)), where CBI(s)C_{\mathrm{BI}}(s) is the capacity of antipodal signaling ±s\pm s in unit Gaussian noise. It vanishes on coordinates whose reference magnitude lies at the median, where gj=gˉjg_j=\bar{g}_j, and grows toward the tails. Since gjg_j is half-normal, the average capacity per coordinate is a function of the signal-to-noise ratio α/ν\alpha/\nu alone,

Cˉ(α/ν)=Eg∼∣N(0,1)∣[CBI(αν⋅∣g−Flip⁡(g)∣2)],(11)\bar{C}(\alpha/\nu)=\mathbb{E}_{g\sim\lvert\mathcal{N}(0,1)\rvert}\left[C_{\mathrm{BI}}\left(\frac{\alpha}{\nu}\cdot\frac{\lvert g-\operatorname{Flip}(g)\rvert}{2}\right)\right], \tag*{(11)}

and no code of rate R=(h+24)/dR=(h+24)/d can be decoded reliably once Cˉ(α/ν)<R\bar{C}(\alpha/\nu)<R. At h=128h=128 and d=16,384d=16{,}384, R≈0.0093R\approx0.0093, and numerical integration of Equation (11) places this limit at α/ν≈0.20\alpha/\nu\approx0.20, i.e., at an inversion noise about five times the shrunk unit magnitude.

Why the Commitment Rarely Fails

At the limit α/ν≈0.20\alpha/\nu\approx0.20 of Appendix § 10.§ 3, the raw sign error rate Ea[Q(αa/ν)]=12−1πarctan⁡(α/ν)\mathbb{E}_a[Q(\alpha a/\nu)]=\frac{1}{2}-\frac{1}{\pi}\arctan(\alpha/\nu), with QQ the standard normal tail and aa half-normal, is about 44%: the signs are nearly random, and no sign layer decodes an index. Under the model, the magnitude layer thus operates far above its limit whenever the index decodes. The model ignores the finite block length and the correlated, non-Gaussian error of real inversion, so decoding needs some margin above α/ν≈0.20\alpha/\nu\approx0.20. It also assumes that the signs σ^\hat{\sigma} used by ExtSem are correct; a wrong sign makes its coordinate vote confidently for the smaller of its two magnitudes, so failures on genuine images should concentrate on images whose index barely decoded.

We test both predictions on the genuine images of the main experiments, clean and distorted (6,000 per sign layer and dataset; Table 6), placing each image on the α/ν\alpha/\nu axis by its fit of Equation (7). The fit predicts each image’s raw sign error rate; where the error can be measured against σ^\hat{\sigma}, the two correlate at 0.98–0.996. The sign layers stop decoding at a predicted error of about 36–39%, well before 44%, and no image with an index lies below α/ν=0.33\alpha/\nu= 0.33. Whenever the CRC of the polar code passes, the decoded hash equals the committed one, on all 23,308 such images.

SignMS-COCO IndexMS-COCO FailsMS-COCO Agree.SDP IndexSDP FailsSDP Agree.
PRC98.61.980.75698.02.960.756
GS++98.90.100.98898.50.490.988

Table 6. Commitment failures on genuine images. Index: the index decodes (%); Fails: the commitment fails among them (%); Agree.: median fraction of coordinates on which the decoded signs match the written ones, on the failures.

The margin that the finite block length needs fits within this gap. Under GS++, which rebuilds σ^\hat{\sigma} from the decoded index so that it agrees with the written signs on at least 98.5% of the coordinates, the commitment decodes down to α/ν=0.34\alpha/\nu= 0.34–0.35, where the sign layer itself stops, and fails on only 0.10–0.49% of the images with an index. Under PRC it fails on 1.98–2.96%, mostly under blur, median filtering or JPEG, because of wrong signs: all but 11 of these 291 failures lie at α/ν\alpha/\nu between 0.37 and 0.55, where GS++ almost always decodes. On them σ^\hat{\sigma} agrees with the written signs on a median 75.6% of the coordinates, against 98.1% where the commitment decodes, and of the PRC images whose agreement exceeds 95%, only 2 of 9,739 fail. As predicted, their index barely decoded: their median PRC detection score is 2.9–3.2, against 18.6–21.0 where the commitment decodes.

Forgeries That Replace the Magnitudes

This appendix details the forgeries of § 3.3 and the reference-field check against them (§ 2.7). We generate 100 images per case with SD 2.1 on MS-COCO and on SDP prompts, under PRC and GS++, and invert as in § 4.1. The genuine images on each dataset are 100 clean ones and 100 under each of the five distortions of Table 2 and of six stronger ones that only probe the margin of the check: JPEG at quality 30 and 15, blur of radius 5, noise of standard deviation 0.05, an 11 ×\times 11 median filter and downscaling by 0.3. Each forgery is a reprompting forgery whose inverted latent is modified before regeneration:

  • resample f: a random fraction ff of the magnitudes is redrawn from the half-normal distribution, keeping the signs;

  • reflect f: Flip is applied to a random fraction ff of the magnitudes, after normalizing the latent by its median magnitude, an estimate of the shrinkage α\alpha;

  • scrub q: every magnitude is redrawn and each sign is flipped with probability qq, to dilute the sign errors that make TT negative.

Table 4 repeats the PRC forgeries on MS-COCO over five seeds of 100 prompts, and adds reflect 0.75.

Of the 1,200 genuine images per dataset, 82 (MS-COCO) and 94 (SDP) fail the commitment under PRC, and 15 and 11 under GS++; the smallest TT among them, 3.7, under a stronger distortion, stays well above z=2z = 2. Forgeries that leave the magnitudes nearly intact (plain reprompting) are unaffected by the check: their magnitudes are still the owner’s, so TT stays high.

Semantic Hashing Network: Data, Training and Evaluation

SemBind released neither the training data nor the code of its semantic masker [70]; we rebuild both from its description.

Data. We select SemBind’s number of prompts, 96,041, from the training captions of MS-COCO 2017 [39] and the training prompts of SDP [24] by spherical kk-means on BGE-large-en-v1.5 embeddings [65] (K=64,000K = 64{,}000, one or two prompts per cluster); 89.8% are MS-COCO captions. For every prompt we generate 16 images with the generator and sampler of our experiments, and one distorted view of each by one or two of nine families (JPEG, crops, rescaling, blur, median filter, Gaussian and salt-and-pepper noise, color jitter). These families cover the distortions of § 4.3, so the robustness results do not measure out-of-distribution generalization of HH. Each sample is encoded by the three frozen encoders of § 2.5, whose ℓ2\ell_2-normalized embeddings are concatenated into e(x)∈R3712\mathrm{e}(x) \in\mathbb{R}^{3712}.

Model and training. HH has the architecture of SemBind’s masker: residual MLPs map e\mathrm{e} to a feature f∈R8192\mathrm{f} \in\mathbb{R}^{8192} and then to hh logits o\mathrm{o}, and H(x)=1(o>0)H(x) = \mathbb{1}(\mathrm{o} > 0) elementwise. We add a frozen per-dimension standardization of e\mathrm{e}, without which every image receives the same code. Holding out 10% of the prompts, we train on batches of 256 prompts with 4 samples each, the prompt being the label. Stage 1 trains the layers up to f\mathrm{f} with the supervised contrastive loss [32]; stage 2 freezes them and trains the hash head on relaxed codes tanh⁡(so)\tanh(s\mathrm{o}), with the same loss plus quantization, bit-balance, decorrelation and consistency terms, under SemBind’s schedule for the hardness ss. The checkpoint is selected by the separation between same- and different-prompt distances on held-out prompts, and by the unrelated pairs accepted at the target TPR on the calibration prompts.

Table 7 compares the default network with two on DINOv2 embeddings alone: SemBind’s released masker cut to its first 128 bits (DINOv2 + SemBind128_{128}) and one retrained by our recipe (DINOv2 + retrained). All three accept nearly all watermarked images; the default accepts the fewest forgeries and SemBind’s masker the most.

NetworkWatermarkedRepromptingImprinting
Accept (↑\uparrow)Alert (↓\downarrow)Accept (↓\downarrow)Alert (↑\uparrow)Accept (↓\downarrow)Alert (↑\uparrow)
PRC
Default99.6±0.4299.6 \pm0.420.4±0.420.4 \pm0.421.4±1.391.4 \pm1.3994.3±1.7594.3 \pm1.750.0±0.000.0 \pm0.00100.0±0.00100.0 \pm0.00
DINOv2 + SemBind128_{128}99.0±0.9499.0 \pm0.941.0±0.941.0 \pm0.946.4±2.416.4 \pm2.4188.3±3.5188.3 \pm3.517.0±5.707.0 \pm5.7093.0±5.7093.0 \pm5.70
DINOv2 + retrained99.2±0.9199.2 \pm0.910.8±0.910.8 \pm0.913.9±1.673.9 \pm1.6790.8±1.4490.8 \pm1.441.0±2.241.0 \pm2.2499.0±2.2499.0 \pm2.24
GS++
Default99.0±0.5099.0 \pm0.501.0±0.501.0 \pm0.501.8±0.761.8 \pm0.7693.9±2.0493.9 \pm2.040.0±0.000.0 \pm0.00100.0±0.00100.0 \pm0.00
DINOv2 + SemBind128_{128}98.7±1.3598.7 \pm1.351.3±1.351.3 \pm1.357.5±1.777.5 \pm1.7787.7±0.6787.7 \pm0.676.0±4.186.0 \pm4.1894.0±4.1894.0 \pm4.18
DINOv2 + retrained99.2±0.7699.2 \pm0.760.8±0.760.8 \pm0.763.2±1.103.2 \pm1.1093.4±1.4393.4 \pm1.430.0±0.000.0 \pm0.00100.0±0.00100.0 \pm0.00

Table 7. Hashing networks (MS-COCO, SD 2.1 surrogate): acceptance and alert rates, in %.

Attacks on the Hashing Network

This appendix details the attacks and the purification-consistency check of § 4.6, with the default hashing network and target TPR, on 100 prompts per seed.

Attacks. The transfer attack and the three-encoder attack (‘All three together’ in Table 5) maximize the cosine similarity to xwx_w’s embedding, averaged over the attacked encoders, with steps of size ϵ/8\epsilon/8 through a differentiable copy of each encoder’s preprocessing, and keep the last iterate. The white-box attack minimizes a hinge loss pushing the logits of HH’s hash head towards xwx_w’s hash bits, and keeps the quantized iterate whose hash is closest to them. Its hash passes the threshold in at least 99.0% of the cases at every budget and seed, as does that of the three-encoder attack in at least 98.0% at every ϵ≥8/255\epsilon\ge8/255; acceptance is then bounded by the index, which decodes for 88.2%, 71.8% and 48.2% of the white-box forgeries at ϵ=2/255\epsilon= 2/255, 4/2554/255 and 8/2558/255.

Purification-consistency check. The purifier noises the query to timestep 10 of 200 and denoises it under the empty prompt, without guidance. τP=8\tau_P = 8 bits, the same for every seed, is the 99.5% quantile of the distance between H(x)H(x) and H(P(x))H(P(x)) over the clean watermarked images of all seeds; its alarm rate on these images is thus in-sample, unlike those on distorted images and forgeries. Purification moves the hash of a genuine image by 2.0 bits on average, and that of a perturbed forgery by 48–64, back to 61–64 bits from the commitment. The distance never exceeds 16 bits on the 3,000 clean and distorted watermarked images, and is at least 19 on each of the 1,938 accepted perturbed forgeries.

Comparison with Detectable Watermarks

SEAL [6] and PAI [40] also aim to reject forgeries, but they change the initial latent or the sampling trajectory and give up undetectability (§ 6). Table 8 compares them with Tripwire-WM on MS-COCO under the attacks of § 4.1. SEAL derives the initial latent patch by patch from a keyed hash of the image’s caption and accepts a query when enough patches match. We report it in its original setting (12 matching patches) and with 5 matching patches, which gives the false-positive rate 10−610^{-6} of the sign layers. SEAL has no Forged verdict. PAI inverts the query under its key and raises an alert when the initialization bias passes its vanilla check but lies outside a Gaussian fitted to clean watermarked images, whose threshold we place at 99.5% of them, as for Tripwire-WM. At the false-positive rate of the sign layers, SEAL accepts 44.4% of reprompting and 32.0% of imprinting forgeries, and PAI 88.5% and all of them, against at most 1.8% and none for Tripwire-WM.

SchemeWatermarked Acc. (↑\uparrow)Watermarked Alert (↓\downarrow)Distortions Acc. (↑\uparrow)Distortions Alert (↓\downarrow)Reprompting Acc. (↓\downarrow)Reprompting Alert (↑\uparrow)Imprinting Acc. (↓\downarrow)Imprinting Alert (↑\uparrow)
SEAL (original)97.5±0.7197.5 \pm0.71–72.3±1.7372.3 \pm1.73–7.6±1.647.6 \pm1.64✗1.0±2.241.0 \pm2.24✗
SEAL (at FPR 10−610^{-6})99.8±0.2799.8 \pm0.27–85.6±0.6285.6 \pm0.62–44.4±2.0444.4 \pm2.04✗32.0±14.8332.0 \pm14.83✗
PAI100.0±0.00100.0 \pm0.000.0±0.000.0 \pm0.0091.4±0.9491.4 \pm0.948.6±0.948.6 \pm0.9488.5±1.2788.5 \pm1.2711.4±1.4311.4 \pm1.43100.0±0.00100.0 \pm0.000.0±0.000.0 \pm0.00
Tripwire-WM (PRC)99.6±0.4299.6 \pm0.420.4±0.420.4 \pm0.4295.3±0.9095.3 \pm0.900.6±0.240.6 \pm0.241.4±1.391.4 \pm1.3994.3±1.7594.3 \pm1.750.0±0.000.0 \pm0.00100.0±0.00100.0 \pm0.00
Tripwire-WM (GS++)99.0±0.5099.0 \pm0.501.0±0.501.0 \pm0.5097.6±0.3697.6 \pm0.360.9±0.290.9 \pm0.291.8±0.761.8 \pm0.7693.9±2.0493.9 \pm2.040.0±0.000.0 \pm0.00100.0±0.00100.0 \pm0.00

Table 8. Detectable watermarks on MS-COCO: acceptance and alert rates, in %; Distortions: their mean.

Generative AI Usage Considerations

Generative models as objects of study. The watermarking schemes we evaluate, including ours, operate on open-weight latent diffusion models: Stable Diffusion 2.1, Stable Diffusion 1.5 and SDXL. Our hashing network reads open-weight image encoders (DINOv2, OpenCLIP ViT-H/14, SigLIP); the transfer attack additionally uses OpenAI CLIP ViT-L/14. The regeneration attacks use Stable Diffusion 1.4 and a learned image codec, and the SEAL baseline captions images with BLIP-2. No closed-source generative model is used in any experiment, so every result can be reproduced from public weights.

Generative AI as a tool. The authors used an LLM-based coding assistant (Anthropic’s Claude, via Claude Code) to help implement experiment code (benchmark harnesses, baseline reimplementations, job scripts, and scripts that aggregate results into tables and figures), to orchestrate and monitor experiment runs, and to draft and edit parts of this manuscript. All code was reviewed by the authors, baseline reimplementations were checked against the original authors’ code where it was available, and all reported numbers were checked against the raw result files. Generative AI was used for editorial purposes in this manuscript, and all outputs were inspected by the authors to ensure accuracy and originality. The research ideas, method, threat model, and security analysis are the authors’ own.

References

  1. [1]3GPP. NR; multiplexing and channel coding. Technical Specification TS 38.212, 2018.
  2. [2]B. An, M. Ding, T. Rabbani, A. Agrawal, Y. Xu, C. Deng, S. Zhu, A. Mohamed, Y. Wen, T. Goldstein, and F. Huang. WAVES: Benchmarking the robustness of image watermarks. In ICML, volume 235, pages 1456–1492, 2024.arxiv.org/abs/2401.08573
  3. [3]L. An, Y. Liu, Y. Liu, Y. Zhang, Y. Bu, and S. Chang. Defending LLM watermarking against spoofing attacks with contrastive representation learning. arXiv preprint arXiv:2504.06575, 2025.arxiv.org/abs/2504.06575
  4. [4]J. P. Anderson. Computer security threat monitoring and surveillance. Technical report, James P. Anderson Company, Fort Washington, PA, 1980.
  5. [5]K. Arabi, B. Feuer, R. T. Witter, C. Hegde, and N. Cohen. Hidden in the noise: Two-stage robust watermarking for images. In ICLR, 2025.arxiv.org/abs/2412.04653
  6. [6]K. Arabi, R. T. Witter, C. Hegde, and N. Cohen. SEAL: Semantic aware image watermarking. In ICCV, pages 16196–16205, 2025.arxiv.org/abs/2503.12172
  7. [7]T. Aremu, N. Hussein, M. Nwadike, S. Poppi, J. Zhang, K. Nandakumar, N. Gong, and N. Lukas. Mitigating watermark forgery in generative models via randomized key selection. In ICML Workshop on Trustworthy AI for Good, 2026. arXiv:2507.07871.arxiv.org/abs/2507.07871
  8. [8]E. Arikan. Channel polarization: A method for constructing capacity-achieving codes for symmetric binary-input memoryless channels. IEEE Transactions on Information Theory, 55(7):3051–3073, 2009.DOI
  9. [9]J. Ballé, D. Minnen, S. Singh, S. J. Hwang, and N. Johnston. Variational image compression with a scale hyperprior. In ICLR, 2018.arxiv.org/abs/1802.01436
  10. [10]J. Betker, G. Goh, L. Jing, T. Brooks, J. Wang, L. Li, L. Ouyang, J. Zhuang, J. Lee, Y. Guo, et al. Improving image generation with better captions. Technical report, OpenAI, 2023. https://cdn.openai.com/papers/dall-e-3.pdf.
  11. [11]Black Forest Labs, S. Batifol, A. Blattmann, F. Boesel, S. Consul, C. Diagne, T. Dockhorn, J. English, Z. English, P. Esser, et al. FLUX.1 Kontext: Flow matching for in-context image generation and editing in latent space. arXiv preprint arXiv:2506.15742, 2025.arxiv.org/abs/2506.15742
  12. [12]M. Cherti, R. Beaumont, R. Wightman, M. Wortsman, G. Ilharco, C. Gordon, C. Schuhmann, L. Schmidt, and J. Jitsev. Reproducible scaling laws for contrastive language-image learning. In CVPR, pages 2818–2829, 2023.DOI
  13. [13]B. Chesney and D. Citron. Deep fakes: A looming challenge for privacy, democracy, and national security. California Law Review, 107:1753, 2019.
  14. [14]M. Christ and S. Gunn. Pseudorandom error-correcting codes. In CRYPTO, pages 325–347, 2024. doi: 10.1007/978-3-031-68391-6_10.DOI
  15. [15]M. Christ, S. Gunn, and O. Zamir. Undetectable watermarks for language models. In COLT, volume 247, pages 1125–1139, 2024.arxiv.org/abs/2306.09194
  16. [16]Coalition for Content Provenance and Authenticity. C2PA technical specification, version 2.1. https://c2pa.org/specifications/, 2024.
  17. [17]Z. Dong, C. Shuai, Z. Ba, P. Cheng, Z. Qin, Q. Wang, and K. Ren. WMCopier: Forging invisible watermarks on arbitrary images. In NeurIPS, volume 38, pages 153114–153144, 2025.arxiv.org/abs/2503.22330
  18. [18]M. Q. Duong, C. T. Lei, and C. P. Lau. PGID: Progressive guided inversion and denoising for robust watermark detection. In NeurIPS, volume 39, 2026. To appear.arxiv.org/abs/2605.09319
  19. [19]P. Esser, S. Kulal, A. Blattmann, R. Ent ezari, J. Müller, H. Saini, Y. Levi, D. Lorenz, A. Sauer, F. Boesel, et al. Scaling rectified flow transformers for high-resolution image synthesis. In ICML, volume 235, pages 12606–12633, 2024.arxiv.org/abs/2403.03206
  20. [20]European Parliament and Council of the European Union. Regulation (EU) 2024/1689 of the European Parliament and of the Council of 13 June 2024 laying down harmonised rules on artificial intelligence (Artificial Intelligence Act). Official Journal of the European Union, L series, July 2024. URL http://data.europa.eu/eli/reg/2024/1689/oj.
  21. [21]J. Fairoze, S. Garg, S. Jha, S. Mahloujifar, M. Mahm oody, and M. Wang. Publicly-detectable watermarking for language models. IACR Communications in Cryptology, 1(4), 2025. doi: 10.62056/ahmpdkp10.DOI
  22. [22]T. Gloaguen, N. Jovanović, R. Staab, and M. Vechev. Discovering spoofing attempts on language model watermarks. In ICML, volume 267, pages 19562–19584, 2025.arxiv.org/abs/2410.02693
  23. [23]S. Gunn, X. Zhao, and D. Song. An undetectable watermark for generative image models. In ICLR, 2025.arxiv.org/abs/2410.07369
  24. [24]Gustavosta. Stable-Diffusion-Prompts. https://huggingface.co/datasets/Gustavosta/Stable-Diffusion-Prompts, 2022.
  25. [25]M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter. GANs trained by a two time-scale update rule converge to a local Nash equilibrium. In NeurIPS, volume 30, 2017.
  26. [26]J. Ho and T. Salimans. Classifier-free diffusion guidance. arXiv preprint arXiv:2207.12598, 2022.arxiv.org/abs/2207.12598
  27. [27]S. Hong, K. Lee, S. Y. Jeon, H. Bae, and S. Y. Chun. On exact inversion of DPM-Solvers. In CVPR, pages 7069–7078, 2024.arxiv.org/abs/2311.18387
  28. [28]A. Jain, Y. Kobayashi, N. Murata, Y. Takida, T. Shibuya, Y. Mitsufuji, N. Cohen, N. Memon, and J. Togelius. Forging and removing latent-noise diffusion watermarks using a single image. arXiv preprint arXiv:2504.20111, 2025.arxiv.org/abs/2504.20111
  29. [29]N. Jovanović, R. Staab, and M. Vechev. Watermark stealing in large language models. In ICML, volume 235, pages 22570–22593, 2024.arxiv.org/abs/2402.19361
  30. [30]M. Kang, D. Song, and B. Li. DiffAttack: Evasion attacks against diffusion-based adversarial purification. In NeurIPS, volume 36, pages 73919–73942, 2023.arxiv.org/abs/2311.16124
  31. [31]A. Kassis, U. Hengartner, and Y. Yu. DiffBreak: Is diffusion-based purification robust? In NeurIPS, volume 38, 2025.arxiv.org/abs/2411.16598
  32. [32]P. Khosla, P. Teterwak, C. Wang, A. Sarna, Y. Tian, P. Isola, A. Maschinot, C. Liu, and D. Krishnan. Supervised contrastive learning. In NeurIPS, volume 33, pages 18661–18673, 2020.arxiv.org/abs/2004.11362
  33. [33]D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In ICLR, 2015.arxiv.org/abs/1412.6980
  34. [34]J. Lai, L. Zhang, C. Tang, P. Sun, Z. Zhang, Y. Wang, and H. Jin. CSGuard: Toward forgery-resistant watermarking in diffusion models via compressed sensing constraint. arXiv preprint arXiv:2605.01479, 2026.arxiv.org/abs/2605.01479
  35. [35]C.-Y. Lee, Y. Zhang, Y. Yang, C.-S. Lu, and J.-C. Chen. Rethinking forgery attacks on semantic watermarks in black-box settings: A geometric distortion perspective. In ICML, volume 306, pages 65253–65276, 2026.arxiv.org/abs/2606.29807
  36. [36]M. Lee and D. Kim. Robust evaluation of diffusion-based adversarial purification. In ICCV, pages 134–144, 2023.arxiv.org/abs/2303.09051
  37. [37]X. Li, W. Sun, H. Chen, Q. Li, Y. Liu, Y. He, J. Shi, and X. Hu. ADBM: Adversarial diffusion bridge model for reliable adversarial purification. In ICLR, 2025.arxiv.org/abs/2408.00315
  38. [38]C.-Y. Lin and S.-F. Chang. A robust image authentication method distinguishing JPEG compression from malicious manipulation. IEEE Transactions on Circuits and Systems for Video Technology, 11(2):153–168, 2001.DOI
  39. [39]T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft COCO: Common objects in context. In ECCV, pages 740–755, 2014.arxiv.org/abs/1405.0312
  40. [40]Q. Liu, Y. Zhang, Z. Ba, C. Shuai, P. Cheng, T. Zheng, and Z. Wang. Attack-resistant watermarking for AIGC image forensics via diffusion-based semantic deflection. In ICLR, 2026.arxiv.org/abs/2601.06639
  41. [41]C. Lu, Y. Zhou, F. Bao, J. Chen, C. Li, and J. Zhu. DPM-Solver: A fast ODE solver for diffusion probabilistic model sampling in around 10 steps. In NeurIPS, volume 35, pages 5775–5787, 2022.arxiv.org/abs/2206.00927
  42. [42]A. Madry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.arxiv.org/abs/1706.06083
  43. [43]A. Müller, D. Lukovnikov, J. Thietke, A. Fischer, and E. Quiring. Black-box forgery attacks on semantic watermarks for diffusion models. In CVPR, pages 20937–20946, 2025.arxiv.org/abs/2412.03283
  44. [44]National Institute of Standards and Technology. SHA-3 standard: Permutation-based hash and extendable-output functions. FIPS PUB 202, NIST, 2015.DOI
  45. [45]W. Nie, B. Guo, Y. Huang, C. Xiao, A. Vahdat, and A. Anandkumar. Diffusion models for adversarial purification. In ICML, volume 162, pages 16805–16827, 2022.arxiv.org/abs/2205.07460
  46. [46]K. Niu and K. Chen. CRC-aided decoding of polar codes. IEEE Communications Letters, 16(10):1668–1671, 2012.DOI
  47. [47]M. Oquab, T. Darcet, T. Moutakanni, H. Vo, M. Szafraniec, V. Khalidov, P. Fernandez, D. Haziza, F. Massa, A. El-Nouby, et al. DINOv2: Learning robust visual features without supervision. TMLR, 2024.arxiv.org/abs/2304.07193
  48. [48]Q. Pang, S. Hu, W. Zheng, and V. Smith. No free lunch in LLM watermarking: Trade-offs in watermarking design choices. In NeurIPS, volume 37, pages 138756–138788, 2024.arxiv.org/abs/2402.16187
  49. [49]D. Podell, Z. English, K. Lacey, A. Blattmann, T. Dockhorn, J. Müller, J. Penna, and R. Rombach. SDXL: Improving latent diffusion models for high-resolution image synthesis. In ICLR, 2024.arxiv.org/abs/2307.01952
  50. [50]A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark, G. Krueger, and I. Sutskever. Learning transferable visual models from natural language supervision. In ICML, volume 139, pages 8748–8763, 2021.arxiv.org/abs/2103.00020
  51. [51]N. Reimers and I. Gurevych. Sentence-BERT: Sentence embeddings using Siamese BERT-networks. In EMNLP-IJCNLP, pages 3982–3992, 2019.arxiv.org/abs/1908.10084
  52. [52]R. Rombach, A. Blattmann, D. Lorenz, P. Esser, and B. Ommer. High-resolution image synthesis with latent diffusion models. In CVPR, pages 10684–10695, 2022.arxiv.org/abs/2112.10752
  53. [53]M. Saberi, V. S. Sadasivan, K. Rezaei, A. Kumar, A. Chegini, W. Wang, and S. Feizi. Robustness of AI-image detectors: Fundamental limits and practical attacks. In ICLR, 2024.arxiv.org/abs/2310.00076
  54. [54]P. Schramowski, M. Brack, B. Deiseroth, and K. Kersting. Safe latent diffusion: Mitigating inappropriate degeneration in diffusion models. In CVPR, pages 22522–22531, 2023.arxiv.org/abs/2211.05105
  55. [55]J. Song, C. Meng, and S. Ermon. Denoising diffusion implicit models. In ICLR, 2021.arxiv.org/abs/2010.02502
  56. [56]T. Souček, S.-A. Rebuffi, P. Fernandez, N. Jovanović, H. Elsahar, V. Lacatusu, T. Tran, and A. Mourachko. Transferable black-box one-shot forging of watermarks via image preference models. In NeurIPS, volume 38, pages 55967–55990, 2025.arxiv.org/abs/2510.20468
  57. [57]I. Tal and A. Vardy. List decoding of polar codes. IEEE Transactions on Information Theory, 61(5):2213–2226, 2015.
  58. [58]M. Tancik, B. Mildenhall, and R. Ng. StegaStamp: Invisible hyperlinks in physical photographs. In CVPR, pages 2117–2126, 2020.arxiv.org/abs/1904.05343
  59. [59]P. Trifonov. Efficient design and decoding of polar codes. IEEE Transactions on Communications, 60(11):3221–3227, 2012.DOI
  60. [60]U.S. Department of Defense. Defense Visual Information Distribution Service (DVIDS). https://www.dvidshub.net, 2026. Public-domain photographs; accessed November 2026.
  61. [61]T. Wang, A. Wang, T. Cong, D. Ran, J. Liu, and X. Wang. Cryptanalysis of ldpc-based pseudorandom error-correcting codes. In USENIX Security, 2026.arxiv.org/abs/2512.17310
  62. [62]Y. Wen, J. Kirchenbauer, J. Geiping, and T. Goldstein. Tree-Rings watermarks: Invisible fingerprints for diffusion images. In NeurIPS, volume 36, pages 58047–58063, 2023.DOI
  63. [63]D. Wesego and P. Rooshenas. TARO: Temporal adversarial rectification optimization using diffusion models as purifiers. arXiv preprint arXiv:2605.08440, 2026.arxiv.org/abs/2605.08440
  64. [64]P. W. Wong. A public key watermark for image verification and authentication. In IEEE ICIP, volume 1, pages 455–459, 1998.
  65. [65]S. Xiao, Z. Liu, P. Zhang, N. Muennighoff, D. Lian, and J.-Y. Nie. C-Pack: Packed resources for general Chinese embeddings. In ACM SIGIR, pages 641–649, 2024.arxiv.org/abs/2309.07597
  66. [66]P. Yang, H. Ci, Y. Song, and M. Z. Shou. Can simple averaging defeat modern watermarks? In NeurIPS, volume 37, pages 56644–56673, 2024.DOI
  67. [67]Z. Yang, K. Zeng, K. Chen, H. Fang, W. Zhang, and N. Yu. Gaussian Shading: Provable performance-lossless image watermarking for diffusion models. In CVPR, pages 12162–12171, 2024.arxiv.org/abs/2404.04956
  68. [68]Z. Yang, X. Zhang, K. Chen, K. Zeng, Q. Yao, H. Fang, W. Zhang, and N. Yu. Gaussian Shading++: Rethinking the realistic deployment challenge of performance-lossless image watermark for diffusion models. arXiv preprint arXiv:2504.15026, 2025.arxiv.org/abs/2504.15026
  69. [69]X. Zhai, B. Mustafa, A. Kolesnikov, and L. Beyer. Sigmoid loss for language image pre-training. In ICCV, pages 11975–11986, 2023.arxiv.org/abs/2303.15343
  70. [70]X. Zhang, Z. Yang, K. Chen, L. Ma, W. Zhang, and N. Yu. SemBind: Binding diffusion watermarks to semantics against black-box forgery attacks. In ICML, volume 306, pages 159761–159784, 2026.arxiv.org/abs/2601.20310
  71. [71]X. Zhao, K. Zhang, Z. Su, S. Vasan, I. Grishchenko, C. Kruegel, G. Vigna, Y.-X. Wang, and L. Li. Invisible image watermarks are provably removable using generative AI. In NeurIPS, volume 37, pages 8643–8672, 2024.arxiv.org/abs/2306.01953
  72. [72]T. Zhou, X. Zhao, X. Xu, and S. Ren. Bileve: Securing text provenance in large language models against spoofing with bi-level signature. In NeurIPS, volume 37, pages 56054–56075, 2024.arxiv.org/abs/2406.01946
  73. [73]T. Zhou, R. Ding, G. Liu, C. Fleming, R. R. Kompella, Y. Fei, X. Xu, and S. Ren. MetaSeal: Defending against image attribution forgery through content-dependent cryptographic watermarks. TMLR, 2026.arxiv.org/abs/2509.10766
  74. [74]J. Zhu, R. Kaplan, J. Johnson, and L. Fei-Fei. HiDDen: Hiding data with deep networks. In ECCV, pages 682–697, 2018.arxiv.org/abs/1807.09937
  75. [75]Y. Zhu, Y. Wang, and X.-S. Gao. Towards robust content watermarking against removal and forgery attacks. In CVPR, Findings, pages 8062–8072, 2026.arxiv.org/abs/2604.06662

Paper details

vlnc:W_ezy24tbr
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 9

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Claude Code

View statement
Looking for related papers…
Contents