sufa 0.1.0__py3-none-any.whl

sufa/__init__.py

@@ -0,0 +1,3 @@
+"""sufa -- AI-powered web vulnerability analysis platform."""
+
+__version__ = "0.1.0"

sufa/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running sufa as `python -m sufa`."""
+
+from sufa.cli.app import main
+
+main()

sufa/burp/__init__.py

@@ -0,0 +1,3 @@
+from sufa.burp.bridge import parse_burp_traffic
+
+__all__ = ["parse_burp_traffic"]

sufa/burp/bridge.py

@@ -0,0 +1,33 @@
+"""Bridge communication protocol between Burp extension and sufa server."""
+
+from __future__ import annotations
+
+from sufa.core.http.parser import build_request, build_response
+from sufa.core.models import TrafficEntry
+
+
+def parse_burp_traffic(data: dict) -> TrafficEntry:
+    """Parse traffic data sent from the Burp bridge into a TrafficEntry."""
+    req_data = data.get("request", {})
+    resp_data = data.get("response", {})
+
+    request = build_request(
+        method=req_data.get("method", "GET"),
+        url=req_data.get("url", ""),
+        headers=req_data.get("headers", {}),
+        body=req_data.get("body", ""),
+    )
+
+    response = None
+    if resp_data.get("status_code"):
+        response = build_response(
+            status_code=resp_data.get("status_code", 0),
+            headers=resp_data.get("headers", {}),
+            body=resp_data.get("body", ""),
+        )
+
+    return TrafficEntry(
+        request=request,
+        response=response,
+        source=data.get("source", "burp"),
+    )

sufa/burp/extension.py

@@ -0,0 +1,138 @@
+"""Thin Jython bridge for Burp Suite integration.
+
+This file is designed to be loaded as a Burp extension. It forwards traffic
+to a running sufa instance over HTTP, keeping all intelligence in the Python 3 codebase.
+
+Usage:
+    1. Start sufa server: sufa server start --port 9000
+    2. In Burp: Extender -> Extensions -> Add -> extension.py
+    3. Traffic captured in Burp is forwarded to sufa for analysis
+"""
+
+# NOTE: This module uses Python 2/Jython compatible syntax for Burp compatibility.
+# It communicates with the main sufa process (Python 3) via HTTP.
+
+import json
+import threading
+
+import urllib2
+
+SUFA_URL = "http://localhost:9000"
+
+
+class BurpExtender:
+    """Burp Suite extension that bridges to sufa."""
+
+    def registerExtenderCallbacks(self, callbacks):
+        self._callbacks = callbacks
+        self._helpers = callbacks.getHelpers()
+        callbacks.setExtensionName("sufa Bridge")
+        callbacks.registerHttpListener(self)
+        callbacks.registerContextMenuFactory(self)
+
+        self._sufa_url = SUFA_URL
+        self._enabled = True
+
+        self.stdout = callbacks.getStdout()
+        self._log("[sufa] Bridge extension loaded")
+        self._log("[sufa] Forwarding traffic to: " + self._sufa_url)
+
+    def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
+        if messageIsRequest:
+            return
+        if not self._enabled:
+            return
+
+        thread = threading.Thread(
+            target=self._forward_traffic,
+            args=(messageInfo,),
+        )
+        thread.daemon = True
+        thread.start()
+
+    def _forward_traffic(self, messageInfo):
+        try:
+            request_info = self._helpers.analyzeRequest(messageInfo)
+            url = str(request_info.getUrl())
+            method = str(request_info.getMethod())
+
+            request_bytes = messageInfo.getRequest()
+            response_bytes = messageInfo.getResponse()
+
+            req_headers = {}
+            for header in request_info.getHeaders():
+                header = str(header)
+                if ": " in header:
+                    k, v = header.split(": ", 1)
+                    req_headers[k] = v
+
+            req_body = ""
+            body_offset = request_info.getBodyOffset()
+            if body_offset < len(request_bytes):
+                req_body = self._helpers.bytesToString(request_bytes[body_offset:])
+
+            resp_info = self._helpers.analyzeResponse(response_bytes) if response_bytes else None
+            status_code = resp_info.getStatusCode() if resp_info else 0
+
+            resp_headers = {}
+            resp_body = ""
+            if resp_info:
+                for header in resp_info.getHeaders():
+                    header = str(header)
+                    if ": " in header:
+                        k, v = header.split(": ", 1)
+                        resp_headers[k] = v
+                resp_body_offset = resp_info.getBodyOffset()
+                if resp_body_offset < len(response_bytes):
+                    raw_bytes = response_bytes[resp_body_offset:]
+                    resp_body = self._helpers.bytesToString(raw_bytes)[:3000]
+
+            payload = json.dumps(
+                {
+                    "request": {
+                        "method": method,
+                        "url": url,
+                        "headers": req_headers,
+                        "body": req_body[:2000],
+                    },
+                    "response": {
+                        "status_code": status_code,
+                        "headers": resp_headers,
+                        "body": resp_body,
+                    },
+                    "source": "burp",
+                }
+            )
+
+            req = urllib2.Request(
+                self._sufa_url + "/api/v1/traffic",
+                data=payload,
+                headers={"Content-Type": "application/json"},
+            )
+            urllib2.urlopen(req, timeout=5)
+
+        except Exception as e:
+            self._log("[sufa] Error forwarding: " + str(e))
+
+    def createMenuItems(self, invocation):
+        from javax.swing import JMenuItem
+
+        items = []
+        item = JMenuItem("Analyze with sufa")
+        item.addActionListener(lambda e: self._analyze_selected(invocation))
+        items.append(item)
+        return items
+
+    def _analyze_selected(self, invocation):
+        messages = invocation.getSelectedMessages()
+        if not messages:
+            return
+        for msg in messages:
+            self._forward_traffic(msg)
+        self._log(f"[sufa] Sent {len(messages)} requests for analysis")
+
+    def _log(self, msg):
+        try:
+            self.stdout.write((msg + "\n").encode())
+        except Exception:
+            pass

sufa/cli/app.py

@@ -0,0 +1,49 @@
+"""Main CLI application for sufa."""
+
+from __future__ import annotations
+
+import typer
+
+from sufa.cli.commands import (
+    config_cmd,
+    findings,
+    import_cmd,
+    project,
+    provider,
+    proxy,
+    replay,
+    report,
+    scan,
+    server,
+)
+
+app = typer.Typer(
+    name="sufa",
+    help="AI-powered web vulnerability analysis platform.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+app.add_typer(scan.app, name="scan", help="Scan targets for vulnerabilities")
+app.add_typer(findings.app, name="findings", help="Manage vulnerability findings")
+app.add_typer(project.app, name="project", help="Manage projects")
+app.add_typer(config_cmd.app, name="config", help="View and modify configuration")
+app.add_typer(provider.app, name="provider", help="Manage AI providers")
+app.add_typer(report.app, name="report", help="Generate reports")
+app.add_typer(import_cmd.app, name="import", help="Import traffic from files")
+app.add_typer(proxy.app, name="proxy", help="Intercept proxy for capturing traffic")
+app.add_typer(replay.app, name="replay", help="Replay stored requests")
+app.add_typer(server.app, name="server", help="Start the API server (Enterprise)")
+
+
+@app.callback(invoke_without_command=True)
+def main_callback(ctx: typer.Context) -> None:
+    if ctx.invoked_subcommand is None:
+        from sufa.cli.display import print_banner
+
+        print_banner()
+        raise typer.Exit()
+
+
+def main() -> None:
+    app()

sufa/cli/commands/config_cmd.py

@@ -0,0 +1,65 @@
+"""CLI commands for configuration management."""
+
+from __future__ import annotations
+
+import typer
+
+from sufa.cli.display import console, print_config_table, print_error, print_success
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _get_config():
+    from sufa.core.utils.config import SufaConfig
+
+    return SufaConfig()
+
+
+@app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Configuration key (e.g., ai.provider)"),
+    value: str = typer.Argument(..., help="Configuration value"),
+) -> None:
+    """Set a configuration value."""
+    config = _get_config()
+    config.set(key, value)
+    print_success(f"{key} = {value}")
+
+
+@app.command("get")
+def config_get(
+    key: str = typer.Argument(..., help="Configuration key"),
+) -> None:
+    """Get a configuration value."""
+    config = _get_config()
+    val = config.get(key)
+    if val is None:
+        print_error(f"Unknown key: {key}")
+        raise typer.Exit(1)
+    display_val = str(val)
+    if "key" in key.lower() and display_val:
+        display_val = display_val[:4] + "****"
+    console.print(f"{key} = {display_val}")
+
+
+@app.command("list")
+def config_list() -> None:
+    """Show all configuration values."""
+    config = _get_config()
+    print_config_table(config.get_all())
+
+
+@app.command("reset")
+def config_reset(
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Reset configuration to defaults."""
+    if not confirm:
+        confirm = typer.confirm("Reset all configuration to defaults?")
+    if confirm:
+        from sufa.core.utils.config import _DEFAULT_CONFIG, SufaConfig
+
+        config = SufaConfig()
+        for key, val in _DEFAULT_CONFIG.items():
+            config.set(key, val)
+        print_success("Configuration reset to defaults")

