feat: add CVSS v3.1 calculator module

reporting/cvss_calculator.py: full CVSS v3.1 spec implementation with
pre-built vectors for common finding types (FTP, SMB, RDP, sensitive files).
score_finding() heuristic auto-assigns CVSS from finding title/severity.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Kim-San04

core/engine.py

@@ -1,65 +1,45 @@
 import logging
+import os
 import time
 from typing import Optional
 
 from rich.console import Console
 from rich.panel import Panel
-from rich.progress import (
-    BarColumn,
-    Progress,
-    SpinnerColumn,
-    TaskProgressColumn,
-    TextColumn,
-    TimeElapsedColumn,
-)
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn, TimeElapsedColumn
 from rich.rule import Rule
 from rich.table import Table
 
 from core.session import Session
-from core.target import Target
 
 logger = logging.getLogger("pentest-agent.engine")
 console = Console()
 
 
 class Engine:
-    def __init__(
-        self,
-        session: Session,
-        passive_only: bool = False,
-        delay: float = 1.0,
-    ):
+    def __init__(self, session: Session, passive_only: bool = False, delay: float = 1.0,
+                 lang: str = "EN", no_pdf: bool = False, no_html: bool = False):
         self.session = session
         self.passive_only = passive_only
         self.delay = delay
+        self.lang = lang
+        self.no_pdf = no_pdf
+        self.no_html = no_html
 
     def run(self):
         target = self.session.target
-        console.print(
-            Panel(
-                f"[bold cyan]Target:[/bold cyan] {target}\n"
-                f"[bold cyan]Type:[/bold cyan]   {target.target_type}\n"
-                f"[bold cyan]Mode:[/bold cyan]   {'Passive only' if self.passive_only else 'Full (passive + active)'}",
-                title="[bold green]Scan Configuration[/bold green]",
-                border_style="green",
-            )
-        )
+        console.print(Panel(
+            f"[bold cyan]Target:[/bold cyan] {target}\n"
+            f"[bold cyan]Type:[/bold cyan]   {target.target_type}\n"
+            f"[bold cyan]Mode:[/bold cyan]   {'Passive only' if self.passive_only else 'Full (passive + active)'}\n"
+            f"[bold cyan]Lang:[/bold cyan]   {self.lang}",
+            title="[bold green]Scan Configuration[/bold green]", border_style="green",
+        ))
 
         steps = self._build_steps()
-
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            TaskProgressColumn(),
-            TimeElapsedColumn(),
-            console=console,
-            transient=False,
-        ) as progress:
-            overall = progress.add_task(
-                "[cyan]Overall progress", total=len(steps)
-            )
-
+        with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"),
+                      BarColumn(), TaskProgressColumn(), TimeElapsedColumn(),
+                      console=console, transient=False) as progress:
+            overall = progress.add_task("[cyan]Overall progress", total=len(steps))
             for step_name, step_fn in steps:
                 progress.update(overall, description=f"[cyan]{step_name}")
                 logger.info(f"Starting: {step_name}")
@@ -96,64 +76,58 @@ def _build_steps(self):
             ]
         return steps
 
-    # ── Passive steps ──────────────────────────────────────────────────────
+    # ── Passive ────────────────────────────────────────────────────────────
 
     def _step_whois(self):
         from modules.recon.passive import PassiveRecon
-        pr = PassiveRecon(self.session.target, self.delay)
-        data = pr.whois_lookup()
-        self.session.update_results("passive_recon", "whois", data)
+        self.session.update_results("passive_recon", "whois",
+            PassiveRecon(self.session.target, self.delay).whois_lookup())
 
     def _step_dns(self):
         from modules.recon.passive import PassiveRecon
-        pr = PassiveRecon(self.session.target, self.delay)
-        data = pr.dns_enumeration()
-        self.session.update_results("passive_recon", "dns", data)
+        self.session.update_results("passive_recon", "dns",
+            PassiveRecon(self.session.target, self.delay).dns_enumeration())
 
     def _step_subdomains(self):
         from modules.recon.passive import PassiveRecon
         from pathlib import Path
-        pr = PassiveRecon(self.session.target, self.delay)
         wordlist = Path(__file__).parent.parent / "wordlists" / "subdomains.txt"
