code/scripts/build_indexes.py

# 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()