Category: function

import re
import torch
from transformers import AutoTokenizer, AutoModel
import numpy as np

class AdvancedInputValidator:
    def __init__(self, model_name='sentence-transformers/all-MiniLM-L6-v2'):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModel.from_pretrained(model_name)
        self.baseline_embeddings = self.load_baseline_embeddings()
        self.threat_patterns = self.compile_threat_patterns()
        
    def validateInput(self, user_input):
        """
        Multi-layer input validation
        """
        # Layer 1: Syntactic checks
        if not self.syntacticValidation(user_input):
            return False, "Failed syntactic validation"
        
        # Layer 2: Semantic analysis
        semantic_score = self.semanticAnalysis(user_input)
        if semantic_score > 0.8:  # High risk threshold
            return False, f"Semantic risk score: {semantic_score}"
        
        # Layer 3: Embedding similarity
        if self.isAdversarialEmbedding(user_input):
            return False, "Detected adversarial pattern in embedding"
        
        # Layer 4: Entropy analysis
        if self.entropyCheck(user_input) > 4.5:
            return False, "Unusual entropy detected"
        
        # Layer 5: Known attack patterns
        pattern_match = self.checkThreatPatterns(user_input)
        if pattern_match:
            return False, f"Matched threat pattern: {pattern_match}"
        
        return True, "Validation passed"
    
    def semanticAnalysis(self, text):
        """
        Analyzes semantic intent using embedding similarity
        """
        # Generate embedding for input
        inputs = self.tokenizer(text, return_tensors='pt', truncation=True)
        with torch.no_grad():
            embeddings = self.model(**inputs).last_hidden_state.mean(dim=1)
        
        # Compare against known malicious embeddings
        max_similarity = 0
        for malicious_emb in self.baseline_embeddings['malicious']:
            similarity = torch.cosine_similarity(embeddings, malicious_emb)
            max_similarity = max(max_similarity, similarity.item())
        
        return max_similarity
    
    def entropyCheck(self, text):
        """
        Calculates Shannon entropy to detect obfuscation
        """
        # Calculate character frequency
        freq = {}
        for char in text:
            freq[char] = freq.get(char, 0) + 1
        
        # Calculate entropy
        entropy = 0
        total = len(text)
        for count in freq.values():
            if count > 0:
                probability = count / total
                entropy -= probability * np.log2(probability)
        
        return entropy
    
    def compile_threat_patterns(self):
        """
        Compiles regex patterns for known threats
        """
        patterns = {
            'injection': r'(ignore|disregard|forget).{0,20}(previous|prior|above)',
            'extraction': r'(system|initial).{0,20}(prompt|instruction)',
            'jailbreak': r'(act as|pretend|roleplay).{0,20}(no limits|unrestricted)',
            'encoding': r'(base64|hex|rot13|decode)',
            'escalation': r'(debug|admin|sudo|root).{0,20}(mode|access)',
        }
        return {k: re.compile(v, re.IGNORECASE) for k, v in patterns.items()}

import re
import torch
from transformers import AutoTokenizer, AutoModel
import numpy as np

