souleyez 2.43.29__py3-none-any.whl → 3.0.0__py3-none-any.whl

souleyez/handlers/web_login_test_handler.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+Web Login Test handler.
+
+Parses and displays results from web login credential tests.
+"""
+import json
+import logging
+import os
+import re
+from typing import Any, Dict, Optional
+
+import click
+
+from souleyez.engine.job_status import STATUS_DONE, STATUS_ERROR, STATUS_NO_RESULTS
+from souleyez.handlers.base import BaseToolHandler
+
+logger = logging.getLogger(__name__)
+
+
+class WebLoginTestHandler(BaseToolHandler):
+    """Handler for web login credential test jobs."""
+
+    tool_name = "web_login_test"
+    display_name = "Web Login Test"
+
+    has_error_handler = True
+    has_warning_handler = False
+    has_no_results_handler = True
+    has_done_handler = True
+
+    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 web login test results.
+
+        Returns parsed result including:
+        - login_success: bool
+        - username: str
+        - http_code: int
+        - reason: str
+        """
+        try:
+            if not log_path or not os.path.exists(log_path):
+                return {
+                    "tool": self.tool_name,
+                    "status": STATUS_ERROR,
+                    "error": "Log file not found",
+                }
+
+            with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                log_content = f.read()
+
+            # Try to parse JSON result
+            json_match = re.search(
+                r"=== JSON_RESULT ===\s*(.*?)\s*=== END_JSON_RESULT ===",
+                log_content,
+                re.DOTALL,
+            )
+
+            result = {
+                "tool": self.tool_name,
+                "status": STATUS_NO_RESULTS,
+                "login_success": False,
+                "username": None,
+                "http_code": None,
+                "reason": None,
+                "response": None,
+            }
+
+            # Extract username from log
+            username_match = re.search(r"Username: (\S+)", log_content)
+            if username_match:
+                result["username"] = username_match.group(1)
+
+            if json_match:
+                try:
+                    json_data = json.loads(json_match.group(1))
+
+                    if json_data.get("error"):
+                        result["status"] = STATUS_ERROR
+                        result["error"] = json_data["error"]
+                        result["summary"] = f"Error: {json_data['error'][:50]}"
+                        return result
+
+                    result["login_success"] = json_data.get("success", False)
+                    result["http_code"] = json_data.get("http_code")
+                    result["reason"] = json_data.get("reason")
+                    result["response"] = json_data.get("response", "")[:100]
+
+                except json.JSONDecodeError:
+                    pass
+
+            # Fallback: parse from log text
+            if "[+] LOGIN SUCCESS" in log_content:
+                result["login_success"] = True
+                result["status"] = STATUS_DONE
+            elif "[-] LOGIN FAILED" in log_content:
+                result["login_success"] = False
+                result["status"] = STATUS_NO_RESULTS
+
+            # Extract HTTP code if not already found
+            if not result["http_code"]:
+                http_match = re.search(r"HTTP Code: (\d+)", log_content)
+                if http_match:
+                    result["http_code"] = int(http_match.group(1))
+
+            # Extract reason if not already found
+            if not result["reason"]:
+                reason_match = re.search(r"Reason: (.+?)(?:\n|$)", log_content)
+                if reason_match:
+                    result["reason"] = reason_match.group(1).strip()
+
+            # Build summary
+            if result["login_success"]:
+                result["status"] = STATUS_DONE
+                result["summary"] = f"Login successful: {result['username']}"
+                # Store validated credential
+                if credentials_manager and result["username"]:
+                    target = job.get("target", "")
+                    # Extract password from args
+                    password = self._extract_password_from_args(job.get("args", []))
+                    if password:
+                        try:
+                            credentials_manager.add_credential(
+                                engagement_id=engagement_id,
+                                host_id=None,
+                                username=result["username"],
+                                password=password,
+                                service="web",
+                                credential_type="password",
+                                tool="web_login_test",
+                                status="validated",
+                                notes=f"Validated against {target}",
+                            )
+                            result["credentials_validated"] = 1
+                            logger.info(
+                                f"Web login test: Validated credential {result['username']}"
+                            )
+                        except Exception as e:
+                            logger.debug(f"Error storing validated credential: {e}")
+            else:
+                result["status"] = STATUS_NO_RESULTS
+                # Build informative failure summary
+                if result["reason"]:
+                    # Truncate long reasons
+                    reason = result["reason"]
+                    if len(reason) > 50:
+                        reason = reason[:47] + "..."
+                    result["summary"] = f"Login failed: {reason}"
+                elif result["http_code"]:
+                    result["summary"] = f"Login failed (HTTP {result['http_code']})"
+                else:
+                    result["summary"] = "Login failed"
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error parsing web_login_test job: {e}")
+            return {"tool": self.tool_name, "status": STATUS_ERROR, "error": str(e)}
+
+    def _extract_password_from_args(self, args: list) -> Optional[str]:
+        """Extract password from job args."""
+        for i, arg in enumerate(args):
+            if arg == "--password" and i + 1 < len(args):
+                return args[i + 1]
+        return None
+
+    def display_done(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        show_all: bool = False,
+        show_passwords: bool = False,
+    ) -> None:
+        """Display successful login test results."""
+        result = self._parse_log(log_path)
+
+        click.echo()
+        click.echo(click.style("=" * 60, fg="green"))
+        click.echo(click.style("WEB LOGIN TEST - SUCCESS", bold=True, fg="green"))
+        click.echo(click.style("=" * 60, fg="green"))
+        click.echo()
+
+        target = job.get("target", "unknown")
+        click.echo(f"  Target: {target}")
+
+        username = result.get("username", "unknown")
+        if show_passwords:
+            password = self._extract_password_from_args(job.get("args", []))
+            click.echo(click.style(f"  Credential: {username}:{password}", fg="green"))
+        else:
+            click.echo(click.style(f"  Credential: {username}:***", fg="green"))
+
+        if result.get("http_code"):
+            click.echo(f"  HTTP Code: {result['http_code']}")
+
+        if result.get("reason"):
+            click.echo(f"  Reason: {result['reason']}")
+
+        click.echo()
+        click.echo(click.style("=" * 60, fg="green"))
+        click.echo()
+
+    def display_no_results(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+    ) -> None:
+        """Display failed login test results."""
+        result = self._parse_log(log_path)
+
+        click.echo()
+        click.echo(click.style("=" * 60, fg="yellow"))
+        click.echo(click.style("WEB LOGIN TEST - FAILED", bold=True, fg="yellow"))
+        click.echo(click.style("=" * 60, fg="yellow"))
+        click.echo()
+
+        target = job.get("target", "unknown")
+        click.echo(f"  Target: {target}")
+
+        username = result.get("username", "unknown")
+        click.echo(f"  Credential: {username}:***")
+
+        if result.get("http_code"):
+            click.echo(f"  HTTP Code: {result['http_code']}")
+
+        if result.get("reason"):
+            click.echo(f"  Reason: {result['reason']}")
+
+        click.echo()
+        click.echo(click.style("  Result: Invalid credentials", fg="yellow"))
+        click.echo()
+        click.echo(click.style("=" * 60, fg="yellow"))
+        click.echo()
+
+    def display_error(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        log_content: Optional[str] = None,
+    ) -> None:
+        """Display error status."""
+        click.echo()
+        click.echo(click.style("=" * 60, fg="red"))
+        click.echo(click.style("[ERROR] WEB LOGIN TEST FAILED", bold=True, fg="red"))
+        click.echo(click.style("=" * 60, fg="red"))
+        click.echo()
+
+        target = job.get("target", "unknown")
+        click.echo(f"  Target: {target}")
+
+        # Try to get error details
+        if log_path and os.path.exists(log_path):
+            try:
+                with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                    content = f.read()
+                error_match = re.search(r"ERROR: (.+?)(?:\n|$)", content)
+                if error_match:
+                    click.echo(f"  Error: {error_match.group(1)}")
+            except Exception:
+                pass
+
+        click.echo()
+        click.echo("  Check raw logs for details (press 'r').")
+        click.echo()
+        click.echo(click.style("=" * 60, fg="red"))
+        click.echo()
+
+    def _parse_log(self, log_path: str) -> Dict[str, Any]:
+        """Parse log file and return result dict."""
+        result = {
+            "username": None,
+            "http_code": None,
+            "reason": None,
+            "response": None,
+        }
+
+        if not log_path or not os.path.exists(log_path):
+            return result
+
+        try:
+            with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                log_content = f.read()
+
+            # Extract username
+            username_match = re.search(r"Username: (\S+)", log_content)
+            if username_match:
+                result["username"] = username_match.group(1)
+
+            # Try JSON result
+            json_match = re.search(
+                r"=== JSON_RESULT ===\s*(.*?)\s*=== END_JSON_RESULT ===",
+                log_content,
+                re.DOTALL,
+            )
+            if json_match:
+                try:
+                    json_data = json.loads(json_match.group(1))
+                    result["http_code"] = json_data.get("http_code")
+                    result["reason"] = json_data.get("reason")
+                    result["response"] = json_data.get("response", "")[:100]
+                except json.JSONDecodeError:
+                    pass
+
+            # Fallback parsing
+            if not result["http_code"]:
+                http_match = re.search(r"HTTP Code: (\d+)", log_content)
+                if http_match:
+                    result["http_code"] = int(http_match.group(1))
+
+            if not result["reason"]:
+                reason_match = re.search(r"Reason: (.+?)(?:\n|$)", log_content)
+                if reason_match:
+                    result["reason"] = reason_match.group(1).strip()
+
+        except Exception:
+            pass
+
+        return result

