acceptodds
Under review as a conference paper at ICLR 2027

SourceShield: Source-Branch Adversarial Disruption for Inversion-Free Image Editing

Abstract

Text-guided image editing enables controllable visual content generation, but also introduces potential risks of misuse. Adversarial disruptions can mitigate such risks by slightly perturbing the input image. However, existing disruption methods have been limited to defending against training-based or inversion-based image editing, leaving the more efficient, inversion-free paradigm unexplored. In this paper, we identify that existing methods struggle to generalize to this paradigm because they overlook the role of the editing trajectory. As a result, early-stage disruptions may be attenuated by later solver updates, and output-stage disruptions can only capture the final disruption effect. To address these limitations, we propose SourceShield, the first disruption method against inversion-free image editing that disrupts the editing trajectory in the source branch. In particular, SourceShield does not choose the target branch due to its target-prompt-specific nature and slow optimization. Specifically, SourceShield disrupts the sum of source-conditioned velocity terms across solver time steps, to maximize the velocity differences between source and target branches. Experimental results demonstrate that SourceShield largely improves existing disruptions under unseen prompts, with 41.5% higher FID and 115.1% lower ImageReward. Additional results show its superior transferability to unseen models, resilience to countermeasures, and imperceptibility of perturbations.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Inversion-free image editing, adversarial disruption, unauthorized image editing, diffusion models, rectified flow.

Reviews

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

This paper studies protective perturbations against inversion-free text-guided image editing such as FlowEdit. It argues that existing protections ignore the editing trajectory, so their perturbations are either attenuated by later solver steps or act only on the final output, and proposes SourceShield, which maximizes the norm of the weighted sum of source-branch velocities over solver timesteps without knowing the target prompt and uses chunk-wise VJPs to reduce memory. Experiments optimize perturbations on SD3 and DreamShaper (DS) for 127 images and cover unseen prompts, cross-model transfer, and preprocessing.

Critical strengths

S1. The source-branch objective needs no target prompt, which the protector cannot know, and is memory-efficient to optimize. Because the Jacobian is additive over timesteps, the chunk-wise VJP cuts peak memory from 67.23 GB to 27.28 GB while per-image time only rises from 8.4 to 10.1 minutes.

S2. The white-box results on SD3 are strong. On unseen prompt pairs the average FID is 226.4 against 128.9 for the strongest baseline, and ImageReward (IR) is −0.47 against the best baseline's 0.90. Switching from maximization to minimization drops FID from 241.3 to 111.3, so the direction of the objective matters.

Critical weaknesses

W1. The persistent-disruption explanation is supported neither by the derivation nor by Fig. 2(b) Sec. 4.2 argues that since AsrcA^{src} is subtracted in Eq. (6), amplifying it persistently perturbs the velocity difference. But the target branch sees the same perturbation. By Eq. (2) and xtTedit=xinx^{edit}_{t_T}=x^{in}, the target and source variables coincide at the first step, and if both velocities shift in the same direction their difference need not grow. In Fig. 2(b), SourceShield's DiΔD^\Delta_i stays around 0.9 to 1.7 for i≤23i \le 23, roughly at or below the baselines, and rises sharply only from i=27i = 27 onward, reaching about 12.5 at the end. Since the metric is normalized by the clean ∥vΔ∥\|v^\Delta\|, the late rise may partly reflect a shrinking denominator. The Step-Deviation variant in Table 5 changes two things at once (per-step vs. accumulated, deviation vs. norm), so it cannot isolate the effect of accumulation. Yet Secs. 1, 4.2 and 6 all rely on persistent disruption to explain why the method works.

