@quantakrypto/qprobe 0.4.4

package/README.md

@@ -0,0 +1,109 @@
+# @quantakrypto/qprobe
+
+Actively inspect **live TLS/SSH endpoints you own** for post-quantum readiness —
+whether they negotiate a PQC-hybrid key exchange, and what their classical exposure
+is — with **zero runtime dependencies** (Node built-ins only).
+
+qProbe is the live-endpoint sibling of [qScan](../qscan) (which scans code) and the
+infrastructure detectors in [`@quantakrypto/core`](../core) (which scan config). It
+is the **only** package in this repo that opens network connections, and it is gated
+behind a mandatory ownership attestation — read **[THREAT-MODEL.md](THREAT-MODEL.md)**
+before using it.
+
+> **Authorization required.** qProbe sends nothing until you attest you are
+> authorized to test the target. Active probing of endpoints you do not own may be
+> unlawful. qProbe refuses CIDR blocks, IP ranges, wildcards, and target lists — it
+> probes **one host you operate** at a time, and it only ever performs a benign,
+> unauthenticated handshake. It reports the negotiated reality; it never modifies an
+> endpoint ("engine disposes").
+
+## What it checks
+
+- **TLS** — the negotiated TLS version, cipher suite, ephemeral key-exchange group,
+  and leaf-certificate key type, **plus** whether the server supports the
+  post-quantum hybrid group **X25519MLKEM768** (codepoint `0x11EC`). Because Node's
+  bundled OpenSSL cannot negotiate that group, qProbe detects it with a hand-rolled
+  raw ClientHello and reads the group the server selects.
+- **SSH** — the offered key-exchange and host-key algorithms (from the cleartext
+  `KEXINIT`), flagging classical-only servers and surfacing PQC KEX
+  (`sntrup761x25519-sha512@openssh.com`, `mlkem768x25519-sha256`) as a positive.
+
+Findings are `@quantakrypto/core` Findings, so they score (`readinessScore`) and
+read exactly like qScan output and can be merged into the same posture.
+
+## Usage
+
+```bash
+# TLS 443: hybrid KEX + certificate posture (endpoint you control)
+npx @quantakrypto/qprobe --i-own-this example.com
+
+# SSH 22: KEXINIT algorithms
+npx @quantakrypto/qprobe --ssh --i-own-this git.example.com
+
+# Multiple endpoints from an ownership manifest, JSON output
+npx @quantakrypto/qprobe --owned-hosts hosts.txt api.example.com:8443 --json
+```
+
+### Options
+
+| Flag | Meaning |
+|---|---|
+| `--i-own-this` | Attest you are authorized to probe the target(s). Required (or `--owned-hosts`). |
+| `--owned-hosts <file>` | Ownership manifest (one host per line, `#` comments). Every target must be listed. |
+| `--tls` / `--ssh` | Force a probe mode (default: auto — SSH on `:22`, TLS otherwise). |
+| `--servername <name>` | TLS SNI server name (default: the host; omitted for bare IPs). |
+| `--timeout <ms>` | Per-connection timeout (default: 8000). |
+| `--format <human\|json\|sarif\|cbom>` | Output format (default: human). `--json` / `--sarif` / `--cbom` are aliases. SARIF 2.1.0 and CycloneDX 1.6 CBOM are the **same formats qScan emits**. |
+
+Exit codes mirror qScan: `0` clean, `1` findings, `2` error / not authorized.
+
+## Example
+
+```
+$ qprobe --i-own-this example.com
+
+example.com:443  [tls]
+  TLSv1.3 · TLS_AES_256_GCM_SHA384 · KEX X25519 · cert EC(prime256v1)-256
+  PQC-hybrid (X25519MLKEM768): not negotiated
+  [medium] Classical TLS key exchange (no PQC hybrid) — the session key is
+           harvest-now-decrypt-later exposed …
+  [low]    Classical certificate key — forgeable once a CRQC exists …
+
+2 findings · 1 HNDL-exposed · readiness 90/100
+```
+
+## One post-quantum posture: code + infra + live endpoints
+
+qProbe findings are `@quantakrypto/core` Findings and emit the **same** SARIF 2.1.0
+and CycloneDX 1.6 CBOM as qScan. That means the three planes compose into a single
+readiness picture:
+
+- **Code + infrastructure-as-code / config** — `qscan .` (the language packs *and*
+  the Terraform / Kubernetes / CI-CD / secrets / messaging / database / JOSE
+  detectors all run in one scan).
+- **Live endpoints** — `qprobe --i-own-this …`.
+
+Because both CBOMs are CycloneDX 1.6 `cryptographic-asset` documents, they merge
+into one org-wide crypto bill of materials, and each readiness score comes from the
+same `buildInventory` math so they read on the same scale:
+
+```bash
+qscan .  --cbom  -o code-infra.cbom.json          # code + infra crypto assets
+qprobe --owned-hosts hosts.txt api.example.com --cbom -o endpoints.cbom.json
+```
+
+Combine them into one CBOM with `mergeCboms` from `@quantakrypto/core` (components
+with the same `bom-ref` collapse to one asset whose evidence spans both planes):
+
+```js
+import { mergeCboms } from "@quantakrypto/core";
+import { readFileSync } from "node:fs";
+const combined = mergeCboms([
+  JSON.parse(readFileSync("code-infra.cbom.json", "utf8")),
+  JSON.parse(readFileSync("endpoints.cbom.json", "utf8")),
+]);
+```
+
+## License
+
+Apache-2.0. See [THREAT-MODEL.md](THREAT-MODEL.md) for the authorization model.