sufa/cli/commands/findings.py

@@ -0,0 +1,115 @@
+"""CLI commands for managing findings."""
+
+from __future__ import annotations
+
+import typer
+
+from sufa.cli.display import console, print_error, print_findings_table, print_info, print_success
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _get_repo():
+    from sufa.core.db import Repository, init_db
+    from sufa.core.utils.config import SufaConfig
+
+    config = SufaConfig()
+    init_db(config.get_db_path())
+    return Repository()
+
+
+@app.command("list")
+def list_findings(
+    scan_id: str = typer.Option("", "--scan", help="Filter by scan ID"),
+    severity: str = typer.Option("", "--severity", "-s", help="Filter by severity"),
+    status: str = typer.Option("", "--status", help="Filter by status"),
+    limit: int = typer.Option(50, "--limit", "-n", help="Max results"),
+) -> None:
+    """List vulnerability findings."""
+    repo = _get_repo()
+    findings = repo.list_findings(scan_id=scan_id, severity=severity, status=status, limit=limit)
+
+    if not findings:
+        print_info("No findings found.")
+        return
+
+    print_findings_table([f.model_dump() for f in findings])
+    print_info(f"{len(findings)} findings shown")
+    repo.close()
+
+
+@app.command("show")
+def show_finding(
+    finding_id: str = typer.Argument(..., help="Finding ID"),
+) -> None:
+    """Show detailed information about a finding."""
+    repo = _get_repo()
+    finding = repo.get_finding(finding_id)
+
+    if not finding:
+        partial = repo.list_findings(limit=500)
+        matches = [f for f in partial if f.id.startswith(finding_id)]
+        if len(matches) == 1:
+            finding = matches[0]
+        else:
+            print_error(f"Finding not found: {finding_id}")
+            raise typer.Exit(1)
+
+    from rich.panel import Panel
+    from rich.text import Text
+
+    from sufa.cli.display import SEVERITY_COLORS
+
+    sev_style = SEVERITY_COLORS.get(finding.severity.value, "")
+    header = Text(f"{finding.title}", style="bold")
+
+    console.print(
+        Panel(
+            header,
+            title=f"Finding {finding.id[:8]}",
+            border_style=sev_style or "cyan",
+        )
+    )
+    console.print(f"  [bold]Severity:[/bold]   {finding.severity.value.upper()}")
+    console.print(
+        f"  [bold]Confidence:[/bold] {finding.confidence.value} ({finding.confidence_score}%)"
+    )
+    console.print(f"  [bold]CWE:[/bold]        {finding.cwe_id} {finding.cwe_url}")
+    console.print(f"  [bold]OWASP:[/bold]      {finding.owasp_category}")
+    console.print(f"  [bold]URL:[/bold]        {finding.url}")
+    console.print(f"  [bold]Parameter:[/bold]  {finding.parameter}")
+    console.print(f"  [bold]Status:[/bold]     {finding.status.value}")
+    console.print()
+    if finding.description:
+        console.print(Panel(finding.description, title="Description"))
+    if finding.evidence:
+        console.print(Panel(finding.evidence, title="Evidence"))
+    if finding.remediation:
+        console.print(Panel(finding.remediation, title="Remediation"))
+    if finding.exploit_steps:
+        console.print("[bold]Exploit Steps:[/bold]")
+        for step in finding.exploit_steps:
+            console.print(f"  {step.step_number}. {step.description}")
+
+    repo.close()
+
+
+@app.command("triage")
+def triage_finding(
+    finding_id: str = typer.Argument(..., help="Finding ID"),
+    status: str = typer.Option(
+        ..., "--status", "-s", help="New status: confirmed, false_positive, accepted_risk, fixed"
+    ),
+) -> None:
+    """Update the triage status of a finding."""
+    valid = {"confirmed", "false_positive", "accepted_risk", "fixed", "open"}
+    if status not in valid:
+        print_error(f"Invalid status. Must be one of: {', '.join(valid)}")
+        raise typer.Exit(1)
+
+    repo = _get_repo()
+    if repo.update_finding_status(finding_id, status):
+        print_success(f"Finding {finding_id[:8]} updated to: {status}")
+    else:
+        print_error(f"Finding not found: {finding_id}")
+    repo.close()