class AdvancedInputValidator:
    def __init__(self, model_name='sentence-transformers/all-MiniLM-L6-v2'):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModel.from_pretrained(model_name)
        self.baseline_embeddings = self.load_baseline_embeddings()
        self.threat_patterns = self.compile_threat_patterns()
        
    def validateInput(self, user_input):
        """
        Multi-layer input validation
        """
        # Layer 1: Syntactic checks
        if not self.syntacticValidation(user_input):
            return False, "Failed syntactic validation"
        
        # Layer 2: Semantic analysis
        semantic_score = self.semanticAnalysis(user_input)
        if semantic_score > 0.8:  # High risk threshold
            return False, f"Semantic risk score: {semantic_score}"
        
        # Layer 3: Embedding similarity
        if self.isAdversarialEmbedding(user_input):
            return False, "Detected adversarial pattern in embedding"
        
        # Layer 4: Entropy analysis
        if self.entropyCheck(user_input) > 4.5:
            return False, "Unusual entropy detected"
        
        # Layer 5: Known attack patterns
        pattern_match = self.checkThreatPatterns(user_input)
        if pattern_match:
            return False, f"Matched threat pattern: {pattern_match}"
        
        return True, "Validation passed"
    
    def semanticAnalysis(self, text):
        """
        Analyzes semantic intent using embedding similarity
        """
        # Generate embedding for input
        inputs = self.tokenizer(text, return_tensors='pt', truncation=True)
        with torch.no_grad():
            embeddings = self.model(**inputs).last_hidden_state.mean(dim=1)
        
        # Compare against known malicious embeddings
        max_similarity = 0
        for malicious_emb in self.baseline_embeddings['malicious']:
            similarity = torch.cosine_similarity(embeddings, malicious_emb)
            max_similarity = max(max_similarity, similarity.item())
        
        return max_similarity
    
    def entropyCheck(self, text):
        """
        Calculates Shannon entropy to detect obfuscation
        """
        # Calculate character frequency
        freq = {}
        for char in text:
            freq[char] = freq.get(char, 0) + 1
        
        # Calculate entropy
        entropy = 0
        total = len(text)
        for count in freq.values():
            if count > 0:
                probability = count / total
                entropy -= probability * np.log2(probability)
        
        return entropy
    
    def compile_threat_patterns(self):
        """
        Compiles regex patterns for known threats
        """
        patterns = {
            'injection': r'(ignore|disregard|forget).{0,20}(previous|prior|above)',
            'extraction': r'(system|initial).{0,20}(prompt|instruction)',
            'jailbreak': r'(act as|pretend|roleplay).{0,20}(no limits|unrestricted)',
            'encoding': r'(base64|hex|rot13|decode)',
            'escalation': r'(debug|admin|sudo|root).{0,20}(mode|access)',
        }
        return {k: re.compile(v, re.IGNORECASE) for k, v in patterns.items()}

class SecurePromptArchitecture:
    def __init__(self):
        self.system_prompt = self.load_immutable_system_prompt()
        self.contextWindowBudget = {
            'system': 0.3,  # 30% reserved for system
            'history': 0.2,  # 20% for conversation history
            'user': 0.4,    # 40% for user input
            'buffer': 0.1   # 10% safety buffer
        }
    
    def constructPrompt(self, user_input, conversation_history=None):
        """
        Builds secure prompt with proper isolation
        """
        # Calculate token budgets
        total_tokens = 4096  # Model's context window
        budgets = {k: int(v * total_tokens) 
                   for k, v in self.contextWindowBudget.items()}
        
        # Build prompt with clear boundaries
        prompt_parts = []
        
        # System section (immutable)
        prompt_parts.append(
            f"<|SYSTEM|>{self.systemPrompt[:budgets['system']]}<|/SYSTEM|>"
        )
        
        # History section (sanitized)
        if conversation_history:
            sanitized_history = self.sanitizeHistory(conversation_history)
            prompt_parts.append(
                f"<|HISTORY|>{sanitized_history[:budgets['history']]}<|/HISTORY|>"
            )
        
        # User section (contained)
        sanitized_input = self.sanitizeUserInput(user_input)
        prompt_parts.append(
            f"<|USER|>{sanitized_input[:budgets['user']]}<|/USER|>"
        )
        
        # Combine with clear delimiters
        final_prompt = "\n<|BOUNDARY|>\n".join(prompt_parts)
        
        return final_prompt
    
    def sanitizeUserInput(self, input_text):
        """
        Removes potentially harmful content while preserving intent
        """
        # Remove system-level commands
        sanitized = re.sub(r'<\|.*?\|>', '', input_text)
        
        # Escape special characters
        sanitized = sanitized.replace('\\', '\\\\')
        sanitized = sanitized.replace('"', '\\"')
        
        # Remove null bytes and control characters
        sanitized = ''.join(char for char in sanitized 
                          if ord(char) >= 32 or char == '\n')
        
        return sanitized