package/THREAT-MODEL.md

@@ -0,0 +1,83 @@
+# qProbe threat model
+
+qProbe is the only `@quantakrypto/*` package that opens network connections to
+systems it did not create. Every other tool reads files you already have; qProbe
+reaches out and touches a live endpoint. That single difference is the whole reason
+this document exists, and it drives the design.
+
+## Authorization is the primary control
+
+**qProbe refuses to send a single byte to any endpoint until the operator has
+attested authorization.** This is enforced in code (`authorizeTargets` in
+`src/attest.ts`), not by a prompt or a README warning, and it runs **before any
+socket is opened** — `runProbe` calls the gate first and throws `AttestationError`
+on failure, so no connection attempt happens on the unauthorized path.
+
+Authorization is exactly one of:
+
+- `--i-own-this` — an explicit per-run attestation that you control the target(s).
+- `--owned-hosts <file>` — an ownership manifest (one host per line); every target
+  host must appear in it, or the run is refused.
+
+There is no third path and no default-on. A run with neither flag exits non-zero
+and connects to nothing.
+
+### Scope is one host at a time
+
+qProbe **refuses CIDR blocks, IP ranges, wildcards, and target lists** outright
+(`parseTarget` in `src/target.ts`). `10.0.0.0/24`, `10.0.0.1-50`, `*.example.com`,
+and `a.com,b.com` are all rejected before parsing. This is deliberate: mass scanning
+is a categorically different activity from checking an endpoint you operate, and the
+tool will not make it convenient. Probes are sequential with a minimum interval
+between connections.
+
+### Legal note (operator responsibility)
+
+Actively probing endpoints you do not own or lack permission to test may violate the
+US Computer Fraud and Abuse Act (CFAA), the UK Computer Misuse Act, and equivalent
+laws elsewhere, as well as your provider's acceptable-use policy. The attestation is
+your assertion that you are authorized; qProbe cannot verify it for you. **You are
+responsible for the legality of every target you pass.**
+
+## What qProbe actually does on the wire
+
+- **TLS:** one normal TLS 1.3 handshake (`node:tls`) to read the negotiated
+  version / cipher / key-exchange group and the leaf certificate's public metadata;
+  plus one raw ClientHello (`node:net`) advertising `X25519MLKEM768` to observe the
+  group the server selects. Both are ordinary, unauthenticated handshakes — the same
+  thing any browser or `openssl s_client` does. qProbe does **not** complete the
+  handshake with real key material, send application data, attempt authentication,
+  or exercise any vulnerability.
+- **SSH:** it reads the server's cleartext identification banner and the
+  `SSH_MSG_KEXINIT` it sends before encryption, to list offered key-exchange and
+  host-key algorithms. **No authentication is attempted; no crypto is performed.**
+
+**"Engine disposes."** qProbe reports the negotiated reality. It never modifies,
+reconfigures, or writes to an endpoint. It has no capability to do so.
+
+## Data handling
+
+- The only data qProbe reads is **already public by construction**: negotiated
+  protocol parameters, a server certificate (served to every client), and an SSH
+  banner + algorithm name-lists (sent to every client before auth).
+- qProbe captures **no secret or key material**. It does not read private keys,
+  credentials, or application data. Findings carry only `host:port`, the negotiated
+  parameters, and the readiness classification.
+- There is no telemetry and no network egress other than to the attested target(s).
+
+## Non-goals
+
+- qProbe is **not** a vulnerability scanner, exploit framework, or penetration-testing
+  tool. It classifies post-quantum readiness of the key exchange, cipher, and
+  certificate; it does not test for CVEs or attempt compromise.
+- It is **not** a discovery tool. It will not enumerate hosts, sweep ranges, or find
+  endpoints for you — you bring the specific endpoint you operate.
+
+## Residual risks & mitigations
+
+| Risk | Mitigation |
+|---|---|
+| Operator probes a third-party endpoint | Attestation is required and is the operator's explicit, logged assertion; CIDR/range/list refused; legal responsibility documented. |
+| Accidental mass scan | CIDR/range/wildcard/list rejected at parse time; sequential probing with a minimum interval. |
+| Endpoint mistakes the probe for an attack | Probes are single, benign, standards-compliant handshakes; no auth, no app data, no exploitation. |
+| Sensitive data captured | Only public handshake/cert/banner data is read; no key/secret material; findings hold only `host:port` + negotiated parameters. |

