acceptodds
Under review as a conference paper at ICLR 2027

Erase to Forge, Verify to Defend: Diffusion-based Forgery Attack and Self-verifiable Defense Mechanism

Abstract

Watermarking has emerged as a critical mechanism for establishing provenance of AI-generated media, yet its security against forgery attacks remains largely underexplored. Forgery attacks, wherein an adversary embeds a counterfeit watermark into arbitrary content to falsely attribute it to a target model, pose a severe threat to the integrity of watermarking systems. In this work, we introduce , a diffusion-based no-box forgery attack that repurposes watermark removal techniques to construct a proxy dataset of watermark-free images, from which a conditional diffusion model learns to estimate and reproduce the target watermark residual. By modeling the watermark as a structured residual rather than regenerating the full image, EraseForge achieves state-of-the-art forgery performance with as few as 1,000 training samples—a 5 improvement in data efficiency over existing methods. We further demonstrate that EraseForge circumvents the multi-message defense strategy previously proposed in the literature, achieving over 91% bit accuracy at samples where prior methods fail at . To address this threat, we propose a defense mechanism with two complementary variants—SeedBind and ContentBind—that transform verification from a finite message pool lookup into a structural consistency check, reducing forged bit accuracy to (near-random) across all tested watermarking schemes and attack strategies without modifying the underlying watermarking architecture. Specifically, SeedBind enforces deterministic consistency between a random seed and its pseudo-random expansion to neutralize estimator-based attacks, while ContentBind derives the watermark message directly from the image's learned visual features, additionally neutralizing residual-based one-shot forgery attacks.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Invisible Watermark, Image Watermark, Watermark Forgery Attack, Watermark Forgery Defense, AI Provenance

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_t5t3OpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2(+1)
Presentation
2
Soundness
3
Read review
Paper summary

This manuscript proposes EraseForge, a no-box watermark forgery attack that leverages diffusion-based watermark removal to construct proxy training data and trains a conditional diffusion model to generate watermark residuals. The proposed method achieves competitive forgery performance with fewer training samples than existing approaches. The authors further introduce two defense mechanisms, SeedBind and ContentBind, which aim to prevent forgery through message consistency verification and content-dependent watermark generation.

Critical strengths
  1. The focused problem that investigating watermark forgery attacks under the practical no-box setting is an important security concern for AI-generated content attribution.

  2. The authors evaluate the proposed attack across multiple watermarking schemes and datasets. The experiments are sufficient.

Critical weaknesses
  1. My major concern is that the proposed EraseForge framework largely combines existing techniques, including diffusion-based watermark removal, watermark residual extraction, and conditional diffusion modeling. Prior works such as WMCopier and WMForger have already explored diffusion-based watermark forgery and residual-based attacks. The proposed conditional residual modeling appears to be a relatively straightforward extension of these established techniques, offering limited novelty for a top-tier conference like ICLR.

  2. Both SeedBind and ContentBind rely on well-established concepts in watermarking and authentication (e.g., Weng et al. (2012), Robust Image Content Authentication Using Perceptual Hashing and Watermarking). SeedBind essentially introduces deterministic consistency checks between message components, while ContentBind binds watermark messages to image features through perceptual hashing. Similar principles have been extensively studied in content-dependent watermarking and image authentication.

  3. In the manuscript, the authors repeatedly emphasize a 5× improvement in data efficiency by reducing training samples from 5,000 to 1,000. However, both dataset sizes are relatively small, and such a reduction may not provide a substantial practical advantage. Furthermore, the proposed approach involves multiple computationally expensive stages, including diffusion-based removal, training, and refinement. Without comparing end-to-end computational costs, the practical significance of this improvement remains unclear.

  4. Some latest relevant recent research are overlooked, such as Removing Box-Free Watermarks for Image-to-Image Models via Query-Based Reverse Engineering (AAAI 2026). Although this work focuses on watermark removal rather than forgery, it also exploits the additive properties of watermark signals and uses surrogate modeling.

Questions for authors

See weaknesses. I may modify my rating based on the authors' rebuttal.

6 comments

We sincerely thank the reviewer for the thoughtful critique and for acknowledging the contributions of our work:

  • An important problem. Watermark forgery under the practical no-box setting is an important security concern for the attribution of AI-generated content.
  • A competitive attack with fewer samples. EraseForge achieves competitive forgery performance with fewer training samples than existing approaches, and we additionally propose two defenses, SeedBind and ContentBind.
  • Sufficient experiments. The attack is evaluated across multiple watermarking schemes and datasets.

We also thank the reviewer for being open to revising their assessment, and we address each concern below.

Summary

