@mark1russell7/netdiag 0.0.0-stage → 0.1.1

package/build/index.d.ts

@@ -0,0 +1,392 @@
+import { i as layerRank, n as Layer, r as isLayer, t as LAYERS } from "./layer-BNg0VYuK.js";
+import { $ as HostKind, A as TRACE_OUTCOMES, B as ProbeContext, C as PathTrace, D as TCP_CONNECT, E as ReportHop, F as TraceHop, G as FactSource, H as defineProbe, I as TraceOutcome, J as ValueOf, K as FactTime, L as Trust, M as TcpConnect, N as TlsCertificate, O as TLS_HANDSHAKE, P as TlsHandshake, Q as observe, R as Availability, S as PathReport, T as RecordType, U as Fact, V as ProbeMode, W as FactKind, X as factsOf, Y as defineFactKind, Z as isFactOf, _ as ICMP_ECHO, a as DNS_ANSWER, at as sameTarget, b as PATH_REPORT, c as DnsOutcome, d as HANDSHAKE_OUTCOMES, et as Target, f as HTTP_OUTCOMES, g as HttpResponse, h as HttpOutcome, i as ConnectOutcome, it as parseTarget, j as TRUSTS, k as TOOL_KINDS, l as ECHO_OUTCOMES, m as HandshakeOutcome, n as CONNECT_OUTCOMES, nt as formatTarget, o as DNS_OUTCOMES, ot as target, p as HTTP_RESPONSE, q as Observation, r as CertProblem, rt as hostKind, s as DnsAnswer, t as CERT_PROBLEMS, tt as canonicalHost, u as EchoOutcome, v as IcmpEcho, w as RECORD_TYPES, x as PATH_TRACE, y as NATIVE_KINDS, z as Probe } from "./kinds-_NShfZpU.js";
+import { ADDRESS_CLASSES, AddressClass, AddressFamily, Cidr, CidrSet, addressClass, addressFamily, addressKind, canonicalAddress, cidrContains, cidrSet, formatCidr, parseCidr } from "./address.js";
+import { A as Part, B as predictive, C as Expectation, D as Hypothesis, E as Feature, F as UNKNOWN, I as compileCatalog, L as diagnose, M as Reach, N as STRENGTHS, O as NONE, P as Strength, R as expand, S as Evidence, T as Fault, _ as CatalogSpec, a as LabRecord, b as Diagnosis, c as LabVerdict, d as scoreLab, f as STANDARD_CATALOG, g as Catalog, h as STANDARD_FEATURES, i as LabGate, j as Prediction, k as PARTS, l as labGate, m as STANDARD_FAULTS, n as LabBars, o as LabScore, p as STANDARD_CATALOG_SPEC, r as LabCause, s as LabStatus, t as LAB_RECORD_FORMAT, u as labRecordOf, v as Cause, w as FLOOR, x as Distribution, y as Contribution, z as explain } from "./index-K2dGiYxW.js";
+import { Socket, TcpNetConnectOpts } from "node:net";
+import { Result } from "@mark1russell7/optional";
+import { Clock } from "@mark1russell7/algebra/clock";
+/**
+ * The basis of a grant: why a target is in the scope.
+ *
+ * - `named`: the user named the target for this diagnosis.
+ * - `owned`: the user declares that the user owns the network or the host.
+ * - `configured`: the configuration of the computer of the user names it, for example the gateway or the DNS resolver.
+ * - `resolved`: a DNS answer for a granted name gave this address.
+ */
+type GrantBasis = "named" | "owned" | "configured" | "resolved";
+/**
+ * A grant puts targets in the scope.
+ *
+ * A `host` grant puts a DNS name in the scope, and with `subdomains` each name under it. A `range` grant puts the
+ * addresses of a CIDR range in the scope, for example `192.0.2.0/24` or `2001:db8::/32`.
+ */
+type Grant = HostGrant | RangeGrant;
+/** A grant of a DNS name, and with `subdomains` of each name under it. */
+interface HostGrant {
+  readonly kind: "host";
+  readonly host: string;
+  readonly subdomains?: boolean | undefined;
+  readonly basis: GrantBasis;
+  readonly note?: string | undefined;
+}
+/** A grant of the addresses of a CIDR range, for example `192.0.2.0/24` or `2001:db8::/32`. */
+interface RangeGrant {
+  readonly kind: "range";
+  readonly cidr: string;
+  readonly basis: GrantBasis;
+  readonly note?: string | undefined;
+}
+/**
+ * The scope of a diagnosis: the grants, and the largest number of ports for each host.
+ *
+ * An active probe sends packets only to a peer in the scope. The limit of ports stops a port scan: netdiag does no
+ * vulnerability scan.
+ */
+interface Scope {
+  readonly grants: readonly Grant[];
+  readonly maxPortsPerHost: number;
+}
+/** The default limit of the different ports of one host in one runner. */
+export declare const DEFAULT_MAX_PORTS_PER_HOST = 8;
+/** The decision of the scope for one peer of an active probe. A refusal has the reason in plain words. */
+type ScopeDecision = {
+  readonly allowed: true;
+  readonly grant: Grant;
+} | {
+  readonly allowed: false;
+  readonly reason: string;
+};
+/** The ports that a runner sent packets to, for each host. */
+type PortLedger = ReadonlyMap<string, ReadonlySet<number>>;
+/** This function gives the problems of a grant, or an empty list for a correct grant. */
+export declare function grantProblems(grant: Grant): string[];
+/**
+ * This function makes a scope from grants. It refuses a grant with a problem, so a typing error cannot widen the scope.
+ *
+ * The default limit of ports is `DEFAULT_MAX_PORTS_PER_HOST`.
+ */
+export declare function scopeOf(grants: readonly Grant[], options?: {
+  readonly maxPortsPerHost?: number;
+}): Result<Scope, string[]>;
+/**
+ * This function gives the grant for a target that the user names. A name gets a host grant. An IP address gets a
+ * range grant of one address.
+ */
+export declare function namedGrant(t: Target, note?: string): Grant;
+/** This function gives the grant of one address that a DNS answer for a granted name gave. */
+export declare function resolvedGrant(name: string, address: string, factId?: string): RangeGrant;
+/** This function gives a scope with more grants. The limit of ports does not change. */
+export declare function widen(scope: Scope, grants: readonly Grant[]): Result<Scope, string[]>;
+/**
+ * This function decides if an active probe can send packets to a peer.
+ *
+ * The peer must match a grant of the scope. A new port of a host must also stay in the limit of ports for each host.
+ * The ledger has the ports that the runner sent packets to before.
+ */
+export declare function decideScope(scope: Scope, peer: Target, ledger?: PortLedger): ScopeDecision;
+/**
+ * The outcome of one run of a probe.
+ *
+ * - `done`: the probe did its work. The facts include each network failure that it saw.
+ * - `refused`: a peer is not in the scope, so the probe did not start.
+ * - `unavailable`: the probe cannot operate on this computer.
+ * - `failed`: the probe or its parser has a fault. The raw output is present when the run ended.
+ * - `aborted`: the signal stopped the run.
+ */
+type ProbeOutcome<R> = {
+  readonly status: "done";
+  readonly time: FactTime;
+  readonly raw: R;
+  readonly facts: readonly Fact[];
+} | {
+  readonly status: "refused";
+  readonly peer: Target;
+  readonly reason: string;
+} | {
+  readonly status: "unavailable";
+  readonly reason: string;
+} | {
+  readonly status: "failed";
+  readonly stage: "probe" | "run" | "parse";
+  readonly error: string;
+  readonly raw?: R | undefined;
+} | {
+  readonly status: "aborted";
+  readonly reason: string;
+};
+/** The wall-clock time of one monotonic time of the runner. */
+interface ClockOrigin {
+  readonly wall: string;
+  readonly monotonic: number;
+}
+/** The options of a runner. */
+interface RunnerOptions {
+  readonly scope: Scope;
+  readonly clock: Clock;
+  /** The wall-clock time of the start, as an ISO 8601 text. The default is the time of the computer. */
+  readonly wall?: string | undefined;
+}
+/**
+ * A runner starts probes in one scope, and keeps the facts of the diagnosis.
+ *
+ * It gives each fact an id in sequence. It keeps the ledger of the ports of each host, for the limit of ports of the scope.
+ */
+interface Runner {
+  readonly origin: ClockOrigin;
+  scope(): Scope;
+  facts(): readonly Fact[];
+  /** This method adds grants to the scope, for example the addresses of a granted name. */
+  grant(grants: readonly Grant[]): void;
+  run<I, R>(probe: Probe<I, R>, input: I, signal?: AbortSignal): Promise<ProbeOutcome<R>>;
+}
+/** This function makes a runner. */
+export declare function createRunner(options: RunnerOptions): Runner;
+/** The function that opens a TCP socket. A test can give a function that gives a socket with no connection. */
+type Dial = (options: TcpNetConnectOpts) => Socket;
+/** The options of the native probes that connect. */
+interface ConnectOptions {
+  /** The function that opens a TCP socket. The default is `connect` of `node:net`. */
+  readonly dial?: Dial | undefined;
+}
+/** The time limit of a probe run, when its input gives none: 5 seconds. */
+export declare const DEFAULT_TIMEOUT_MS = 5e3;
+/** This function maps an error code of a TCP connect to its outcome. */
+export declare function connectOutcome(code: string | undefined): ConnectOutcome;
+/** This function maps an error of a TLS handshake to its outcome. */
+export declare function handshakeOutcome(thrown: unknown, expired: boolean): HandshakeOutcome;
+/** This function maps the authorization error of a TLS socket to the problem of the certificate. */
+export declare function certProblem(code: string): CertProblem;
+/** The TCP phase of a probe run. The times are readings of the clock of the runner. */
+interface TcpPhase {
+  readonly address: string;
+  readonly port: number;
+  readonly family: 4 | 6;
+  readonly start: number;
+  readonly end: number;
+  readonly outcome: ConnectOutcome;
+  readonly code?: string | undefined;
+}
+/** The TLS phase of a probe run. */
+interface TlsPhase {
+  readonly servername?: string | undefined;
+  readonly start: number;
+  readonly end: number;
+  readonly outcome: HandshakeOutcome;
+  readonly protocol?: string | undefined;
+  readonly cipher?: string | undefined;
+  readonly alpn?: string | undefined;
+  readonly code?: string | undefined;
+  readonly certificate?: TlsCertificate | undefined;
+}
+/** The fields of a response head that an HTTP fact keeps. */
+export declare const KEPT_FIELDS: readonly string[];
+/** The HTTP phase of a probe run. */
+interface HttpPhase {
+  readonly method: "GET" | "HEAD";
+  readonly host: string;
+  readonly path: string;
+  readonly start: number;
+  /** The time of the head of the response. */
+  readonly head?: number | undefined;
+  readonly end: number;
+  readonly outcome: HttpOutcome;
+  readonly status?: number | undefined;
+  readonly version?: string | undefined;
+  readonly fields: Readonly<Record<string, string>>;
+  readonly bytes: number;
+  readonly truncated: boolean;
+  readonly code?: string | undefined;
+}
+/** The input of the DNS probe: one query for the addresses of a name, to one resolver. */
+interface DnsInput {
+  readonly name: string;
+  /** The record type. The default is `A`. */
+  readonly record?: RecordType | undefined;
+  /** The IP address of the resolver. */
+  readonly resolver: string;
+  /** The port of the resolver. The default is 53. */
+  readonly port?: number | undefined;
+  readonly timeoutMs?: number | undefined;
+}
+/** The raw output of the DNS probe. The times are readings of the clock of the runner. */
+interface DnsRaw {
+  readonly name: string;
+  readonly record: RecordType;
+  readonly resolver: string;
+  readonly start: number;
+  readonly end: number;
+  readonly outcome: DnsOutcome;
+  readonly addresses: readonly string[];
+  readonly ttl?: number | undefined;
+  readonly code?: string | undefined;
+}
+/** This function maps an error code of a DNS query to its outcome. */
+export declare function dnsOutcome(code: string | undefined): DnsOutcome;
+/**
+ * The DNS probe sends one query for the addresses of a name to one resolver. Its peer is the resolver, not the name.
+ * The query uses no search domain.
+ */
+export declare const DNS_PROBE: Probe<DnsInput, DnsRaw>;
+/** The input of the TCP probe: one connect to an IP address and a port. */
+interface TcpInput {
+  readonly address: string;
+  readonly port: number;
+  readonly timeoutMs?: number | undefined;
+}
+/** The raw output of the TCP probe. */
+interface TcpRaw {
+  readonly tcp: TcpPhase;
+}
+/** This function makes the TCP probe. It connects, and then it closes the connection. */
+export declare function tcpProbe(options?: ConnectOptions): Probe<TcpInput, TcpRaw>;
+/** The TCP probe with the `connect` of `node:net`. */
+export declare const TCP_PROBE: Probe<TcpInput, TcpRaw>;
+/** The input of the TLS probe: a TCP connect and a TLS handshake. */
+interface TlsInput {
+  readonly address: string;
+  /** The port. The default is 443. */
+  readonly port?: number | undefined;
+  /** The name for SNI and for the check of the certificate. */
+  readonly servername?: string | undefined;
+  readonly alpn?: readonly string[] | undefined;
+  readonly timeoutMs?: number | undefined;
+}
+/** The raw output of the TLS probe. It has no TLS phase when the TCP connect failed. */
+interface TlsRaw {
+  readonly tcp: TcpPhase;
+  readonly tls?: TlsPhase | undefined;
+}
+/** The options of the TLS and HTTP probes. */
+interface TlsProbeOptions extends ConnectOptions {
+  /** More roots of trust, as PEM text: the roots that the user trusts, for example the root of a company. */
+  readonly roots?: readonly string[] | undefined;
+  /**
+   * More public roots, as PEM text. A chain that ends at one of them gets the trust `public`. A lab gives its own
+   * root here, so that its servers stand for servers on the internet.
+   */
+  readonly publicRoots?: readonly string[] | undefined;
+}
+/**
+ * This function makes the TLS probe. It measures the TCP connect and the TLS handshake apart. It examines the
+ * certificate, and it does not refuse a certificate that is not valid.
+ */
+export declare function tlsProbe(options?: TlsProbeOptions): Probe<TlsInput, TlsRaw>;
+/** The TLS probe with the public roots and the roots of the computer. */
+export declare const TLS_PROBE: Probe<TlsInput, TlsRaw>;
+/** The input of the HTTP probe: one HTTP/1.1 request over TCP, or over TLS for `https`. */
+interface HttpInput {
+  readonly address: string;
+  readonly scheme: "http" | "https";
+  /** The port. The default is 80 for `http` and 443 for `https`. */
+  readonly port?: number | undefined;
+  /** The name of the host for the `Host` field and for SNI. The default is the address. */
+  readonly host?: string | undefined;
+  /** The path of the request. The default is `/`. */
+  readonly path?: string | undefined;
+  /** The method. The default is `GET`. */
+  readonly method?: "GET" | "HEAD" | undefined;
+  readonly timeoutMs?: number | undefined;
+  /** The limit of the bytes of the body that the probe reads. The default is 65536. */
+  readonly maxBytes?: number | undefined;
+}
+/** The raw output of the HTTP probe. */
+interface HttpRaw {
+  readonly scheme: "http" | "https";
+  readonly tcp: TcpPhase;
+  readonly tls?: TlsPhase | undefined;
+  readonly http?: HttpPhase | undefined;
+}
+/** The limit of the bytes of a body that the HTTP probe reads, when its input gives none: 64 KiB. */
+export declare const DEFAULT_MAX_BYTES = 65536;
+/**
+ * This function makes the HTTP probe. It sends one request, follows no redirect, and reads the body up to a limit. It
+ * gives the facts of each phase: TCP, TLS for `https`, and HTTP. For `https`, it sends the request only when the
+ * certificate passes its check.
+ */
+export declare function httpProbe(options?: TlsProbeOptions): Probe<HttpInput, HttpRaw>;
+/** The HTTP probe with the public roots and the roots of the computer. */
+export declare const HTTP_PROBE: Probe<HttpInput, HttpRaw>;
+/** A fact that gave no evidence, with the reason in plain words. */
+export interface Skipped {
+  readonly fact: string;
+  readonly reason: string;
+}
+/** The evidence of a list of facts, and the facts that gave no evidence. */
+export interface Reading {
+  readonly evidence: readonly Evidence[];
+  readonly skipped: readonly Skipped[];
+}
+/** The options of `readEvidence`. */
+export interface ReadOptions {
+  /** This function tells if a fact is about the target (`true`) or about a reference host (`false`). The default is `true`. */
+  readonly primary?: ((fact: Fact) => boolean) | undefined;
+  /**
+   * The IP address of the default gateway. The ICMP echo facts of this address give the feature `gateway.reply`. The
+   * ICMP echo facts of the other addresses give the feature `icmp.reply`.
+   */
+  readonly gateway?: string | undefined;
+}
+/** A bin of a time or a ratio. A number below `below` gets `value`. The last bin has no limit. */
+export interface Bin {
+  readonly below?: number | undefined;
+  readonly value: string;
+}
+/** The bins of the feature `tcp.time`, in milliseconds. A connect of 900 ms or more sent its SYN again. */
+export declare const TCP_TIME_BINS: readonly Bin[];
+/** The bins of the feature `tls.ratio`: the time of the TLS handshake divided by the time of the TCP connect. */
+export declare const TLS_RATIO_BINS: readonly Bin[];
+/** The bins of the feature `http.ttfb`: the time to the first byte divided by the time of the TCP connect. */
+export declare const HTTP_TTFB_BINS: readonly Bin[];
+/**
+ * The smallest time of a TCP connect in a ratio, in milliseconds. On a local link, a ratio with a smaller time measures
+ * only the cost of the cryptography.
+ */
+export declare const MIN_CONNECT_MS = 1;
+/** The value of the feature `dns.answer` for each outcome of a DNS query. `nodata` tells that the name exists. */
+export declare const DNS_ANSWER_VALUES: Readonly<Partial<Record<DnsOutcome, string>>>;
+/** The value of the feature `tcp.connect` for each outcome of a TCP connect. */
+export declare const TCP_CONNECT_VALUES: Readonly<Partial<Record<ConnectOutcome, string>>>;
+/**
+ * The value of the feature `tls.handshake` for each outcome of a TLS handshake. The catalog has no value for `not-tls`
+ * and `closed` yet. The lab runs (ND-7) tell which faults cause them.
+ */
+export declare const TLS_HANDSHAKE_VALUES: Readonly<Partial<Record<HandshakeOutcome, string>>>;
+/** The value of the feature `tls.trust` for each trust. A chain that ends at no root of the store has no public root. */
+export declare const TLS_TRUST_VALUES: Readonly<Record<Trust, string>>;
+/** The value of the feature `icmp.reply` for each outcome of the ICMP echo requests to an address. */
+export declare const ICMP_REPLY_VALUES: Readonly<Partial<Record<EchoOutcome, string>>>;
+/**
+ * The value of the feature `gateway.reply` for each outcome of the ICMP echo requests to the gateway. When this computer
+ * tells that the gateway is unreachable, the gateway gives no reply.
+ */
+export declare const GATEWAY_REPLY_VALUES: Readonly<Partial<Record<EchoOutcome, string>>>;
+/**
+ * The bins of the feature `path.loss`, on the share of the echo requests with a reply. A share of 1 has no loss. A share
+ * of 0.95 or more has a loss of up to 5 %.
+ */
+export declare const PATH_LOSS_BINS: readonly Bin[];
+/**
+ * The smallest number of echo requests that gives the feature `path.loss`. With 20 requests, one lost request is a loss
+ * of 5 %. With no reply, the feature `icmp.reply` tells the result, not `path.loss`.
+ */
+export declare const LOSS_MIN_SENT = 20;
+/** The suffixes of the names of local networks and of the special-use names (RFC 6761, RFC 6762 and RFC 8375). */
+export declare const LOCAL_SUFFIXES: readonly string[];
+/** This function gives the value of the first bin that holds `x`. */
+export declare function binOf(bins: readonly Bin[], x: number): string;
+/** This function tells if a name is a local name: a name with one label, or a name with a local suffix. */
+export declare function isLocalName(name: string): boolean;
+/**
+ * This function changes facts into evidence for the model.
+ *
+ * - The reader gives one evidence for each feature, subject and role. When a subject has more facts, the last fact decides.
+ * - For `dns.answer`, one answer `ok` of a name and a resolver decides. For `dns.address`, one private address decides.
+ * - The order of the facts is the order of the runner. A ratio uses the last TCP connect before the handshake or the request.
+ * - An ICMP echo fact gives `gateway.reply` for the gateway, and `icmp.reply` for each other address.
+ * - An ICMP echo fact with replies to `LOSS_MIN_SENT` requests or more gives `path.loss`. A report of `mtr` gives it from
+ *   the last hop, when the address answered there.
+ * - A trace of `traceroute` gives no evidence. The catalog has no feature for the hops of a path.
+ */
+export declare function readEvidence(facts: readonly Fact[], options?: ReadOptions): Reading;
+export { ADDRESS_CLASSES, AddressClass, AddressFamily, type Availability, CERT_PROBLEMS, CONNECT_OUTCOMES, type Catalog, type CatalogSpec, type Cause, CertProblem, Cidr, CidrSet, type ClockOrigin, type ConnectOptions, ConnectOutcome, type Contribution, DNS_ANSWER, DNS_OUTCOMES, type Diagnosis, type Dial, type Distribution, DnsAnswer, type DnsInput, DnsOutcome, type DnsRaw, ECHO_OUTCOMES, EchoOutcome, type Evidence, type Expectation, FLOOR, type Fact, type FactKind, type FactSource, type FactTime, type Fault, type Feature, type Grant, type GrantBasis, HANDSHAKE_OUTCOMES, HTTP_OUTCOMES, HTTP_RESPONSE, HandshakeOutcome, type HostGrant, type HostKind, type HttpInput, HttpOutcome, type HttpPhase, type HttpRaw, HttpResponse, type Hypothesis, ICMP_ECHO, IcmpEcho, LAB_RECORD_FORMAT, LAYERS, type LabBars, type LabCause, type LabGate, type LabRecord, type LabScore, type LabStatus, type LabVerdict, type Layer, NATIVE_KINDS, NONE, type Observation, PARTS, PATH_REPORT, PATH_TRACE, type Part, PathReport, PathTrace, type PortLedger, type Prediction, type Probe, type ProbeContext, type ProbeMode, type ProbeOutcome, RECORD_TYPES, type RangeGrant, type Reach, RecordType, ReportHop, type Runner, type RunnerOptions, STANDARD_CATALOG, STANDARD_CATALOG_SPEC, STANDARD_FAULTS, STANDARD_FEATURES, STRENGTHS, type Scope, type ScopeDecision, type Strength, TCP_CONNECT, TLS_HANDSHAKE, TOOL_KINDS, TRACE_OUTCOMES, TRUSTS, type Target, TcpConnect, type TcpInput, type TcpPhase, type TcpRaw, TlsCertificate, TlsHandshake, type TlsInput, type TlsPhase, type TlsProbeOptions, type TlsRaw, TraceHop, TraceOutcome, Trust, UNKNOWN, type ValueOf, addressClass, addressFamily, addressKind, canonicalAddress, canonicalHost, cidrContains, cidrSet, compileCatalog, defineFactKind, defineProbe, diagnose, expand, explain, factsOf, formatCidr, formatTarget, hostKind, isFactOf, isLayer, labGate, labRecordOf, layerRank, observe, parseCidr, parseTarget, predictive, sameTarget, scoreLab, target };
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/scope.ts","../src/run.ts","../src/probes/socket.ts","../src/probes/native.ts","../src/readers.ts"],"mappings":"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"}