README.md

metadata

license: unknown
task_categories:
  - text-classification
language:
  - en
tags:
  - security
  - sql-injection
  - cybersecurity
  - intrusion-detection
  - web-security
  - anomaly-detection
size_categories:
  - 100K<n<1M
pretty_name: VNU SQLi Detection Dataset (Branch 1 multiclass + Branch 2 anomaly)

VNU SQLi Detection Dataset

Data for a 3-branch AI-based SQL Injection detection system, combining 3+ public sources plus a small synthetic supplement:

• nhanh1_train.csv — multi-class labels for Branch 1 (supervised classifier). Labels go beyond binary normal/attack: each attack row is further tagged with its SQLi sub-technique.
• nhanh2_normal.csv + nhanh2_anomalous_eval.csv — benign-only pool (+ a held-out anomalous eval set) for Branch 2 (One-Class anomaly detection), using structural/statistical features instead of TF-IDF.

Labels (Branch 1 only — nhanh1_train.csv)

ID	Name	Meaning
0	normal	Benign query / request
1	union_based	UNION SELECT-style data exfiltration
2	error_based	Forces a DB error to leak data (extractvalue, updatexml, ...)
3	boolean_blind	True/false conditional inference (OR 1=1, ...) — also the catch-all bucket for attack rows that don't match a more specific rule (see Limitations)
4	time_blind	Response-delay inference (SLEEP(), WAITFOR DELAY, ...)

stacked (id 5, ; DROP TABLE ...) was REMOVED (16/7). It was 100% synthetic (363 templated payloads, no real source had a single example) and scored 100% recall across all 4 architectures compared — a sign the synthetic data was trivially separable, not a real quality signal. Disabled via branch1_supervised.balance.exclude_labels in configs/config.yaml until real stacked-query examples are available (e.g. from Docker-lab/sqlmap traffic). The generator (src/preprocessing/synthetic_stacked.py) is kept in the codebase for that future use.

Dataset Structure

This repository has 3 files, one for Branch 1 (supervised multiclass) and two for Branch 2 (anomaly detection, benign-only + a held-out eval set).

nhanh1_train.csv (Branch 1 — supervised multiclass)

Columns:

• id (int): row index
• query_raw (string): original text before canonicalization
• query_canonical (string): after URL/hex/CHAR() decoding, comment-marker detection, lowercasing
• has_comment_marker (0/1): whether a /* */ or -- comment was present in the original text
• label (int 0-4): class id, see table above
• label_name (string): human-readable class name
• source (string): originating dataset (see below)
• split (train/test): stratified split, test_size=0.2, random_state=42

Size: 67,796 rows — 54,236 train / 13,560 test.

Class balance: normal, union_based, boolean_blind, time_blind capped at 15,000 rows each (undersampled from a larger pool); error_based kept in full at 7,796 (smaller than the cap).

nhanh2_normal.csv / nhanh2_anomalous_eval.csv (Branch 2 — anomaly detection)

Branch 2 trains on 100% benign data (One-Class SVM / Isolation Forest) and does not use TF-IDF — it uses 4 structural/statistical features so it can generalize to attack syntax it has never seen:

• length (int): character length
• special_char_ratio (float): fraction of '";#-=<>()*|% characters
• sql_keyword_count (int): count of SQL keywords (select/union/sleep/...)
• entropy (float): Shannon entropy in bits/char

Plus query_raw, query_canonical, has_comment_marker, source, and (for nhanh2_normal.csv) split (train/test, test_size=0.2, seed=42).

• nhanh2_normal.csv: 91,935 rows (73,548 train / 18,387 test), the full benign pool from D1 + D3 (CSIC 2010) + D7 (SR-BH 2020), after the same content-based attack-signature filter used for Branch 1's normal class, deduplicated. Not capped — unlike Branch 1, more clean benign data only helps Branch 2 estimate the "safe zone" boundary.
• nhanh2_anomalous_eval.csv: 25,065 rows, D3's anomalous split, held out for evaluating false-positive rate / detection rate (not used for training). ⚠️ Covers multiple attack types (buffer overflow, XSS, path traversal, etc.), not just SQLi — its mean sql_keyword_count is actually lower than the benign pool's, so don't assume it isolates SQLi-detection performance specifically; see Limitations.

Source Datasets

Source tag	Origin	Notes
d1_sqliv3	SQLiV3 (~30.9K rows, binary-labeled), originally distributed via Kaggle	Accessed via a public GitHub mirror (nidnogg/sqliv5-dataset)
d4_payloadbox	payload-box/sql-injection-payload-list	Small curated payload list, DBMS-specific files
d7_srbh2020 / d7_srbh2020_normal	SR-BH 2020 — a real honeypot capture (12 days, 2020) with multi-label CAPEC attack-type annotations, hosted on Harvard Dataverse	See the Dataverse page for the canonical citation. _normal suffix = rows the source labeled Normal=1, sampled (Nhanh 1) or fully used (Nhanh 2) and content-filtered (see below)
d3_csic2010	CSIC 2010 HTTP dataset — a widely-used synthetic e-commerce traffic capture, hosted on the GSI/UdelaR GitLab mirror	Used only in Branch 2 files (nhanh2_normal.csv / nhanh2_anomalous_eval.csv); URL + POST body extracted from the raw HTTP request blocks