package/dist/args.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hand-rolled CLI argument parser (zero dependencies), mirroring qScan's approach:
+ * the parser is pure and total — it never throws and never does I/O.
+ */
+export type ProbeModeArg = "tls" | "ssh" | "smtp" | "auto";
+export type FormatArg = "human" | "json" | "sarif" | "cbom";
+export interface CliArgs {
+    targets: string[];
+    mode: ProbeModeArg;
+    iOwnThis: boolean;
+    ownedHostsFile?: string;
+    servername?: string;
+    timeoutMs: number;
+    format: FormatArg;
+    help: boolean;
+}
+export declare function parseArgs(argv: readonly string[]): CliArgs;
+export declare const HELP = "qprobe \u2014 active post-quantum readiness probing of live TLS/SSH endpoints you OWN.\n\nUSAGE\n  qprobe [options] <host[:port]> [host[:port] ...]\n\nAUTHORIZATION (required \u2014 one of)\n  --i-own-this            Attest you are authorized to probe the given endpoint(s).\n  --owned-hosts <file>    Ownership manifest (one host per line, # comments).\n\n  Active probing of endpoints you do not own may be unlawful. qprobe refuses CIDR\n  blocks, IP ranges, wildcards and target lists. See THREAT-MODEL.md.\n\nOPTIONS\n  --tls | --ssh | --smtp  Force a probe mode (default: auto \u2014 SSH on :22, SMTP\n                          STARTTLS on :25/:587, else TLS).\n  --servername <name>     TLS SNI server name (default: the host).\n  --timeout <ms>          Per-connection timeout (default: 8000).\n  --format <human|json|sarif|cbom>\n                          Output format (default: human). --json / --sarif / --cbom\n                          are aliases. SARIF 2.1.0 and CycloneDX 1.6 CBOM compose\n                          with qScan output (same formats).\n  -h, --help              Show this help.\n\nEXAMPLES\n  qprobe --i-own-this example.com                 # TLS 443: hybrid KEX + cert posture\n  qprobe --ssh --i-own-this git.example.com       # SSH 22: KEXINIT algorithms\n  qprobe --owned-hosts hosts.txt api.example.com:8443 --json\n\nqprobe reports the negotiated reality; it never modifies an endpoint (\"engine disposes\").";
+//# sourceMappingURL=args.d.ts.map

package/dist/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../src/args.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5D,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAyD1D;AAED,eAAO,MAAM,IAAI,06CA4ByE,CAAC"}

package/dist/args.js

@@ -0,0 +1,94 @@
+/**
+ * Hand-rolled CLI argument parser (zero dependencies), mirroring qScan's approach:
+ * the parser is pure and total — it never throws and never does I/O.
+ */
+export function parseArgs(argv) {
+    const args = {
+        targets: [],
+        mode: "auto",
+        iOwnThis: false,
+        timeoutMs: 8000,
+        format: "human",
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        switch (a) {
+            case "-h":
+            case "--help":
+                args.help = true;
+                break;
+            case "--i-own-this":
+                args.iOwnThis = true;
+                break;
+            case "--tls":
+                args.mode = "tls";
+                break;
+            case "--ssh":
+                args.mode = "ssh";
+                break;
+            case "--smtp":
+                args.mode = "smtp";
+                break;
+            case "--owned-hosts":
+                args.ownedHostsFile = argv[++i];
+                break;
+            case "--servername":
+                args.servername = argv[++i];
+                break;
+            case "--timeout":
+                args.timeoutMs = Number(argv[++i]) || args.timeoutMs;
+                break;
+            case "--format": {
+                const v = argv[++i];
+                if (v === "json" || v === "sarif" || v === "cbom" || v === "human")
+                    args.format = v;
+                break;
+            }
+            case "--json":
+                args.format = "json";
+                break;
+            case "--sarif":
+                args.format = "sarif";
+                break;
+            case "--cbom":
+                args.format = "cbom";
+                break;
+            default:
+                if (a && !a.startsWith("-"))
+                    args.targets.push(a);
+                break;
+        }
+    }
+    return args;
+}
+export const HELP = `qprobe — active post-quantum readiness probing of live TLS/SSH endpoints you OWN.
+
+USAGE
+  qprobe [options] <host[:port]> [host[:port] ...]
+
+AUTHORIZATION (required — one of)
+  --i-own-this            Attest you are authorized to probe the given endpoint(s).
+  --owned-hosts <file>    Ownership manifest (one host per line, # comments).
+
+  Active probing of endpoints you do not own may be unlawful. qprobe refuses CIDR
+  blocks, IP ranges, wildcards and target lists. See THREAT-MODEL.md.
+
+OPTIONS
+  --tls | --ssh | --smtp  Force a probe mode (default: auto — SSH on :22, SMTP
+                          STARTTLS on :25/:587, else TLS).
+  --servername <name>     TLS SNI server name (default: the host).
+  --timeout <ms>          Per-connection timeout (default: 8000).
+  --format <human|json|sarif|cbom>
+                          Output format (default: human). --json / --sarif / --cbom
+                          are aliases. SARIF 2.1.0 and CycloneDX 1.6 CBOM compose
+                          with qScan output (same formats).
+  -h, --help              Show this help.
+
+EXAMPLES
+  qprobe --i-own-this example.com                 # TLS 443: hybrid KEX + cert posture
+  qprobe --ssh --i-own-this git.example.com       # SSH 22: KEXINIT algorithms
+  qprobe --owned-hosts hosts.txt api.example.com:8443 --json
+
+qprobe reports the negotiated reality; it never modifies an endpoint ("engine disposes").`;
+//# sourceMappingURL=args.js.map

