Method _run_check

modules/exploit_engine/runner.py:195–238

(
        self, ref: MSFModuleRef, target: str, port: int, extra: dict
    )

    async def _ensure_connected(self) -> bool:
        if not self._connected:
            self._connected = await self._msf.connect()
        return self._connected

    async def _run_check(
        self, ref: MSFModuleRef, target: str, port: int, extra: dict
    ) -> ExploitResult:
        try:
            if not await self._ensure_connected():
                return ExploitResult(
                    cve_id=ref.cve_id, target=target, port=port,
                    module_path=ref.module_path, status="ERROR",
                    error="Cannot connect to Metasploit RPC. Is msfrpcd running?",
                )

            options = {**ref.default_options, "RHOSTS": target, "RPORT": port, **extra}
            logger.info(f"[CHECK] {ref.module_path} → {target}:{port} (CVE: {ref.cve_id})")

            if ref.module_type == "exploit":
                # Exploit modules: use module.check (runs check() without payload)
                raw = await self._msf._call(
                    "module.check", [ref.module_type, ref.module_path, options]
                )
                status = self._parse_check_result(raw)
            else:
                # Auxiliary modules: use module.execute + direct socket probe fallback
                # module.check does not apply to auxiliary scanners.
                # We run execute and then probe the service ourselves to confirm exposure.
                status = await self._probe_service(target, port, ref)

            logger.info(f"[CHECK RESULT] {ref.cve_id} @ {target}:{port} → {status}")

            from modules.mitre.mapper import MITREMapper  # noqa: PLC0415
            tags = MITREMapper.tag_finding(
                ref.description, "", cve_ids=[ref.cve_id], port=port
            )
            return ExploitResult(
                cve_id=ref.cve_id, target=target, port=port,
                module_path=ref.module_path, status=status,
                attack_tags=[t.to_dict() for t in tags],
            )

        except Exception as exc:
            logger.error(f"[CHECK ERROR] {ref.cve_id} @ {target}: {exc}")
            return ExploitResult(
                cve_id=ref.cve_id, target=target, port=port,
                module_path=ref.module_path, status="ERROR", error=str(exc),
            )