zen-ai-pentest 2.0.0__py3-none-any.whl

ci_cd/__init__.py

@@ -0,0 +1,2 @@
+"""CI/CD Integration Module for Zen AI Pentest"""
+__version__ = "2.0.0"

core/__init__.py

@@ -0,0 +1,17 @@
+"""
+Zen AI Pentest - Multi-LLM Penetration Testing Intelligence System
+Author: SHAdd0WTAka
+Version: 1.0.0
+"""
+
+# AsyncIO Fix für Windows Python 3.13+ (Issue #10)
+# Muss vor allen anderen Imports geladen werden
+try:
+    from .asyncio_fix import patch_asyncio_for_windows, safe_asyncio_run
+    patch_asyncio_for_windows()
+except ImportError:
+    pass  # Not critical
+
+__version__ = "1.0.0"
+__author__ = "SHAdd0WTAka"
+__description__ = "Multi-LLM Penetration Testing Intelligence System"

core/async_pool.py

@@ -0,0 +1,282 @@
+"""
+Async Connection Pooling and Resource Management
+Optimized HTTP client with connection reuse
+"""
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any, AsyncGenerator, Dict, Optional
+
+import aiohttp
+
+from core.rate_limiter import RateLimitedClient, TokenBucket
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PoolConfig:
+    """Connection pool configuration"""
+
+    limit: int = 100
+    limit_per_host: int = 10
+    ttl_dns_cache: int = 300
+    use_dns_cache: bool = True
+    timeout: aiohttp.ClientTimeout = None
+
+    def __post_init__(self):
+        if self.timeout is None:
+            self.timeout = aiohttp.ClientTimeout(total=60, connect=10)
+
+
+class ConnectionPool:
+    """
+    Managed HTTP connection pool with rate limiting.
+    Implements proper connection reuse and cleanup.
+    """
+
+    def __init__(self, config: PoolConfig = None):
+        self.config = config or PoolConfig()
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._connector: Optional[aiohttp.TCPConnector] = None
+        self._semaphore: Optional[asyncio.Semaphore] = None
+        self._rate_limiter: Optional[TokenBucket] = None
+        self._lock = asyncio.Lock()
+        self._closed = True
+
+    async def _create_session(self) -> aiohttp.ClientSession:
+        """Create HTTP session with optimized connector"""
+        self._connector = aiohttp.TCPConnector(
+            limit=self.config.limit,
+            limit_per_host=self.config.limit_per_host,
+            ttl_dns_cache=self.config.ttl_dns_cache,
+            use_dns_cache=self.config.use_dns_cache,
+            enable_cleanup_closed=True,
+            force_close=False,
+        )
+
+        # Global semaphore for concurrent request limiting
+        self._semaphore = asyncio.Semaphore(self.config.limit)
+
+        self._session = aiohttp.ClientSession(
+            connector=self._connector,
+            timeout=self.config.timeout,
+            headers={
+                "User-Agent": "Zen-AI-Pentest/1.0 (Security Scanner)",
+                "Accept": "application/json, text/plain, */*",
+                "Accept-Encoding": "gzip, deflate",
+            },
+        )
+
+        self._closed = False
+        return self._session
+
+    async def get_session(self) -> aiohttp.ClientSession:
+        """Get or create session"""
+        if self._session is None or self._session.closed:
+            async with self._lock:
+                if self._session is None or self._session.closed:
+                    await self._create_session()
+        return self._session
+
+    @asynccontextmanager
+    async def request(
+        self, method: str, url: str, rate_limit: float = None, **kwargs
+    ) -> AsyncGenerator[aiohttp.ClientResponse, None]:
+        """
+        Make rate-limited HTTP request with connection pooling.
+
+        Args:
+            method: HTTP method
+            url: Request URL
+            rate_limit: Max requests per second (None = unlimited)
+            **kwargs: Additional aiohttp request arguments
+        """
+        session = await self.get_session()
+
+        # Apply rate limiting if configured
+        if rate_limit and self._rate_limiter is None:
+            self._rate_limiter = TokenBucket(rate=rate_limit, capacity=5)
+
+        if self._rate_limiter:
+            await self._rate_limiter.wait()
+
+        # Limit concurrent requests
+        async with self._semaphore:
+            try:
+                async with session.request(method, url, **kwargs) as response:
+                    yield response
+            except aiohttp.ClientError as e:
+                logger.error(f"HTTP error {method} {url}: {e}")
+                raise
+
+    async def get(self, url: str, **kwargs) -> aiohttp.ClientResponse:
+        """Simple GET request"""
+        async with self.request("GET", url, **kwargs) as response:
+            return await response.text()
+
+    async def post(self, url: str, **kwargs) -> aiohttp.ClientResponse:
+        """Simple POST request"""
+        async with self.request("POST", url, **kwargs) as response:
+            return await response.text()
+
+    async def json_get(self, url: str, **kwargs) -> Dict[str, Any]:
+        """GET request with JSON parsing"""
+        async with self.request("GET", url, **kwargs) as response:
+            return await response.json()
+
+    async def close(self):
+        """Close all connections properly"""
+        async with self._lock:
+            if self._session and not self._session.closed:
+                await self._session.close()
+            if self._connector and not self._connector.closed:
+                await self._connector.close()
+            self._closed = True
+            logger.debug("Connection pool closed")
+
+    async def __aenter__(self):
+        await self.get_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+
+class SmartHTTPClient(RateLimitedClient):
+    """
+    HTTP client with circuit breaker, retries, and connection pooling.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        pool_config: PoolConfig = None,
+        rate_config: Any = None,
+        circuit_config: Any = None,
+    ):
+        super().__init__(name, rate_config, circuit_config)
+        self.pool = ConnectionPool(pool_config)
+
+    async def _do_request(self, method: str, url: str, **kwargs) -> Dict[str, Any]:
+        """Execute HTTP request with full error handling"""
+        async with self.pool.request(method, url, **kwargs) as response:
+            content_type = response.headers.get("Content-Type", "")
+
+            if "application/json" in content_type:
+                data = await response.json()
+            else:
+                data = await response.text()
+
+            return {
+                "status": response.status,
+                "headers": dict(response.headers),
+                "data": data,
+                "url": str(response.url),
+            }
+
+    async def close(self):
+        await self.pool.close()
+        await super().close()
+
+
+class ParallelProcessor:
+    """
+    Execute tasks in parallel with semaphore-controlled concurrency.
+    Prevents resource exhaustion during bulk operations.
+    """
+
+    def __init__(self, max_concurrent: int = 10):
+        self.max_concurrent = max_concurrent
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def run(self, tasks: list, return_exceptions: bool = True) -> list:
+        """
+        Run tasks with controlled concurrency.
+
+        Args:
+            tasks: List of coroutines
+            return_exceptions: If True, exceptions are returned instead of raised
+        """
+
+        async def bounded_task(task):
+            async with self._semaphore:
+                return await task
+
+        # Create bounded tasks
+        bounded = [bounded_task(t) for t in tasks]
+
+        # Execute with exception handling
+        return await asyncio.gather(*bounded, return_exceptions=return_exceptions)
+
+    async def map(self, func: callable, items: list, *args, **kwargs) -> list:
+        """
+        Map function over items with controlled concurrency.
+
+        Args:
+            func: Async function to apply
+            items: List of items to process
+            *args, **kwargs: Additional arguments for func
+        """
+        tasks = [func(item, *args, **kwargs) for item in items]
+        return await self.run(tasks)
+
+
+# Global pool instance
+_global_pool: Optional[ConnectionPool] = None
+
+
+async def get_global_pool() -> ConnectionPool:
+    """Get global connection pool"""
+    global _global_pool
+    if _global_pool is None:
+        _global_pool = ConnectionPool()
+    return _global_pool
+
+
+async def close_global_pool():
+    """Close global connection pool"""
+    global _global_pool
+    if _global_pool:
+        await _global_pool.close()
+        _global_pool = None
+
+
+# Example usage patterns
+async def example_bulk_requests(urls: list[str]):
+    """Example: Bulk HTTP requests with connection pooling"""
+    pool = ConnectionPool(PoolConfig(limit_per_host=5))
+
+    processor = ParallelProcessor(max_concurrent=10)
+
+    async def fetch(url):
+        async with pool.request("GET", url) as response:
+            return await response.text()
+
+    results = await processor.map(fetch, urls)
+    await pool.close()
+    return results
+
+
+async def example_with_circuit_breaker():
+    """Example: HTTP client with circuit breaker"""
+    from core.rate_limiter import CircuitBreakerConfig, RateLimitConfig
+
+    client = SmartHTTPClient(
+        name="api-client",
+        pool_config=PoolConfig(limit_per_host=5),
+        rate_config=RateLimitConfig(requests_per_second=2.0, burst_size=5),
+        circuit_config=CircuitBreakerConfig(failure_threshold=3, recovery_timeout=30.0),
+    )
+
+    try:
+        result = await client.request("GET", "https://api.example.com/data")
+        print(result)
+    finally:
+        await client.close()

core/asyncio_fix.py

@@ -0,0 +1,222 @@
+"""
+Python 3.13 Windows AsyncIO Fix
+Issue #10: Python 3.13 Windows AsyncIO Fix permanent lösen
+
+Fix für bekannte Probleme:
+- ProactorEventLoop issues on Windows
+- asyncio.run() hanging
+- Task cancellation problems
+- Event loop policy conflicts
+"""
+
+import sys
+import asyncio
+import platform
+import warnings
+from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def is_windows() -> bool:
+    """Check if running on Windows"""
+    return platform.system() == "Windows"
+
+
+def is_python_313_or_higher() -> bool:
+    """Check if Python 3.13 or higher"""
+    return sys.version_info >= (3, 13)
+
+
+def apply_windows_asyncio_fix():
+    """
+    Wendet Windows-spezifische AsyncIO Fixes an
+    
+    Muss vor der ersten asyncio Nutzung aufgerufen werden!
+    """
+    if not is_windows():
+        return
+    
+    logger.info("Applying Windows AsyncIO fixes...")
+    
+    # Fix 1: SelectorEventLoop für Windows (statt Proactor)
+    # Python 3.13 hat Proactor-Probleme auf Windows
+    try:
+        if is_python_313_or_higher():
+            # Nutze SelectorEventLoop als Workaround
+            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+            logger.info("Set WindowsSelectorEventLoopPolicy")
+    except Exception as e:
+        logger.warning(f"Could not set SelectorEventLoopPolicy: {e}")
+    
+    # Fix 2: Erhöhe Stack-Size für recursive coroutines
+    try:
+        import threading
+        threading.stack_size(2 * 1024 * 1024)  # 2MB stack
+    except Exception:
+        pass  # Nicht kritisch
+    
+    logger.info("Windows AsyncIO fixes applied")
+
+
+class SafeAsyncioRunner:
+    """
+    Sicherer AsyncIO Runner für Windows Python 3.13+
+    
+    Workaround für hängende asyncio.run() Aufrufe
+    """
+    
+    def __init__(self, timeout: Optional[float] = None):
+        self.timeout = timeout
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+    
+    def run(self, coro):
+        """
+        Führt eine Coroutine sicher aus
+        
+        Args:
+            coro: Die auszuführende Coroutine
+            
+        Returns:
+            Das Ergebnis der Coroutine
+        """
+        # Fix anwenden falls nötig
+        if is_windows() and is_python_313_or_higher():
+            return self._run_with_fix(coro)
+        else:
+            return asyncio.run(coro)
+    
+    def _run_with_fix(self, coro):
+        """Interne Run-Methode mit Windows Fixes"""
+        # Erstelle neuen Loop statt asyncio.run()
+        loop = asyncio.new_event_loop()
+        
+        try:
+            asyncio.set_event_loop(loop)
+            
+            # Setze exception handler
+            def exception_handler(loop, context):
+                logger.error(f"AsyncIO Exception: {context}")
+            
+            loop.set_exception_handler(exception_handler)
+            
+            # Führe coroutine aus
+            if self.timeout:
+                return loop.run_until_complete(
+                    asyncio.wait_for(coro, timeout=self.timeout)
+                )
+            else:
+                return loop.run_until_complete(coro)
+                
+        finally:
+            # Cleanup
+            try:
+                # Cancel pending tasks
+                pending = asyncio.all_tasks(loop)
+                if pending:
+                    for task in pending:
+                        task.cancel()
+                    
+                    # Wait for cancellation
+                    loop.run_until_complete(
+                        asyncio.gather(*pending, return_exceptions=True)
+                    )
+                
+                loop.run_until_complete(loop.shutdown_asyncgens())
+                loop.close()
+                
+            except Exception as e:
+                logger.warning(f"Error during loop cleanup: {e}")
+            
+            asyncio.set_event_loop(None)
+
+
+def safe_asyncio_run(coro, timeout: Optional[float] = None):
+    """
+    Sicherer Ersatz für asyncio.run()
+    
+    Usage:
+        result = safe_asyncio_run(my_coroutine())
+    """
+    runner = SafeAsyncioRunner(timeout=timeout)
+    return runner.run(coro)
+
+
+class AsyncIOContext:
+    """
+    Context Manager für sichere AsyncIO Operationen
+    
+    Usage:
+        async with AsyncIOContext() as ctx:
+            result = await ctx.run_task(my_task())
+    """
+    
+    def __init__(self, timeout: Optional[float] = None):
+        self.timeout = timeout
+        self.loop: Optional[asyncio.AbstractEventLoop] = None
+    
+    async def __aenter__(self):
+        self.loop = asyncio.get_event_loop()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        # Cleanup bei Bedarf
+        pass
+    
+    async def run_task(self, coro):
+        """Führt eine Task mit Timeout aus"""
+        if self.timeout:
+            return await asyncio.wait_for(coro, timeout=self.timeout)
+        return await coro
+
+
+def patch_asyncio_for_windows():
+    """
+    Hauptfunktion zum Patchen von AsyncIO auf Windows
+    
+    Sollte ganz am Anfang der Anwendung aufgerufen werden.
+    """
+    if not is_windows():
+        return
+    
+    # Wende Fixes an
+    apply_windows_asyncio_fix()
+    
+    # Monkey-patch asyncio.run für Python 3.13+
+    if is_python_313_or_higher():
+        import asyncio
+        
+        # Speichere Original
+        _original_run = asyncio.run
+        
+        def _patched_run(coro, *, debug=False):
+            """Gepatchte asyncio.run()"""
+            runner = SafeAsyncioRunner()
+            return runner.run(coro)
+        
+        # Ersetze nur wenn nötig
+        if not getattr(asyncio, '_patched', False):
+            asyncio.run = _patched_run
+            asyncio._patched = True
+            logger.info("asyncio.run patched for Windows compatibility")
+
+
+# Automatisch Fixes anwenden beim Import
+patch_asyncio_for_windows()
+
+
+if __name__ == "__main__":
+    # Test
+    import time
+    
+    async def test_coro():
+        await asyncio.sleep(0.1)
+        return "Success"
+    
+    print(f"Python version: {sys.version}")
+    print(f"Windows: {is_windows()}")
+    print(f"Python >= 3.13: {is_python_313_or_higher()}")
+    
+    result = safe_asyncio_run(test_coro())
+    print(f"Result: {result}")