package/dist/args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.js","sourceRoot":"","sources":["../src/args.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgBH,MAAM,UAAU,SAAS,CAAC,IAAuB;IAC/C,MAAM,IAAI,GAAY;QACpB,OAAO,EAAE,EAAE;QACX,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,KAAK;QACf,SAAS,EAAE,IAAI;QACf,MAAM,EAAE,OAAO;QACf,IAAI,EAAE,KAAK;KACZ,CAAC;IACF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,QAAQ,CAAC,EAAE,CAAC;YACV,KAAK,IAAI,CAAC;YACV,KAAK,QAAQ;gBACX,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;gBACjB,MAAM;YACR,KAAK,cAAc;gBACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACrB,MAAM;YACR,KAAK,OAAO;gBACV,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;gBAClB,MAAM;YACR,KAAK,OAAO;gBACV,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;gBAClB,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;gBACnB,MAAM;YACR,KAAK,eAAe;gBAClB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;gBAChC,MAAM;YACR,KAAK,cAAc;gBACjB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC5B,MAAM;YACR,KAAK,WAAW;gBACd,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC;gBACrD,MAAM;YACR,KAAK,UAAU,CAAC,CAAC,CAAC;gBAChB,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;gBACpB,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,OAAO;oBAAE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;gBACpF,MAAM;YACR,CAAC;YACD,KAAK,QAAQ;gBACX,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;gBACrB,MAAM;YACR,KAAK,SAAS;gBACZ,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;gBACtB,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;gBACrB,MAAM;YACR;gBACE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC;oBAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAClD,MAAM;QACV,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,CAAC,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;0FA4BsE,CAAC","sourcesContent":["/**\n * Hand-rolled CLI argument parser (zero dependencies), mirroring qScan's approach:\n * the parser is pure and total — it never throws and never does I/O.\n */\n\nexport type ProbeModeArg = \"tls\" | \"ssh\" | \"smtp\" | \"auto\";\nexport type FormatArg = \"human\" | \"json\" | \"sarif\" | \"cbom\";\n\nexport interface CliArgs {\n  targets: string[];\n  mode: ProbeModeArg;\n  iOwnThis: boolean;\n  ownedHostsFile?: string;\n  servername?: string;\n  timeoutMs: number;\n  format: FormatArg;\n  help: boolean;\n}\n\nexport function parseArgs(argv: readonly string[]): CliArgs {\n  const args: CliArgs = {\n    targets: [],\n    mode: \"auto\",\n    iOwnThis: false,\n    timeoutMs: 8000,\n    format: \"human\",\n    help: false,\n  };\n  for (let i = 0; i < argv.length; i++) {\n    const a = argv[i];\n    switch (a) {\n      case \"-h\":\n      case \"--help\":\n        args.help = true;\n        break;\n      case \"--i-own-this\":\n        args.iOwnThis = true;\n        break;\n      case \"--tls\":\n        args.mode = \"tls\";\n        break;\n      case \"--ssh\":\n        args.mode = \"ssh\";\n        break;\n      case \"--smtp\":\n        args.mode = \"smtp\";\n        break;\n      case \"--owned-hosts\":\n        args.ownedHostsFile = argv[++i];\n        break;\n      case \"--servername\":\n        args.servername = argv[++i];\n        break;\n      case \"--timeout\":\n        args.timeoutMs = Number(argv[++i]) || args.timeoutMs;\n        break;\n      case \"--format\": {\n        const v = argv[++i];\n        if (v === \"json\" || v === \"sarif\" || v === \"cbom\" || v === \"human\") args.format = v;\n        break;\n      }\n      case \"--json\":\n        args.format = \"json\";\n        break;\n      case \"--sarif\":\n        args.format = \"sarif\";\n        break;\n      case \"--cbom\":\n        args.format = \"cbom\";\n        break;\n      default:\n        if (a && !a.startsWith(\"-\")) args.targets.push(a);\n        break;\n    }\n  }\n  return args;\n}\n\nexport const HELP = `qprobe — active post-quantum readiness probing of live TLS/SSH endpoints you OWN.\n\nUSAGE\n  qprobe [options] <host[:port]> [host[:port] ...]\n\nAUTHORIZATION (required — one of)\n  --i-own-this            Attest you are authorized to probe the given endpoint(s).\n  --owned-hosts <file>    Ownership manifest (one host per line, # comments).\n\n  Active probing of endpoints you do not own may be unlawful. qprobe refuses CIDR\n  blocks, IP ranges, wildcards and target lists. See THREAT-MODEL.md.\n\nOPTIONS\n  --tls | --ssh | --smtp  Force a probe mode (default: auto — SSH on :22, SMTP\n                          STARTTLS on :25/:587, else TLS).\n  --servername <name>     TLS SNI server name (default: the host).\n  --timeout <ms>          Per-connection timeout (default: 8000).\n  --format <human|json|sarif|cbom>\n                          Output format (default: human). --json / --sarif / --cbom\n                          are aliases. SARIF 2.1.0 and CycloneDX 1.6 CBOM compose\n                          with qScan output (same formats).\n  -h, --help              Show this help.\n\nEXAMPLES\n  qprobe --i-own-this example.com                 # TLS 443: hybrid KEX + cert posture\n  qprobe --ssh --i-own-this git.example.com       # SSH 22: KEXINIT algorithms\n  qprobe --owned-hosts hosts.txt api.example.com:8443 --json\n\nqprobe reports the negotiated reality; it never modifies an endpoint (\"engine disposes\").`;\n"]}

