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

mcp_proxy_adapter/examples/scripts/create_certificates_simple.py

@@ -10,17 +10,27 @@ import subprocess
 import sys
 import argparse
 from pathlib import Path
+
 # Import mcp_security_framework
 try:
     from mcp_security_framework.core.cert_manager import CertificateManager
-    from mcp_security_framework.schemas.config import CertificateConfig, CAConfig, ServerCertConfig, ClientCertConfig
+    from mcp_security_framework.schemas.config import (
+        CertificateConfig,
+        CAConfig,
+        ServerCertConfig,
+        ClientCertConfig,
+    )
     from mcp_security_framework.schemas.models import CertificateType
+
     SECURITY_FRAMEWORK_AVAILABLE = True
 except ImportError:
     SECURITY_FRAMEWORK_AVAILABLE = False
     print("Warning: mcp_security_framework not available, falling back to OpenSSL")
+
+
 class SimpleCertificateCreator:
     """Create certificates using OpenSSL directly."""
+
     def __init__(self, certs_dir: str = None, keys_dir: str = None):
         # Use current working directory as base
         cwd = Path.cwd()
@@ -39,17 +49,13 @@ class SimpleCertificateCreator:
         self.keys_dir.mkdir(parents=True, exist_ok=True)
         print(f"🔧 Using certificates directory: {self.certs_dir}")
         print(f"🔧 Using keys directory: {self.keys_dir}")
+
     def run_command(self, cmd: list, description: str) -> bool:
         """Run a command and handle errors."""
         try:
             print(f"🔧 {description}...")
             # Use current working directory instead of project_root
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                check=True
-            )
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
             print(f"✅ {description} completed successfully")
             return True
         except subprocess.CalledProcessError as e:
@@ -60,6 +66,7 @@ class SimpleCertificateCreator:
         except Exception as e:
             print(f"❌ {description} failed: {e}")
             return False
+
     def create_ca_certificate(self) -> bool:
         """Create CA certificate using mcp_security_framework or OpenSSL fallback."""
         ca_cert_path = self.certs_dir / "ca_cert.pem"
@@ -71,6 +78,7 @@ class SimpleCertificateCreator:
             return self._create_ca_certificate_with_framework()
         else:
             return self._create_ca_certificate_with_openssl()
+
     def _create_ca_certificate_with_framework(self) -> bool:
         """Create CA certificate using mcp_security_framework."""
         try:
@@ -83,7 +91,7 @@ class SimpleCertificateCreator:
                 country="US",
                 state="Test State",
                 locality="Test City",
-                validity_years=10
+                validity_years=10,
             )
             # Create certificate manager
             cert_config = CertificateConfig(
@@ -91,7 +99,7 @@ class SimpleCertificateCreator:
                 key_storage_path=str(self.keys_dir),
                 default_validity_days=365,
                 key_size=2048,
-                hash_algorithm="sha256"
+                hash_algorithm="sha256",
             )
             cert_manager = CertificateManager(cert_config)
             # Create CA certificate
@@ -106,7 +114,9 @@ class SimpleCertificateCreator:
                     expected_key = self.keys_dir / "ca_key.pem"
                     generated_cert.rename(expected_cert)
                     generated_key.rename(expected_key)
-                    print("✅ CA certificate created successfully using mcp_security_framework")
+                    print(
+                        "✅ CA certificate created successfully using mcp_security_framework"
+                    )
                     return True
                 else:
                     print("❌ Generated CA certificate files not found")
@@ -117,24 +127,32 @@ class SimpleCertificateCreator:
         except Exception as e:
             print(f"❌ Error creating CA certificate with framework: {e}")
             return False
+
     def _create_ca_certificate_with_openssl(self) -> bool:
         """Create CA certificate using OpenSSL fallback."""
         ca_cert_path = self.certs_dir / "ca_cert.pem"
         ca_key_path = self.keys_dir / "ca_key.pem"
         # Create CA private key
