Patchnoisseur

A connoisseur's cellar of CVEs: every NVD CVE joined to its fixing-commit diff (when one could be found), its NVD description, and its associated CWE(s) (id, name, short description) — served as a single Parquet dataset.

351 884 CVEs · 25 015 with a real git diff attached · CVE-1999 → CVE-2026 · ~744 MB on disk (zstd-compressed Parquet, sharded ~300 MB each).

What's in it

One row per CVE in the NVD feed. CVEs without a retrievable patch are kept (with has_patch = false and empty patch columns), so the dataset is also usable as a complete NVD snapshot enriched with CWE metadata.

For CVEs that do have a patch, the patch_diff column contains the raw unified diff(s) (with === <commit-url> === section headers when several commits fix the same CVE), and the patch is further indexed by:

• patch_urls — normalized commit URLs
• patch_hosts — github, gitlab, gitee, cgit, …
• patch_languages — programming languages touched, detected from the diff --git a/<old> b/<new> paths (extension + basename map)

Schema

Column	Type	Description
cve_id	string	CVE-YYYY-NNNN
year	int32	Year parsed from the ID
description	string	NVD description (English)
cwes	list<struct<id, name, description>>	Linked CWEs, enriched from MITRE XML views (Research Concepts, Top 25, OWASP…)
patch_diff	large_string	Full diff body, with === url === section headers when multiple commits
patch_urls	list<string>	Source commit URLs
patch_hosts	list<string>	Normalized patch hosts
patch_languages	list<string>	Programming languages touched by the diff
has_patch	bool	true when a non-empty diff was loaded
published, last_modified	string	NVD ISO dates
status, source_identifier	string	NVD metadata
cvss_version, cvss_base_score, cvss_base_severity, cvss_vector	string / float	Best available metric (V4 → V3.1 → V3.0 → V2)
references	list<string>	All NVD references

Sources

Downloaders live under dataset/:

Directory	Contents	Source
dataset/nvd/data/nvdcve-2.0-YYYY.json	NVD 2.0 feed (description, CWE, CVSS, references…)	https://nvd.nist.gov/feeds/json/cve/2.0/
dataset/cwe/data/<view>.xml	CWE views (Research Concepts, Top 25, OWASP…)	https://cwe.mitre.org/data/downloads.html
dataset/cve_diff/data/<year>/<bucket>xxx/CVE-*.diff	Fixing-commit diff(s), one file per CVE	GitHub, GitLab, Gitee, cgit (kernel.org, savannah, freedesktop…)

To (re)populate the sources:

bash dataset/nvd/download.sh
bash dataset/cwe/download.sh
python dataset/cve_diff/download.py    # requires git; GITHUB_TOKEN recommended

The CVE-diff fetcher (dataset/cve_diff/download.py) is auto-healing, parallel (configurable via JOBS), and logs every attempted fallback per job (try / skip / ok / fail) into dataset/cve_diff/.logs/downloads.log.

Parquet pipeline

build_parquet.py joins the three sources:

