web-scanner 2.0.0__py3-none-any.whl

webscanner/modules/security.py

@@ -0,0 +1,124 @@
+"""Security module — three tables: Open Ports, HTTP Security, Blocklists.
+
+- Open Ports: TCP-connect scan of a short list of common ports.
+- HTTP Security: presence of key response security headers (from prefetch).
+- Blocklists: whether the domain is blocked by popular filtering DNS resolvers
+  (AdGuard, CleanBrowsing, Cloudflare, Google, OpenDNS, Quad9), queried directly
+  by IP via ``dig``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from ..colors import GREEN, RED
+from ..core.module import ScanModule
+from ..core.context import ScanContext
+from ..core.models import Section, Sections
+
+# port -> service label (short common set)
+COMMON_PORTS: dict[int, str] = {
+    21: "FTP", 22: "SSH", 25: "SMTP", 53: "DNS", 80: "HTTP",
+    443: "HTTPS", 3306: "MySQL", 3389: "RDP", 8080: "HTTP-alt", 8443: "HTTPS-alt",
+}
+
+# response header -> short label shown in the table
+SEC_HEADERS: dict[str, str] = {
+    "content-security-policy": "Content-Security-Policy",
+    "strict-transport-security": "Strict-Transport-Security",
+    "x-content-type-options": "X-Content-Type-Options",
+    "x-frame-options": "X-Frame-Options",
+    "referrer-policy": "Referrer-Policy",
+    "permissions-policy": "Permissions-Policy",
+    "cross-origin-opener-policy": "Cross-Origin-Opener-Policy",
+    "cross-origin-embedder-policy": "Cross-Origin-Embedder-Policy",
+    "cross-origin-resource-policy": "Cross-Origin-Resource-Policy",
+}
+
+# filtering DNS resolver -> IP (we ask each whether it blocks the domain)
+FILTERS: dict[str, str] = {
+    "AdGuard": "94.140.14.14",
+    "AdGuard Family": "94.140.14.15",
+    "CleanBrowsing Adult": "185.228.168.10",
+    "CleanBrowsing Family": "185.228.168.168",
+    "CleanBrowsing Security": "185.228.168.9",
+    "CloudFlare": "1.1.1.1",
+    "CloudFlare Family": "1.1.1.3",
+    "Google DNS": "8.8.8.8",
+    "OpenDNS": "208.67.222.222",
+    "OpenDNS Family": "208.67.222.123",
+    "Quad9": "9.9.9.9",
+}
+# answer IPs that mean "blocked/sinkhole" rather than a real result
+_BLOCK_PREFIXES = ("0.0.0.0", "146.112.61.", "146.112.255.", "208.69.38.", "208.69.39.", "::")
+
+_YES, _NO = f"[{GREEN}]Yes[/]", f"[{RED}]No[/]"
+
+
+async def _port_open(ip: str, port: int) -> bool:
+    try:
+        _, writer = await asyncio.wait_for(asyncio.open_connection(ip, port), timeout=1.5)
+        writer.close()
+        try:
+            await writer.wait_closed()
+        except Exception:  # noqa: BLE001
+            pass
+        return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
+async def _scan_ports(ip: str) -> dict[str, str]:
+    opens = await asyncio.gather(*(_port_open(ip, p) for p in COMMON_PORTS))
+    return {
+        f"{port} ({svc})": f"[{GREEN}]open[/]" if is_open else "[dim]closed[/]"
+        for (port, svc), is_open in zip(COMMON_PORTS.items(), opens)
+    }
+
+
+def _http_security(headers: dict[str, str]) -> dict[str, str]:
+    present = {k.lower() for k in headers}
+    return {label: (_YES if h in present else _NO) for h, label in SEC_HEADERS.items()}
+
+
+async def _query_filter(domain: str, ip: str) -> str:
+    """Ask a filtering resolver for the domain; classify Blocked/Not Blocked."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "dig", "+short", "+time=2", "+tries=1", f"@{ip}", domain, "A",
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+        )
+        out, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+        answers = [ln.strip() for ln in out.decode(errors="replace").splitlines() if ln.strip()]
+        if not answers:  # NXDOMAIN / refused / empty
+            return f"[{RED}]Blocked[/]"
+        if any(a.startswith(_BLOCK_PREFIXES) for a in answers):
+            return f"[{RED}]Blocked[/]"
+        return f"[{GREEN}]Not Blocked[/]"
+    except Exception:  # noqa: BLE001
+        return "[dim]error[/]"
+
+
+async def _blocklists(domain: str) -> dict[str, str]:
+    names = list(FILTERS)
+    outcomes = await asyncio.gather(*(_query_filter(domain, FILTERS[n]) for n in names))
+    return dict(zip(names, outcomes))
+
+
+class SecurityModule(ScanModule):
+    name = "security"
+    label = "Security"
+
+    async def run(self, ctx: ScanContext) -> Sections:
+        ports_coro = _scan_ports(ctx.ip) if ctx.ip else _empty()
+        ports, blocks = await asyncio.gather(ports_coro, _blocklists(ctx.domain))
+        r = (3, 2)  # 60/40 columns across all three tables
+        return Sections([
+            Section("Open Ports", ports or {"note": "no IP to scan"}, ("Port", "Status"), ratio=r),
+            Section("HTTP Security", _http_security(ctx.headers), ("Header", "Present"), ratio=r),
+            Section("Blocklists", blocks, ("Blocklist", "Status"), ratio=r),
+        ])
+
+
+async def _empty() -> dict[str, str]:
+    return {}