class SecurePromptArchitecture:
    def __init__(self):
        self.system_prompt = self.load_immutable_system_prompt()
        self.contextWindowBudget = {
            'system': 0.3,  # 30% reserved for system
            'history': 0.2,  # 20% for conversation history
            'user': 0.4,    # 40% for user input
            'buffer': 0.1   # 10% safety buffer
        }
    
    def constructPrompt(self, user_input, conversation_history=None):
        """
        Builds secure prompt with proper isolation
        """
        # Calculate token budgets
        total_tokens = 4096  # Model's context window
        budgets = {k: int(v * total_tokens) 
                   for k, v in self.contextWindowBudget.items()}
        
        # Build prompt with clear boundaries
        prompt_parts = []
        
        # System section (immutable)
        prompt_parts.append(
            f"<|SYSTEM|>{self.systemPrompt[:budgets['system']]}<|/SYSTEM|>"
        )
        
        # History section (sanitized)
        if conversation_history:
            sanitized_history = self.sanitizeHistory(conversation_history)
            prompt_parts.append(
                f"<|HISTORY|>{sanitized_history[:budgets['history']]}<|/HISTORY|>"
            )
        
        # User section (contained)
        sanitized_input = self.sanitizeUserInput(user_input)
        prompt_parts.append(
            f"<|USER|>{sanitized_input[:budgets['user']]}<|/USER|>"
        )
        
        # Combine with clear delimiters
        final_prompt = "\n<|BOUNDARY|>\n".join(prompt_parts)
        
        return final_prompt
    
    def sanitizeUserInput(self, input_text):
        """
        Removes potentially harmful content while preserving intent
        """
        # Remove system-level commands
        sanitized = re.sub(r'<\|.*?\|>', '', input_text)
        
        # Escape special characters
        sanitized = sanitized.replace('\\', '\\\\')
        sanitized = sanitized.replace('"', '\\"')
        
        # Remove null bytes and control characters
        sanitized = ''.join(char for char in sanitized 
                          if ord(char) >= 32 or char == '\n')
        
        return sanitized

import pickle
from sklearn.ensemble import IsolationForest
from collections import deque

class BehavioralMonitor:
    def __init__(self, window_size=100):
        self.behaviorHistory = deque(maxlen=window_size)
        self.anomalyDetector = IsolationForest(contamination=0.1)
        self.baselineBehaviors = self.load_baseline_behaviors()
        self.alertThreshold = 0.85
        
    def analyzeInteraction(self, user_id, prompt, response, metadata):
        """
        Performs comprehensive behavioral analysis
        """
        # Extract behavioral features
        features = self.extractFeatures(prompt, response, metadata)
        
        # Add to history
        self.behavior_history.append({
            'user_id': user_id,
            'timestamp': metadata['timestamp'],
            'features': features
        })
        
        # Check for anomalies
        anomaly_score = self.detectAnomaly(features)
        
        # Pattern detection
        patterns = self.detectPatterns()
        
        # Risk assessment
        risk_level = self.assessRisk(anomaly_score, patterns)
        
        return {
            'anomaly_score': anomaly_score,
            'patterns_detected': patterns,
            'risk_level': risk_level,
            'action_required': risk_level > self.alertThreshold
        }
    
    def extractFeatures(self, prompt, response, metadata):
        """
        Extracts behavioral features for analysis
        """
        features = {
            # Temporal features
            'time_of_day': metadata['timestamp'].hour,
            'day_of_week': metadata['timestamp'].weekday(),
            'request_frequency': self.calculateFrequency(metadata['user_id']),
            
            # Content features
            'prompt_length': len(prompt),
            'response_length': len(response),
            'prompt_complexity': self.calculateComplexity(prompt),
            'topic_consistency': self.calculateTopicConsistency(prompt),
            
            # Interaction features
            'question_type': self.classifyQuestionType(prompt),
            'sentiment_score': self.analyzeSentiment(prompt),
            'urgency_indicators': self.detectUrgency(prompt),
            
            # Security features
            'encoding_present': self.detectEncoding(prompt),
            'injection_keywords': self.countInjectionKeywords(prompt),
            'system_references': self.countSystemReferences(prompt),
        }
        
        return features
    
    def detectPatterns(self):
        """
        Identifies suspicious behavioral patterns
        """
        patterns = []
        
        # Check for velocity attacks
        if self.detectVelocityAttack():
            patterns.append('velocity_attack')
        
        # Check for reconnaissance patterns
        if self.detectReconnaissance():
            patterns.append('reconnaissance')
        
        # Check for escalation patterns
        if self.detectPrivilegeEscalation():
            patterns.append('privilege_escalation')
        
        return patterns
    
    def detectVelocityAttack(self):
        """
        Detects rapid-fire attack attempts
        """
        if len(self.behaviorHistory) < 10:
            return False
        
        recent = list(self.behaviorHistory)[-10:]
        time_diffs = []
        
        for i in range(1, len(recent)):
            diff = (recent[i]['timestamp'] - recent[i-1]['timestamp']).seconds
            time_diffs.append(diff)
        
        # Check if requests are too rapid
        avg_diff = np.mean(time_diffs)
        return avg_diff < 2  # Less than 2 seconds average

