mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.6__py3-none-any.whl

mcp_proxy_adapter/core/ssl_utils.py

@@ -25,15 +25,15 @@ class SSLUtils:
     """
     SSL utilities for creating SSL contexts and validating certificates.
     """
-    
+
     # TLS version mapping
     TLS_VERSIONS = {
         "1.0": ssl.TLSVersion.TLSv1,
         "1.1": ssl.TLSVersion.TLSv1_1,
         "1.2": ssl.TLSVersion.TLSv1_2,
-        "1.3": ssl.TLSVersion.TLSv1_3
+        "1.3": ssl.TLSVersion.TLSv1_3,
     }
-    
+
     # Cipher suite mapping
     CIPHER_SUITES = {
         "TLS_AES_256_GCM_SHA384": "TLS_AES_256_GCM_SHA384",
@@ -41,20 +41,23 @@ class SSLUtils:
         "TLS_AES_128_GCM_SHA256": "TLS_AES_128_GCM_SHA256",
         "ECDHE-RSA-AES256-GCM-SHA384": "ECDHE-RSA-AES256-GCM-SHA384",
         "ECDHE-RSA-AES128-GCM-SHA256": "ECDHE-RSA-AES128-GCM-SHA256",
-        "ECDHE-RSA-CHACHA20-POLY1305": "ECDHE-RSA-CHACHA20-POLY1305"
+        "ECDHE-RSA-CHACHA20-POLY1305": "ECDHE-RSA-CHACHA20-POLY1305",
     }
-    
+
     @staticmethod
-    def create_ssl_context(cert_file: str, key_file: str, 
-                          ca_cert: Optional[str] = None, 
-                          verify_client: bool = False,
-                          cipher_suites: Optional[List[str]] = None,
-                          min_tls_version: str = "1.2",
-                          max_tls_version: str = "1.3",
-                          crl_config: Optional[Dict[str, Any]] = None) -> ssl.SSLContext:
+    def create_ssl_context(
+        cert_file: str,
+        key_file: str,
+        ca_cert: Optional[str] = None,
+        verify_client: bool = False,
+        cipher_suites: Optional[List[str]] = None,
+        min_tls_version: str = "1.2",
+        max_tls_version: str = "1.3",
+        crl_config: Optional[Dict[str, Any]] = None,
+    ) -> ssl.SSLContext:
         """
         Create SSL context with specified configuration.
-        
+
         Args:
             cert_file: Path to certificate file
             key_file: Path to private key file
@@ -64,10 +67,10 @@ class SSLUtils:
             min_tls_version: Minimum TLS version
             max_tls_version: Maximum TLS version
             crl_config: CRL configuration dictionary (optional)
-            
+
         Returns:
             Configured SSL context
-            
+
         Raises:
             ValueError: If certificate validation fails
             FileNotFoundError: If certificate or key files not found
@@ -77,18 +80,20 @@ class SSLUtils:
         result = validator.validate_certificate(cert_file)
         if not result.is_valid:
             raise ValueError(f"Invalid certificate: {result.error_message}")
-        
+
         # Check CRL if configured
         if crl_config:
             try:
                 crl_manager = CRLManager(crl_config)
                 if crl_manager.is_certificate_revoked(cert_file):
-                    raise ValueError(f"Certificate is revoked according to CRL: {cert_file}")
+                    raise ValueError(
+                        f"Certificate is revoked according to CRL: {cert_file}"
+                    )
             except Exception as e:
                 logger.error(f"CRL check failed: {e}")
                 # For security, fail if CRL check fails
                 raise ValueError(f"CRL validation failed: {e}")
-        
+
         # Check if files exist
         if not Path(cert_file).exists():
             raise FileNotFoundError(f"Certificate file not found: {cert_file}")
@@ -96,45 +101,47 @@ class SSLUtils:
             raise FileNotFoundError(f"Key file not found: {key_file}")
         if ca_cert and not Path(ca_cert).exists():
             raise FileNotFoundError(f"CA certificate file not found: {ca_cert}")
-        
+
         # Create SSL context
         if verify_client:
             context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
         else:
             context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
-        
+
         # Load certificate and key
         context.load_cert_chain(cert_file, key_file)
-        
+
         # Load CA certificate if provided
         if ca_cert:
             context.load_verify_locations(ca_cert)
-        
+
         # Configure client verification
         if verify_client:
             context.verify_mode = ssl.CERT_REQUIRED
             context.check_hostname = False
         else:
             context.verify_mode = ssl.CERT_NONE
-        
+
         # Setup cipher suites
         SSLUtils.setup_cipher_suites(context, cipher_suites or [])
-        
+
         # Setup TLS versions
         SSLUtils.setup_tls_versions(context, min_tls_version, max_tls_version)
-        
+
         logger.info(f"SSL context created successfully with cert: {cert_file}")
         return context
-    
+
     @staticmethod
-    def validate_certificate(cert_file: str, crl_config: Optional[Dict[str, Any]] = None) -> bool:
+    def validate_certificate(
+        cert_file: str, crl_config: Optional[Dict[str, Any]] = None
+    ) -> bool:
         """
         Validate certificate using AuthValidator and optional CRL check.
