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

mcp_proxy_adapter/examples/run_security_tests.py

@@ -1,18 +1,15 @@
 #!/usr/bin/env python3
 """
 Security Test Runner for MCP Proxy Adapter
-
 This script runs comprehensive security tests against all server configurations:
 - Basic HTTP
 - HTTP + Token authentication
 - HTTPS
 - HTTPS + Token authentication
 - mTLS
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import asyncio
 import json
 import os
@@ -22,17 +19,12 @@ import sys
 import time
 from pathlib import Path
 from typing import Dict, List, Optional, Any
-
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
-
 from security_test_client import SecurityTestClient, TestResult
-
-
 class SecurityTestRunner:
     """Main test runner for security testing."""
-    
     def __init__(self):
         """Initialize test runner."""
         self.servers = {}
@@ -69,50 +61,40 @@ class SecurityTestRunner:
                 "auth": "certificate"
             }
         }
-    
     def check_prerequisites(self) -> bool:
         """Check if all prerequisites are met."""
         print("🔍 Checking prerequisites...")
-        
         # Check if we're in the right directory
         if not Path("server_configs").exists():
             print("❌ server_configs directory not found. Please run from mcp_proxy_adapter/examples/")
             return False
-        
         # Check if certificates exist
         cert_files = [
             "certs/ca_cert.pem",
             "certs/server_cert.pem",
             "certs/server_key.pem"
         ]
-        
         missing_certs = []
         for cert_file in cert_files:
             if not Path(cert_file).exists():
                 missing_certs.append(cert_file)
-        
         if missing_certs:
             print(f"❌ Missing certificates: {missing_certs}")
             print("💡 Run: python generate_certificates.py")
             return False
-        
         print("✅ Prerequisites check passed")
         return True
-    
     def start_server(self, name: str, config_path: str, port: int) -> Optional[subprocess.Popen]:
         """Start a server in background."""
         try:
             print(f"🚀 Starting {name} server on port {port}...")
-            
             # Start server in background
             process = subprocess.Popen([
                 sys.executable, "-m", "mcp_proxy_adapter.main",
                 "--config", config_path
             ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            
             # Wait a bit for server to start
             time.sleep(3)
-            
             # Check if process is still running
             if process.poll() is None:
                 print(f"✅ {name} server started (PID: {process.pid})")
@@ -123,17 +105,14 @@ class SecurityTestRunner:
                 print(f"STDOUT: {stdout.decode()}")
                 print(f"STDERR: {stderr.decode()}")
                 return None
-                
         except Exception as e:
             print(f"❌ Error starting {name} server: {e}")
             return None
-    
     def stop_server(self, name: str, process: subprocess.Popen):
         """Stop a server."""
         try:
             print(f"🛑 Stopping {name} server (PID: {process.pid})...")
             process.terminate()
-            
             # Wait for graceful shutdown
             try:
                 process.wait(timeout=5)
@@ -142,15 +121,12 @@ class SecurityTestRunner:
                 print(f"⚠️ Force killing {name} server")
                 process.kill()
                 process.wait()
-                
         except Exception as e:
             print(f"❌ Error stopping {name} server: {e}")
-    
     async def test_server(self, name: str, config: Dict[str, Any]) -> List[TestResult]:
         """Test a specific server configuration."""
         print(f"\n🧪 Testing {name} server...")
         print("=" * 50)
-        
         # Create client with appropriate SSL context
         if config["auth"] == "certificate":
             # For mTLS, create client with certificate-based SSL context
@@ -159,29 +135,25 @@ class SecurityTestRunner:
             client.create_ssl_context = client.create_ssl_context_for_mtls
             async with client as client_session:
                 results = await client_session.run_security_tests(
-                    config["url"], 
+                    config["url"],
                     config["auth"]
                 )
         else:
             # For other auth types, use default SSL context
             async with SecurityTestClient(config["url"]) as client:
                 results = await client.run_security_tests(
-                    config["url"], 
+                    config["url"],
                     config["auth"]
                 )
-        
         # Print summary for this server
         passed = sum(1 for r in results if r.success)
         total = len(results)
         print(f"\n📊 {name} Results: {passed}/{total} tests passed")
-        
         return results
-    
     async def run_all_tests(self) -> Dict[str, List[TestResult]]:
         """Run tests against all server configurations."""
         print("🚀 Starting comprehensive security testing")
         print("=" * 60)
-        
         # Start all servers
         for name, config in self.configs.items():
             process = self.start_server(name, config["config"], config["port"])
@@ -189,11 +161,9 @@ class SecurityTestRunner:
                 self.servers[name] = process
             else:
                 print(f"⚠️ Skipping tests for {name} due to startup failure")
-        
         # Wait for all servers to be ready
         print("\n⏳ Waiting for servers to be ready...")
         time.sleep(5)
-        
         # Test each server
         all_results = {}
         for name, config in self.configs.items():
@@ -207,41 +177,33 @@ class SecurityTestRunner:
             else:
                 print(f"⚠️ Skipping {name} tests (server not running)")
                 all_results[name] = []
-        
         return all_results
-    
     def print_final_summary(self, all_results: Dict[str, List[TestResult]]):
         """Print final test summary."""
         print("\n" + "=" * 80)
         print("📊 FINAL SECURITY TEST SUMMARY")
         print("=" * 80)
-        
         total_tests = 0
         total_passed = 0
-        
         for server_name, results in all_results.items():
             if results:
                 passed = sum(1 for r in results if r.success)
                 total = len(results)
                 total_tests += total
                 total_passed += passed
-                
                 status = "✅ PASS" if passed == total else "❌ FAIL"
                 print(f"{status} {server_name.upper()}: {passed}/{total} tests passed")
-                
                 # Show failed tests
                 failed_tests = [r for r in results if not r.success]
                 for test in failed_tests:
                     print(f"   ❌ {test.test_name}: {test.error_message}")
             else:
                 print(f"⚠️ SKIP {server_name.upper()}: No tests run")
-        
         print("\n" + "-" * 80)
         print(f"OVERALL: {total_passed}/{total_tests} tests passed")
         if total_tests > 0:
             success_rate = (total_passed / total_tests) * 100
             print(f"SUCCESS RATE: {success_rate:.1f}%")
-        
         # Overall status
         if total_passed == total_tests and total_tests > 0:
             print("🎉 ALL TESTS PASSED!")
@@ -249,68 +211,50 @@ class SecurityTestRunner:
             print("⚠️ SOME TESTS FAILED")
         else:
             print("❌ ALL TESTS FAILED")
-    
     def cleanup(self):
         """Cleanup all running servers."""
         print("\n🧹 Cleaning up...")
-        
         for name, process in self.servers.items():
             self.stop_server(name, process)
-        
         self.servers.clear()
-    
     def signal_handler(self, signum, frame):
         """Handle interrupt signals."""
         print(f"\n⚠️ Received signal {signum}, cleaning up...")
         self.cleanup()
         sys.exit(0)
-    
     async def run(self):
         """Main run method."""
         # Set up signal handlers
         signal.signal(signal.SIGINT, self.signal_handler)
         signal.signal(signal.SIGTERM, self.signal_handler)
-        
         try:
             # Check prerequisites
             if not self.check_prerequisites():
                 return False
-            
             # Run all tests
             all_results = await self.run_all_tests()
-            
             # Print summary
             self.print_final_summary(all_results)
-            
             return True
-            
         except Exception as e:
             print(f"❌ Test runner error: {e}")
             return False
-        
         finally:
             # Always cleanup
             self.cleanup()
-
-
 def main():
     """Main function."""
     import argparse
-    
     parser = argparse.ArgumentParser(description="Security Test Runner for MCP Proxy Adapter")
     parser.add_argument("--config", help="Test specific configuration")
     parser.add_argument("--no-cleanup", action="store_true", help="Don't cleanup servers after tests")
     parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
-    
     args = parser.parse_args()
-    
     # Change to examples directory
     examples_dir = Path(__file__).parent
     os.chdir(examples_dir)
-    
     # Create and run test runner
     runner = SecurityTestRunner()
-    
     try:
         success = asyncio.run(runner.run())
         sys.exit(0 if success else 1)
@@ -320,7 +264,5 @@ def main():
     except Exception as e:
         print(f"❌ Unexpected error: {e}")
         sys.exit(1)
-
-
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/run_security_tests_fixed.py

@@ -1,14 +1,11 @@
 #!/usr/bin/env python3
 """
 Security Testing Script - Fixed Version
