Method _run_tls_audit

recon_engine.py:281–337

(self, target: str)

                        logger.error(f"Recon runner {rt.value} raised in {scan_id}: {exc}\n{traceback.format_exc()}")
                        result = ReconResult(
                            recon_type=rt,
                            target=target,
                            status="error",
                            error_message=str(exc),
                        )
                    state.results[rt] = result
        except TimeoutError:
            state.error_message = f"engine timeout after {timeout}s"
            logger.warning(f"Recon scan {scan_id} hit engine timeout")
        except Exception as exc:
            import traceback
            state.error_message = str(exc)
            logger.error(f"Recon scan {scan_id} engine failed: {exc}\n{traceback.format_exc()}")

        state.status = "completed"
        state.completed_at = datetime.now()
        self._scan_history.append(scan_id)

    def _run_port_scan(self, target: str) -> ReconResult:
        """Discover open web/management ports on the target and classify each as
        http vs https (via a TLS handshake). The result feeds the handoff gate,
        so the operator can point ZAP at the port(s) that are actually up instead
        of guessing 80/443. Lightweight parallel TCP connect — no nmap needed."""
        result = ReconResult(recon_type=ReconType.PORT_SCAN, target=target)
        started = time.monotonic()
        host, _ = _split_host_port(target, default_port=80)
        try:
            server_hostname = None if _is_ip(host) else host
        except Exception:
            server_hostname = host

        open_ports: List[Dict[str, Any]] = []
        lock = threading.Lock()

        def probe(port: int):
            try:
                raw = socket.create_connection((host, port), timeout=2.5)
            except Exception:
                return  # closed / filtered
            scheme = "http"
            try:
                ctx = ssl.create_default_context()
                ctx.check_hostname = False
                ctx.verify_mode = ssl.CERT_NONE
                tls = ctx.wrap_socket(raw, server_hostname=server_hostname)
                scheme = "https"
                try:
                    tls.close()
                except Exception:
                    pass
            except Exception:
                try:
                    raw.close()
                except Exception:
                    pass
            with lock:
                open_ports.append({"port": port, "scheme": scheme,
                                   "url": f"{scheme}://{host}:{port}"})