code/src/constructors/cpe_parser_system.py

# Advanced CPE Parsing and Product Extraction System

import re
import json
from typing import Dict, List, Tuple, Optional, Set
from dataclasses import dataclass
from urllib.parse import unquote
import logging
from collections import defaultdict, Counter

@dataclass
class CPEComponent:
    """Individual CPE component with metadata"""
    part: str  # a, h, o (application, hardware, operating system)
    vendor: str
    product: str
    version: str
    update: str
    edition: str
    language: str
    sw_edition: str
    target_sw: str
    target_hw: str
    other: str
    
    # Derived metadata
    is_wildcard: bool = False
    confidence_score: float = 1.0
    normalized_vendor: str = ""
    normalized_product: str = ""

class CPEParser:
    """Advanced CPE parsing with normalization and validation"""
    
    def __init__(self):
        self.vendor_aliases = self.load_vendor_aliases()
        self.product_mappings = self.load_product_mappings()
        self.version_patterns = self.compile_version_patterns()
        self.stop_words = {'the', 'inc', 'corp', 'corporation', 'ltd', 'limited', 'llc'}
        
    def load_vendor_aliases(self) -> Dict[str, List[str]]:
        """Load vendor name aliases and variations"""
        return {
            'microsoft': ['microsoft', 'ms', 'msft', 'redmond'],
            'apache': ['apache', 'apache_software_foundation', 'asf'],
            'oracle': ['oracle', 'oracle_corporation', 'sun_microsystems'],
            'google': ['google', 'alphabet', 'google_llc'],
            'amazon': ['amazon', 'aws', 'amazon_web_services'],
            'redhat': ['redhat', 'red_hat', 'rh'],
            'canonical': ['canonical', 'ubuntu'],
            'mozilla': ['mozilla', 'mozilla_foundation'],
            'adobe': ['adobe', 'adobe_systems', 'macromedia'],
            'ibm': ['ibm', 'international_business_machines']
        }
    
    def load_product_mappings(self) -> Dict[str, Dict[str, any]]:
        """Load product metadata and categorizations"""
        return {
            'android': {
                'category': 'Mobile OS',
                'family': 'Android',
                'criticality': 9.0,
                'aliases': ['android']
            },
            'linux_kernel': {
                'category': 'Operating System',
                'family': 'Linux',
                'criticality': 8.5,
                'aliases': ['linux_kernel', 'linux', 'gnu_linux']
            },
            'junos': {
                'category': 'Network OS',
                'family': 'Juniper Junos',
                'criticality': 8.0,
                'aliases': ['junos', 'juniper_junos']
            },
            'commerce': {
                'category': 'E-commerce',
                'family': 'Adobe Commerce',
                'criticality': 8.0,
                'aliases': ['commerce', 'adobe_commerce', 'magento_commerce']
            },
            'checkmk': {
                'category': 'Monitoring',
                'family': 'Checkmk',
                'criticality': 7.5,
                'aliases': ['checkmk']
            },
            'ios': {
                'category': 'Network OS',
                'family': 'Cisco IOS',
                'criticality': 8.5,
                'aliases': ['ios', 'cisco_ios']
            },
            'junos_os_evolved': {
                'category': 'Network OS',
                'family': 'Juniper Junos OS Evolved',
                'criticality': 8.0,
                'aliases': ['junos_os_evolved', 'juniper_junos_os_evolved']
            },
            'ios_xe': {
                'category': 'Network OS',
                'family': 'Cisco IOS XE',
                'criticality': 8.5,
                'aliases': ['ios_xe', 'cisco_ios_xe']
            },
            'adaptive_security_appliance_software': {
                'category': 'Security Appliance',
                'family': 'Cisco ASA',
                'criticality': 8.5,
                'aliases': ['adaptive_security_appliance_software', 'cisco_asa']
            },
            'magento': {
                'category': 'E-commerce',
                'family': 'Adobe Magento',
                'criticality': 8.0,
                'aliases': ['magento', 'adobe_magento']
            },
            'digital_experience_platform': {
                'category': 'Portal',
                'family': 'Liferay DXP',
                'criticality': 7.5,
                'aliases': ['digital_experience_platform', 'liferay_dxp']
            },
            'secure_firewall_management_center': {
                'category': 'Security Appliance',
                'family': 'Cisco Secure Firewall Management Center',
                'criticality': 8.0,
                'aliases': ['secure_firewall_management_center', 'cisco_firewall_management_center']
            },
            'windows_server_2012': {
                'category': 'Operating System',
                'family': 'Windows Server',
                'criticality': 9.0,
                'aliases': ['windows_server_2012', 'windows_server', 'microsoft_windows_server_2012']
            },
            'nx-os': {
                'category': 'Network OS',
                'family': 'Cisco NX-OS',
                'criticality': 8.0,
                'aliases': ['nx-os', 'cisco_nx-os']
            },
            'identity_services_engine': {
                'category': 'Security Appliance',
                'family': 'Cisco ISE',
                'criticality': 8.0,
                'aliases': ['identity_services_engine', 'cisco_ise']
            },
            'macos': {
                'category': 'Operating System',
                'family': 'Apple macOS',
                'criticality': 8.5,
                'aliases': ['macos', 'apple_macos', 'osx']
            },
            'windows_10_22h2': {
                'category': 'Operating System',
                'family': 'Windows 10',
                'criticality': 9.0,
                'aliases': ['windows_10_22h2', 'windows_10', 'microsoft_windows_10_22h2']
            },
            'windows_10_1809': {
                'category': 'Operating System',
                'family': 'Windows 10',
                'criticality': 9.0,
                'aliases': ['windows_10_1809', 'windows_10', 'microsoft_windows_10_1809']
            },
            'windows_server_2008': {
                'category': 'Operating System',
                'family': 'Windows Server',
                'criticality': 8.5,
                'aliases': ['windows_server_2008', 'windows_server', 'microsoft_windows_server_2008']
            },
            'windows': {
                'category': 'Operating System',
                'family': 'Windows',
                'criticality': 9.0,
                'aliases': ['windows', 'win', 'microsoft_windows']
            },
            'linux': {
                'category': 'Operating System', 
                'family': 'Linux',
                'criticality': 8.5,
                'aliases': ['linux', 'gnu_linux', 'linux_kernel']
            },
            'http_server': {
                'category': 'Web Server',
                'family': 'Apache HTTP Server', 
                'criticality': 8.0,
                'aliases': ['apache', 'httpd', 'apache_httpd']
            },
            'mysql': {
                'category': 'Database',
                'family': 'MySQL',
                'criticality': 7.5,
                'aliases': ['mysql', 'mysql_server']
            }
        }
    
    def compile_version_patterns(self) -> Dict[str, re.Pattern]:
        """Compile regex patterns for version extraction"""
        return {
            'semantic': re.compile(r'^(\d+)\.(\d+)(?:\.(\d+))?(?:\.(\d+))?'),
            'date_based': re.compile(r'^(\d{4})(?:\.(\d{2}))?(?:\.(\d{2}))?'),
            'build_number': re.compile(r'^(\d+)(?:\.(\d+))*(?:-(\w+))?'),
            'alpha_beta': re.compile(r'^(\d+\.?\d*)\s*-?\s*(alpha|beta|rc|release|final)'),
            'windows_version': re.compile(r'^(vista|xp|2000|2003|2008|2012|2016|2019|2022)'),
        }
    
    def parse_cpe23_string(self, cpe_string: str) -> Optional[CPEComponent]:
        """Parse CPE 2.3 format string"""
        try:
            if not cpe_string.startswith('cpe:2.3:'):
                return None
                
            # Remove cpe:2.3: prefix and split by colons
            components = cpe_string[9:].split(':')
            
            if len(components) < 11:
                # Pad with wildcards if insufficient components
                components.extend(['*'] * (11 - len(components)))
            
            # Decode URL encoding and handle special values
            decoded_components = []
            for comp in components[:11]:  # Only take first 11 components
                if comp == '*':
                    decoded_components.append('*')
                elif comp == '-':
                    decoded_components.append('')
                else:
                    decoded_components.append(unquote(comp))
            
            cpe_comp = CPEComponent(
                part=decoded_components[0],
                vendor=decoded_components[1],
                product=decoded_components[2], 
                version=decoded_components[3],
                update=decoded_components[4],
                edition=decoded_components[5],
                language=decoded_components[6],
                sw_edition=decoded_components[7],
                target_sw=decoded_components[8],
                target_hw=decoded_components[9],
                other=decoded_components[10]
            )
            
            # Set derived properties
            cpe_comp.is_wildcard = self.is_wildcard_cpe(cpe_comp)
            cpe_comp.normalized_vendor = self.normalize_vendor(cpe_comp.vendor)
            cpe_comp.normalized_product = self.normalize_product(cpe_comp.product)
            cpe_comp.confidence_score = self.calculate_confidence(cpe_comp)
            
            return cpe_comp
            
        except Exception as e:
            logging.error(f"Error parsing CPE {cpe_string}: {e}")
            return None
    
    def normalize_vendor(self, vendor: str) -> str:
        """Normalize vendor name using aliases"""
        if not vendor or vendor == '*':
            return vendor
            
        vendor_lower = vendor.lower().replace('_', ' ')
        
        # Remove common suffixes
        for suffix in self.stop_words:
            vendor_lower = vendor_lower.replace(f' {suffix}', '')
        
        # Check aliases
        for canonical, aliases in self.vendor_aliases.items():
            if vendor_lower in aliases:
                return canonical
                
        return vendor.lower().replace(' ', '_')
    
    def normalize_product(self, product: str) -> str:
        """Normalize product name"""
        if not product or product == '*':
            return product
            
        product_lower = product.lower().replace('_', ' ')
        
        # Handle common product name variations
        normalizations = {
            'http server': 'http_server',
            'web server': 'web_server', 
            'mysql server': 'mysql',
            'sql server': 'sql_server',
            'internet explorer': 'internet_explorer'
        }
        
        for variant, canonical in normalizations.items():
            if variant in product_lower:
                return canonical
                
        return product.lower().replace(' ', '_')
    
    def is_wildcard_cpe(self, cpe: CPEComponent) -> bool:
        """Check if CPE contains wildcards indicating generic match"""
        wildcard_fields = [cpe.vendor, cpe.product, cpe.version]
        return any(field == '*' for field in wildcard_fields)
    
    def calculate_confidence(self, cpe: CPEComponent) -> float:
        """Calculate confidence score for CPE parsing"""
        confidence = 1.0
        
        # Reduce confidence for wildcards
        if cpe.vendor == '*':
            confidence -= 0.3
        if cpe.product == '*':
            confidence -= 0.4
        if cpe.version == '*':
            confidence -= 0.2
            
        # Reduce confidence for very short/generic names
        if len(cpe.vendor) <= 2 and cpe.vendor != '*':
            confidence -= 0.1
        if len(cpe.product) <= 2 and cpe.product != '*':
            confidence -= 0.1
            
        return max(0.0, confidence)
    
    def extract_version_info(self, version_string: str) -> Dict[str, any]:
        """Extract structured version information"""
        if not version_string or version_string == '*':
            return {'raw': version_string, 'type': 'unknown'}
        
        version_info = {'raw': version_string}
        
        # Try different version patterns
        for pattern_name, pattern in self.version_patterns.items():
            match = pattern.match(version_string)
            if match:
                version_info['type'] = pattern_name
                version_info['groups'] = match.groups()
                
                if pattern_name == 'semantic':
                    version_info['major'] = int(match.group(1))
                    version_info['minor'] = int(match.group(2)) if match.group(2) else 0
                    version_info['patch'] = int(match.group(3)) if match.group(3) else 0
                    version_info['build'] = int(match.group(4)) if match.group(4) else 0
                
                break
        else:
            version_info['type'] = 'custom'
            
        return version_info