-
 This script runs comprehensive security tests without fallback mode
 and with proper port management.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import asyncio
 import json
 import os
@@ -18,23 +15,17 @@ import sys
 import time
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
-
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
-
 from security_test_client import SecurityTestClient, TestResult
-
-
 class SecurityTestRunner:
     """Security test runner with proper port management."""
-    
     def __init__(self):
         self.project_root = Path(__file__).parent.parent.parent
         self.configs_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "server_configs"
         self.server_processes = {}
         self.test_results = []
-        
     def kill_process_on_port(self, port: int) -> bool:
         """Kill process using specific port."""
         try:
@@ -45,7 +36,6 @@ class SecurityTestRunner:
                 text=True,
                 timeout=5
             )
-            
             if result.returncode == 0 and result.stdout.strip():
                 pid = result.stdout.strip()
                 # Kill the process
@@ -62,7 +52,6 @@ class SecurityTestRunner:
         except Exception as e:
             print(f"❌ Error killing process on port {port}: {e}")
             return False
-    
     def start_server(self, config_name: str, config_path: Path) -> Optional[subprocess.Popen]:
         """Start server with proper error handling."""
         try:
@@ -70,22 +59,18 @@ class SecurityTestRunner:
             with open(config_path) as f:
                 config = json.load(f)
             port = config.get("server", {}).get("port", 8000)