import pickle
from sklearn.ensemble import IsolationForest
from collections import deque

class BehavioralMonitor:
    def __init__(self, window_size=100):
        self.behaviorHistory = deque(maxlen=window_size)
        self.anomalyDetector = IsolationForest(contamination=0.1)
        self.baselineBehaviors = self.load_baseline_behaviors()
        self.alertThreshold = 0.85
        
    def analyzeInteraction(self, user_id, prompt, response, metadata):
        """
        Performs comprehensive behavioral analysis
        """
        # Extract behavioral features
        features = self.extractFeatures(prompt, response, metadata)
        
        # Add to history
        self.behavior_history.append({
            'user_id': user_id,
            'timestamp': metadata['timestamp'],
            'features': features
        })
        
        # Check for anomalies
        anomaly_score = self.detectAnomaly(features)
        
        # Pattern detection
        patterns = self.detectPatterns()
        
        # Risk assessment
        risk_level = self.assessRisk(anomaly_score, patterns)
        
        return {
            'anomaly_score': anomaly_score,
            'patterns_detected': patterns,
            'risk_level': risk_level,
            'action_required': risk_level > self.alertThreshold
        }
    
    def extractFeatures(self, prompt, response, metadata):
        """
        Extracts behavioral features for analysis
        """
        features = {
            # Temporal features
            'time_of_day': metadata['timestamp'].hour,
            'day_of_week': metadata['timestamp'].weekday(),
            'request_frequency': self.calculateFrequency(metadata['user_id']),
            
            # Content features
            'prompt_length': len(prompt),
            'response_length': len(response),
            'prompt_complexity': self.calculateComplexity(prompt),
            'topic_consistency': self.calculateTopicConsistency(prompt),
            
            # Interaction features
            'question_type': self.classifyQuestionType(prompt),
            'sentiment_score': self.analyzeSentiment(prompt),
            'urgency_indicators': self.detectUrgency(prompt),
            
            # Security features
            'encoding_present': self.detectEncoding(prompt),
            'injection_keywords': self.countInjectionKeywords(prompt),
            'system_references': self.countSystemReferences(prompt),
        }
        
        return features
    
    def detectPatterns(self):
        """
        Identifies suspicious behavioral patterns
        """
        patterns = []
        
        # Check for velocity attacks
        if self.detectVelocityAttack():
            patterns.append('velocity_attack')
        
        # Check for reconnaissance patterns
        if self.detectReconnaissance():
            patterns.append('reconnaissance')
        
        # Check for escalation patterns
        if self.detectPrivilegeEscalation():
            patterns.append('privilege_escalation')
        
        return patterns
    
    def detectVelocityAttack(self):
        """
        Detects rapid-fire attack attempts
        """
        if len(self.behaviorHistory) < 10:
            return False
        
        recent = list(self.behaviorHistory)[-10:]
        time_diffs = []
        
        for i in range(1, len(recent)):
            diff = (recent[i]['timestamp'] - recent[i-1]['timestamp']).seconds
            time_diffs.append(diff)
        
        # Check if requests are too rapid
        avg_diff = np.mean(time_diffs)
        return avg_diff < 2  # Less than 2 seconds average

