Datasets:

DuyTa
/

cve-kgrag-db

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

	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