Section, table and line numbers below refer to the revised manuscript; all changes are marked in blue.

  1. EraseForge builds on known components, but it is not a straightforward extension of prior attacks. It recasts no-box forgery as supervised conditional residual estimation, using removal-generated proxy pairs. This differs from both residual copying (WMForger) and modelling the distribution of watermarked images (WMCopier). The reformulation is what changes the security conclusion: a 100-message pool, which WMCopier reported to withstand forgery even with 50k samples, is broken by EraseForge with 20k (Table 3). A new ablation shows that both parts of the formulation are needed (CW #1).
  2. SeedBind and ContentBind share a similar idea with Weng et al. (2012), namely embedding verification information in the watermark so that the verifier can re-derive and check it. Our approaches differ in the threat model (false attribution by learned forgers rather than tampering), the components (off-the-shelf neural watermarks, learned features) and the security analysis. We developed them independently and will acknowledge this prior work explicitly (CW #2).
  3. The data reduction comes with a compute reduction, and EraseForge breaks a previously reported defense. End to end, EraseForge needs ≈14 h on one 8-GPU node, compared with ≈30 h for WMCopier. Beyond these savings, it breaks the 100-message defense that WMCopier reported to be effective (Table 3) (CW #3).

Based on the reviewer's feedback, we have made the following changes:

  1. Positioning of EraseForge: we state the novelty of EraseForge explicitly in the introduction (L. 85), the contributions (L. 105) and the related work (L. 505), add the comparison table from CW #1 (Appendix A.4, Table 6, L. 952), and add the residual-regressor ablation (Appendix B.5, L. 1121) (resolves CW #1).
  2. Prior authentication work: we add Weng et al. (2012) and the related content-dependent watermarking and perceptual-hashing literature to the Related Work (L. 517), acknowledge the shared idea in the SeedBind and ContentBind descriptions (§5.1, L. 374 and L. 430), and add the comparison table in a new Appendix D.5 (Table 14, L. 1297) (resolves CW #2).
  3. Missing related work: we add the AAAI 2026 work on removing box-free watermarks (§6, L. 495) (resolves CW #4).

The end-to-end computational cost requested in CW #3 is reported in this response.

[CW #1] Novelty of EraseForge relative to WMCopier / WMForger. We thank the reviewer for raising this concern, and we have improved our write-up to explain the novelty and contribution of EraseForge more clearly. EraseForge builds on known components, but it is not a straightforward extension of either prior attack, which belong to different families:

  • WMForger is a residual-copy attack. It extracts the watermark residual of a single image by optimisation against an image-preference model, then pastes that fixed residual onto target images. Nothing is learned about the watermark.
  • WMCopier and EraseForge are estimator-based, but they solve different learning problems.
    • WMCopier models the distribution of watermarked images, so the watermark must be learned jointly with image content.
    • EraseForge uses diffusion-based removal to construct proxy (clean, watermarked) pairs. This turns no-box forgery into supervised conditional residual estimation of p(δ | x), learning only the watermark signal conditioned on the target content.
WMForgerWMCopierEraseForge
Familyresidual copyestimatorestimator
What is learnednothing (one residual extracted per image)distribution of watermarked imagesconditional distribution of the watermark residual given content
Training signal—watermarked images onlyremoval-generated proxy pairs (x_r, x_w)
Data1 image5k–50k1k (single message); 20k breaks a 100-message pool

This reformulation, not the individual components, is what produces the gains we report. Each claim is supported by an experiment:

  1. Less data. Comparable forgery with 5× fewer samples (Table 1).
  2. A changed security conclusion.
    • WMCopier reported that a K=100 message pool withstands forgery even with 50k samples.
    • In our evaluation, WMCopier stays at 69–72% bit accuracy (Table 3), while EraseForge exceeds 91% at N=20k.
    • The multi-message strategy, the main existing forgery defense, is therefore insufficient.
  3. Both parts of the formulation are necessary.
    • Residual target: residual vs. full-image modelling gives an 8–10 dB PSNR gain at comparable or better bit accuracy (Table 8).

    • Conditional generation (new, also requested by Reviewer P9gr): a direct residual regressor uses the same UNet, proxy pairs and training budget, and is trained with MSE in a single forward pass. HiDDeN-48, N=1k; forged bit accuracy / PSNR:

      single message10-message pool
      EraseForge (conditional diffusion)99.2% / 31.8 dB81.6% / 32.0 dB
      Direct residual regressor (same pairs)98.2% / 29.0 dB73.2% / 27.6 dB

      If EraseForge were a straightforward extension, residual regression on the proxy pairs would suffice. It does for a single message, but not once the defender uses multiple messages.

Changes in the revised paper (marked in blue).

  1. Contributions (§1, L. 105). The first contribution now states the novelty explicitly: "We introduce EraseForge, which reformulates no-box watermark forgery as supervised conditional residual estimation: diffusion-based watermark removal constructs proxy (clean, watermarked) pairs, from which a conditional diffusion model learns the distribution of the watermark residual given the target image."
  2. Introduction (§1, L. 85). A new paragraph explains how EraseForge differs from WMForger and WMCopier, and why both the residual target (Table 8) and conditional generation (Appendix B.5) are necessary.
  3. Related Work (§6, Watermark Attacks, L. 505). New sentences position EraseForge within the estimator family and point to the comparison table above, now Table 6 in Appendix A.4 (L. 952).
  4. New ablation (Appendix B.5, L. 1121). The comparison with a direct residual regressor trained on the same pairs (point 3 above; also requested by Reviewer P9gr).

[CW #2] Relation of SeedBind / ContentBind to prior authentication work. We thank the reviewer for pointing us to this line of work. ContentBind and SeedBind share a similar idea with Weng et al. (2012): verification information is embedded in the watermark itself, so that the verifier can re-derive it and check it. ContentBind in particular, like Weng et al., embeds a hash derived from the image. However, our approaches differ from theirs in the threat model, the components and the security analysis, as summarised below. We developed SeedBind and ContentBind independently and were not aware of this prior work at the time. We have added it to the Related Work section and acknowledge it explicitly (§6, L. 517).

Weng et al. (PCM 2012) address content authentication along a distribution chain:

  • A keyed perceptual hash is embedded in the same image with a robust STDM watermark placed in different wavelet subbands, so that embedding does not disturb the hash. The hash consists of sign bits of low-frequency DCT coefficients of a wavelet approximation band, permuted with a secret key.
  • The verifier extracts the embedded hash, recomputes the hash from the received image, and accepts if their Hamming distance is below a threshold. This distinguishes incidental distortion from malicious tampering.
  • The idea goes back to Fridrich (1999) and Fridrich & Goljan (2000), who proposed image-dependent watermarks, which counter attacks that copy a watermark between images such as the copy attack of Kutter et al. (2000).

The differences between Weng et al. (2012) and our approaches are as follows:

Weng et al. 2012 (and Fridrich & Goljan)ContentBind (ours)SeedBind (ours)
Goal / threatintegrity: detect tampering of a given imageprovenance: detect transplanting a provider's watermark onto other content (false attribution)provenance against learned estimators
Adversary evaluatedcontent editing; no learning adversarylearned forgers: one-shot residual copying (WMForger) and diffusion-based estimation (EraseForge)EraseForge
Bindingkeyed perceptual hash of the same imagesecret projection of learned features (DINOv2)internal seed–hash consistency, independent of content
Watermarkhand-designed STDM, co-designed with the hashoff-the-shelf neural watermarkers, unmodifiedsame
Security analysiscollision probability of the hashlearnability of the binding by a data-driven attackersensitivity of the consistency check to decoding errors

Changes in the revised paper (marked in blue).

  1. Related Work (§6, Forgery Defense, L. 517). We credit Fridrich (1999), Fridrich & Goljan (2000), the copy attack of Kutter et al. (2000), Lin & Chang (2001), Weng et al. (2012) and Swaminathan et al. (2006), and state that SeedBind and ContentBind adapt these binding principles to off-the-shelf neural watermarks and evaluate them against learned forgers.
  2. §5.1, SeedBind (L. 374). SeedBind is described as a self-authenticating payload, in which part of the message is a deterministic function of the rest.
  3. §5.1, ContentBind (L. 430). ContentBind is described as following the classical principle of content-dependent watermarking (Fridrich & Goljan, 2000; Weng et al., 2012).
  4. New Appendix D.5, "Relation to Content Authentication" (Table 14, L. 1297). The comparison table above.
Reviewer_PsbFOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
3(+2)
Read review
Paper summary

The paper presents both a no-box image watermark forgery attack, EraseForge, and two forgery defenses, SeedBind and ContentBind. EraseForge first uses watermark removal attacks to extract the original unwatermarked image, then uses the watermarked-unwatermarked image pair to train a conditional diffusion model to learn the watermarking signal. EraseForge improves empirically over related work. SeedBind and ContentBind both adapt how they construct the embedded message to improve robustness to forgery attacks. SeedBind splits the message in half: one half is a random seed, and the other is a hash of that seed. ContentBind instead writes the message as a hash of the original image.

Critical strengths
  1. Strong intuitive attack.
  2. Easy to understand and follow.
  3. Aside from the lack of evaluation of EraseForge on ContentBind, the experiment suite is fairly comprehensive.
Critical weaknesses
  1. The post-hoc watermarking methods evaluated are fairly old (2007 to 2019); more recent watermarking methods might be more robust to your attack.
  2. The number of test images used to generate the results in the experiment section is not specified. Additionally, you do not report standard deviations or confidence intervals. (No seed variation).
  3. I believe that your ContentBind defense is not robust against EraseForge or similar attacks. Unfortunately, you do not evaluate EraseForge against ContentBind. What prevents the attacker from learning the relationship between the original input image (which they can obtain with removal attacks like EraseForge) and the watermarked image? Nothing prevents the EraseForge residual prediction model from inherently learning h(ϕ(x))h(\phi(x)) on top of the watermarking process, as it does against the watermarks you evaluate. 
  4. If ContentBind is indeed broken by EraseForge, your defensive contributions are two approaches with fundamental flaws that severely limit their usefulness in realistic deployment. As you pointed out, SeedBind is broken by WMForger.
  5. Figure and Table text is often too small to read comfortably, and it borders on template exploitation to pack more content into the paper than can reasonably fit.
  6. prp_r is not explicitly defined.
Questions for authors
  1. In Table 1, it would be helpful to include the baseline/benign bit accuracy for comparison.
  2. In some cases, your method performs better at N=1000 than at N=5000; can you explain why?
  3. Please address the lower PSNR of EraseForge compared to WMCopier in Table 3.
  4. How does ContentBind work for in-generation schemes, if it works at all?
6 comments

We sincerely thank the reviewer for the careful reading and for acknowledging the strengths of our work:

  • A strong, intuitive attack. EraseForge uses watermark removal to obtain approximate unwatermarked images and learns the watermark signal from the resulting pairs.
  • Clear presentation. The paper is easy to understand and follow.
  • A comprehensive experiment suite. We also thank the reviewer for identifying the missing evaluation of EraseForge against ContentBind, which we now provide (CW #3).

We also thank the reviewer for the detailed questions, which helped us strengthen the evaluation.

Summary

Section, table and line numbers below refer to the revised manuscript; all changes are marked in blue.

  1. ContentBind is robust to EraseForge in the limited-sample setting of our threat model. Following the reviewer's suggestion, we trained EraseForge directly against ContentBind. Without the defense, EraseForge forges VideoSeal-96 (N=5,000) and HiDDeN-48 (N=1,000) with 94.4% and 99.2% bit accuracy. Under ContentBind, its forgeries stay at about 53%, close to unwatermarked images. We acknowledge that an attacker with many more samples might learn the content binding, and we describe ContentBind-FE, a keyed variant, as a potential defense against such an attacker (CW #3, CW #4).
  2. EraseForge also forges a recent watermarking method. With 5,000 samples, EraseForge forges VideoSeal (2024) with 92.9% bit accuracy (94.4% with post-forgery refinement) (CW #1).
  3. Our results are stable. The 95% confidence intervals over test images are ±0.44–0.63 points of bit accuracy, and repeated forgery runs differ by at most 0.81 points, far less than the differences our conclusions rest on (CW #2, Q2).

Based on the reviewer's feedback, we have made the following changes:

  1. Limitations and future work (Appendix E, L. 1342–1352): we state that ContentBind was evaluated against EraseForge with up to 5,000 samples, that a much larger attacker might learn the content binding, and that the combination of ContentBind with in-generation watermarking is a direction for future work. We also briefly discuss ContentBind-FE as a potential defense, with its full evaluation left to future work (CW #3, Q4).
  2. Experimental details: we state the test-set sizes in §4.1 (L. 254), and add 95% confidence intervals for Table 4 with a note that training-seed variance is not evaluated, in §5.1 (L. 413) and the Table 4 caption (L. 378) (CW #2).
  3. Table 1 (L. 270): we add the bit accuracy of genuine watermarked and unwatermarked images as reference columns (Q1).
  4. Presentation: we increase the font size of the appendix tables (Tables 7–11), and define p_r after Eq. 6 in §3.2 (L. 204) (CW #5, CW #6).

[CW #1] Older post-hoc schemes. We thank the reviewer for pointing this out. This work started from the idea that EraseForge can forge watermarks more effectively than WMCopier (Dong et al., 2025). Our main comparison is therefore with WMCopier, and we use the same datasets and watermarking schemes as the WMCopier paper. To show that ContentBind is an effective defense against WMForger (Souček et al., 2025b), we followed the WMForger setup and evaluated on CIN, MBRS and VideoSeal (Table 5).

We agree that evaluating EraseForge on more recent post-hoc watermarking methods is valuable. We therefore ran EraseForge on VideoSeal (Fernandez et al., 2024; 96 bits), with one fixed message and all 4,911 test images:

VideoSeal-96Bit accuracyPSNR
Unwatermarked images50.3%–
Genuine watermarked images97.5%53.3 dB
Forged by EraseForge, N=5,000 (with post-forgery refinement)92.9% (94.4%)26.6 dB (30.7 dB)

With 5,000 samples, EraseForge forges VideoSeal with 92.9% bit accuracy (94.4% with post-forgery refinement). A recent watermarking method such as VideoSeal is therefore not robust to EraseForge. Given the limited rebuttal period, this is the only such experiment we could complete. We consider evaluating EraseForge on other recent post-hoc watermarking techniques a valuable next step for our work. As it is a single data point, we do not plan to add it to the paper or the appendix, but we hope it demonstrates that more recent watermarking techniques are not robust to EraseForge.

[CW #2] Test-set size and variance. We thank the reviewer for pointing this out. All results use four test sets: MS-COCO (1,711 images), CelebA-HQ (1,000), ImageNet (1,200) and DiffusionDB (1,000), 4,911 images in total. We now state these sizes in the experimental setup (§4.1, L. 254).

We quantified two sources of variance for the SeedBind results in Table 4:

  • Test images. The 95% confidence interval of the mean is ±0.44–0.63 points of bit accuracy and ±0.09–0.30 dB of PSNR in every cell.
  • Forgery sampling. Re-running the forgery for all 12 cells from the same trained estimators with fresh sampling noise changes the mean bit accuracy by at most 0.81 points and the PSNR by at most 0.02 dB.

Both are far smaller than the differences on which our conclusions rest (e.g. ≈53% under SeedBind vs. 99% without a defense). We did not retrain the estimators with multiple seeds, because each training run takes about 13 hours on an 8-GPU node. In the revised paper, we report these confidence intervals in §5.1 (L. 413) and the Table 4 caption (L. 378), and note that training-seed variance is not evaluated.

[CW #3] Is ContentBind robust against EraseForge? We thank the reviewer for raising this excellent question. Under ContentBind, the valid message h(φ(x)) is a deterministic function of the image content, and EraseForge conditions on that content, so it could in principle learn the binding. We therefore trained EraseForge directly against ContentBind, with up to 5,000 samples, under the same protocol as our other experiments. Bit accuracy is measured against each verifier's reference on all 4,911 test images; values in parentheses include post-forgery refinement.

SettingForged bit accuracyUnwatermarked images
VideoSeal-96, N=5k, single fixed message (no defense)92.9% (94.4%)50.3%
VideoSeal-96, N=5k, ContentBind52.5% (53.0%)50.6%
HiDDeN-48, N=1k, single fixed message (no defense)99.2%55.3%
HiDDeN-48, N=1k, ContentBind53.1% (54.2%)49.0%

EraseForge does not forge ContentBind. Without the defense, it forges both watermarks with more than 92% bit accuracy. Under ContentBind, its forgeries stay at 53%, close to the level of unwatermarked images.

We acknowledge the limits of this evaluation, and state them in the Limitations section (Appendix E, L. 1342):

  • Within the rebuttal period, we could run this experiment with up to N=5,000 samples, consistent with our focus on attackers with limited samples.
  • With a much larger number of samples, EraseForge might learn the content binding and break ContentBind.

We list this exploration as future work. In the meantime, we propose ContentBind-FE as a potential defense against such an attacker, described below. We briefly discuss it in the Limitations section (Appendix E, L. 1344) and leave its full evaluation to future work.

ContentBind-FE. The plain ContentBind message is a fixed linear function of public image features, sign(P·φ(x)), so an attacker with enough data could in principle learn it. ContentBind-FE replaces this hash with a keyed pseudorandom function, m = HMAC_K(Q(φ(x))), where Q quantises the DINOv2 features to 127 sign bits and K is a secret key. Without K, the message is pseudorandom and cannot be predicted from the image content. Because a PRF output changes completely when a single input bit flips, we make it tolerant to small feature changes, such as those caused by watermark embedding or JPEG compression, with a code-offset secure sketch (BCH(127,15), correcting up to 27 bit errors). The sketch's helper data (112 bits per image) is stored by the verifier.

[CW #4] Usefulness of the defenses if ContentBind is broken by EraseForge. Please see our response to CW #3. With up to 5,000 samples, EraseForge does not forge ContentBind: its forgeries stay at about 53% bit accuracy, close to unwatermarked images, compared with more than 92% without the defense. ContentBind therefore withstands both residual copying (WMForger, Table 5) and EraseForge in the limited-sample setting of our threat model, which also covers the vulnerability of SeedBind to WMForger. The limits of this evaluation are stated in Appendix E (L. 1342).

[CW #5] Figure/table readability. We thank the reviewer for pointing this out. We did not reduce the font size intentionally and did not modify the template. The wide result tables in the main text are scaled to fit the text width, which reduces their apparent font size. Because all of their columns are needed to compare the methods, training sizes and datasets side by side, we are unfortunately unable to enlarge them further. We have, however, increased the font size of the appendix tables (Tables 7–11) in the new version of the paper.

[CW #6] Undefined symbol p_r. We thank the reviewer for pointing this out. In Eq. 6, p_r denotes the distribution of natural (watermark-free) images. We have added this definition after Eq. 6 in §3.2 (L. 204).

Reviewer_P9grOpenReview ↗
Rating
4(+1)
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes EraseForge, an image watermark forgery attack that uses only collected watermarked images, without access to the target watermarking algorithm or detection API. It constructs approximate training pairs through watermark removal and image refinement, trains a conditional diffusion model to learn watermark residuals, and adds generated residuals to new images. Experiments across four watermarking schemes and four datasets show good data efficiency and high bit accuracy under the tested multi-message defense. The authors also propose SeedBind and ContentBind, two defenses that check internal message consistency and consistency between the message and image content, respectively.

Critical strengths
  1. A well-motivated attack pipeline. Removal-based training pairs allow an attacker to learn watermark residuals without access to the original clean images or the target detection API. Conditioning residual generation on the image provides a clear rationale for preserving content while reproducing the watermark signal. The residual-versus-full-image ablation supports this design choice.

  2. Meaningful empirical attack results. EraseForge achieves high bit accuracy on several schemes with 1,000 training samples. Under a 100-message defense, it exceeds 91% bit accuracy with 20,000 training samples, substantially outperforming the corresponding WMCopier configuration. These results demonstrate forgery capabilities beyond the baseline and are the main reason for my positive recommendation.

Critical weaknesses
  1. The defenses are not fully evaluated under their actual verification rules. Tables 4 and 5 show substantially reduced forged bit accuracy, but Appendix A.3 gives only a general definition relative to a target message. For SeedBind, failure to recover the original message does not necessarily imply that the decoded message violates the seed–hash consistency rule. For ContentBind, the relevant comparison is with the content hash recomputed from the received image. The reference messages and their relationship to the actual acceptance rules therefore need clarification.

  2. The paper also does not jointly report acceptance rates for genuine watermarked, unwatermarked, and forged images under the new verifiers. Appendix D.3 acknowledges possible false rejections under ContentBind, including sensitivity to image edits and the need for feature stability under watermark embedding itself, but does not quantify these effects. Since the defenses are a main contribution, it matters whether reduced forgery acceptance is achieved while preserving normal verification. This is a potentially addressable evaluation gap rather than evidence that the defenses are ineffective.

Questions for authors
  1. Clarification: What reference messages are used to compute bit accuracy in Tables 4 and 5? How are these measurements related to the acceptance decisions of the corresponding consistency checks? Please specify the acceptance thresholds and error tolerances.

  2. Defense validation: Under the complete verification rules, what are the acceptance rates for genuine watermarked, unwatermarked, and forged images? For ContentBind, how does genuine-image acceptance change after common transformations such as JPEG compression and resizing? These results could affect my assessment of the defense’s usability.

  3. Method attribution: Table 7 supports residual modeling over full-image modeling. What evidence helps distinguish the contribution of conditional diffusion from that of residual prediction itself? If available, a comparison with a direct residual predictor trained on the same approximate pairs would help clarify this point.

5 comments

We sincerely thank the reviewer for the positive assessment and for recognising the strengths of our work:

  • A well-motivated attack pipeline. Removal-generated training pairs let the attacker learn the watermark residual without access to the original clean images or the detection API. Conditioning residual generation on the image preserves content while reproducing the watermark signal. The residual-versus-full-image ablation (Table 8) supports this design choice.
  • Meaningful empirical results. EraseForge achieves high bit accuracy on several watermarking schemes with only 1,000 training samples. Under the 100-message defense it exceeds 91% bit accuracy with 20,000 samples, substantially outperforming WMCopier in the corresponding configuration.

We also thank the reviewer for the careful questions on our defenses. Before answering them individually, we would like to clarify two points about our evaluation protocol, since they underlie all of our answers.

Summary

Section, table and line numbers below refer to the revised manuscript; all changes are marked in blue.

  1. Evaluation protocol. Following WMCopier (Dong et al., 2025), we evaluate forgery with two metrics: forged bit accuracy, which measures how much of a valid watermark message is recovered from the forged image, and PSNR, which measures the quality of the forged image. Forged bit accuracy above 90% indicates a successful forgery, and forged bit accuracy around 50% (near-random, in the single-message setting) indicates an unsuccessful one. We do not adopt a specific binary decision rule for whether a watermark is present, since the appropriate rule depends on the deployment (CW #1).
  2. The defenses do not modify the underlying watermark. SeedBind and ContentBind leave the watermark's encoder and decoder unchanged. They only determine which message is embedded, and they add a consistency check on the decoded message at verification. They therefore do not degrade the watermark's performance: both bit recovery and image quality are unchanged (CW #2, Q2).

Based on the reviewer's feedback, we have made the following major changes:

  1. Verification rules: we state the verification rule and the reference message of each defense precisely, in §5.1 (L. 395, L. 446), in the captions of Tables 4 and 5 (L. 378, L. 432) and in Appendix A.3 (L. 932) (resolves CW #1 and Q1).
  2. Impact on the underlying watermark: a new Appendix D.3 (L. 1230–1269) shows that SeedBind and ContentBind do not affect the watermark's bit recovery or image quality, and reports genuine, unwatermarked and forged images under each defense's verifier (resolves CW #2 and Q2).
  3. Conditional diffusion vs. residual prediction: following the reviewer's suggestion, a new ablation in Appendix B.5 (L. 1121–1148) compares conditional diffusion with a direct residual predictor trained on the same approximate pairs (resolves Q3).

[CW #1] The defenses are not fully evaluated under their actual verification rules. We thank the reviewer for this observation.

In this paper we use forged bit accuracy as the core metric for both attacks and defenses, and we intentionally do not commit to a single decision rule. The appropriate rule depends on the deployment. Examples include a fixed bit-accuracy threshold (e.g. 90% or 95%), exact message recovery with an error-correcting code, or a threshold tuned on a mix of watermarked and unwatermarked content. Bit accuracy is the fraction of decoded bits that agree with the reference the verifier checks. For a forged image, it directly measures how much of a valid watermark the attacker has implanted: higher forged bit accuracy means a stronger forgery, and lower means a stronger defense. Bit accuracy is also the quantity all such rules operate on, so a decrease in forged bit accuracy translates into a lower forgery success rate under any of them.

We agree, however, that the reference against which bits are compared must be stated precisely for the defenses, and Appendix A.3 did not do so.

  • SeedBind: the decoded hash bits are compared with the hash recomputed from the image's own decoded seed. A forgery carrying any self-consistent seed–hash pair would therefore score 100%. This is now stated in §5.1 (L. 395).
  • ContentBind: the decoded bits are compared with the content hash recomputed from the received image. This is now stated in §5.1 (L. 446).

A forgery is unsuccessful when its bit accuracy is indistinguishable from that of unwatermarked images under the same verifier. In the setting of Table 4 at N=1k, forged images score 53.2% under SeedBind, comparable to unwatermarked images (55.3%) and far below genuine watermarked ones (96.0%; see CW #2, table (b), and Table 13 in Appendix D.3).

In the revised paper, we state these references in Appendix A.3 (L. 932), in §5.1 (L. 395, L. 446) and in the captions of Tables 4 (L. 378) and 5 (L. 432).

[CW #2] Genuine, unwatermarked and forged results are not reported jointly; ContentBind's false rejections are not quantified. We thank the reviewer for this point. We agree that a defense is only useful if it reduces forgery while preserving verification of genuine images. We now report all three populations jointly, and we separate two effects.

SeedBind and ContentBind change only which message is embedded. The watermark encoder and decoder are unchanged. A defense can therefore affect genuine images in only two ways: through the watermark's bit recovery, or through the defense's own verification step. We measure each in turn. All results below use HiDDeN-48 (the Table-4 scheme) with all 4,911 test images, so both defenses are evaluated on the same watermark.

(a) Bit recovery does not depend on the message type. We embedded a random message, a SeedBind message (24 seed + 24 hash bits) and a ContentBind message on the same images. Bit accuracy is measured against the embedded message (Table 12 in Appendix D.3, L. 1242):

MessagenoneJPEG 90 / 70 / 50resize 0.75× / 0.5×blur σ=1crop 0.9brightness ×1.2
Random98.4%91.6 / 78.3 / 80.5%86.8 / 69.9%68.3%92.3%98.8%
SeedBind98.6%91.7 / 78.4 / 80.7%87.3 / 70.2%68.6%92.3%98.9%
ContentBind98.5%91.5 / 78.1 / 80.1%86.9 / 69.3%67.8%92.3%98.9%

The three message types are within 0.8 points of each other under every condition, and the watermark PSNR is identical (37.07 dB). The same holds on VideoSeal-96 (97.2 / 97.1 / 97.4% without distortion).

(b) Genuine, unwatermarked and forged images under each defense's verifier. Each verifier compares the decoded bits with a different reference, listed in the second column (Table 13 in Appendix D.3, L. 1258):

Defense (HiDDeN-48)Decoded bits compared withGenuine watermarkedUnwatermarkedForged by EraseForge, N=1k (with post-forgery refinement)
No defense (single fixed message)the fixed embedded message (48 bits)98.4%55.3%99.2%
SeedBindthe hash recomputed from the decoded seed (24 hash bits)96.0%55.3%53.2% (55.5%)
ContentBindthe hash recomputed from the received image (48 bits)93.7%49.0%53.1% (54.2%)

Both defenses reduce forged bit accuracy from 99.2% to about 53%, while genuine images stay above 93%.

Both tables are included in the revised paper as a new Appendix D.3 (L. 1230–1269). The feature-stability effects acknowledged in the original Appendix D.3 are now quantified in Appendix D.4 (L. 1285): watermark embedding changes 1.8% of the content-hash bits on VideoSeal and 5.0% on HiDDeN.

Q1 — Reference messages and their relation to acceptance decisions.

Reference messages. The bit accuracy in Tables 4 and 5 is the fraction of decoded bits that agree with the reference below. These references are now stated in the captions of Tables 4 (L. 378) and 5 (L. 432) and in Appendix A.3 (L. 932):

Table / columnEmbedded messageReference used for bit accuracyBits compared
Table 4, 100 messages (HiDDeN-48)one of 100 fixed 48-bit messages, drawn uniformly per imageall 100 messages; the score is the best match over the pool‡48
Table 4, SeedBind (HiDDeN-48)m = [m̂ ; g(m̂)]: a 24-bit random seed m̂ followed by 24 hash bits g(m̂) (SimHash)g(m̂′), recomputed from the decoded seed m̂′24 hash bits
Table 5, Randoma random messagethe embedded messageM
Table 5, SeedBindm = [m̂ ; g(m̂)], as in Table 4g(m̂′), recomputed from the decoded seed m̂′M − k hash bits
Table 5, ContentBindm = h(φ(x)) = sign(P·φ(x)) of the original image x (Eq. 12)h(φ(x′)), recomputed from the received image x′M

‡ This follows the multi-message defense of Dong et al. (2025) (WMCopier): the embedded message is drawn at random per image and not recorded, so the verifier checks whether the image carries any valid message in the pool. For genuine images the best match is almost always the embedded message. A forged image succeeds if it matches any pool message.

No stored message is needed for SeedBind or ContentBind: both verifiers recompute the reference from the received image.

Relation to acceptance decisions. As discussed in CW #1 and CW #2, SeedBind and ContentBind only choose which message is embedded; they rely on the underlying watermark's embedding and decoding and do not change its bit recovery (CW #2, table (a)). A deployed verifier accepts an image iff its bit accuracy against the reference above reaches a threshold τ. Tables 4 and 5 report the mean bit accuracy, which is the quantity any such rule operates on.

A benefit of this design is that the proposed defenses improve directly with the underlying watermarking technique: a scheme that embeds more message bits and is more robust to image operations yields stronger SeedBind and ContentBind verification.

Q2 — Genuine, unwatermarked and forged images under the complete verification rules. We thank the reviewer for this question. We understand the underlying concern: whether SeedBind and ContentBind degrade the watermark itself, in terms of image quality or bit accuracy. They do not. Both defenses only choose which message is embedded, and they leave the encoder and decoder of the underlying watermarking technique unchanged (CW #2). Consistent with the rest of the paper, we report bit accuracy against each verifier's reference (Q1), on HiDDeN-48 with all 4,911 test images:

  • Image quality is unchanged: the watermark PSNR is 37.07 dB for random, SeedBind and ContentBind messages alike (Appendix D.3, L. 1230).
  • Bit accuracy is unchanged: the three message types are within 0.8 points of each other without distortion and under JPEG compression, resizing, blur, cropping and brightness changes (CW #2, table (a); Table 12, L. 1242).
  • Genuine, unwatermarked and forged images (CW #2, table (b); Table 13, L. 1258): genuine images score 96.0% under SeedBind and 93.7% under ContentBind, against 55.3% and 49.0% for unwatermarked images. Forged images score 53.2% and 53.1%, compared with 99.2% without a defense.

Q3 — Conditional diffusion vs. a direct residual predictor. We trained a direct residual regressor with the identical UNet, the same approximate pairs, epochs, batch size, learning rate and EMA. It predicts the residual δ̂ = f(x) for every pixel in a single forward pass, trained with MSE on δ = x_w − x_r, and forges x + f(x). EraseForge instead samples δ from the learned conditional distribution p(δ | x). We compare the two on HiDDeN-48 at N=1,000, using all 4,911 test images (forged bit accuracy / PSNR):

SettingEraseForge (conditional diffusion)Direct residual regressorUnwatermarked images (bit accuracy)
single message (K=1)99.2% / 31.8 dB98.2% / 29.0 dB55.3%
10-message pool (K=10)81.6% / 32.0 dB73.2% / 27.6 dB60.0%
100-message pool (K=100)69.6% / 31.4 dB71.7% / 27.3 dB70.0%

With a single message, residual prediction alone suffices. With multiple messages, the conditional generative estimator is clearly stronger: +8.4 points of bit accuracy at K=10, at 4.4 dB higher PSNR. At K=100 and N=1k, neither method succeeds (both score like unwatermarked images); EraseForge needs N=20k there (Table 3). So both the residual formulation (Table 8) and conditional diffusion (this ablation) contribute. We have added this comparison as a new ablation study, Appendix B.5 (Table 10, L. 1121–1148), and refer to it from the residual-modeling ablation in Appendix B.2 (L. 1011).

Comments on the paper

1 comment
AuthorsOpenReview ↗

Thank you for the constructive reviews and engagement

Summary of the rebuttal and revisions

We thank all reviewers and the AC for their time and constructive feedbacks. Reviewers PsbF and t5t3 have indicated that their concerns have been addressed and have raised their scores. We summarize the main points and the changes in the revised manuscript (all changes are marked in blue).

New experiments

  • EraseForge against ContentBind (PsbF, P9gr). Trained directly against ContentBind with up to 5,000 samples, EraseForge's forgeries stay at about 53% bit accuracy, close to unwatermarked images, compared with 92–99% without the defense.
  • EraseForge on a recent watermarking method (PsbF). With 5,000 samples, EraseForge forges VideoSeal (2024) with 92.9% bit accuracy (94.4% with post-forgery refinement).
  • Effect of the defenses on genuine images (P9gr). SeedBind and ContentBind do not change the watermark's bit recovery or image quality; we now report genuine, unwatermarked and forged images under each defense's verifier (Appendix D.3).
  • Conditional diffusion vs. direct residual regression (P9gr, t5t3). A regressor trained on the same pairs matches EraseForge for a single message but falls clearly short under multi-message pools (Appendix B.5).
  • Variance (PsbF). 95% confidence intervals of ±0.44–0.63 points of bit accuracy; repeated forgery runs differ by at most 0.81 points.

Main revisions

  • Precise verification rules and reference messages for both defenses (§5.1, Tables 4–5, Appendix A.3).
  • Explicit statement of EraseForge's novelty relative to WMForger and WMCopier (§1, §6, Appendix A.4).
  • Acknowledgement of prior content-authentication work and a comparison with our defenses (§5.1, §6, Appendix D.5).
  • Reference bit-accuracy columns in Table 1, test-set sizes, the definition of p_r, and an extended Limitations section, including ContentBind-FE as a direction for future work.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.