package/dist/attest.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Ownership attestation — the first-class authorization gate for active probing.
+ *
+ * qProbe MUST NOT connect to an endpoint until the operator has attested they are
+ * authorized to test it. Attestation comes from exactly one of:
+ *   - `--i-own-this`            : an explicit per-run attestation for the target(s).
+ *   - `--owned-hosts <file>`    : an ownership manifest (one host per line, `#`
+ *                                 comments allowed); every target host must appear.
+ *
+ * With neither, {@link authorizeTargets} throws and NOTHING connects. This is a
+ * code-enforced control, not a prompt: see THREAT-MODEL.md §Authorization.
+ */
+import type { Target } from "./target.js";
+export declare class AttestationError extends Error {
+    constructor(message: string);
+}
+export interface AttestationInput {
+    /** `--i-own-this` was passed. */
+    iOwnThis: boolean;
+    /** Parsed contents of an ownership manifest, if `--owned-hosts` was given. */
+    ownedHosts?: readonly string[];
+}
+/** Parse an ownership manifest file's text into a host allow-list. */
+export declare function parseOwnedHosts(text: string): string[];
+/**
+ * Authorize a set of targets or throw {@link AttestationError}. Returns silently
+ * when every target is covered by the attestation. No network I/O happens here or
+ * anywhere upstream of a successful return.
+ */
+export declare function authorizeTargets(targets: readonly Target[], attest: AttestationInput): void;
+//# sourceMappingURL=attest.d.ts.map

package/dist/attest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attest.d.ts","sourceRoot":"","sources":["../src/attest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,QAAQ,EAAE,OAAO,CAAC;IAClB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAStD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAsB3F"}

package/dist/attest.js

@@ -0,0 +1,39 @@
+export class AttestationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AttestationError";
+    }
+}
+/** Parse an ownership manifest file's text into a host allow-list. */
+export function parseOwnedHosts(text) {
+    return (text
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l !== "" && !l.startsWith("#"))
+        // A manifest line may be `host` or `host:port`; ownership is per host.
+        .map((l) => (l.startsWith("[") ? l : l.split(":")[0])));
+}
+/**
+ * Authorize a set of targets or throw {@link AttestationError}. Returns silently
+ * when every target is covered by the attestation. No network I/O happens here or
+ * anywhere upstream of a successful return.
+ */
+export function authorizeTargets(targets, attest) {
+    if (targets.length === 0)
+        throw new AttestationError("no targets to authorize");
+    if (attest.ownedHosts && attest.ownedHosts.length > 0) {
+        const owned = new Set(attest.ownedHosts.map((h) => h.toLowerCase()));
+        const missing = targets.filter((t) => !owned.has(t.host.toLowerCase()));
+        if (missing.length > 0) {
+            throw new AttestationError(`not authorized: ${missing.map((t) => t.host).join(", ")} not in the ownership manifest. ` +
+                `Add the host(s) to the manifest, or pass --i-own-this only for endpoints you control.`);
+        }
+        return;
+    }
+    if (attest.iOwnThis)
+        return;
+    throw new AttestationError("refusing to probe: no ownership attestation. Pass --i-own-this (endpoints you control) " +
+        "or --owned-hosts <manifest>. Active probing of endpoints you do not own may be unlawful; " +
+        "see THREAT-MODEL.md.");
+}
+//# sourceMappingURL=attest.js.map

