- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This work proposes DirtyRAG, a query-blind poisoning attack against Retrieval-Augmented Generation (RAG). The proposed method aims to generate adversarial passages that can be retrieved without knowing the user's query while misleading the victim LLM toward attacker-desired answers.
The proposed method first generates adversarial passages using an LLM and then paraphrases them through embedding-aware beam search to maintain both semantic fluency and similarity to a target benign passage. It also introduces index perturbation to improve top-k packing, allowing adversarial passages to dominate retrieval results.
The authors further introduce RAGAttack Bench to evaluate retrieval success, end-to-end attack effectiveness, and robustness against defenses. The experiments cover three victim LLMs and five dense retrievers, including black-box transfer settings. With 128 injected adversarial passages, DirtyRAG achieves average accuracy drops exceeding 40 percentage points in most evaluated settings. The authors also demonstrate attack effectiveness with 10 or 20 injected passages and evaluate robustness against filtering and reranking defenses.
Critical strengths
- This work addresses an interesting problem of query-blind RAG poisoning and proposes a top-k packing strategy to improve attack effectiveness.
- The paper provides extensive experiments across different LLMs, retrievers, and retrieval settings, including black-box transfer evaluations.
Critical weaknesses
-
The motivation mischaracterizes previous query-dependent attacks. In Sections 1.1 and D.1, the authors argue that these attacks require real-time query surveillance and online document injection. However, PoisonedRAG can prepare and inject adversarial documents offline for predetermined target queries. Although Appendix A discusses the distinction between knowing a target query and a target passage, the main motivation overstates the practical limitations of existing attacks.
-
The experimental evaluation is limited. The main end-to-end evaluation uses only 100 selected query–passage pairs. The TrustRAG evaluation in Appendix G covers only 16 handpicked queries. After applying TrustRAG, only 1/16 queries are successfully steered, while only 1/16 are answered correctly. These results make it difficult to establish the broader claims about defense robustness and practical effectiveness.
Questions for authors
- Can the authors clarify why query-dependent attacks are assumed to require real-time query surveillance, given that attacks such as PoisonedRAG can prepare adversarial documents offline?
- How do the authors interpret the TrustRAG results in Appendix G, where both attack success and correct answering decrease to 1/16?
- How representative are the 100 selected query–passage pairs of broader RAG applications?
- Can the authors clarify how DirtyRAG performs when the exact stored benign passage is unavailable due to chunking, rewriting, or deduplication? Appendix E.2 discusses these cases, but no experimental results are provided.
5 comments
Initial Response to Reviewer 57F7 (2/2)
W2.2/Q2 - "The TrustRAG evaluation in Appendix G covers only 16 handpicked queries... How do the authors interpret the TrustRAG results in Appendix G, where both attack success and correct answering decrease to 1/16?" We concede the scale, and have replaced it with a 42-query, four-setting evaluation that shows the same trend.
The reviewer is correct that 16 hand-picked queries are too few to interpret, and that our original report lacked the clean-system references needed to read them. We have thus replaced Appendix G with all four {no attack, DirtyRAG} × {no defense, TrustRAG} settings on the 42 contextual queries (those the LLM answers wrong without retrieval) out of our 100 end-to-end ones (Granite top-10, Llama, 128 spoofs per passage as in Table 5).
| Setting | Correct | Passages to LLM | Spoofs to LLM | Golden passage to LLM | No passage left | ≥1 spoof to LLM |
|---|---|---|---|---|---|---|
| No attack, no defense | 24 | 10.0 | – | 33 | 0 | – |
| No attack, TrustRAG | 11 | 5.88 | – | 25 | 9 | – |
| DirtyRAG, no defense | 3 | 10.0 | 8.05 | 7 | 0 | 41 |
| DirtyRAG, TrustRAG | 5 | 0.64 | 0.10 | 1 | 37 | 2 |
(Passage columns are per-query averages; others are query counts out of 42.)
The larger scale shows the same trend as our original 16 queries, and now with the references to interpret it. With TrustRAG, only 2 of 42 queries have a spoof reaching the LLM. TrustRAG thus does stop DirtyRAG from steering, but by essentially disabling RAG (37 of 42 queries are left with no passage at all). Without the attack, TrustRAG leaves only 9 queries with no passage and keeps most golden passages (33 → 25 of 42). Yet, with DirtyRAG spoofs in the corpus, the golden passage survives for only 1 of 42 queries, as our spoofs are grounded to the benign passage's embedding and -means cannot separate the two (Appendix G). These results replace our original 16 hand-picked queries in Appendix G (Table 10).
We thus maintain that TrustRAG is not an effective defense against DirtyRAG. A RAG defense should let users still get correct answers under attack, yet accuracy under attack is 5/42 with TrustRAG versus 3/42 without — far from the 24/42 of an unattacked system. We have revised our paper to clarify that TrustRAG prevents targeted steering only by discarding nearly all retrieved passages, which does not restore a usable RAG system.
Q4 - "Can the authors clarify how DirtyRAG performs when the exact stored benign passage is unavailable due to chunking, rewriting, or deduplication?" Sure! DirtyRAG remains just as effective when the stored passage is chunked or rewritten.
To test this, we keep the same 128 spoofs per passage (crafted against the original passage), but replace the target benign passage in the knowledge bank with: its 2 or 3 sentence-boundary chunks (Chunk ×2, Chunk ×3), or an LLM-rewritten version (Rewrite, by Qwen3.5-35B). Each chunk or rewrite is ranked by its own similarity to the query.
| Knowledge base | Llama @10 | Llama @20 | Qwen @10 | Qwen @20 | Avg |
|---|---|---|---|---|---|
| Original | 81 → 32 | 81 → 31 | 83 → 37 | 83 → 30 | 82.0 → 32.5 |
| Chunk ×2 | 80 → 34 | 79 → 31 | 83 → 36 | 86 → 29 | 82.0 → 32.5 |
| Chunk ×3 | 78 → 35 | 81 → 31 | 80 → 35 | 83 → 28 | 80.5 → 32.3 |
| Rewrite | 75 → 34 | 77 → 30 | 82 → 34 | 81 → 28 | 78.8 → 31.5 |
(Values are accuracy (%) without → with DirtyRAG over 100 queries; Noisy setting, Granite retrieval. The Original row here and the one in our query-paraphrase experiment (Appendix H.5, Table 24) come from independent runs of the same configuration, hence the small differences.)
Across all variants, DirtyRAG still cuts accuracy from ~80% to ~32%, on par with the original knowledge base. We consider this to be much expected: DirtyRAG spoofs are grounded to (perturbations of) the original passage's embedding, and chunks or rewrites of the same content typically land in the same embedding neighborhood. As for deduplication, it removes duplicate copies of the benign passages rather than altering the passage itself, so the attacker's copy will still match the stored one, making no difference in its pipeline. We have added these results to Appendix E.2 (Table 8).
Thank you for the clarifications and additional experiments.
In the revised TrustRAG evaluation, accuracy decreases from 24/42 to 11/42 even without an attack. Could the authors clarify what causes this substantial degradation on clean queries?
Initial Response to Reviewer 57F7 (1/2)
W1/Q1 - "PoisonedRAG can prepare and inject adversarial documents offline for predetermined target queries... the main motivation overstates the practical limitations of existing attacks."PoisonedRAG uses the exact query for spoof crafting, which means it must either predict the exact user query or have real-time access to it.The reviewer is correct that PoisonedRAG technically can prepare its spoofs offline. However, it might be important to note that PoisonedRAG crafts spoofs upon the exact query it evaluates on (queries are sampled from the benchmark's testset, and each spoof is then prefixed with that exact query). This means PoisonedRAG must either have a way to predict the exact user query, craft spoofs, and inject them before the query arrives; or craft spoofs in real time, after the query lands.
We respectfully hold that this is a major limitation of existing works like PoisonedRAG: it is highly unlikely for an attacker to access user queries in real time, and it might be even more difficult to know the exact user query before that query is even initiated. DirtyRAG requires neither, as no query enters its pipeline, making query-blind a more realistic threat model.
That said, we agree our original description focused only on the real-time route, and we have since updated our wording in Section 1.1 and Appendix D.1 to cover both.
W2.1/Q3 - "How representative are the 100 selected query-passage pairs of broader RAG applications?"Surprisingly plenty: 100 pairs are in line with much prior art, and we are far more comprehensive on many other axes.We are glad you asked, since we actually discussed this exact matter in Appendix A. Surprisingly, 100 queries is in line with many prior end-to-end RAG attack evaluations: Corpus Poisoning conducts no end-to-end evaluation; PoisonedRAG and CPA-RAG both evaluate 100 target queries per dataset (10 per trial over 10 trials, without repeats); and CorruptRAG evaluates 100 queries per dataset. We do concede that some works feature more datasets than we do.
In our defense, the scale of queries is only one aspect of the evaluation scale. For our DirtyRAG, the same 100 queries are evaluated under 5 dense retrievers (Qwen, GritLM, Granite, Stella, GTE), 3 top-k settings (10, 25, 50), 3 reader LLMs (Llama-3.2-3B, Qwen3-4B, gpt-oss-20b), 2 settings (Controlled and Noisy), and 2 embedding verifiers (Granite and Qwen), i.e., 180 configurations per query (Tables 5 and 16–19); plus a reranker defense with 10/20 injected spoofs (Table 6) and 10 temperature-sampling runs (Tables 20–21).
Moreover, end-to-end evaluation is only one part of our results. Retrieval and defense evaluations do not require manual payload verification, so we run them at a much larger scale: RSR@k covers 1,400 multi-query query–passage pairs from
BeIR/hotpot_qaandBeIR/nqunder both white-box and black-box retrievers (Appendix H.1.2), and defense robustness uses 500 query–passage pairs fromBeIR/msmarco(Appendix H.1.5).To our knowledge, this is considerably more comprehensive than existing RAG attack evaluations, which mostly default to a small top-k (e.g., k=5 in PoisonedRAG).