- Rating
- 2
- Confidence
- 2
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 3
Read review
Paper summary
This paper presents Obscrowd, a protection method against generative image editing by injecting a carefully crafted perturbation into group photographs and single portraits we want to protect. To craft such a perturbation, Obscrowd follows a teacher-student-based framework where the student learns to craft perturbation that reduces the cosine similarity value below a margin when added to the target image (implicitly guided by the teacher), even when a fixed family of transformations is applied (directly guided by the student loss). The output perturbation from the student model then serves as the starting point of the subsequent PGD-based refinement. The authors compare Obscrowd with existing anti-editing (PhotoGuard, EditShield) and identity-disrupting protection (FaceLock) works, showing that Obscrowd outperforms these works in terms of the protection gap, i.e., the gap on the cosine similarities from editing before and after protection.
Critical strengths
- The proposed Obscrowd looks lightweight enough for practical distribution settings, though computation would be a bottleneck.
Critical weaknesses
- I'm not fully convinced why we need to care about cosine similarity scores. In my opinion, just making the edited face easily detectable looks enough. As shown in Figs 4-6, the baseline protection methods already produce human-visible artifacts after editing, and when such edited images are misused by the adversary, one can easily detect such attempts through these visual artifacts. Of course, the adversary may try to remove such artifacts through image-level refinement after editing, but the authors did not consider such a case. As a result, this makes your method equivalent to just crafting adversarial examples that are robust to diffusion-based editing. I feel that the problem setting must be more clearly stated and well-justified but the current manuscript does not.
Questions for authors
-
Many recent commercial LLM services also support image editing (such as GPT-Image, Grok Imagine, Nano Banana by Gemini) and the attacker can use them without any significant effort. Though I appreciate the authors' effort on testing their method against open-source image editing methods, I think considering such a type of attackers is worth investigating as one of the possible realistic threats. Can Obscrowd also defend against such an attacker who exploits off-the-shelf commercial services?
-
I feel that the threshold choice at a specific FAR=0.01% is somewhat arbitrary. From my understanding, the decision of the FR model serves as the extent to which the protection is strong (lower FAR makes protection easier), and the desired protection level depends on the target scenario. For example, if the defender wishes to prevent the edited face from being misused at high-security thresholds, e.g., banking applications, it suffices to select lower FARs, e.g., FAR=0.001% or 0.0001%. On the other hand, if the defender wants to make the edited image get caught by FR similarity-based crawling, then FAR should be set higher, e.g., 1% or 0.1%. It would be nice if you could clearly justify your choice FAR=0.01%, and provide results on other FAR levels, e.g., 1%, 0.1%, 0.001%, and 0.0001%.
-
I don't think the per-face PGD is a genuine "control". You said per-face PGD excludes the "simulator", drawn from one of nine predefined transformation families (if I correctly understand). However, taking an expectation over such transformations is a well-established standard technique, EOT [AEIK18], in adversarial attacks, and it is quite straightforward for me to add such a technique in your setting. Thus, the baseline should be the PGD attack in accordance with Eq. (5), with zero/randomly initialized instead of one from the student model, the same setting mentioned in the second paragraph of Section 5.6 (Ablations & Robustness). At the end, it seems that the gain from employing the student looks relatively marginal compared to adopting the "simulator". Could you comment on this situation, and clarify how novel your "simulator" is compared to existing EOT-based approaches?
[AEIK18] Athalye, A., Engstrom, L., Ilyas, A., & Kwok, K. (2018, July). Synthesizing robust adversarial examples. ICML 2018.
- How robust Obscrowd is against FR models with adversarial training?
5 comments
Response to Reviewer nUSy (2/3)
Q1. Commercial editors
Commercial services add server-side moderation, account-level accountability and logging. These do not prevent every misuse, but they raise the cost of abuse in a way that local models do not. They do no content moderation, no usage logging, no rate limits and no terms of service, and they can be fine-tuned or scripted to process images at scale. Therefore We evaluated open-weight editors run locally (SD, SDXL, FLUX), On two editors absent from training and from the simulator, SDXL Img2Img and FLUX.1-schnell, the gap is +0.190 / +0.238 and +0.337 / +0.430 (single / group, Table 26). A service that regenerates the face may also erase identity from the unprotected image, which is why we always report the matched control.
Q2. FAR choice and other levels
We headline FAR 1% for three reasons:
- It fits the threat. Crawlers and face search favor recall, the setting you place at 1% or 0.1%.
- It is the hardest point for a defense: As you note, a lower FAR makes protection easier. Every Obscrowd rate rises from 1% to 0.1%.Even Headlining 0.1% would have flattered our scores.
- The thresholds do not depend on our method: We set them once from 44,850 impostor pairs among unprotected faces. The same thresholds score every method and the control.
Obscrowd, % (FaceNet / AdaFace-1 / AdaFace-2 / majority), unprotected control in brackets:
| set, attack | FAR 1% | FAR 0.1% |
|---|---|---|
| single, IP2P | 80 / 14 / 10 / 16 (9 / 2 / 2 / 2) | 97 / 42 / 27 / 44 (20 / 3 / 3 / 3) |
| group, IP2P | 86 / 23 / 19 / 26 (23 / 5 / 5 / 6) | 98 / 52 / 38 / 57 (36 / 10 / 8 / 10) |
We cannot estimate FAR 0.001% or 0.0001% from 44,850 pairs: about 0.45 impostor pairs would fall above a 10⁻⁵ threshold. Thresholds only rise as FAR falls, so the non-match rates at any lower FAR are at least the 0.1% values.
Q3. Per-face PGD, the student, and the simulator vs EOT
Per-face PGD
We clarify that per-face PGD was included as a negative control to represent conventional adversarial attacks on face recognition (optimizing directly on clean faces without modeling the downstream generative editing pipeline). Its large deficit (+0.225 behind Obscrowd on multi; +0.242 on solo) proves that standard adversarial face perturbations are thoroughly erased by generative editors.
The student
While it is not the main source of strength, the student initialization contributes to an additional consistent gain. For group photographs, under the same simulator at K = 30, the student achieves +0.391, compared with +0.318 for zero initialization and +0.310 for random initialization. At K = 50, the student retains an advantage (+0.370 vs. +0.293 and +0.302, respectively). We therefore do not attribute the entire improvement to the student; rather, the simulator and learned initialization serve complementary roles, with the latter providing a measurable benefit even when the optimizer has access to the same simulator.
The simulator vs EOT
We follow EOT's sampling rule (Athalye et al., 2018): draw one transformation per step and compute the gradient through it. We make no novelty claim for this rule. But our contribution lies in how it is applied:
| EOT (Athalye et al., 2018) | Obscrowd | |
|---|---|---|
| Sampling rule | one draw per step | same |
| Distribution | rotation, rescaling, translation, lighting, noise; 3D rendering | stochastic diffusion edits: SDEdit at t = 200/400/600 with fresh noise per draw, text-conditioned SDEdit, VAE round-trip; plus pixel noise |
| Objective | targeted misclassification of an ImageNet classifier | hinge on identity similarity for every face, three recognizers |
| Scope | one object | the whole photo: each draw edits all faces together, one soft-masked δ covers them all (masks overlap on 108 of 149 group photos) |
| Backward pass | through the transformation | SDEdit U-Net noise estimate held fixed (BPDA, Athalye, Carlini & Wagner, 2018) |
The EOT based protection methods we compare against also differ from Obscrowd. In their released code, EditShield applies EOT over crop, blur, and resize to shift the editor's image embedding, without an identity objective. FaceLock targets identity using a single fixed VAE encode–decode pass on one face, without transformation sampling.
The choice of transformations matters far more than the sampling. Averaging three draws per step adds +0.012 at matched perturbation density (p = 0.081). Adding the editing surrogates to a transformation-free optimizer adds +0.18 to +0.20, measured with a simulator that held only the diffusion surrogates and pixel noise. Against FaceLock rerun at our L∞ over the whole image, Obscrowd leads by +0.183 [+0.174, +0.192] on 484 of 500 portraits, scored by a recognizer neither method optimized against (Table 21).
Response to Reviewer nUSy (3/3)
Q4. Robustness against FR models with adversarial techniques
We evaluated three IR50-ArcFace recognizers from RobFR, sharing the same backbone and training data: a standard model, a PGD adversarially trained model, and a TRADES model. None was used during Obscrowd's optimization. At FAR 1% with K=10:
Obscrowd successfully protects faces against normal recognition models, even ones it has never seen during optimization. However, adversarially trained models can largely overcome this protection. We acknowledge this limitation. But these robust models also perform much worse at recognizing genuine faces, making them less practical in the tested setting.
| standard | PGD-AT | TRADES | |
|---|---|---|---|
| group, VAE | +0.661 · 88 / 0 | +0.046 · 0 / 0 | +0.022 · 1 / 0 |
| group, IP2P | +0.380 · 94 / 23 | +0.018 · 3 / 4 | +0.009 · 10 / 8 |
| single, IP2P | +0.417 · 89 / 6 | +0.041 · 3 / 1 | +0.024 · 19 / 5 |
- Against the standard recognizer, Obscrowd prevents recognition for 64–94% of protected faces,
- Against PGD adversarial training, protection drops substantially, with only 0–3% of protected faces becoming unrecognized.
- Against TRADES, protection is also reduced, with 0–19% of protected faces becoming unrecognized.
This demonstrates that adversarial training can substantially weaken Obscrowd's protection. However, there is an important trade-off: at the same operating point, the PGD-AT and TRADES recognizers correctly recognize only 26% and 72% of genuine LFW pairs from different photographs, respectively, compared with 98-99.5% for the recognizers in our evaluation.
Thus, adversarially trained recognizers can defeat much of Obscrowd's protection, but they also sacrifice considerable genuine-pair recognition performance.
Important to note that, None of the methods we compare against reports this test. FaceLock optimizes and evaluates with the same single recognizer, and PhotoGuard and EditShield use no recognizer. The limitation is shared by the class: Fawkes reports 64% protection against a strongly robust tracker (Shan et al., 2020), and Radiya-Dixit et al. (2022) show that a trainer who fine-tunes on the perturbations breaks Fawkes and LowKey.
Response to Reviewer nUSy (1/3)
Weakness
Thank you for the review. One notable point is that our operating points are FAR = 0.01 and 0.001, i.e. 1% and 0.1%, not 0.01%. The paper writes FAR as a fraction; If needed the revision can use percentages.
Why cosine similarity rather than visible artifacts
We are targeting automatic re-identification systems. A face search engine or crawler ingests the face and relinks back to the original person, where no human looks at the image, so visible artifacts doesn’t stop the link.Cosine similarity is the quantity those systems threshold.
Our data show that visible damage and recognizability are largely independent:
PhotoGuard causes the most visible damage among the baselines (face LPIPS 0.156 single / 0.412 group, Table 20). After InstructPix2Pix, the calibrated 2-of-3 majority still rejects only 1% of its single-portrait faces at FAR 1%, against 2% with no protection.
FaceLock and EditShield are close to invisible (face LPIPS 0.033–0.060), and their edited outputs stay close to unprotected edits (edit-LPIPS 0.090–0.128). There is no artifact to detect. When the edit succeeds, only 4–19% of Obscrowd faces remain verifiable, against 84–100% for FaceLock and per-face PGD (Table 3).
Obscrowd removes identity because it optimizes the quantity recognizers use: it minimizes recognizer similarity directly, through simulated edits, on the face pixels. At similar or lower face LPIPS than PhotoGuard (0.144 vs 0.156 single, 0.216 vs 0.412 group), the same calibrated majority rejects 16% of Obscrowd's single-portrait faces after InstructPix2Pix (44% at FAR 0.1%), against PhotoGuard's 1%.
A detector that flags an image as edited also does not stop a search index from linking the face to the person.
Artifact removal after editing
We ran tests where the adversary edits the protected group photo with InstructPix2Pix, then cleans the edited output with JPEG 75, a Gaussian denoiser or DiffPure. The unprotected control goes through the same process, on 638 faces, with a 1% FAR threshold and 2 of 3 majority recognizer voting.
Cleaning the edited image restores no identity. DiffPure damages both images and drops the control from 0.651 to 0.434. Here an attacker is only damaging the very thing they’re trying to recover. We have not tested purifiers designed against our perturbation, and Our Section 6 (Limitations) will state this in the revision.
"Equivalent to adversarial examples robust to diffusion editing"
Obscrowd is an adversarial perturbation against recognizers, as are FaceLock and per-face PGD, and we do not claim a new class of attack. Our contribution is the multi-face setting and how we solve it.
Shared photos often show several people. FaceLock's own paper names multi-person images as an open challenge, IDProtector protects a single face by design, and a whole-image perturbation spends about 91% of its budget off the faces in a typical group photo. Obscrowd places one bounded perturbation on all detected faces with soft masks and optimizes them jointly, with no cap on face count. This costs 4.2× less compute than protecting each face separately, at no measurable loss (paired −0.0009 [−0.005, +0.004], 149 photos).
On group photos (1,373 faces), Obscrowd has the largest gap of all compared methods under VAE, JPEG and InstructPix2Pix (IP2P: +0.375, vs PhotoGuard +0.232, per-face PGD +0.190, EditShield +0.029, FaceLock +0.008)