-            
             # Kill any existing process on this port
             self.kill_process_on_port(port)
-            
             # Start server
             cmd = [
                 sys.executable, "-m", "mcp_proxy_adapter.main",
                 "--config", str(config_path)
             ]
-            
             # For mTLS, start from examples directory
             if config_name == "mtls":
                 cwd = self.project_root / "mcp_proxy_adapter" / "examples"
             else:
                 cwd = self.project_root
-            
             print(f"🚀 Starting {config_name} on port {port}...")
             process = subprocess.Popen(
                 cmd,
@@ -94,10 +79,8 @@ class SecurityTestRunner:
                 stderr=subprocess.PIPE,
                 text=True
             )
-            
             # Wait a bit for server to start
             time.sleep(3)
-            
             # Check if process is still running
             if process.poll() is None:
                 print(f"✅ {config_name} started successfully on port {port}")
@@ -108,11 +91,9 @@ class SecurityTestRunner:
                 print(f"STDOUT: {stdout}")
                 print(f"STDERR: {stderr}")
                 return None
-                
         except Exception as e:
             print(f"❌ Error starting {config_name}: {e}")
             return None
-    
     def stop_server(self, config_name: str, process: subprocess.Popen):
         """Stop server gracefully."""
         try:
@@ -126,11 +107,9 @@ class SecurityTestRunner:
             process.wait()
         except Exception as e:
             print(f"❌ Error stopping {config_name}: {e}")
-    
     async def test_server(self, config_name: str, config_path: Path) -> List[TestResult]:
         """Test a single server configuration."""
         results = []
-        
         # Start server
         process = self.start_server(config_name, config_path)
         if not process:
@@ -141,23 +120,19 @@ class SecurityTestRunner:
                 success=False,
                 error_message="Server failed to start"
             )]
-        
         try:
             # Get config for client setup
             with open(config_path) as f:
                 config = json.load(f)
-            
             port = config.get("server", {}).get("port", 8000)
             auth_enabled = config.get("security", {}).get("auth", {}).get("enabled", False)
             auth_methods = config.get("security", {}).get("auth", {}).get("methods", [])
-            
             # Create test client with correct protocol
             protocol = "https" if config.get("ssl", {}).get("enabled", False) else "http"
             client = SecurityTestClient(base_url=f"{protocol}://localhost:{port}")
             client.auth_enabled = auth_enabled
             client.auth_methods = auth_methods
             client.api_keys = config.get("security", {}).get("auth", {}).get("api_keys", {})