W2. The premise that existing methods ignore the editing trajectory rests on a questionable categorization of prior work Like the source-branch objective, AdvDM [r1] and the SDS method of Xue et al. (2024) query the denoiser on noised versions of the protected image, need no target prompt, and compute gradients per timestep. They differ mainly in the objective built from these outputs and in how the gradient is computed. Yet the paper classifies Xue et al. (2024) as optimizing the final edited output (Sec. 1), does not cite AdvDM, and compares with neither. Output-stage methods are excluded entirely on the basis of Fig. 3, where Sec. 3.2 names PhotoGuard while the legend says DiffusionGuard, an early-stage method, and the paper does not say whether PhotoGuard's encoder or diffusion attack was used. Sec. 1 also states that such methods are "in principle not able to model the accumulated disruption effects", but a terminal loss backpropagated through the full editing process already accounts for every step's velocity difference, at a higher computational cost.

[r1] Adversarial Example Does Good: Preventing Painting Imitation from Diffusion Models via Adversarial Examples. ICML 2023.

Questions for authors
  1. According to App. D.3, the seed is fixed to 42 during optimization, and clean and protected images are edited with the same inference seed under default settings. The public FlowEdit configuration also defaults to seed 42. Does editing reuse the per-step noise realizations from optimization? If you have results with independent seeds, do they match Table 1?
  2. What are IR and CLIP-T for unprotected images and for random noise with the same budget? Under transfer to SD3 and FLUX, all methods have IR between 1.11 and 1.33, and DS→SD3 gives an FID of 86.7 against 81.3 to 84.9 for the baselines. On SD3, DiffPure lowers FID from 243.3 (Table 1, Prompt A) to 106.1 (Fig. 6), leaving PSNR and IR only 0.1 and 0.05 ahead of the strongest baseline. Without such a reference or confidence intervals, how do these results support the "superior transferability" and "resilience" claimed in the abstract? What parameters were used for the three preprocessing operations?
  3. The editor runs the editing model (Sec. 2.2), so the number of solver steps, the starting step and the guidance scales are theirs to choose. Fig. 7 gives FIDs of 97.5 and 156.0 when only the first or the last 10 steps are perturbed. How well does the protection hold when these settings change, or when the source prompt is shorter or more generic? Which editing method is used on DS, and if it is the consistency-model-based InfEdit, how is SsrcS^{src} defined?
  4. The four baselines were designed for instruction-based editing, personalization and inpainting. How were they adapted to SD3 and DS? EditShield and VAC-LE perturb the VAE latent, which enters every step. Do they also count as early-stage disruptions that Fig. 2 describes as attenuated by later steps? If the input is encoded with the posterior mean, as in the official FlowEdit code, does VAC-LE, which targets the posterior variance, remain effective?
  5. Widely used open-source editors such as FLUX.1 Kontext and Qwen-Image-Edit are instruction-based and have no source branch. Does the perturbation transfer to these models?
  6. Minor points. The 41.5% and 115.1% in the abstract would be better reported as absolute differences, since IR crosses zero, and a single average hides that the FID gains on SD3 and DS (about 76% and 6%) differ greatly. The FID in Table 1 is computed on only 127 images per group, far fewer than the Inception feature dimension, so its estimate is unreliable and needs support from the per-image metrics before it serves as the headline result. All methods share the ϵ=16/255\epsilon=16/255 budget, and a PSNR of 28.60 vs. 28.40 in Table 3 does not support imperceptibility as a contribution. The full set in Fig. 7 has many more steps than the 10-step windows, so coverage and step count are confounded. I could not find the code. Figs. 9 and 10 are very blurry, Eqs. (1) and (9) omit the VAE encoder, the caption of Fig. 1 contains an incomplete sentence, and Table 5 and Fig. 5 contain typos.
Reviewer_Fb1ZOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes SourceShield, an adversarial protection method for inversion-free image editing. The method maximizes the norm of accumulated source-conditioned velocities across editing timesteps. It requires a source description but does not require the future target editing prompt. Since the source states can be constructed directly from the input image, the method avoids backpropagation through the target editing trajectory. The authors also introduce a two-stage, chunk-wise gradient computation to reduce memory usage. Experiments cover unseen prompts, cross-model transfer, and several preprocessing countermeasures.