• loads CWE definitions (id, name, short description) from every XML view
• indexes NVD CVEs (EN description, CWEs, dates, CVSS, references)
• emits one row per CVE in (NVD ∪ patches) — patch-less rows keep empty patch_diff / patch_urls / patch_hosts / patch_languages and have has_patch = False
• for CVEs with a diff: extracts commit URLs (=== https://… ===) → normalized patch_urls + patch_hosts (github, gitlab, gitee, cgit, …) and detects the programming language(s) touched (diff --git a/<old> b/<new> paths → extension/basename map) → patch_languages
• writes dataset/parquet/cve_diff-part<NNN>.parquet in zstd, starting a new shard when the estimated size approaches 300 MB

Run:

uv run python build_parquet.py

Schema

Column	Type	Description
cve_id	string	CVE-YYYY-NNNN
year	int32	Year parsed from the ID
description	string	NVD description (EN)
cwes	list<struct<id, name, description>>	Linked CWEs, enriched from the XML views
patch_diff	large_string	Full diff body, === url === headers included
patch_urls	list<string>	Source commit URLs
patch_hosts	list<string>	Normalized patch hosts
patch_languages	list<string>	Programming languages touched by the diff
has_patch	bool	true when a non-empty diff was loaded for this CVE
published, last_modified	string	NVD ISO dates
status, source_identifier	string	NVD metadata
cvss_version, cvss_base_score, cvss_base_severity, cvss_vector	string/float	Best available metric (V4 → V3.1 → V3.0 → V2)
references	list<string>	All NVD references

Web app (FastAPI)

A small UI under app/ lets you browse the parquet: paginated list with filters (CWE, year, severity, host, language, with/without patch, free-text search on CVE-ID/description) and a detail view per CVE with a side-by-side patch viewer (old left, new right, GitLab-style color coding).

uv run uvicorn app.main:app --reload
# then open http://127.0.0.1:8000

Routes:

• GET / — paginated list. Query string: q, cwe, year, severity, host, language, patch (yes/no), page
• GET /cve/{cve_id} — detail + side-by-side diff (shown only when the CVE has a patch)

Language chips on both the list and the detail pages are clickable: they take you back to a filtered list.

Layout: app/main.py (routes), app/data.py (Polars layer), app/diff_parser.py (unified diff → render model), app/templates/ (Jinja2), app/static/style.css.

Exploration with Jupyter + Polars

explore.ipynb ships a few example Polars queries on the parquet: overview (with patch coverage stats), top languages, top CWEs, CVSS/host filters, language-based filtering, with/without-patch filtering by year, inspecting a single patch, diff-size statistics, …

Install the deps and launch JupyterLab:

uv sync                          # installs runtime + dev group (polars, jupyterlab)
uv run jupyter lab explore.ipynb

Handy variants:

# run the notebook in batch
uv run jupyter nbconvert --to notebook --execute explore.ipynb --output explore.ipynb

# one-off query from the command line
uv run python -c "import polars as pl; print(pl.scan_parquet('dataset/parquet/cve_diff-part*.parquet').select(pl.len()).collect())"

Layout

.
├── build_parquet.py          # NVD + CWE + diffs → parquet pipeline
├── explore.ipynb             # Polars examples
├── app/                      # FastAPI + Jinja2 (search & viewer)
│   ├── main.py
│   ├── data.py
│   ├── diff_parser.py
│   ├── templates/
│   └── static/
├── dataset/
│   ├── nvd/{download.sh,data/}
│   ├── cwe/{download.sh,data/}
│   ├── cve_diff/{download.py,data/}
│   └── parquet/              # pipeline output
├── pyproject.toml
└── uv.lock

Requirements

• Python ≥ 3.13 (declared in pyproject.toml)
• uv for environment management
• bash, jq, curl, unzip, wget for the download.sh scripts
• git for the cve_diff fetcher's clone-based fallback (optional, on by default)

How to use it

With datasets

from datasets import load_dataset

ds = load_dataset("michoo42/Patchnoisseur/dataset/cve_diff/data", split="train")
print(ds)
print(ds[0]["cve_id"], ds[0]["patch_languages"])

With Polars (recommended for the full dataset — lazy + fast)

import polars as pl

df = pl.scan_parquet("hf://datasets/michoo42/Patchnoisseur/dataset/cve_diff/data/*.parquet")

# How many CVEs actually have a patch?
print(df.filter(pl.col("has_patch")).select(pl.len()).collect())

# Top languages touched by security patches
print(
    df.filter(pl.col("has_patch"))
      .explode("patch_languages")
      .group_by("patch_languages")
      .len()
      .sort("len", descending=True)
      .head(20)
      .collect()
)

# All HIGH/CRITICAL CVEs since 2023 with a GitHub patch
hot = (
    df.filter(
        (pl.col("year") >= 2023)
        & (pl.col("cvss_base_severity").is_in(["HIGH", "CRITICAL"]))
        & (pl.col("patch_hosts").list.contains("github"))
    )
    .select("cve_id", "cvss_base_score", "patch_urls", "patch_languages")
    .collect()
)

With pandas / pyarrow

import pyarrow.dataset as ds
table = ds.dataset("path/to/parquet", format="parquet").to_table()
df = table.to_pandas()

Suggested use cases

• Training / fine-tuning models on vulnerability classification (CVE → CWE)
• Patch summarization and commit-message generation from real security fixes
• Vulnerability localization in source code (diff + description → file/function)
• Retrieval-augmented setups for security copilots (search by CWE / language / severity)
• Empirical security research: language exposure, patch-size statistics, host distribution, time-to-fix proxies…

Data sources

• NVD 2.0 JSON feed — https://nvd.nist.gov/feeds/json/cve/2.0/
• MITRE CWE XML views (Research Concepts, Top 25, OWASP, …) — https://cwe.mitre.org/data/downloads.html
• Fixing-commit diffs fetched from GitHub, GitLab, Gitee, and cgit-based forges (kernel.org, savannah, freedesktop, …) using the references declared in the NVD entry. The retrieval is best-effort, auto-healing and parallel; only patches that returned a non-empty, well-formed git diff are kept (has_patch = true).

Known limitations

• Only ~7 % of CVEs have a patch attached. This is expected: many CVEs have no public fixing commit, point to vendor advisories without code, or live in private repositories.
• patch_languages is inferred from file paths only — it does not analyze the actual edited code.
• Diffs are kept as fetched (UTF-8 best-effort, no re-formatting). A few patches may contain partially binary hunks.
• Descriptions are English only (NVD en description).

License

The dataset compiles public information from NVD (public-domain), MITRE CWE (CC BY 4.0) and patches retrieved from public commits hosted by their respective projects (each under its own upstream license). The packaging itself is released under CC BY 4.0 — please cite if you build on it.

Citation

@misc{patchnoisseur2026,
  title  = {Patchnoisseur: a CVE × Patch × CWE Parquet dataset},
  author = {michoo42},
  year   = {2026},
  url    = {https://huggingface.co/datasets/michoo42/patchnoisseur}
}