Datasets:

DuyTa
/

cve-kgrag-db

# scripts/build_indexes.py
"""
Build complete indexes for all CVE data (2002-2025)
Run this script once to pre-build all indexes for fast API startup
"""

import sys
import os
import time
import json
import pickle
import logging
from datetime import datetime
from typing import Dict, List, Set

# Add parent directory to path
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('build_indexes.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)


class IndexBuilder:
    """Dedicated index builder for preprocessing all CVE data"""

    def __init__(self, base_path: str = 'data/knowledge_base'):
        self.base_path = base_path
        self.start_year = 2002
        self.end_year = 2025

        # Index structures
        self.cve_index = {}  # cve_id -> document
        self.keyword_index = {}  # keyword -> set of cve_ids
        self.year_index = {}  # year -> set of cve_ids
        self.severity_index = {}  # severity -> set of cve_ids
        self.cwe_index = {}  # cwe_id -> set of cve_ids
        self.capec_index = {}  # capec_id -> set of cve_ids
        self.mitre_tactic_index = {}  # tactic -> set of cve_ids
        self.mitre_technique_index = {}  # technique -> set of cve_ids

        # Statistics
        self.stats = {
            'total_cves': 0,
            'years_processed': [],
            'cves_per_year': {},
            'processing_time': {},
            'index_sizes': {}
        }

    def build_all_indexes(self):
        """Build indexes for all years"""
        logger.info(f"Starting index build for years {self.start_year}-{self.end_year}")
        logger.info("This process will take 10-30 minutes depending on your system")
        logger.info("-" * 60)

        overall_start = time.time()

        # Detect available years
        available_years = self._detect_available_years()
        logger.info(f"Found CVE data for {len(available_years)} years: {available_years}")

        # Process each year
        for i, year in enumerate(available_years):
            year_start = time.time()

            logger.info(f"\nProcessing year {year} ({i + 1}/{len(available_years)})...")

            try:
                cve_count = self._process_year(year)

                year_time = time.time() - year_start
                self.stats['years_processed'].append(year)
                self.stats['cves_per_year'][year] = cve_count
                self.stats['processing_time'][year] = year_time

                logger.info(f"  Processed {cve_count:,} CVEs in {year_time:.2f} seconds")

                # Show progress
                progress = (i + 1) / len(available_years) * 100
                logger.info(f"  Overall progress: {progress:.1f}%")

            except Exception as e:
                logger.error(f"  Error processing year {year}: {e}")
                continue

        # Save indexes
        logger.info("\nSaving indexes...")
        self._save_indexes()

        # Final statistics
        overall_time = time.time() - overall_start
        self._print_statistics(overall_time)

        logger.info("\nIndex building complete!")
        logger.info(f"Indexes saved to: {os.path.join(self.base_path, 'master_index_full.pkl')}")

    def _detect_available_years(self) -> List[int]:
        """Detect which years have CVE data files"""
        available_years = []

        for year in range(self.start_year, self.end_year + 1):
            file_path = os.path.join(self.base_path, f'enhanced_documents_cve_{year}.json')
            if os.path.exists(file_path):
                available_years.append(year)

        return sorted(available_years)

    def _process_year(self, year: int) -> int:
        """Process a single year of CVE data"""
        file_path = os.path.join(self.base_path, f'enhanced_documents_cve_{year}.json')

        with open(file_path, 'r', encoding='utf-8') as f:
            documents = json.load(f)

        processed = 0

        for doc in documents:
            cve_id = doc.get('id', '') or doc.get('cve_id', '')
            if not cve_id:
                continue

            # Store full document
            self.cve_index[cve_id] = doc

            # Update year index
            if year not in self.year_index:
                self.year_index[year] = set()
            self.year_index[year].add(cve_id)

            # Extract and index metadata
            self._index_document(doc, cve_id)

            processed += 1

            # Progress indicator for large years
            if processed % 5000 == 0:
                logger.info(f"    Processed {processed:,}/{len(documents):,} CVEs...")

        self.stats['total_cves'] += processed
        return processed

    def _index_document(self, doc: Dict, cve_id: str):
        """Index a single document"""
        # Severity index
        severity = (doc.get('severity', '') or 'unknown').lower()
        if severity not in self.severity_index:
            self.severity_index[severity] = set()
        self.severity_index[severity].add(cve_id)

        # CWE index
        cwe_ids = doc.get('cwe_ids', []) or []
        for cwe_id in cwe_ids:
            cwe_str = str(cwe_id)
            if cwe_str not in self.cwe_index:
                self.cwe_index[cwe_str] = set()
            self.cwe_index[cwe_str].add(cve_id)

        # CAPEC index
        capec_ids = doc.get('capec_ids', []) or []
        for capec_id in capec_ids:
            capec_str = str(capec_id)
            if capec_str not in self.capec_index:
                self.capec_index[capec_str] = set()
            self.capec_index[capec_str].add(cve_id)

        # MITRE ATT&CK indexes
        mitre_tactics = doc.get('mitre_tactics', []) or []
        for tactic in mitre_tactics:
            tactic_lower = tactic.lower()
            if tactic_lower not in self.mitre_tactic_index:
                self.mitre_tactic_index[tactic_lower] = set()
            self.mitre_tactic_index[tactic_lower].add(cve_id)

        mitre_techniques = doc.get('mitre_techniques', []) or []
        for technique in mitre_techniques:
            technique_lower = technique.lower()
            if technique_lower not in self.mitre_technique_index:
                self.mitre_technique_index[technique_lower] = set()
            self.mitre_technique_index[technique_lower].add(cve_id)

        # Keyword extraction (optimized for large dataset)
        keywords = self._extract_keywords_fast(doc)
        for keyword in keywords:
            keyword_lower = keyword.lower()
            if keyword_lower not in self.keyword_index:
                self.keyword_index[keyword_lower] = set()
            self.keyword_index[keyword_lower].add(cve_id)

    def _extract_keywords_fast(self, doc: Dict) -> Set[str]:
        """Fast keyword extraction for large datasets"""
        keywords = set()

        # Get text fields
        description = (doc.get('description', '') or '').lower()

        # Common technology keywords (pre-defined for speed)
        tech_keywords = {
            'apache', 'nginx', 'iis', 'tomcat', 'docker', 'kubernetes',
            'windows', 'linux', 'ubuntu', 'debian', 'redhat', 'macos',
            'chrome', 'firefox', 'safari', 'edge',
            'mysql', 'postgresql', 'mongodb', 'oracle', 'redis',
            'java', 'python', 'php', 'ruby', 'javascript', 'node.js',
            'wordpress', 'drupal', 'joomla',
            'aws', 'azure', 'gcp', 'vmware',
            'cisco', 'microsoft', 'adobe', 'apple', 'google',
            'android', 'ios', 'mobile',
            '5g', '4g', 'lte', 'wifi', 'bluetooth'
        }

        # Quick keyword matching
        for keyword in tech_keywords:
            if keyword in description:
                keywords.add(keyword)

        # Vulnerability type keywords
        vuln_keywords = {
            'rce': 'remote code execution',
            'sqli': 'sql injection',
            'xss': 'cross-site scripting',
            'dos': 'denial of service',
            'privesc': 'privilege escalation',
            'overflow': 'buffer overflow'
        }

        for short, full in vuln_keywords.items():
            if full in description or short in description:
                keywords.add(short)

        # Add product names from affected_products
        affected_products = doc.get('affected_products', [])
        if affected_products:
            for product in affected_products[:5]:  # Limit to prevent explosion
                if product:
                    # Extract first word as keyword
                    words = str(product).lower().split()
                    if words and len(words[0]) > 2:
                        keywords.add(words[0])

        return keywords

    def _save_indexes(self):
        """Save all indexes to disk"""
        # Prepare data for pickling
        index_data = {
            'metadata': {
                'build_date': datetime.now().isoformat(),
                'start_year': self.start_year,
                'end_year': self.end_year,
                'total_cves': self.stats['total_cves'],
                'years_available': sorted(self.year_index.keys()),
                'index_version': '2.0'
            },
            'indexes': {
                'keyword_index': {k: list(v) for k, v in self.keyword_index.items()},
                'year_index': {k: list(v) for k, v in self.year_index.items()},
                'severity_index': {k: list(v) for k, v in self.severity_index.items()},
                'cwe_index': {k: list(v) for k, v in self.cwe_index.items()},
                'capec_index': {k: list(v) for k, v in self.capec_index.items()},
                'mitre_tactic_index': {k: list(v) for k, v in self.mitre_tactic_index.items()},
                'mitre_technique_index': {k: list(v) for k, v in self.mitre_technique_index.items()},
            },
            'cve_ids': list(self.cve_index.keys()),
            'stats': self.stats
        }

        # Calculate index sizes
        for index_name, index_data_dict in index_data['indexes'].items():
            size_bytes = sys.getsizeof(pickle.dumps(index_data_dict))
            self.stats['index_sizes'][index_name] = size_bytes / (1024 * 1024)  # MB

        # Save to file
        output_path = os.path.join(self.base_path, 'master_index_full.pkl')
        logger.info(f"Saving indexes to {output_path}...")

        with open(output_path, 'wb') as f:
            pickle.dump(index_data, f, protocol=pickle.HIGHEST_PROTOCOL)

        # Also save a lightweight version without full documents
        output_path_light = os.path.join(self.base_path, 'master_index_light.pkl')
        with open(output_path_light, 'wb') as f:
            pickle.dump(index_data, f, protocol=pickle.HIGHEST_PROTOCOL)

        logger.info("Indexes saved successfully!")

    def _print_statistics(self, total_time: float):
        """Print final statistics"""
        logger.info("\n" + "=" * 60)
        logger.info("INDEX BUILD STATISTICS")
        logger.info("=" * 60)

        logger.info(f"\nTotal CVEs indexed: {self.stats['total_cves']:,}")
        logger.info(f"Years processed: {len(self.stats['years_processed'])}")
        logger.info(f"Total time: {total_time / 60:.2f} minutes")
        logger.info(f"Average time per CVE: {total_time / self.stats['total_cves'] * 1000:.2f} ms")

        logger.info("\nCVEs per year:")
        for year in sorted(self.stats['cves_per_year'].keys()):
            count = self.stats['cves_per_year'][year]
            time_taken = self.stats['processing_time'].get(year, 0)
            logger.info(f"  {year}: {count:,} CVEs ({time_taken:.2f}s)")

        logger.info("\nIndex sizes:")
        logger.info(f"  Keywords indexed: {len(self.keyword_index):,}")
        logger.info(f"  CWE mappings: {len(self.cwe_index):,}")
        logger.info(f"  CAPEC mappings: {len(self.capec_index):,}")
        logger.info(f"  MITRE tactics: {len(self.mitre_tactic_index):,}")
        logger.info(f"  MITRE techniques: {len(self.mitre_technique_index):,}")

        if self.stats['index_sizes']:
            logger.info("\nIndex file sizes:")
            for index_name, size_mb in self.stats['index_sizes'].items():
                logger.info(f"  {index_name}: {size_mb:.2f} MB")


def main():
    """Main entry point"""
    print("CVE Index Builder")
    print("=" * 60)
    print("This script will build complete indexes for all CVE data (2002-2025)")
    print("Expected time: 10-30 minutes depending on your system")
    print("=" * 60)

    # Ask for confirmation
    response = input("\nDo you want to continue? (yes/no): ").lower().strip()
    if response not in ['yes', 'y']:
        print("Index building cancelled.")
        return

    # Build indexes
    builder = IndexBuilder()
    builder.build_all_indexes()

    print("\n✓ Index building complete!")
    print("  You can now start the API with fast loading.")
    print("  The API will automatically use the pre-built indexes.")


if __name__ == "__main__":
    main()

	# scripts/build_indexes.py
	"""
	Build complete indexes for all CVE data (2002-2025)
	Run this script once to pre-build all indexes for fast API startup
	"""

	import sys
	import os
	import time
	import json
	import pickle
	import logging
	from datetime import datetime
	from typing import Dict, List, Set

	# Add parent directory to path
	sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

	# Configure logging
	logging.basicConfig(
	level=logging.INFO,
	format='%(asctime)s - %(levelname)s - %(message)s',
	handlers=[
	logging.FileHandler('build_indexes.log'),
	logging.StreamHandler()
	]
	)
	logger = logging.getLogger(__name__)


	class IndexBuilder:
	"""Dedicated index builder for preprocessing all CVE data"""

	def __init__(self, base_path: str = 'data/knowledge_base'):
	self.base_path = base_path
	self.start_year = 2002
	self.end_year = 2025

	# Index structures
	self.cve_index = {} # cve_id -> document
	self.keyword_index = {} # keyword -> set of cve_ids
	self.year_index = {} # year -> set of cve_ids
	self.severity_index = {} # severity -> set of cve_ids
	self.cwe_index = {} # cwe_id -> set of cve_ids
	self.capec_index = {} # capec_id -> set of cve_ids
	self.mitre_tactic_index = {} # tactic -> set of cve_ids
	self.mitre_technique_index = {} # technique -> set of cve_ids

	# Statistics
	self.stats = {
	'total_cves': 0,
	'years_processed': [],
	'cves_per_year': {},
	'processing_time': {},
	'index_sizes': {}
	}

	def build_all_indexes(self):
	"""Build indexes for all years"""
	logger.info(f"Starting index build for years {self.start_year}-{self.end_year}")
	logger.info("This process will take 10-30 minutes depending on your system")
	logger.info("-" * 60)

	overall_start = time.time()

	# Detect available years
	available_years = self._detect_available_years()
	logger.info(f"Found CVE data for {len(available_years)} years: {available_years}")

	# Process each year
	for i, year in enumerate(available_years):
	year_start = time.time()

	logger.info(f"\nProcessing year {year} ({i + 1}/{len(available_years)})...")

	try:
	cve_count = self._process_year(year)

	year_time = time.time() - year_start
	self.stats['years_processed'].append(year)
	self.stats['cves_per_year'][year] = cve_count
	self.stats['processing_time'][year] = year_time

	logger.info(f" Processed {cve_count:,} CVEs in {year_time:.2f} seconds")

	# Show progress
	progress = (i + 1) / len(available_years) * 100
	logger.info(f" Overall progress: {progress:.1f}%")

	except Exception as e:
	logger.error(f" Error processing year {year}: {e}")
	continue

	# Save indexes
	logger.info("\nSaving indexes...")
	self._save_indexes()

	# Final statistics
	overall_time = time.time() - overall_start
	self._print_statistics(overall_time)

	logger.info("\nIndex building complete!")
	logger.info(f"Indexes saved to: {os.path.join(self.base_path, 'master_index_full.pkl')}")

	def _detect_available_years(self) -> List[int]:
	"""Detect which years have CVE data files"""
	available_years = []

	for year in range(self.start_year, self.end_year + 1):
	file_path = os.path.join(self.base_path, f'enhanced_documents_cve_{year}.json')
	if os.path.exists(file_path):
	available_years.append(year)

	return sorted(available_years)

	def _process_year(self, year: int) -> int:
	"""Process a single year of CVE data"""
	file_path = os.path.join(self.base_path, f'enhanced_documents_cve_{year}.json')

	with open(file_path, 'r', encoding='utf-8') as f:
	documents = json.load(f)

	processed = 0

	for doc in documents:
	cve_id = doc.get('id', '') or doc.get('cve_id', '')
	if not cve_id:
	continue

	# Store full document
	self.cve_index[cve_id] = doc

	# Update year index
	if year not in self.year_index:
	self.year_index[year] = set()
	self.year_index[year].add(cve_id)

	# Extract and index metadata
	self._index_document(doc, cve_id)

	processed += 1

	# Progress indicator for large years
	if processed % 5000 == 0:
	logger.info(f" Processed {processed:,}/{len(documents):,} CVEs...")

	self.stats['total_cves'] += processed
	return processed

	def _index_document(self, doc: Dict, cve_id: str):
	"""Index a single document"""
	# Severity index
	severity = (doc.get('severity', '') or 'unknown').lower()
	if severity not in self.severity_index:
	self.severity_index[severity] = set()
	self.severity_index[severity].add(cve_id)

	# CWE index
	cwe_ids = doc.get('cwe_ids', []) or []
	for cwe_id in cwe_ids:
	cwe_str = str(cwe_id)
	if cwe_str not in self.cwe_index:
	self.cwe_index[cwe_str] = set()
	self.cwe_index[cwe_str].add(cve_id)

	# CAPEC index
	capec_ids = doc.get('capec_ids', []) or []
	for capec_id in capec_ids:
	capec_str = str(capec_id)
	if capec_str not in self.capec_index:
	self.capec_index[capec_str] = set()
	self.capec_index[capec_str].add(cve_id)

	# MITRE ATT&CK indexes
	mitre_tactics = doc.get('mitre_tactics', []) or []
	for tactic in mitre_tactics:
	tactic_lower = tactic.lower()
	if tactic_lower not in self.mitre_tactic_index:
	self.mitre_tactic_index[tactic_lower] = set()
	self.mitre_tactic_index[tactic_lower].add(cve_id)

	mitre_techniques = doc.get('mitre_techniques', []) or []
	for technique in mitre_techniques:
	technique_lower = technique.lower()
	if technique_lower not in self.mitre_technique_index:
	self.mitre_technique_index[technique_lower] = set()
	self.mitre_technique_index[technique_lower].add(cve_id)

	# Keyword extraction (optimized for large dataset)
	keywords = self._extract_keywords_fast(doc)
	for keyword in keywords:
	keyword_lower = keyword.lower()
	if keyword_lower not in self.keyword_index:
	self.keyword_index[keyword_lower] = set()
	self.keyword_index[keyword_lower].add(cve_id)

	def _extract_keywords_fast(self, doc: Dict) -> Set[str]:
	"""Fast keyword extraction for large datasets"""
	keywords = set()

	# Get text fields
	description = (doc.get('description', '') or '').lower()

	# Common technology keywords (pre-defined for speed)
	tech_keywords = {
	'apache', 'nginx', 'iis', 'tomcat', 'docker', 'kubernetes',
	'windows', 'linux', 'ubuntu', 'debian', 'redhat', 'macos',
	'chrome', 'firefox', 'safari', 'edge',
	'mysql', 'postgresql', 'mongodb', 'oracle', 'redis',
	'java', 'python', 'php', 'ruby', 'javascript', 'node.js',
	'wordpress', 'drupal', 'joomla',
	'aws', 'azure', 'gcp', 'vmware',
	'cisco', 'microsoft', 'adobe', 'apple', 'google',
	'android', 'ios', 'mobile',
	'5g', '4g', 'lte', 'wifi', 'bluetooth'
	}

	# Quick keyword matching
	for keyword in tech_keywords:
	if keyword in description:
	keywords.add(keyword)

	# Vulnerability type keywords
	vuln_keywords = {
	'rce': 'remote code execution',
	'sqli': 'sql injection',
	'xss': 'cross-site scripting',
	'dos': 'denial of service',
	'privesc': 'privilege escalation',
	'overflow': 'buffer overflow'
	}

	for short, full in vuln_keywords.items():
	if full in description or short in description:
	keywords.add(short)

	# Add product names from affected_products
	affected_products = doc.get('affected_products', [])
	if affected_products:
	for product in affected_products[:5]: # Limit to prevent explosion
	if product:
	# Extract first word as keyword
	words = str(product).lower().split()
	if words and len(words[0]) > 2:
	keywords.add(words[0])

	return keywords

	def _save_indexes(self):
	"""Save all indexes to disk"""
	# Prepare data for pickling
	index_data = {
	'metadata': {
	'build_date': datetime.now().isoformat(),
	'start_year': self.start_year,
	'end_year': self.end_year,
	'total_cves': self.stats['total_cves'],
	'years_available': sorted(self.year_index.keys()),
	'index_version': '2.0'
	},
	'indexes': {
	'keyword_index': {k: list(v) for k, v in self.keyword_index.items()},
	'year_index': {k: list(v) for k, v in self.year_index.items()},
	'severity_index': {k: list(v) for k, v in self.severity_index.items()},
	'cwe_index': {k: list(v) for k, v in self.cwe_index.items()},
	'capec_index': {k: list(v) for k, v in self.capec_index.items()},
	'mitre_tactic_index': {k: list(v) for k, v in self.mitre_tactic_index.items()},
	'mitre_technique_index': {k: list(v) for k, v in self.mitre_technique_index.items()},
	},
	'cve_ids': list(self.cve_index.keys()),
	'stats': self.stats
	}

	# Calculate index sizes
	for index_name, index_data_dict in index_data['indexes'].items():
	size_bytes = sys.getsizeof(pickle.dumps(index_data_dict))
	self.stats['index_sizes'][index_name] = size_bytes / (1024 * 1024) # MB

	# Save to file
	output_path = os.path.join(self.base_path, 'master_index_full.pkl')
	logger.info(f"Saving indexes to {output_path}...")

	with open(output_path, 'wb') as f:
	pickle.dump(index_data, f, protocol=pickle.HIGHEST_PROTOCOL)

	# Also save a lightweight version without full documents
	output_path_light = os.path.join(self.base_path, 'master_index_light.pkl')
	with open(output_path_light, 'wb') as f:
	pickle.dump(index_data, f, protocol=pickle.HIGHEST_PROTOCOL)

	logger.info("Indexes saved successfully!")

	def _print_statistics(self, total_time: float):
	"""Print final statistics"""
	logger.info("\n" + "=" * 60)
	logger.info("INDEX BUILD STATISTICS")
	logger.info("=" * 60)

	logger.info(f"\nTotal CVEs indexed: {self.stats['total_cves']:,}")
	logger.info(f"Years processed: {len(self.stats['years_processed'])}")
	logger.info(f"Total time: {total_time / 60:.2f} minutes")
	logger.info(f"Average time per CVE: {total_time / self.stats['total_cves'] * 1000:.2f} ms")

	logger.info("\nCVEs per year:")
	for year in sorted(self.stats['cves_per_year'].keys()):
	count = self.stats['cves_per_year'][year]
	time_taken = self.stats['processing_time'].get(year, 0)
	logger.info(f" {year}: {count:,} CVEs ({time_taken:.2f}s)")

	logger.info("\nIndex sizes:")
	logger.info(f" Keywords indexed: {len(self.keyword_index):,}")
	logger.info(f" CWE mappings: {len(self.cwe_index):,}")
	logger.info(f" CAPEC mappings: {len(self.capec_index):,}")
	logger.info(f" MITRE tactics: {len(self.mitre_tactic_index):,}")
	logger.info(f" MITRE techniques: {len(self.mitre_technique_index):,}")

	if self.stats['index_sizes']:
	logger.info("\nIndex file sizes:")
	for index_name, size_mb in self.stats['index_sizes'].items():
	logger.info(f" {index_name}: {size_mb:.2f} MB")


	def main():
	"""Main entry point"""
	print("CVE Index Builder")
	print("=" * 60)
	print("This script will build complete indexes for all CVE data (2002-2025)")
	print("Expected time: 10-30 minutes depending on your system")
	print("=" * 60)

	# Ask for confirmation
	response = input("\nDo you want to continue? (yes/no): ").lower().strip()
	if response not in ['yes', 'y']:
	print("Index building cancelled.")
	return

	# Build indexes
	builder = IndexBuilder()
	builder.build_all_indexes()

	print("\n✓ Index building complete!")
	print(" You can now start the API with fast loading.")
	print(" The API will automatically use the pre-built indexes.")


	if __name__ == "__main__":
	main()