class ProductExtractor:
    """Extract and enrich product information from CVE data"""
    
    def __init__(self):
        self.cpe_parser = CPEParser()
        self.product_database = {}
        self.vendor_database = {}
        
    def extract_products_from_cve_data(self, cve_data: List[Dict]) -> Dict[str, any]:
        """Extract products and vendors from CVE data, only for valid CPEs"""
        products = {}
        vendors = {}
        product_vulnerabilities = defaultdict(list)
        vendor_vulnerabilities = defaultdict(list)
        cves_with_no_valid_cpe = []

        for cve in cve_data:
            cve_id = cve.get('id')
            configurations = cve.get('configurations', {})
            cpe_list = self.extract_cpe_from_configurations(configurations)
            valid_cpe_found = False
            for cpe_str in cpe_list:
                if not cpe_str or not isinstance(cpe_str, str) or not cpe_str.startswith('cpe:2.3:'):
                    continue  # Skip empty or malformed CPE strings
                cpe_obj = self.cpe_parser.parse_cpe23_string(cpe_str)
                if not cpe_obj:
                    continue  # Skip malformed CPEs
                valid_cpe_found = True
                product_key = f"{cpe_obj.normalized_vendor}:{cpe_obj.normalized_product}"
                print(f"[DEBUG] Creating/updating product {product_key} from CPE: {cpe_str}")
                # Create or update product record
                if product_key not in products:
                    products[product_key] = self.create_product_record(cpe_obj)
                # Add version info
                version_info = self.cpe_parser.extract_version_info(cpe_obj.version)
                self.add_version_to_product(products[product_key], version_info, cve_id)
                # Track vulnerabilities
                product_vulnerabilities[product_key].append(cve_id)
                # Create or update vendor record
                vendor_key = cpe_obj.normalized_vendor
                if vendor_key not in vendors:
                    vendors[vendor_key] = self.create_vendor_record(cpe_obj)
                if product_key not in vendors[vendor_key]['products']:
                    vendors[vendor_key]['products'].append(product_key)
                vendor_vulnerabilities[vendor_key].append(cve_id)
            if not valid_cpe_found:
                print(f"[DEBUG] Skipping CVE {cve_id}: no valid CPEs found.")
                cves_with_no_valid_cpe.append(cve_id)

        # Enrich products with vulnerability statistics
        self.enrich_products_with_stats(products, product_vulnerabilities)
        self.enrich_vendors_with_stats(vendors, vendor_vulnerabilities)

        if cves_with_no_valid_cpe:
            print(f"[INFO] Skipped {len(cves_with_no_valid_cpe)} CVEs with no valid CPEs. Example IDs: {cves_with_no_valid_cpe[:5]}")

        return {
            'products': products,
            'vendors': vendors,
            'product_vulnerabilities': dict(product_vulnerabilities),
            'vendor_vulnerabilities': dict(vendor_vulnerabilities),
            'skipped_cves_no_cpe': cves_with_no_valid_cpe
        }
    
    def extract_cpe_from_configurations(self, configurations: Dict) -> List[str]:
        """Extract CPE strings from CVE configuration data"""
        cpe_list = []
        
        def extract_recursive(config):
            if isinstance(config, dict):
                # Handle CPE match criteria
                if 'cpe_match' in config:
                    for match in config['cpe_match']:
                        if 'cpe23Uri' in match:
                            cpe_list.append(match['cpe23Uri'])
                
                # Handle nodes structure
                if 'nodes' in config:
                    for node in config['nodes']:
                        extract_recursive(node)
                
                # Handle children structure
                if 'children' in config:
                    for child in config['children']:
                        extract_recursive(child)
                        
                # Recurse into other dict values
                for value in config.values():
                    if isinstance(value, (dict, list)):
                        extract_recursive(value)
            
            elif isinstance(config, list):
                for item in config:
                    extract_recursive(item)
        
        extract_recursive(configurations)
        return list(set(cpe_list))  # Remove duplicates
    
    def create_product_record(self, cpe: CPEComponent) -> Dict[str, any]:
        """Create comprehensive product record"""
        product_meta = self.cpe_parser.product_mappings.get(
            cpe.normalized_product, 
            None
        )
        if product_meta:
            category = product_meta['category']
            family = product_meta['family']
            criticality = product_meta['criticality']
            aliases = product_meta['aliases']
        else:
            part_category = {
                'a': 'Application',
                'o': 'Operating System',
                'h': 'Hardware'
            }
            category = part_category.get(cpe.part, 'Unknown')
            family = cpe.product.title()
            criticality = 5.0
            aliases = [cpe.product]
        return {
            'vendor': cpe.normalized_vendor,
            'product': cpe.normalized_product,
            'display_name': f"{cpe.vendor} {cpe.product}",
            'category': category,
            'family': family,
            'criticality_score': criticality,
            'aliases': aliases,
            'versions': {},
            'vulnerability_count': 0,
            'critical_vulnerability_count': 0,
            'first_vulnerability_date': None,
            'latest_vulnerability_date': None,
            'cpe_patterns': [cpe]
        }
    
    def create_vendor_record(self, cpe: CPEComponent) -> Dict[str, any]:
        """Create vendor record"""
        return {
            'name': cpe.normalized_vendor,
            'display_name': cpe.vendor.title(),
            'products': [],
            'vulnerability_count': 0,
            'critical_vulnerability_count': 0,
            'aliases': self.cpe_parser.vendor_aliases.get(cpe.normalized_vendor, [cpe.vendor])
        }
    
    def add_version_to_product(self, product: Dict, version_info: Dict, cve_id: str):
        """Add version information to product record"""
        version_key = version_info['raw']
        
        if version_key not in product['versions']:
            product['versions'][version_key] = {
                'version_string': version_key,
                'version_info': version_info,
                'vulnerabilities': [],
                'vulnerability_count': 0
            }
        
        product['versions'][version_key]['vulnerabilities'].append(cve_id)
        product['versions'][version_key]['vulnerability_count'] += 1
    
    def enrich_products_with_stats(self, products: Dict, product_vulnerabilities: Dict):
        """Add vulnerability statistics to products"""
        for product_key, vuln_list in product_vulnerabilities.items():
            if product_key in products:
                products[product_key]['vulnerability_count'] = len(vuln_list)
                # Additional enrichment would require CVE severity data
    
    def enrich_vendors_with_stats(self, vendors: Dict, vendor_vulnerabilities: Dict):
        """Add vulnerability statistics to vendors"""
        for vendor_key, vuln_list in vendor_vulnerabilities.items():
            if vendor_key in vendors:
                vendors[vendor_key]['vulnerability_count'] = len(vuln_list)
    
    def generate_product_hierarchy(self, products: Dict) -> Dict[str, any]:
        """Generate hierarchical product structure"""
        hierarchy = {
            'vendors': {},
            'categories': defaultdict(list),
            'families': defaultdict(list)
        }
        
        for product_key, product in products.items():
            vendor = product['vendor']
            category = product['category']
            family = product['family']
            
            # Vendor hierarchy
            if vendor not in hierarchy['vendors']:
                hierarchy['vendors'][vendor] = {
                    'products': [],
                    'total_vulnerabilities': 0
                }
            
            hierarchy['vendors'][vendor]['products'].append(product_key)
            hierarchy['vendors'][vendor]['total_vulnerabilities'] += product['vulnerability_count']
            
            # Category grouping
            hierarchy['categories'][category].append(product_key)
            
            # Family grouping  
            hierarchy['families'][family].append(product_key)
        
        return hierarchy

