stackscan 2.5.0__tar.gz → 2.6.0__tar.gz

{stackscan-2.5.0 → stackscan-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackscan
-Version: 2.5.0
+Version: 2.6.0
 Summary: Full web stack, infrastructure, DNS, port, subdomain and CVE analyzer.
 Project-URL: Source, https://github.com/reekeer/stackscan
 Project-URL: Issues, https://github.com/reekeer/stackscan/issues

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/__init__.py

@@ -2,4 +2,4 @@ from .core import StackscanSession
 from .utils import normalize_url
 
 __all__ = ["StackscanSession", "__version__", "normalize_url"]
-__version__ = "2.5.0"
+__version__ = "2.6.0"

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/analyzers/osdetect.py

@@ -106,9 +106,7 @@ def detect_os(report: ScanReport) -> list[OsFinding]:
         for os, src in pairs:
             by_source.setdefault(src, []).append(os)
         dominant_source = max(by_source, key=lambda s: len(by_source[s]))
-        if dominant_source == "port-banner" or dominant_source.startswith(
-            ("header:", "meta:", "script")
-        ):
+        if dominant_source == "port-banner" or dominant_source.startswith(("header:", "meta:", "script")):
             category = "banner"
         elif dominant_source.startswith("port "):
             category = "network"

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/analyzers/tech.py

@@ -40,51 +40,17 @@ def _script_srcs(html: str) -> list[str]:
 _CLASS_ATTR_RE = re.compile(r'\bclass\s*=\s*"([^"]*)"|\bclass\s*=\s*\'([^\']*)\'', re.I)
 
 
-_CSS_UTILITY_EXACT: frozenset[str] = frozenset(
-    {
-        "container",
-        "flex",
-        "grid",
-        "block",
-        "inline",
-        "inline-block",
-        "hidden",
-        "table",
-        "table-cell",
-        "table-row",
-        "flow-root",
-        "contents",
-        "float-left",
-        "float-right",
-        "float-none",
-        "clear-left",
-        "clear-right",
-        "clear-both",
-        "clear-none",
-        "isolate",
-        "isolation-auto",
-        "object-contain",
-        "object-cover",
-        "object-fill",
-        "object-none",
-        "object-scale-down",
-        "overflow-auto",
-        "overflow-hidden",
-        "overflow-visible",
-        "overflow-scroll",
-        "overscroll-auto",
-        "overscroll-contain",
-        "overscroll-none",
-        "visible",
-        "invisible",
-        "collapse",
-        "static",
-        "fixed",
-        "absolute",
-        "relative",
-        "sticky",
-    }
-)
+_CSS_UTILITY_EXACT: frozenset[str] = frozenset({
+    "container", "flex", "grid", "block", "inline", "inline-block", "hidden",
+    "table", "table-cell", "table-row", "flow-root", "contents",
+    "float-left", "float-right", "float-none", "clear-left", "clear-right",
+    "clear-both", "clear-none", "isolate", "isolation-auto",
+    "object-contain", "object-cover", "object-fill", "object-none", "object-scale-down",
+    "overflow-auto", "overflow-hidden", "overflow-visible", "overflow-scroll",
+    "overscroll-auto", "overscroll-contain", "overscroll-none",
+    "visible", "invisible", "collapse",
+    "static", "fixed", "absolute", "relative", "sticky",
+})
 # Tailwind-style utilities: px-4, w-full, bg-red-500, my-auto, backdrop-blur, etc.
 _CSS_UTILITY_RE = re.compile(
     r"^[a-z]+(-[a-z]+)?-(\d+|auto|full|screen|px|sm|md|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl|none|hidden|visible|inherit|current|transparent|black|white|blur|opacity|saturate|sepia|grayscale|contrast|brightness|invert|drop-shadow|hue-rotate|shadow|sm|md|lg|xl)$",
@@ -152,9 +118,7 @@ def _confidence(evidence: list[str]) -> int:
 
 
 _VERSION_RE = re.compile(r"(\d+\.\d+(?:\.\d+)?(?:[-+.]?[a-zA-Z0-9]+)?)")
-_CORE_COMMIT_RE = re.compile(
-    r"([A-Za-z][A-Za-z0-9\s-]*?)\s+Core\s+\(([a-f0-9]{4,})\)", re.IGNORECASE
-)
+_CORE_COMMIT_RE = re.compile(r"([A-Za-z][A-Za-z0-9\s-]*?)\s+Core\s+\(([a-f0-9]{4,})\)", re.IGNORECASE)
 
 
 def _version_key(version: str) -> tuple[int, int, int, int]:
@@ -310,7 +274,9 @@ class TechAnalyzer:
             self._add(acc, matcher.match(result.body), "body")
             self._add(acc, matcher.match(result.url), "url")
             for token in _framework_tokens(result.body):
-                self._add(acc, matcher.match_search({"framework": token}), f"framework:{token}")
+                self._add(
+                    acc, matcher.match_search({"framework": token}), f"framework:{token}"
+                )
         self._curated(acc, result)
         by_name: dict[str, _Hit] = {}
         for hit in acc.values():
@@ -370,9 +336,4 @@ class TechAnalyzer:
                 add(name, "service", f"body:{name} Core ({commit})", version=commit)
 
         for tech in extract_generic_tech(result.body):
-            add(
-                tech.name,
-                tech.categories[0] if tech.categories else "service",
-                tech.evidence[0],
-                tech.version,
-            )
+            add(tech.name, tech.categories[0] if tech.categories else "service", tech.evidence[0], tech.version)

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/cli.py

@@ -341,14 +341,14 @@ class _StageTracker:
         self._progress.update(
             self._task_id,
             advance=1,
-            description=f"[~] {self._target} · {message}",
+            description=f"{_glyphs().run} {self._target} {_glyphs().bullet} {message}",
         )
         self._title(message)
 
     def info(self, message: str) -> None:
         self._progress.update(
             self._task_id,
-            description=f"[~] {self._target} · {message}",
+            description=f"{_glyphs().run} {self._target} {_glyphs().bullet} {message}",
         )
         self._title(message)
 
@@ -363,7 +363,7 @@ class _StageTracker:
         self._progress.update(
             self._task_id,
             advance=steps,
-            description=f"[~] {self._target} · {message}",
+            description=f"{_glyphs().run} {self._target} {_glyphs().bullet} {message}",
         )
         self._title(message)
 
@@ -427,7 +427,6 @@ async def _run_scans(args: argparse.Namespace) -> list[ScanReport]:
     from rich.progress import (
         BarColumn,
         MofNCompleteColumn,
-        SpinnerColumn,
         TextColumn,
         TimeElapsedColumn,
     )
@@ -435,7 +434,7 @@ async def _run_scans(args: argparse.Namespace) -> list[ScanReport]:
     err_console = Console(stderr=True)
     total_targets = len(targets)
     completed = 0
-    staged = args.verbose >= 2 or (args.verbose == 0 and total_targets == 1)
+    staged = args.verbose >= 1 or (args.verbose == 0 and total_targets == 1)
     per_target_total = stage_total(options)
 
     async def scan_one(
@@ -493,7 +492,9 @@ async def _run_scans(args: argparse.Namespace) -> list[ScanReport]:
         _set_title(f"stackscan {completed}/{total_targets} · {target.split('://', 1)[-1]}")
         if progress_obj is not None and task_id is not None:
             if staged:
-                progress_obj.update(task_id, completed=target_total, description=f"[+] {target}")
+                progress_obj.update(
+                    task_id, completed=target_total, description=f"{_glyphs().ok} {target}"
+                )
             else:
                 progress_obj.update(task_id, advance=1, description=f"Scanning: {target}")
 
@@ -509,9 +510,8 @@ async def _run_scans(args: argparse.Namespace) -> list[ScanReport]:
     _set_title(f"stackscan · scanning {total_targets} target(s)")
     async with StackscanSession() as session:
         if not is_json_terminal():
-            transient = args.verbose < 2
+            transient = args.verbose == 0
             with Progress(
-                SpinnerColumn(),
                 TextColumn("[progress.description]{task.description}"),
                 BarColumn(),
                 MofNCompleteColumn(),

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/export.py

@@ -9,8 +9,6 @@ from typing import Any
 from xml.sax.saxutils import escape
 
 from stackscan import __version__, theme
-from stackscan.analyzers import summarize_edge
-from stackscan.types import InfraInfo
 from stackscan.utils import host_of
 
 Payload = dict[str, Any]
@@ -208,15 +206,19 @@ def _html_card(r: dict[str, Any]) -> str:
             vals = net.get(key) or []
             if vals:
                 rows.append(_kv(label, _chips(vals)))
+        for rrtype, vals in sorted((net.get("extras") or {}).items()):
+            if vals:
+                rows.append(_kv(rrtype, _chips(vals)))
         domains = net.get("domains") or []
         if domains:
             rows.append(_kv("Domains", _chips(sorted(set(domains)))))
         body_parts.append(_section("Network / DNS", "".join(rows)))
     whois = r.get("whois") or {}
     if whois:
-        rows = ""
-        if whois.get("registrar"):
-            rows += _kv("Registrar", _e(whois["registrar"]))
+        registrar = whois.get("registrar") or ""
+        if registrar and whois.get("registrar_url"):
+            registrar += f" · {whois['registrar_url']}"
+        rows = _kv("Registrar", _e(registrar)) if registrar else ""
         if whois.get("registrant_public") and whois.get("registrant"):
             rows += _kv("Registrant", _e(whois["registrant"]))
         elif whois.get("privacy"):
@@ -224,10 +226,16 @@ def _html_card(r: dict[str, Any]) -> str:
         dates = []
         if whois.get("created"):
             dates.append(f"registered {_e(str(whois['created'])[:10])}")
+        if whois.get("updated"):
+            dates.append(f"updated {_e(str(whois['updated'])[:10])}")
         if whois.get("expires"):
             dates.append(f"expires {_e(str(whois['expires'])[:10])}")
         if dates:
             rows += _kv("Dates", " · ".join(dates))
+        if whois.get("nameservers"):
+            rows += _kv("Nameservers", _chips(whois["nameservers"]))
+        if whois.get("dnssec"):
+            rows += _kv("DNSSEC", _e(whois["dnssec"]))
         if whois.get("statuses"):
             rows += _kv("Status", _e(", ".join(whois["statuses"])))
         if rows:
@@ -246,31 +254,6 @@ def _html_card(r: dict[str, Any]) -> str:
             for i in ipinfo
         )
         body_parts.append(_section("IP intelligence", rows))
-    infra = r.get("infra") or {}
-    cdn_orgs = [
-        i.get("org") or i.get("isp")
-        for i in (r.get("ip_info") or [])
-        if i.get("is_cdn") and (i.get("org") or i.get("isp"))
-    ]
-    edge = summarize_edge(
-        InfraInfo(
-            cdn=tuple(infra.get("cdn") or ()),
-            waf=tuple(infra.get("waf") or ()),
-            proxy=tuple(infra.get("proxy") or ()),
-            server=tuple(infra.get("server") or ()),
-        ),
-        [org for org in cdn_orgs if org],
-    )
-    infra_rows = _kv("Edge", _e(f"behind {edge}")) if edge else ""
-    infra_rows += "".join(
-        (
-            _kv(label, _chips(infra.get(key) or []))
-            for label, key in (("Server", "server"),)
-            if infra.get(key)
-        )
-    )
-    if infra_rows:
-        body_parts.append(_section("Infrastructure", infra_rows))
     protocols = r.get("protocols") or []
     if protocols:
         body_parts.append(_section("Protocol", _chips(protocols)))
@@ -316,20 +299,6 @@ def _html_card(r: dict[str, Any]) -> str:
                 f"<table><thead><tr><th>Service</th><th>Kind</th><th>Severity</th><th>Evidence</th></tr></thead><tbody>{rows}</tbody></table>",
             )
         )
-    os_findings = r.get("os_findings") or []
-    if os_findings:
-        rows = "".join(
-            f"<tr><td>{_e(o.get('host'))}</td><td>{_e(o.get('os'))}</td>"
-            f"<td>{_e(o.get('service'))}</td><td>{_e(o.get('category'))}</td>"
-            f"<td>{_e(o.get('source'))}  ({int((o.get('confidence') or 0) * 100)}%)</td></tr>"
-            for o in os_findings
-        )
-        body_parts.append(
-            _section(
-                "Hosts & OS",
-                f"<table><thead><tr><th>Host</th><th>OS</th><th>Service</th><th>Category</th><th>Source</th></tr></thead><tbody>{rows}</tbody></table>",
-            )
-        )
     software = r.get("software") or []
     if software:
         names = [f"{s.get('name')} {s.get('version')}".strip() for s in software]

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/net/dns.py

@@ -9,7 +9,9 @@ from typing import Any, cast
 
 _QUERY_TIMEOUT = 2.5
 _QUERY_LIFETIME = 5.0
-_RECORD_TYPES = ("A", "AAAA", "CNAME", "MX", "NS", "TXT", "SOA", "CAA")
+_CORE_TYPES = ("A", "AAAA", "CNAME", "MX", "NS", "TXT", "SOA", "CAA")
+_EXTRA_TYPES = ("HTTPS", "SVCB", "DS")
+_RECORD_TYPES = _CORE_TYPES + _EXTRA_TYPES
 
 _PUBLIC_NAMESERVERS: tuple[str, ...] = (
     "1.1.1.1",
@@ -173,6 +175,7 @@ def resolve_host(host: str, *, reverse: bool = True) -> DnsResult:
     ipv4 = records.get("A", ())
     ipv6 = records.get("AAAA", ())
     reverse_map = _reverse_lookup(dns_mod, (*ipv4, *ipv6)) if reverse else {}
+    extras = {rdtype: records[rdtype] for rdtype in _EXTRA_TYPES if records.get(rdtype)}
     return DnsResult(
         host=host,
         ipv4=ipv4,
@@ -185,6 +188,7 @@ def resolve_host(host: str, *, reverse: bool = True) -> DnsResult:
         soa=records.get("SOA", ()),
         caa=records.get("CAA", ()),
         resolver_available=bool(records),
+        extras=extras,
         ttl=ttls,
     )
 

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/net/fingerprint.py

@@ -25,13 +25,7 @@ _DISTRO_PATTERNS: tuple[tuple[re.Pattern[str], str, int | None], ...] = (
     (re.compile(r"\bubuntu\b", re.I), "Ubuntu", None),
     (re.compile(r"\+?deb(\d+)u?(\d+)?", re.I), "Debian", 1),
     (re.compile(r"\bdebian[_-]?(\d[\d._]*)?", re.I), "Debian", 1),
-    (
-        re.compile(
-            r"\b(red\s*hat(?:\s*enterprise\s*linux|\s*linux)?|rhel)[-_\s]?(\d[\d._]*)?", re.I
-        ),
-        "Red Hat",
-        2,
-    ),
+    (re.compile(r"\b(red\s*hat(?:\s*enterprise\s*linux|\s*linux)?|rhel)[-_\s]?(\d[\d._]*)?", re.I), "Red Hat", 2),
     (re.compile(r"\bcentos[-_\s]?(\d[\d._]*)?", re.I), "CentOS", 1),
     (re.compile(r"\bfedora[-_\s]?(\d[\d._]*)?", re.I), "Fedora", 1),
     (re.compile(r"\brocky\s*linux?[-_\s]?(\d[\d._]*)?", re.I), "Rocky Linux", 1),

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/net/whois.py

@@ -91,6 +91,40 @@ def _registrar_name(entity: dict[str, Any] | None) -> str | None:
     return str(handle) if handle else None
 
 
+def _registrar_url(entity: dict[str, Any] | None) -> str | None:
+    if not entity:
+        return None
+    url = _vcard(entity).get("url")
+    if url:
+        return url
+    for link in cast("list[dict[str, Any]]", entity.get("links") or []):
+        href = link.get("href")
+        if href and link.get("rel") in ("about", "self"):
+            return str(href)
+    return None
+
+
+def _nameservers(data: dict[str, Any]) -> tuple[str, ...]:
+    out: list[str] = []
+    for ns in cast("list[dict[str, Any]]", data.get("nameservers") or []):
+        name = str(ns.get("ldhName") or ns.get("unicodeName") or "").rstrip(".").lower()
+        if name and name not in out:
+            out.append(name)
+    return tuple(out)
+
+
+def _dnssec(data: dict[str, Any]) -> str:
+    secure = data.get("secureDNS")
+    if not isinstance(secure, dict):
+        return ""
+    signed = cast("dict[str, Any]", secure).get("delegationSigned")
+    if signed is True:
+        return "signed"
+    if signed is False:
+        return "unsigned"
+    return ""
+
+
 def _event(events: list[dict[str, Any]], action: str) -> str | None:
     for event in events:
         if str(event.get("eventAction", "")).lower() == action:
@@ -121,7 +155,8 @@ def _privacy(
 
 def _parse_rdap(domain: str, data: dict[str, Any]) -> WhoisInfo:
     entities = cast("list[dict[str, Any]]", data.get("entities") or [])
-    registrar = _registrar_name(_find_role(entities, "registrar"))
+    registrar_entity = _find_role(entities, "registrar")
+    registrar = _registrar_name(registrar_entity)
     registrant_entity = _find_role(entities, "registrant")
     events = cast("list[dict[str, Any]]", data.get("events") or [])
     statuses = tuple(str(s) for s in cast("list[Any]", data.get("status") or []))
@@ -129,11 +164,14 @@ def _parse_rdap(domain: str, data: dict[str, Any]) -> WhoisInfo:
     return WhoisInfo(
         domain=domain,
         registrar=registrar,
+        registrar_url=_registrar_url(registrar_entity),
         registrant=contact,
         registrant_public=public,
         privacy=note,
         created=_event(events, "registration"),
         updated=_event(events, "last changed"),
         expires=_event(events, "expiration"),
+        nameservers=_nameservers(data),
+        dnssec=_dnssec(data),
         statuses=statuses,
     )

{stackscan-2.5.0 → stackscan-2.6.0}/src/stackscan/render.py

@@ -12,7 +12,7 @@ from rich.table import Table
 from rich.text import Text
 
 from stackscan import __version__, theme
-from stackscan.analyzers import port_category, summarize_edge
+from stackscan.analyzers import port_category
 from stackscan.types import CveMatch, IpInfo, ScanReport
 from stackscan.utils import host_of
 
@@ -108,6 +108,8 @@ def _network_section(report: ScanReport) -> RenderableType | None:
         add("TXT", host, net.txt)
         add("SOA", host, net.soa)
         add("CAA", host, net.caa)
+        for rrtype in sorted(net.extras):
+            add(rrtype, host, net.extras[rrtype])
         for ip, name in sorted(net.reverse_dns.items(), key=lambda x: _ip_sort_key(x[0])):
             rows.append(("PTR", ip, name))
         if net.geo:
@@ -145,17 +147,6 @@ def _network_section(report: ScanReport) -> RenderableType | None:
     return table
 
 
-def _cdn_orgs(report: ScanReport) -> list[str]:
-    orgs: list[str] = []
-    for info in report.ip_info:
-        if not info.is_cdn:
-            continue
-        org = info.org or info.isp
-        if org and org not in orgs:
-            orgs.append(org)
-    return orgs
-
-
 def _whois_section(report: ScanReport) -> RenderableType | None:
     whois = report.whois
     if whois is None:
@@ -163,8 +154,11 @@ def _whois_section(report: ScanReport) -> RenderableType | None:
     grid = Table.grid(padding=(0, 1))
     grid.add_column(style="bold cyan", no_wrap=True, justify="right")
     grid.add_column(overflow="fold")
-    if whois.registrar:
-        grid.add_row("Registrar", whois.registrar)
+    registrar = whois.registrar or ""
+    if registrar and whois.registrar_url:
+        registrar += f"  ·  {whois.registrar_url}"
+    if registrar:
+        grid.add_row("Registrar", registrar)
     if whois.registrant_public and whois.registrant:
         grid.add_row("Registrant", Text(whois.registrant, style=theme.WARN))
     elif whois.privacy:
@@ -172,10 +166,17 @@ def _whois_section(report: ScanReport) -> RenderableType | None:
     dates: list[str] = []
     if whois.created:
         dates.append(f"registered {whois.created[:10]}")
+    if whois.updated:
+        dates.append(f"updated {whois.updated[:10]}")
     if whois.expires:
         dates.append(f"expires {whois.expires[:10]}")
     if dates:
         grid.add_row("Dates", "  ·  ".join(dates))
+    if whois.nameservers:
+        grid.add_row("Nameservers", ", ".join(whois.nameservers))
+    if whois.dnssec:
+        style = theme.SUCCESS if whois.dnssec == "signed" else theme.MUTED
+        grid.add_row("DNSSEC", Text(whois.dnssec, style=style))
     if whois.statuses:
         shown = ", ".join(whois.statuses[:4])
         if len(whois.statuses) > 4:
@@ -186,21 +187,6 @@ def _whois_section(report: ScanReport) -> RenderableType | None:
     return grid
 
 
-def _infra_section(report: ScanReport) -> RenderableType | None:
-    infra = report.infra
-    edge = summarize_edge(infra, _cdn_orgs(report), sep=f" {_glyphs().arrow} ")
-    if not edge and not infra.notes:
-        return None
-    grid = Table.grid(padding=(0, 1))
-    grid.add_column(style="bold cyan", no_wrap=True, justify="right")
-    grid.add_column(overflow="fold")
-    if edge:
-        grid.add_row("Edge", Text(f"behind {edge}", style=theme.ACCENT_2))
-    for note in infra.notes:
-        grid.add_row("Note", Text(note, style="dim"))
-    return grid
-
-
 _ACME_CAS: tuple[str, ...] = (
     "let's encrypt",
     "lets encrypt",
@@ -306,26 +292,26 @@ def _tls_section(report: ScanReport) -> RenderableType | None:
     return grid
 
 
+_EDGE_CATEGORIES: frozenset[str] = frozenset({"edge", "cdn", "waf", "proxy"})
+
+
 def _tech_section(report: ScanReport) -> RenderableType | None:
-    """Render technologies and extracted software as a flat table."""
     all_techs = report.all_technologies()
+    primary = host_of(report.url)
     rows: list[tuple[str, str, str, str, str]] = []
     seen: set[tuple[str, str | None, str]] = set()
 
     def _add_row(name: str, version: str | None, category: str, host: str, confidence: int) -> None:
-        key = (name.lower(), version, host)
+        is_edge = any(cat in _EDGE_CATEGORIES for cat in category.split(", "))
+        host_cell = host or primary or "-"
+        if is_edge:
+            key = (name.lower(), version, "")
+        else:
+            key = (name.lower(), version, host)
         if key in seen:
             return
         seen.add(key)
-        rows.append(
-            (
-                name,
-                version or "-",
-                category,
-                host if host and host != host_of(report.url) else "-",
-                f"{confidence}%",
-            )
-        )
+        rows.append((name, version or "-", category, host_cell, f"{confidence}%"))
 
     for tech in all_techs:
         category = ", ".join(tech.categories) if tech.categories else "uncategorized"
@@ -548,26 +534,6 @@ def _subdomains_section(report: ScanReport) -> RenderableType | None:
     return table if table.row_count else None
 
 
-def _os_section(report: ScanReport) -> RenderableType | None:
-    if not report.os_findings:
-        return None
-    table = Table(box=None, pad_edge=False)
-    table.add_column("Host", style="bold cyan", overflow="fold")
-    table.add_column("OS", overflow="fold")
-    table.add_column("Service", overflow="fold")
-    table.add_column("Category", overflow="fold")
-    table.add_column("Source", overflow="fold")
-    for finding in report.os_findings:
-        table.add_row(
-            finding.host,
-            finding.os,
-            finding.service,
-            finding.category,
-            f"{finding.source}  ({int(finding.confidence * 100)}%)",
-        )
-    return table
-
-
 def _social_section(report: ScanReport) -> RenderableType | None:
     if not report.social:
         return None
@@ -583,20 +549,6 @@ def _social_section(report: ScanReport) -> RenderableType | None:
     return grid
 
 
-def _security_section(report: ScanReport) -> RenderableType | None:
-    sec = report.security
-    if not sec.present and (not sec.missing):
-        return None
-    grid = Table.grid(padding=(0, 1))
-    grid.add_column(style="bold cyan", no_wrap=True, justify="right")
-    grid.add_column(overflow="fold")
-    if sec.present:
-        grid.add_row("Present", Text(", ".join(sorted(sec.present)), style="green"))
-    if sec.missing:
-        grid.add_row("Missing", Text(", ".join(sec.missing), style="red"))
-    return grid
-
-
 def _exposure_section(report: ScanReport) -> RenderableType | None:
     exp = report.exposure
     if exp is None:
@@ -631,17 +583,14 @@ _SECTIONS: tuple[tuple[str, _SectionBuilder], ...] = (
     ("Network / DNS", _network_section),
     ("Registration (WHOIS)", _whois_section),
     ("IP intelligence", _ipinfo_section),
-    ("Infrastructure", _infra_section),
     ("TLS / Protocol", _tls_section),
     ("Technologies & Software", _tech_section),
     ("Vulnerabilities (CVE)", _cve_section),
     ("Services & open ports", _services_section),
-    ("Hosts & OS", _os_section),
     ("Default creds / open devices", _creds_section),
     ("Secrets & leaks", _secrets_section),
     ("Subdomain takeovers", _takeovers_section),
     ("Subdomains", _subdomains_section),
-    ("Security headers", _security_section),
     ("Exposure", _exposure_section),
     ("Social & contacts", _social_section),
 )