webscanner/modules/seo.py

@@ -0,0 +1,148 @@
+"""SEO module — Content, Keywords, Robots, and Schema tables.
+
+- Content: title / description (each with a character-count + recommended-length
+  hint, green when in range, red when out), h1–h3 headings + socials.
+- Keywords: the top-10 most frequent 1-, 2- and 3-word phrases on the page.
+- Robots: robots.txt presence, any sitemaps, and the raw file.
+- Schema: whether the page has schema.org structured data (JSON-LD) + the parsed
+  JSON (shown last, in full).
+
+Parses the HTML fetched once during prefetch; robots.txt is a small extra fetch.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from collections import Counter
+from urllib.parse import urlparse
+
+import requests
+from bs4 import BeautifulSoup
+from rich.markup import escape
+
+from ..colors import GREEN, RED
+from ..core.module import ScanModule
+from ..core.context import ScanContext
+from ..core.models import Section, Sections
+from ..net.http import DEFAULT_HEADERS, TIMEOUT
+
+TITLE_RANGE = (30, 60)
+DESC_RANGE = (70, 160)
+
+SOCIAL_DOMAINS = (
+    "facebook.com", "twitter.com", "x.com", "instagram.com", "linkedin.com",
+    "youtube.com", "youtu.be", "pinterest.com", "tiktok.com", "reddit.com",
+    "medium.com", "discord.com", "discord.gg", "twitch.tv", "vimeo.com",
+)
+
+_STOPWORDS = frozenset(
+    "the a an and or but if of to in on for with as by at from is are was were be "
+    "been being this that these those it its you your we our us they their he she "
+    "his her not no so do does did has have had can will would should could may "
+    "might just than then there here what which who when where how all any some "
+    "more most other into out up down over under about also new get one two".split()
+)
+
+
+def _len_line(text: str, lo: int, hi: int) -> str:
+    n = len(text)
+    colour = GREEN if lo <= n <= hi else RED
+    return f"[dim]{escape(text)}[/]\n[{colour}]{n} chars · rec. {lo}-{hi}[/]"
+
+
+class SeoModule(ScanModule):
+    name = "seo"
+    label = "SEO"
+
+    async def run(self, ctx: ScanContext) -> Sections:
+        robots_coro = asyncio.to_thread(self._fetch_robots, ctx.domain)
+        if not ctx.html:
+            robots = await robots_coro
+            note = {"note": "no page content"}
+            schema, content, keywords = {"Has Schema": f"[{RED}]No[/]"}, note, note
+        else:
+            parsed, robots = await asyncio.gather(
+                asyncio.to_thread(self._parse, ctx), robots_coro
+            )
+            schema, content, keywords = parsed
+
+        return Sections([
+            Section("Content", content, ("Field", "Value"), spaced=True),
+            Section("Keywords", keywords, ("N-gram", "Top 10 (by frequency)"), spaced=True),
+            Section("Robots", robots, ("Field", "Value"), spaced=True),
+            Section("Schema", schema, ("Field", "Value"), spaced=True),
+        ])
+
+    @staticmethod
+    def _parse(ctx: ScanContext) -> tuple[dict, dict, dict]:
+        soup = BeautifulSoup(ctx.html, "html.parser")
+
+        # --- Schema (JSON-LD structured data) ---
+        blocks = []
+        for tag in soup.find_all("script", attrs={"type": "application/ld+json"}):
+            try:
+                blocks.append(json.loads(tag.string or tag.get_text()))
+            except Exception:  # noqa: BLE001
+                pass
+        schema: dict[str, str] = {"Has Schema": f"[{GREEN}]Yes[/]" if blocks else f"[{RED}]No[/]"}
+        if blocks:
+            schema["Schema"] = json.dumps(
+                blocks[0] if len(blocks) == 1 else blocks, indent=2, ensure_ascii=False
+            )
+
+        # --- Content ---
+        title_el = soup.find("title")
+        title = title_el.get_text(strip=True) if title_el else None
+        desc_el = soup.find("meta", attrs={"name": "description"})
+        desc = (desc_el.get("content") or "").strip() if desc_el else None
+        content: dict[str, object] = {
+            "Title": _len_line(title, *TITLE_RANGE) if title else "-",
+            "Description": _len_line(desc, *DESC_RANGE) if desc else "-",
+        }
+        for lvl in range(1, 4):
+            content[f"H{lvl}"] = [h.get_text(strip=True) for h in soup.find_all(f"h{lvl}")]
+        content["Socials"] = sorted({
+            tag["href"].rstrip("/")
+            for tag in soup.find_all("a", href=True)
+            if any(urlparse(tag["href"]).netloc.lower().endswith(d) for d in SOCIAL_DOMAINS)
+        })
+
+        # --- Keywords (n-grams) ---
+        for tag in soup(["script", "style", "noscript"]):
+            tag.decompose()
+        text = soup.get_text(" ", strip=True).lower()
+        tokens = [t for t in re.findall(r"[a-z][a-z'-]{2,}", text) if t not in _STOPWORDS]
+
+        def top(n: int) -> str:
+            grams = (" ".join(tokens[i:i + n]) for i in range(len(tokens) - n + 1))
+            return ", ".join(g for g, _ in Counter(grams).most_common(10)) or "-"
+
+        keywords = {"1-word": top(1), "2-word": top(2), "3-word": top(3)}
+        return schema, content, keywords
+
+    @staticmethod
+    def _fetch_robots(domain: str) -> dict[str, object]:
+        try:
+            resp = requests.get(
+                f"https://{domain}/robots.txt",
+                headers=DEFAULT_HEADERS, timeout=TIMEOUT, allow_redirects=True,
+            )
+            text = resp.text.strip()
+            ctype = resp.headers.get("content-type", "").lower()
+            looks_html = "html" in ctype or "<html" in text[:200].lower() or text[:20].lower().startswith("<!doctype")
+            if resp.status_code == 200 and text and not looks_html:
+                result: dict[str, object] = {"Found": f"[{GREEN}]Yes[/]"}
+                sitemaps = [
+                    ln.split(":", 1)[1].strip()
+                    for ln in text.splitlines()
+                    if ln.strip().lower().startswith("sitemap:")
+                ]
+                if sitemaps:
+                    result["Sitemaps"] = sitemaps
+                result["robots.txt"] = text
+                return result
+        except Exception:  # noqa: BLE001
+            pass
+        return {"Found": f"[{RED}]No[/]"}

webscanner/modules/ssl.py

@@ -0,0 +1,57 @@
+"""SSL/TLS certificate module (uses the cert grabbed in prefetch)."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from ..core.module import ScanModule
+from ..core.context import ScanContext
+
+_CERT_DATE = "%b %d %H:%M:%S %Y %Z"
+
+
+def _flatten(pairs: Any) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for rdn in pairs or ():
+        for key, value in rdn:
+            out[key] = value
+    return out
+
+
+class SslModule(ScanModule):
+    name = "ssl"
+    label = "SSL"
+
+    async def run(self, ctx: ScanContext) -> dict[str, Any]:
+        cert = ctx.tls_cert
+        if not cert:
+            return {}
+
+        subject = _flatten(cert.get("subject"))
+        issuer = _flatten(cert.get("issuer"))
+        sans = [v for k, v in cert.get("subjectAltName", ()) if k == "DNS"]
+
+        result: dict[str, Any] = {
+            "subject_cn": subject.get("commonName"),
+            "issuer_org": issuer.get("organizationName"),
+            "issuer_cn": issuer.get("commonName"),
+            "valid_from": cert.get("notBefore"),
+            "valid_until": cert.get("notAfter"),
+            "san_count": len(sans),
+            "san": sans[:20],
+        }
+
+        not_after = cert.get("notAfter")
+        if not_after:
+            try:
+                expires = datetime.strptime(not_after, _CERT_DATE).replace(tzinfo=timezone.utc)
+                days = (expires - datetime.now(timezone.utc)).days
+                result["days_until_expiry"] = days
+                result["expired"] = days < 0
+                # A successful handshake in prefetch means the chain validated
+                # against the system trust store.
+                result["trusted"] = not result["expired"]
+            except ValueError:
+                pass
+        return result

