This dataset is publicly accessible, but you must agree to the terms to access the files. Please provide your institutional or organizational email address. Personal email addresses (Gmail, Outlook, QQ, 163, etc.) are not accepted — use the email address associated with your HuggingFace account for verification.

By clicking "Agree" I confirm that I have read and agree to the CyberSecurity-100B Data Access Agreement and that I will use this dataset solely for academic, non-commercial research or defensive security purposes. I understand this dataset contains cybersecurity content including vulnerability details, exploit techniques, and offensive security information from publicly available sources. I will not use this data for any commercial or unlawful activities.

CyberSecurity-100B

A large-scale, quality-filtered cybersecurity corpus extracted from Nemotron-CC-v2, Ultra-FineWeb, Fineweb-Edu-Chinese-V2.1, StarCoderData, and curated seed sources, designed for continual pre-training (CPT) of large language models on cybersecurity domain knowledge. Contains ~4.6B English text tokens, ~5.5B Chinese text tokens, ~4.7B code tokens, and ~0.84B seed tokens for a total of ~15.5B tokens across quality-tiered, code-aware, and language-specific splits with multi-signal scoring and structured metadata.

Access Agreement: This dataset is publicly accessible but gated. By clicking "Agree" you confirm you will use this data solely for academic, non-commercial research or defensive security purposes. You must provide your institutional or organizational email — personal email addresses (Gmail, Outlook, QQ, 163, etc.) will be rejected. The email must match your HuggingFace account for identity verification.

Security Notice: This dataset contains information about cybersecurity vulnerabilities, exploitation techniques, and offensive security methods. This information is already publicly available and is collected here solely for defensive security research and education. Misuse of this information to attack systems without authorization is illegal. Users must comply with all applicable laws and regulations.

Dataset Summary

CyberSecurity-100B is produced by a multi-stage pipeline (cyberhunter) that extracts, scores, and categorizes cybersecurity-relevant content from large-scale web crawls and code datasets. The pipeline applies:

Lexical recall filtering — keyword and high-value-phrase matching with two-tier import system (core vs broad)
ML-based cyber relevance scoring — sklearn logistic regression classifier (v2)
CPT-worthiness scoring — rule-based quality assessment with grouped regex patterns
Code-aware detection — identifies 7 code/technical content types with false-positive control
Code cybersecurity mining — 30+ signals across source code, git commits, GitHub issues, Jupyter notebooks
Topic classification — 10–18 cybersecurity topic categories
MinHash near-dedup — Jaccard similarity deduplication at 0.85 threshold

The result is a quality-tiered, code-aware corpus optimized for continual pre-training of cybersecurity-capable LLMs.

Supported Tasks

Continual pre-training (CPT): Domain-adapt LLMs to cybersecurity
Language modeling: Pre-train or fine-tune on cybersecurity domain text
Security code generation: Train on code-aware splits (security rules, exploits, configurations)
Text classification: Leverage cyber_score and topic labels for downstream tasks
Information extraction: Extract IOCs, CVEs, TTPs using code detection metadata
Curriculum midtraining: Use quality-tiered splits for staged training (foundation → implementation → offensive → mastery)

Dataset Structure