Critical strengths
  1. The choice of the source branch is well motivated from a computational perspective. It avoids dependence on the unknown target prompt and allows velocity evaluations at different timesteps without unrolling the target trajectory.

  2. The reported results are encouraging, particularly on SD3. SourceShield achieves the best average results in 9 of 10 model–metric cases in Table 1 and 16 of 20 transfer cases in Table 2. The evaluation includes both DiT- and U-Net-based backbones.

  3. The chunk-wise gradient computation provides a useful memory–runtime trade-off. Table 4 reports a reduction in peak memory from 67.23 GB to 27.28 GB, with runtime increasing from 8.4 to 10.1 minutes per image.

  4. The main comparisons use the same perturbation budget, number of optimization iterations, and seen-prompt split. Clean and protected inputs are evaluated with matched inference seeds.

Critical weaknesses
  1. The proposed objective is not sufficiently justified by the trajectory analysis. My main concern is the connection between the source-accumulation objective and the claimed disruption mechanism. Equation (6) is a decomposition of the editing updates, whereas Equation (11) maximizes the absolute norm of the source accumulation. It does not directly maximize the change from the clean accumulation, the source–target velocity difference, or the final output discrepancy. Using the state-space notation of Equation (6), the difference between protected and clean trajectories under matched prompts and noise satisfies: Δxt0edit=Δxin+ΔAtgt−ΔAsrc\Delta x^{\mathrm{edit}}_{t_0}=\Delta x^{\mathrm{in}}+\Delta A^{\mathrm{tgt}}-\Delta A^{\mathrm{src}}. Here, Δ\Delta denotes the protected quantity minus its clean counterpart. The target accumulation also changes with the input and may offset the change in the source accumulation. In addition, increasing ∣Ssrc(xadv)∣2|S^{\mathrm{src}}(x^{\mathrm{adv}})|_2 does not necessarily increase ∣Ssrc(xadv)−Ssrc(xin)∣2|S^{\mathrm{src}}(x^{\mathrm{adv}})-S^{\mathrm{src}}(x^{\mathrm{in}})|_2. Therefore, the decomposition does not by itself justify the claims that the objective maximizes source–target velocity differences or persistently disrupts the editing trajectory. The diagnostic experiments do not fully address this issue. Figure 2 reports normalized per-step velocity deviations. Their changes can reflect changes in either the numerator or denominator. Moreover, a decrease in local velocity deviation does not show that previously accumulated editing-state deviations have been removed. Step sizes and cancellation between updates also matter for the final result. Table 5 is useful, but its Step-Deviation baseline measures average per-step deviations. It does not test the cumulative-deviation objective above. The results support the proposed objective over the tested alternatives, but do not yet explain why maximizing the absolute accumulation is the appropriate choice. A general theoretical guarantee is not necessary here. However, the claimed trajectory mechanism is a central contribution of the paper and needs more direct experimental support.

  2. The comparison with output-stage attacks is unclear, and the argument used to exclude them is too strong. The introduction states that output-stage objectives are, in principle, unable to model accumulated disruption across solver timesteps. This is not generally correct. If a terminal loss is differentiated through the complete editor, its gradient includes the intermediate trajectory dependencies. Computational cost, truncated backpropagation, and dependence on a specific target prompt are relevant limitations, but they should be distinguished from an inability to account for the trajectory. There is also an inconsistency in the supporting experiment. Section 3.2 identifies the comparator in Figure 3 as PhotoGuard, while the figure legend says DiffusionGuard. Appendix D.3 describes the four main early-stage baselines but does not explain the PhotoGuard adaptation used in this experiment. The paper then relies on this comparison to exclude output-stage attacks from the main evaluation. This may be a labeling error, and I am not claiming that the baseline was implemented incorrectly. Nevertheless, the method identity and experimental protocol must be clear before this comparison can support the exclusion of an important class of alternatives. In particular, the paper should specify the attack objective, editing pipeline, differentiation horizon, prompt usage, and optimization budget.