souleyez/handlers/whois_handler.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+WHOIS handler.
+
+Consolidates parsing and display logic for WHOIS domain lookup jobs.
+"""
+import logging
+import os
+from typing import Any, Dict, Optional
+
+import click
+
+from souleyez.engine.job_status import STATUS_DONE, STATUS_NO_RESULTS
+from souleyez.handlers.base import BaseToolHandler
+
+logger = logging.getLogger(__name__)
+
+
+class WhoisHandler(BaseToolHandler):
+    """Handler for WHOIS domain lookup jobs."""
+
+    tool_name = "whois"
+    display_name = "WHOIS"
+
+    # All handlers enabled
+    has_error_handler = True
+    has_warning_handler = True
+    has_no_results_handler = True
+    has_done_handler = True
+
+    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 WHOIS job results.
+
+        Extracts domain registration information and stores as OSINT data.
+        """
+        try:
+            from souleyez.parsers.whois_parser import (
+                parse_whois_output,
+                map_to_osint_data,
+                extract_emails,
+            )
+            from souleyez.storage.osint import OsintManager
+
+            # Read the log file
+            with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                log_content = f.read()
+
+            # Parse WHOIS output
+            target = job.get("target", "")
+            parsed = parse_whois_output(log_content, target)
+
+            # Store OSINT data
+            om = OsintManager()
+            osint_record = map_to_osint_data(parsed, engagement_id)
+            om.add_osint_data(
+                engagement_id,
+                osint_record["data_type"],
+                osint_record["target"],
+                source=osint_record["source"],
+                target=target,
+                summary=osint_record["summary"],
+                content=osint_record["content"],
+                metadata=osint_record["metadata"],
+            )
+
+            # Extract emails and add separately for better querying
+            emails = extract_emails(parsed)
+            emails_added = 0
+            if emails:
+                emails_added = om.bulk_add_osint_data(
+                    engagement_id, "email", emails, "whois", target
+                )
+
+            return {
+                "tool": "whois",
+                "status": (
+                    STATUS_DONE
+                    if (parsed.get("registrar") or parsed.get("nameservers"))
+                    else STATUS_NO_RESULTS
+                ),
+                "domain": parsed.get("domain", target),
+                "registrar": parsed.get("registrar"),
+                "created": parsed.get("dates", {}).get("created"),
+                "expires": parsed.get("dates", {}).get("expires"),
+                "emails_found": len(emails),
+                "nameservers": len(parsed.get("nameservers", [])),
+                "osint_records_added": 1,
+                "emails_added": emails_added,
+            }
+
+        except Exception as e:
+            logger.error(f"Error parsing whois job: {e}")
+            return {"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 WHOIS results."""
+        try:
+            from souleyez.parsers.whois_parser import parse_whois_output
+
+            if not log_path or not os.path.exists(log_path):
+                return
+
+            with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                log_content = f.read()
+
+            parsed = parse_whois_output(log_content, job.get("target", ""))
+
+            click.echo(click.style("=" * 70, fg="cyan"))
+            click.echo(click.style("WHOIS DOMAIN INFORMATION", bold=True, fg="cyan"))
+            click.echo(click.style("=" * 70, fg="cyan"))
+            click.echo()
+
+            # Check if we have any data
+            has_data = (
+                parsed.get("domain")
+                or parsed.get("registrar")
+                or parsed.get("dates")
+                or parsed.get("nameservers")
+                or parsed.get("status")
+                or parsed.get("dnssec")
+            )
+
+            if has_data:
+                # Domain and registrar
+                if parsed.get("domain"):
+                    click.echo(click.style(f"Domain: {parsed['domain']}", bold=True))
+                elif job.get("target"):
+                    click.echo(click.style(f"Target: {job.get('target')}", bold=True))
+                if parsed.get("registrar"):
+                    click.echo(f"Registrar: {parsed['registrar']}")
+                click.echo()
+
+                # Registration dates
+                dates = parsed.get("dates", {})
+                if dates:
+                    click.echo(click.style("Registration Information:", bold=True))
+                    if dates.get("created"):
+                        click.echo(f"  Created: {dates['created']}")
+                    if dates.get("updated"):
+                        click.echo(f"  Updated: {dates['updated']}")
+                    if dates.get("expires"):
+                        click.echo(f"  Expires: {dates['expires']}")
+                    click.echo()
+
+                # Nameservers
+                ns = parsed.get("nameservers", [])
+                if ns:
+                    click.echo(click.style(f"Nameservers: {len(ns)}", bold=True))
+                    for server in ns:
+                        click.echo(f"  - {server}")
+                    click.echo()
+
+                # Status
+                status_list = parsed.get("status", [])
+                if status_list:
+                    click.echo(click.style("Domain Status:", bold=True))
+                    for status in status_list:
+                        click.echo(f"  - {status}")
+                    click.echo()
+
+                # DNSSEC
+                if parsed.get("dnssec"):
+                    click.echo(f"DNSSEC: {parsed['dnssec']}")
+                    click.echo()
+            else:
+                self.display_no_results(job, log_path)
+                return
+
+            click.echo(click.style("=" * 70, fg="cyan"))
+            click.echo()
+
+        except Exception as e:
+            logger.debug(f"Error in display_done: {e}")
+
+    def display_warning(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        log_content: Optional[str] = None,
+    ) -> None:
+        """Display warning status for WHOIS."""
+        click.echo(click.style("=" * 70, fg="yellow"))
+        click.echo(click.style("[WARNING] WHOIS LOOKUP", bold=True, fg="yellow"))
+        click.echo(click.style("=" * 70, fg="yellow"))
+        click.echo()
+        click.echo("  WHOIS lookup completed with warnings.")
+        click.echo("  Check raw logs for details (press 'r').")
+        click.echo()
+        click.echo(click.style("=" * 70, fg="yellow"))
+        click.echo()
+
+    def display_error(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+        log_content: Optional[str] = None,
+    ) -> None:
+        """Display error status for WHOIS."""
+        # Read log if not provided
+        if log_content is None and log_path and os.path.exists(log_path):
+            try:
+                with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+                    log_content = f.read()
+            except Exception:
+                log_content = ""
+
+        click.echo(click.style("=" * 70, fg="red"))
+        click.echo(click.style("[ERROR] WHOIS LOOKUP FAILED", bold=True, fg="red"))
+        click.echo(click.style("=" * 70, fg="red"))
+        click.echo()
+
+        # Check for common whois errors
+        error_msg = None
+        if log_content:
+            if "No match for" in log_content or "NOT FOUND" in log_content.upper():
+                error_msg = "Domain not found in WHOIS database"
+            elif "timed out" in log_content.lower() or "timeout" in log_content.lower():
+                error_msg = "WHOIS query timed out - server may be slow"
+            elif "Connection refused" in log_content:
+                error_msg = "Connection refused - WHOIS server may be down"
+            elif (
+                "rate limit" in log_content.lower() or "too many" in log_content.lower()
+            ):
+                error_msg = "Rate limited - too many WHOIS queries"
+
+        if error_msg:
+            click.echo(f"  {error_msg}")
+        else:
+            click.echo("  Lookup failed - see raw logs for details (press 'r')")
+
+        click.echo()
+        click.echo(click.style("=" * 70, fg="red"))
+        click.echo()
+
+    def display_no_results(
+        self,
+        job: Dict[str, Any],
+        log_path: str,
+    ) -> None:
+        """Display no_results status for WHOIS."""
+        click.echo(click.style("=" * 70, fg="cyan"))
+        click.echo(click.style("WHOIS DOMAIN INFORMATION", bold=True, fg="cyan"))
+        click.echo(click.style("=" * 70, fg="cyan"))
+        click.echo()
+
+        if job.get("target"):
+            click.echo(click.style(f"Target: {job.get('target')}", bold=True))
+            click.echo()
+
+        click.echo(
+            click.style("Result: No WHOIS information found", fg="yellow", bold=True)
+        )
+        click.echo()
+        click.echo("  The WHOIS lookup did not return any information.")
+        click.echo()
+        click.echo(click.style("Tips:", dim=True))
+        click.echo("  - Verify the domain name is correct")
+        click.echo("  - Some domains have private WHOIS")
+        click.echo("  - Try a different WHOIS server")
+        click.echo()
+        click.echo(click.style("=" * 70, fg="cyan"))
+        click.echo()