Synthetic Prompt Injection Classification Dataset
— Technical Report

1. Introduction

Prompt injection is listed as the number-one vulnerability in the OWASP Large Language Model Top 10 (2025 edition). As LLM-powered applications proliferate — autonomous agents, RAG pipelines, chatbots embedded in enterprise workflows — the attack surface for malicious prompt manipulation grows correspondingly. Defenders need high-quality, labelled data to build and benchmark detection systems.

Yet publicly available prompt-injection datasets are scarce and often narrow in scope: they may cover only jailbreak-style attacks, lack benign counterexamples, or contain only a few hundred labelled instances. This dataset is an attempt to fill that gap with a diverse, well-annotated, openly licensed corpus that practitioners can use immediately to fine-tune classifiers, evaluate guardrails, or run red-teaming benchmarks.

The dataset is purely synthetic — every example was produced by parameterised templates executed in Python with no access to proprietary data. This makes the generation process fully reproducible and the data free of privacy concerns. The trade-off is that real-world adversarial creativity is not fully captured; see Section 6 for a detailed discussion of limitations.

2. Methodology

2.1 Generation Strategy

We used a template-first, parametric expansion approach. For each attack type, we hand-authored 25–40 distinct prompt skeletons containing one or more fill slots (e.g. {harmful_task}, {persona_name}, {data_type}). Each slot was populated from a curated vocabulary of 20–80 values. Slot values were drawn by seeded random sampling (seed = 42) to ensure full reproducibility.

Benign prompts were generated from 48 templates covering general Q&A, coding, writing, mathematics, travel, and business topics, again with parameterised fill slots to produce lexically distinct examples.

2.2 Quality Validation

Every generated example passed three validation checks before being retained:

1. Uniqueness: MD5 hash of the lowercased text field. Any collision was dropped. This ensures zero exact duplicates across all splits.
2. Field completeness: All six fields (id, text, label, attack_type, severity, explanation) must be non-null.
3. Enum validity: label must be one of {"benign", "injection"}; attack_type must be one of the 8 permitted values; severity must be in {0, 1, 2, 3}.

2.3 Split Construction

After deduplication, examples were randomly shuffled (seed = 42) and assigned to splits in a 70 / 15 / 15 ratio: train (1,794), validation (384), test (386). All three splits preserve approximately the same injection/benign ratio (~1.9:1) and similar attack-type distributions.

2.4 Format

The dataset is distributed in both JSONL and Parquet formats. Parquet is the primary format recommended for HuggingFace Hub consumption due to native columnar browsing support. Both formats are identical in content.

3. Attack Type Taxonomy

We define seven prompt injection attack types, each with a distinct mechanism and threat model:

4. Results & Dataset Statistics

4.1 Split Sizes

4.2 Attack Type Distribution (total)

4.3 Severity Distribution

5. Representative Examples

One curated example per attack type from the test split:

6. Limitations

• Template-bounded creativity. All injection examples were produced from hand-authored templates. Adversaries in the wild use more creative, compositional, and multilingual attack patterns not represented here. Models trained on this data may not generalise to novel attack phrasings.
• English-only. All examples are in English. Multilingual prompt injection attacks (cross-language overrides, transliterated jailbreaks) are out of scope.
• Static severity labels. Severity scores were assigned by the template author, not by empirical measurement against a live model. What is "medium" for one model may be "high" for another. Treat severity as a qualitative guide, not a calibrated metric.
• Class imbalance. Injection examples outnumber benign examples ~1.9:1. Train with class_weight="balanced" or equivalent to avoid precision bias toward the injection class.
• Explanation quality. Explanations are template-derived and may be less nuanced than human-authored annotations for edge cases. They should not be used as ground truth for explanation-oriented tasks.
• No adversarial rephrasing. We did not apply back-translation, paraphrase augmentation, or adversarial perturbation. A classifier trained on this data may be brittle to minor rephrasing of known attack patterns.

7. Intended Use Cases

• Binary classifier training: Fine-tune a text classifier (BERT, RoBERTa, DeBERTa) to detect injection vs. benign prompts. Use the label field.
• Multi-class attack-type classifier: Train a 7-way classifier to identify attack mechanism. Use attack_type on the injection-class subset only.
• Severity-weighted evaluation: Use severity as a regression target or evaluation weight to prioritise catching high-severity attacks.
• Guardrail benchmarking: Evaluate off-the-shelf prompt injection guardrails (LLM Guard, Rebuff, custom regex) against the labelled test split.
• LLM red-teaming: Mine the injection examples as seed inputs for a red-teaming pipeline. The explanation field helps researchers understand the attack vector being tested.
• Few-shot prompting: Use as demonstration examples in a few-shot injection-detection prompt for a larger LLM.

# Quick-start: load with 🤗 datasets
from datasets import load_dataset

ds = load_dataset("SalutefaceAAC/prompt-injection-classification")

# Binary classification (injection vs. benign)
train = ds["train"].map(lambda x: {"label_id": int(x["label"] == "injection")})

# Attack-type subset
injections = ds["train"].filter(lambda x: x["label"] == "injection")

# Severity-weighted sample
import random
high_severity = ds["train"].filter(lambda x: x["severity"] == 3)

8. References