CyberSecurity-100B/
├── Nemotron-CC-v2 (EN) ─────────────────────────────────────
│   ├── high_precision_code/    # cyber>=0.93, cpt>=0.75, has_code=True
│   ├── high_precision_text/    # cyber>=0.93, cpt>=0.75, has_code=False
│   ├── balanced_code/          # cyber 0.85-0.93, cpt>=0.60, has_code=True
│   ├── balanced_text/          # cyber 0.85-0.93, cpt>=0.60, has_code=False
│   └── general_cyber/          # cyber>=0.85, cpt<0.60
├── Ultra-FineWeb (EN + ZH, MinHash deduped) ──────────────
│   ├── ufw_en_high_precision/  # EN cyber>=0.93
│   ├── ufw_en_balanced/        # EN cyber>=0.85
│   ├── ufw_en_general/         # EN cyber>=0.78
│   ├── ufw_zh_high_precision/  # ZH cyber>=0.93
│   ├── ufw_zh_balanced/        # ZH cyber>=0.85
│   └── ufw_zh_general/         # ZH cyber>=0.78
├── Fineweb-Edu-Chinese-V2.1 (ZH, MinHash deduped) ───────
│   ├── fwedu_4_5_high_precision/  # edu 4-5, cyber>=0.93
│   ├── fwedu_4_5_balanced/        # edu 4-5, cyber>=0.85
│   ├── fwedu_4_5_general/         # edu 4-5, cyber>=0.78
│   ├── fwedu_3_4_high_precision/  # edu 3-4, cyber>=0.93
│   ├── fwedu_3_4_balanced/        # edu 3-4, cyber>=0.85
│   ├── fwedu_3_4_general/         # edu 3-4, cyber>=0.78
│   ├── fwedu_2_3_high_precision/  # edu 2-3, cyber>=0.93
│   ├── fwedu_2_3_balanced/        # edu 2-3, cyber>=0.85
│   └── fwedu_2_3_general/         # edu 2-3, cyber>=0.78
├── StarCoderData (Code, v6) ───────────────────────────────
│   ├── code_exploit_offensive_code/       # exploit/shellcode/CTF (~51K docs, ~143M tokens)
│   ├── code_defensive_security_code/      # auth/validation/crypto (~491K docs, ~1.2B tokens)
│   ├── code_crypto_protocol_code/         # TLS/SSH/protocol impl (~86K docs, ~309M tokens)
│   ├── code_vulnerability_reports/        # CVE/security issues (~113K docs, ~110M tokens)
│   ├── code_vulnerability_fix_commits/    # security fix diffs (~17K docs, ~39M tokens)
│   ├── code_detection_rules_code/         # YARA/Sigma/Snort rules (~21K docs, ~51M tokens)
│   ├── code_security_config_code/         # firewall/hardening (~130K docs, ~240M tokens)
│   ├── code_security_analysis_notebooks/  # Jupyter security analysis (~9K docs, ~31M tokens)
│   └── code_review_candidates_code/       # borderline (~1.3M docs, ~2.5B tokens)
└── Curated Seed Data (EN + ZH, MinHash cross-deduped) ────
    ├── seed_nvd_cve/              # NVD CVE vulnerability database
    ├── seed_exploitdb/            # ExploitDB archive
    ├── seed_osv/                  # OSV vulnerability database
    ├── seed_trickest_cve/         # Trickest CVE collection
    ├── seed_expku/                # Chinese exploit archive
    ├── seed_ctf_search/           # CTF challenge/search archive
    ├── seed_ctftime/              # CTFtime writeups
    ├── seed_nuclei_templates/     # Nuclei vulnerability templates
    ├── seed_et_open_rules/        # Emerging Threats Suricata rules
    ├── ... (196 seed sources total)
    └── seed_*                     # One config per curated source

    └── Curriculum & Advanced Data ────
        ├── curriculum_v2/             # 4-stage Bloom's taxonomy indexes
        │   ├── stage_1_foundation/    # CVE, CWE, standards, taxonomy
        │   ├── stage_2_implementation/# Detection rules, defensive code
        │   ├── stage_3_analysis/      # Threat intel, forensics, analysis
        │   └── stage_4_offensive/     # Exploits, PoC, attack patterns
        ├── vkc/                       # Vulnerability Knowledge Chains
        │   ├── vkc_chains.jsonl       # 49K cross-linked chains
        │   ├── vkc_cpt_samples.jsonl  # CPT training samples
        │   ├── vkc_fas_samples.jsonl  # FAS training samples
        │   └── vkc_has_samples.jsonl  # HAS training samples
        ├── offensive_deduped/         # 5-layer deduped offensive data
        └── recipe/                    # Curriculum recipe & schedule

    └── Curriculum & Advanced Data ────
        ├── curriculum_v2/             # 4-stage Bloom's taxonomy indexes
        │   ├── stage_1_foundation/    # CVE, CWE, standards, taxonomy
        │   ├── stage_2_implementation/# Detection rules, defensive code
        │   ├── stage_3_analysis/      # Threat intel, forensics, analysis
        │   └── stage_4_offensive/     # Exploits, PoC, attack patterns
        ├── vkc/                       # Vulnerability Knowledge Chains
        │   ├── vkc_chains.jsonl       # 49K cross-linked chains
        │   ├── vkc_cpt_samples.jsonl  # CPT training samples
        │   ├── vkc_fas_samples.jsonl  # FAS training samples
        │   └── vkc_has_samples.jsonl  # HAS training samples
        ├── offensive_deduped/         # 5-layer deduped offensive data
        └── recipe/                    # Curriculum recipe & schedule