-        
+
         Args:
             cert_file: Path to certificate file
             crl_config: CRL configuration dictionary (optional)
-            
+
         Returns:
             True if certificate is valid, False otherwise
         """
@@ -143,36 +150,38 @@ class SSLUtils:
             result = validator.validate_certificate(cert_file)
             if not result.is_valid:
                 return False
-            
+
             # Check CRL if configured
             if crl_config:
                 try:
                     crl_manager = CRLManager(crl_config)
                     if crl_manager.is_certificate_revoked(cert_file):
-                        logger.warning(f"Certificate is revoked according to CRL: {cert_file}")
+                        logger.warning(
+                            f"Certificate is revoked according to CRL: {cert_file}"
+                        )
                         return False
                 except Exception as e:
                     logger.error(f"CRL check failed: {e}")
                     # For security, consider certificate invalid if CRL check fails
                     return False
-            
+
             return True
         except Exception as e:
             logger.error(f"Certificate validation failed: {e}")
             return False
-    
+
     @staticmethod
     def setup_cipher_suites(context: ssl.SSLContext, cipher_suites: List[str]) -> None:
         """
         Setup cipher suites for SSL context.
-        
+
         Args:
             context: SSL context to configure
             cipher_suites: List of cipher suite names
         """
         if not cipher_suites:
             return
-        
+
         # Convert cipher suite names to actual cipher suite strings
         actual_ciphers = []
         for cipher_name in cipher_suites:
@@ -180,19 +189,21 @@ class SSLUtils:
                 actual_ciphers.append(SSLUtils.CIPHER_SUITES[cipher_name])
             else:
                 logger.warning(f"Unknown cipher suite: {cipher_name}")
-        
+
         if actual_ciphers:
             try:
                 context.set_ciphers(":".join(actual_ciphers))
                 logger.info(f"Cipher suites configured: {actual_ciphers}")
             except ssl.SSLError as e:
                 logger.error(f"Failed to set cipher suites: {e}")
-    
+
     @staticmethod
-    def setup_tls_versions(context: ssl.SSLContext, min_version: str, max_version: str) -> None:
+    def setup_tls_versions(
+        context: ssl.SSLContext, min_version: str, max_version: str
+    ) -> None:
         """
         Setup TLS version range for SSL context.
-        
+
         Args:
             context: SSL context to configure
             min_version: Minimum TLS version
@@ -201,66 +212,68 @@ class SSLUtils:
         try:
             min_tls = SSLUtils.TLS_VERSIONS.get(min_version)
             max_tls = SSLUtils.TLS_VERSIONS.get(max_version)
-            
+
             if min_tls and max_tls:
                 context.minimum_version = min_tls
                 context.maximum_version = max_tls
                 logger.info(f"TLS versions configured: {min_version} - {max_version}")
             else:
-                logger.warning(f"Invalid TLS version range: {min_version} - {max_version}")
+                logger.warning(
+                    f"Invalid TLS version range: {min_version} - {max_version}"
+                )
         except Exception as e:
             logger.error(f"Failed to set TLS versions: {e}")
-    
+
     @staticmethod
     def check_tls_version(min_version: str, max_version: str) -> bool:
         """
         Check if TLS version range is valid.
-        
+
         Args:
             min_version: Minimum TLS version
             max_version: Maximum TLS version
-            
+
         Returns:
             True if version range is valid, False otherwise
         """
         min_tls = SSLUtils.TLS_VERSIONS.get(min_version)
         max_tls = SSLUtils.TLS_VERSIONS.get(max_version)
-        
+
         if not min_tls or not max_tls:
             return False
-        
+
         # Check if min version is less than or equal to max version
         return min_tls <= max_tls
-    
+
     @staticmethod
     def get_ssl_config_for_hypercorn(ssl_config: Dict[str, Any]) -> Dict[str, Any]:
         """
         Get SSL configuration for hypercorn from transport configuration.
-        
+
         Args:
             ssl_config: SSL configuration from transport manager
-            
+
         Returns:
             Configuration for hypercorn
         """
         hypercorn_ssl = {}
-        
+
         if not ssl_config:
             return hypercorn_ssl
-        
+
         # Basic SSL parameters
         if ssl_config.get("cert_file"):
             hypercorn_ssl["certfile"] = ssl_config["cert_file"]
