ech

type CipherSuite struct {
	KDF  uint16
	AEAD uint16
}

type Config []byte

type ConfigSpec struct {
	Version           uint16
	ID                uint8
	KEM               uint16
	PublicKey         []byte
	CipherSuites      []CipherSuite
	MaximumNameLength uint8
	PublicName        []byte
}

type Conn struct {
	net.Conn // The underlying connection
	// contains filtered or unexported fields
}

type Dialer[T any] struct {
	// RequireECH indicates that Encrypted Client Hello must be available
	// and successfully negotiated for Dial to return successfully.
	// By default, when RequireECH is false, Dial falls back to regular
	// plaintext Client Hello when a Config List isn't found.
	RequireECH bool
	// Resolver specifies the resolver to use for DNS lookups. If nil,
	// DefaultResolver is used. When Dialer is used by Transport, this
	// value is ignored.
	Resolver *Resolver
	// PublicName is used to fetch the ECH Config List from the server when
	// the Config List isn't specified in the tls.Config or in DNS. In
	// that case, Dial generates a fake (but valid) Config List with this
	// PublicName and use it to establish a TLS connection with the server,
	// which should return the real Config List in RetryConfigList.
	PublicName string
	// MaxConcurrency specifies the maximum number of connections that can
	// be attempted in parallel by Dial when the network address resolves to
	// multiple targets. The default value is 3.
	MaxConcurrency int
	// ConcurrencyDelay is the amount of time to wait before initiating a
	// new concurrent connection attempt. The default is 1s.
	ConcurrencyDelay time.Duration
	// Timeout is the amount of time to wait for a single connection to be
	// established. The default value is 30s.
	Timeout time.Duration
	// DialFunc must be set to a function that will be used to connect to
	// a network address. NewDialer automatically sets this value.
	DialFunc func(ctx context.Context, network, addr string, tc *tls.Config) (T, error)
}

type Key = tls.EncryptedClientHelloKey

type Option func(*Conn)

type ResolveResult struct {
	Port       uint16
	Address    []net.IP
	HTTPS      []dns.HTTPS
	Additional map[string][]net.IP
}

type Resolver struct {
	// contains filtered or unexported fields
}

type Target struct {
	Address netip.AddrPort
	ECH     []byte
	ALPN    []string
}

type Transport struct {
	// This http.Transport is used to execute the HTTP transaction. The
	// DialContext and DialTLSContext functions are set by NewTransport
	// and should not be modified.
	HTTPTransport *http.Transport
	// This RoundTripper is used to execute the HTTP transaction using the
	// HTTP/3 protocol. This value is optional. If set, it is used only when
	// the hostname has an HTTPS RR with h3 present in its ALPN list with a
	// lower Priority value than any with h2 or http/1.1.
	// See github.com/c2FmZQ/ech/quic/h3 NewTransport
	HTTP3Transport http.RoundTripper
	// This Resolver is used for DNS name resolution. NewTransport() sets
	// it to DefaultResolver. Any valid Resolver can be used.
	Resolver *Resolver
	// This Dialer is used to dial the TLS connection. Its parameters can
	// be modified as needed.
	Dialer *Dialer[*tls.Conn]
	// This tls.Config is used when dialing the TLS connection. A nil value
	// is generally fine.
	TLSConfig *tls.Config
}