Add dataset card

README.md

@@ -0,0 +1,336 @@
+
+---
+
+title: CVEfixes Data Splits
+description: A detailed dataset split from CVEfixes_v1.0.8 for vulnerability analysis, including train, validation, and test sets.
+author: Mohammad Taghavi
+date: 2025-03-31
+source: "CVEfixes: Automated Collection of Vulnerabilities and Their Fixes from Open-Source Software"
+tags:
+  - security
+  - vulnerabilities
+  - dataset
+  - software-security
+license: mit
+
+---
+
+# CVEfixes Data Splits README
+
+This repository contains data splits derived from the `CVEfixes_v1.0.8` dataset, an automated collection of vulnerabilities and their fixes from open-source software. The dataset has been processed and split into training, validation, and test sets to facilitate machine learning and vulnerability analysis tasks. Below, you’ll find details about the splits, problematic CVEs excluded due to memory constraints, and a comprehensive guide on how to recreate these splits yourself.
+
+## Dataset Overview
+
+The original `CVEfixes_v1.0.8` dataset was sourced from the Github repository `https://github.com/secureIT-project/CVEfixes`. We’ve split it into four parts:
+- **Training Split (Part 1)**: 4000 CVEs (first portion of the 70% training data)
+- **Training Split (Part 2)**: 4307 CVEs (remaining portion of the 70% training data, totaling 8307 CVEs with Part 1)
+- **Validation Split**: 1781 CVEs (15% of the dataset)
+- **Test Split**: 1781 CVEs (15% of the dataset)
+
+These splits include full data from all tables in the `CVEfixes.db` SQLite database, preserving referential integrity across tables such as `cve`, `fixes`, `commits`, `file_change`, `method_change`, `cwe`, `cwe_classification`, and `repository`.
+
+### Excluded CVEs
+The following CVEs were excluded from processing due to excessive memory usage (>50GB RAM), which caused runtime crashes on standard Colab environments:
+- `CVE-2021-3957`
+- `CVE-2024-26152`
+- `CVE-2016-5833`
+- `CVE-2023-6848`
+
+If your system has less than 50GB of RAM, we recommend skipping these CVEs during processing to avoid crashes.
+
+## How to Create Your Own Data Split
+
+Below is a step-by-step guide to download, extract, and split the `CVEfixes_v1.0.8` dataset into training, validation, and test sets, mirroring the process used to create these splits. This includes Python code snippets ready to run in a Google Colab environment.
+
+### Step 1: Download the Original ZIP File
+Download the dataset from Hugging Face using the `huggingface_hub` library.
+
+```
+from huggingface_hub import snapshot_download
+repo_id = "starsofchance/CVEfixes_v1.0.8"
+filename = "CVEfixes_v1.0.8.zip"
+dataset_path = snapshot_download(
+    repo_id=repo_id,
+    repo_type="dataset",
+    allow_patterns=filename  # Only download the zip file and not the splits we created
+)
+print(f"Dataset downloaded to: {dataset_path}")
+```
+After downloading the file you will see a massage:Dataset containing CVEfixes_v1.0.8.zip downloaded to: /addres you must copy/ 
+### Step 2: Create a Folder to Extract the Data
+Set up a directory to extract the contents of the ZIP file.
+```
+import os
+extract_dir = "/content/extracted_data"
+os.makedirs(extract_dir, exist_ok=True)
+print(f"Extraction directory created at: {extract_dir}")
+```
+
+### Step 3: Decompress and Convert to SQLite Database
+Extract the `.sql.gz` file from the ZIP and convert it into a SQLite database.
+```
+cache_path = "addres you have copied"
+zip_file_path = os.path.join(cache_path, "CVEfixes_v1.0.8.zip")
+!unzip -q "{zip_file_path}" -d "{extract_dir}"
+#Verify extraction
+print("\nExtracted files:")
+!ls -lh "{extract_dir}"
+```
+
+
+# Decompress the .gz file and convert to SQLite
+```
+!zcat {extract_dir}/CVEfixes_v1.0.8/Data/CVEfixes_v1.0.8.sql.gz | sqlite3 /content/CVEfixes.db
+print("Database created at: /content/CVEfixes.db")
+```
+### Step 4: Explore Tables and Relationships
+Connect to the database and inspect its structure.
+
+```
+import sqlite3
+import pandas as pd
+
+# Connect to the database
+conn = sqlite3.connect('/content/CVEfixes.db')
+cursor = conn.cursor()
+
+# Get all tables
+cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+tables = cursor.fetchall()
+print("Tables in the database:", tables)
+
+# Display column headers for each table
+for table in tables:
+    table_name = table[0]
+    print(f"\nHeaders for table '{table_name}':")
+    cursor.execute(f"PRAGMA table_info('{table_name}');")
+    columns = cursor.fetchall()
+    column_names = [col[1] for col in columns]
+    print(f"Columns: {column_names}")
+
+# Count rows in each table
+for table in tables:
+    table_name = table[0]
+    cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+    row_count = cursor.fetchone()[0]
+    print(f"Table: {table_name}, Rows: {row_count}")
+
+conn.close()
+```
+
+**Expected Output**:
+```
+Tables in the database: [('fixes',), ('commits',), ('file_change',), ('method_change',), ('cve',), ('cwe',), ('cwe_classification',), ('repository',)]
+
+Headers for table 'fixes':
+Columns: ['cve_id', 'hash', 'repo_url']
+
+Headers for table 'commits':
+Columns: ['hash', 'repo_url', 'author', 'author_date', 'author_timezone', 'committer', 'committer_date', 'committer_timezone', 'msg', 'merge', 'parents', 'num_lines_added', 'num_lines_deleted', 'dmm_unit_complexity', 'dmm_unit_interfacing', 'dmm_unit_size']
+
+[... truncated for brevity ...]
+
+Table: fixes, Rows: 12923
+Table: commits, Rows: 12107
+Table: file_change, Rows: 51342
+Table: method_change, Rows: 277948
+Table: cve, Rows: 11873
+Table: cwe, Rows: 272
+Table: cwe_classification, Rows: 12198
+Table: repository, Rows: 4249
+```
+
+### Step 5: Retrieve All Distinct CVE IDs
+Extract unique CVE IDs from the `cve` table, which serves as the anchor for the dataset.
+
+```
+import sqlite3
+
+conn = sqlite3.connect('/content/CVEfixes.db')
+cursor = conn.cursor()
+
+cursor.execute("SELECT DISTINCT cve_id FROM cve;")
+cve_ids = [row[0] for row in cursor.fetchall()]
+print(f"Total CVEs found: {len(cve_ids)}")
+
+conn.close()
+```
+
+### Step 6: Split the CVE IDs
+Randomly shuffle and split the CVE IDs into training (70%), validation (15%), and test (15%) sets.
+
+```
+import random
+import json
+
+# Shuffle and split the dataset
+random.shuffle(cve_ids)
+n = len(cve_ids)
+train_split = cve_ids[:int(0.70 * n)]  # 70% for training
+val_split = cve_ids[int(0.70 * n):int(0.85 * n)]  # 15% for validation
+test_split = cve_ids[int(0.85 * n):]  # 15% for test
+
+# Save the splits to JSON files
+with open('/content/train_split.json', 'w') as f:
+    json.dump(train_split, f)
+with open('/content/val_split.json', 'w') as f:
+    json.dump(val_split, f)
+with open('/content/test_split.json', 'w') as f:
+    json.dump(test_split, f)
+
+# Print split sizes
+print("Train count:", len(train_split))
+print("Validation count:", len(val_split))
+print("Test count:", len(test_split))
+```
+
+**Expected Output**:
+```
+Total CVEs found: 11873
+Train count: 8311
+Validation count: 1781
+Test count: 1781
+```
+
+### Step 7: Process CVEs into JSONL Files
+Define a function to bundle data for each CVE across all tables and write it to JSONL files. Below is an example script to process the training split, skipping problematic CVEs. You can adapt it for validation and test splits by changing the input and output files.
+
+```
+import sqlite3
+import json
+import time
+import gc
+import os
+
+def dict_factory(cursor, row):
+    if cursor.description is None or row is None:
+        return None
+    return {col[0]: row[idx] for idx, col in enumerate(cursor.description)}
+
+def get_cwe_data(cursor, cve_id):
+    cursor.execute("""
+        SELECT cwe.* FROM cwe
+        JOIN cwe_classification ON cwe.cwe_id = cwe_classification.cwe_id
+        WHERE cwe_classification.cve_id = ?;
+    """, (cve_id,))
+    return cursor.fetchall()
+
+def get_repository_data(cursor, repo_url, repo_cache):
+    if repo_url in repo_cache:
+        return repo_cache[repo_url]
+    cursor.execute("SELECT * FROM repository WHERE repo_url = ?;", (repo_url,))
+    repo_data = cursor.fetchone()
+    repo_cache[repo_url] = repo_data
+    return repo_data
+
+def get_method_changes(cursor, file_change_id):
+    cursor.execute("SELECT * FROM method_change WHERE file_change_id = ?;", (file_change_id,))
+    return cursor.fetchall()
+
+def get_file_changes(cursor, commit_hash):
+    cursor.execute("SELECT * FROM file_change WHERE hash = ?;", (commit_hash,))
+    file_changes = []
+    for fc_row in cursor.fetchall():
+        file_change_data = fc_row
+        if file_change_data:
+            file_change_data['method_changes'] = get_method_changes(cursor, file_change_data['file_change_id'])
+            file_changes.append(file_change_data)
+    return file_changes
+
+def get_commit_data(cursor, commit_hash, repo_url, repo_cache):
+    cursor.execute("SELECT * FROM commits WHERE hash = ? AND repo_url = ?;", (commit_hash, repo_url))
+    commit_row = cursor.fetchone()
+    if not commit_row:
+        return None
+    commit_data = commit_row
+    commit_data['repository'] = get_repository_data(cursor, repo_url, repo_cache)
+    commit_data['file_changes'] = get_file_changes(cursor, commit_hash)
+    return commit_data
+
+def get_fixes_data(cursor, cve_id, repo_cache):
+    cursor.execute("SELECT * FROM fixes WHERE cve_id = ?;", (cve_id,))
+    fixes = []
+    for fix_row in cursor.fetchall():
+        fix_data = fix_row
+        if fix_data:
+            commit_details = get_commit_data(cursor, fix_data['hash'], fix_data['repo_url'], repo_cache)
+            if commit_details:
+                fix_data['commit_details'] = commit_details
+                fixes.append(fix_data)
+    return fixes
+
+def process_cve(cursor, cve_id, repo_cache):
+    cursor.execute("SELECT * FROM cve WHERE cve_id = ?;", (cve_id,))
+    cve_row = cursor.fetchone()
+    if not cve_row:
+        return None
+    cve_data = cve_row
+    cve_data['cwe_info'] = get_cwe_data(cursor, cve_id)
+    cve_data['fixes_info'] = get_fixes_data(cursor, cve_id, repo_cache)
+    return cve_data
+
+def process_split(split_name, split_file, db_path, output_file):
+    print(f"--- Processing {split_name} split ---")
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = dict_factory
+    cursor = conn.cursor()
+    repo_cache = {}
+    
+    with open(split_file, 'r') as f:
+        cve_ids = json.load(f)
+    
+    skip_cves = ["CVE-2021-3957", "CVE-2024-26152", "CVE-2016-5833", "CVE-2023-6848"]
+    with open(output_file, 'w') as outfile:
+        for i, cve_id in enumerate(cve_ids):
+            if cve_id in skip_cves:
+                print(f"Skipping {cve_id} due to memory constraints.")
+                continue
+            try:
+                cve_bundle = process_cve(cursor, cve_id, repo_cache)
+                if cve_bundle:
+                    outfile.write(json.dumps(cve_bundle) + '\n')
+                if (i + 1) % 50 == 0:
+                    print(f"Processed {i + 1}/{len(cve_ids)} CVEs")
+                    gc.collect()
+            except Exception as e:
+                print(f"Error processing {cve_id}: {e}")
+                continue
+    
+    conn.close()
+    gc.collect()
+    print(f"Finished processing {split_name} split. Output saved to {output_file}")
+
+# Example usage for training split
+process_split(
+    split_name="train",
+    split_file="/content/train_split.json",
+    db_path="/content/CVEfixes.db",
+    output_file="/content/train_data.jsonl"
+)
+```
+
+**Notes**:
+- Replace `train` with `val` or `test` and adjust file paths to process other splits.
+- The script skips the problematic CVEs listed above.
+- Output is written to a `.jsonl` file, with one JSON object per line.
+
+## Preprocessing
+The current splits (`train_data_part1.jsonl`, `train_data_part2.jsonl`, `val_data.jsonl`, `test_data.jsonl`) contain raw data from all tables. Preprocessing (e.g., feature extraction, normalization) will be addressed in subsequent steps depending on your use case.
+
+## Copyright and License
+Copyright © 2021-2024 Data-Driven Software Engineering Department (dataSED), Simula Research Laboratory, Norway
+
+This work is licensed under the [Creative Commons Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/).
+
+### Reference
+The original dataset is sourced from:
+
+**CVEfixes: Automated Collection of Vulnerabilities and Their Fixes from Open-Source Software**  
+Guru Bhandari, Amara Naseer, Leon Moonen  
+Simula Research Laboratory, Oslo, Norway  
+- Guru Bhandari: guru@simula.no  
+- Amara Naseer: amara@simula.no  
+- Leon Moonen: leon.moonen@computer.org  
+
+For more details, refer to the original publication at `https://dl.acm.org/doi/10.1145/3475960.3475985`.
+```