-        data = pr.subdomain_enumeration(str(wordlist))
-        self.session.update_results("passive_recon", "subdomains", data)
+        self.session.update_results("passive_recon", "subdomains",
+            PassiveRecon(self.session.target, self.delay).subdomain_enumeration(str(wordlist)))
 
     def _step_shodan(self):
         from modules.recon.passive import PassiveRecon
-        pr = PassiveRecon(self.session.target, self.delay)
-        data = pr.shodan_lookup()
-        self.session.update_results("passive_recon", "shodan", data)
+        self.session.update_results("passive_recon", "shodan",
+            PassiveRecon(self.session.target, self.delay).shodan_lookup())
 
     def _step_http_tech(self):
         from modules.recon.passive import PassiveRecon
-        pr = PassiveRecon(self.session.target, self.delay)
-        data = pr.detect_web_technologies()
-        self.session.update_results("passive_recon", "http_tech", data)
+        self.session.update_results("passive_recon", "http_tech",
+            PassiveRecon(self.session.target, self.delay).detect_web_technologies())
 
-    # ── Active steps ───────────────────────────────────────────────────────
+    # ── Active ─────────────────────────────────────────────────────────────
 
     def _step_host_discovery(self):
         from modules.scanner.port_scanner import PortScanner
-        ps = PortScanner()
-        hosts = ps.host_discovery(self.session.target.get_hosts())
+        hosts = PortScanner().host_discovery(self.session.target.get_hosts())
         self.session.update_results("active_recon", "live_hosts", hosts)
 
     def _step_port_scan(self):
         from modules.scanner.port_scanner import PortScanner
         ps = PortScanner()
         live = self.session.results["active_recon"].get("live_hosts", self.session.target.get_hosts())
-        results = {}
-        for host in live:
-            results[host] = ps.port_scan(host)
-        self.session.update_results("active_recon", "ports", results)
+        self.session.update_results("active_recon", "ports",
+            {host: ps.port_scan(host) for host in live})
 
     def _step_service_detection(self):
         from modules.scanner.port_scanner import PortScanner
         ps = PortScanner()
-        ports_data = self.session.results["active_recon"].get("ports", {})
         results = {}
-        for host, port_info in ports_data.items():
-            open_ports = [p for p, info in port_info.items() if info.get("state") == "open"]
+        for host, port_info in self.session.results["active_recon"].get("ports", {}).items():
+            if not isinstance(port_info, dict):
+                continue
+            open_ports = [p for p, info in port_info.items()
+                          if isinstance(info, dict) and info.get("state") == "open"]
             if open_ports:
                 results[host] = ps.service_detection(host, open_ports)
         self.session.update_results("active_recon", "services", results)
@@ -166,11 +140,14 @@ def _step_web_enum(self):
         ws = WebScanner(str(wordlist))
         results = {}
         for host, svc_info in services.items():
+            if not isinstance(svc_info, dict) or "error" in svc_info:
+                continue
             for port, info in svc_info.items():
+                if not isinstance(info, dict):
+                    continue
                 if port in ("80", "443", "8080", "8443") or info.get("name") in ("http", "https", "ssl/http"):
                     scheme = "https" if port in ("443", "8443") else "http"
-                    url = f"{scheme}://{host}:{port}"
-                    results[url] = ws.full_scan(url)
+                    results[f"{scheme}://{host}:{port}"] = ws.full_scan(f"{scheme}://{host}:{port}")
         self.session.update_results("active_recon", "web_enum", results)
 
     def _step_smb_enum(self):
@@ -179,6 +156,8 @@ def _step_smb_enum(self):
         ss = ServiceScanner()
         results = {}
         for host, svc_info in services.items():
+            if not isinstance(svc_info, dict) or "error" in svc_info:
+                continue
             if "445" in svc_info or "139" in svc_info:
                 results[host] = ss.smb_enum(host)
         self.session.update_results("active_recon", "smb", results)
@@ -189,6 +168,8 @@ def _step_ldap_enum(self):
         ss = ServiceScanner()
         results = {}
         for host, svc_info in services.items():
+            if not isinstance(svc_info, dict) or "error" in svc_info:
+                continue
             if "389" in svc_info or "636" in svc_info:
                 results[host] = ss.ldap_enum(host)
         self.session.update_results("active_recon", "ldap", results)