package/dist/attest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attest.js","sourceRoot":"","sources":["../src/attest.ts"],"names":[],"mappings":"AAcA,MAAM,OAAO,gBAAiB,SAAQ,KAAK;IACzC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AASD,sEAAsE;AACtE,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,CACL,IAAI;SACD,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAC9C,uEAAuE;SACtE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CACzD,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAA0B,EAAE,MAAwB;IACnF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,gBAAgB,CAAC,yBAAyB,CAAC,CAAC;IAEhF,IAAI,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtD,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QACrE,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QACxE,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,gBAAgB,CACxB,mBAAmB,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,kCAAkC;gBACxF,uFAAuF,CAC1F,CAAC;QACJ,CAAC;QACD,OAAO;IACT,CAAC;IAED,IAAI,MAAM,CAAC,QAAQ;QAAE,OAAO;IAE5B,MAAM,IAAI,gBAAgB,CACxB,yFAAyF;QACvF,2FAA2F;QAC3F,sBAAsB,CACzB,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Ownership attestation — the first-class authorization gate for active probing.\n *\n * qProbe MUST NOT connect to an endpoint until the operator has attested they are\n * authorized to test it. Attestation comes from exactly one of:\n *   - `--i-own-this`            : an explicit per-run attestation for the target(s).\n *   - `--owned-hosts <file>`    : an ownership manifest (one host per line, `#`\n *                                 comments allowed); every target host must appear.\n *\n * With neither, {@link authorizeTargets} throws and NOTHING connects. This is a\n * code-enforced control, not a prompt: see THREAT-MODEL.md §Authorization.\n */\nimport type { Target } from \"./target.js\";\n\nexport class AttestationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AttestationError\";\n  }\n}\n\nexport interface AttestationInput {\n  /** `--i-own-this` was passed. */\n  iOwnThis: boolean;\n  /** Parsed contents of an ownership manifest, if `--owned-hosts` was given. */\n  ownedHosts?: readonly string[];\n}\n\n/** Parse an ownership manifest file's text into a host allow-list. */\nexport function parseOwnedHosts(text: string): string[] {\n  return (\n    text\n      .split(\"\\n\")\n      .map((l) => l.trim())\n      .filter((l) => l !== \"\" && !l.startsWith(\"#\"))\n      // A manifest line may be `host` or `host:port`; ownership is per host.\n      .map((l) => (l.startsWith(\"[\") ? l : l.split(\":\")[0]))\n  );\n}\n\n/**\n * Authorize a set of targets or throw {@link AttestationError}. Returns silently\n * when every target is covered by the attestation. No network I/O happens here or\n * anywhere upstream of a successful return.\n */\nexport function authorizeTargets(targets: readonly Target[], attest: AttestationInput): void {\n  if (targets.length === 0) throw new AttestationError(\"no targets to authorize\");\n\n  if (attest.ownedHosts && attest.ownedHosts.length > 0) {\n    const owned = new Set(attest.ownedHosts.map((h) => h.toLowerCase()));\n    const missing = targets.filter((t) => !owned.has(t.host.toLowerCase()));\n    if (missing.length > 0) {\n      throw new AttestationError(\n        `not authorized: ${missing.map((t) => t.host).join(\", \")} not in the ownership manifest. ` +\n          `Add the host(s) to the manifest, or pass --i-own-this only for endpoints you control.`,\n      );\n    }\n    return;\n  }\n\n  if (attest.iOwnThis) return;\n\n  throw new AttestationError(\n    \"refusing to probe: no ownership attestation. Pass --i-own-this (endpoints you control) \" +\n      \"or --owned-hosts <manifest>. Active probing of endpoints you do not own may be unlawful; \" +\n      \"see THREAT-MODEL.md.\",\n  );\n}\n"]}

package/dist/classify.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Map live-probe results onto `@quantakrypto/core` Findings, so qProbe output
+ * scores and reports through the same engine as qScan (buildInventory, toSarif,
+ * toJson, toCbom). A positive result (PQC-hybrid TLS selected, or PQC SSH KEX
+ * offered) intentionally emits NO finding — good news keeps the readiness score
+ * high; it is surfaced separately in the human summary.
+ *
+ * Findings are synthesised with `location.file = "host:port"` and line 1, since a
+ * live endpoint has no source position.
+ */
+import type { Finding } from "@quantakrypto/core";
+import type { Target } from "./target.js";
+import type { TlsNegotiated, HybridSupport } from "./tls.js";
+import type { SshProbeResult } from "./ssh.js";
+/** Findings for a TLS endpoint from the negotiated params + the hybrid probe. */
+export declare function classifyTls(target: Target, neg: TlsNegotiated, hybrid: HybridSupport): Finding[];
+/** Findings for an SSH endpoint from its KEXINIT. */
+export declare function classifySsh(target: Target, ssh: SshProbeResult): Finding[];
+//# sourceMappingURL=classify.d.ts.map

package/dist/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../src/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAmB,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAkB/C,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,EAAE,CAkEhG;AAED,qDAAqD;AACrD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,EAAE,CAsB1E"}

package/dist/classify.js