synthetic_stacked (template-generated stacked-class payloads) was a source used until 16/7 — see the note under Labels above for why it was removed. The generator remains in the codebase (src/preprocessing/synthetic_stacked.py) for future re-use once real examples are available.

How the Labels Were Assigned

1. Canonicalize raw text: iteratively URL-decode, decode hex literals (0x...) and CHAR(...) calls, lowercase, flag (not strip) SQL comments.
2. Tag with a fixed-priority rule-based tagger: stacked > time_blind > error_based > union_based > boolean_blind (first regex match wins; unmatched attack rows fall back to boolean_blind). The stacked branch of this priority order is currently dead code in practice since that class is excluded from the shipped dataset (see Labels).
3. Content-filter the normal candidate pool: rows a source dataset called "normal"/benign were still rejected if their canonicalized text matched a known SQLi or OS-command-injection/SSI signature, independent of the source's own label (see Limitations — this filter is not exhaustive).
4. Balance: undersample large classes to a fixed per-class cap; keep smaller classes in full.
5. Split: stratified train/test, fixed seed.

Limitations (please read before using for anything beyond an MVP baseline)

• boolean_blind is a catch-all bucket for attack rows that don't match a more specific rule, not a purely precise label. A manual 30-sample review measured ~13% (4/30) of boolean_blind rows as clearly mislabeled by the upstream source (SSRF probes, CRLF/header injection, and even one fully benign form submission that the source dataset had flagged as SQL Injection). Treat this class's precision as noisier than the other 4 attack classes.
• The content-based normal filter is not evasion-proof. It catches literal attack signatures (SQL keywords, cat/whoami-style OS commands, Shellshock, SSI injection) but a manually-obfuscated variant (e.g. cat$jj $jj/etc$jj/passwd — junk tokens inserted to dodge keyword matching) was found to still slip through during review. Do not assume the normal class is adversarially clean.
• Out-of-scope attack types may still appear in normal. The filter targets SQLi and OS-command/SSI injection specifically; the source honeypot dataset (D7) covers 12 broader attack categories (e.g. XSS, SSRF). Rows matching those other categories were not specifically filtered out and may still be present in the normal pool.
• Multi-label source, single-label output. D7 (SR-BH 2020) is a multi-label dataset (a request can trigger several attack-category flags at once); this dataset was built by filtering on a single flag (SQL Injection==1 for attacks, Normal==1 for the benign candidate pool) and did not otherwise deduplicate against other simultaneously-set flags (a lightweight cross-check found ~0.9% overlap, mostly co-occurring with a "Scanning for Vulnerable Software" flag).

How to Use

This repo has 3 CSVs with different schemas (Branch 1 vs Branch 2) and no loading script, so load each file explicitly rather than load_dataset(repo_id) directly (which would try to treat all CSVs as one dataset):

from datasets import load_dataset

nhanh1 = load_dataset("Jason-42195/VNU-SQLi-Detection", data_files="nhanh1_train.csv")["train"]
print(nhanh1[0])
# {'id': 0, 'query_raw': "...", 'query_canonical': "...",
#  'has_comment_marker': 0, 'label': 3, 'label_name': 'boolean_blind',
#  'source': 'd7_srbh2020', 'split': 'train'}

nhanh2_normal = load_dataset("Jason-42195/VNU-SQLi-Detection", data_files="nhanh2_normal.csv")["train"]
nhanh2_eval = load_dataset("Jason-42195/VNU-SQLi-Detection", data_files="nhanh2_anomalous_eval.csv")["train"]

Or with pandas, filtering the split column yourself:

import pandas as pd

df = pd.read_csv("nhanh1_train.csv")  # or nhanh2_normal.csv
train_df = df[df["split"] == "train"]
test_df = df[df["split"] == "test"]

Branch 1 metric: F1-macro (not accuracy) — the original per-source class sizes were extremely imbalanced before undersampling (error_based is still notably smaller than the other 4 classes even after balancing). Branch 2 metric: false-positive rate on nhanh2_normal.csv's test split + detection rate on nhanh2_anomalous_eval.csv (keep in mind the eval set spans multiple attack types, not just SQLi — see note above).

License

Mixed — verified per source:

• D4 (payload-box): MIT, confirmed directly on the source repository.
• D7 (SR-BH 2020): CC0 1.0 (public domain dedication), confirmed directly on the Harvard Dataverse record.
• D1 (SQLiV3): unclear. The original Kaggle listing has no license attached (empty license metadata). It was accessed here via a third-party GitHub mirror (nidnogg/sqliv5-dataset) that applies its own MIT license to its repository — that MIT grant covers the mirror's own repo contents, not necessarily the original author's rights over the underlying data, since the mirror maintainer is not the original creator. Treat D1-derived rows as provenance-unclear until the original author's terms are confirmed.
• Synthetic rows: generated for this project, no external license constraint.

Given D1 is one of several sources merged into this dataset (not isolated to its own file), the dataset as a whole should be treated as provenance-unclear rather than cleanly MIT/CC0, until D1's status is resolved.

Citation

If you use this dataset, please also cite the original upstream sources listed above (SQLiV3, payload-box, SR-BH 2020) in addition to this derived release.