@intentsolutionsio/penetration-tester 2.0.0 → 3.0.4

package/skills/performing-penetration-testing/scripts/security_scanner.py

@@ -27,7 +27,6 @@ import json
 import socket
 import ssl
 import sys
-import time
 from dataclasses import asdict, dataclass, field
 from datetime import datetime, timezone
 from typing import Optional
@@ -102,11 +101,13 @@ def _log_error(message: str) -> None:
 def create_session(timeout: int = 10) -> requests.Session:
     """Create a requests session with retry logic and custom headers."""
     session = requests.Session()
-    session.headers.update({
-        "User-Agent": USER_AGENT,
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.5",
-    })
+    session.headers.update(
+        {
+            "User-Agent": USER_AGENT,
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            "Accept-Language": "en-US,en;q=0.5",
+        }
+    )
 
     retry_strategy = Retry(
         total=2,
@@ -127,6 +128,7 @@ def create_session(timeout: int = 10) -> requests.Session:
 # Check 1: Security Headers
 # ---------------------------------------------------------------------------
 
+
 def scan_security_headers(url: str, session: requests.Session) -> list[Finding]:
     """Analyze HTTP response security headers for misconfigurations and missing headers."""
     findings: list[Finding] = []
@@ -135,13 +137,15 @@ def scan_security_headers(url: str, session: requests.Session) -> list[Finding]:
     try:
         resp = session.get(url, timeout=timeout, allow_redirects=True)
     except requests.RequestException as exc:
-        findings.append(Finding(
-            check="headers",
-            severity="high",
-            title="Unable to retrieve headers",
-            detail=f"Request failed: {exc}",
-            remediation="Verify the target URL is reachable and the server is running.",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="high",
+                title="Unable to retrieve headers",
+                detail=f"Request failed: {exc}",
+                remediation="Verify the target URL is reachable and the server is running.",
+            )
+        )
         return findings
 
     headers = resp.headers
@@ -149,57 +153,66 @@ def scan_security_headers(url: str, session: requests.Session) -> list[Finding]:
     # --- Content-Security-Policy ---
     csp = headers.get("Content-Security-Policy")
     if not csp:
-        findings.append(Finding(
-            check="headers",
-            severity="high",
-            title="Missing Content-Security-Policy header",
-            detail="No CSP header was found in the response. This leaves the application "
-                   "vulnerable to cross-site scripting and data injection attacks.",
-            remediation="Implement a Content-Security-Policy header. Start with a restrictive "
-                        "policy such as \"default-src 'self'\" and expand as needed.",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="high",
+                title="Missing Content-Security-Policy header",
+                detail="No CSP header was found in the response. This leaves the application "
+                "vulnerable to cross-site scripting and data injection attacks.",
+                remediation="Implement a Content-Security-Policy header. Start with a restrictive "
+                "policy such as \"default-src 'self'\" and expand as needed.",
+            )
+        )
     else:
         if "'unsafe-inline'" in csp:
-            findings.append(Finding(
-                check="headers",
-                severity="medium",
-                title="CSP allows unsafe-inline",
-                detail=f"The Content-Security-Policy contains 'unsafe-inline', which weakens "
-                       f"XSS protections. Value: {csp[:200]}",
-                remediation="Replace 'unsafe-inline' with nonce-based or hash-based CSP directives.",
-            ))
+            findings.append(
+                Finding(
+                    check="headers",
+                    severity="medium",
+                    title="CSP allows unsafe-inline",
+                    detail=f"The Content-Security-Policy contains 'unsafe-inline', which weakens "
+                    f"XSS protections. Value: {csp[:200]}",
+                    remediation="Replace 'unsafe-inline' with nonce-based or hash-based CSP directives.",
+                )
+            )
         if "'unsafe-eval'" in csp:
-            findings.append(Finding(
-                check="headers",
-                severity="medium",
-                title="CSP allows unsafe-eval",
-                detail=f"The Content-Security-Policy contains 'unsafe-eval', allowing dynamic "
-                       f"code execution. Value: {csp[:200]}",
-                remediation="Remove 'unsafe-eval' from CSP and refactor code to avoid eval().",
-            ))
+            findings.append(
+                Finding(
+                    check="headers",
+                    severity="medium",
+                    title="CSP allows unsafe-eval",
+                    detail=f"The Content-Security-Policy contains 'unsafe-eval', allowing dynamic "
+                    f"code execution. Value: {csp[:200]}",
+                    remediation="Remove 'unsafe-eval' from CSP and refactor code to avoid eval().",
+                )
+            )
         if "default-src" not in csp and "script-src" not in csp:
-            findings.append(Finding(
-                check="headers",
-                severity="medium",
-                title="CSP missing default-src or script-src directive",
-                detail="The CSP header does not define a default-src or script-src directive, "
-                       "which may leave resource loading unrestricted.",
-                remediation="Add a 'default-src' directive as a fallback for all resource types.",
-            ))
+            findings.append(
+                Finding(
+                    check="headers",
+                    severity="medium",
+                    title="CSP missing default-src or script-src directive",
+                    detail="The CSP header does not define a default-src or script-src directive, "
+                    "which may leave resource loading unrestricted.",
+                    remediation="Add a 'default-src' directive as a fallback for all resource types.",
+                )
+            )
 
     # --- Strict-Transport-Security ---
     hsts = headers.get("Strict-Transport-Security")
     if not hsts:
         severity = "high" if url.startswith("https") else "medium"
-        findings.append(Finding(
-            check="headers",
-            severity=severity,
-            title="Missing Strict-Transport-Security (HSTS) header",
-            detail="The server does not send an HSTS header. Clients may connect over "
-                   "insecure HTTP, enabling man-in-the-middle attacks.",
-            remediation="Add the header: Strict-Transport-Security: max-age=31536000; "
-                        "includeSubDomains; preload",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity=severity,
+                title="Missing Strict-Transport-Security (HSTS) header",
+                detail="The server does not send an HSTS header. Clients may connect over "
+                "insecure HTTP, enabling man-in-the-middle attacks.",
+                remediation="Add the header: Strict-Transport-Security: max-age=31536000; includeSubDomains; preload",
+            )
+        )
     else:
         hsts_lower = hsts.lower()
         # Check max-age value
@@ -212,117 +225,136 @@ def scan_security_headers(url: str, session: requests.Session) -> list[Finding]:
                 except ValueError:
                     max_age_val = 0
         if max_age_val < 31536000:
-            findings.append(Finding(
-                check="headers",
-                severity="medium",
-                title="HSTS max-age is too short",
-                detail=f"HSTS max-age is {max_age_val} seconds (recommended minimum is "
-                       f"31536000 / 1 year). Current value: {hsts}",
-                remediation="Set max-age to at least 31536000 (one year).",
-            ))
+            findings.append(
+                Finding(
+                    check="headers",
+                    severity="medium",
+                    title="HSTS max-age is too short",
+                    detail=f"HSTS max-age is {max_age_val} seconds (recommended minimum is "
+                    f"31536000 / 1 year). Current value: {hsts}",
+                    remediation="Set max-age to at least 31536000 (one year).",
+                )
+            )
         if "includesubdomains" not in hsts_lower:
-            findings.append(Finding(
-                check="headers",
-                severity="low",
-                title="HSTS missing includeSubDomains directive",
-                detail=f"The HSTS header does not include the includeSubDomains directive. "
-                       f"Subdomains may still be accessed over HTTP. Value: {hsts}",
-                remediation="Add 'includeSubDomains' to the HSTS header.",
-            ))
+            findings.append(
+                Finding(
+                    check="headers",
+                    severity="low",
+                    title="HSTS missing includeSubDomains directive",
+                    detail=f"The HSTS header does not include the includeSubDomains directive. "
+                    f"Subdomains may still be accessed over HTTP. Value: {hsts}",
+                    remediation="Add 'includeSubDomains' to the HSTS header.",
+                )
+            )
 
     # --- X-Frame-Options ---
     xfo = headers.get("X-Frame-Options")
     if not xfo:
         # Only flag if CSP frame-ancestors is also missing
         if not csp or "frame-ancestors" not in (csp or ""):
-            findings.append(Finding(
-                check="headers",
-                severity="medium",
-                title="Missing X-Frame-Options header",
-                detail="Neither X-Frame-Options nor CSP frame-ancestors is set. "
-                       "The page may be embedded in frames, enabling clickjacking.",
-                remediation="Set X-Frame-Options to DENY or SAMEORIGIN, or use CSP "
-                            "frame-ancestors directive.",
-            ))
+            findings.append(
+                Finding(
+                    check="headers",
+                    severity="medium",
+                    title="Missing X-Frame-Options header",
+                    detail="Neither X-Frame-Options nor CSP frame-ancestors is set. "
+                    "The page may be embedded in frames, enabling clickjacking.",
+                    remediation="Set X-Frame-Options to DENY or SAMEORIGIN, or use CSP frame-ancestors directive.",
+                )
+            )
 
     # --- X-Content-Type-Options ---
     xcto = headers.get("X-Content-Type-Options")
     if not xcto:
-        findings.append(Finding(
-            check="headers",
-            severity="medium",
-            title="Missing X-Content-Type-Options header",
-            detail="Without this header, browsers may MIME-sniff responses, potentially "
-                   "interpreting files as executable content.",
-            remediation="Set the header: X-Content-Type-Options: nosniff",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="medium",
+                title="Missing X-Content-Type-Options header",
+                detail="Without this header, browsers may MIME-sniff responses, potentially "
+                "interpreting files as executable content.",
+                remediation="Set the header: X-Content-Type-Options: nosniff",
+            )
+        )
     elif xcto.strip().lower() != "nosniff":
-        findings.append(Finding(
-            check="headers",
-            severity="medium",
-            title="X-Content-Type-Options has unexpected value",
-            detail=f"Expected 'nosniff' but got '{xcto}'. The header may not function correctly.",
-            remediation="Set the value to exactly 'nosniff'.",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="medium",
+                title="X-Content-Type-Options has unexpected value",
+                detail=f"Expected 'nosniff' but got '{xcto}'. The header may not function correctly.",
+                remediation="Set the value to exactly 'nosniff'.",
+            )
+        )
 
     # --- Referrer-Policy ---
     rp = headers.get("Referrer-Policy")
     if not rp:
-        findings.append(Finding(
-            check="headers",
-            severity="low",
-            title="Missing Referrer-Policy header",
-            detail="Without a Referrer-Policy, the browser sends the full URL as referrer "
-                   "to other sites, potentially leaking sensitive URL parameters.",
-            remediation="Set Referrer-Policy to 'strict-origin-when-cross-origin' or 'no-referrer'.",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="low",
+                title="Missing Referrer-Policy header",
+                detail="Without a Referrer-Policy, the browser sends the full URL as referrer "
+                "to other sites, potentially leaking sensitive URL parameters.",
+                remediation="Set Referrer-Policy to 'strict-origin-when-cross-origin' or 'no-referrer'.",
+            )
+        )
 
     # --- Permissions-Policy ---
     pp = headers.get("Permissions-Policy")
     if not pp:
-        findings.append(Finding(
-            check="headers",
-            severity="low",
-            title="Missing Permissions-Policy header",
-            detail="No Permissions-Policy header found. Browser features like camera, "
-                   "microphone, and geolocation are not explicitly restricted.",
-            remediation="Add a Permissions-Policy header to restrict unnecessary browser features, "
-                        "e.g., Permissions-Policy: camera=(), microphone=(), geolocation=()",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="low",
+                title="Missing Permissions-Policy header",
+                detail="No Permissions-Policy header found. Browser features like camera, "
+                "microphone, and geolocation are not explicitly restricted.",
+                remediation="Add a Permissions-Policy header to restrict unnecessary browser features, "
+                "e.g., Permissions-Policy: camera=(), microphone=(), geolocation=()",
+            )
+        )
 
     # --- X-XSS-Protection (deprecated) ---
     xxp = headers.get("X-XSS-Protection")
     if xxp:
-        findings.append(Finding(
-            check="headers",
-            severity="info",
-            title="X-XSS-Protection header present (deprecated)",
-            detail=f"The X-XSS-Protection header is set to '{xxp}'. This header is deprecated "
-                   f"in modern browsers and the XSS auditor has been removed. Relying on it "
-                   f"provides a false sense of security.",
-            remediation="Remove X-XSS-Protection and rely on a strong Content-Security-Policy instead.",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="info",
+                title="X-XSS-Protection header present (deprecated)",
+                detail=f"The X-XSS-Protection header is set to '{xxp}'. This header is deprecated "
+                f"in modern browsers and the XSS auditor has been removed. Relying on it "
+                f"provides a false sense of security.",
+                remediation="Remove X-XSS-Protection and rely on a strong Content-Security-Policy instead.",
+            )
+        )
 
     # --- Server header version disclosure ---
     server = headers.get("Server")
     if server and any(ch.isdigit() for ch in server):
-        findings.append(Finding(
-            check="headers",
-            severity="low",
-            title="Server header discloses version information",
-            detail=f"The Server header value '{server}' contains version numbers, "
-                   f"which aids attackers in identifying known vulnerabilities.",
-            remediation="Configure the web server to suppress or generalize the Server header.",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="low",
+                title="Server header discloses version information",
+                detail=f"The Server header value '{server}' contains version numbers, "
+                f"which aids attackers in identifying known vulnerabilities.",
+                remediation="Configure the web server to suppress or generalize the Server header.",
+            )
+        )
 
     if not findings:
-        findings.append(Finding(
-            check="headers",
-            severity="info",
-            title="All recommended security headers are present",
-            detail="The response includes the standard set of security headers.",
-            remediation="Continue monitoring headers as security best practices evolve.",
-        ))
+        findings.append(
+            Finding(
+                check="headers",
+                severity="info",
+                title="All recommended security headers are present",
+                detail="The response includes the standard set of security headers.",
+                remediation="Continue monitoring headers as security best practices evolve.",
+            )
+        )
 
     return findings
 
@@ -331,20 +363,23 @@ def scan_security_headers(url: str, session: requests.Session) -> list[Finding]:
 # Check 2: SSL/TLS Certificate
 # ---------------------------------------------------------------------------
 
+
 def check_ssl_tls(url: str) -> list[Finding]:
     """Validate SSL/TLS certificate properties for the target host."""
     findings: list[Finding] = []
     parsed = urlparse(url)
 
     if parsed.scheme != "https":
-        findings.append(Finding(
-            check="ssl",
-            severity="high",
-            title="Target does not use HTTPS",
-            detail=f"The target URL uses the '{parsed.scheme}' scheme. All traffic "
-                   f"is transmitted in plaintext, vulnerable to interception.",
-            remediation="Configure the server to use HTTPS with a valid TLS certificate.",
-        ))
+        findings.append(
+            Finding(
+                check="ssl",
+                severity="high",
+                title="Target does not use HTTPS",
+                detail=f"The target URL uses the '{parsed.scheme}' scheme. All traffic "
+                f"is transmitted in plaintext, vulnerable to interception.",
+                remediation="Configure the server to use HTTPS with a valid TLS certificate.",
+            )
+        )
         return findings
 
     hostname = parsed.hostname or ""
@@ -359,32 +394,38 @@ def check_ssl_tls(url: str) -> list[Finding]:
                 protocol_version = tls_sock.version()
 
                 if not cert:
-                    findings.append(Finding(
-                        check="ssl",
-                        severity="critical",
-                        title="No certificate returned by server",
-                        detail="The TLS handshake completed but no certificate was presented.",
-                        remediation="Ensure the server is configured with a valid TLS certificate.",
-                    ))
+                    findings.append(
+                        Finding(
+                            check="ssl",
+                            severity="critical",
+                            title="No certificate returned by server",
+                            detail="The TLS handshake completed but no certificate was presented.",
+                            remediation="Ensure the server is configured with a valid TLS certificate.",
+                        )
+                    )
                     return findings
 
                 # Protocol version
                 if protocol_version:
-                    findings.append(Finding(
-                        check="ssl",
-                        severity="info",
-                        title=f"TLS protocol version: {protocol_version}",
-                        detail=f"The server negotiated {protocol_version}.",
-                        remediation="Ensure TLS 1.2 or higher is used; disable TLS 1.0 and 1.1.",
-                    ))
-                    if protocol_version in ("TLSv1", "TLSv1.1"):
-                        findings.append(Finding(
+                    findings.append(
+                        Finding(
                             check="ssl",
-                            severity="high",
-                            title=f"Outdated TLS protocol: {protocol_version}",
-                            detail=f"{protocol_version} is deprecated and has known vulnerabilities.",
-                            remediation="Disable TLS 1.0 and TLS 1.1. Use TLS 1.2 or TLS 1.3.",
-                        ))
+                            severity="info",
+                            title=f"TLS protocol version: {protocol_version}",
+                            detail=f"The server negotiated {protocol_version}.",
+                            remediation="Ensure TLS 1.2 or higher is used; disable TLS 1.0 and 1.1.",
+                        )
+                    )
+                    if protocol_version in ("TLSv1", "TLSv1.1"):
+                        findings.append(
+                            Finding(
+                                check="ssl",
+                                severity="high",
+                                title=f"Outdated TLS protocol: {protocol_version}",
+                                detail=f"{protocol_version} is deprecated and has known vulnerabilities.",
+                                remediation="Disable TLS 1.0 and TLS 1.1. Use TLS 1.2 or TLS 1.3.",
+                            )
+                        )
 
                 # Certificate expiry
                 not_after_str = cert.get("notAfter", "")
@@ -397,48 +438,58 @@ def check_ssl_tls(url: str) -> list[Finding]:
                         days_remaining = (not_after - now).days
 
                         if days_remaining < 0:
-                            findings.append(Finding(
-                                check="ssl",
-                                severity="critical",
-                                title="SSL certificate has expired",
-                                detail=f"The certificate expired on {not_after_str} "
-                                       f"({abs(days_remaining)} days ago).",
-                                remediation="Renew the SSL/TLS certificate immediately.",
-                            ))
+                            findings.append(
+                                Finding(
+                                    check="ssl",
+                                    severity="critical",
+                                    title="SSL certificate has expired",
+                                    detail=f"The certificate expired on {not_after_str} "
+                                    f"({abs(days_remaining)} days ago).",
+                                    remediation="Renew the SSL/TLS certificate immediately.",
+                                )
+                            )
                         elif days_remaining < 7:
-                            findings.append(Finding(
-                                check="ssl",
-                                severity="critical",
-                                title=f"SSL certificate expires in {days_remaining} days",
-                                detail=f"The certificate expires on {not_after_str}. "
-                                       f"Immediate renewal is required.",
-                                remediation="Renew the SSL/TLS certificate before expiry.",
-                            ))
+                            findings.append(
+                                Finding(
+                                    check="ssl",
+                                    severity="critical",
+                                    title=f"SSL certificate expires in {days_remaining} days",
+                                    detail=f"The certificate expires on {not_after_str}. "
+                                    f"Immediate renewal is required.",
+                                    remediation="Renew the SSL/TLS certificate before expiry.",
+                                )
+                            )
                         elif days_remaining < 30:
-                            findings.append(Finding(
-                                check="ssl",
-                                severity="high",
-                                title=f"SSL certificate expires in {days_remaining} days",
-                                detail=f"The certificate expires on {not_after_str}. "
-                                       f"Plan renewal soon to avoid service disruption.",
-                                remediation="Renew the SSL/TLS certificate within the next two weeks.",
-                            ))
+                            findings.append(
+                                Finding(
+                                    check="ssl",
+                                    severity="high",
+                                    title=f"SSL certificate expires in {days_remaining} days",
+                                    detail=f"The certificate expires on {not_after_str}. "
+                                    f"Plan renewal soon to avoid service disruption.",
+                                    remediation="Renew the SSL/TLS certificate within the next two weeks.",
+                                )
+                            )
                         else:
-                            findings.append(Finding(
-                                check="ssl",
-                                severity="info",
-                                title=f"SSL certificate valid for {days_remaining} days",
-                                detail=f"The certificate expires on {not_after_str}.",
-                                remediation="Monitor certificate expiry and renew before it lapses.",
-                            ))
+                            findings.append(
+                                Finding(
+                                    check="ssl",
+                                    severity="info",
+                                    title=f"SSL certificate valid for {days_remaining} days",
+                                    detail=f"The certificate expires on {not_after_str}.",
+                                    remediation="Monitor certificate expiry and renew before it lapses.",
+                                )
+                            )
                     except ValueError:
-                        findings.append(Finding(
-                            check="ssl",
-                            severity="medium",
-                            title="Unable to parse certificate expiry date",
-                            detail=f"Certificate notAfter value: '{not_after_str}' could not be parsed.",
-                            remediation="Manually verify the certificate expiry date.",
-                        ))
+                        findings.append(
+                            Finding(
+                                check="ssl",
+                                severity="medium",
+                                title="Unable to parse certificate expiry date",
+                                detail=f"Certificate notAfter value: '{not_after_str}' could not be parsed.",
+                                remediation="Manually verify the certificate expiry date.",
+                            )
+                        )
 
                 # Subject and issuer info
                 subject_parts = []
@@ -453,60 +504,72 @@ def check_ssl_tls(url: str) -> list[Finding]:
                         issuer_parts.append(f"{attr_name}={attr_value}")
                 issuer_str = ", ".join(issuer_parts) if issuer_parts else "unknown"
 
-                findings.append(Finding(
-                    check="ssl",
-                    severity="info",
-                    title="Certificate subject and issuer",
-                    detail=f"Subject: {subject_str} | Issuer: {issuer_str}",
-                    remediation="Verify the certificate is issued by a trusted certificate authority.",
-                ))
+                findings.append(
+                    Finding(
+                        check="ssl",
+                        severity="info",
+                        title="Certificate subject and issuer",
+                        detail=f"Subject: {subject_str} | Issuer: {issuer_str}",
+                        remediation="Verify the certificate is issued by a trusted certificate authority.",
+                    )
+                )
 
                 # SAN (Subject Alternative Names)
                 san_list = cert.get("subjectAltName", ())
                 san_names = [val for typ, val in san_list if typ == "DNS"]
                 if san_names:
-                    findings.append(Finding(
-                        check="ssl",
-                        severity="info",
-                        title=f"Certificate covers {len(san_names)} domain(s)",
-                        detail=f"SANs: {', '.join(san_names[:10])}"
-                               + (f" ... and {len(san_names) - 10} more" if len(san_names) > 10 else ""),
-                        remediation="Ensure all required domains are listed in the certificate SANs.",
-                    ))
+                    findings.append(
+                        Finding(
+                            check="ssl",
+                            severity="info",
+                            title=f"Certificate covers {len(san_names)} domain(s)",
+                            detail=f"SANs: {', '.join(san_names[:10])}"
+                            + (f" ... and {len(san_names) - 10} more" if len(san_names) > 10 else ""),
+                            remediation="Ensure all required domains are listed in the certificate SANs.",
+                        )
+                    )
 
     except ssl.SSLCertVerificationError as exc:
-        findings.append(Finding(
-            check="ssl",
-            severity="critical",
-            title="SSL certificate verification failed",
-            detail=f"Certificate validation error: {exc}",
-            remediation="Replace the certificate with one issued by a trusted CA. "
-                        "Ensure the certificate chain is complete.",
-        ))
+        findings.append(
+            Finding(
+                check="ssl",
+                severity="critical",
+                title="SSL certificate verification failed",
+                detail=f"Certificate validation error: {exc}",
+                remediation="Replace the certificate with one issued by a trusted CA. "
+                "Ensure the certificate chain is complete.",
+            )
+        )
     except ssl.SSLError as exc:
-        findings.append(Finding(
-            check="ssl",
-            severity="high",
-            title="SSL/TLS connection error",
-            detail=f"TLS handshake failed: {exc}",
-            remediation="Check the server TLS configuration and ensure modern cipher suites are enabled.",
-        ))
+        findings.append(
+            Finding(
+                check="ssl",
+                severity="high",
+                title="SSL/TLS connection error",
+                detail=f"TLS handshake failed: {exc}",
+                remediation="Check the server TLS configuration and ensure modern cipher suites are enabled.",
+            )
+        )
     except socket.timeout:
-        findings.append(Finding(
-            check="ssl",
-            severity="medium",
-            title="SSL connection timed out",
-            detail="The TLS handshake did not complete within 10 seconds.",
-            remediation="Verify the server is reachable and TLS is properly configured.",
-        ))
+        findings.append(
+            Finding(
+                check="ssl",
+                severity="medium",
+                title="SSL connection timed out",
+                detail="The TLS handshake did not complete within 10 seconds.",
+                remediation="Verify the server is reachable and TLS is properly configured.",
+            )
+        )
     except OSError as exc:
-        findings.append(Finding(
-            check="ssl",
-            severity="high",
-            title="Unable to establish SSL connection",
-            detail=f"Connection error: {exc}",
-            remediation="Verify the hostname, port, and network connectivity.",
-        ))
+        findings.append(
+            Finding(
+                check="ssl",
+                severity="high",
+                title="Unable to establish SSL connection",
+                detail=f"Connection error: {exc}",
+                remediation="Verify the hostname, port, and network connectivity.",
+            )
+        )
 
     return findings
 
@@ -552,25 +615,29 @@ def probe_common_exposures(url: str, session: requests.Session) -> list[Finding]
                 # Verify it is not a generic error page or redirect by checking content length
                 content_length = len(resp.content)
                 if content_length > 0:
-                    findings.append(Finding(
-                        check="endpoints",
-                        severity=severity,
-                        title=f"Exposed: {description} ({path})",
-                        detail=f"HTTP 200 returned for {target} with {content_length} bytes. "
-                               f"This resource should not be publicly accessible.",
-                        remediation=f"Block access to {path} via web server configuration. "
-                                    f"Return 403 or 404 for this path.",
-                    ))
+                    findings.append(
+                        Finding(
+                            check="endpoints",
+                            severity=severity,
+                            title=f"Exposed: {description} ({path})",
+                            detail=f"HTTP 200 returned for {target} with {content_length} bytes. "
+                            f"This resource should not be publicly accessible.",
+                            remediation=f"Block access to {path} via web server configuration. "
+                            f"Return 403 or 404 for this path.",
+                        )
+                    )
             elif resp.status_code in (401, 403):
-                findings.append(Finding(
-                    check="endpoints",
-                    severity="info",
-                    title=f"Path exists but access denied: {path}",
-                    detail=f"HTTP {resp.status_code} returned for {target}. "
-                           f"The path exists but requires authentication.",
-                    remediation=f"Consider returning 404 instead of {resp.status_code} "
-                                f"to avoid confirming the path exists.",
-                ))
+                findings.append(
+                    Finding(
+                        check="endpoints",
+                        severity="info",
+                        title=f"Path exists but access denied: {path}",
+                        detail=f"HTTP {resp.status_code} returned for {target}. "
+                        f"The path exists but requires authentication.",
+                        remediation=f"Consider returning 404 instead of {resp.status_code} "
+                        f"to avoid confirming the path exists.",
+                    )
+                )
         except requests.RequestException:
             # Silently skip unreachable paths
             continue
@@ -579,14 +646,16 @@ def probe_common_exposures(url: str, session: requests.Session) -> list[Finding]
     try:
         resp = session.get(base + "/robots.txt", timeout=timeout, allow_redirects=True)
         if resp.status_code == 200 and "disallow" in resp.text.lower():
-            findings.append(Finding(
-                check="endpoints",
-                severity="info",
-                title="robots.txt found",
-                detail=f"The robots.txt file is accessible at {base}/robots.txt.",
-                remediation="Review robots.txt entries. Disallowed paths may reveal "
-                            "sensitive directories that warrant additional access controls.",
-            ))
+            findings.append(
+                Finding(
+                    check="endpoints",
+                    severity="info",
+                    title="robots.txt found",
+                    detail=f"The robots.txt file is accessible at {base}/robots.txt.",
+                    remediation="Review robots.txt entries. Disallowed paths may reveal "
+                    "sensitive directories that warrant additional access controls.",
+                )
+            )
             # Parse interesting disallows
             interesting_disallows = []
             for line in resp.text.splitlines():
@@ -595,21 +664,35 @@ def probe_common_exposures(url: str, session: requests.Session) -> list[Finding]
                     path_part = line.strip().split(":", 1)[1].strip()
                     if path_part and path_part != "/":
                         sensitive_keywords = [
-                            "admin", "api", "config", "backup", "private",
-                            "internal", "secret", "debug", "staging", "test",
-                            "tmp", "upload", "database", "db", "cgi-bin",
+                            "admin",
+                            "api",
+                            "config",
+                            "backup",
+                            "private",
+                            "internal",
+                            "secret",
+                            "debug",
+                            "staging",
+                            "test",
+                            "tmp",
+                            "upload",
+                            "database",
+                            "db",
+                            "cgi-bin",
                         ]
                         if any(kw in path_part.lower() for kw in sensitive_keywords):
                             interesting_disallows.append(path_part)
             if interesting_disallows:
-                findings.append(Finding(
-                    check="endpoints",
-                    severity="low",
-                    title="robots.txt reveals potentially sensitive paths",
-                    detail=f"Interesting disallowed paths: {', '.join(interesting_disallows[:10])}",
-                    remediation="Ensure disallowed paths have proper access controls beyond "
-                                "robots.txt, which is advisory only and publicly readable.",
-                ))
+                findings.append(
+                    Finding(
+                        check="endpoints",
+                        severity="low",
+                        title="robots.txt reveals potentially sensitive paths",
+                        detail=f"Interesting disallowed paths: {', '.join(interesting_disallows[:10])}",
+                        remediation="Ensure disallowed paths have proper access controls beyond "
+                        "robots.txt, which is advisory only and publicly readable.",
+                    )
+                )
     except requests.RequestException:
         pass
 
@@ -618,14 +701,16 @@ def probe_common_exposures(url: str, session: requests.Session) -> list[Finding]
         try:
             resp = session.get(base + sec_path, timeout=timeout, allow_redirects=True)
             if resp.status_code == 200 and "contact:" in resp.text.lower():
-                findings.append(Finding(
-                    check="endpoints",
-                    severity="info",
-                    title="security.txt found",
-                    detail=f"A security.txt file is accessible at {base}{sec_path}. "
-                           f"This is a good security practice (RFC 9116).",
-                    remediation="Ensure the security.txt contact information is current.",
-                ))
+                findings.append(
+                    Finding(
+                        check="endpoints",
+                        severity="info",
+                        title="security.txt found",
+                        detail=f"A security.txt file is accessible at {base}{sec_path}. "
+                        f"This is a good security practice (RFC 9116).",
+                        remediation="Ensure the security.txt contact information is current.",
+                    )
+                )
                 break  # Only report once
         except requests.RequestException:
             continue
@@ -636,15 +721,17 @@ def probe_common_exposures(url: str, session: requests.Session) -> list[Finding]
         content_sample = resp.text[:2000] if resp.text else ""
         for indicator in _DIRECTORY_LISTING_INDICATORS:
             if indicator.lower() in content_sample.lower():
-                findings.append(Finding(
-                    check="endpoints",
-                    severity="high",
-                    title="Directory listing is enabled",
-                    detail=f"The root path appears to expose a directory listing "
-                           f"(detected indicator: '{indicator}').",
-                    remediation="Disable directory listing in the web server configuration. "
-                                "For Apache: 'Options -Indexes'. For Nginx: remove 'autoindex on'.",
-                ))
+                findings.append(
+                    Finding(
+                        check="endpoints",
+                        severity="high",
+                        title="Directory listing is enabled",
+                        detail=f"The root path appears to expose a directory listing "
+                        f"(detected indicator: '{indicator}').",
+                        remediation="Disable directory listing in the web server configuration. "
+                        "For Apache: 'Options -Indexes'. For Nginx: remove 'autoindex on'.",
+                    )
+                )
                 break
     except requests.RequestException:
         pass
@@ -655,32 +742,38 @@ def probe_common_exposures(url: str, session: requests.Session) -> list[Finding]
         server_header = resp.headers.get("Server", "")
         x_powered = resp.headers.get("X-Powered-By", "")
         if server_header and any(ch.isdigit() for ch in server_header):
-            findings.append(Finding(
-                check="endpoints",
-                severity="low",
-                title="Server version disclosure",
-                detail=f"The Server header reveals: '{server_header}'.",
-                remediation="Suppress version information in the Server header.",
-            ))
+            findings.append(
+                Finding(
+                    check="endpoints",
+                    severity="low",
+                    title="Server version disclosure",
+                    detail=f"The Server header reveals: '{server_header}'.",
+                    remediation="Suppress version information in the Server header.",
+                )
+            )
         if x_powered:
-            findings.append(Finding(
-                check="endpoints",
-                severity="low",
-                title="X-Powered-By header exposes technology stack",
-                detail=f"The X-Powered-By header reveals: '{x_powered}'.",
-                remediation="Remove the X-Powered-By header from server responses.",
-            ))
+            findings.append(
+                Finding(
+                    check="endpoints",
+                    severity="low",
+                    title="X-Powered-By header exposes technology stack",
+                    detail=f"The X-Powered-By header reveals: '{x_powered}'.",
+                    remediation="Remove the X-Powered-By header from server responses.",
+                )
+            )
     except requests.RequestException:
         pass
 
     if not findings:
-        findings.append(Finding(
-            check="endpoints",
-            severity="info",
-            title="No common exposures detected",
-            detail="None of the probed paths returned accessible content.",
-            remediation="Continue monitoring for accidental exposure of sensitive paths.",
-        ))
+        findings.append(
+            Finding(
+                check="endpoints",
+                severity="info",
+                title="No common exposures detected",
+                detail="None of the probed paths returned accessible content.",
+                remediation="Continue monitoring for accidental exposure of sensitive paths.",
+            )
+        )
 
     return findings
 
@@ -689,6 +782,7 @@ def probe_common_exposures(url: str, session: requests.Session) -> list[Finding]
 # Check 4: HTTP Methods
 # ---------------------------------------------------------------------------
 
+
 def check_http_methods(url: str, session: requests.Session) -> list[Finding]:
     """Test for enabled HTTP methods and flag potentially dangerous ones."""
     findings: list[Finding] = []
@@ -706,60 +800,77 @@ def check_http_methods(url: str, session: requests.Session) -> list[Finding]:
             methods = {m.strip().upper() for m in methods_str.split(",") if m.strip()}
             enabled_dangerous = methods & dangerous_methods
 
-            findings.append(Finding(
-                check="methods",
-                severity="info",
-                title=f"Allowed HTTP methods: {', '.join(sorted(methods))}",
-                detail=f"The server advertises these methods via the Allow or "
-                       f"Access-Control-Allow-Methods header.",
-                remediation="Restrict HTTP methods to only those required by the application.",
-            ))
+            findings.append(
+                Finding(
+                    check="methods",
+                    severity="info",
+                    title=f"Allowed HTTP methods: {', '.join(sorted(methods))}",
+                    detail="The server advertises these methods via the Allow or Access-Control-Allow-Methods header.",
+                    remediation="Restrict HTTP methods to only those required by the application.",
+                )
+            )
 
             if enabled_dangerous:
                 for method in sorted(enabled_dangerous):
                     severity = "high" if method == "TRACE" else "medium"
                     detail_msg = ""
                     if method == "TRACE":
-                        detail_msg = ("TRACE reflects the request back to the client, which "
-                                      "can be exploited in cross-site tracing (XST) attacks "
-                                      "to steal credentials from HTTP headers.")
+                        detail_msg = (
+                            "TRACE reflects the request back to the client, which "
+                            "can be exploited in cross-site tracing (XST) attacks "
+                            "to steal credentials from HTTP headers."
+                        )
                     elif method == "PUT":
-                        detail_msg = ("PUT allows uploading or replacing files on the server, "
-                                      "which may allow unauthorized content modification.")
+                        detail_msg = (
+                            "PUT allows uploading or replacing files on the server, "
+                            "which may allow unauthorized content modification."
+                        )
                     elif method == "DELETE":
-                        detail_msg = ("DELETE allows removing resources from the server, "
-                                      "which may allow unauthorized data destruction.")
+                        detail_msg = (
+                            "DELETE allows removing resources from the server, "
+                            "which may allow unauthorized data destruction."
+                        )
                     elif method == "CONNECT":
-                        detail_msg = ("CONNECT may allow the server to be used as a proxy, "
-                                      "potentially enabling unauthorized network access.")
+                        detail_msg = (
+                            "CONNECT may allow the server to be used as a proxy, "
+                            "potentially enabling unauthorized network access."
+                        )
                     elif method == "PATCH":
-                        detail_msg = ("PATCH allows partial resource modification. Ensure it "
-                                      "requires proper authentication and authorization.")
-                    findings.append(Finding(
-                        check="methods",
-                        severity=severity,
-                        title=f"Dangerous HTTP method enabled: {method}",
-                        detail=detail_msg,
-                        remediation=f"Disable the {method} method unless explicitly required. "
-                                    f"Configure the web server or application firewall to block it.",
-                    ))
+                        detail_msg = (
+                            "PATCH allows partial resource modification. Ensure it "
+                            "requires proper authentication and authorization."
+                        )
+                    findings.append(
+                        Finding(
+                            check="methods",
+                            severity=severity,
+                            title=f"Dangerous HTTP method enabled: {method}",
+                            detail=detail_msg,
+                            remediation=f"Disable the {method} method unless explicitly required. "
+                            f"Configure the web server or application firewall to block it.",
+                        )
+                    )
         else:
-            findings.append(Finding(
+            findings.append(
+                Finding(
+                    check="methods",
+                    severity="info",
+                    title="No Allow header in OPTIONS response",
+                    detail=f"The OPTIONS request returned HTTP {resp.status_code} without "
+                    f"an Allow header. Method enumeration was not possible.",
+                    remediation="This is acceptable. The server does not advertise allowed methods.",
+                )
+            )
+    except requests.RequestException as exc:
+        findings.append(
+            Finding(
                 check="methods",
                 severity="info",
-                title="No Allow header in OPTIONS response",
-                detail=f"The OPTIONS request returned HTTP {resp.status_code} without "
-                       f"an Allow header. Method enumeration was not possible.",
-                remediation="This is acceptable. The server does not advertise allowed methods.",
-            ))
-    except requests.RequestException as exc:
-        findings.append(Finding(
-            check="methods",
-            severity="info",
-            title="OPTIONS request failed",
-            detail=f"Could not perform method enumeration: {exc}",
-            remediation="OPTIONS may be blocked by a firewall or WAF, which is acceptable.",
-        ))
+                title="OPTIONS request failed",
+                detail=f"Could not perform method enumeration: {exc}",
+                remediation="OPTIONS may be blocked by a firewall or WAF, which is acceptable.",
+            )
+        )
 
     return findings
 
@@ -768,6 +879,7 @@ def check_http_methods(url: str, session: requests.Session) -> list[Finding]:
 # Check 5: CORS Policy
 # ---------------------------------------------------------------------------
 
+
 def check_cors_policy(url: str, session: requests.Session) -> list[Finding]:
     """Analyze CORS configuration for misconfigurations that allow unauthorized access."""
     findings: list[Finding] = []
@@ -783,61 +895,71 @@ def check_cors_policy(url: str, session: requests.Session) -> list[Finding]:
         acac = resp.headers.get("Access-Control-Allow-Credentials", "").lower()
 
         if not acao:
-            findings.append(Finding(
-                check="cors",
-                severity="info",
-                title="No CORS headers in response",
-                detail="The server did not return an Access-Control-Allow-Origin header. "
-                       "Cross-origin requests from browsers will be blocked by default.",
-                remediation="This is the secure default. Only add CORS headers if cross-origin "
-                            "access is intentionally required.",
-            ))
+            findings.append(
+                Finding(
+                    check="cors",
+                    severity="info",
+                    title="No CORS headers in response",
+                    detail="The server did not return an Access-Control-Allow-Origin header. "
+                    "Cross-origin requests from browsers will be blocked by default.",
+                    remediation="This is the secure default. Only add CORS headers if cross-origin "
+                    "access is intentionally required.",
+                )
+            )
         elif acao == "*":
             if acac == "true":
-                findings.append(Finding(
-                    check="cors",
-                    severity="critical",
-                    title="CORS: Wildcard origin with credentials allowed",
-                    detail="Access-Control-Allow-Origin is set to '*' and "
-                           "Access-Control-Allow-Credentials is 'true'. While browsers block "
-                           "this combination, server-side misconfiguration indicates a flawed "
-                           "CORS implementation that could be exploited.",
-                    remediation="Never combine wildcard origin with Allow-Credentials. "
-                                "Implement an origin allowlist and validate requests against it.",
-                ))
+                findings.append(
+                    Finding(
+                        check="cors",
+                        severity="critical",
+                        title="CORS: Wildcard origin with credentials allowed",
+                        detail="Access-Control-Allow-Origin is set to '*' and "
+                        "Access-Control-Allow-Credentials is 'true'. While browsers block "
+                        "this combination, server-side misconfiguration indicates a flawed "
+                        "CORS implementation that could be exploited.",
+                        remediation="Never combine wildcard origin with Allow-Credentials. "
+                        "Implement an origin allowlist and validate requests against it.",
+                    )
+                )
             else:
-                findings.append(Finding(
-                    check="cors",
-                    severity="medium",
-                    title="CORS: Wildcard origin configured",
-                    detail="Access-Control-Allow-Origin is set to '*', allowing any website "
-                           "to make cross-origin requests. If the API serves sensitive data "
-                           "or requires authentication, this is a security risk.",
-                    remediation="Replace the wildcard with specific trusted origins. "
-                                "Use an allowlist approach for cross-origin access.",
-                ))
+                findings.append(
+                    Finding(
+                        check="cors",
+                        severity="medium",
+                        title="CORS: Wildcard origin configured",
+                        detail="Access-Control-Allow-Origin is set to '*', allowing any website "
+                        "to make cross-origin requests. If the API serves sensitive data "
+                        "or requires authentication, this is a security risk.",
+                        remediation="Replace the wildcard with specific trusted origins. "
+                        "Use an allowlist approach for cross-origin access.",
+                    )
+                )
         elif acao.lower() == test_origin.lower():
             severity = "critical" if acac == "true" else "high"
             cred_note = " with credentials" if acac == "true" else ""
-            findings.append(Finding(
-                check="cors",
-                severity=severity,
-                title=f"CORS: Origin reflection detected{cred_note}",
-                detail=f"The server reflected the arbitrary origin '{test_origin}' in the "
-                       f"Access-Control-Allow-Origin header{cred_note}. This means any "
-                       f"website can make authenticated cross-origin requests.",
-                remediation="Implement a strict origin allowlist. Never reflect the Origin "
-                            "header value without validation against a list of trusted domains.",
-            ))
+            findings.append(
+                Finding(
+                    check="cors",
+                    severity=severity,
+                    title=f"CORS: Origin reflection detected{cred_note}",
+                    detail=f"The server reflected the arbitrary origin '{test_origin}' in the "
+                    f"Access-Control-Allow-Origin header{cred_note}. This means any "
+                    f"website can make authenticated cross-origin requests.",
+                    remediation="Implement a strict origin allowlist. Never reflect the Origin "
+                    "header value without validation against a list of trusted domains.",
+                )
+            )
         else:
-            findings.append(Finding(
-                check="cors",
-                severity="info",
-                title=f"CORS: Specific origin configured ({acao})",
-                detail=f"The server returned a specific origin '{acao}' in the CORS header, "
-                       f"not reflecting the test origin. This indicates proper origin validation.",
-                remediation="Periodically review the allowed origins to ensure they are still trusted.",
-            ))
+            findings.append(
+                Finding(
+                    check="cors",
+                    severity="info",
+                    title=f"CORS: Specific origin configured ({acao})",
+                    detail=f"The server returned a specific origin '{acao}' in the CORS header, "
+                    f"not reflecting the test origin. This indicates proper origin validation.",
+                    remediation="Periodically review the allowed origins to ensure they are still trusted.",
+                )
+            )
 
         # Check for overly permissive methods in preflight
         acam = resp.headers.get("Access-Control-Allow-Methods", "")
@@ -845,24 +967,28 @@ def check_cors_policy(url: str, session: requests.Session) -> list[Finding]:
             allowed_methods = {m.strip().upper() for m in acam.split(",") if m.strip()}
             risky = allowed_methods & {"PUT", "DELETE", "PATCH"}
             if risky:
-                findings.append(Finding(
-                    check="cors",
-                    severity="low",
-                    title=f"CORS allows state-changing methods: {', '.join(sorted(risky))}",
-                    detail=f"Cross-origin requests are permitted to use {', '.join(sorted(risky))} "
-                           f"methods. Ensure these endpoints have proper authentication.",
-                    remediation="Only expose the minimum set of HTTP methods required for "
-                                "legitimate cross-origin requests.",
-                ))
+                findings.append(
+                    Finding(
+                        check="cors",
+                        severity="low",
+                        title=f"CORS allows state-changing methods: {', '.join(sorted(risky))}",
+                        detail=f"Cross-origin requests are permitted to use {', '.join(sorted(risky))} "
+                        f"methods. Ensure these endpoints have proper authentication.",
+                        remediation="Only expose the minimum set of HTTP methods required for "
+                        "legitimate cross-origin requests.",
+                    )
+                )
 
     except requests.RequestException as exc:
-        findings.append(Finding(
-            check="cors",
-            severity="info",
-            title="CORS check failed",
-            detail=f"Could not perform CORS analysis: {exc}",
-            remediation="Verify the target is reachable and retry the scan.",
-        ))
+        findings.append(
+            Finding(
+                check="cors",
+                severity="info",
+                title="CORS check failed",
+                detail=f"Could not perform CORS analysis: {exc}",
+                remediation="Verify the target is reachable and retry the scan.",
+            )
+        )
 
     return findings
 
@@ -871,6 +997,7 @@ def check_cors_policy(url: str, session: requests.Session) -> list[Finding]:
 # Report Generation
 # ---------------------------------------------------------------------------
 
+
 def _calculate_risk_score(findings: list[Finding]) -> int:
     """Calculate a security risk score from 0 (worst) to 100 (best).
 
@@ -907,7 +1034,11 @@ def generate_report(
     """
     # Count findings by severity
     severity_counts: dict[str, int] = {
-        "critical": 0, "high": 0, "medium": 0, "low": 0, "info": 0,
+        "critical": 0,
+        "high": 0,
+        "medium": 0,
+        "low": 0,
+        "info": 0,
     }
     for f in results.findings:
         severity_counts[f.severity] = severity_counts.get(f.severity, 0) + 1
@@ -928,7 +1059,7 @@ def generate_report(
     # Build Markdown report
     lines: list[str] = []
     lines.append("=" * 72)
-    lines.append(f"  SECURITY SCAN REPORT")
+    lines.append("  SECURITY SCAN REPORT")
     lines.append("=" * 72)
     lines.append("")
     lines.append(f"Target:     {url}")
@@ -975,8 +1106,7 @@ def generate_report(
         lines.append("")
 
     lines.append("=" * 72)
-    lines.append(f"  End of report. {total_findings} finding(s) across "
-                 f"{len(results.checks_performed)} check(s).")
+    lines.append(f"  End of report. {total_findings} finding(s) across {len(results.checks_performed)} check(s).")
     lines.append("=" * 72)
 
     report_text = "\n".join(lines)
@@ -1011,6 +1141,7 @@ def generate_report(
 # CLI / Main
 # ---------------------------------------------------------------------------
 
+
 def main() -> int:
     """Parse arguments and execute the security scan.
 
@@ -1038,28 +1169,29 @@ def main() -> int:
         help="Target URL to scan (must include scheme, e.g., https://example.com)",
     )
     parser.add_argument(
-        "--output", "-o",
+        "--output",
+        "-o",
         metavar="FILE",
         help="Write JSON report to the specified file path",
     )
     parser.add_argument(
-        "--checks", "-c",
+        "--checks",
+        "-c",
         metavar="LIST",
         default=",".join(ALL_CHECKS),
-        help=(
-            f"Comma-separated list of checks to run. "
-            f"Available: {', '.join(ALL_CHECKS)}. Default: all"
-        ),
+        help=(f"Comma-separated list of checks to run. Available: {', '.join(ALL_CHECKS)}. Default: all"),
     )
     parser.add_argument(
-        "--timeout", "-t",
+        "--timeout",
+        "-t",
         type=int,
         default=10,
         metavar="SECONDS",
         help="Request timeout in seconds (default: 10)",
     )
     parser.add_argument(
-        "--verbose", "-v",
+        "--verbose",
+        "-v",
         action="store_true",
         help="Print progress messages to stderr",
     )
@@ -1084,8 +1216,7 @@ def main() -> int:
     requested = [c.strip().lower() for c in args.checks.split(",") if c.strip()]
     invalid_checks = [c for c in requested if c not in ALL_CHECKS]
     if invalid_checks:
-        _log_error(f"Unknown check(s): {', '.join(invalid_checks)}. "
-                   f"Available: {', '.join(ALL_CHECKS)}")
+        _log_error(f"Unknown check(s): {', '.join(invalid_checks)}. Available: {', '.join(ALL_CHECKS)}")
         return 2
 
     # Initialize
@@ -1144,8 +1275,7 @@ def main() -> int:
     result.duration_seconds = round((scan_end - scan_start).total_seconds(), 2)
 
     _log("", args.verbose)
-    _log(f"Scan complete. {len(result.findings)} finding(s) in "
-         f"{result.duration_seconds}s", args.verbose)
+    _log(f"Scan complete. {len(result.findings)} finding(s) in {result.duration_seconds}s", args.verbose)
     _log("", args.verbose)
 
     # Generate and print report
@@ -1153,9 +1283,7 @@ def main() -> int:
     print(report)
 
     # Determine exit code
-    critical_or_high = sum(
-        1 for f in result.findings if f.severity in ("critical", "high")
-    )
+    critical_or_high = sum(1 for f in result.findings if f.severity in ("critical", "high"))
     if critical_or_high > 0:
         _log(f"Exiting with code 1: {critical_or_high} critical/high finding(s)", args.verbose)
         return 1