Split Criteria

Nemotron-CC-v2 (EN)

Split	Cyber Score	CPT Score	Has Code	Recommended Use
high_precision_code	>= 0.93	>= 0.75	Yes	Core CPT — highest quality with code
high_precision_text	>= 0.93	>= 0.75	No	Core CPT — highest quality prose
balanced_code	0.85–0.93	>= 0.60	Yes	Extended CPT — code content, moderate confidence
balanced_text	0.85–0.93	>= 0.60	No	Extended CPT — prose, moderate confidence
general_cyber	>= 0.85	< 0.60	Either	Supplementary — cyber-relevant but lower quality

StarCoderData (Code, v6)

Split	Documents	Est. Tokens	Avg Score	Description
code_defensive_security_code	491,319	~1,209M	0.84	Auth, validation, encryption implementations
code_review_candidates_code	1,300,189	~2,537M	0.45	Borderline candidates (review recommended)
code_security_config_code	129,590	~240M	0.80	Firewall, seccomp, hardening configs
code_crypto_protocol_code	85,789	~309M	0.86	TLS/SSH/protocol implementations
code_exploit_offensive_code	51,016	~143M	0.87	Exploit/shellcode/ROP, CTF challenges
code_vulnerability_reports	112,654	~110M	0.69	CVE disclosures, security issue reports
code_detection_rules_code	20,557	~51M	0.73	YARA/Sigma/Snort rule definitions
code_vulnerability_fix_commits	16,941	~39M	0.64	Security fix diffs with before/after
code_security_analysis_notebooks	8,712	~31M	0.67	Jupyter notebooks for security analysis

Code pipeline: TF-IDF (char_wb 3-5) + LogisticRegression, ROC-AUC=0.982. Two-tier recall filter: core security imports (ssh2, paramiko, scapy) + broad imports with keyword confirmation (crypto+CVE, tls+exploit). 30+ quality signals per document across 4 content types (source_code, git_commit, github_issue, jupyter).

Ultra-FineWeb (EN + ZH, MinHash deduped)

Split	Language	Cyber Score	Documents	Est. Tokens	Has Code
ufw_en_high_precision	EN	>= 0.93	19,270	26.3M	5,804
ufw_en_balanced	EN	>= 0.85	42,213	56.8M	11,929
ufw_en_general	EN	>= 0.78	60,554	80.8M	16,846
ufw_zh_high_precision	ZH	>= 0.93	50,559	36.5M	7,791
ufw_zh_balanced	ZH	>= 0.85	105,182	65.4M	10,824
ufw_zh_general	ZH	>= 0.78	148,396	84.8M	13,031
EN subtotal			122,037	164.0M	34,579
ZH subtotal			304,137	186.7M	31,646

Fineweb-Edu-Chinese-V2.1 (ZH, MinHash deduped)

Split	Edu Band	Cyber Score	Documents	Est. Tokens	Has Code
fwedu_4_5_high_precision	4-5	>= 0.93	23,320	45.2M	1,425
fwedu_4_5_balanced	4-5	>= 0.85	66,108	108.5M	2,323
fwedu_4_5_general	4-5	>= 0.78	99,716	154.7M	2,728
fwedu_3_4_high_precision	3-4	>= 0.93	317,582	495.8M	34,664
fwedu_3_4_balanced	3-4	>= 0.85	786,036	1,032.9M	47,207
fwedu_3_4_general	3-4	>= 0.78	1,154,106	1,416.6M	53,064
fwedu_2_3_high_precision	2-3	>= 0.93	201,655	250.5M	19,676
fwedu_2_3_balanced	2-3	>= 0.85	661,999	668.7M	31,741
fwedu_2_3_general	2-3	>= 0.78	1,133,271	1,052.5M	39,520
Total			4,443,793	5,225.4M	232,348