webscanner/modules/subdomains.py

@@ -0,0 +1,56 @@
+"""Native subdomain discovery — no external service (replaces crt.sh).
+
+Two native sources:
+  1. Subject Alternative Names on the live TLS certificate (grabbed once in
+     prefetch via ``ssl``/``socket``) — real hostnames the cert is valid for.
+  2. Resolving a curated list of common subdomains via ``socket`` and keeping the
+     ones that exist.
+
+Less exhaustive than a Certificate Transparency search, but instant and
+dependency-free. Swap in a CT/API source later if broader coverage is needed.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import socket
+
+from ..core.module import ScanModule
+from ..core.context import ScanContext
+
+COMMON_SUBDOMAINS = (
+    "www", "mail", "webmail", "smtp", "imap", "pop", "ftp", "cpanel", "webdisk",
+    "ns1", "ns2", "mx", "api", "dev", "staging", "blog", "shop", "admin",
+    "portal", "vpn", "cdn", "m",
+)
+
+
+class SubdomainsModule(ScanModule):
+    name = "subdomains"
+    label = "Subdomains"
+
+    async def run(self, ctx: ScanContext) -> list[str]:
+        found: set[str] = set()
+
+        # 1. certificate SANs (from the prefetch TLS handshake)
+        if ctx.tls_cert:
+            for entry_type, value in ctx.tls_cert.get("subjectAltName", ()):
+                if entry_type != "DNS":
+                    continue
+                host = value.lstrip("*.").lower()
+                if host == ctx.domain or host.endswith("." + ctx.domain):
+                    found.add(host)
+
+        # 2. resolve common subdomains concurrently
+        async def probe(sub: str) -> str | None:
+            host = f"{sub}.{ctx.domain}"
+            try:
+                await asyncio.to_thread(socket.gethostbyname, host)
+                return host
+            except OSError:
+                return None
+
+        resolved = await asyncio.gather(*(probe(s) for s in COMMON_SUBDOMAINS))
+        found.update(host for host in resolved if host)
+        found.discard(ctx.domain)
+        return sorted(found)

webscanner/modules/tech.py

@@ -0,0 +1,43 @@
+"""Technology detection via Wappalyzer.
+
+Uses ``analyze(..., scan_type="fast")`` — a pure-HTTP path (no headless browser) —
+which returns per-technology version, confidence, categories and groups. Rendered as
+a multi-column :class:`Grid`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from wappalyzer import analyze
+
+from ..core.module import ScanModule
+from ..core.context import ScanContext
+from ..core.models import Grid
+
+COLUMNS = ["Name", "Category", "Confidence", "Groups", "Version"]
+
+
+class TechModule(ScanModule):
+    name = "tech"
+    label = "Tech"
+
+    async def run(self, ctx: ScanContext) -> Grid:
+        def detect() -> Grid:
+            results = analyze(url=ctx.url, scan_type="fast", timeout=30)
+            techs = results.get(ctx.url) or next(iter(results.values()), {})
+            rows = [
+                [
+                    name,
+                    ", ".join(info.get("categories") or []) or "-",
+                    f"{info.get('confidence', 0)}%",
+                    ", ".join(info.get("groups") or []) or "-",
+                    info.get("version") or "-",
+                ]
+                for name, info in techs.items()
+            ]
+            # highest-confidence first, then alphabetical
+            rows.sort(key=lambda r: (-int(r[2].rstrip("%") or 0), r[0].lower()))
+            return Grid(COLUMNS, rows)
+
+        return await asyncio.to_thread(detect)

