aiptx 2.0.7__py3-none-any.whl

aipt_v2/docker/manager.py

@@ -0,0 +1,222 @@
+"""
+AIPT Container Manager - Manages multiple sandbox configurations
+
+Provides pre-configured sandboxes for different use cases:
+- Recon tools (nmap, masscan)
+- Web tools (nuclei, httpx)
+- Exploitation (metasploit)
+- Post-exploitation (linpeas)
+"""
+from __future__ import annotations
+
+from typing import Optional, Dict, List
+from dataclasses import dataclass, field
+from enum import Enum
+
+from .sandbox import DockerSandbox, SandboxConfig, SandboxResult
+
+
+class SecurityImage(str, Enum):
+    """Pre-defined security tool images"""
+    KALI = "kalilinux/kali-rolling"
+    NMAP = "instrumentisto/nmap"
+    NUCLEI = "projectdiscovery/nuclei"
+    HTTPX = "projectdiscovery/httpx"
+    SUBFINDER = "projectdiscovery/subfinder"
+    MASSCAN = "adarnimrod/masscan"
+    METASPLOIT = "metasploitframework/metasploit-framework"
+    SQLMAP = "paoloo/sqlmap"
+    NIKTO = "sullo/nikto"
+
+
+@dataclass
+class PhaseConfig:
+    """Configuration for a pentest phase"""
+    memory_limit: str = "1g"
+    cpu_limit: float = 2.0
+    timeout: int = 600
+    network_mode: str = "bridge"
+    capabilities: List[str] = field(default_factory=list)
+
+
+class ContainerManager:
+    """
+    Manages multiple sandbox configurations for different use cases.
+
+    Provides pre-configured sandboxes for:
+    - Recon tools (nmap, masscan)
+    - Web tools (nuclei, httpx)
+    - Exploitation (metasploit)
+    - Post-exploitation (linpeas)
+    """
+
+    # Tool to image mapping
+    TOOL_IMAGES: Dict[str, SecurityImage] = {
+        "nmap": SecurityImage.NMAP,
+        "masscan": SecurityImage.MASSCAN,
+        "nuclei": SecurityImage.NUCLEI,
+        "httpx": SecurityImage.HTTPX,
+        "subfinder": SecurityImage.SUBFINDER,
+        "metasploit": SecurityImage.METASPLOIT,
+        "msfconsole": SecurityImage.METASPLOIT,
+        "sqlmap": SecurityImage.SQLMAP,
+        "nikto": SecurityImage.NIKTO,
+    }
+
+    # Phase configurations
+    PHASE_CONFIGS: Dict[str, PhaseConfig] = {
+        "recon": PhaseConfig(
+            memory_limit="1g",
+            cpu_limit=2.0,
+            timeout=600,
+            network_mode="bridge",
+            capabilities=["NET_RAW"],
+        ),
+        "enum": PhaseConfig(
+            memory_limit="2g",
+            cpu_limit=2.0,
+            timeout=900,
+            network_mode="bridge",
+        ),
+        "exploit": PhaseConfig(
+            memory_limit="4g",
+            cpu_limit=4.0,
+            timeout=1800,
+            network_mode="host",  # May need host network for reverse shells
+        ),
+        "post": PhaseConfig(
+            memory_limit="2g",
+            cpu_limit=2.0,
+            timeout=600,
+            network_mode="none",  # Isolated for safety
+        ),
+    }
+
+    def __init__(self, default_image: str = SecurityImage.KALI.value):
+        self.default_image = default_image
+        self.sandboxes: Dict[str, DockerSandbox] = {}
+        self._active_containers: List[str] = []
+
+    def get_sandbox(self, phase: str = "recon") -> DockerSandbox:
+        """Get or create sandbox for phase"""
+        if phase not in self.sandboxes:
+            phase_config = self.PHASE_CONFIGS.get(phase, PhaseConfig())
+
+            config = SandboxConfig(
+                image=self.default_image,
+                memory_limit=phase_config.memory_limit,
+                cpu_limit=phase_config.cpu_limit,
+                timeout=phase_config.timeout,
+                network_mode=phase_config.network_mode,
+                capabilities=phase_config.capabilities,
+            )
+
+            self.sandboxes[phase] = DockerSandbox(config)
+
+        return self.sandboxes[phase]
+
+    def get_image_for_tool(self, tool_name: str) -> str:
+        """Get appropriate Docker image for tool"""
+        tool_lower = tool_name.lower()
+
+        # Check direct mapping
+        if tool_lower in self.TOOL_IMAGES:
+            return self.TOOL_IMAGES[tool_lower].value
+
+        # Check partial match
+        for key, image in self.TOOL_IMAGES.items():
+            if key in tool_lower:
+                return image.value
+
+        # Default to Kali for unknown tools
+        return self.default_image
+
+    def execute_tool(
+        self,
+        tool_name: str,
+        command: str,
+        phase: str = "recon",
+        **kwargs,
+    ) -> SandboxResult:
+        """
+        Execute a security tool in appropriate sandbox.
+
+        Args:
+            tool_name: Name of the tool
+            command: Full command to execute
+            phase: Pentest phase (recon, enum, exploit, post)
+            **kwargs: Additional sandbox options
+
+        Returns:
+            SandboxResult
+        """
+        sandbox = self.get_sandbox(phase)
+        image = self.get_image_for_tool(tool_name)
+        return sandbox.execute(command, image=image, **kwargs)
+
+    def execute_with_callback(
+        self,
+        tool_name: str,
+        command: str,
+        callback,
+        phase: str = "recon",
+    ) -> SandboxResult:
+        """Execute tool with streaming output callback"""
+        sandbox = self.get_sandbox(phase)
+        image = self.get_image_for_tool(tool_name)
+        return sandbox.execute_streaming(command, callback, image=image)
+
+    def is_available(self) -> bool:
+        """Check if Docker is available"""
+        sandbox = self.get_sandbox("recon")
+        return sandbox.is_available()
+
+    def pull_security_images(self, images: Optional[List[SecurityImage]] = None) -> Dict[str, bool]:
+        """
+        Pull security tool images.
+
+        Args:
+            images: List of images to pull (pulls all if None)
+
+        Returns:
+            Dict mapping image name to success status
+        """
+        images_to_pull = images or list(SecurityImage)
+        results = {}
+
+        sandbox = DockerSandbox()
+
+        for image in images_to_pull:
+            image_name = image.value if isinstance(image, SecurityImage) else image
+            results[image_name] = sandbox.pull_image(image_name)
+
+        return results
+
+    def list_pulled_images(self) -> List[str]:
+        """List pulled security images"""
+        sandbox = DockerSandbox()
+        pulled = []
+
+        for image in SecurityImage:
+            if sandbox.image_exists(image.value):
+                pulled.append(image.value)
+
+        return pulled
+
+    def cleanup(self) -> None:
+        """Cleanup all sandboxes and containers"""
+        for sandbox in self.sandboxes.values():
+            sandbox.cleanup_containers()
+        self.sandboxes.clear()
+
+
+# Singleton instance
+_container_manager: Optional[ContainerManager] = None
+
+
+def get_container_manager() -> ContainerManager:
+    """Get singleton container manager"""
+    global _container_manager
+    if _container_manager is None:
+        _container_manager = ContainerManager()
+    return _container_manager

