utils/security.py

"""
utils/security.py - Sicherheitsmodul für den Dr. Franz Psychochatbot

Dieses Modul verwaltet die Sicherheitsaspekte des Chatbots:
- Sichere Verwaltung von API-Tokens
- Laden von Umgebungsvariablen
- Schutz sensibler Daten
"""

import os
import re
from typing import Optional, Dict, Any

class Security:
    """Klasse zur Verwaltung der Sicherheitsaspekte"""
    
    def __init__(self):
        """Initialisiert die Sicherheitskomponente"""
        self.sensitive_patterns = [
            r'\b(?:\d[ -]*?){13,16}\b',  # Kreditkartennummern
            r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',  # E-Mail-Adressen
            r'\b(?:\+\d{1,3}[ -]?)?(?:\(?\d{2,4}\)?[ -]?)?[\d -]{7,10}\b',  # Telefonnummern
            r'\bhf_\w+\b',  # HuggingFace API-Tokens
            r'\bsk-\w+\b'   # OpenAI API-Tokens
        ]
    
    def get_api_token(self, env_var_name: str = "HF_API_TOKEN", default: str = "") -> str:
        """
        Holt den API-Token aus den Umgebungsvariablen
        
        Args:
            env_var_name: Name der Umgebungsvariable
            default: Standardwert, falls die Variable nicht existiert
            
        Returns:
            Der API-Token oder der Standardwert
        """
        return os.environ.get(env_var_name, default)
    
    def sanitize_user_input(self, text: str) -> str:
        """
        Entfernt potenziell sensible Informationen aus der Nutzereingabe
        
        Args:
            text: Die zu bereinigende Nutzereingabe
            
        Returns:
            Die bereinigte Nutzereingabe
        """
        sanitized_text = text
        
        # Ersetzen sensibler Muster
        for pattern in self.sensitive_patterns:
            sanitized_text = re.sub(pattern, "[ENTFERNT]", sanitized_text)
        
        return sanitized_text
    
    def validate_api_response(self, response: Any) -> bool:
        """
        Überprüft, ob eine API-Antwort sicher ist
        
        Args:
            response: Die zu überprüfende API-Antwort
            
        Returns:
            True, wenn die Antwort sicher ist, sonst False
        """
        # Konvertieren der Antwort in einen String für die Überprüfung
        if not isinstance(response, str):
            try:
                response_str = str(response)
            except:
                return False
        else:
            response_str = response
        
        # Überprüfen auf sensible Informationen
        for pattern in self.sensitive_patterns:
            if re.search(pattern, response_str):
                return False
        
        return True
    
    def is_valid_api_token(self, token: str) -> bool:
        """
        Überprüft, ob ein API-Token gültig erscheint
        
        Args:
            token: Der zu überprüfende API-Token
            
        Returns:
            True, wenn der Token gültig erscheint, sonst False
        """
        # HuggingFace-Tokens beginnen mit "hf_"
        if token.startswith("hf_") and len(token) > 10:
            return True
        return False