code/src/mapper/simple_tie_inference.py

import json
import logging
import sys
import os
from pathlib import Path
from typing import Dict, List, Tuple, Set, Optional
import zipfile
import tempfile

logger = logging.getLogger(__name__)

# Try to import numpy
try:
    import numpy as np
    NUMPY_AVAILABLE = True
except ImportError:
    logger.warning("NumPy not available, TIE inference will be disabled")
    NUMPY_AVAILABLE = False


class SimpleTIEInference:
    """Simplified TIE inference using pre-trained embeddings without full TensorFlow dependencies."""
    
    def __init__(self, model_path: Path, enrichment_path: Path):
        """Initialize simple TIE inference.
        
        Args:
            model_path: Path to the trained model (.zip file)
            enrichment_path: Path to enrichment JSON file
        """
        self.model_path = model_path
        self.enrichment_path = enrichment_path
        self.model_loaded = False
        self.technique_names = {}
        self.technique_ids = []
        
        if NUMPY_AVAILABLE:
            self._load_model()
            self._load_technique_metadata()
    
    def _load_model(self):
        """Load the pre-trained TIE model embeddings."""
        try:
            # Extract and load model components
            with tempfile.TemporaryDirectory() as tmpdir:
                with zipfile.ZipFile(self.model_path, 'r') as zf:
                    zf.extractall(tmpdir)
                
                # Load embeddings and metadata
                self.U = np.load(Path(tmpdir) / "U.npy")  # Report embeddings
                self.V = np.load(Path(tmpdir) / "V.npy")  # Technique embeddings
                
                # Load technique IDs
                technique_ids = np.load(Path(tmpdir) / "technique_ids.npy", allow_pickle=True)
                if isinstance(technique_ids[0], bytes):
                    self.technique_ids = [t.decode('utf-8') for t in technique_ids]
                else:
                    self.technique_ids = technique_ids.tolist()
                
                # Load hyperparameters
                try:
                    hp = np.load(Path(tmpdir) / "hyperparameters.npy", allow_pickle=True)
                    if len(hp) > 0:
                        self.hyperparameters = {
                            'c': float(hp[0][0]) if len(hp[0]) > 0 else 0.001,
                            'epochs': int(hp[0][1]) if len(hp[0]) > 1 else 25,
                            'regularization_coefficient': float(hp[0][2]) if len(hp[0]) > 2 else 0.00001
                        }
                    else:
                        self.hyperparameters = {'c': 0.001, 'epochs': 25, 'regularization_coefficient': 0.00001}
                except:
                    self.hyperparameters = {'c': 0.001, 'epochs': 25, 'regularization_coefficient': 0.00001}
            
            self.model_loaded = True
            self.m, self.k = self.U.shape  # Number of reports, embedding dimension
            self.n = self.V.shape[0]  # Number of techniques
            
            logger.info(f"Loaded TIE embeddings: {self.m} reports, {self.n} techniques, {self.k}-dim")
            
        except Exception as e:
            logger.error(f"Failed to load TIE model: {e}")
            self.model_loaded = False
    
    def _load_technique_metadata(self):
        """Load technique names and descriptions from enrichment data."""
        try:
            with open(self.enrichment_path, 'r', encoding='utf-8') as f:
                enrichment_data = json.load(f)
            
            # Extract technique names - the structure is {"techniques": {"T1234": {...}}}
            techniques_dict = enrichment_data.get('techniques', {})
            for tech_id, technique_data in techniques_dict.items():
                if isinstance(technique_data, dict):
                    self.technique_names[tech_id] = technique_data.get('name', tech_id)
                
        except Exception as e:
            logger.error(f"Failed to load enrichment data: {e}")
    
    def extract_keywords_from_cve(self, cve_description: str) -> Set[str]:
        """Extract relevant keywords from CVE description for TTP inference."""
        keyword_mappings = {
            # Exploitation techniques
            'remote code execution': ['T1203', 'T1210'],
            'rce': ['T1203', 'T1210'],
            'arbitrary code': ['T1203', 'T1055'],
            'code execution': ['T1203', 'T1059'],
            
            # Privilege escalation
            'privilege escalation': ['T1068', 'T1078', 'T1548'],
            'elevation of privilege': ['T1068', 'T1548'],
            'root access': ['T1068', 'T1548.001'],
            'admin access': ['T1078', 'T1098'],
            
            # Injection attacks
            'sql injection': ['T1190'],
            'command injection': ['T1059', 'T1190'],
            'code injection': ['T1055', 'T1055.001'],
            'ldap injection': ['T1190'],
            
            # Web attacks
            'cross-site scripting': ['T1059.007', 'T1189'],
            'xss': ['T1059.007', 'T1189'],
            'csrf': ['T1185'],
            'xxe': ['T1190'],
            'ssrf': ['T1190', 'T1090'],
            
            # Memory corruption
            'buffer overflow': ['T1203', 'T1055'],
            'heap overflow': ['T1203', 'T1055'],
            'stack overflow': ['T1203', 'T1055'],
            'use after free': ['T1055', 'T1203'],
            'memory corruption': ['T1055', 'T1203'],
            
            # Authentication/Access
            'authentication bypass': ['T1078', 'T1110'],
            'access control': ['T1078', 'T1548'],
            'unauthorized access': ['T1078', 'T1190'],
            
            # DoS attacks
            'denial of service': ['T1499', 'T1498'],
            'dos': ['T1499', 'T1498'],
            'resource exhaustion': ['T1499', 'T1496'],
            
            # Information disclosure
            'information disclosure': ['T1005', 'T1083', 'T1057'],
            'data exposure': ['T1005', 'T1530'],
            'sensitive information': ['T1005', 'T1552'],
            
            # File/Path issues
            'directory traversal': ['T1083', 'T1570'],
            'path traversal': ['T1083', 'T1570'],
            'file inclusion': ['T1055', 'T1574'],
        }
        
        description_lower = cve_description.lower()
        found_ttps = set()
        
        for keyword, ttps in keyword_mappings.items():
            if keyword in description_lower:
                found_ttps.update(ttps)
        
        return found_ttps
    
    def infer_ttps_from_description(self, cve_description: str, confidence_threshold: float = 0.1) -> Tuple[List[str], Dict]:
        """Infer TTPs from CVE description using simplified TIE approach."""
        
        # First, extract keywords
        keyword_ttps = self.extract_keywords_from_cve(cve_description)
        
        if not self.model_loaded or not NUMPY_AVAILABLE:
            return list(keyword_ttps), {"method": "keyword_extraction", "reason": "TIE model not available"}
        
        if not keyword_ttps:
            return [], {"method": "simple_tie", "message": "No techniques identified in description"}
        
        try:
            # Find indices of observed techniques in our model
            observed_indices = []
            for tech in keyword_ttps:
                if tech in self.technique_ids:
                    idx = self.technique_ids.index(tech)
                    observed_indices.append(idx)
            
            if not observed_indices:
                return list(keyword_ttps), {"method": "keyword_extraction", "message": "No known techniques found in model"}
            
            # Use technique embeddings to find similar techniques
            # Get embeddings of observed techniques
            observed_embeddings = self.V[observed_indices]
            
            # Compute average embedding of observed techniques
            avg_embedding = np.mean(observed_embeddings, axis=0)
            
            # Compute similarity with all techniques using cosine similarity
            # Handle zero division for techniques with zero embeddings
            v_norms = np.linalg.norm(self.V, axis=1)
            avg_norm = np.linalg.norm(avg_embedding)
            
            # Avoid division by zero
            v_norms = np.where(v_norms == 0, 1e-8, v_norms)
            avg_norm = max(avg_norm, 1e-8)
            
            similarities = np.dot(self.V, avg_embedding) / (v_norms * avg_norm)
            
            # Get predictions above threshold, excluding already observed
            predictions = []
            observed_set = set(observed_indices)
            
            for idx, similarity in enumerate(similarities):
                if similarity > confidence_threshold and idx not in observed_set:
                    tech_id = self.technique_ids[idx]
                    predictions.append({
                        "technique": tech_id,
                        "confidence": float(similarity),
                        "name": self.technique_names.get(tech_id, tech_id)
                    })
            
            # Sort by confidence
            predictions.sort(key=lambda x: x['confidence'], reverse=True)
            
            # Combine original keywords with top predictions
            all_ttps = list(keyword_ttps)
            for pred in predictions[:10]:  # Top 10 predictions
                all_ttps.append(pred['technique'])
            
            return all_ttps, {
                "method": "simple_tie",
                "keyword_ttps": list(keyword_ttps),
                "inferred_ttps": [p['technique'] for p in predictions[:10]],
                "confidence_scores": {p['technique']: p['confidence'] for p in predictions[:10]},
                "observed_techniques_count": len(observed_indices)
            }
            
        except Exception as e:
            logger.error(f"TIE inference failed: {e}")
            return list(keyword_ttps), {"method": "keyword_extraction", "error": str(e)}
    
    def batch_infer_ttps(self, cve_list: List[Dict], confidence_threshold: float = 0.1) -> Dict[str, Dict]:
        """Infer TTPs for multiple CVEs."""
        results = {}
        
        for cve in cve_list:
            cve_id = cve.get('id', '')
            description = cve.get('description', '')
            
            if cve_id and description:
                ttps, details = self.infer_ttps_from_description(description, confidence_threshold)
                results[cve_id] = {
                    "ttps": ttps,
                    "inference_details": details
                }
        
        return results