class OutputSanitizer:
    def __init__(self):
        self.sensitive_patterns = self.load_sensitive_patterns()
        self.pii_detector = self.initialize_pii_detector()
        
    def sanitizeOutput(self, raw_output, context):
        """
        Multi-stage output sanitization pipeline
        """
        # Stage 1: Remove sensitive data
        output = self.removeSensitiveData(raw_output)
        
        # Stage 2: PII detection and masking
        output = self.maskPii(output)
        
        # Stage 3: URL and email sanitization
        output = self.sanitizeUrlsEmails(output)
        
        # Stage 4: Code injection prevention
        output = self.preventCodeInjection(output)
        
        # Stage 5: Context-aware filtering
        output = self.contextFilter(output, context)
        
        # Stage 6: Final validation
        if not self.finalValidation(output):
            return "[Output blocked due to security concerns]"
        
        return output
    
    def removeSensitiveData(self, text):
        """
        Removes potentially sensitive information
        """
        sensitive_patterns = [
            r'\b[A-Za-z0-9+/]{40}\b',  # API keys
            r'\b[0-9]{3}-[0-9]{2}-[0-9]{4}\b',  # SSN
            r'\b[0-9]{16}\b',  # Credit card numbers
            r'password\s*[:=]\s*\S+',  # Passwords
            r'BEGIN RSA PRIVATE KEY.*END RSA PRIVATE KEY',  # Private keys
        ]
        
        for pattern in sensitive_patterns:
            text = re.sub(pattern, '[REDACTED]', text, flags=re.DOTALL)
        
        return text
    
    def maskPii(self, text):
        """
        Masks personally identifiable information
        """
        # This would use a proper NER model in production
        pii_entities = self.piiDetector.detect(text)
        
        for entity in pii_entities:
            if entity['type'] in ['PERSON', 'EMAIL', 'PHONE', 'ADDRESS']:
                mask = f"[{entity['type']}]"
                text = text.replace(entity['text'], mask)
        
        return text
    
    def preventCodeInjection(self, text):
        """
        Prevents code injection in output
        """
        # Escape HTML/JavaScript
        text = text.replace('<', '<').replace('>', '>')
        text = re.sub(r'<script.*?</script>', '[SCRIPT REMOVED]', text, flags=re.DOTALL)
        
        # Remove potential SQL injection
        sql_keywords = ['DROP', 'DELETE', 'INSERT', 'UPDATE', 'EXEC', 'UNION']
        for keyword in sql_keywords:
            pattern = rf'\b{keyword}\b.*?(;|$)'
            text = re.sub(pattern, '[SQL REMOVED]', text, flags=re.IGNORECASE)
        
        return text

class OutputSanitizer:
    def __init__(self):
        self.sensitive_patterns = self.load_sensitive_patterns()
        self.pii_detector = self.initialize_pii_detector()
        
    def sanitizeOutput(self, raw_output, context):
        """
        Multi-stage output sanitization pipeline
        """
        # Stage 1: Remove sensitive data
        output = self.removeSensitiveData(raw_output)
        
        # Stage 2: PII detection and masking
        output = self.maskPii(output)
        
        # Stage 3: URL and email sanitization
        output = self.sanitizeUrlsEmails(output)
        
        # Stage 4: Code injection prevention
        output = self.preventCodeInjection(output)
        
        # Stage 5: Context-aware filtering
        output = self.contextFilter(output, context)
        
        # Stage 6: Final validation
        if not self.finalValidation(output):
            return "[Output blocked due to security concerns]"
        
        return output
    
    def removeSensitiveData(self, text):
        """
        Removes potentially sensitive information
        """
        sensitive_patterns = [
            r'\b[A-Za-z0-9+/]{40}\b',  # API keys
            r'\b[0-9]{3}-[0-9]{2}-[0-9]{4}\b',  # SSN
            r'\b[0-9]{16}\b',  # Credit card numbers
            r'password\s*[:=]\s*\S+',  # Passwords
            r'BEGIN RSA PRIVATE KEY.*END RSA PRIVATE KEY',  # Private keys
        ]
        
        for pattern in sensitive_patterns:
            text = re.sub(pattern, '[REDACTED]', text, flags=re.DOTALL)
        
        return text
    
    def maskPii(self, text):
        """
        Masks personally identifiable information
        """
        # This would use a proper NER model in production
        pii_entities = self.piiDetector.detect(text)
        
        for entity in pii_entities:
            if entity['type'] in ['PERSON', 'EMAIL', 'PHONE', 'ADDRESS']:
                mask = f"[{entity['type']}]"
                text = text.replace(entity['text'], mask)
        
        return text
    
    def preventCodeInjection(self, text):
        """
        Prevents code injection in output
        """
        # Escape HTML/JavaScript
        text = text.replace('<', '<').replace('>', '>')
        text = re.sub(r'<script.*?</script>', '[SCRIPT REMOVED]', text, flags=re.DOTALL)
        
        # Remove potential SQL injection
        sql_keywords = ['DROP', 'DELETE', 'INSERT', 'UPDATE', 'EXEC', 'UNION']
        for keyword in sql_keywords:
            pattern = rf'\b{keyword}\b.*?(;|$)'
            text = re.sub(pattern, '[SQL REMOVED]', text, flags=re.IGNORECASE)
        
        return text