-            
             # For mTLS, override SSL context creation and change working directory
             if config_name == "mtls":
                 client.create_ssl_context = client.create_ssl_context_for_mtls
@@ -166,34 +141,27 @@ class SecurityTestRunner:
                 # Change to examples directory for mTLS tests
                 import os
                 os.chdir(self.project_root / "mcp_proxy_adapter" / "examples")
-            
             # Run tests
             async with client:
                 # Test 1: Health check
                 result = await client.test_health()
                 results.append(result)
-                
                 # Test 2: Command execution
                 result = await client.test_command_execution()
                 results.append(result)
-                
                 # Test 3: Authentication (if enabled)
                 if auth_enabled:
                     result = await client.test_authentication()
                     results.append(result)
-                    
                     # Test 4: Negative authentication
                     result = await client.test_negative_authentication()
                     results.append(result)
-                    
                     # Test 5: Role-based access
                     result = await client.test_role_based_access(client.base_url, "api_key")
                     results.append(result)
-                    
                     # Test 6: Role permissions
                     result = await client.test_role_permissions(client.base_url, "api_key")
                     results.append(result)
-                    
                     # Test 7: Multiple roles test
                     result = await client.test_multiple_roles(client.base_url, "api_key")
                     results.append(result)
@@ -201,11 +169,9 @@ class SecurityTestRunner:
                     # Test 3: No authentication required
                     result = await client.test_no_auth_required()
                     results.append(result)
-                    
                     # Test 4: Negative auth (should fail)
                     result = await client.test_negative_authentication()
                     results.append(result)
-        
         except Exception as e:
             results.append(TestResult(
                 test_name=f"{config_name}_client_error",
@@ -214,18 +180,14 @@ class SecurityTestRunner:
                 success=False,
                 error_message=str(e)
             ))
-        
         finally:
             # Stop server
             self.stop_server(config_name, process)
-        
         return results
-    
     async def run_all_tests(self):
         """Run all security tests."""
         print("🔒 Starting Security Testing Suite")
         print("=" * 50)
-        
         # Test configurations
         configs = [
             ("basic_http", "config_basic_http.json"),
@@ -234,22 +196,16 @@ class SecurityTestRunner:
             ("https_token", "config_https_token.json"),
             ("mtls", "config_mtls.json")
         ]
-        
         total_tests = 0
         passed_tests = 0
-        
         for config_name, config_file in configs:
             config_path = self.configs_dir / config_file
-            
             if not config_path.exists():
                 print(f"❌ Configuration not found: {config_path}")
                 continue
-            
             print(f"\n📋 Testing {config_name.upper()} configuration")
             print("-" * 30)
-            
             results = await self.test_server(config_name, config_path)
-            
             for result in results:
                 total_tests += 1
                 if result.success:
@@ -257,9 +213,7 @@ class SecurityTestRunner:
                     print(f"✅ {result.test_name}: PASS")
                 else:
                     print(f"❌ {result.test_name}: FAIL - {result.error_message}")
-            
             self.test_results.extend(results)
-        
         # Print summary
         print("\n" + "=" * 50)
         print("📊 TEST SUMMARY")
@@ -268,7 +222,6 @@ class SecurityTestRunner:
         print(f"Passed: {passed_tests}")
         print(f"Failed: {total_tests - passed_tests}")
         print(f"Success rate: {(passed_tests/total_tests*100):.1f}%" if total_tests > 0 else "N/A")
-        
         # Detailed results
         print("\n📋 DETAILED RESULTS")
         print("-" * 30)
@@ -277,14 +230,10 @@ class SecurityTestRunner:
             print(f"{status} {result.test_name}")
             if not result.success and result.error_message:
                 print(f"   Error: {result.error_message}")
-        
         return passed_tests == total_tests
-
-
 async def main():
     """Main function."""
     runner = SecurityTestRunner()
-    
     try:
         success = await runner.run_all_tests()
         sys.exit(0 if success else 1)
@@ -294,7 +243,5 @@ async def main():
     except Exception as e:
         print(f"\n❌ Testing failed: {e}")
         sys.exit(1)
-
-
 if __name__ == "__main__":
     asyncio.run(main())