-        key_cmd = [
-            "openssl", "genrsa", "-out", str(ca_key_path), "2048"
-        ]
+        key_cmd = ["openssl", "genrsa", "-out", str(ca_key_path), "2048"]
         if not self.run_command(key_cmd, "Creating CA private key"):
             return False
         # Create CA certificate
         cert_cmd = [
-            "openssl", "req", "-new", "-x509", "-days", "3650",
-            "-key", str(ca_key_path),
-            "-out", str(ca_cert_path),
-            "-subj", "/C=US/ST=Test State/L=Test City/O=Test Organization/CN=MCP Proxy Adapter Test CA"
+            "openssl",
+            "req",
+            "-new",
+            "-x509",
+            "-days",
+            "3650",
+            "-key",
+            str(ca_key_path),
+            "-out",
+            str(ca_cert_path),
+            "-subj",
+            "/C=US/ST=Test State/L=Test City/O=Test Organization/CN=MCP Proxy Adapter Test CA",
         ]
         return self.run_command(cert_cmd, "Creating CA certificate")
+
     def create_server_certificate(self) -> bool:
         """Create server certificate using mcp_security_framework or OpenSSL fallback."""
         server_cert_path = self.certs_dir / "server_cert.pem"
@@ -146,6 +164,7 @@ class SimpleCertificateCreator:
             return self._create_server_certificate_with_framework()
         else:
             return self._create_server_certificate_with_openssl()
+
     def _create_server_certificate_with_framework(self) -> bool:
         """Create server certificate using mcp_security_framework."""
         try:
@@ -184,7 +203,7 @@ class SimpleCertificateCreator:
                 subject_alt_names=["localhost", "127.0.0.1"],
                 validity_years=1,
                 ca_cert_path=ca_cert_path,
-                ca_key_path=ca_key_path
+                ca_key_path=ca_key_path,
             )
             # Create certificate manager
             cert_config = CertificateConfig(
@@ -192,7 +211,7 @@ class SimpleCertificateCreator:
                 key_storage_path=str(self.certs_dir),  # Server keys in certs dir
                 default_validity_days=365,
                 key_size=2048,
-                hash_algorithm="sha256"
+                hash_algorithm="sha256",
             )
             cert_manager = CertificateManager(cert_config)
             # Create server certificate
@@ -205,52 +224,71 @@ class SimpleCertificateCreator:
                     # Move to expected names
                     generated_cert.rename(self.certs_dir / "server_cert.pem")
                     generated_key.rename(self.certs_dir / "server_key.pem")
-                    print("✅ Server certificate created successfully using mcp_security_framework")
+                    print(
+                        "✅ Server certificate created successfully using mcp_security_framework"
+                    )
                     return True
                 else:
                     print("❌ Generated certificate files not found")
                     return False
             else:
-                print("❌ Failed to create server certificate: Invalid certificate pair")
+                print(
+                    "❌ Failed to create server certificate: Invalid certificate pair"
+                )
                 return False
         except Exception as e:
             print(f"❌ Error creating server certificate with framework: {e}")
             return False
+
     def _create_server_certificate_with_openssl(self) -> bool:
         """Create server certificate using OpenSSL fallback."""
         server_cert_path = self.certs_dir / "server_cert.pem"
         server_key_path = self.certs_dir / "server_key.pem"
         # Create server private key
-        key_cmd = [
-            "openssl", "genrsa", "-out", str(server_key_path), "2048"
-        ]
+        key_cmd = ["openssl", "genrsa", "-out", str(server_key_path), "2048"]
         if not self.run_command(key_cmd, "Creating server private key"):
             return False
         # Create server certificate signing request
         csr_path = self.certs_dir / "server.csr"
         csr_cmd = [
-            "openssl", "req", "-new",
-            "-key", str(server_key_path),
-            "-out", str(csr_path),
-            "-subj", "/C=US/ST=Test State/L=Test City/O=Test Organization/CN=localhost"
+            "openssl",
+            "req",
+            "-new",
+            "-key",
+            str(server_key_path),
+            "-out",
+            str(csr_path),
+            "-subj",
+            "/C=US/ST=Test State/L=Test City/O=Test Organization/CN=localhost",
         ]
         if not self.run_command(csr_cmd, "Creating server CSR"):
             return False
         # Create server certificate
         cert_cmd = [
-            "openssl", "x509", "-req", "-days", "730",
-            "-in", str(csr_path),
-            "-CA", str(self.certs_dir / "ca_cert.pem"),
-            "-CAkey", str(self.keys_dir / "ca_key.pem"),
+            "openssl",
+            "x509",
+            "-req",
+            "-days",
+            "730",
+            "-in",
+            str(csr_path),
+            "-CA",
+            str(self.certs_dir / "ca_cert.pem"),
+            "-CAkey",
+            str(self.keys_dir / "ca_key.pem"),
             "-CAcreateserial",
-            "-out", str(server_cert_path)
+            "-out",
+            str(server_cert_path),
         ]
         success = self.run_command(cert_cmd, "Creating server certificate")
         # Clean up CSR
         if csr_path.exists():
             csr_path.unlink()
         return success