Data Instances

Text Data (EN/ZH from Nemotron/UFW/FW-Edu)

Each JSONL record contains full text with rich metadata:

{
  "id": "b38f5ed2bc1c8b807fa7830f15ad1f9f...",
  "source": "nvidia/Nemotron-CC-v2",
  "source_path": "v1/High-Quality/part_000000.parquet",
  "source_subset": "organic_cc",
  "url": "https://example.com/blog/cve-analysis",
  "domain": "example.com",
  "text": "A remote code execution vulnerability exists in...",
  "language": "en",
  "char_count": 7496,
  "token_count_est": 1874,
  "cyber_score": 0.9756,
  "topic": "vulnerability",
  "topic_confidence": 0.8,
  "cpt_worthy_score": 0.8420,
  "cpt_worthy_label": "high",
  "has_code": true,
  "code_score": 0.65,
  "code_types": ["security_rules", "programming_code"],
  "code_line_count_est": 42,
  "code_block_count_est": 3,
  "command_count_est": 5,
  "ioc_count_est": 8,
  "code_detection_reasons": ["matched_security_rules", "matched_programming_code_strong"],
  "pipeline_version": "cyberhunter_v2"
}

Code Data (from StarCoderData)

Each JSONL record contains source code with security signal metadata:

{
  "doc_id": "abc123",
  "source_dataset": "bigcode/starcoderdata",
  "source_path": "/data/starcoderdata/python/train-00000-of-00059.parquet",
  "source_subset": "python",
  "content_type": "source_code",
  "language": "python",
  "repo_path": "security/pentest/scanner.py",
  "repo_name": "cyber-tools",
  "repo_stars": 42,
  "text": "import scapy.all as scapy\nimport paramiko...",
  "text_sha256": "a1b2c3...",
  "char_count": 2847,
  "token_count_est": 712,
  "recall_matched": true,
  "recall_reason": "sec_import:python",
  "cyber_score": 0.87,
  "cyber_classifier_version": "code_relevance_v2",
  "has_sec_import": true,
  "num_sec_imports": 2,
  "has_exploit_signals": false,
  "has_defensive_signals": true,
  "has_detection_signals": false,
  "has_crypto_signals": false,
  "strong_keyword_count": 1,
  "medium_keyword_count": 3,
  "repo_path_security": true,
  "repo_name_security": true,
  "commit_msg_security": false,
  "issue_title_security": false,
  "filter_passed": true,
  "accepted_split": "defensive_security_code",
  "pipeline_version": "cyberhunter_code_v1"
}

Data Fields

Text Data Fields

Field	Type	Description
`id`	string	SHA-256 based document identifier
`source`	string	Source dataset
`source_path`	string	Original parquet file path
`source_subset`	string	Source subset identifier
`url`	string	Original URL (may be empty)
`domain`	string	URL domain (may be empty)
`text`	string	Full document text
`language`	string	Language code (en, zh)
`char_count`	int	Character count
`token_count_est`	int	Estimated token count
`cyber_score`	float	Cyber relevance score from ML classifier [0, 1]
`topic`	string	Cybersecurity topic category
`topic_confidence`	float	Topic classification confidence [0, 1]
`cpt_worthy_score`	float	CPT-worthiness quality score [0, 1]
`cpt_worthy_label`	string	Quality label (high, medium, low, reject)
`has_code`	bool	Whether code/technical content detected
`code_score`	float	Code content detection score [0, 1]
`code_types`	list[string]	Detected code types
`code_line_count_est`	int	Estimated lines of code
`code_block_count_est`	int	Estimated code blocks
`command_count_est`	int	Estimated CLI commands
`ioc_count_est`	int	Estimated indicators of compromise
`code_detection_reasons`	list[string]	Reasons for code detection
`pipeline_version`	string	Pipeline version identifier

Code Data Fields

