probe

type Cert struct {
	// Bytes is the DER length the peer sent for this certificate. Post-quantum
	// *authentication* is the next migration and its failure will be a size
	// failure again — an ML-DSA signature is around 3.3 KB where an ECDSA one
	// is 64 — so what a chain costs today is worth having in hand.
	Bytes     int       `json:"bytes,omitempty"`
	Subject   string    `json:"subject"`
	Issuer    string    `json:"issuer"`
	NotAfter  time.Time `json:"not_after"`
	NotBefore time.Time `json:"not_before"`
	DNSNames  []string  `json:"dns_names,omitempty"`
	IsCA      bool      `json:"is_ca"`
	// KeyBytes and SigBytes are what this certificate's subjectPublicKeyInfo
	// and signature weigh in the DER the peer sent (PQ-72). They are the two
	// numbers a post-quantum projection needs: an ML-DSA certificate is the
	// same certificate with those two fields replaced, and without them the
	// projection has to assume what comes *out*, which is how a number ends up
	// in a ticket with nobody able to say where it came from.
	KeyBytes int `json:"key_bytes,omitempty"`
	SigBytes int `json:"sig_bytes,omitempty"`
	// KeyAlg, KeyBits and SigAlg are the inventory a certificate migration is
	// planned against (PQ-73): what this certificate's key is, how big, and
	// what signed it. Recorded rather than judged — whether RSA-2048 is good
	// enough is a configuration opinion, and configuration opinions belong to
	// testssl.sh.
	KeyAlg  string `json:"key_alg,omitempty"`
	KeyBits int    `json:"key_bits,omitempty"`
	SigAlg  string `json:"sig_alg,omitempty"`
}

type Dialer struct {
	Timeout time.Duration
	ALPN    []string
	// StartTLS, when set, is the protocol whose plaintext negotiation gets to
	// TLS before the handshake: smtp, imap or postgres. Implicit TLS on any
	// port needs none of this — `host:465` is already just TLS.
	StartTLS string
	// Socks5, when set, is the `host:port` of a SOCKS5 proxy every connection
	// goes through. SOCKS5 and nothing else: HTTP CONNECT is a *request*, and
	// sending one would trade away the property that makes this binary safe to
	// point at production. The target name is passed to the proxy unresolved,
	// because inside a network that is often the only place it resolves.
	Socks5 string
	// Net pins the address family every connection uses: "tcp4", "tcp6", or ""
	// for whatever the resolver hands over. Pinning it is what makes an
	// IPv6-only failure reproducible on demand — unpinned, a dual-stack name
	// answers on whichever address the resolver felt like handing over, and two
	// runs can disagree with nothing having changed on the endpoint.
	Net string
	// Resolver is the resolver used to turn a target name into an address; nil
	// means the machine's own. It is set from --dns, so that one flag governs
	// every question a run asks (PQ-58).
	Resolver *net.Resolver
	// Confirm re-dials an abrupt failure once before it is believed. See
	// DoConfirmed.
	Confirm bool
	// ConfirmDelay is the pause between the two dials. Zero means a short
	// default; tests set it to nothing.
	ConfirmDelay time.Duration
	// Now is the clock used for expiry arithmetic; tests set it.
	Now func() time.Time
}

type Kind string

type Resolver interface {
	LookupIPAddr(ctx context.Context, host string) ([]net.IPAddr, error)
}

type Result struct {
	Profile string        `json:"profile"`
	OK      bool          `json:"ok"`
	Kind    Kind          `json:"kind"`
	Err     string        `json:"error,omitempty"`
	Version string        `json:"tls_version,omitempty"`
	Group   string        `json:"group,omitempty"`
	Cipher  string        `json:"cipher,omitempty"`
	ALPN    string        `json:"alpn,omitempty"`
	Elapsed time.Duration `json:"elapsed_ns,omitempty"`
	// PQ is true when the negotiated key exchange was a post-quantum hybrid.
	PQ bool `json:"pq,omitempty"`
	// Chain is the certificate chain as the peer sent it, leaf first. It is
	// recorded on every successful handshake and read once, from the baseline.
	Chain []Cert `json:"chain,omitempty"`
	// ChainVerified is the result of verifying that chain against the system
	// roots, done here rather than by the dialler — see clientprofile.TLSConfig.
	ChainVerified bool   `json:"chain_verified"`
	ChainError    string `json:"chain_error,omitempty"`
	// Attempts is how many handshakes this result is based on: two when an
	// abrupt failure was re-dialled to confirm it. See DoConfirmed.
	Attempts int `json:"attempts,omitempty"`
	// FirstKind is how the first attempt ended, when there was more than one.
	FirstKind Kind `json:"first_kind,omitempty"`
	// Reproduced is true when both attempts ended abruptly: the refusal is a
	// wall rather than a flap, and the finding may say so.
	Reproduced bool `json:"reproduced,omitempty"`
	// Flapped is true when the first attempt ended abruptly and the second
	// connected. The endpoint works and is unstable, which is a third state and
	// must not render as either of the other two.
	Flapped bool `json:"flapped,omitempty"`
	// ECHAccepted is true when the peer accepted Encrypted Client Hello. Read
	// from the connection state and never inferred: a server that ignores ECH
	// completes the handshake too, and calling that acceptance would be a claim
	// about privacy that is not true (PQ-50).
	ECHAccepted bool `json:"ech_accepted,omitempty"`
	// HelloBytes is the size on the wire of the first ClientHello record,
	// measured rather than estimated. It is the number the whole
	// size-intolerance conversation turns on: the hybrid hello is roughly
	// 1.2 KB larger than the classical one, which is what stops it fitting a
	// single TCP segment.
	HelloBytes int `json:"hello_bytes,omitempty"`
	// HelloCount is how many ClientHellos went out. Two means the peer sent a
	// HelloRetryRequest.
	HelloCount int `json:"hello_count,omitempty"`
	// HRR is true when the peer answered with a HelloRetryRequest: it did not
	// take the key share offered and asked for another group, which costs a
	// round trip and is a different state from never having seen ML-KEM.
	HRR bool `json:"hrr,omitempty"`
	// ClientCertRequested is true when the peer sent a CertificateRequest: this
	// endpoint is mutual TLS. On TLS 1.3 that does not stop the handshake —
	// the peer's objection arrives after the client is finished, and pqprobe
	// never reads — so the key exchange answer stands and this is the note that
	// keeps "pq-ready" from being read as "usable". On TLS 1.2 client auth
	// happens inside the handshake, and then this is the only thing that tells
	// the failure apart from "no mutually supported group".
	ClientCertRequested bool `json:"client_cert_requested,omitempty"`
	// ChainBytes is what the whole chain cost on the wire, in bytes of DER. It
	// is the headroom number for post-quantum authentication: a chain that is
	// already 6 KB has a different future from one that is 2.
	ChainBytes int `json:"chain_bytes,omitempty"`
	// PeerChainLen is how many certificates the peer sent. One means the peer
	// sent the leaf alone: browsers with a cached intermediate will be fine and
	// a fresh client will not, which is the most confusing class of bug there
	// is.
	PeerChainLen int `json:"peer_chain_len,omitempty"`
}

type Target struct {
	Host string
	Port string
	SNI  string
	// PortWritten records that the target named its own port, so `--port` —
	// documented as the default "for targets written without one" — cannot
	// replace it. Without this the two cases are indistinguishable at 443, and
	// `--port 8443 origin.example:443` probed an endpoint nobody named.
	PortWritten bool
}