I would reconsider my recommendation if the authors clarify the baseline comparison and provide targeted evidence supporting the source-accumulation objective. Simply weakening the claims would not fully resolve the concerns.

Questions for authors
  1. Could the authors compare Equation (11) with ∣Ssrc(xadv)−Ssrc(xin)∣2|S^{\mathrm{src}}(x^{\mathrm{adv}})-S^{\mathrm{src}}(x^{\mathrm{in}})|_2? Measuring the changes in both branch accumulations and their cancellation would also help establish whether the proposed explanation accounts for the observed improvement. Unnormalized velocity deviations and editing-state deviations would be more directly informative than the current ratios alone.

  2. Which baseline was evaluated in Figure 3? Please clarify its implementation and whether its gradients pass through the full editing trajectory or a truncated approximation. A clearly specified comparison under the held-out-prompt protocol, even on a limited subset if computationally necessary, would help resolve this concern.

  3. Figure 7 shows that the full timestep set outperforms the three tested ten-step windows, but it also uses more timestep evaluations per update. Does this advantage remain when matching total model evaluations or runtime against a sparse or sampled timestep alternative?

  4. Please specify how the DreamShaper implementation maps to the RF formulation, including the editor, prediction parameterization, accumulation weights, and active timestep interval. Also, are the same noise draws and other relevant random quantities reused between the two gradient-computation stages? These details are needed to assess the implementation; their omission does not establish that it is incorrect.

Reviewer_2SE5OpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper proposes the first image protection method against inversion-free image editing via adversarial perturbations. It identifies a research gap between existing methods for training- or inversion-based image editing and inversion-free image editing, and observes that existing methods overlook the editing trajectory. The paper introduces SourceShield, which directly targets the source-conditioned velocity accumulation along the editing trajectory to disrupt the editing process. The proposed method outperforms existing SoTA methods and shows better transferability to unseen editing models.

Critical strengths
  • The paper analyzes the limitations of prior methods and proposed a novel approach that directly targets editing trajectory in inversion-free image editing.
  • The proposed method significantly outperforms existing image protection methods in white-box settings.
Critical weaknesses
  • Insufficient justification of the objective: The method maximizes the norm of source-conditioned velocity accumulation, but it is unclear that the reason why this is more effective than directly maximizing its deviation from the clean one.
  • Limited generalizability: The proposed source-branch disruption is specific to FlowEdit-style inversion-free editing. Can it be generalized to inversion-based editing methods? If it is not possible to directly adapt for inversion-based editing methods, at least it should be evaluated on there, which can show true black-box transferability. It seems that it is only evaluated on models that share the same FlowEdit-based editing mechanisms, and SD3 and FLUX are both flow-based Transformer models.
  • High optimization cost: In Table 4., the GPU memory usage is about 27GB and optimization time requires more than 10 min (K=11) which may not be practical in real-world applications. The paper should provide a more detailed analysis of the trade-off between computational cost and performance, including comparisons with existing methods.
  • Robustness evaluation: In Table 6., the robustness evaluation against purification methods is somehow limited. It only compares with Gaussian filtering, JPEG compression and DiffPure. It would be useful to include more recent and stronger purification methods, such as GrIDPure [a], for more comprehensive evaluation. Also robustness evaluation should consider not only the absolute performance after purification, but also how much the performance drops compared to the original performance. It seems that the strong results of SourceShield are partly due to its high white-box performance against other methods, rather than its robustness against purification.
  • Fairness of comparison: In the paper, the authors use 200 optimization iterations for all methods. However, DiffusionGuard officially uses 800 iterations, while AdvPaint uses 250 iterations by their official codebases. The authors said that they use the same iterations for the fair comparison, but I think simply using the same number of iterations is rather somehow unfair, as different methods have different convergence rates and computational costs. It would be better to compare the methods using their original configurations or under the same computational budget.
Questions for authors

See weaknesses

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.