Field	Type	Description
`doc_id`	string	Document identifier
`source_dataset`	string	"bigcode/starcoderdata"
`source_path`	string	Original parquet file path
`source_subset`	string	Language/directory name
`content_type`	string	source_code, git_commit, github_issue, jupyter
`language`	string	Programming language
`repo_path`	string	File path within repository
`repo_name`	string	Repository name
`repo_stars`	int	GitHub stars
`text`	string	Full source code / commit diff / issue text
`text_sha256`	string	SHA-256 hash of text
`char_count`	int	Character count
`token_count_est`	int	Estimated token count
`recall_matched`	bool	Whether recall filter matched
`recall_reason`	string	Reason for recall match
`cyber_score`	float	Classifier score [0, 1]
`cyber_classifier_version`	string	Classifier version
`has_sec_import`	bool	Whether security imports detected
`num_sec_imports`	int	Number of security imports
`has_exploit_signals`	bool	Whether exploit/shellcode signals present
`has_defensive_signals`	bool	Whether defensive security signals present
`has_detection_signals`	bool	Whether detection rule signals present
`has_crypto_signals`	bool	Whether crypto protocol signals present
`strong_keyword_count`	int	Count of strong security keywords
`medium_keyword_count`	int	Count of medium security keywords
`repo_path_security`	bool	Whether repo path has security keywords
`repo_name_security`	bool	Whether repo name has security keywords
`filter_passed`	bool	Whether quality filters passed
`accepted_split`	string	Assigned corpus split
`pipeline_version`	string	Pipeline version

Topic Categories

English (10 categories)

Topic	Description
malware_analysis	Malware analysis and reverse engineering
vulnerability	Vulnerability disclosure and analysis
threat_intelligence	Threat landscape and APT analysis
exploit_writeup	Exploit development and PoC code
incident_response	Incident handling and DFIR
digital_forensics	Forensic analysis and evidence
detection_engineering	Detection rules and hunting
network_security	Network security analysis
identity_access	Identity and access management
application_security	Application security testing

Chinese (18 categories)

All English categories plus: cryptography_security, ctf_training, security_tools, offensive_security, secure_coding, compliance_policy, cloud_security, general_cybersecurity

Code Types

Detected by the code-aware module with false-positive control (single IP/hash/command does NOT trigger has_code):

Code Type	Description	Examples
security_rules	Security detection rules	YARA, Sigma, Snort/Suricata, Splunk SPL
configuration	Infrastructure configuration	YAML, nginx/apache, K8s, Dockerfile, iptables
programming_code	Source code snippets	Python, C/C++, JS, Java, Go, Rust, PHP, Ruby, Shell
exploit_or_poc_code	Exploit scripts and PoC	Payload generation, shellcode, exploit frameworks
logs_and_iocs	Log data and IOCs	Log lines, stack traces, IP/hash indicators, Sysmon
command_line	CLI commands and tool output	nmap, sqlmap, yara, security tool invocations
patch_or_diff	Patches and diffs	git diff, unified diff, CVE patch snippets

Data Sources & Statistics

Grand Total

Source	Language	Documents	Est. Tokens
Nemotron-CC-v2	EN	~4,200,000	~4,400M
Ultra-FineWeb	EN	122,037	164M
Ultra-FineWeb-L3	ZH	146,357	46M
Ultra-FineWeb	ZH	304,137	187M
Fineweb-Edu-Chinese-V2.1	ZH	4,443,793	5,225M
StarCoderData	Code (86+ langs)	916,578 (core 8) + 1,300,189 (review)	2,135M (core) + 2,537M (review)
Curated Seed Data	EN+ZH	949,520	841M
Total (recommended)		~12.4M	~~15,533M (~~15.5B)

Note: An additional below_threshold split (~~3.6M docs, ~3.7B tokens) is available for analysis but not recommended for CPT training. A rejected_code split (~~3.76M docs) was excluded from upload.

Code Corpus Token Breakdown

Split	Est. Tokens
code_defensive_security_code	~1,209M
code_review_candidates_code	~2,537M
code_security_config_code	~240M
code_crypto_protocol_code	~309M
code_exploit_offensive_code	~143M
code_vulnerability_reports	~110M
code_detection_rules_code	~51M
code_vulnerability_fix_commits	~39M
code_security_analysis_notebooks	~31M
Core 8 splits	~2,135M
All 9 splits (incl. review)	~4,672M