# Example usage and testing
def main():
    """Test the CPE parsing and product extraction system"""
    
    # Sample CVE data
    sample_cve_data = [
        {
            'id': 'CVE-2023-12345',
            'configurations': {
                'nodes': [
                    {
                        'cpe_match': [
                            {'cpe23Uri': 'cpe:2.3:a:apache:http_server:2.4.41:*:*:*:*:*:*:*'},
                            {'cpe23Uri': 'cpe:2.3:a:apache:http_server:2.4.42:*:*:*:*:*:*:*'}
                        ]
                    }
                ]
            }
        },
        {
            'id': 'CVE-2023-67890', 
            'configurations': {
                'nodes': [
                    {
                        'cpe_match': [
                            {'cpe23Uri': 'cpe:2.3:o:microsoft:windows_10:1909:*:*:*:*:*:*:*'},
                            {'cpe23Uri': 'cpe:2.3:o:microsoft:windows_server_2019:*:*:*:*:*:*:*:*'}
                        ]
                    }
                ]
            }
        }
    ]
    
    # Initialize extractor
    extractor = ProductExtractor()
    
    # Extract products
    results = extractor.extract_products_from_cve_data(sample_cve_data)
    
    print("Extracted Products:")
    for product_key, product in results['products'].items():
        print(f"  {product_key}: {product['display_name']} ({product['vulnerability_count']} vulnerabilities)")
    
    print("\nExtracted Vendors:")
    for vendor_key, vendor in results['vendors'].items():
        print(f"  {vendor_key}: {vendor['display_name']} ({vendor['vulnerability_count']} vulnerabilities)")
    
    # Generate hierarchy
    hierarchy = extractor.generate_product_hierarchy(results['products'])
    
    print("\nProduct Hierarchy by Category:")
    for category, products in hierarchy['categories'].items():
        print(f"  {category}: {len(products)} products")

if __name__ == "__main__":
    main()