@@ -0,0 +1,105 @@
+import { CWE_BROKEN_CRYPTO, CWE_RISKY_PRIMITIVE, CWE_WEAK_STRENGTH } from "@quantakrypto/core";
+function endpoint(t) {
+    return { file: `${t.host}:${t.port}`, line: 1 };
+}
+/** Classify a TLS ephemeral group name into a classical algorithm family, or undefined if PQ/unknown. */
+function classicalKexFamily(group) {
+    if (!group)
+        return undefined;
+    const g = group.toLowerCase();
+    if (g.includes("mlkem") || g.includes("kyber"))
+        return undefined; // already PQ-hybrid
+    if (g === "x25519")
+        return "X25519";
+    if (g === "x448")
+        return "X448";
+    if (g.startsWith("p-") || g.includes("prime256") || g.includes("secp"))
+        return "ECDH";
+    if (g === "dh" || g.includes("ffdhe") || g.includes("modp"))
+        return "DH";
+    return undefined;
+}
+/** Findings for a TLS endpoint from the negotiated params + the hybrid probe. */
+export function classifyTls(target, neg, hybrid) {
+    const out = [];
+    const loc = endpoint(target);
+    if (neg.protocol === "TLSv1" || neg.protocol === "TLSv1.1") {
+        out.push({
+            ruleId: "qprobe-tls-legacy-version",
+            title: "Legacy TLS version negotiated",
+            category: "tls",
+            severity: "high",
+            confidence: "high",
+            hndl: false,
+            cwe: CWE_RISKY_PRIMITIVE,
+            message: `Endpoint negotiated ${neg.protocol}; obsolete TLS with weak, harvestable key exchange.`,
+            remediation: "Require TLS 1.3.",
+            location: loc,
+        });
+    }
+    // Flag classical KEX when the server did NOT select a PQC-hybrid group. The
+    // negotiated group (from node:tls, which cannot do hybrid) is factual; only the
+    // "did not select hybrid" claim depends on the raw probe, so soften it when the
+    // hybrid probe was inconclusive (e.g. a firewall dropped the raw ClientHello).
+    const fam = classicalKexFamily(neg.kexGroup);
+    if (!hybrid.hybridSelected && fam) {
+        const hybridNote = hybrid.error
+            ? "the PQC-hybrid probe was inconclusive"
+            : "the server did not select a PQC-hybrid group (X25519MLKEM768)";
+        out.push({
+            ruleId: "qprobe-tls-classical-kex",
+            title: "Classical TLS key exchange (no PQC hybrid)",
+            category: "key-exchange",
+            severity: "medium",
+            confidence: hybrid.error ? "medium" : "high",
+            algorithm: fam,
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: `TLS key exchange is classical ${neg.kexGroup}; the session key is harvest-now-decrypt-later exposed and ${hybridNote}.`,
+            remediation: "Enable a PQC-hybrid key-exchange group (X25519MLKEM768) on the TLS terminator.",
+            location: loc,
+        });
+    }
+    if (neg.certKeyType) {
+        const isRsa = neg.certKeyType === "RSA";
+        out.push({
+            ruleId: "qprobe-tls-classical-cert",
+            title: "Classical certificate key",
+            category: "certificate",
+            severity: "low",
+            confidence: "high",
+            algorithm: isRsa ? "RSA" : "ECDSA",
+            hndl: false,
+            cwe: isRsa ? CWE_BROKEN_CRYPTO : CWE_WEAK_STRENGTH,
+            message: `Leaf certificate uses a classical ${neg.certKeyType}${neg.certKeyBits ? `-${neg.certKeyBits}` : ""} key${neg.certSigFamily ? `, signed by the CA with ${neg.certSigFamily}` : ""}; its signature is forgeable once a CRQC exists.`,
+            remediation: "Plan migration to ML-DSA-65 (FIPS 204) certificate keys as your CA adds support.",
+            location: loc,
+        });
+    }
+    return out;
+}
+/** Findings for an SSH endpoint from its KEXINIT. */
+export function classifySsh(target, ssh) {
+    const out = [];
+    if (ssh.error || !ssh.kex)
+        return out;
+    if (!ssh.pqKexOffered) {
+        out.push({
+            ruleId: "qprobe-ssh-classical-kex",
+            title: "SSH offers only classical key exchange",
+            category: "key-exchange",
+            severity: "medium",
+            confidence: "high",
+            algorithm: "ECDH",
+            hndl: true,
+            cwe: CWE_BROKEN_CRYPTO,
+            message: `SSH endpoint offers no post-quantum key exchange (${ssh.kex.kexAlgorithms
+                .slice(0, 4)
+                .join(", ")}…); session keys are harvest-now-decrypt-later exposed.`,
+            remediation: "Enable a PQC hybrid SSH KEX (sntrup761x25519-sha512@openssh.com or mlkem768x25519-sha256).",
+            location: endpoint(target),
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=classify.js.map

package/dist/classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.js","sourceRoot":"","sources":["../src/classify.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Map live-probe results onto `@quantakrypto/core` Findings, so qProbe output\n * scores and reports through the same engine as qScan (buildInventory, toSarif,\n * toJson, toCbom). A positive result (PQC-hybrid TLS selected, or PQC SSH KEX\n * offered) intentionally emits NO finding — good news keeps the readiness score\n * high; it is surfaced separately in the human summary.\n *\n * Findings are synthesised with `location.file = \"host:port\"` and line 1, since a\n * live endpoint has no source position.\n */\nimport type { AlgorithmFamily, Finding } from \"@quantakrypto/core\";\nimport { CWE_BROKEN_CRYPTO, CWE_RISKY_PRIMITIVE, CWE_WEAK_STRENGTH } from \"@quantakrypto/core\";\nimport type { Target } from \"./target.js\";\nimport type { TlsNegotiated, HybridSupport } from \"./tls.js\";\nimport type { SshProbeResult } from \"./ssh.js\";\n\nfunction endpoint(t: Target): Finding[\"location\"] {\n  return { file: `${t.host}:${t.port}`, line: 1 };\n}\n\n/** Classify a TLS ephemeral group name into a classical algorithm family, or undefined if PQ/unknown. */\nfunction classicalKexFamily(group?: string): AlgorithmFamily | undefined {\n  if (!group) return undefined;\n  const g = group.toLowerCase();\n  if (g.includes(\"mlkem\") || g.includes(\"kyber\")) return undefined; // already PQ-hybrid\n  if (g === \"x25519\") return \"X25519\";\n  if (g === \"x448\") return \"X448\";\n  if (g.startsWith(\"p-\") || g.includes(\"prime256\") || g.includes(\"secp\")) return \"ECDH\";\n  if (g === \"dh\" || g.includes(\"ffdhe\") || g.includes(\"modp\")) return \"DH\";\n  return undefined;\n}\n\n/** Findings for a TLS endpoint from the negotiated params + the hybrid probe. */\nexport function classifyTls(target: Target, neg: TlsNegotiated, hybrid: HybridSupport): Finding[] {\n  const out: Finding[] = [];\n  const loc = endpoint(target);\n\n  if (neg.protocol === \"TLSv1\" || neg.protocol === \"TLSv1.1\") {\n    out.push({\n      ruleId: \"qprobe-tls-legacy-version\",\n      title: \"Legacy TLS version negotiated\",\n      category: \"tls\",\n      severity: \"high\",\n      confidence: \"high\",\n      hndl: false,\n      cwe: CWE_RISKY_PRIMITIVE,\n      message: `Endpoint negotiated ${neg.protocol}; obsolete TLS with weak, harvestable key exchange.`,\n      remediation: \"Require TLS 1.3.\",\n      location: loc,\n    });\n  }\n\n  // Flag classical KEX when the server did NOT select a PQC-hybrid group. The\n  // negotiated group (from node:tls, which cannot do hybrid) is factual; only the\n  // \"did not select hybrid\" claim depends on the raw probe, so soften it when the\n  // hybrid probe was inconclusive (e.g. a firewall dropped the raw ClientHello).\n  const fam = classicalKexFamily(neg.kexGroup);\n  if (!hybrid.hybridSelected && fam) {\n    const hybridNote = hybrid.error\n      ? \"the PQC-hybrid probe was inconclusive\"\n      : \"the server did not select a PQC-hybrid group (X25519MLKEM768)\";\n    out.push({\n      ruleId: \"qprobe-tls-classical-kex\",\n      title: \"Classical TLS key exchange (no PQC hybrid)\",\n      category: \"key-exchange\",\n      severity: \"medium\",\n      confidence: hybrid.error ? \"medium\" : \"high\",\n      algorithm: fam,\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message: `TLS key exchange is classical ${neg.kexGroup}; the session key is harvest-now-decrypt-later exposed and ${hybridNote}.`,\n      remediation: \"Enable a PQC-hybrid key-exchange group (X25519MLKEM768) on the TLS terminator.\",\n      location: loc,\n    });\n  }\n\n  if (neg.certKeyType) {\n    const isRsa = neg.certKeyType === \"RSA\";\n    out.push({\n      ruleId: \"qprobe-tls-classical-cert\",\n      title: \"Classical certificate key\",\n      category: \"certificate\",\n      severity: \"low\",\n      confidence: \"high\",\n      algorithm: isRsa ? \"RSA\" : \"ECDSA\",\n      hndl: false,\n      cwe: isRsa ? CWE_BROKEN_CRYPTO : CWE_WEAK_STRENGTH,\n      message: `Leaf certificate uses a classical ${neg.certKeyType}${\n        neg.certKeyBits ? `-${neg.certKeyBits}` : \"\"\n      } key${\n        neg.certSigFamily ? `, signed by the CA with ${neg.certSigFamily}` : \"\"\n      }; its signature is forgeable once a CRQC exists.`,\n      remediation:\n        \"Plan migration to ML-DSA-65 (FIPS 204) certificate keys as your CA adds support.\",\n      location: loc,\n    });\n  }\n\n  return out;\n}\n\n/** Findings for an SSH endpoint from its KEXINIT. */\nexport function classifySsh(target: Target, ssh: SshProbeResult): Finding[] {\n  const out: Finding[] = [];\n  if (ssh.error || !ssh.kex) return out;\n  if (!ssh.pqKexOffered) {\n    out.push({\n      ruleId: \"qprobe-ssh-classical-kex\",\n      title: \"SSH offers only classical key exchange\",\n      category: \"key-exchange\",\n      severity: \"medium\",\n      confidence: \"high\",\n      algorithm: \"ECDH\",\n      hndl: true,\n      cwe: CWE_BROKEN_CRYPTO,\n      message: `SSH endpoint offers no post-quantum key exchange (${ssh.kex.kexAlgorithms\n        .slice(0, 4)\n        .join(\", \")}…); session keys are harvest-now-decrypt-later exposed.`,\n      remediation:\n        \"Enable a PQC hybrid SSH KEX (sntrup761x25519-sha512@openssh.com or mlkem768x25519-sha256).\",\n      location: endpoint(target),\n    });\n  }\n  return out;\n}\n"]}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}