webscanner/modules/whois.py

@@ -0,0 +1,114 @@
+"""WHOIS module — async subprocess, no temp files, rich normalised key set.
+
+Shells out to the system ``whois`` (the same output you'd see in a terminal) and
+parses it robustly:
+
+- If the output contains a referral marker (``# whois.<server>``), only the last
+  section is parsed — this drops the IANA/registry TLD block (which for ccTLDs
+  like .au otherwise pollutes the domain fields with the *TLD's* dates/nameservers).
+- Fields are matched **most-specific prefix first** across all lines, so e.g.
+  ``Domain Name:`` wins over a stray ``domain:``.
+- Covers gTLD *and* ccTLD label variants incl. per-contact names (Registrant /
+  Admin / Tech Contact Name).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from typing import Any
+
+from ..core.module import ScanModule
+from ..core.context import ScanContext
+
+# canonical field -> candidate label prefixes (lowercased), most-specific first
+_FIELDS: dict[str, tuple[str, ...]] = {
+    "domain": ("domain name:", "domain:"),
+    "registry_domain_id": ("registry domain id:",),
+    "registrar": ("registrar name:", "registrar:", "sponsoring registrar:"),
+    "registrar_url": ("registrar url:", "registrar web:", "referral url:"),
+    "registrar_whois": ("registrar whois server:", "whois server:"),
+    "registrar_iana_id": ("registrar iana id:",),
+    "registrar_abuse_email": ("registrar abuse contact email:",),
+    "registrar_abuse_phone": ("registrar abuse contact phone:",),
+    "reseller": ("reseller name:", "reseller:"),
+    "creation_date": ("creation date:", "created on:", "registered on:", "domain registration date:", "created:", "registered:"),
+    "updated_date": ("updated date:", "last modified:", "last updated:", "modified:", "changed:"),
+    "expiry_date": ("registry expiry date:", "registrar registration expiration date:", "expiry date:", "expiration date:", "expires:", "expire:", "paid-till:"),
+    "registrant_name": ("registrant contact name:", "registrant name:"),
+    "registrant_org": ("registrant organization:", "registrant organisation:", "registrant:", "organization:", "org:"),
+    "registrant_id": ("registrant contact id:", "registrant id:"),
+    "registrant_email": ("registrant contact email:", "registrant email:"),
+    "registrant_phone": ("registrant contact phone:", "registrant phone:"),
+    "registrant_country": ("registrant country:", "country:"),
+    "admin_name": ("admin contact name:", "admin name:", "administrative contact:"),
+    "admin_email": ("admin contact email:", "admin email:"),
+    "tech_name": ("tech contact name:", "tech name:", "technical contact:"),
+    "tech_email": ("tech contact email:", "tech email:"),
+    "eligibility": ("eligibility type:",),
+    "status_reason": ("status reason:",),
+    "dnssec": ("dnssec:",),
+}
+
+
+def _first(lines: list[tuple[str, str]], prefixes: tuple[str, ...]) -> str | None:
+    for pfx in prefixes:  # prefix-priority: most specific wins regardless of order
+        for low, raw in lines:
+            if low.startswith(pfx):
+                value = raw[len(pfx):].strip()
+                if value:
+                    return value
+    return None
+
+
+def _multi(lines: list[tuple[str, str]], *prefixes: str) -> list[str]:
+    out: list[str] = []
+    for low, raw in lines:
+        if low.startswith(prefixes):
+            out.append(raw.split(":", 1)[1].strip())
+    return out
+
+
+class WhoisModule(ScanModule):
+    name = "whois"
+    label = "Whois"
+
+    async def run(self, ctx: ScanContext) -> dict[str, Any]:
+        proc = await asyncio.create_subprocess_exec(
+            "whois",
+            ctx.domain,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        stdout, _ = await proc.communicate()
+        text = stdout.decode("utf-8", errors="replace")
+
+        raw = text.splitlines()
+        # keep only the authoritative section (after the last referral marker)
+        markers = [i for i, ln in enumerate(raw) if ln.lstrip().lower().startswith("# whois.")]
+        if markers:
+            raw = raw[markers[-1] + 1:]
+
+        lines = [
+            (ln.strip().lower(), ln.strip())
+            for ln in raw
+            if ":" in ln and not ln.lstrip().startswith(("%", "#", ">>>"))
+        ]
+
+        result: dict[str, Any] = {}
+        for field, prefixes in _FIELDS.items():
+            value = _first(lines, prefixes)
+            if value:
+                result[field] = value
+
+        ns = _multi(lines, "name server:", "nserver:", "nameserver:")
+        if ns:
+            result["name_servers"] = sorted({n.split()[0].lower() for n in ns if n})
+
+        status = _multi(lines, "domain status:", "status:")
+        if status:
+            result["status"] = sorted({s for s in status if s})
+
+        if not result and re.search(r"no match|not found|no entries found", text, re.IGNORECASE):
+            result["note"] = "no WHOIS match / not found"
+        return result

webscanner/net/__init__.py

@@ -0,0 +1,5 @@
+"""Shared network helpers (sync; called from threads by the async core)."""
+
+from . import http
+
+__all__ = ["http"]

webscanner/net/http.py

@@ -0,0 +1,66 @@
+"""Blocking HTTP / DNS / TLS primitives.
+
+Kept synchronous on purpose: the async core calls these via ``asyncio.to_thread``.
+Centralising them here gives every module one user-agent, one timeout policy and
+one place to add retries/proxying later.
+"""
+
+from __future__ import annotations
+
+import socket
+import ssl
+import time
+from typing import Any
+
+import requests
+
+USER_AGENT = "web-scanner/2.0 (+https://github.com/iamramizk/web-scanner)"
+TIMEOUT = 12
+DEFAULT_HEADERS = {"User-Agent": USER_AGENT}
+
+
+def fetch(url: str) -> dict[str, Any]:
+    """GET a URL, following redirects; return status/headers/body/timing/final-url."""
+    start = time.perf_counter()
+    resp = requests.get(url, headers=DEFAULT_HEADERS, timeout=TIMEOUT, allow_redirects=True)
+    elapsed = (time.perf_counter() - start) * 1000
+    return {
+        "status_code": resp.status_code,
+        "headers": dict(resp.headers),
+        "html": resp.text,
+        "elapsed_ms": elapsed,
+        "final_url": resp.url,
+    }
+
+
+def resolve_ip(domain: str) -> str | None:
+    """Resolve a host to its first IPv4 address."""
+    try:
+        return socket.gethostbyname(domain)
+    except OSError:
+        return None
+
+
+def get_geo(ip: str) -> dict[str, Any]:
+    """Geolocate an IP via ip-api.com (free, no key)."""
+    resp = requests.get(f"http://ip-api.com/json/{ip}", headers=DEFAULT_HEADERS, timeout=TIMEOUT)
+    return resp.json()
+
+
+def get_tls_cert(host: str, port: int = 443) -> dict[str, Any] | None:
+    """Complete a TLS handshake and return the peer certificate dict (or None)."""
+    ctx = ssl.create_default_context()
+    with socket.create_connection((host, port), timeout=TIMEOUT) as sock:
+        with ctx.wrap_socket(sock, server_hostname=host) as tls:
+            return tls.getpeercert()
+
+
+def doh_query(name: str, rtype: str = "A") -> dict[str, Any]:
+    """DNS-over-HTTPS query via Cloudflare (used for blocklist checks)."""
+    resp = requests.get(
+        "https://cloudflare-dns.com/dns-query",
+        params={"name": name, "type": rtype},
+        headers={"accept": "application/dns-json", "User-Agent": USER_AGENT},
+        timeout=TIMEOUT,
+    )
+    return resp.json()

webscanner/ui/__init__.py

@@ -0,0 +1 @@
+"""Textual UI layer (widgets, layout, world map)."""