Score Distribution (StarCoderData, Code)

Score Range	Count	Percentage	Interpretation
0.9-1.0	285,541	4.8%	Very likely cybersecurity
0.7-0.9	367,112	6.1%	Likely cybersecurity
0.5-0.7	570,680	9.5%	Probably cybersecurity
0.3-0.5	1,107,267	18.5%	Borderline
0.1-0.3	2,008,604	33.6%	Unlikely cybersecurity
<0.1	1,640,479	27.4%	Very unlikely cybersecurity

Recommended Thresholds for Code CPT

Profile	Min Score	Est. Docs	Est. Precision	Use Case
high_precision	0.7	~652K	~97%	CPT core training
balanced	0.5	~1,223K	~94%	Broader CPT
full_coverage	0.3	~2,330K	~87%	Maximum recall

Pipeline Details

The cyberhunter pipeline processes data in the following stages:

Text Pipeline (EN/ZH)

Recall filtering — Precompiled regex + frozenset keyword matching with hard-negative exclusion
Lexical pre-ranking — Cyber-relevant term frequency scoring with configurable threshold
ML classification — Logistic regression (sklearn) with embedding features for cyber relevance scoring
Topic classification — Rule-based topic assignment across 10–18 cybersecurity categories
CPT-worthiness scoring — Grouped regex alternation across 11 positive and 8 negative quality groups
Code-aware detection — 7 code type detectors with strong/weak indicator classification and false-positive control
MinHash near-dedup — datasketch MinHashLSH at Jaccard >= 0.85 (shingle_size=5, num_perm=128)

English Pipeline

Classifier: TF-IDF + Logistic Regression on English embeddings
Source: Nemotron-CC-v2 (88.2B docs) + Ultra-FineWeb (1.16B docs)
Recall rate: ~0.005% from Nemotron, ~0.22% from UFW

Chinese Pipeline

Classifier: jieba word segmentation + TF-IDF (1-2gram, 500k features) + Logistic Regression
Version: v2 with 5,000+ hard negatives (食品安全, 网络游戏, 生产安全, etc.)
Performance: F1=0.998, PR-AUC=0.9999, Precision=1.0 at threshold >= 0.80
Sources: Ultra-FineWeb-L3 (359M ZH docs), Ultra-FineWeb (131M ZH docs), Fineweb-Edu-Chinese-V2.1 (977M docs)

Code Pipeline (StarCoderData)

Two-tier recall filter — Core security imports (scapy, paramiko, ssh2, node-forge, helmet) + broad imports with keyword confirmation (crypto+CVE, tls+exploit)
30+ quality signals — Across source_code, git_commit, github_issue, jupyter content types
ML classification — TF-IDF (char_wb 3-5, 100K features) + LogisticRegression, ROC-AUC=0.982
10-way split assignment — exploit_offensive, defensive_security, crypto_protocol, detection_rules, vulnerability_reports, vulnerability_fix_commits, security_config, security_analysis_notebooks, review_candidates, rejected

Considerations

Academic Use Only

This dataset is compiled and distributed strictly for academic, non-commercial research purposes. Any commercial use, redistribution for profit, or application in commercial products is strictly prohibited without explicit written authorization. The research team receives no financial benefit from this dataset.

Disclaimer

The content in this dataset is extracted from publicly available web data and represents the views of the original authors, not the research team. The research team:

Does not endorse, verify, or guarantee the accuracy of any content
Does not take responsibility for any claims, opinions, or information in the dataset
Does not encourage or support the use of this information for unauthorized access or illegal activities
Makes no warranties, express or implied, regarding the dataset's fitness for any particular purpose

Security Risk Notice

This dataset contains technical information about vulnerabilities, exploitation methods, and offensive security techniques. While this information is already publicly available, users should be aware that:

Unauthorized use of exploit techniques against systems you do not own or have explicit permission to test is illegal in most jurisdictions
Responsible disclosure practices should be followed when discovering new vulnerabilities
Users must comply with all applicable local, national, and international laws
The dataset should only be used to improve defensive security capabilities

Licensing