-    def create_client_certificate(self, name: str, common_name: str, roles: list = None, permissions: list = None) -> bool:
+
+    def create_client_certificate(
+        self, name: str, common_name: str, roles: list = None, permissions: list = None
+    ) -> bool:
         """Create client certificate using mcp_security_framework or OpenSSL fallback."""
         cert_path = self.certs_dir / f"{name}_cert.pem"
         key_path = self.certs_dir / f"{name}_key.pem"
@@ -258,13 +296,20 @@ class SimpleCertificateCreator:
             print(f"ℹ️ Client certificate {name} already exists: {cert_path}")
             return True
         if SECURITY_FRAMEWORK_AVAILABLE:
-            return self._create_client_certificate_with_framework(name, common_name, roles, permissions)
+            return self._create_client_certificate_with_framework(
+                name, common_name, roles, permissions
+            )
         else:
             return self._create_client_certificate_with_openssl(name, common_name)
-    def _create_client_certificate_with_framework(self, name: str, common_name: str, roles: list = None, permissions: list = None) -> bool:
+
+    def _create_client_certificate_with_framework(
+        self, name: str, common_name: str, roles: list = None, permissions: list = None
+    ) -> bool:
         """Create client certificate using mcp_security_framework."""
         try:
-            print(f"🔧 Creating client certificate {name} using mcp_security_framework...")
+            print(
+                f"🔧 Creating client certificate {name} using mcp_security_framework..."
+            )
             # Find CA certificate and key files
             ca_cert_path = None
             ca_key_path = None
@@ -298,7 +343,7 @@ class SimpleCertificateCreator:
                 locality="Test City",
                 validity_years=1,
                 ca_cert_path=ca_cert_path,
-                ca_key_path=ca_key_path
+                ca_key_path=ca_key_path,
             )
             # Create certificate manager
             cert_config = CertificateConfig(
@@ -306,7 +351,7 @@ class SimpleCertificateCreator:
                 key_storage_path=str(self.certs_dir),  # Client keys in certs dir
                 default_validity_days=365,
                 key_size=2048,
-                hash_algorithm="sha256"
+                hash_algorithm="sha256",
             )
             cert_manager = CertificateManager(cert_config)
             # Create client certificate
@@ -321,58 +366,77 @@ class SimpleCertificateCreator:
                     expected_key = self.certs_dir / f"{name}_key.pem"
                     generated_cert.rename(expected_cert)
                     generated_key.rename(expected_key)
-                    print(f"✅ Client certificate {name} created successfully using mcp_security_framework")
+                    print(
+                        f"✅ Client certificate {name} created successfully using mcp_security_framework"
+                    )
                     return True
                 else:
                     print(f"❌ Generated certificate files not found for {name}")
                     return False
             else:
-                print(f"❌ Failed to create client certificate {name}: Invalid certificate pair")
+                print(
+                    f"❌ Failed to create client certificate {name}: Invalid certificate pair"
+                )
                 return False
         except Exception as e:
             print(f"❌ Error creating client certificate {name} with framework: {e}")
             return False
-    def _create_client_certificate_with_openssl(self, name: str, common_name: str) -> bool:
+
+    def _create_client_certificate_with_openssl(
+        self, name: str, common_name: str
+    ) -> bool:
         """Create client certificate using OpenSSL fallback."""
         cert_path = self.certs_dir / f"{name}_cert.pem"
         key_path = self.certs_dir / f"{name}_key.pem"
         # Create client private key