@@ -199,11 +180,7 @@ def _run_ai_analysis(self):
         console.print(Rule("[bold magenta]AI Analysis[/bold magenta]"))
         try:
             from modules.ai.analyzer import AIAnalyzer
-            analyzer = AIAnalyzer()
-            analysis = analyzer.analyze(
-                str(self.session.target),
-                self.session.results,
-            )
+            analysis = AIAnalyzer().analyze(str(self.session.target), self.session.results)
             self.session.update_results("ai_analysis", "findings", analysis)
             console.print("[green]  ✓ AI analysis complete[/green]")
         except Exception as exc:
@@ -214,8 +191,7 @@ def _generate_reports(self):
         console.print(Rule("[bold blue]Generating Reports[/bold blue]"))
         try:
             from reporting.generator import ReportGenerator
-            gen = ReportGenerator(self.session)
-            gen.generate()
+            ReportGenerator(self.session, lang=self.lang, no_pdf=self.no_pdf, no_html=self.no_html).generate()
             console.print(f"[green]  ✓ Reports saved to: {self.session.output_dir}[/green]")
         except Exception as exc:
             logger.warning(f"Report generation failed: {exc}")
@@ -226,37 +202,38 @@ def _print_summary(self):
         console.print(Rule("[bold green]Scan Summary[/bold green]"))
         ai = self.session.results.get("ai_analysis", {}).get("findings", {})
         score = ai.get("attack_surface_score", "N/A")
-        summary = ai.get("executive_summary", "No AI summary available.")
 
         table = Table(show_header=True, header_style="bold cyan")
         table.add_column("Metric", style="cyan")
         table.add_column("Value", style="white")
 
         duration = self.session.results.get("scan_duration_seconds", 0)
-        passive = self.session.results.get("passive_recon", {})
         active = self.session.results.get("active_recon", {})
+        passive = self.session.results.get("passive_recon", {})
 
-        dns_records = sum(
-            len(v) for v in passive.get("dns", {}).values() if isinstance(v, list)
-        )
-        live_hosts = len(active.get("live_hosts", [self.session.target.value]))
+        live_hosts = active.get("live_hosts", [self.session.target.value])
         open_ports = sum(
-            len([p for p, i in ports.items() if i.get("state") == "open"])
-            for ports in active.get("ports", {}).values()
+            1 for ports in active.get("ports", {}).values()
+            if isinstance(ports, dict)
+            for p, i in ports.items()
+            if isinstance(i, dict) and i.get("state") == "open"
         )
-        subdomains = len(passive.get("subdomains", []))
+        dns_count = sum(len(v) for v in passive.get("dns", {}).values() if isinstance(v, list))
+        findings = ai.get("critical_findings", [])
+        crit = sum(1 for f in findings if f.get("severity") == "Critical")
+        high = sum(1 for f in findings if f.get("severity") == "High")
+
+        score_str = f"[bold red]{score}[/bold red]" if isinstance(score, int) and score >= 60 else str(score)
 
         table.add_row("Duration", f"{duration:.1f}s")
-        table.add_row("Live hosts", str(live_hosts))
+        table.add_row("Live hosts", str(len(live_hosts)))
         table.add_row("Open ports", str(open_ports))
-        table.add_row("DNS records", str(dns_records))
-        table.add_row("Subdomains found", str(subdomains))
-        table.add_row("Attack surface score", f"[bold red]{score}[/bold red]" if isinstance(score, int) and score >= 60 else str(score))
+        table.add_row("DNS records", str(dns_count))
+        table.add_row("Subdomains found", str(len(passive.get("subdomains", []))))
+        table.add_row("Findings", f"{len(findings)} total ({crit} critical, {high} high)")
+        table.add_row("Attack surface score", score_str)
+        table.add_row("Reports", str(self.session.output_dir))
 
         console.print(table)
-        console.print(
-            Panel(summary, title="[bold]Executive Summary[/bold]", border_style="green")
-        )
-        console.print(
-            f"\n[bold green]Output directory:[/bold green] {self.session.output_dir}"
-        )
+        summary = ai.get("executive_summary", "No AI summary available.")
+        console.print(Panel(summary, title="[bold]Executive Summary[/bold]", border_style="green"))