-        
+
         if ssl_config.get("key_file"):
             hypercorn_ssl["keyfile"] = ssl_config["key_file"]
-        
+
         if ssl_config.get("ca_cert"):
             hypercorn_ssl["ca_certs"] = ssl_config["ca_cert"]
-        
+
         # Client verification mode
         if ssl_config.get("verify_client", False):
             hypercorn_ssl["verify_mode"] = "CERT_REQUIRED"
-        
+
         logger.info(f"Generated hypercorn SSL config: {hypercorn_ssl}")
-        return hypercorn_ssl 
+        return hypercorn_ssl

mcp_proxy_adapter/core/transport_manager.py

@@ -14,6 +14,7 @@ from mcp_proxy_adapter.core.logging import logger
 
 class TransportType(Enum):
     """Transport types enumeration."""
+
     HTTP = "http"
     HTTPS = "https"
     MTLS = "mtls"
@@ -22,6 +23,7 @@ class TransportType(Enum):
 @dataclass
 class TransportConfig:
     """Transport configuration data class."""
+
     type: TransportType
     port: Optional[int]
     ssl_enabled: bool
@@ -35,36 +37,36 @@ class TransportConfig:
 class TransportManager:
     """
     Transport manager for handling different transport types.
-    
+
     This class manages transport configuration and provides utilities
     for determining ports and SSL settings based on transport type.
     """
-    
+
     # Default ports for transport types
     DEFAULT_PORTS = {
         TransportType.HTTP: 8000,
         TransportType.HTTPS: 8443,
-        TransportType.MTLS: 9443
+        TransportType.MTLS: 9443,
     }
-    
+
     def __init__(self):
         """Initialize transport manager."""
         self._config: Optional[TransportConfig] = None
         self._current_transport: Optional[TransportType] = None
-    
+
     def load_config(self, config: Dict[str, Any]) -> bool:
         """
         Load transport configuration from config dict.
-        
+
         Args:
             config: Configuration dictionary
-            
+
         Returns:
             True if config loaded successfully, False otherwise
         """
         try:
             transport_config = config.get("transport", {})
-            
+
             # Get transport type
             transport_type_str = transport_config.get("type", "http").lower()
             try:
@@ -72,24 +74,29 @@ class TransportManager:
             except ValueError:
                 logger.error(f"Invalid transport type: {transport_type_str}")
                 return False
-            
+
             # Get port (use default if not specified)
             port = transport_config.get("port")
             if port is None:
                 port = self.DEFAULT_PORTS.get(transport_type, 8000)
-            
+
             # Get SSL configuration
             ssl_config = transport_config.get("ssl", {})
             ssl_enabled = ssl_config.get("enabled", False)
-            
+
             # Validate SSL requirements
-            if transport_type in [TransportType.HTTPS, TransportType.MTLS] and not ssl_enabled:
-                logger.error(f"SSL must be enabled for transport type: {transport_type.value}")
+            if (
+                transport_type in [TransportType.HTTPS, TransportType.MTLS]
+                and not ssl_enabled
+            ):
+                logger.error(
+                    f"SSL must be enabled for transport type: {transport_type.value}"
+                )
                 return False
-            
+
             if transport_type == TransportType.HTTP and ssl_enabled:
                 logger.warning("SSL enabled for HTTP transport - this may cause issues")
-            
+
             # Create transport config
             self._config = TransportConfig(
                 type=transport_type,
@@ -99,100 +106,102 @@ class TransportManager:
                 key_file=ssl_config.get("key_file") if ssl_enabled else None,
                 ca_cert=ssl_config.get("ca_cert") if ssl_enabled else None,
                 verify_client=ssl_config.get("verify_client", False),
-                client_cert_required=ssl_config.get("client_cert_required", False)
+                client_cert_required=ssl_config.get("client_cert_required", False),
             )
-            
+
             self._current_transport = transport_type
-            
-            logger.info(f"Transport config loaded: {transport_type.value} on port {port}")
+
+            logger.info(
+                f"Transport config loaded: {transport_type.value} on port {port}"
+            )
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to load transport config: {e}")
             return False
-    
+
     def get_transport_type(self) -> Optional[TransportType]:
         """
         Get current transport type.
-        
+
         Returns:
             Current transport type or None if not configured
         """
         return self._current_transport
-    
+
     def get_port(self) -> Optional[int]:
         """
         Get configured port.
-        
+
         Returns:
             Port number or None if not configured
         """
         return self._config.port if self._config else None
-    
+
     def is_ssl_enabled(self) -> bool:
         """
         Check if SSL is enabled.
-        
+
         Returns:
             True if SSL is enabled, False otherwise
         """
         return self._config.ssl_enabled if self._config else False