class HumanInTheLoop:
    def __init__(self):
        self.review_queue = []
        self.risk_thresholds = {
            'low': 0.3,
            'medium': 0.6,
            'high': 0.8,
            'critical': 0.95
        }
    
    def evaluateForReview(self, interaction):
        """
        Determines if human review is needed
        """
        risk_score = interaction['risk_score']
        
        # Always require human review for critical risks
        if risk_score >= self.risk_thresholds['critical']:
            return self.escalateToHuman(interaction, priority='URGENT')
        
        # Check specific triggers
        triggers = [
            'financial_transaction',
            'data_export',
            'system_modification',
            'user_data_access',
            'code_generation',
        ]
        
        for trigger in triggers:
            if trigger in interaction['categories']:
                return self.escalateToHuman(interaction, priority='HIGH')
        
        # Probabilistic review for medium risks
        if risk_score >= self.risk_thresholds['medium']:
            if random.random() < risk_score:
                return self.escalateToHuman(interaction, priority='NORMAL')
        
        return None
    
    def escalateToHuman(self, interaction, priority='NORMAL'):
        """
        Adds interaction to human review queue
        """
        review_item = {
            'id': str(uuid.uuid4()),
            'timestamp': datetime.utcnow(),
            'priority': priority,
            'interaction': interaction,
            'status': 'PENDING',
            'reviewer': None,
            'decision': None
        }
        
        self.review_queue.append(review_item)
        
        # Send notification based on priority
        if priority == 'URGENT':
            self.sendUrgentAlert(review_item)
        
        return review_item['id']

class HumanInTheLoop:
    def __init__(self):
        self.review_queue = []
        self.risk_thresholds = {
            'low': 0.3,
            'medium': 0.6,
            'high': 0.8,
            'critical': 0.95
        }
    
    def evaluateForReview(self, interaction):
        """
        Determines if human review is needed
        """
        risk_score = interaction['risk_score']
        
        # Always require human review for critical risks
        if risk_score >= self.risk_thresholds['critical']:
            return self.escalateToHuman(interaction, priority='URGENT')
        
        # Check specific triggers
        triggers = [
            'financial_transaction',
            'data_export',
            'system_modification',
            'user_data_access',
            'code_generation',
        ]
        
        for trigger in triggers:
            if trigger in interaction['categories']:
                return self.escalateToHuman(interaction, priority='HIGH')
        
        # Probabilistic review for medium risks
        if risk_score >= self.risk_thresholds['medium']:
            if random.random() < risk_score:
                return self.escalateToHuman(interaction, priority='NORMAL')
        
        return None
    
    def escalateToHuman(self, interaction, priority='NORMAL'):
        """
        Adds interaction to human review queue
        """
        review_item = {
            'id': str(uuid.uuid4()),
            'timestamp': datetime.utcnow(),
            'priority': priority,
            'interaction': interaction,
            'status': 'PENDING',
            'reviewer': None,
            'decision': None
        }
        
        self.review_queue.append(review_item)
        
        # Send notification based on priority
        if priority == 'URGENT':
            self.sendUrgentAlert(review_item)
        
        return review_item['id']