The dataset compilation is released under Apache 2.0 for academic, non-commercial use. Individual content items originate from publicly available web data and retain their original source licensing. Users must verify licensing for specific content before any redistribution. Commercial use is prohibited.

Biases

Language bias: Primarily English + Chinese + Code; other languages not covered
Source bias: Content reflects the distribution of underlying web crawls and code repositories
Topic imbalance: malware_analysis and vulnerability dominate scored docs
Score calibration: Cyber scores are ML-predicted and may have domain-specific miscalibration
Code detection: Rule-based detection may miss implicit code references or flag false positives
Formal verification languages: Alloy/TLA+ use security vocabulary in modeling contexts; partially mitigated by classifier

v6 Update: Code Cybersecurity Corpus from StarCoderData (2026-06-04)

Added 9 code splits mined from StarCoderData (290GB, 863 parquet files, 206.6M documents across 86+ programming languages).

Pipeline

Two-tier recall filter: Core security imports (scapy, paramiko, ssh2, node-forge, helmet) + broad imports with keyword confirmation (crypto+CVE, tls+exploit) — 3.0% recall rate
30+ quality signals: Per document across 4 content types (source_code, git_commit, github_issue, jupyter)
Classifier: TF-IDF (char_wb 3-5, 100K features) + LogisticRegression — ROC-AUC=0.982, PR-AUC=0.983
10-way corpus split: exploit_offensive, defensive_security, crypto_protocol, detection_rules, vulnerability_reports, vulnerability_fix_commits, security_config, security_analysis_notebooks, review_candidates, rejected
Core splits all 100% >= 0.5 classifier score, 0% < 0.3 — high quality guaranteed

Code Corpus Statistics

Split	Documents	Est. Tokens	Top Languages
code_defensive_security_code	491,319	~1,209M	C, Java, JavaScript, C#, C++
code_review_candidates_code	1,300,189	~2,537M	Dockerfile, C#, Java, Python
code_security_config_code	129,590	~240M	C#, C++, PHP, C, Markdown
code_crypto_protocol_code	85,789	~309M	Markdown, Python, C, Java, PHP
code_vulnerability_reports	112,654	~110M	GitHub Issues
code_exploit_offensive_code	51,016	~143M	C, Markdown, Python, C++, Java
code_detection_rules_code	20,557	~51M	Markdown, JavaScript, TypeScript
code_vulnerability_fix_commits	16,941	~39M	Git Commits
code_security_analysis_notebooks	8,712	~31M	Jupyter

Unique Value

Source code level: Real security implementations (not just text about security)
Commit diffs: Security fix before/after for causal learning
Detection rules: YARA/Sigma/Snort rules for security operations training
86+ programming languages: Broad coverage beyond Python/C
Classifier-quality filtered: ROC-AUC=0.982 ensures high precision in core splits

v5 Update: Curated Cybersecurity Seed Data (2026-06-03)

Added 196 seed splits from curated cybersecurity sources — vulnerability databases, exploit archives, CTF platforms, detection rule repositories, threat intelligence feeds, security media, and more. All seed data is confirmed cybersecurity-relevant with cyber_score=1.0, topic_confidence=1.0, and cpt_worthy_label="high".

Seed Data by Category

Category	Splits	Documents	Est. Tokens
Vulnerability Advisories	13	521,666	~222M
Exploits PoC	10	148,638	~94M
CTF Training	13	61,958	~89M
Detection Rules	7	78,660	~40M
ZH Security Media	15	53,209	~105M
Threat Intel	19	13,703	~17M
Forensics Analysis	14	14,132	~11M
Security Blogs	24	4,249	~11M
Standards Compliance	7	1,807	~7M
Offensive Tools	4	3,100	~4M
Reference KB	14	6,852	~22M
Other	53	40,319	~217M

Aggregate Seed Stats

Metric	Value
Total splits	196
Total documents	949,520
Total est. tokens	~841M

v7 Update: Curriculum Learning & Deduplication (2026-06-06)

Added 4-stage curriculum indexes, Vulnerability Knowledge Chains (VKC), 5-layer deduplicated offensive data, and curriculum recipe for 27B-parameter cybersecurity CPT.

Curriculum v2 Indexes

