souleyez 2.43.26__py3-none-any.whl → 2.43.34__py3-none-any.whl

souleyez/handlers/rdp_sec_check_handler.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""
+Handler for rdp-sec-check RDP security scanner.
+"""
+import logging
+import os
+import re
+from typing import Any, Dict, Optional
+
+import click
+
+from souleyez.handlers.base import BaseToolHandler
+
+logger = logging.getLogger(__name__)
+
+STATUS_DONE = "done"
+STATUS_ERROR = "error"
+STATUS_WARNING = "warning"
+STATUS_NO_RESULTS = "no_results"
+
+
+class RdpSecCheckHandler(BaseToolHandler):
+    """Handler for rdp-sec-check RDP security scanner."""
+
+    tool_name = "rdp-sec-check"
+    display_name = "RDP Security Check"
+
+    has_error_handler = True
+    has_warning_handler = True
+    has_no_results_handler = True
+    has_done_handler = True
+
+    # Protocol support patterns
+    PROTOCOL_RDP_PATTERN = r"supports PROTOCOL_RDP:\s*(TRUE|FALSE)"
+    PROTOCOL_SSL_PATTERN = r"supports PROTOCOL_SSL:\s*(TRUE|FALSE)"
+    PROTOCOL_HYBRID_PATTERN = r"supports PROTOCOL_HYBRID:\s*(TRUE|FALSE)"
+
+    # Encryption patterns
+    ENCRYPTION_LEVEL_PATTERN = r"encryption level:\s*(\S+)"
+
+    # Security issue patterns
+    ISSUE_PATTERN = r"has issue\s+(\S+)"
+
+    # NLA patterns
+    NLA_PATTERN = r"(NLA|Network Level Authentication).*?(required|not required|supported|not supported)"
+
+    # Error patterns
+    ERROR_PATTERNS = [
+        (r"connection refused", "Connection refused"),
+        (r"connection timed out", "Connection timed out"),
+        (r"no route to host", "No route to host"),
+        (r"unable to connect", "Unable to connect"),
+        (r"failed to run command", "Tool not installed"),
+    ]
+
+    def parse_job(
+        self,
+        engagement_id: int,
+        log_path: str,
+        job: Dict[str, Any],
+        host_manager: Optional[Any] = None,
+        findings_manager: Optional[Any] = None,
+        credentials_manager: Optional[Any] = None,
+    ) -> Dict[str, Any]:
+        """Parse rdp-sec-check results."""
+        try:
+            target = job.get("target", "")
+
+            if not log_path or not os.path.exists(log_path):
+                return {
+                    "tool": "rdp-sec-check",
+                    "status": STATUS_ERROR,
+                    "error": "Log file not found",
+                }
+
+            with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                log_content = f.read()
+
+            # Check for errors first
+            for pattern, error_msg in self.ERROR_PATTERNS:
+                if re.search(pattern, log_content, re.IGNORECASE):
+                    return {
+                        "tool": "rdp-sec-check",
+                        "status": STATUS_ERROR,
+                        "target": target,
+                        "error": error_msg,
+                    }
+
+            # Parse protocol support
+            protocols = {}
+            rdp_match = re.search(self.PROTOCOL_RDP_PATTERN, log_content, re.IGNORECASE)
+            if rdp_match:
+                protocols["rdp"] = rdp_match.group(1).upper() == "TRUE"
+
+            ssl_match = re.search(self.PROTOCOL_SSL_PATTERN, log_content, re.IGNORECASE)
+            if ssl_match:
+                protocols["tls"] = ssl_match.group(1).upper() == "TRUE"
+
+            hybrid_match = re.search(
+                self.PROTOCOL_HYBRID_PATTERN, log_content, re.IGNORECASE
+            )
+            if hybrid_match:
+                protocols["credssp"] = hybrid_match.group(1).upper() == "TRUE"
+
+            # Parse encryption level
+            encryption_level = None
+            enc_match = re.search(
+                self.ENCRYPTION_LEVEL_PATTERN, log_content, re.IGNORECASE
+            )
+            if enc_match:
+                encryption_level = enc_match.group(1)
+
+            # Parse security issues
+            issues = re.findall(self.ISSUE_PATTERN, log_content, re.IGNORECASE)
+
+            # Check NLA status
+            nla_required = None
+            nla_match = re.search(self.NLA_PATTERN, log_content, re.IGNORECASE)
+            if nla_match:
+                nla_status = nla_match.group(2).lower()
+                nla_required = "required" in nla_status or "supported" in nla_status
+
+            # Determine security findings
+            findings = []
+
+            # Check for NLA issues
+            if "NLA_SUPPORTED_BUT_NOT_MANDATED" in log_content:
+                findings.append(
+                    {
+                        "type": "misconfiguration",
+                        "severity": "medium",
+                        "title": "NLA Supported But Not Mandated",
+                        "description": "NLA is supported but not required - allows downgrade attacks and pre-auth DoS",
+                    }
+                )
+            elif nla_required is False:
+                findings.append(
+                    {
+                        "type": "misconfiguration",
+                        "severity": "high",
+                        "title": "NLA Not Required",
+                        "description": "Network Level Authentication is not required, enabling MITM attacks",
+                    }
+                )
+
+            # RDP without TLS
+            if protocols.get("rdp") and not protocols.get("tls"):
+                findings.append(
+                    {
+                        "type": "misconfiguration",
+                        "severity": "medium",
+                        "title": "RDP Without TLS",
+                        "description": "RDP is supported without TLS encryption",
+                    }
+                )
+
+            # Weak encryption
+            if encryption_level and encryption_level.upper() in [
+                "NONE",
+                "LOW",
+                "CLIENT_COMPATIBLE",
+            ]:
+                findings.append(
+                    {
+                        "type": "misconfiguration",
+                        "severity": "medium",
+                        "title": f"Weak RDP Encryption: {encryption_level}",
+                        "description": f"RDP encryption level is set to {encryption_level}",
+                    }
+                )
+
+            # Check for SSL required (good config)
+            ssl_required = "SSL_REQUIRED_BY_SERVER" in log_content
+
+            # Store findings
+            if findings and findings_manager and host_manager:
+                host = host_manager.get_host_by_ip(engagement_id, target)
+                if host:
+                    for finding in findings:
+                        try:
+                            findings_manager.add_finding(
+                                engagement_id=engagement_id,
+                                host_id=host["id"],
+                                finding_type=finding["type"],
+                                severity=finding["severity"],
+                                title=finding["title"],
+                                description=finding["description"],
+                                tool="rdp-sec-check",
+                                port=3389,
+                                service="rdp",
+                            )
+                        except Exception as e:
+                            logger.warning(f"Failed to store finding: {e}")
+
+            # Determine result
+            if protocols or encryption_level or issues or findings:
+                # Only warn on HIGH severity findings - medium/low are informational
+                has_high_severity = any(f.get("severity") == "high" for f in findings)
+                status = STATUS_WARNING if has_high_severity else STATUS_DONE
+                return {
+                    "tool": "rdp-sec-check",
+                    "status": status,
+                    "target": target,
+                    "protocols": protocols,
+                    "encryption_level": encryption_level,
+                    "nla_required": nla_required,
+                    "ssl_required": "SSL_REQUIRED_BY_SERVER" in log_content,
+                    "issues": issues,
+                    "findings": findings,
+                    "findings_added": len(findings),
+                }
+
+            return {
+                "tool": "rdp-sec-check",
+                "status": STATUS_NO_RESULTS,
+                "target": target,
+            }
+
+        except Exception as e:
+            logger.error(f"Error parsing rdp-sec-check job: {e}")
+            return {"tool": "rdp-sec-check", "status": STATUS_ERROR, "error": str(e)}
+
+    def display_done(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        show_all: bool = False,
+        show_passwords: bool = False,
+    ) -> None:
+        """Display successful rdp-sec-check results."""
+        click.echo()
+        click.echo(click.style("=" * 70, fg="green"))
+        click.echo(click.style("RDP SECURITY CHECK COMPLETE", fg="green", bold=True))
+        click.echo(click.style("=" * 70, fg="green"))
+        click.echo()
+
+        parse_result = job.get("parse_result", {})
+
+        # Protocol support
+        protocols = parse_result.get("protocols", {})
+        if protocols:
+            click.echo(click.style("  PROTOCOL SUPPORT", bold=True, fg="cyan"))
+            for proto, supported in protocols.items():
+                status = (
+                    click.style("YES", fg="green")
+                    if supported
+                    else click.style("NO", fg="red")
+                )
+                click.echo(f"    {proto.upper()}: {status}")
+            click.echo()
+
+        # Encryption
+        enc_level = parse_result.get("encryption_level")
+        if enc_level:
+            color = "green" if enc_level.upper() in ["HIGH", "FIPS"] else "yellow"
+            click.echo(click.style("  ENCRYPTION", bold=True, fg="cyan"))
+            click.echo(f"    Level: {click.style(enc_level, fg=color)}")
+            click.echo()
+
+        # NLA Status
+        nla = parse_result.get("nla_required")
+        if nla is not None:
+            color = "green" if nla else "red"
+            status = "Required" if nla else "NOT Required"
+            click.echo(
+                click.style("  NETWORK LEVEL AUTHENTICATION", bold=True, fg="cyan")
+            )
+            click.echo(f"    Status: {click.style(status, fg=color, bold=not nla)}")
+            click.echo()
+
+        click.echo()
+
+    def display_error(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        show_all: bool = False,
+    ) -> None:
+        """Display rdp-sec-check error."""
+        click.echo()
+        click.echo(click.style("=" * 70, fg="red"))
+        click.echo(click.style("RDP SECURITY CHECK FAILED", fg="red", bold=True))
+        click.echo(click.style("=" * 70, fg="red"))
+        click.echo()
+
+        error = job.get("parse_result", {}).get("error") or job.get("error")
+        if error:
+            click.echo(f"  Error: {error}")
+        else:
+            click.echo("  Check log for details")
+
+        # Installation hint
+        click.echo()
+        click.echo(click.style("  Installation:", dim=True))
+        click.echo("    Kali: sudo apt install rdp-sec-check")
+        click.echo()
+
+    def display_warning(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        show_all: bool = False,
+    ) -> None:
+        """Display rdp-sec-check warning (security issues found)."""
+        click.echo()
+        click.echo(click.style("=" * 70, fg="yellow"))
+        click.echo(click.style("RDP SECURITY ISSUES FOUND", fg="yellow", bold=True))
+        click.echo(click.style("=" * 70, fg="yellow"))
+        click.echo()
+
+        parse_result = job.get("parse_result", {})
+
+        # Show findings
+        findings = parse_result.get("findings", [])
+        if findings:
+            click.echo(click.style("  SECURITY FINDINGS", bold=True, fg="red"))
+            for finding in findings:
+                severity = finding.get("severity", "info").upper()
+                sev_color = (
+                    "red"
+                    if severity == "HIGH"
+                    else "yellow" if severity == "MEDIUM" else "white"
+                )
+                click.echo(
+                    f"    [{click.style(severity, fg=sev_color)}] {finding.get('title')}"
+                )
+                click.echo(f"         {finding.get('description')}")
+            click.echo()
+
+        # Also show protocol info
+        self.display_done(job, log_path, show_all, False)
+
+    def display_no_results(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        show_all: bool = False,
+    ) -> None:
+        """Display rdp-sec-check no results."""
+        click.echo()
+        click.echo(click.style("=" * 70, fg="yellow"))
+        click.echo(
+            click.style("RDP SECURITY CHECK - NO RESULTS", fg="yellow", bold=True)
+        )
+        click.echo(click.style("=" * 70, fg="yellow"))
+        click.echo()
+        click.echo("  Could not retrieve RDP security information.")
+        click.echo()
+        click.echo(click.style("  Possible causes:", dim=True))
+        click.echo("    - RDP service not responding")
+        click.echo("    - Port blocked by firewall")
+        click.echo("    - Non-standard RDP configuration")
+        click.echo()

souleyez/handlers/registry.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+Tool handler registry with auto-discovery.
+
+Provides a central registry for tool handlers that:
+- Auto-discovers handlers via __subclasses__()
+- Provides capability queries (has_warning_handler, etc.)
+- Returns None for unmigrated tools (fallback to legacy code)
+"""
+import logging
+from typing import Dict, List, Optional
+
+from souleyez.handlers.base import BaseToolHandler
+
+logger = logging.getLogger(__name__)
+
+# Singleton registry instance
+_registry: Optional["ToolHandlerRegistry"] = None
+
+
+class ToolHandlerRegistry:
+    """
+    Registry for tool handlers.
+
+    Handlers are discovered automatically when their modules are imported.
+    The registry uses __subclasses__() to find all BaseToolHandler subclasses.
+    """
+
+    def __init__(self):
+        self._handlers: Dict[str, BaseToolHandler] = {}
+        self._discovered = False
+
+    def _discover_handlers(self) -> None:
+        """
+        Auto-discover all BaseToolHandler subclasses.
+
+        This imports handler modules to trigger class definition,
+        then finds all subclasses of BaseToolHandler.
+        """
+        if self._discovered:
+            return
+
+        # Import handler modules here to trigger class registration
+        # As we add handlers, add imports here:
+        try:
+            from souleyez.handlers import msf_exploit_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import msf_exploit_handler: {e}")
+        try:
+            from souleyez.handlers import msf_auxiliary_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import msf_auxiliary_handler: {e}")
+        try:
+            from souleyez.handlers import hydra_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import hydra_handler: {e}")
+        try:
+            from souleyez.handlers import gobuster_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import gobuster_handler: {e}")
+        try:
+            from souleyez.handlers import ffuf_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import ffuf_handler: {e}")
+        try:
+            from souleyez.handlers import nmap_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import nmap_handler: {e}")
+        try:
+            from souleyez.handlers import nuclei_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import nuclei_handler: {e}")
+        try:
+            from souleyez.handlers import theharvester_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import theharvester_handler: {e}")
+        try:
+            from souleyez.handlers import nikto_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import nikto_handler: {e}")
+        try:
+            from souleyez.handlers import wpscan_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import wpscan_handler: {e}")
+        try:
+            from souleyez.handlers import dnsrecon_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import dnsrecon_handler: {e}")
+        try:
+            from souleyez.handlers import sqlmap_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import sqlmap_handler: {e}")
+        try:
+            from souleyez.handlers import smbmap_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import smbmap_handler: {e}")
+        try:
+            from souleyez.handlers import gpp_extract_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import gpp_extract_handler: {e}")
+        try:
+            from souleyez.handlers import enum4linux_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import enum4linux_handler: {e}")
+        try:
+            from souleyez.handlers import crackmapexec_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import crackmapexec_handler: {e}")
+        try:
+            from souleyez.handlers import john_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import john_handler: {e}")
+        try:
+            from souleyez.handlers import hashcat_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import hashcat_handler: {e}")
+        try:
+            from souleyez.handlers import responder_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import responder_handler: {e}")
+        try:
+            from souleyez.handlers import whois_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import whois_handler: {e}")
+        try:
+            from souleyez.handlers import impacket_secretsdump_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import impacket_secretsdump_handler: {e}")
+        try:
+            from souleyez.handlers import impacket_psexec_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import impacket_psexec_handler: {e}")
+        try:
+            from souleyez.handlers import impacket_getuserspns_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import impacket_getuserspns_handler: {e}")
+        try:
+            from souleyez.handlers import katana_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import katana_handler: {e}")
+        try:
+            from souleyez.handlers import lfi_extract_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import lfi_extract_handler: {e}")
+        try:
+            from souleyez.handlers import evil_winrm_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import evil_winrm_handler: {e}")
+        try:
+            from souleyez.handlers import ldapsearch_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import ldapsearch_handler: {e}")
+        try:
+            from souleyez.handlers import service_explorer_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import service_explorer_handler: {e}")
+        try:
+            from souleyez.handlers import kerbrute_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import kerbrute_handler: {e}")
+        try:
+            from souleyez.handlers import rdp_sec_check_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import rdp_sec_check_handler: {e}")
+        try:
+            from souleyez.handlers import nxc_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import nxc_handler: {e}")
+        try:
+            from souleyez.handlers import certipy_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import certipy_handler: {e}")
+        try:
+            from souleyez.handlers import bloodhound_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import bloodhound_handler: {e}")
+        try:
+            from souleyez.handlers import smbclient_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import smbclient_handler: {e}")
+        try:
+            from souleyez.handlers import smbpasswd_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import smbpasswd_handler: {e}")
+        try:
+            from souleyez.handlers import bash_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import bash_handler: {e}")
+        try:
+            from souleyez.handlers import web_login_test_handler  # noqa: F401
+        except ImportError as e:
+            logger.warning(f"Failed to import web_login_test_handler: {e}")
+
+        # Find all subclasses of BaseToolHandler
+        for handler_class in BaseToolHandler.__subclasses__():
+            try:
+                # Skip the base class itself
+                if handler_class.tool_name == "base":
+                    continue
+
+                instance = handler_class()
+                tool_key = instance.tool_name.lower()
+
+                if tool_key in self._handlers:
+                    logger.warning(
+                        f"Duplicate handler for tool '{tool_key}': "
+                        f"{handler_class.__name__} (using first registered)"
+                    )
+                    continue
+
+                self._handlers[tool_key] = instance
+                logger.debug(
+                    f"Registered handler: {tool_key} -> {handler_class.__name__}"
+                )
+
+            except Exception as e:
+                logger.warning(
+                    f"Failed to register handler {handler_class.__name__}: {e}"
+                )
+
+        self._discovered = True
+        logger.debug(
+            f"Handler discovery complete. Registered: {list(self._handlers.keys())}"
+        )
+
+    def get_handler(self, tool_name: str) -> Optional[BaseToolHandler]:
+        """
+        Get handler for a tool.
+
+        Args:
+            tool_name: The tool identifier (case-insensitive)
+
+        Returns:
+            The handler instance, or None if no handler registered
+        """
+        self._discover_handlers()
+        return self._handlers.get(tool_name.lower())
+
+    def has_handler(self, tool_name: str) -> bool:
+        """Check if a handler exists for this tool."""
+        return self.get_handler(tool_name) is not None
+
+    def has_warning_handler(self, tool_name: str) -> bool:
+        """Check if tool has a warning handler (replaces manual list)."""
+        handler = self.get_handler(tool_name)
+        return handler is not None and handler.has_warning_handler
+
+    def has_error_handler(self, tool_name: str) -> bool:
+        """Check if tool has an error handler (replaces manual list)."""
+        handler = self.get_handler(tool_name)
+        return handler is not None and handler.has_error_handler
+
+    def has_no_results_handler(self, tool_name: str) -> bool:
+        """Check if tool has a no_results handler (replaces manual list)."""
+        handler = self.get_handler(tool_name)
+        return handler is not None and handler.has_no_results_handler
+
+    def has_done_handler(self, tool_name: str) -> bool:
+        """Check if tool has a done handler."""
+        handler = self.get_handler(tool_name)
+        return handler is not None and handler.has_done_handler
+
+    def list_handlers(self) -> List[str]:
+        """List all registered handler tool names."""
+        self._discover_handlers()
+        return list(self._handlers.keys())
+
+    def reset(self) -> None:
+        """Reset registry (for testing)."""
+        self._handlers.clear()
+        self._discovered = False
+
+
+def get_registry() -> ToolHandlerRegistry:
+    """Get the singleton registry instance."""
+    global _registry
+    if _registry is None:
+        _registry = ToolHandlerRegistry()
+    return _registry
+
+
+def get_handler(tool_name: str) -> Optional[BaseToolHandler]:
+    """
+    Convenience function to get a handler.
+
+    Args:
+        tool_name: The tool identifier (case-insensitive)
+
+    Returns:
+        The handler instance, or None if no handler registered
+    """
+    return get_registry().get_handler(tool_name)