-    
+
     def get_ssl_config(self) -> Optional[Dict[str, Any]]:
         """
         Get SSL configuration.
-        
+
         Returns:
             SSL configuration dict or None if SSL not enabled
         """
         if not self._config or not self._config.ssl_enabled:
             return None
-        
+
         return {
             "cert_file": self._config.cert_file,
             "key_file": self._config.key_file,
             "ca_cert": self._config.ca_cert,
             "verify_client": self._config.verify_client,
-            "client_cert_required": self._config.client_cert_required
+            "client_cert_required": self._config.client_cert_required,
         }
-    
+
     def is_mtls(self) -> bool:
         """
         Check if current transport is MTLS.
-        
+
         Returns:
             True if MTLS transport, False otherwise
         """
         return self._current_transport == TransportType.MTLS
-    
+
     def is_https(self) -> bool:
         """
         Check if current transport is HTTPS.
-        
+
         Returns:
             True if HTTPS transport, False otherwise
         """
         return self._current_transport == TransportType.HTTPS
-    
+
     def is_http(self) -> bool:
         """
         Check if current transport is HTTP.
-        
+
         Returns:
             True if HTTP transport, False otherwise
         """
         return self._current_transport == TransportType.HTTP
-    
+
     def get_transport_info(self) -> Dict[str, Any]:
         """
         Get transport information.
-        
+
         Returns:
             Dictionary with transport information
         """
         if not self._config:
             return {"error": "Transport not configured"}
-        
+
         return {
             "type": self._config.type.value,
             "port": self._config.port,
@@ -200,55 +209,57 @@ class TransportManager:
             "is_mtls": self.is_mtls(),
             "is_https": self.is_https(),
             "is_http": self.is_http(),
-            "ssl_config": self.get_ssl_config()
+            "ssl_config": self.get_ssl_config(),
         }
-    
+
     def validate_config(self) -> bool:
         """
         Validate current transport configuration.
-        
+
         Returns:
             True if configuration is valid, False otherwise
         """
         if not self._config:
             logger.error("Transport not configured")
             return False
-        
+
         # Validate SSL requirements
         if self._config.type in [TransportType.HTTPS, TransportType.MTLS]:
             if not self._config.ssl_enabled:
                 logger.error(f"SSL must be enabled for {self._config.type.value}")
                 return False
-            
+
             if not self._config.cert_file or not self._config.key_file:
-                logger.error(f"SSL certificate and key required for {self._config.type.value}")
+                logger.error(
+                    f"SSL certificate and key required for {self._config.type.value}"
+                )
                 return False
-        
+
         # Validate SSL files exist
         if not self.validate_ssl_files():
             return False
-        
+
         # Validate MTLS requirements
         if self._config.type == TransportType.MTLS:
             if not self._config.verify_client:
                 logger.warning("MTLS transport should have client verification enabled")
-            
+
             if not self._config.ca_cert:
                 logger.warning("CA certificate recommended for MTLS transport")
-        
+
         logger.info(f"Transport configuration validated: {self._config.type.value}")
         return True
-    
+
     def validate_ssl_files(self) -> bool:
         """
         Check if SSL files exist.
-        
+
         Returns:
             True if all SSL files exist, False otherwise
         """
         if not self._config or not self._config.ssl_enabled:
             return True
-        
+
         files_to_check = []
         if self._config.cert_file:
             files_to_check.append(self._config.cert_file)
@@ -256,37 +267,38 @@ class TransportManager:
             files_to_check.append(self._config.key_file)
         if self._config.ca_cert:
             files_to_check.append(self._config.ca_cert)
-        
+
         for file_path in files_to_check:
             if not Path(file_path).exists():
                 logger.error(f"SSL file not found: {file_path}")
                 return False
-        
+
         logger.info(f"All SSL files validated successfully: {files_to_check}")
         return True
-    
+
     def get_hypercorn_config(self) -> Dict[str, Any]:
         """
         Get configuration for hypercorn.
-        
+
         Returns:
             Hypercorn configuration dictionary
         """
         config = {
             "host": "0.0.0.0",  # Can be moved to settings
             "port": self.get_port(),
-            "log_level": "info"
+            "log_level": "info",
         }
-        
+
         if self.is_ssl_enabled():
             ssl_config = self.get_ssl_config()
             if ssl_config:
                 from mcp_proxy_adapter.core.ssl_utils import SSLUtils
+
                 hypercorn_ssl = SSLUtils.get_ssl_config_for_hypercorn(ssl_config)
                 config.update(hypercorn_ssl)
-        
+
         return config
 
 
 # Global transport manager instance
-transport_manager = TransportManager() 
+transport_manager = TransportManager()