4-stage Bloom's taxonomy curriculum with layered entry, difficulty scoring, and quality grading. Each stage directory contains an index.parquet (document index with source_path + row_index pointing to source data) and a manifest.json.

Stage	Documents	Est. Tokens	Repeat Factor	Epochs	Description
`stage_1_foundation`	1,331,391	~0.48B	2.0x	1-2	CVE databases, CWE knowledge, standards, vulnerability taxonomy
`stage_2_implementation`	21,690,804	~15.6B	1.5x	3-4	Defensive code, detection rules, security configuration
`stage_3_analysis`	8,182,643	~14.5B	1.2x	5-6	Threat intelligence, forensics, vulnerability analysis
`stage_4_offensive`	2,310,266	~1.59B	1.5x	7-9	Exploit techniques, PoC code, penetration testing
Total	33,515,104	~32.2B		9

Index schema (25 columns): doc_id, source_path, source_name, source_type, row_index, stage, difficulty, difficulty_abstraction, difficulty_depth, difficulty_domain, difficulty_length, difficulty_relevance, cyber_score, quality_grade, data_product, topic, language, char_count, token_count_est, weight, epoch_first, epoch_last, layer_tag, cve, has_exploit_code

Key features:

Layered entry: A+/A-grade documents enter at S2/S3; B-grade at S3/S4; C-grade capped at 5-8% of S4 tokens
Difficulty scoring: 5 dimensions (abstraction, depth, domain, length, relevance) per document
MegaVul C→B- reclassification: 637K MegaVul records with CWE tags upgraded from C to B-
Maintenance scheduling: 20% of previous stage data mixed into next stage to prevent catastrophic forgetting

Vulnerability Knowledge Chains (VKC)

49,561 cross-linked vulnerability chains connecting CVE advisories to exploits, patches, detection rules, and MITRE ATT&CK mappings. Each chain links evidence from 2+ sources.

Chain Grade	Count	Avg Completeness
A+	310	0.80
A	1,104	0.60
B+	9,394	0.40
B	38,753	0.30

Training formats:

CPT (vkc_cpt_samples.jsonl): 49,561 structured explanation samples (~19M tokens)
FAS (vkc_fas_samples.jsonl): 36,260 predict-next-evidence samples (~5.5M tokens)
HAS (vkc_has_samples.jsonl): 4,167 select-best-action samples

Deduplicated Offensive Raw

5-layer deduplicated offensive cybersecurity data, reduced from 2.6M to 1,351,234 documents (48.1% removed).

Source	Description
`nvd_cve.jsonl`	NVD CVE vulnerability database
`megavul.jsonl`	MegaVul function-level vulnerability data
`big_vul.jsonl`	BigVul vulnerability dataset
`osv.jsonl`	OSV open source vulnerability database
`expku.jsonl`	Chinese exploit archive
`trickest_cve.jsonl`	Trickest CVE collection
`exploitdb.jsonl`	ExploitDB exploit archive
`nuclei_templates.jsonl`	Nuclei vulnerability scanner templates
`hacktricks.jsonl`	HackTricks penetration testing notes
`hacktricks_cloud.jsonl`	HackTricks cloud security notes

Dedup layers: L1 exact hash → L2 normalized text → L3 CVE canonical merge → L4 code hash → L5 MinHash (Jaccard ≥ 0.85)

Curriculum Recipe

unified_curriculum_recipe.json: Full recipe with stage definitions, data sources, repeat factors, and Chinchilla ratio (~1.59x for 27B params, 9 epochs)
training_schedule.json: Epoch-by-epoch schedule with maintenance mixing and sequence count estimates
curriculum_recipe.json: Original recipe with effective token calculations

Citation

@dataset{cybersecurity-100b,
  title={CyberSecurity-100B: A Quality-Filtered Cybersecurity Corpus for Continual Pre-Training},
  author={WhitzardAgent Team (SIIxFudan)},
  year={2026},
  note={v6: Added code cybersecurity corpus (~4.7B tokens from StarCoderData)},
  publisher={Hugging Face},
  url={https://huggingface.co/datasets/WhitzardAgent/CyberSecurity-100B}
}