-        key_cmd = [
-            "openssl", "genrsa", "-out", str(key_path), "2048"
-        ]
+        key_cmd = ["openssl", "genrsa", "-out", str(key_path), "2048"]
         if not self.run_command(key_cmd, f"Creating {name} private key"):
             return False
         # Create client certificate signing request
         csr_path = self.certs_dir / f"{name}.csr"
         csr_cmd = [
-            "openssl", "req", "-new",
-            "-key", str(key_path),
-            "-out", str(csr_path),
-            "-subj", f"/C=US/ST=Test State/L=Test City/O=Test Organization/CN={common_name}"
+            "openssl",
+            "req",
+            "-new",
+            "-key",
+            str(key_path),
+            "-out",
+            str(csr_path),
+            "-subj",
+            f"/C=US/ST=Test State/L=Test City/O=Test Organization/CN={common_name}",
         ]
         if not self.run_command(csr_cmd, f"Creating {name} CSR"):
             return False
         # Create client certificate
         cert_cmd = [
-            "openssl", "x509", "-req", "-days", "730",
-            "-in", str(csr_path),
-            "-CA", str(self.certs_dir / "ca_cert.pem"),
-            "-CAkey", str(self.keys_dir / "ca_key.pem"),
+            "openssl",
+            "x509",
+            "-req",
+            "-days",
+            "730",
+            "-in",
+            str(csr_path),
+            "-CA",
+            str(self.certs_dir / "ca_cert.pem"),
+            "-CAkey",
+            str(self.keys_dir / "ca_key.pem"),
             "-CAcreateserial",
-            "-out", str(cert_path)
+            "-out",
+            str(cert_path),
         ]
         success = self.run_command(cert_cmd, f"Creating {name} certificate")
         # Clean up CSR
         if csr_path.exists():
             csr_path.unlink()
         return success
+
     def create_legacy_certificates(self) -> bool:
         """Create legacy certificate files for compatibility."""
         legacy_files = [
             ("client_admin.crt", "client_admin.key", "admin"),
             ("admin.crt", "admin.key", "admin"),
             ("user.crt", "user.key", "user"),
-            ("readonly.crt", "readonly.key", "readonly")
+            ("readonly.crt", "readonly.key", "readonly"),
         ]
         success = True
         for cert_file, key_file, source_name in legacy_files:
@@ -382,13 +446,21 @@ class SimpleCertificateCreator:
                 source_cert = self.certs_dir / f"{source_name}_cert.pem"
                 source_key = self.certs_dir / f"{source_name}_key.pem"
                 if source_cert.exists() and source_key.exists():
-                    self.run_command(["cp", str(source_cert), str(cert_path)], f"Creating {cert_file}")
-                    self.run_command(["cp", str(source_key), str(key_path)], f"Creating {key_file}")
+                    self.run_command(
+                        ["cp", str(source_cert), str(cert_path)],
+                        f"Creating {cert_file}",
+                    )
+                    self.run_command(
+                        ["cp", str(source_key), str(key_path)], f"Creating {key_file}"
+                    )
                 else:
-                    print(f"⚠️ Source certificate {source_name} not found for {cert_file}")
+                    print(
+                        f"⚠️ Source certificate {source_name} not found for {cert_file}"
+                    )
                     # Don't fail the entire process for missing legacy certificates
                     continue
         return True  # Always return True for legacy certificates
+
     def validate_certificates(self) -> bool:
         """Validate all created certificates."""
         print("\n🔍 Validating certificates...")
@@ -399,7 +471,7 @@ class SimpleCertificateCreator:
             "user_cert.pem",
             "readonly_cert.pem",
             "guest_cert.pem",
-            "proxy_cert.pem"
+            "proxy_cert.pem",
         ]
         success = True
         for cert_file in cert_files:
@@ -410,7 +482,7 @@ class SimpleCertificateCreator:
                         ["openssl", "x509", "-in", str(cert_path), "-text", "-noout"],
                         capture_output=True,
                         text=True,
-                        check=True
+                        check=True,
                     )
                     print(f"✅ {cert_file}: Valid")
                 except subprocess.CalledProcessError:
@@ -419,6 +491,7 @@ class SimpleCertificateCreator:
             else:
                 print(f"⚠️ {cert_file}: Not found")
         return success
+
     def create_all(self) -> bool:
         """Create all certificates."""
         print("🔐 Creating All Certificates for Security Testing")
@@ -435,14 +508,41 @@ class SimpleCertificateCreator:
         # 3. Create client certificates
         print("\n👥 Creating client certificates...")
         client_certs = [
-            ("admin", "admin-client", ["admin"], ["read", "write", "execute", "delete", "admin", "register", "unregister", "heartbeat", "discover"]),
-            ("user", "user-client", ["user"], ["read", "execute", "register", "unregister", "heartbeat", "discover"]),
+            (
+                "admin",
+                "admin-client",
+                ["admin"],
+                [
+                    "read",
+                    "write",
+                    "execute",
+                    "delete",
+                    "admin",
+                    "register",
+                    "unregister",
+                    "heartbeat",
+                    "discover",
+                ],
+            ),
+            (
+                "user",
+                "user-client",
+                ["user"],
+                ["read", "execute", "register", "unregister", "heartbeat", "discover"],
+            ),
             ("readonly", "readonly-client", ["readonly"], ["read", "discover"]),
             ("guest", "guest-client", ["guest"], ["read", "discover"]),
-            ("proxy", "proxy-client", ["proxy"], ["register", "unregister", "heartbeat", "discover"])
+            (
+                "proxy",
+                "proxy-client",
+                ["proxy"],
+                ["register", "unregister", "heartbeat", "discover"],
+            ),
         ]
         for name, common_name, roles, permissions in client_certs:
