Add scope guidance to asset discovery skill

docs/advanced/skills.mdx

@@ -81,6 +81,14 @@ Protocol-specific testing techniques.
 | --------- | ------------------------------------------------ |
 | `graphql` | GraphQL introspection, batching, resolver issues |
 
+### Reconnaissance
+
+Passive discovery and attack-surface mapping techniques.
+
+| Skill             | Coverage                                                        |
+| ----------------- | --------------------------------------------------------------- |
+| `asset_discovery` | CT, TLS SAN pivoting, passive DNS, and ASN/IP asset enumeration |
+
 ### Tooling
 
 Sandbox CLI playbooks for core recon and scanning tools.

strix/interface/main.py

@@ -5,7 +5,6 @@ Strix Agent Interface
 
 import argparse
 import asyncio
-import os
 import shutil
 import sys
 from datetime import UTC, datetime
@@ -33,13 +32,6 @@ from strix.config.models import (
 from strix.core.paths import run_dir_for, runtime_state_dir
 from strix.interface.cli import run_cli
 from strix.interface.tui import run_tui
-from strix.interface.update_check import (
-    is_binary_install,
-    notify_update,
-    prompt_update_if_available,
-    self_update,
-    start_background_check,
-)
 from strix.interface.utils import (
     assign_workspace_subdirs,
     build_final_stats_text,
@@ -455,14 +447,6 @@ Examples:
         version=f"strix {get_version()}",
     )
 
-    parser.add_argument(
-        "--update",
-        action="store_true",
-        help="Update strix to the latest version and exit. Self-updates the "
-        "standalone binary install; for pip/pipx/uv installs, prints the "
-        "matching upgrade command instead.",
-    )
-
     parser.add_argument(
         "-t",
         "--target",
@@ -581,9 +565,6 @@ Examples:
 
     args = parser.parse_args()
 
-    if args.update:
-        sys.exit(0 if self_update() else 1)
-
     if args.instruction and args.instruction_file:
         parser.error(
             "Cannot specify both --instruction and --instruction-file. Use one or the other."
@@ -807,8 +788,6 @@ def display_completion_message(args: argparse.Namespace, results_path: Path) ->
         "[#60a5fa]discord.gg/strix-ai[/]"
     )
     console.print()
-    if not args.non_interactive:
-        notify_update(console)
 
 
 def pull_docker_image() -> None:
@@ -872,12 +851,6 @@ def main() -> None:
     if args.config:
         apply_config_override(validate_config_file(args.config))
 
-    start_background_check()
-    if not args.non_interactive and prompt_update_if_available(Console()):
-        if is_binary_install() and sys.platform != "win32":
-            os.execv(sys.executable, sys.argv)  # noqa: S606  # nosec B606
-        sys.exit(0)
-
     check_docker_installed()
     pull_docker_image()
 

strix/interface/update_check.py

@@ -1,389 +0,0 @@
-"""Update notifications and self-update for the strix CLI.
-
-Follows the pattern used by tools like gh, uv, and pip: a background,
-rate-limited (once per 24h) check against the release source, a cached
-result in ``~/.strix``, a non-intrusive notice with the upgrade command
-for the detected install method, and a ``strix --update`` self-update
-path for the standalone binary install.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-import os
-import platform
-import shutil
-import stat
-import subprocess
-import sys
-import tarfile
-import tempfile
-import threading
-import time
-import zipfile
-from pathlib import Path
-from typing import cast
-
-import requests
-from rich.console import Console
-from rich.prompt import Prompt
-
-from strix.telemetry._common import get_version
-
-
-logger = logging.getLogger(__name__)
-
-GITHUB_REPO = "usestrix/strix"
-PYPI_PACKAGE = "strix-agent"
-CHECK_INTERVAL_SECONDS = 24 * 60 * 60
-REQUEST_TIMEOUT_SECONDS = 5
-
-_CACHE_PATH = Path.home() / ".strix" / "update-check.json"
-
-_background_thread: threading.Thread | None = None
-
-
-def _is_disabled() -> bool:
-    return bool(os.environ.get("STRIX_NO_UPDATE_CHECK")) or any(
-        os.environ.get(key)
-        for key in ("CI", "GITHUB_ACTIONS", "GITLAB_CI", "JENKINS_URL", "BUILDKITE", "CIRCLECI")
-    )
-
-
-def is_binary_install() -> bool:
-    return bool(getattr(sys, "frozen", False))
-
-
-def get_install_method() -> str:
-    if is_binary_install():
-        return "binary"
-    prefix = str(Path(sys.prefix)).replace("\\", "/")
-    if "/pipx/" in prefix or prefix.endswith("/pipx"):
-        return "pipx"
-    if "/uv/tools/" in prefix:
-        return "uv"
-    return "pip"
-
-
-def get_upgrade_command(method: str | None = None) -> str:
-    method = method or get_install_method()
-    commands = {
-        "binary": "strix --update",
-        "pipx": "pipx upgrade strix-agent",
-        "uv": "uv tool upgrade strix-agent",
-        "pip": "pip install --upgrade strix-agent",
-    }
-    return commands[method]
-
-
-def _parse_version(value: str) -> tuple[int, ...] | None:
-    parts = value.strip().lstrip("v").split(".")
-    try:
-        return tuple(int(part) for part in parts)
-    except ValueError:
-        return None
-
-
-def _is_newer(latest: str, current: str) -> bool:
-    latest_parts = _parse_version(latest)
-    current_parts = _parse_version(current)
-    if latest_parts is None or current_parts is None:
-        return False
-    return latest_parts > current_parts
-
-
-def _fetch_latest_version() -> str | None:
-    try:
-        if is_binary_install():
-            response = requests.get(
-                f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest",
-                timeout=REQUEST_TIMEOUT_SECONDS,
-            )
-            response.raise_for_status()
-            tag = response.json().get("tag_name", "")
-            return tag.lstrip("v") or None
-        response = requests.get(
-            f"https://pypi.org/pypi/{PYPI_PACKAGE}/json",
-            timeout=REQUEST_TIMEOUT_SECONDS,
-        )
-        response.raise_for_status()
-        version = response.json().get("info", {}).get("version")
-        return str(version) if version else None
-    except Exception:  # noqa: BLE001
-        logger.debug("update check failed", exc_info=True)
-        return None
-
-
-def _fetch_asset_digest(version: str, filename: str) -> str | None:
-    """Return the expected sha256 (hex) for a release asset, if the API provides one."""
-    try:
-        response = requests.get(
-            f"https://api.github.com/repos/{GITHUB_REPO}/releases/tags/v{version}",
-            timeout=REQUEST_TIMEOUT_SECONDS,
-        )
-        response.raise_for_status()
-        for asset in response.json().get("assets", []):
-            if asset.get("name") == filename:
-                digest = asset.get("digest") or ""
-                if digest.startswith("sha256:"):
-                    return digest.removeprefix("sha256:")
-    except Exception:  # noqa: BLE001
-        logger.debug("release asset digest lookup failed", exc_info=True)
-    return None
-
-
-def _sha256_file(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as f:
-        for chunk in iter(lambda: f.read(1 << 20), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def _read_cache() -> dict[str, object]:
-    try:
-        with _CACHE_PATH.open(encoding="utf-8") as f:
-            data = json.load(f)
-        if isinstance(data, dict):
-            return cast("dict[str, object]", data)
-    except Exception:  # noqa: BLE001, S110
-        pass  # nosec B110
-    return {}
-
-
-def _write_cache(**fields: object) -> None:
-    try:
-        cache = _read_cache()
-        cache.update(fields)
-        _CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
-        _CACHE_PATH.write_text(json.dumps(cache), encoding="utf-8")
-    except Exception:  # noqa: BLE001, S110
-        pass  # nosec B110
-
-
-def skip_version(version: str) -> None:
-    """Remember not to prompt again for this version (newer releases still notify)."""
-    _write_cache(skipped_version=version)
-
-
-def _refresh_cache() -> None:
-    latest = _fetch_latest_version()
-    if latest:
-        _write_cache(latest_version=latest, checked_at=time.time())
-
-
-def start_background_check() -> None:
-    """Refresh the cached latest-version info in a daemon thread (at most once per 24h)."""
-    global _background_thread  # noqa: PLW0603
-    if _is_disabled():
-        return
-    cache = _read_cache()
-    checked_at = cache.get("checked_at")
-    if isinstance(checked_at, int | float) and time.time() - checked_at < CHECK_INTERVAL_SECONDS:
-        return
-    _background_thread = threading.Thread(target=_refresh_cache, daemon=True)
-    _background_thread.start()
-
-
-def get_available_update(*, respect_skip: bool = True) -> str | None:
-    """Return the newer version from the cache, or None if up to date / unknown."""
-    if _is_disabled():
-        return None
-    if _background_thread is not None:
-        _background_thread.join(timeout=0.2)
-    cache = _read_cache()
-    latest = cache.get("latest_version")
-    current = get_version()
-    if not isinstance(latest, str) or current == "unknown" or not _is_newer(latest, current):
-        return None
-    if respect_skip and cache.get("skipped_version") == latest:
-        return None
-    return latest
-
-
-def notify_update(console: Console) -> None:
-    latest = get_available_update()
-    if not latest:
-        return
-    console.print(
-        f"[#eab308]A new version of strix is available:[/] "
-        f"[dim]{get_version()}[/] [dim]→[/] [bold #22c55e]{latest}[/]"
-        f"  [dim]·[/]  [#60a5fa]{get_upgrade_command()}[/]"
-    )
-    console.print()
-
-
-def run_package_upgrade(console: Console, method: str) -> bool:
-    """Upgrade a package-manager install by running its upgrade command."""
-    command = get_upgrade_command(method).split()
-    console.print(f"[dim]Running[/] [#60a5fa]{' '.join(command)}[/]")
-    try:
-        result = subprocess.run(command, check=False)  # noqa: S603
-    except OSError as e:
-        console.print(f"[bold red]Update failed:[/] {e}")
-        return False
-    if result.returncode != 0:
-        console.print(
-            f"[bold red]Update failed[/] [dim](exit code {result.returncode}).[/] "
-            f"Run it manually: [#60a5fa]{get_upgrade_command(method)}[/]"
-        )
-        return False
-    console.print("[#22c55e]✓ strix updated — restart the scan to use the new version[/]")
-    return True
-
-
-def prompt_update_if_available(console: Console) -> bool:
-    """Offer an interactive update before a scan starts.
-
-    Returns True if strix was updated (caller should re-exec / exit).
-    """
-    latest = get_available_update()
-    if not latest or not sys.stdin.isatty() or not sys.stdout.isatty():
-        return False
-    console.print()
-    console.print(
-        f"[#eab308]A new version of strix is available:[/] "
-        f"[dim]{get_version()}[/] [dim]→[/] [bold #22c55e]{latest}[/]"
-    )
-    console.print(
-        "[dim]  y — update now    n — not now (ask again next run)    s — skip this version[/]"
-    )
-    choice = Prompt.ask("Update strix?", choices=["y", "n", "s"], default="n")
-    console.print()
-    if choice == "s":
-        skip_version(latest)
-        return False
-    if choice != "y":
-        return False
-    method = get_install_method()
-    if method == "binary":
-        return self_update(console, version=latest)
-    return run_package_upgrade(console, method)
-
-
-def _release_target() -> str | None:
-    raw_os = platform.system().lower()
-    os_name = {"darwin": "macos", "linux": "linux", "windows": "windows"}.get(raw_os)
-    arch = platform.machine().lower()
-    arch = {"aarch64": "arm64", "amd64": "x86_64"}.get(arch, arch)
-    if os_name is None:
-        return None
-    target = f"{os_name}-{arch}"
-    supported = {"linux-x86_64", "macos-x86_64", "macos-arm64", "windows-x86_64"}
-    return target if target in supported else None
-
-
-def _download_and_replace(version: str, target: str, console: Console) -> bool:
-    is_windows = target.startswith("windows")
-    archive_ext = ".zip" if is_windows else ".tar.gz"
-    filename = f"strix-{version}-{target}{archive_ext}"
-    url = f"https://github.com/{GITHUB_REPO}/releases/download/v{version}/{filename}"
-    binary_name = f"strix-{version}-{target}" + (".exe" if is_windows else "")
-    current_exe = Path(sys.executable).resolve()
-
-    with tempfile.TemporaryDirectory() as tmp:
-        tmp_dir = Path(tmp)
-        archive_path = tmp_dir / filename
-        console.print(f"[dim]Downloading[/] {url}")
-        with requests.get(  # nosec B113
-            url,
-            stream=True,
-            timeout=REQUEST_TIMEOUT_SECONDS * 12,
-        ) as response:
-            response.raise_for_status()
-            with archive_path.open("wb") as f:
-                for chunk in response.iter_content(chunk_size=1 << 20):
-                    f.write(chunk)
-
-        expected_digest = _fetch_asset_digest(version, filename)
-        if expected_digest:
-            actual_digest = _sha256_file(archive_path)
-            if actual_digest != expected_digest:
-                raise RuntimeError(
-                    f"checksum mismatch for {filename}: "
-                    f"expected sha256 {expected_digest}, got {actual_digest}"
-                )
-        else:
-            console.print("[dim yellow]No published checksum available; skipping verification[/]")
-
-        if is_windows:
-            with zipfile.ZipFile(archive_path) as zf:
-                zf.extract(binary_name, tmp_dir)
-        else:
-            with tarfile.open(archive_path, "r:gz") as tf:
-                tf.extract(binary_name, tmp_dir, filter="data")
-
-        new_binary = tmp_dir / binary_name
-        new_binary.chmod(new_binary.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
-
-        staged = current_exe.with_name(current_exe.name + ".new")
-        try:
-            shutil.copy2(new_binary, staged)
-            if is_windows:
-                # Windows can't replace a running executable in place; move it aside first.
-                old = current_exe.with_name(current_exe.name + ".old")
-                old.unlink(missing_ok=True)
-                current_exe.rename(old)
-                try:
-                    staged.replace(current_exe)
-                except Exception:
-                    old.rename(current_exe)
-                    raise
-            else:
-                staged.replace(current_exe)
-        except Exception:
-            staged.unlink(missing_ok=True)
-            raise
-    return True
-
-
-def self_update(console: Console | None = None, version: str | None = None) -> bool:
-    """Replace the running standalone binary with the latest release.
-
-    Returns True on success. For package-manager installs this only
-    prints the right upgrade command and returns False.
-    """
-    console = console or Console()
-
-    if not is_binary_install():
-        method = get_install_method()
-        console.print(
-            f"[#eab308]This strix was installed via {method};[/] "
-            f"upgrade it with: [#60a5fa]{get_upgrade_command(method)}[/]"
-        )
-        return False
-
-    latest = version or _fetch_latest_version()
-    if not latest:
-        console.print("[bold red]Could not determine the latest strix version.[/]")
-        return False
-
-    current = get_version()
-    if current != "unknown" and not _is_newer(latest, current):
-        console.print(f"[#22c55e]strix {current} is already the latest version.[/]")
-        return True
-
-    target = _release_target()
-    if not target:
-        console.print(
-            f"[bold red]No prebuilt binary for this platform "
-            f"({platform.system()}/{platform.machine()}).[/]"
-        )
-        return False
-
-    try:
-        _download_and_replace(latest, target, console)
-    except Exception as e:  # noqa: BLE001
-        logger.debug("self-update failed", exc_info=True)
-        console.print(f"[bold red]Update failed:[/] {e}")
-        console.print(
-            "[dim]You can reinstall manually with:[/] "
-            "[#60a5fa]curl -sSL https://strix.ai/install | bash[/]"
-        )
-        return False
-
-    _write_cache(latest_version=latest, checked_at=time.time())
-    console.print(f"[#22c55e]✓ Updated strix to {latest}[/]")
-    return True

strix/skills/reconnaissance/asset_discovery.md

@@ -0,0 +1,151 @@
+---
+name: asset-discovery
+description: Passive asset and attack-surface discovery via certificate transparency, TLS SAN pivoting, passive DNS, and ASN/IP enumeration to find hosts beyond subdomain brute force
+---
+
+# Asset Discovery
+
+Most engagements start from a small seed (one domain, one org name) but the real attack surface is far larger: forgotten hosts, staging/internal-named services, acquisitions, and infrastructure that never appears in a wordlist. Build a broad, deduplicated inventory using passive intelligence — certificate transparency, TLS certificate metadata, passive DNS, and ASN/IP data — then collapse it into a probed, classified attack surface. The aim is coverage and pivoting: every certificate, DNS record, and IP is a lead to more assets.
+
+Only use this skill when all subdomains and related assets of the target are in scope — broad discovery pulls in hosts far beyond the seed.
+
+## Attack Surface
+
+- Hosts discoverable via issued certificates (CT logs) but absent from DNS brute force
+- Internal/staging/pre-prod hostnames leaked in certificate SAN lists
+- Sibling and acquisition domains sharing certificates, ASNs, or IP ranges with the seed
+- Wildcard and short-lived certs revealing naming conventions (`*.internal.example.com`, `k8s-*`, `argocd.*`)
+- ASN-owned IP ranges hosting services with no DNS name at all
+- Virtual hosts co-located on shared IPs (multiple apps behind one address)
+- Non-HTTP services on discovered hosts (databases, brokers, admin ports)
+
+## High-Value Sources
+
+### Certificate Transparency (CT)
+
+CT logs record nearly every publicly-trusted certificate. Query by domain (matches SAN/CN) and by organization name.
+
+- **crt.sh** (free, no key):
+  - By domain incl. subdomains: `curl -s 'https://crt.sh/?q=%25.example.com&output=json' | jq -r '.[].name_value' | sed 's/^\*\.//' | sort -u`
+  - By organization: `https://crt.sh/?O=Example+Inc&output=json`
+- **Censys / Shodan / Fofa** (API keys): search certs by `parsed.names`, `parsed.subject.organization`, or a specific `fingerprint_sha256`, then pivot to every host serving that cert.
+- Cross-check multiple indexes (`certspotter`, Google CT, `chaos`) — no single log is complete.
+- **Wildcards** (`*.corp.example.com`) reveal internal naming schemes even when individual hosts resolve privately; use them to seed targeted guesses (`grafana.corp`, `ci.corp`, `vault.corp`).
+
+### TLS Certificate SAN/CN
+
+- **SAN expansion**: one cert often lists many hostnames (marketing + api + admin + internal) — extract every SAN, not just the queried name.
+- **Shared-cert pivot**: the same cert fingerprint served on multiple IPs ties disparate assets to one owner.
+- **Issuer/org pivot**: certs sharing `subject.organization`/`organizationalUnit` frequently belong to the same target.
+- **Active read** catches names never submitted to public CT: `echo | openssl s_client -connect HOST:443 -servername HOST 2>/dev/null | openssl x509 -noout -text | grep -A1 'Subject Alternative Name'`
+- **Internal leak signal**: SANs like `localhost`, `*.internal`, `*.svc.cluster.local`, `*.local`, or RFC1918-style names on a public cert expose internal naming and sometimes internal services fronted publicly.
+
+### Passive DNS
+
+- Forward-resolve every name (A/AAAA/CNAME); keep CNAME chains — they reveal third-party providers and CDNs.
+- **Reverse DNS (PTR)** on discovered IPs surfaces co-located hostnames.
+- **Historical/passive DNS** (SecurityTrails, VirusTotal, `chaos`, passivedns providers) recovers names that no longer resolve but may still front live infra.
+
+### ASN & IP Ranges
+
+- Map a known IP to its ASN and netblock: `whois -h whois.cymru.com " -v <IP>"` or a BGP/ASN lookup.
+- If the org runs its own ASN, enumerate all announced prefixes and treat them as candidate assets.
+- For cloud-hosted targets the IP belongs to the provider, not the org — pivot via cert/vhost instead of netblock.
+
+## Recommended Tooling
+
+Prefer the projectdiscovery suite (already available in the sandbox and pipeline-friendly with JSON output):
+
+- **`subfinder`** — passive subdomain aggregation across many sources incl. CT: `subfinder -d example.com -all -recursive -silent -oJ -o subs.jsonl`
+- **`tlsx`** — TLS/cert data at scale; grab SANs and issuer/org to pivot: `tlsx -l hosts.txt -san -cn -tls-version -json -o tls.jsonl`
+- **`uncover`** — query Shodan/Censys/Fofa/Quake/crt.sh engines from one CLI: `uncover -q 'ssl:"Example Inc"' -e shodan,censys,fofa -json`
+- **`asnmap`** — org/domain/ASN → CIDR ranges: `asnmap -d example.com -json` / `asnmap -org "Example Inc"`
+- **`mapcidr`** — expand/aggregate CIDRs into host lists for probing: `mapcidr -cidr 192.0.2.0/24 -o hosts.txt`
+- **`dnsx`** — fast resolution, PTR, and wildcard filtering: `dnsx -l names.txt -a -aaaa -cname -ptr -resp -json -o dns.jsonl`
+- **`httpx`** — live probing + cert grab in one pass (see methodology).
+- **`naabu`** — port sweep for non-HTTP services: `naabu -list hosts.txt -top-ports 100 -verify -silent`
+
+Also useful: **`amass`** (`amass intel`/`enum` for ASN, cert, and passive sources), **`cero`** (bulk SAN extraction from IPs/ranges), and direct **crt.sh** JSON queries when no keys are configured. Cross-source results — CT + passive DNS + `subfinder` together beat any single source.
+
+## Key Techniques
+
+### Iterative Seed Expansion
+
+Every new name, PTR result, CNAME target, and cert SAN becomes a fresh seed. Loop CT → SAN extraction → passive DNS → ASN/range expansion until the asset set stops growing.
+
+### Cert-Fingerprint Pivoting
+
+Search Censys/Shodan (or `uncover`) by a cert's `fingerprint_sha256` to find every other host presenting the same certificate — the strongest cross-asset link for tying acquisitions and shadow infra to the target.
+
+### Naming-Convention Inference
+
+Wildcard SANs and observed hostnames expose the org's naming scheme; generate targeted candidates from it (`<service>.<env>.example.com`) rather than blind brute force.
+
+### IP-First Discovery
+
+For ASN-owned ranges, sweep IPs directly with `naabu`/`httpx` and read served certs (`tlsx`) to find services that have no DNS name at all.
+
+## Advanced Techniques
+
+- **Active SAN harvesting** across whole ranges with `tlsx`/`cero` recovers internal hostnames never logged to public CT.
+- **Favicon and response hashing** (`httpx -favicon`, hash pivots in Shodan) clusters instances of the same app across unrelated hostnames.
+- **Vhost differentials**: probe a single IP with multiple `Host:` values to unmask co-located apps behind one address.
+- **Historical CT/DNS diffing** highlights recently issued certs and newly appearing hosts — high-signal for fresh or misconfigured deployments.
+
+## Consolidation & Probing
+
+1. **Dedupe** names and IPs into one inventory; record source(s) per asset for confidence.
+2. **Live probe** with `httpx`, capturing status/title/tech/server and cert SANs in one pass — each grabbed SAN feeds back as a new seed:
+   `httpx -l hosts.txt -sc -title -server -td -tls-grab -json -o assets.jsonl`
+3. **Classify** assets by function from title/tech/path signals: app, API, marketing, auth, CI/CD, observability, storage, admin, VCS, mail. Cluster by role, not by a specific product.
+4. **Port sweep** interesting hosts with `naabu` for non-HTTP services (DBs, caches, brokers, mgmt ports).
+5. **Prioritize** by exposure and value, then hand each finding to the right specialist skill:
+   - Exposed dashboards / debug / observability / metadata leaks → `information_disclosure`
+   - Login/admin panels with default or weak creds → `weak_password_detection`
+   - Dangling DNS / unclaimed provider resources → `subdomain_takeover`
+   - Cloud consoles/metadata surfaces → `aws` / `gcp` / `kubernetes`
+
+## Testing Methodology
+
+1. **Seed** - domains, org/legal names, known IPs, email domains, code-host org
+2. **Certificate transparency** - pull all logged certs per seed domain and org name (crt.sh, `uncover`)
+3. **SAN/CN extraction** - parse every Subject CN and SAN with `tlsx`; each new name is a new seed
+4. **Passive DNS** - resolve forward and reverse with `dnsx`; harvest historical records
+5. **ASN/IP mapping** - `asnmap` → `mapcidr` to expand owned ranges, then sweep for live hosts
+6. **Active TLS pivot** - `tlsx`/`cero` on live IPs/ports to grab SANs missing from public CT
+7. **Consolidate & probe** - dedupe, `httpx` probe, classify, and route to specialists
+
+## Validation
+
+1. Confirm each discovered asset actually resolves and serves content (live `httpx` result, not just a passive hit)
+2. Attribute assets to the target via matching cert org, shared cert fingerprint, or DNS under a seed domain
+3. Deduplicate vhost aliases and CDN edges down to distinct origins so the surface is not inflated
+4. Record provenance (which source produced each asset) for reproducibility
+
+## False Positives
+
+- CDN/edge hostnames and provider default names that are not org-owned
+- Shared-hosting neighbors on the same IP (vhost co-tenancy, not the target's asset)
+- Stale historical DNS entries pointing at reassigned infrastructure
+- Wildcard-cert-implied hostnames that never actually resolve or serve content
+
+## Impact
+
+- Expanded attack surface: forgotten, staging, and internal-named hosts brute force misses
+- Discovery of misconfigured or unauthenticated services fronted by leaked internal hostnames
+- Attribution of shadow infra, acquisitions, and sibling domains to the target
+- A prioritized, classified inventory that feeds every downstream specialist skill
+
+## Pro Tips
+
+1. Loop the pipeline — every SAN, PTR, and CNAME target is a new seed until the set converges.
+2. crt.sh is the cheapest high-yield source (no key); Censys/Shodan via `uncover` add cert-fingerprint and vhost pivoting when keys exist.
+3. Always cert-grab live hosts with `tlsx` — active SANs catch internal hostnames never sent to public CT.
+4. Internal-looking SANs (`*.internal`, `*.svc.cluster.local`, staging names) are the highest-signal leads.
+5. Wildcard SANs reveal naming conventions — seed targeted guesses instead of blind brute force.
+6. Cluster by function, not product name, so the workflow generalizes to any exposed service.
+7. Keep JSON output throughout so stages chain cleanly (`subfinder` → `dnsx` → `httpx` → `naabu`).
+
+## Summary
+
+Broad passive discovery — CT + TLS SAN pivoting + passive DNS + ASN/IP mapping, looped until convergence — finds the assets brute force misses, especially internal-named and forgotten services leaked through certificates. Build the inventory with the projectdiscovery suite, probe and classify it generically, then route each interesting asset to the specialist skill for its class.

tests/test_update_check.py

@@ -1,172 +0,0 @@
-import hashlib
-import io
-import json
-import platform
-import time
-from pathlib import Path
-
-import pytest
-from rich.console import Console
-
-from strix.interface import update_check
-
-
-@pytest.fixture(autouse=True)
-def _isolated_cache(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(update_check, "_CACHE_PATH", tmp_path / "update-check.json")
-    monkeypatch.setattr(update_check, "_background_thread", None)
-    monkeypatch.delenv("STRIX_NO_UPDATE_CHECK", raising=False)
-    for key in ("CI", "GITHUB_ACTIONS", "GITLAB_CI", "JENKINS_URL", "BUILDKITE", "CIRCLECI"):
-        monkeypatch.delenv(key, raising=False)
-
-
-@pytest.mark.parametrize(
-    ("latest", "current", "expected"),
-    [
-        ("1.2.0", "1.1.0", True),
-        ("1.1.0", "1.1.0", False),
-        ("1.0.9", "1.1.0", False),
-        ("2.0.0", "1.99.99", True),
-        ("1.10.0", "1.9.0", True),
-        ("v1.2.0", "1.1.0", True),
-        ("not-a-version", "1.1.0", False),
-        ("1.2.0", "unknown", False),
-    ],
-)
-def test_is_newer(latest: str, current: str, expected: bool) -> None:
-    assert update_check._is_newer(latest, current) is expected
-
-
-def test_get_available_update_from_cache(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps({"latest_version": "9.9.9", "checked_at": time.time()})
-    )
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    assert update_check.get_available_update() == "9.9.9"
-
-
-def test_get_available_update_up_to_date(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps({"latest_version": "1.0.0", "checked_at": time.time()})
-    )
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    assert update_check.get_available_update() is None
-
-
-def test_get_available_update_disabled_by_env(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps({"latest_version": "9.9.9", "checked_at": time.time()})
-    )
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    monkeypatch.setenv("STRIX_NO_UPDATE_CHECK", "1")
-    assert update_check.get_available_update() is None
-
-
-def test_get_available_update_disabled_in_ci(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps({"latest_version": "9.9.9", "checked_at": time.time()})
-    )
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    monkeypatch.setenv("CI", "true")
-    assert update_check.get_available_update() is None
-
-
-def test_get_available_update_corrupt_cache(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text("{not json")
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    assert update_check.get_available_update() is None
-
-
-def test_background_check_skipped_when_fresh(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps({"latest_version": "1.0.0", "checked_at": time.time()})
-    )
-    called = False
-
-    def fake_refresh() -> None:
-        nonlocal called
-        called = True
-
-    monkeypatch.setattr(update_check, "_refresh_cache", fake_refresh)
-    update_check.start_background_check()
-    assert update_check._background_thread is None
-    assert called is False
-
-
-def test_background_check_runs_when_stale(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps({"latest_version": "1.0.0", "checked_at": time.time() - 2 * 24 * 60 * 60})
-    )
-    monkeypatch.setattr(update_check, "_fetch_latest_version", lambda: "1.2.3")
-    update_check.start_background_check()
-    assert update_check._background_thread is not None
-    update_check._background_thread.join(timeout=5)
-    cache = json.loads(update_check._CACHE_PATH.read_text())
-    assert cache["latest_version"] == "1.2.3"
-
-
-def test_skipped_version_suppresses_update(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps({"latest_version": "9.9.9", "checked_at": time.time()})
-    )
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    update_check.skip_version("9.9.9")
-    assert update_check.get_available_update() is None
-    assert update_check.get_available_update(respect_skip=False) == "9.9.9"
-
-
-def test_newer_release_overrides_skipped_version(monkeypatch: pytest.MonkeyPatch) -> None:
-    update_check._CACHE_PATH.write_text(
-        json.dumps(
-            {"latest_version": "9.9.10", "checked_at": time.time(), "skipped_version": "9.9.9"}
-        )
-    )
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    assert update_check.get_available_update() == "9.9.10"
-
-
-def test_write_cache_preserves_existing_fields() -> None:
-    update_check.skip_version("9.9.9")
-    update_check._write_cache(latest_version="1.2.3", checked_at=123.0)
-    cache = json.loads(update_check._CACHE_PATH.read_text())
-    assert cache == {"latest_version": "1.2.3", "checked_at": 123.0, "skipped_version": "9.9.9"}
-
-
-def test_get_upgrade_command_all_methods() -> None:
-    assert update_check.get_upgrade_command("binary") == "strix --update"
-    assert update_check.get_upgrade_command("pipx") == "pipx upgrade strix-agent"
-    assert update_check.get_upgrade_command("uv") == "uv tool upgrade strix-agent"
-    assert update_check.get_upgrade_command("pip") == "pip install --upgrade strix-agent"
-
-
-def test_self_update_non_binary_prints_command(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(update_check, "is_binary_install", lambda: False)
-    buffer = io.StringIO()
-    assert update_check.self_update(Console(file=buffer)) is False
-    assert "upgrade" in buffer.getvalue()
-
-
-def test_self_update_already_latest(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(update_check, "is_binary_install", lambda: True)
-    monkeypatch.setattr(update_check, "_fetch_latest_version", lambda: "1.0.0")
-    monkeypatch.setattr(update_check, "get_version", lambda: "1.0.0")
-    assert update_check.self_update() is True
-
-
-def test_sha256_file(tmp_path: Path) -> None:
-    path = tmp_path / "blob"
-    path.write_bytes(b"strix")
-    assert update_check._sha256_file(path) == hashlib.sha256(b"strix").hexdigest()
-
-
-def test_release_target(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(platform, "system", lambda: "Linux")
-    monkeypatch.setattr(platform, "machine", lambda: "x86_64")
-    assert update_check._release_target() == "linux-x86_64"
-
-    monkeypatch.setattr(platform, "system", lambda: "Darwin")
-    monkeypatch.setattr(platform, "machine", lambda: "arm64")
-    assert update_check._release_target() == "macos-arm64"
-
-    monkeypatch.setattr(platform, "machine", lambda: "riscv64")
-    assert update_check._release_target() is None