mcp-proxy-adapter 6.0.0__py3-none-any.whl → 6.1.1__py3-none-any.whl

mcp_proxy_adapter/examples/generate_all_certificates.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+"""
+Generate All Certificates for Security Testing
+
+This script generates all necessary certificates for comprehensive security testing:
+- Root CA certificate and key
+- Server certificates for HTTPS and mTLS
+- Client certificates for different roles (admin, user, readonly, etc.)
+- Test certificates for negative scenarios
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+class CertificateGenerator:
+    """Generate all certificates for security testing."""
+    
+    def __init__(self):
+        self.project_root = Path(__file__).parent.parent.parent
+        self.certs_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "certs"
+        self.keys_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "keys"
+        
+        # Create directories if they don't exist
+        self.certs_dir.mkdir(parents=True, exist_ok=True)
+        self.keys_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Certificate configuration
+        self.ca_config = {
+            "common_name": "MCP Proxy Adapter Test CA",
+            "organization": "Test Organization",
+            "country": "US",
+            "state": "Test State",
+            "city": "Test City",
+            "validity_years": 10
+        }
+        
+        self.server_config = {
+            "common_name": "mcp-proxy-adapter-test.local",
+            "organization": "Test Organization",
+            "country": "US",
+            "state": "Test State",
+            "city": "Test City",
+            "validity_years": 2,
+            "san": ["localhost", "127.0.0.1", "mcp-proxy-adapter-test.local"]
+        }
+        
+        # Client certificates configuration
+        self.client_certs = {
+            "admin": {
+                "common_name": "admin-client",
+                "organization": "Test Organization",
+                "roles": ["admin"],
+                "permissions": ["*"]
+            },
+            "user": {
+                "common_name": "user-client",
+                "organization": "Test Organization",
+                "roles": ["user"],
+                "permissions": ["read", "write"]
+            },
+            "readonly": {
+                "common_name": "readonly-client",
+                "organization": "Test Organization",
+                "roles": ["readonly"],
+                "permissions": ["read"]
+            },
+            "guest": {
+                "common_name": "guest-client",
+                "organization": "Test Organization",
+                "roles": ["guest"],
+                "permissions": ["read"]
+            },
+            "proxy": {
+                "common_name": "proxy-client",
+                "organization": "Test Organization",
+                "roles": ["proxy"],
+                "permissions": ["register", "discover"]
+            }
+        }
+        
+        # Negative test certificates
+        self.negative_certs = {
+            "expired": {
+                "common_name": "expired-client",
+                "organization": "Test Organization",
+                "validity_days": 1  # Will expire quickly
+            },
+            "wrong_org": {
+                "common_name": "wrong-org-client",
+                "organization": "Wrong Organization",
+                "roles": ["user"]
+            },
+            "no_roles": {
+                "common_name": "no-roles-client",
+                "organization": "Test Organization",
+                "roles": []
+            },
+            "invalid_roles": {
+                "common_name": "invalid-roles-client",
+                "organization": "Test Organization",
+                "roles": ["invalid_role"]
+            }
+        }
+    
+    def run_command(self, cmd: List[str], description: str) -> bool:
+        """Run a command and handle errors."""
+        try:
+            print(f"🔧 {description}...")
+            result = subprocess.run(
+                cmd,
+                cwd=self.project_root,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            print(f"✅ {description} completed successfully")
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"❌ {description} failed:")
+            print(f"   Command: {' '.join(cmd)}")
+            print(f"   Error: {e.stderr}")
+            return False
+        except Exception as e:
+            print(f"❌ {description} failed: {e}")
+            return False
+    
+    def create_ca_certificate(self) -> bool:
+        """Create Root CA certificate and key."""
+        ca_cert_path = self.certs_dir / "ca_cert.pem"
+        ca_key_path = self.keys_dir / "ca_key.pem"
+        
+        if ca_cert_path.exists() and ca_key_path.exists():
+            print(f"ℹ️ CA certificate already exists: {ca_cert_path}")
+            return True
+        
+        cmd = [
+            sys.executable, "-m", "mcp_security_framework.cli.cert_cli", "create-ca",
+            "-cn", self.ca_config["common_name"],
+            "-o", self.ca_config["organization"],
+            "-c", self.ca_config["country"],
+            "-s", self.ca_config["state"],
+            "-l", self.ca_config["city"],
+            "-y", str(self.ca_config["validity_years"])
+        ]
+        
+        success = self.run_command(cmd, "Creating Root CA certificate")
+        
+        if success:
+            # Move files to correct locations
+            default_ca_cert = Path("./certs") / f"{self.ca_config['common_name'].lower().replace(' ', '_')}_ca.crt"
+            default_ca_key = Path("./keys") / f"{self.ca_config['common_name'].lower().replace(' ', '_')}_ca.key"
+            
+            if default_ca_cert.exists():
+                self.run_command(["mv", str(default_ca_cert), str(ca_cert_path)], "Moving CA certificate")
+            if default_ca_key.exists():
+                self.run_command(["mv", str(default_ca_key), str(ca_key_path)], "Moving CA key")
+        
+        return success
+    
+    def create_server_certificate(self) -> bool:
+        """Create server certificate for HTTPS and mTLS."""
+        server_cert_path = self.certs_dir / "server_cert.pem"
+        server_key_path = self.certs_dir / "server_key.pem"
+        
+        if server_cert_path.exists() and server_key_path.exists():
+            print(f"ℹ️ Server certificate already exists: {server_cert_path}")
+            return True
+        
+        # Create server certificate
+        cmd = [
+            sys.executable, "-m", "mcp_security_framework.cli.cert_cli", "create-server",
+            "-cn", self.server_config["common_name"],
+            "-o", self.server_config["organization"],
+            "-c", self.server_config["country"],
+            "-s", self.server_config["state"],
+            "-l", self.server_config["city"],
+            "-d", str(self.server_config["validity_years"] * 365)  # Convert years to days
+        ]
+        
+        # Add SAN if supported
+        if self.server_config["san"]:
+            for san in self.server_config["san"]:
+                cmd.extend(["--san", san])
+        
+        success = self.run_command(cmd, "Creating server certificate")
+        
+        if success:
+            # Move files to correct locations
+            default_server_cert = Path("./certs") / f"{self.server_config['common_name'].lower().replace('.', '_')}_server.crt"
+            default_server_key = Path("./keys") / f"{self.server_config['common_name'].lower().replace('.', '_')}_server.key"
+            
+            if default_server_cert.exists():
+                self.run_command(["mv", str(default_server_cert), str(server_cert_path)], "Moving server certificate")
+            if default_server_key.exists():
+                self.run_command(["mv", str(default_server_key), str(server_key_path)], "Moving server key")
+        
+        return success
+    
+    def create_client_certificate(self, name: str, config: Dict) -> bool:
+        """Create client certificate with specific configuration."""
+        cert_path = self.certs_dir / f"{name}_cert.pem"
+        key_path = self.certs_dir / f"{name}_key.pem"
+        
+        if cert_path.exists() and key_path.exists():
+            print(f"ℹ️ Client certificate {name} already exists: {cert_path}")
+            return True
+        
+        cmd = [
+            sys.executable, "-m", "mcp_security_framework.cli.cert_cli", "create-client",
+            "-cn", config["common_name"],
+            "-o", config["organization"],
+            "-c", self.ca_config["country"],
+            "-s", self.ca_config["state"],
+            "-l", self.ca_config["city"],
+            "-d", "730"  # 2 years in days
+        ]
+        
+        # Add roles if specified
+        if "roles" in config and config["roles"]:
+            for role in config["roles"]:
+                cmd.extend(["--roles", role])
+        
+        # Add permissions if specified
+        if "permissions" in config and config["permissions"]:
+            for permission in config["permissions"]:
+                cmd.extend(["--permissions", permission])
+        
+        # Add custom validity for negative tests
+        if "validity_days" in config:
+            cmd[cmd.index("-d") + 1] = str(config["validity_days"])
+        
+        success = self.run_command(cmd, f"Creating client certificate: {name}")
+        
+        if success:
+            # Move files to correct locations
+            default_client_cert = Path("./certs") / f"{config['common_name'].lower().replace('-', '_')}_client.crt"
+            default_client_key = Path("./keys") / f"{config['common_name'].lower().replace('-', '_')}_client.key"
+            
+            if default_client_cert.exists():
+                self.run_command(["mv", str(default_client_cert), str(cert_path)], f"Moving {name} certificate")
+            if default_client_key.exists():
+                self.run_command(["mv", str(default_client_key), str(key_path)], f"Moving {name} key")
+        
+        return success
+    
+    def create_legacy_certificates(self) -> bool:
+        """Create legacy certificate files for compatibility."""
+        legacy_files = [
+            ("client.crt", "client.key"),
+            ("client_admin.crt", "client_admin.key"),
+            ("admin.crt", "admin.key"),
+            ("user.crt", "user.key"),
+            ("readonly.crt", "readonly.key")
+        ]
+        
+        success = True
+        for cert_file, key_file in legacy_files:
+            cert_path = self.certs_dir / cert_file
+            key_path = self.certs_dir / key_file
+            
+            if not cert_path.exists() or not key_path.exists():
+                # Copy from existing certificates
+                if cert_file == "client.crt" and (self.certs_dir / "user_cert.pem").exists():
+                    self.run_command(["cp", str(self.certs_dir / "user_cert.pem"), str(cert_path)], f"Creating {cert_file}")
+                    self.run_command(["cp", str(self.certs_dir / "user_key.pem"), str(key_path)], f"Creating {key_file}")
+                elif cert_file == "client_admin.crt" and (self.certs_dir / "admin_cert.pem").exists():
+                    self.run_command(["cp", str(self.certs_dir / "admin_cert.pem"), str(cert_path)], f"Creating {cert_file}")
+                    self.run_command(["cp", str(self.certs_dir / "admin_key.pem"), str(key_path)], f"Creating {key_file}")
+                elif cert_file == "admin.crt" and (self.certs_dir / "admin_cert.pem").exists():
+                    self.run_command(["cp", str(self.certs_dir / "admin_cert.pem"), str(cert_path)], f"Creating {cert_file}")
+                    self.run_command(["cp", str(self.certs_dir / "admin_key.pem"), str(key_path)], f"Creating {key_file}")
+                elif cert_file == "user.crt" and (self.certs_dir / "user_cert.pem").exists():
+                    self.run_command(["cp", str(self.certs_dir / "user_cert.pem"), str(cert_path)], f"Creating {cert_file}")
+                    self.run_command(["cp", str(self.certs_dir / "user_key.pem"), str(key_path)], f"Creating {key_file}")
+                elif cert_file == "readonly.crt" and (self.certs_dir / "readonly_cert.pem").exists():
+                    self.run_command(["cp", str(self.certs_dir / "readonly_cert.pem"), str(cert_path)], f"Creating {cert_file}")
+                    self.run_command(["cp", str(self.certs_dir / "readonly_key.pem"), str(key_path)], f"Creating {key_file}")
+        
+        return success
+    
+    def create_certificate_config(self) -> bool:
+        """Create certificate configuration file."""
+        config_path = self.certs_dir / "cert_config.json"
+        
+        config = {
+            "ca_cert_path": str(self.certs_dir / "ca_cert.pem"),
+            "ca_key_path": str(self.keys_dir / "ca_key.pem"),
+            "cert_storage_path": str(self.certs_dir),
+            "key_storage_path": str(self.keys_dir),
+            "default_validity_days": 365,
+            "key_size": 2048,
+            "hash_algorithm": "sha256"
+        }
+        
+        try:
+            with open(config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+            print(f"✅ Created certificate config: {config_path}")
+            return True
+        except Exception as e:
+            print(f"❌ Failed to create certificate config: {e}")
+            return False
+    
+    def validate_certificates(self) -> bool:
+        """Validate all created certificates."""
+        print("\n🔍 Validating certificates...")
+        
+        cert_files = [
+            "ca_cert.pem",
+            "server_cert.pem",
+            "admin_cert.pem",
+            "user_cert.pem",
+            "readonly_cert.pem",
+            "guest_cert.pem",
+            "proxy_cert.pem"
+        ]
+        
+        success = True
+        for cert_file in cert_files:
+            cert_path = self.certs_dir / cert_file
+            if cert_path.exists():
+                try:
+                    result = subprocess.run(
+                        ["openssl", "x509", "-in", str(cert_path), "-text", "-noout"],
+                        capture_output=True,
+                        text=True,
+                        check=True
+                    )
+                    print(f"✅ {cert_file}: Valid")
+                except subprocess.CalledProcessError:
+                    print(f"❌ {cert_file}: Invalid")
+                    success = False
+            else:
+                print(f"⚠️ {cert_file}: Not found")
+        
+        return success
+    
+    def generate_all(self) -> bool:
+        """Generate all certificates."""
+        print("🔐 Generating All Certificates for Security Testing")
+        print("=" * 60)
+        
+        success = True
+        
+        # 1. Create CA certificate
+        if not self.create_ca_certificate():
+            success = False
+            print("❌ Cannot continue without CA certificate")
+            return False
+        
+        # 2. Create server certificate
+        if not self.create_server_certificate():
+            success = False
+        
+        # 3. Create client certificates for different roles
+        print("\n👥 Creating client certificates...")
+        for name, config in self.client_certs.items():
+            if not self.create_client_certificate(name, config):
+                success = False
+        
+        # 4. Create negative test certificates
+        print("\n🚫 Creating negative test certificates...")
+        for name, config in self.negative_certs.items():
+            if not self.create_client_certificate(name, config):
+                success = False
+        
+        # 5. Create legacy certificates for compatibility
+        print("\n🔄 Creating legacy certificates...")
+        if not self.create_legacy_certificates():
+            success = False
+        
+        # 6. Create certificate configuration
+        if not self.create_certificate_config():
+            success = False
+        
+        # 7. Validate certificates
+        if not self.validate_certificates():
+            success = False
+        
+        # Print summary
+        print("\n" + "=" * 60)
+        print("📊 CERTIFICATE GENERATION SUMMARY")
+        print("=" * 60)
+        
+        if success:
+            print("✅ All certificates generated successfully!")
+            print(f"📁 Certificates directory: {self.certs_dir}")
+            print(f"🔑 Keys directory: {self.keys_dir}")
+            print("\n📋 Generated certificates:")
+            
+            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"))
+            for key_file in sorted(key_files):
+                print(f"   - {key_file.name}")
+        else:
+            print("❌ Some certificates failed to generate")
+            print("Check the error messages above")
+        
+        return success
+
+
+def main():
+    """Main function."""
+    generator = CertificateGenerator()
+    
+    try:
+        success = generator.generate_all()
+        sys.exit(0 if success else 1)
+    except KeyboardInterrupt:
+        print("\n⚠️ Certificate generation interrupted by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n❌ Certificate generation failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/generate_certificates.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+Certificate Generation Script
+
+This script generates all necessary certificates for the examples using
+mcp_security_framework certificate management tools.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+def run_command(cmd, description):
+    """Run a command and handle errors."""
+    print(f"🔧 {description}...")
+    try:
+        result = subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True)
+        print(f"✅ {description} completed successfully")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ {description} failed: {e}")
+        print(f"Error output: {e.stderr}")
+        return False
+
+def main():
+    """Generate all certificates for examples."""
+    print("🔐 Certificate Generation Script")
+    print("=" * 50)
+    
+    # Create directories
+    cert_dir = Path("certs")
+    cert_dir.mkdir(exist_ok=True)
+    
+    # Check if mcp_security_framework is available
+    try:
+        import mcp_security_framework
+        print(f"✅ mcp_security_framework version {mcp_security_framework.__version__} found")
+    except ImportError:
+        print("❌ mcp_security_framework not found")
+        return False
+    
+    # Generate CA certificate
+    if not run_command(
+        "python -m mcp_security_framework.cli.cert_cli create-ca "
+        "--common-name 'MCP Proxy Adapter CA' "
+        "--organization 'MCP Proxy Adapter' "
+        "--country 'US' "
+        "--state 'State' "
+        "--locality 'City' "
+        "--validity-years 10 "
+        "--key-size 2048",
+        "Creating root CA certificate"
+    ):
+        return False
+    
+    # Generate server certificate
+    if not run_command(
+        "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-server "
+        "--common-name 'localhost' "
+        "--organization 'MCP Proxy Adapter' "
+        "--country 'US' "
+        "--validity-days 365 "
+        "--key-size 2048",
+        "Creating server certificate"
+    ):
+        return False
+    
+    # Generate admin client certificate
+    if not run_command(
+        "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-client "
+        "--common-name 'admin' "
+        "--organization 'MCP Proxy Adapter' "
+        "--country 'US' "
+        "--validity-days 365 "
+        "--key-size 2048 "
+        "--roles 'admin' "
+        "--permissions 'read,write,delete'",
+        "Creating admin client certificate"
+    ):
+        return False
+    
+    # Generate user client certificate
+    if not run_command(
+        "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-client "
+        "--common-name 'user' "
+        "--organization 'MCP Proxy Adapter' "
+        "--country 'US' "
+        "--validity-days 365 "
+        "--key-size 2048 "
+        "--roles 'user' "
+        "--permissions 'read,write'",
+        "Creating user client certificate"
+    ):
+        return False
+    
+    # Generate readonly client certificate
+    if not run_command(
+        "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-client "
+        "--common-name 'readonly' "
+        "--organization 'MCP Proxy Adapter' "
+        "--country 'US' "
+        "--validity-days 365 "
+        "--key-size 2048 "
+        "--roles 'readonly' "
+        "--permissions 'read'",
+        "Creating readonly client certificate"
+    ):
+        return False
+    
+    print("\n🎉 All certificates generated successfully!")
+    print("📁 Certificates are stored in the 'certs' directory")
+    
+    return True
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

mcp_proxy_adapter/examples/keys/ca_key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDLlJMRJelqXw2E
+AHQf8KnxSbiqY8Ee2q5G7xjgyamBae4HdOcCoLu4GA7mvSmBZDvj6NuVjdYKhKYH
+TzfT1aXgwx9DZykDB9/ApbPYFO3rndu0c5xxST8iJqtLk5YJ+yM04rCv3miQhdSN
+ZjNlInihC5uoOXrVyUgrgxKjOxhkudW1CIaIgaIlbJcftffUzEtcfYgSMc0J3EZX
+E3fvX+9xqWMWfpcoftWMHZpcbV+1dke68s+i5F+98TEG2JxbmlkXgNq0xRdWpcnV
+osU4sYxfKiKCWN5RUlumx9Xh1Mlw4m/C38ZgM3/DWS+0dAl5r4Q0lObBF0ej54U4
+BVgMMOPJAgMBAAECggEAARkcj/ed4jKADqm39qIkMIZ+xgCCvqlcTkqk3jWIQgfx
+vj2Nr3BxgsUyc2Eq06VYQ1rysERTFrxvbtOpD+3zlppG1WS9jmQg+1eJeE1omSBB
+WqBTBDNqcUM3IlG5+fTOVE8yt8gh1UG7i0W1WkLM1sWKweYJeRS8XGu5EoNTltt9
+SDWsx5fCjHMviYhEiHOkkP62ZjdsrH7qYvoR6AeWAUWODy253cWs/Fzj6OeGk7VO
+qLw7i7geWpzmosevfd+fxVJW0UOKKMGngI8xPeJnpQJDL1Vrb+fUeJ0Hu9LXWR9d
+6LKoP9gaKvXLA4NmkkX+B0+fBVWTR3rAuYRgxLJeAQKBgQD5N1Dw3ocayMM3RqOq
+l6OkGxd+kssnSJN3yZiOBXHy7923mhAMP2KKTP9z3J/CzjWxfRbLEwKWn3Ft2IzM
+WCbQKFTKRWGJeOg0I2k6DI68x7Wqw5kkc3NogxziWOO67UPgHNWsXFR9H9XzAB5+
+RY7THOrHPIjQIeT2xEHeh/UOgQKBgQDRHz3t0iRt3Qj58RxknbXbTA82FijPF2Xc
+ByzJQNZs2+nYlB+S4MB/XCzMfJdP+FrA8BZ5MOT90TBIqYmIo2mnY6/D9XeGaOti
+H8xV45x0C2RlNXCX9Nn4P+j64fZdHVp2+rirNqvyTKN7fKI/Cbd3TMipJUGe77N4
+5KmPMCFBSQKBgQDPEDrcJsgyZORuJO8Pana4fxoCPI020oJUYNe0CKooo0ugpQz4
+YCHLrzYAWisTfKn4EmrBx8W6yDdCgU5a6lM1WI06knL7+c1UpKdlZ9Gg4H38qA+x
+zYryJx30os50HXbr2olecEhyveTRxiOP3tNQbRJU/+Lcq4zFy0K/Vk8yAQKBgF7J
+9H46BH0v9YOlgKMywV23qiVwAetsxaToM6q9kvQg8mxTJ8Shz19rXnsJ9mQvRKOz
+r9wbB5DtIx+siUTAHYHcM611NEpegGMn2q0L0Lzg9Q7THEgkmjBmd6pQhiVKytin
+aNFipKndhzTQF5LPSrPuv/27f3UVXZpsu1bGECzRAoGBAIBAJPYmlt8Mfhhvi9Yg
+OXhlqPT7PjRBu+YaoineS5BNZ9V/23ib7iAOClCxdX+7doHI0VKzMyGJR2xa7Rzl
+/oRInNWGU2UV+mCb6FoYohfHX0OFkelKJOZsyxWUrQ93IipwBTomoQnnrEExSzLh
+r0FGAumOHw6zwjmbFSXRbPvs
+-----END PRIVATE KEY-----

mcp_proxy_adapter/examples/keys/mcp_proxy_adapter_ca_ca.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDWjQzvziU+/Y+S
+wXDHXvcG5/ZV3C/R/9JhKZCAJ2g28Dg97Xjf9L8hh+Wzpkj3wDJL2Ho76nMegO5V
++m/HFVabSA/dn4bxOGqL5v7AXkQrdWRATYMRmGG6lS1NZC6pHRuD/Oun76Jv9aiN
+QyYkLR3iFY8+pQTFhJX2MOO99gmPtAPmy3l3Zu1l2S87TB5Lv8MGuhSuPoNTWzND
+hKP06oX6BCpqmqgkgo0Moy7SaVWAxviyZFjv/SbxUVU1kXqXJpUFoyCHX4ocQqNT
+iGl+M2q0VZm9slhNuisoR7RfAx8eEBcPebOIlqzHBvq3hGgYeWWjnW34OrNwmhx1
+kAPu3CRhAgMBAAECggEACi6y4NAGzSuEMdyDuWKUv2Yo4cBLy1/5yxS0P/DJgw9O
+4VmGNWgh3g8wuUr4sZFp5wGaI4J9U4Lzohmlo8GBKmjMH/eJ6aQvd6j53tqvyjmN
+uCOK8eh/0uFw6fhe4osixYEuafpMhPBtacQ4aNp0ovM6U33KG9musvrKWYygvYog
+/FUsR/3iUx0FK2Bpa9O7BDNpau7QdBwXyoQAv/BY+lGysdtfwuJOiQdIxg2if15v
+QUgryNV+x6v2mmVV/wiJ/H+3D1Els+BQG5DA3s0IjblEKYKryA6xM5WdSLUCADt4
+gE5V4yJ652iHPGd9X0OZ3wKEz55HJecIW6O8UORQsQKBgQD3uYdVLLMReZxV2tfk
+hoIJ2HEtiJjCmvjnL5fSbLGVTnkCi/S94X02UsKeHnrkzR/QCRzSBKdOkPZXinMZ
+cDYv4z7rNolBMc2Itqq27g5Yxu0NpJ1303QOc3m97O37X8y6r+TYj8frRJrx7iG1
+9N11j99ZoP9vH2LHcdDubcDL5QKBgQDdt9RYwyFo/vmi8I1KdYBScNXXujf6spPa
+jgeZ3tP8Dkhuf2oABjflK7G4ySIAPl9BDBgc9paY4IcHkgw2YJd5pyYMaCrk4mPg
+NnYCthGIxSzpeqfaFIEavE8/zxeT9jhTh7ScFCFqaUFtzzlzjTzc54MNm5fhc9oq
+2I4rl9OGzQKBgQCbjSQtl6PZlUNVpdVq6gs9o2tt7BgAGs+wW3I574aS+nOB5eAI
+W08EjXMnVnxUr3kKaK5wMfvcmaoVzhn4Hz3nVApuKBCHn34wGoOX2mOn20F/D57R
+XzXA3UHUwLGu5rjngQtx8NbYJHwm7iC84MUuzOiynyXF4S9ljVJkZQZrAQKBgGOg
+/DlajYPJt1FBeKvxutTQwTasBgWQAyJdWgsJdwY3QNLuTCpwoONIzBZ1wuKLJHBt
+R9ST9b4CfoqnVPeGVeqjclR25ndtR2Xz8vlq6NwlhfXwWMaFGjJyVcYdf8HMDSlz
+vHO6E/3mCDGYwX8sAyJcoaYWuZvkXC+Omev60GEtAoGAeryzTJzl8DHbDKk/3Zvv
+Zo6CbiPh2iBdb6PoPL4cSg/NBDNuHrnWPr/N0RZ5D/cNfA8cv20I1tWBPr+X6r3F
+2QQKSVt89JqfWJ1Xpj2Nxpnfa3QGFiQFCG5/366rZgASaQsuZNTAVgpbMEpwCjzI
+t0rl84AcRvCvzc67//51jZg=
+-----END PRIVATE KEY-----

mcp_proxy_adapter/examples/keys/test_ca_ca.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDLj3pcpg4owGNK
++8KT5FbXuGKYH0577+h9RE0KGC9JrJxCn8O1g62lRcpDCQ8IGwPn97wVGfbAG8ei
+iQUfEPNfkaILv+f2j69tZIbhwuuUjfip8Xy4qcMCYTOnoB8ruwpwiKC8VCmWOOG+
+ma59isHAc0WuNhM+UXmkvEh1CnW3IlmRSilkLAdAI0Z+LkJH6Olb8loFsCcIb3kS
++FXrviS10eUXxntwNmyHV29svqByS+l5vxloatsMpRZWKZVRr9avYEZhtV37Ae/k
+JD5dqGGa4+5iJJiN9FBmxr7FRJ1/w35fFzR9TP2UyBNhMrEGTii2abITzrSS+nid
+jSBj01kxAgMBAAECggEAUGEvAZ+mjqvtaWIBgvGS4yrRb91I2gKxTKmoPBixr4dj
+yqEYoDfHXTAyPoc4sswsHjCCSdjPSSuPCJzPc2V3nKC+mqIkQAWb0Xf1FPepm6b1
+7nFHfQm30dw9D+9X76YzaJ1izwrywvliFqfLsZIVkN9TwAdlUOHORWD9wY2oTvAi
+JS7PvTCWuqv4JkAIPZz2UIMBSv7ZajFr4Ysa2Sp9MM2kbIA7uE66HoIF7ic7eD6P
+a6vaFQ23oDs/ZkL73L4goD0283E0HZ/RIBXgFTVvS4bOfbU+ShgRuznX9MmTJIXP
+kgIbgOa3gJhvkKvmLsame9QP7nXzLQiystFqa7B6KwKBgQD1u5ztEkt2CQ1EFjMG
+9A6kCMPsJHn/HFVbQcs2ZEPiZ7ioTamWZDziP0ykzrymNqkBqOcqEpAj6OUKbFpA
+8Q1sxVkZZrJmlOMT73Hzv0fyS2sRVH7ee4uFjVd67lVoWjKFOu/CAooz82IkI6r0
+qTGaPbCsz0w4U5ka+ZQWw1RQpwKBgQDUEMi7di8YAZYEwiYNDzee+E6JcJ1z/URU
+29DO+5YIhVHLft6vLWqe5law/oQlKULN6k3FO/zd977DoS0c9ALgKgDuhf46NXSk
+ukboc2Yplt1LtFOlE7JeYuiHacRHwh+j5ToVlcUVZywXmadDpnNLmWqmivqw9th/
+V/0AiOiqZwKBgQC5ORR9IfgdXY9RTgZibF4IyM6dVZVbdQjlw38gXY1Jv/LRcdCt
+mprF0v67j1VlV/gmVyD/doSNfMQAClIxd0EuRsb1PZKlff54DVlwaDMb8DshEfab
+TraJEVPqRnG8OZixEg6cx3tS01abdQMsbcgEwhFFAPAr2N+kFJHKYqtQKwKBgQCs
+U5dK/pb2YxONeleBdUQ1ooHvndvVTZIhgx8Dk94vvmbhfo9muvlRdswruCeaKxVm
+T2gzRrQNjC0wu+D1DjToBDoNmkUk+Bt5YQYODviOA1KBGmB+XKstmCJtJ72gslcT
+0EqLD9G/ur9RzkLl7nTykhDglT9yXqU/lji6HoczMQKBgAYhRQeD9pjWPw1+I3Em
+ZwKrAWmOsQKjV4oURU2U/QHKuyzH/H5XkKXpJgpCnYU6XRmIGWvoH/SyLvFv4fhC
+SN8NEoT5JuuMrrJP2m0lWen52ATuuBt/PD+9CSkm9lD9zTG0V9V/he0wYXYv5yYA
+52PiP265yj3oroWvGzUwJxxR
+-----END PRIVATE KEY-----