aipt_v2/docker/sandbox.py

@@ -0,0 +1,371 @@
+"""
+AIPT Docker Sandbox - Secure command execution in containers
+
+Provides isolated execution environment for security tools:
+- Network-isolated containers
+- Resource limits (CPU, memory)
+- Timeout enforcement
+- Output capture and streaming
+"""
+from __future__ import annotations
+
+import subprocess
+import json
+import os
+import time
+import asyncio
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any, Callable
+from pathlib import Path
+
+
+@dataclass
+class SandboxResult:
+    """Result from sandbox execution"""
+    output: str
+    return_code: int
+    duration: float
+    container_id: Optional[str] = None
+    error: Optional[str] = None
+    truncated: bool = False
+
+
+@dataclass
+class SandboxConfig:
+    """Docker sandbox configuration"""
+    image: str = "kalilinux/kali-rolling"
+    memory_limit: str = "512m"
+    cpu_limit: float = 1.0
+    network_mode: str = "bridge"  # bridge, host, none
+    timeout: int = 300
+    working_dir: str = "/workspace"
+    environment: Dict[str, str] = field(default_factory=dict)
+    volumes: Dict[str, str] = field(default_factory=dict)
+    capabilities: List[str] = field(default_factory=list)  # NET_RAW, etc.
+    privileged: bool = False
+    remove_after: bool = True
+
+
+class DockerSandbox:
+    """
+    Docker-based sandbox for secure command execution.
+
+    Provides isolated execution environment with:
+    - Resource limits (memory, CPU)
+    - Network isolation options
+    - Timeout enforcement
+    - Output streaming
+    """
+
+    def __init__(
+        self,
+        config: Optional[SandboxConfig] = None,
+        auto_pull: bool = True,
+    ):
+        self.config = config or SandboxConfig()
+        self.auto_pull = auto_pull
+        self._docker_available: Optional[bool] = None
+
+    def is_available(self) -> bool:
+        """Check if Docker is available"""
+        if self._docker_available is not None:
+            return self._docker_available
+
+        try:
+            result = subprocess.run(
+                ["docker", "info"],
+                capture_output=True,
+                timeout=10,
+            )
+            self._docker_available = result.returncode == 0
+        except (FileNotFoundError, subprocess.TimeoutExpired, PermissionError, OSError):
+            self._docker_available = False
+
+        return self._docker_available
+
+    def image_exists(self, image: str) -> bool:
+        """Check if Docker image exists locally"""
+        try:
+            result = subprocess.run(
+                ["docker", "images", "-q", image],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            return bool(result.stdout.strip())
+        except Exception:
+            return False
+
+    def pull_image(self, image: Optional[str] = None) -> bool:
+        """Pull Docker image"""
+        image = image or self.config.image
+        try:
+            result = subprocess.run(
+                ["docker", "pull", image],
+                capture_output=True,
+                text=True,
+                timeout=600,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def execute(
+        self,
+        command: str,
+        timeout: Optional[int] = None,
+        image: Optional[str] = None,
+        network: Optional[str] = None,
+        env: Optional[Dict[str, str]] = None,
+        volumes: Optional[Dict[str, str]] = None,
+    ) -> SandboxResult:
+        """
+        Execute command in Docker container.
+
+        Args:
+            command: Command to execute
+            timeout: Execution timeout in seconds
+            image: Docker image (overrides config)
+            network: Network mode (overrides config)
+            env: Additional environment variables
+            volumes: Additional volume mounts
+
+        Returns:
+            SandboxResult with output and status
+        """
+        start_time = time.time()
+
+        if not self.is_available():
+            return SandboxResult(
+                output="",
+                return_code=-1,
+                duration=0,
+                error="Docker is not available",
+            )
+
+        image = image or self.config.image
+
+        if self.auto_pull and not self.image_exists(image):
+            if not self.pull_image(image):
+                return SandboxResult(
+                    output="",
+                    return_code=-1,
+                    duration=0,
+                    error=f"Failed to pull image: {image}",
+                )
+
+        docker_cmd = self._build_docker_command(
+            command=command,
+            image=image,
+            network=network,
+            env=env,
+            volumes=volumes,
+        )
+
+        timeout = timeout or self.config.timeout
+
+        try:
+            result = subprocess.run(
+                docker_cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+
+            duration = time.time() - start_time
+            output = result.stdout
+
+            if result.stderr:
+                output = f"{output}\n[STDERR]\n{result.stderr}"
+
+            truncated = False
+            if len(output) > 100000:
+                output = output[:100000] + "\n... [OUTPUT TRUNCATED]"
+                truncated = True
+
+            return SandboxResult(
+                output=output,
+                return_code=result.returncode,
+                duration=duration,
+                truncated=truncated,
+            )
+
+        except subprocess.TimeoutExpired:
+            return SandboxResult(
+                output="",
+                return_code=-1,
+                duration=timeout,
+                error=f"Command timed out after {timeout}s",
+            )
+        except Exception as e:
+            return SandboxResult(
+                output="",
+                return_code=-1,
+                duration=time.time() - start_time,
+                error=str(e),
+            )
+
+    async def execute_async(
+        self,
+        command: str,
+        timeout: Optional[int] = None,
+        image: Optional[str] = None,
+        **kwargs
+    ) -> SandboxResult:
+        """Async version of execute"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.execute(command, timeout, image, **kwargs)
+        )
+
+    def execute_streaming(
+        self,
+        command: str,
+        callback: Callable[[str], None],
+        timeout: Optional[int] = None,
+        image: Optional[str] = None,
+    ) -> SandboxResult:
+        """
+        Execute command with streaming output.
+
+        Args:
+            command: Command to execute
+            callback: Function to call with each output line
+            timeout: Execution timeout
+            image: Docker image
+
+        Returns:
+            SandboxResult
+        """
+        start_time = time.time()
+        image = image or self.config.image
+        timeout = timeout or self.config.timeout
+
+        if not self.is_available():
+            return SandboxResult(
+                output="",
+                return_code=-1,
+                duration=0,
+                error="Docker is not available",
+            )
+
+        docker_cmd = self._build_docker_command(command, image)
+
+        try:
+            process = subprocess.Popen(
+                docker_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+
+            output_lines = []
+
+            while True:
+                if time.time() - start_time > timeout:
+                    process.kill()
+                    return SandboxResult(
+                        output="\n".join(output_lines),
+                        return_code=-1,
+                        duration=timeout,
+                        error=f"Command timed out after {timeout}s",
+                    )
+
+                line = process.stdout.readline()
+                if not line and process.poll() is not None:
+                    break
+
+                if line:
+                    line = line.rstrip()
+                    output_lines.append(line)
+                    callback(line)
+
+            return SandboxResult(
+                output="\n".join(output_lines),
+                return_code=process.returncode,
+                duration=time.time() - start_time,
+            )
+
+        except Exception as e:
+            return SandboxResult(
+                output="",
+                return_code=-1,
+                duration=time.time() - start_time,
+                error=str(e),
+            )
+
+    def _build_docker_command(
+        self,
+        command: str,
+        image: str,
+        network: Optional[str] = None,
+        env: Optional[Dict[str, str]] = None,
+        volumes: Optional[Dict[str, str]] = None,
+    ) -> List[str]:
+        """Build docker run command"""
+        docker_cmd = [
+            "docker", "run",
+            "--memory", self.config.memory_limit,
+            "--cpus", str(self.config.cpu_limit),
+            "--network", network or self.config.network_mode,
+            "-w", self.config.working_dir,
+        ]
+
+        if self.config.remove_after:
+            docker_cmd.append("--rm")
+
+        if self.config.privileged:
+            docker_cmd.append("--privileged")
+
+        for cap in self.config.capabilities:
+            docker_cmd.extend(["--cap-add", cap])
+
+        all_env = {**self.config.environment, **(env or {})}
+        for key, value in all_env.items():
+            docker_cmd.extend(["-e", f"{key}={value}"])
+
+        all_volumes = {**self.config.volumes, **(volumes or {})}
+        for host_path, container_path in all_volumes.items():
+            docker_cmd.extend(["-v", f"{host_path}:{container_path}"])
+
+        docker_cmd.extend([image, "sh", "-c", command])
+
+        return docker_cmd
+
+    def list_containers(self, all_containers: bool = False) -> List[Dict[str, str]]:
+        """List running containers"""
+        cmd = ["docker", "ps", "--format", "{{json .}}"]
+        if all_containers:
+            cmd.append("-a")
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            containers = []
+            for line in result.stdout.strip().split("\n"):
+                if line:
+                    containers.append(json.loads(line))
+            return containers
+        except Exception:
+            return []
+
+    def stop_container(self, container_id: str, force: bool = False) -> bool:
+        """Stop a running container"""
+        cmd = ["docker", "kill" if force else "stop", container_id]
+        try:
+            result = subprocess.run(cmd, capture_output=True, timeout=30)
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def cleanup_containers(self, image_filter: Optional[str] = None) -> int:
+        """Remove stopped containers"""
+        cmd = ["docker", "container", "prune", "-f"]
+        if image_filter:
+            cmd.extend(["--filter", f"ancestor={image_filter}"])
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            return result.returncode
+        except Exception:
+            return -1

aipt_v2/evasion/__init__.py

@@ -0,0 +1,58 @@
+"""
+AIPT Evasion Module - WAF Bypass and Request Obfuscation
+
+Provides evasion techniques for authorized penetration testing:
+- WAF bypass payload generation
+- Request obfuscation and encoding
+- User-Agent rotation
+- TLS fingerprint randomization
+
+WARNING: Use only for authorized security testing!
+
+Usage:
+    from aipt_v2.evasion import WAFBypass, RequestObfuscator, UARotator
+
+    bypass = WAFBypass()
+    payloads = bypass.generate_sqli_bypasses("' OR '1'='1")
+"""
+
+from aipt_v2.evasion.waf_bypass import (
+    WAFBypass,
+    BypassPayload,
+    generate_bypass_payloads,
+)
+
+from aipt_v2.evasion.request_obfuscator import (
+    RequestObfuscator,
+    ObfuscationConfig,
+    obfuscate_request,
+)
+
+from aipt_v2.evasion.ua_rotator import (
+    UARotator,
+    UserAgent,
+    get_random_ua,
+)
+
+from aipt_v2.evasion.tls_fingerprint import (
+    TLSFingerprint,
+    randomize_tls,
+)
+
+__all__ = [
+    # WAF Bypass
+    "WAFBypass",
+    "BypassPayload",
+    "generate_bypass_payloads",
+    # Obfuscation
+    "RequestObfuscator",
+    "ObfuscationConfig",
+    "obfuscate_request",
+    # User-Agent
+    "UARotator",
+    "UserAgent",
+    "get_random_ua",
+    # TLS
+    "TLSFingerprint",
+    "randomize_tls",
+]