-            if not self.create_client_certificate(name, common_name, roles, permissions):
+            if not self.create_client_certificate(
+                name, common_name, roles, permissions
+            ):
                 success = False
         # 4. Create legacy certificates
         print("\n🔄 Creating legacy certificates...")
@@ -463,6 +563,7 @@ class SimpleCertificateCreator:
                 except OSError:
                     # On Windows, symlink might require admin privileges, copy instead
                     import shutil
+
                     shutil.copy2(ca_cert, expected_ca_cert)
                     print(f"✅ Created CA certificate copy: {expected_ca_cert}")
 
@@ -472,10 +573,13 @@ class SimpleCertificateCreator:
             if server_cert.exists() and not expected_server_cert.exists():
                 try:
                     expected_server_cert.symlink_to(server_cert)
-                    print(f"✅ Created server certificate symlink: {expected_server_cert}")
+                    print(
+                        f"✅ Created server certificate symlink: {expected_server_cert}"
+                    )
                 except OSError:
                     # On Windows, symlink might require admin privileges, copy instead
                     import shutil
+
                     shutil.copy2(server_cert, expected_server_cert)
                     print(f"✅ Created server certificate copy: {expected_server_cert}")
 
@@ -486,6 +590,7 @@ class SimpleCertificateCreator:
             if server_key_certs.exists():
                 # Server key is in certs directory, move it to keys directory
                 import shutil
+
                 shutil.move(str(server_key_certs), str(server_key_keys))
                 print(f"✅ Moved server key to keys directory: {server_key_keys}")
 
@@ -498,6 +603,7 @@ class SimpleCertificateCreator:
                     except OSError:
                         # On Windows, symlink might require admin privileges, copy instead
                         import shutil
+
                         shutil.copy2(server_key_keys, expected_server_key)
                         print(f"✅ Created server key copy: {expected_server_key}")
 
@@ -510,20 +616,28 @@ class SimpleCertificateCreator:
             print(f"📁 Certificates directory: {self.certs_dir}")
             print(f"🔑 Keys directory: {self.keys_dir}")
             print("\n📋 Created certificates:")
-            cert_files = list(self.certs_dir.glob("*.pem")) + list(self.certs_dir.glob("*.crt"))
+            cert_files = list(self.certs_dir.glob("*.pem")) + list(
+                self.certs_dir.glob("*.crt")
+            )
             for cert_file in sorted(cert_files):
                 print(f"   - {cert_file.name}")
-            key_files = list(self.keys_dir.glob("*.pem")) + list(self.keys_dir.glob("*.key"))
+            key_files = list(self.keys_dir.glob("*.pem")) + list(
+                self.keys_dir.glob("*.key")
+            )
             for key_file in sorted(key_files):
                 print(f"   - {key_file.name}")
         else:
             print("❌ Some certificates failed to create")
             print("Check the error messages above")
         return success
+
+
 def main():
     """Main function."""
     parser = argparse.ArgumentParser(description="Create certificates for testing")
-    parser.add_argument("--certs-dir", help="Directory for certificates (default: ./certs)")
+    parser.add_argument(
+        "--certs-dir", help="Directory for certificates (default: ./certs)"
+    )
     parser.add_argument("--keys-dir", help="Directory for keys (default: ./keys)")
     args = parser.parse_args()
 
@@ -543,10 +657,7 @@ def main():
         certs_dir = args.certs_dir
         keys_dir = args.keys_dir
 
-    creator = SimpleCertificateCreator(
-        certs_dir=certs_dir,
-        keys_dir=keys_dir
-    )
+    creator = SimpleCertificateCreator(certs_dir=certs_dir, keys_dir=keys_dir)
     try:
         success = creator.create_all()
         sys.exit(0 if success else 1)
@@ -556,5 +667,7 @@ def main():
     except Exception as e:
         print(f"\n❌ Certificate creation failed: {e}")
         sys.exit(1)
+
+
 if __name__ == "__main__":
     main()