sufa/cli/commands/import_cmd.py

@@ -0,0 +1,145 @@
+"""CLI commands for importing traffic from files."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from sufa.cli.display import print_error, print_success
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.callback(invoke_without_command=True)
+def import_file(
+    file_path: str = typer.Argument(..., help="Path to HAR or Burp XML file"),
+    fmt: str = typer.Option("auto", "--format", "-f", help="File format: auto, har, burp"),
+    scan_id: str = typer.Option("", "--scan", help="Associate with scan ID"),
+    project_id: str = typer.Option("", "--project", help="Associate with project ID"),
+) -> None:
+    """Import HTTP traffic from a file."""
+    path = Path(file_path)
+    if not path.exists():
+        print_error(f"File not found: {file_path}")
+        raise typer.Exit(1)
+
+    if fmt == "auto":
+        if path.suffix.lower() == ".har":
+            fmt = "har"
+        elif path.suffix.lower() in (".xml", ".burp"):
+            fmt = "burp"
+        else:
+            print_error(
+                f"Cannot detect format for {path.suffix}. Use --format har or --format burp"
+            )
+            raise typer.Exit(1)
+
+    from sufa.core.db import Repository, init_db
+    from sufa.core.events import EventBus
+    from sufa.core.traffic import TrafficStore
+    from sufa.core.utils.config import SufaConfig
+
+    config = SufaConfig()
+    init_db(config.get_db_path())
+    repo = Repository()
+    store = TrafficStore(repo, EventBus())
+
+    count = 0
+    if fmt == "har":
+        count = _import_har(path, store, scan_id, project_id)
+    elif fmt == "burp":
+        count = _import_burp_xml(path, store, scan_id, project_id)
+
+    print_success(f"Imported {count} traffic entries from {path.name}")
+    repo.close()
+
+
+def _import_har(path: Path, store, scan_id: str, project_id: str) -> int:
+    from sufa.core.http.parser import build_request, build_response
+    from sufa.core.models import TrafficEntry
+
+    with open(path) as f:
+        data = json.load(f)
+
+    entries = data.get("log", {}).get("entries", [])
+    count = 0
+
+    for entry in entries:
+        try:
+            req_data = entry.get("request", {})
+            resp_data = entry.get("response", {})
+
+            headers = {h["name"]: h["value"] for h in req_data.get("headers", [])}
+            body = ""
+            if req_data.get("postData"):
+                body = req_data["postData"].get("text", "")
+
+            req = build_request(
+                method=req_data.get("method", "GET"),
+                url=req_data.get("url", ""),
+                headers=headers,
+                body=body,
+            )
+
+            resp_headers = {h["name"]: h["value"] for h in resp_data.get("headers", [])}
+            resp_body = ""
+            if resp_data.get("content"):
+                resp_body = resp_data["content"].get("text", "")
+
+            resp = build_response(
+                status_code=resp_data.get("status", 0),
+                headers=resp_headers,
+                body=resp_body,
+            )
+
+            traffic = TrafficEntry(
+                request=req,
+                response=resp,
+                scan_id=scan_id,
+                project_id=project_id,
+                source="har_import",
+            )
+            store.store(traffic)
+            count += 1
+        except Exception:
+            continue
+
+    return count
+
+
+def _import_burp_xml(path: Path, store, scan_id: str, project_id: str) -> int:
+    import xml.etree.ElementTree as ET
+
+    from sufa.core.http.parser import build_request, build_response
+    from sufa.core.models import TrafficEntry
+
+    tree = ET.parse(path)
+    root = tree.getroot()
+    count = 0
+
+    for item in root.iter("item"):
+        try:
+            url = item.findtext("url", "")
+            method = item.findtext("method", "GET")
+            status = int(item.findtext("status", "0"))
+            req_body = item.findtext("request", "")
+            resp_body = item.findtext("response", "")
+
+            req = build_request(method=method, url=url, body=req_body or "")
+            resp = build_response(status_code=status, body=resp_body or "")
+
+            traffic = TrafficEntry(
+                request=req,
+                response=resp,
+                scan_id=scan_id,
+                project_id=project_id,
+                source="burp_import",
+            )
+            store.store(traffic)
+            count += 1
+        except Exception:
+            continue
+
+    return count

sufa/cli/commands/project.py

@@ -0,0 +1,66 @@
+"""CLI commands for project management."""
+
+from __future__ import annotations
+
+import typer
+
+from sufa.cli.display import print_error, print_info, print_projects_table, print_success
+
+app = typer.Typer(no_args_is_help=True)
+
+
+def _get_repo():
+    from sufa.core.db import Repository, init_db
+    from sufa.core.utils.config import SufaConfig
+
+    config = SufaConfig()
+    init_db(config.get_db_path())
+    return Repository()
+
+
+@app.command("create")
+def create_project(
+    name: str = typer.Argument(..., help="Project name"),
+    description: str = typer.Option("", "--desc", "-d", help="Project description"),
+) -> None:
+    """Create a new project."""
+    from sufa.core.models import Project
+
+    repo = _get_repo()
+    project = Project(name=name, description=description)
+    repo.save_project(project)
+    print_success(f"Project created: {project.id[:8]} - {name}")
+    repo.close()
+
+
+@app.command("list")
+def list_projects() -> None:
+    """List all projects."""
+    repo = _get_repo()
+    projects = repo.list_projects()
+
+    if not projects:
+        print_info("No projects found. Create one with: sufa project create <name>")
+        return
+
+    print_projects_table([p.model_dump() for p in projects])
+    repo.close()
+
+
+@app.command("delete")
+def delete_project(
+    project_id: str = typer.Argument(..., help="Project ID"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Delete a project."""
+    if not confirm:
+        confirm = typer.confirm(f"Delete project {project_id[:8]}?")
+    if not confirm:
+        return
+
+    repo = _get_repo()
+    if repo.delete_project(project_id):
+        print_success(f"Project {project_id[:8]} deleted")
+    else:
+        print_error(f"Project not found: {project_id}")
+    repo.close()