func CipherSuiteName(iduint16)string

func Listen(network, laddrstring, config *Config) (net.Listener,error)

func NewListener(innernet.Listener, config *Config)net.Listener

func VersionName(versionuint16)string

type AlertErroruint8

func (AlertError)Error¶added ingo1.21.0

func (eAlertError) Error()string

type Certificate struct {Certificate [][]byte// PrivateKey contains the private key corresponding to the public key in// Leaf. This must implement crypto.Signer with an RSA, ECDSA or Ed25519 PublicKey.// For a server up to TLS 1.2, it can also implement crypto.Decrypter with// an RSA PublicKey.PrivateKeycrypto.PrivateKey// SupportedSignatureAlgorithms is an optional list restricting what// signature algorithms the PrivateKey can be used for.SupportedSignatureAlgorithms []SignatureScheme// OCSPStaple contains an optional OCSP response which will be served// to clients that request it.OCSPStaple []byte// SignedCertificateTimestamps contains an optional list of Signed// Certificate Timestamps which will be served to clients that request it.SignedCertificateTimestamps [][]byte// Leaf is the parsed form of the leaf certificate, which may be initialized// using x509.ParseCertificate to reduce per-handshake processing. If nil,// the leaf certificate will be parsed as needed.Leaf *x509.Certificate}

funcLoadX509KeyPair¶

func LoadX509KeyPair(certFile, keyFilestring) (Certificate,error)

LoadX509KeyPair reads and parses a public/private key pair from a pair offiles. The files must contain PEM encoded data. The certificate file maycontain intermediate certificates following the leaf certificate to form acertificate chain. On successful return, Certificate.Leaf will be populated.

Before Go 1.23 Certificate.Leaf was left nil, and the parsed certificate wasdiscarded. This behavior can be re-enabled by setting "x509keypairleaf=0"in the GODEBUG environment variable.

package mainimport ("crypto/tls""log")func main() {cert, err := tls.LoadX509KeyPair("testdata/example-cert.pem", "testdata/example-key.pem")if err != nil {log.Fatal(err)}cfg := &tls.Config{Certificates: []tls.Certificate{cert}}listener, err := tls.Listen("tcp", ":2000", cfg)if err != nil {log.Fatal(err)}_ = listener}

funcX509KeyPair¶

func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (Certificate,error)

X509KeyPair parses a public/private key pair from a pair ofPEM encoded data. On successful return, Certificate.Leaf will be populated.

Before Go 1.23 Certificate.Leaf was left nil, and the parsed certificate wasdiscarded. This behavior can be re-enabled by setting "x509keypairleaf=0"in the GODEBUG environment variable.

package mainimport ("crypto/tls""log")func main() {certPem := []byte(`-----BEGIN CERTIFICATE-----MIIBhTCCASugAwIBAgIQIRi6zePL6mKjOipn+dNuaTAKBggqhkjOPQQDAjASMRAwDgYDVQQKEwdBY21lIENvMB4XDTE3MTAyMDE5NDMwNloXDTE4MTAyMDE5NDMwNlowEjEQMA4GA1UEChMHQWNtZSBDbzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD0d7VNhbWvZLWPuj/RtHFjvtJBEwOkhbN/BnnE8rnZR8+sbwnc/KhCk3FhnpHZnQz7B5aETbbIgmuvewdjvSBSjYzBhMA4GA1UdDwEB/wQEAwICpDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MCkGA1UdEQQiMCCCDmxvY2FsaG9zdDo1NDUzgg4xMjcuMC4wLjE6NTQ1MzAKBggqhkjOPQQDAgNIADBFAiEA2zpJEPQyz6/lWf86aX6PepsntZv2GYlA5UpabfT2EZICICpJ5h/iI+i341gBmLiAFQOyTDT+/wQc6MF9+Yw1Yy0t-----END CERTIFICATE-----`)keyPem := []byte(`-----BEGIN EC PRIVATE KEY-----MHcCAQEEIIrYSSNQFaA2Hwf1duRSxKtLYX5CB04fSeQ6tF1aY/PuoAoGCCqGSM49AwEHoUQDQgAEPR3tU2Fta9ktY+6P9G0cWO+0kETA6SFs38GecTyudlHz6xvCdz8qEKTcWGekdmdDPsHloRNtsiCa697B2O9IFA==-----END EC PRIVATE KEY-----`)cert, err := tls.X509KeyPair(certPem, keyPem)if err != nil {log.Fatal(err)}cfg := &tls.Config{Certificates: []tls.Certificate{cert}}listener, err := tls.Listen("tcp", ":2000", cfg)if err != nil {log.Fatal(err)}_ = listener}

package mainimport ("crypto/tls""log""net/http""time")func main() {certPem := []byte(`-----BEGIN CERTIFICATE-----MIIBhTCCASugAwIBAgIQIRi6zePL6mKjOipn+dNuaTAKBggqhkjOPQQDAjASMRAwDgYDVQQKEwdBY21lIENvMB4XDTE3MTAyMDE5NDMwNloXDTE4MTAyMDE5NDMwNlowEjEQMA4GA1UEChMHQWNtZSBDbzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD0d7VNhbWvZLWPuj/RtHFjvtJBEwOkhbN/BnnE8rnZR8+sbwnc/KhCk3FhnpHZnQz7B5aETbbIgmuvewdjvSBSjYzBhMA4GA1UdDwEB/wQEAwICpDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MCkGA1UdEQQiMCCCDmxvY2FsaG9zdDo1NDUzgg4xMjcuMC4wLjE6NTQ1MzAKBggqhkjOPQQDAgNIADBFAiEA2zpJEPQyz6/lWf86aX6PepsntZv2GYlA5UpabfT2EZICICpJ5h/iI+i341gBmLiAFQOyTDT+/wQc6MF9+Yw1Yy0t-----END CERTIFICATE-----`)keyPem := []byte(`-----BEGIN EC PRIVATE KEY-----MHcCAQEEIIrYSSNQFaA2Hwf1duRSxKtLYX5CB04fSeQ6tF1aY/PuoAoGCCqGSM49AwEHoUQDQgAEPR3tU2Fta9ktY+6P9G0cWO+0kETA6SFs38GecTyudlHz6xvCdz8qEKTcWGekdmdDPsHloRNtsiCa697B2O9IFA==-----END EC PRIVATE KEY-----`)cert, err := tls.X509KeyPair(certPem, keyPem)if err != nil {log.Fatal(err)}cfg := &tls.Config{Certificates: []tls.Certificate{cert}}srv := &http.Server{TLSConfig:    cfg,ReadTimeout:  time.Minute,WriteTimeout: time.Minute,}log.Fatal(srv.ListenAndServeTLS("", ""))}

type CertificateRequestInfo struct {// AcceptableCAs contains zero or more, DER-encoded, X.501// Distinguished Names. These are the names of root or intermediate CAs// that the server wishes the returned certificate to be signed by. An// empty slice indicates that the server has no preference.AcceptableCAs [][]byte// SignatureSchemes lists the signature schemes that the server is// willing to verify.SignatureSchemes []SignatureScheme// Version is the TLS version that was negotiated for this connection.Versionuint16// contains filtered or unexported fields}

func (*CertificateRequestInfo)Context¶added ingo1.17

func (c *CertificateRequestInfo) Context()context.Context

Context returns the context of the handshake that is in progress.This context is a child of the context passed to HandshakeContext,if any, and is canceled when the handshake concludes.

func (*CertificateRequestInfo)SupportsCertificate¶added ingo1.14

func (cri *CertificateRequestInfo) SupportsCertificate(c *Certificate)error

SupportsCertificate returns nil if the provided certificate is supported bythe server that sent the CertificateRequest. Otherwise, it returns an errordescribing the reason for the incompatibility.

type CertificateVerificationError struct {// UnverifiedCertificates and its contents should not be modified.UnverifiedCertificates []*x509.CertificateErrerror}

func (*CertificateVerificationError)Error¶added ingo1.20

func (e *CertificateVerificationError) Error()string

func (*CertificateVerificationError)Unwrap¶added ingo1.20

func (e *CertificateVerificationError) Unwrap()error

type CipherSuite struct {IDuint16Namestring// Supported versions is the list of TLS protocol versions that can// negotiate this cipher suite.SupportedVersions []uint16// Insecure is true if the cipher suite has known security issues// due to its primitives, design, or implementation.Insecurebool}

funcCipherSuites¶added ingo1.14

func CipherSuites() []*CipherSuite

CipherSuites returns a list of cipher suites currently implemented by thispackage, excluding those with security issues, which are returned byInsecureCipherSuites.

The list is sorted by ID. Note that the default cipher suites selected bythis package might depend on logic that can't be captured by a static list,and might not match those returned by this function.

funcInsecureCipherSuites¶added ingo1.14

func InsecureCipherSuites() []*CipherSuite

InsecureCipherSuites returns a list of cipher suites currently implemented bythis package and which have security issues.

Most applications should not use the cipher suites in this list, and shouldonly use those returned byCipherSuites.

type ClientAuthTypeint

func (ClientAuthType)String¶added ingo1.15

func (iClientAuthType) String()string

type ClientHelloInfo struct {// CipherSuites lists the CipherSuites supported by the client (e.g.// TLS_AES_128_GCM_SHA256, TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256).CipherSuites []uint16// ServerName indicates the name of the server requested by the client// in order to support virtual hosting. ServerName is only set if the// client is using SNI (seeRFC 4366, Section 3.1).ServerNamestring// SupportedCurves lists the key exchange mechanisms supported by the// client. It was renamed to "supported groups" in TLS 1.3, seeRFC 8446,// Section 4.2.7 and [CurveID].//// SupportedCurves may be nil in TLS 1.2 and lower if the Supported Elliptic// Curves Extension is not being used (seeRFC 4492, Section 5.1.1).SupportedCurves []CurveID// SupportedPoints lists the point formats supported by the client.// SupportedPoints is set only if the Supported Point Formats Extension// is being used (seeRFC 4492, Section 5.1.2).SupportedPoints []uint8// SignatureSchemes lists the signature and hash schemes that the client// is willing to verify. SignatureSchemes is set only if the Signature// Algorithms Extension is being used (seeRFC 5246, Section 7.4.1.4.1).SignatureSchemes []SignatureScheme// SupportedProtos lists the application protocols supported by the client.// SupportedProtos is set only if the Application-Layer Protocol// Negotiation Extension is being used (seeRFC 7301, Section 3.1).//// Servers can select a protocol by setting Config.NextProtos in a// GetConfigForClient return value.SupportedProtos []string// SupportedVersions lists the TLS versions supported by the client.// For TLS versions less than 1.3, this is extrapolated from the max// version advertised by the client, so values other than the greatest// might be rejected if used.SupportedVersions []uint16// Extensions lists the IDs of the extensions presented by the client// in the ClientHello.Extensions []uint16// Conn is the underlying net.Conn for the connection. Do not read// from, or write to, this connection; that will cause the TLS// connection to fail.Connnet.Conn// contains filtered or unexported fields}

func (*ClientHelloInfo)Context¶added ingo1.17

func (c *ClientHelloInfo) Context()context.Context

Context returns the context of the handshake that is in progress.This context is a child of the context passed to HandshakeContext,if any, and is canceled when the handshake concludes.

func (*ClientHelloInfo)SupportsCertificate¶added ingo1.14

func (chi *ClientHelloInfo) SupportsCertificate(c *Certificate)error

SupportsCertificate returns nil if the provided certificate is supported bythe client that sent the ClientHello. Otherwise, it returns an errordescribing the reason for the incompatibility.

If thisClientHelloInfo was passed to a GetConfigForClient or GetCertificatecallback, this method will take into account the associatedConfig. Note thatif GetConfigForClient returns a differentConfig, the change can't beaccounted for by this method.

This function will call x509.ParseCertificate unless c.Leaf is set, which canincur a significant performance cost.

type ClientSessionCache interface {// Get searches for a ClientSessionState associated with the given key.// On return, ok is true if one was found.Get(sessionKeystring) (session *ClientSessionState, okbool)// Put adds the ClientSessionState to the cache with the given key. It might// get called multiple times in a connection if a TLS 1.3 server provides// more than one session ticket. If called with a nil *ClientSessionState,// it should remove the cache entry.Put(sessionKeystring, cs *ClientSessionState)}

funcNewLRUClientSessionCache¶added ingo1.3

func NewLRUClientSessionCache(capacityint)ClientSessionCache

NewLRUClientSessionCache returns aClientSessionCache with the givencapacity that uses an LRU strategy. If capacity is < 1, a default capacityis used instead.

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

funcNewResumptionState¶added ingo1.21.0

func NewResumptionState(ticket []byte, state *SessionState) (*ClientSessionState,error)

NewResumptionState returns a state value that can be returned by[ClientSessionCache.Get] to resume a previous session.

state needs to be returned byParseSessionState, and the ticket and sessionstate must have been returned byClientSessionState.ResumptionState.

func (*ClientSessionState)ResumptionState¶added ingo1.21.0

func (cs *ClientSessionState) ResumptionState() (ticket []byte, state *SessionState, errerror)

ResumptionState returns the session ticket sent by the server (also known asthe session's identity) and the state necessary to resume this session.

It can be called by [ClientSessionCache.Put] to serialize (withSessionState.Bytes) and store the session.

type Config struct {// Rand provides the source of entropy for nonces and RSA blinding.// If Rand is nil, TLS uses the cryptographic random reader in package// crypto/rand.// The Reader must be safe for use by multiple goroutines.Randio.Reader// Time returns the current time as the number of seconds since the epoch.// If Time is nil, TLS uses time.Now.Time func()time.Time// Certificates contains one or more certificate chains to present to the// other side of the connection. The first certificate compatible with the// peer's requirements is selected automatically.//// Server configurations must set one of Certificates, GetCertificate or// GetConfigForClient. Clients doing client-authentication may set either// Certificates or GetClientCertificate.//// Note: if there are multiple Certificates, and they don't have the// optional field Leaf set, certificate selection will incur a significant// per-handshake performance cost.Certificates []Certificate// NameToCertificate maps from a certificate name to an element of// Certificates. Note that a certificate name can be of the form// '*.example.com' and so doesn't have to be a domain name as such.//// Deprecated: NameToCertificate only allows associating a single// certificate with a given name. Leave this field nil to let the library// select the first compatible chain from Certificates.NameToCertificate map[string]*Certificate// GetCertificate returns a Certificate based on the given// ClientHelloInfo. It will only be called if the client supplies SNI// information or if Certificates is empty.//// If GetCertificate is nil or returns nil, then the certificate is// retrieved from NameToCertificate. If NameToCertificate is nil, the// best element of Certificates will be used.//// Once a Certificate is returned it should not be modified.GetCertificate func(*ClientHelloInfo) (*Certificate,error)// GetClientCertificate, if not nil, is called when a server requests a// certificate from a client. If set, the contents of Certificates will// be ignored.//// If GetClientCertificate returns an error, the handshake will be// aborted and that error will be returned. Otherwise// GetClientCertificate must return a non-nil Certificate. If// Certificate.Certificate is empty then no certificate will be sent to// the server. If this is unacceptable to the server then it may abort// the handshake.//// GetClientCertificate may be called multiple times for the same// connection if renegotiation occurs or if TLS 1.3 is in use.//// Once a Certificate is returned it should not be modified.GetClientCertificate func(*CertificateRequestInfo) (*Certificate,error)// GetConfigForClient, if not nil, is called after a ClientHello is// received from a client. It may return a non-nil Config in order to// change the Config that will be used to handle this connection. If// the returned Config is nil, the original Config will be used. The// Config returned by this callback may not be subsequently modified.//// If GetConfigForClient is nil, the Config passed to Server() will be// used for all connections.//// If SessionTicketKey was explicitly set on the returned Config, or if// SetSessionTicketKeys was called on the returned Config, those keys will// be used. Otherwise, the original Config keys will be used (and possibly// rotated if they are automatically managed).GetConfigForClient func(*ClientHelloInfo) (*Config,error)// VerifyPeerCertificate, if not nil, is called after normal// certificate verification by either a TLS client or server. It// receives the raw ASN.1 certificates provided by the peer and also// any verified chains that normal processing found. If it returns a// non-nil error, the handshake is aborted and that error results.//// If normal verification fails then the handshake will abort before// considering this callback. If normal verification is disabled (on the// client when InsecureSkipVerify is set, or on a server when ClientAuth is// RequestClientCert or RequireAnyClientCert), then this callback will be// considered but the verifiedChains argument will always be nil. When// ClientAuth is NoClientCert, this callback is not called on the server.// rawCerts may be empty on the server if ClientAuth is RequestClientCert or// VerifyClientCertIfGiven.//// This callback is not invoked on resumed connections, as certificates are// not re-verified on resumption.//// verifiedChains and its contents should not be modified.VerifyPeerCertificate func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate)error// VerifyConnection, if not nil, is called after normal certificate// verification and after VerifyPeerCertificate by either a TLS client// or server. If it returns a non-nil error, the handshake is aborted// and that error results.//// If normal verification fails then the handshake will abort before// considering this callback. This callback will run for all connections,// including resumptions, regardless of InsecureSkipVerify or ClientAuth// settings.VerifyConnection func(ConnectionState)error// RootCAs defines the set of root certificate authorities// that clients use when verifying server certificates.// If RootCAs is nil, TLS uses the host's root CA set.RootCAs *x509.CertPool// NextProtos is a list of supported application level protocols, in// order of preference. If both peers support ALPN, the selected// protocol will be one from this list, and the connection will fail// if there is no mutually supported protocol. If NextProtos is empty// or the peer doesn't support ALPN, the connection will succeed and// ConnectionState.NegotiatedProtocol will be empty.NextProtos []string// ServerName is used to verify the hostname on the returned// certificates unless InsecureSkipVerify is given. It is also included// in the client's handshake to support virtual hosting unless it is// an IP address.ServerNamestring// ClientAuth determines the server's policy for// TLS Client Authentication. The default is NoClientCert.ClientAuthClientAuthType// ClientCAs defines the set of root certificate authorities// that servers use if required to verify a client certificate// by the policy in ClientAuth.ClientCAs *x509.CertPool// InsecureSkipVerify controls whether a client verifies the server's// certificate chain and host name. If InsecureSkipVerify is true, crypto/tls// accepts any certificate presented by the server and any host name in that// certificate. In this mode, TLS is susceptible to machine-in-the-middle// attacks unless custom verification is used. This should be used only for// testing or in combination with VerifyConnection or VerifyPeerCertificate.InsecureSkipVerifybool// CipherSuites is a list of enabled TLS 1.0–1.2 cipher suites. The order of// the list is ignored. Note that TLS 1.3 ciphersuites are not configurable.//// If CipherSuites is nil, a safe default list is used. The default cipher// suites might change over time. In Go 1.22 RSA key exchange based cipher// suites were removed from the default list, but can be re-added with the// GODEBUG setting tlsrsakex=1. In Go 1.23 3DES cipher suites were removed// from the default list, but can be re-added with the GODEBUG setting// tls3des=1.CipherSuites []uint16// PreferServerCipherSuites is a legacy field and has no effect.//// It used to control whether the server would follow the client's or the// server's preference. Servers now select the best mutually supported// cipher suite based on logic that takes into account inferred client// hardware, server hardware, and security.//// Deprecated: PreferServerCipherSuites is ignored.PreferServerCipherSuitesbool// SessionTicketsDisabled may be set to true to disable session ticket and// PSK (resumption) support. Note that on clients, session ticket support is// also disabled if ClientSessionCache is nil.SessionTicketsDisabledbool// SessionTicketKey is used by TLS servers to provide session resumption.// SeeRFC 5077 and the PSK mode ofRFC 8446. If zero, it will be filled// with random data before the first server handshake.//// Deprecated: if this field is left at zero, session ticket keys will be// automatically rotated every day and dropped after seven days. For// customizing the rotation schedule or synchronizing servers that are// terminating connections for the same host, use SetSessionTicketKeys.SessionTicketKey [32]byte// ClientSessionCache is a cache of ClientSessionState entries for TLS// session resumption. It is only used by clients.ClientSessionCacheClientSessionCache// UnwrapSession is called on the server to turn a ticket/identity// previously produced by [WrapSession] into a usable session.//// UnwrapSession will usually either decrypt a session state in the ticket// (for example with [Config.EncryptTicket]), or use the ticket as a handle// to recover a previously stored state. It must use [ParseSessionState] to// deserialize the session state.//// If UnwrapSession returns an error, the connection is terminated. If it// returns (nil, nil), the session is ignored. crypto/tls may still choose// not to resume the returned session.UnwrapSession func(identity []byte, csConnectionState) (*SessionState,error)// WrapSession is called on the server to produce a session ticket/identity.//// WrapSession must serialize the session state with [SessionState.Bytes].// It may then encrypt the serialized state (for example with// [Config.DecryptTicket]) and use it as the ticket, or store the state and// return a handle for it.//// If WrapSession returns an error, the connection is terminated.//// Warning: the return value will be exposed on the wire and to clients in// plaintext. The application is in charge of encrypting and authenticating// it (and rotating keys) or returning high-entropy identifiers. Failing to// do so correctly can compromise current, previous, and future connections// depending on the protocol version.WrapSession func(ConnectionState, *SessionState) ([]byte,error)// MinVersion contains the minimum TLS version that is acceptable.//// By default, TLS 1.2 is currently used as the minimum. TLS 1.0 is the// minimum supported by this package.//// The server-side default can be reverted to TLS 1.0 by including the value// "tls10server=1" in the GODEBUG environment variable.MinVersionuint16// MaxVersion contains the maximum TLS version that is acceptable.//// By default, the maximum version supported by this package is used,// which is currently TLS 1.3.MaxVersionuint16// CurvePreferences contains a set of supported key exchange mechanisms.// The name refers to elliptic curves for legacy reasons, see [CurveID].// The order of the list is ignored, and key exchange mechanisms are chosen// from this list using an internal preference order. If empty, the default// will be used.//// From Go 1.24, the default includes the [X25519MLKEM768] hybrid// post-quantum key exchange. To disable it, set CurvePreferences explicitly// or use the GODEBUG=tlsmlkem=0 environment variable.CurvePreferences []CurveID// DynamicRecordSizingDisabled disables adaptive sizing of TLS records.// When true, the largest possible TLS record size is always used. When// false, the size of TLS records may be adjusted in an attempt to// improve latency.DynamicRecordSizingDisabledbool// Renegotiation controls what types of renegotiation are supported.// The default, none, is correct for the vast majority of applications.RenegotiationRenegotiationSupport// KeyLogWriter optionally specifies a destination for TLS master secrets// in NSS key log format that can be used to allow external programs// such as Wireshark to decrypt TLS connections.// Seehttps://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS/Key_Log_Format.// Use of KeyLogWriter compromises security and should only be// used for debugging.KeyLogWriterio.Writer// EncryptedClientHelloConfigList is a serialized ECHConfigList. If// provided, clients will attempt to connect to servers using Encrypted// Client Hello (ECH) using one of the provided ECHConfigs.//// Servers do not use this field. In order to configure ECH for servers, see// the EncryptedClientHelloKeys field.//// If the list contains no valid ECH configs, the handshake will fail// and return an error.//// If EncryptedClientHelloConfigList is set, MinVersion, if set, must// be VersionTLS13.//// When EncryptedClientHelloConfigList is set, the handshake will only// succeed if ECH is successfully negotiated. If the server rejects ECH,// an ECHRejectionError error will be returned, which may contain a new// ECHConfigList that the server suggests using.//// How this field is parsed may change in future Go versions, if the// encoding described in the final Encrypted Client Hello RFC changes.EncryptedClientHelloConfigList []byte// EncryptedClientHelloRejectionVerify, if not nil, is called when ECH is// rejected by the remote server, in order to verify the ECH provider// certificate in the outer ClientHello. If it returns a non-nil error, the// handshake is aborted and that error results.//// On the server side this field is not used.//// Unlike VerifyPeerCertificate and VerifyConnection, normal certificate// verification will not be performed before calling// EncryptedClientHelloRejectionVerify.//// If EncryptedClientHelloRejectionVerify is nil and ECH is rejected, the// roots in RootCAs will be used to verify the ECH providers public// certificate. VerifyPeerCertificate and VerifyConnection are not called// when ECH is rejected, even if set, and InsecureSkipVerify is ignored.EncryptedClientHelloRejectionVerify func(ConnectionState)error// GetEncryptedClientHelloKeys, if not nil, is called when by a server when// a client attempts ECH.//// If GetEncryptedClientHelloKeys is not nil, [EncryptedClientHelloKeys] is// ignored.//// If GetEncryptedClientHelloKeys returns an error, the handshake will be// aborted and the error will be returned. Otherwise,// GetEncryptedClientHelloKeys must return a non-nil slice of// [EncryptedClientHelloKey] that represents the acceptable ECH keys.//// For further details, see [EncryptedClientHelloKeys].GetEncryptedClientHelloKeys func(*ClientHelloInfo) ([]EncryptedClientHelloKey,error)// EncryptedClientHelloKeys are the ECH keys to use when a client// attempts ECH.//// If EncryptedClientHelloKeys is set, MinVersion, if set, must be// VersionTLS13.//// If a client attempts ECH, but it is rejected by the server, the server// will send a list of configs to retry based on the set of// EncryptedClientHelloKeys which have the SendAsRetry field set.//// If GetEncryptedClientHelloKeys is non-nil, EncryptedClientHelloKeys is// ignored.//// On the client side, this field is ignored. In order to configure ECH for// clients, see the EncryptedClientHelloConfigList field.EncryptedClientHelloKeys []EncryptedClientHelloKey// contains filtered or unexported fields}

func (*Config)Clone¶added ingo1.8

func (c *Config) Clone() *Config

Clone returns a shallow clone of c or nil if c is nil. It is safe to clone aConfig that isbeing used concurrently by a TLS client or server.

func (*Config)DecryptTicket¶added ingo1.21.0

func (c *Config) DecryptTicket(identity []byte, csConnectionState) (*SessionState,error)

DecryptTicket decrypts a ticket encrypted byConfig.EncryptTicket. It canbe used as a [Config.UnwrapSession] implementation.

If the ticket can't be decrypted or parsed, DecryptTicket returns (nil, nil).

func (*Config)EncryptTicket¶added ingo1.21.0

func (c *Config) EncryptTicket(csConnectionState, ss *SessionState) ([]byte,error)

EncryptTicket encrypts a ticket with theConfig's configured (or default)session ticket keys. It can be used as a [Config.WrapSession] implementation.

func (*Config)SetSessionTicketKeys¶added ingo1.5

func (c *Config) SetSessionTicketKeys(keys [][32]byte)

SetSessionTicketKeys updates the session ticket keys for a server.

The first key will be used when creating new tickets, while all keys can beused for decrypting tickets. It is safe to call this function while theserver is running in order to rotate the session ticket keys. The functionwill panic if keys is empty.

Calling this function will turn off automatic session ticket key rotation.

If multiple servers are terminating connections for the same host they shouldall have the same session ticket keys. If the session ticket keys leaks,previously recorded and future TLS connections using those keys might becompromised.

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

funcClient¶

func Client(connnet.Conn, config *Config) *Conn

Client returns a new TLS client side connectionusing conn as the underlying transport.The config cannot be nil: users must set either ServerName orInsecureSkipVerify in the config.

funcDial¶

func Dial(network, addrstring, config *Config) (*Conn,error)

Dial connects to the given network address using net.Dialand then initiates a TLS handshake, returning the resultingTLS connection.Dial interprets a nil configuration as equivalent tothe zero configuration; see the documentation of Configfor the defaults.

package mainimport ("crypto/tls""crypto/x509")func main() {// Connecting with a custom root-certificate set.const rootPEM = `-- GlobalSign Root R2, valid until Dec 15, 2021-----BEGIN CERTIFICATE-----MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPLv4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklqtTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzdC9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pazq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCBmTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IHV2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5nbG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4GsJ0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavSot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxdAfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg==-----END CERTIFICATE-----`// First, create the set of root certificates. For this example we only// have one. It's also possible to omit this in order to use the// default root set of the current operating system.roots := x509.NewCertPool()ok := roots.AppendCertsFromPEM([]byte(rootPEM))if !ok {panic("failed to parse root certificate")}conn, err := tls.Dial("tcp", "mail.google.com:443", &tls.Config{RootCAs: roots,})if err != nil {panic("failed to connect: " + err.Error())}conn.Close()}

funcDialWithDialer¶added ingo1.3

func DialWithDialer(dialer *net.Dialer, network, addrstring, config *Config) (*Conn,error)

DialWithDialer connects to the given network address using dialer.Dial andthen initiates a TLS handshake, returning the resulting TLS connection. Anytimeout or deadline given in the dialer apply to connection and TLShandshake as a whole.

DialWithDialer interprets a nil configuration as equivalent to the zeroconfiguration; see the documentation ofConfig for the defaults.

DialWithDialer uses context.Background internally; to specify the context,useDialer.DialContext with NetDialer set to the desired dialer.

funcServer¶

func Server(connnet.Conn, config *Config) *Conn

Server returns a new TLS server side connectionusing conn as the underlying transport.The configuration config must be non-nil and must includeat least one certificate or else set GetCertificate.

func (*Conn)Close¶

func (c *Conn) Close()error

Close closes the connection.

func (*Conn)CloseWrite¶added ingo1.8

func (c *Conn) CloseWrite()error

CloseWrite shuts down the writing side of the connection. It should only becalled once the handshake has completed and does not call CloseWrite on theunderlying connection. Most callers should just useConn.Close.

func (*Conn)ConnectionState¶

func (c *Conn) ConnectionState()ConnectionState

ConnectionState returns basic TLS details about the connection.

func (*Conn)Handshake¶

func (c *Conn) Handshake()error

Handshake runs the client or server handshakeprotocol if it has not yet been run.

Most uses of this package need not call Handshake explicitly: thefirstConn.Read orConn.Write will call it automatically.

For control over canceling or setting a timeout on a handshake, useConn.HandshakeContext or theDialer's DialContext method instead.

In order to avoid denial of service attacks, the maximum RSA key size allowedin certificates sent by either the TLS server or client is limited to 8192bits. This limit can be overridden by setting tlsmaxrsasize in the GODEBUGenvironment variable (e.g. GODEBUG=tlsmaxrsasize=4096).

func (*Conn)HandshakeContext¶added ingo1.17

func (c *Conn) HandshakeContext(ctxcontext.Context)error

HandshakeContext runs the client or server handshakeprotocol if it has not yet been run.

The provided Context must be non-nil. If the context is canceled beforethe handshake is complete, the handshake is interrupted and an error is returned.Once the handshake has completed, cancellation of the context will not affect theconnection.

Most uses of this package need not call HandshakeContext explicitly: thefirstConn.Read orConn.Write will call it automatically.

func (*Conn)LocalAddr¶

func (c *Conn) LocalAddr()net.Addr

LocalAddr returns the local network address.

func (*Conn)NetConn¶added ingo1.18

func (c *Conn) NetConn()net.Conn

NetConn returns the underlying connection that is wrapped by c.Note that writing to or reading from this connection directly will corrupt theTLS session.

func (*Conn)OCSPResponse¶

func (c *Conn) OCSPResponse() []byte

OCSPResponse returns the stapled OCSP response from the TLS server, ifany. (Only valid for client connections.)

func (*Conn)Read¶

func (c *Conn) Read(b []byte) (int,error)

Read reads data from the connection.

As Read callsConn.Handshake, in order to prevent indefinite blocking a deadlinemust be set for both Read andConn.Write before Read is called when the handshakehas not yet completed. SeeConn.SetDeadline,Conn.SetReadDeadline, andConn.SetWriteDeadline.

func (*Conn)RemoteAddr¶

func (c *Conn) RemoteAddr()net.Addr

RemoteAddr returns the remote network address.

func (*Conn)SetDeadline¶

func (c *Conn) SetDeadline(ttime.Time)error

SetDeadline sets the read and write deadlines associated with the connection.A zero value for t meansConn.Read andConn.Write will not time out.After a Write has timed out, the TLS state is corrupt and all future writes will return the same error.

func (*Conn)SetReadDeadline¶

func (c *Conn) SetReadDeadline(ttime.Time)error

SetReadDeadline sets the read deadline on the underlying connection.A zero value for t meansConn.Read will not time out.

func (*Conn)SetWriteDeadline¶

func (c *Conn) SetWriteDeadline(ttime.Time)error

SetWriteDeadline sets the write deadline on the underlying connection.A zero value for t meansConn.Write will not time out.After aConn.Write has timed out, the TLS state is corrupt and all future writes will return the same error.

func (*Conn)VerifyHostname¶

func (c *Conn) VerifyHostname(hoststring)error

VerifyHostname checks that the peer certificate chain is valid forconnecting to host. If so, it returns nil; if not, it returns an errordescribing the problem.

func (*Conn)Write¶

func (c *Conn) Write(b []byte) (int,error)

Write writes data to the connection.

As Write callsConn.Handshake, in order to prevent indefinite blocking a deadlinemust be set for bothConn.Read and Write before Write is called when the handshakehas not yet completed. SeeConn.SetDeadline,Conn.SetReadDeadline, andConn.SetWriteDeadline.

type ConnectionState struct {// Version is the TLS version used by the connection (e.g. VersionTLS12).Versionuint16// HandshakeComplete is true if the handshake has concluded.HandshakeCompletebool// DidResume is true if this connection was successfully resumed from a// previous session with a session ticket or similar mechanism.DidResumebool// CipherSuite is the cipher suite negotiated for the connection (e.g.// TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS_AES_128_GCM_SHA256).CipherSuiteuint16// CurveID is the key exchange mechanism used for the connection. The name// refers to elliptic curves for legacy reasons, see [CurveID]. If a legacy// RSA key exchange is used, this value is zero.CurveIDCurveID// NegotiatedProtocol is the application protocol negotiated with ALPN.NegotiatedProtocolstring// NegotiatedProtocolIsMutual used to indicate a mutual NPN negotiation.//// Deprecated: this value is always true.NegotiatedProtocolIsMutualbool// ServerName is the value of the Server Name Indication extension sent by// the client. It's available both on the server and on the client side.ServerNamestring// PeerCertificates are the parsed certificates sent by the peer, in the// order in which they were sent. The first element is the leaf certificate// that the connection is verified against.//// On the client side, it can't be empty. On the server side, it can be// empty if Config.ClientAuth is not RequireAnyClientCert or// RequireAndVerifyClientCert.//// PeerCertificates and its contents should not be modified.PeerCertificates []*x509.Certificate// VerifiedChains is a list of one or more chains where the first element is// PeerCertificates[0] and the last element is from Config.RootCAs (on the// client side) or Config.ClientCAs (on the server side).//// On the client side, it's set if Config.InsecureSkipVerify is false. On// the server side, it's set if Config.ClientAuth is VerifyClientCertIfGiven// (and the peer provided a certificate) or RequireAndVerifyClientCert.//// VerifiedChains and its contents should not be modified.VerifiedChains [][]*x509.Certificate// SignedCertificateTimestamps is a list of SCTs provided by the peer// through the TLS handshake for the leaf certificate, if any.SignedCertificateTimestamps [][]byte// OCSPResponse is a stapled Online Certificate Status Protocol (OCSP)// response provided by the peer for the leaf certificate, if any.OCSPResponse []byte// TLSUnique contains the "tls-unique" channel binding value (seeRFC 5929,// Section 3). This value will be nil for TLS 1.3 connections and for// resumed connections that don't support Extended Master Secret (RFC 7627).TLSUnique []byte// ECHAccepted indicates if Encrypted Client Hello was offered by the client// and accepted by the server. Currently, ECH is supported only on the// client side.ECHAcceptedbool// contains filtered or unexported fields}

func (*ConnectionState)ExportKeyingMaterial¶added ingo1.11

func (cs *ConnectionState) ExportKeyingMaterial(labelstring, context []byte, lengthint) ([]byte,error)

ExportKeyingMaterial returns length bytes of exported key material in a newslice as defined inRFC 5705. If context is nil, it is not used as part ofthe seed. If the connection was set to allow renegotiation viaConfig.Renegotiation, or if the connections supports neither TLS 1.3 norExtended Master Secret, this function will return an error.

Exporting key material without Extended Master Secret or TLS 1.3 was disabledin Go 1.22 due to security issues (see the Security Considerations sectionsofRFC 5705 andRFC 7627), but can be re-enabled with the GODEBUG settingtlsunsafeekm=1.

type CurveIDuint16

func (CurveID)String¶added ingo1.15

func (iCurveID) String()string

type Dialer struct {// NetDialer is the optional dialer to use for the TLS connections'// underlying TCP connections.// A nil NetDialer is equivalent to the net.Dialer zero value.NetDialer *net.Dialer// Config is the TLS configuration to use for new connections.// A nil configuration is equivalent to the zero// configuration; see the documentation of Config for the// defaults.Config *Config}

func (*Dialer)Dial¶added ingo1.15

func (d *Dialer) Dial(network, addrstring) (net.Conn,error)

Dial connects to the given network address and initiates a TLShandshake, returning the resulting TLS connection.

The returnedConn, if any, will always be of type *Conn.

Dial uses context.Background internally; to specify the context,useDialer.DialContext.

func (*Dialer)DialContext¶added ingo1.15

func (d *Dialer) DialContext(ctxcontext.Context, network, addrstring) (net.Conn,error)

DialContext connects to the given network address and initiates a TLShandshake, returning the resulting TLS connection.

The provided Context must be non-nil. If the context expires beforethe connection is complete, an error is returned. Once successfullyconnected, any expiration of the context will not affect theconnection.

The returnedConn, if any, will always be of type *Conn.

type ECHRejectionError struct {RetryConfigList []byte}

func (*ECHRejectionError)Error¶added ingo1.23.0

func (e *ECHRejectionError) Error()string

type EncryptedClientHelloKey struct {// Config should be a marshalled ECHConfig associated with PrivateKey. This// must match the config provided to clients byte-for-byte. The config// should only specify the DHKEM(X25519, HKDF-SHA256) KEM ID (0x0020), the// HKDF-SHA256 KDF ID (0x0001), and a subset of the following AEAD IDs:// AES-128-GCM (0x0001), AES-256-GCM (0x0002), ChaCha20Poly1305 (0x0003).Config []byte// PrivateKey should be a marshalled private key. Currently, we expect// this to be the output of [ecdh.PrivateKey.Bytes].PrivateKey []byte// SendAsRetry indicates if Config should be sent as part of the list of// retry configs when ECH is requested by the client but rejected by the// server.SendAsRetrybool}

type QUICConfig struct {TLSConfig *Config// EnableSessionEvents may be set to true to enable the// [QUICStoreSession] and [QUICResumeSession] events for client connections.// When this event is enabled, sessions are not automatically// stored in the client session cache.// The application should use [QUICConn.StoreSession] to store sessions.EnableSessionEventsbool}

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

funcQUICClient¶added ingo1.21.0

func QUICClient(config *QUICConfig) *QUICConn

QUICClient returns a new TLS client side connection using QUICTransport as theunderlying transport. The config cannot be nil.

The config's MinVersion must be at least TLS 1.3.

funcQUICServer¶added ingo1.21.0

func QUICServer(config *QUICConfig) *QUICConn

QUICServer returns a new TLS server side connection using QUICTransport as theunderlying transport. The config cannot be nil.

The config's MinVersion must be at least TLS 1.3.

func (*QUICConn)Close¶added ingo1.21.0

func (q *QUICConn) Close()error

Close closes the connection and stops any in-progress handshake.

func (*QUICConn)ConnectionState¶added ingo1.21.0

func (q *QUICConn) ConnectionState()ConnectionState

ConnectionState returns basic TLS details about the connection.

func (*QUICConn)HandleData¶added ingo1.21.0

func (q *QUICConn) HandleData(levelQUICEncryptionLevel, data []byte)error

HandleData handles handshake bytes received from the peer.It may produce connection events, which may be read withQUICConn.NextEvent.

func (*QUICConn)NextEvent¶added ingo1.21.0

func (q *QUICConn) NextEvent()QUICEvent

NextEvent returns the next event occurring on the connection.It returns an event with a Kind ofQUICNoEvent when no events are available.

func (*QUICConn)SendSessionTicket¶added ingo1.21.0

func (q *QUICConn) SendSessionTicket(optsQUICSessionTicketOptions)error

SendSessionTicket sends a session ticket to the client.It produces connection events, which may be read withQUICConn.NextEvent.Currently, it can only be called once.

func (*QUICConn)SetTransportParameters¶added ingo1.21.0

func (q *QUICConn) SetTransportParameters(params []byte)

SetTransportParameters sets the transport parameters to send to the peer.

Server connections may delay setting the transport parameters until afterreceiving the client's transport parameters. SeeQUICTransportParametersRequired.

func (*QUICConn)Start¶added ingo1.21.0

func (q *QUICConn) Start(ctxcontext.Context)error

Start starts the client or server handshake protocol.It may produce connection events, which may be read withQUICConn.NextEvent.

Start must be called at most once.

func (*QUICConn)StoreSession¶added ingo1.23.0

func (q *QUICConn) StoreSession(session *SessionState)error

StoreSession stores a session previously received in a QUICStoreSession eventin the ClientSessionCache.The application may process additional events or modify the SessionStatebefore storing the session.

type QUICEncryptionLevelint

func (QUICEncryptionLevel)String¶added ingo1.21.0

func (lQUICEncryptionLevel) String()string

type QUICEvent struct {KindQUICEventKind// Set for QUICSetReadSecret, QUICSetWriteSecret, and QUICWriteData.LevelQUICEncryptionLevel// Set for QUICTransportParameters, QUICSetReadSecret, QUICSetWriteSecret, and QUICWriteData.// The contents are owned by crypto/tls, and are valid until the next NextEvent call.Data []byte// Set for QUICSetReadSecret and QUICSetWriteSecret.Suiteuint16// Set for QUICResumeSession and QUICStoreSession.SessionState *SessionState}

type QUICEventKindint

type QUICSessionTicketOptions struct {// EarlyData specifies whether the ticket may be used for 0-RTT.EarlyDataboolExtra     [][]byte}

type RecordHeaderError struct {// Msg contains a human readable string that describes the error.Msgstring// RecordHeader contains the five bytes of TLS record header that// triggered the error.RecordHeader [5]byte// Conn provides the underlying net.Conn in the case that a client// sent an initial handshake that didn't look like TLS.// It is nil if there's already been a handshake or a TLS alert has// been written to the connection.Connnet.Conn}

func (RecordHeaderError)Error¶added ingo1.6

func (eRecordHeaderError) Error()string

type RenegotiationSupportint

type SessionState struct {// Extra is ignored by crypto/tls, but is encoded by [SessionState.Bytes]// and parsed by [ParseSessionState].//// This allows [Config.UnwrapSession]/[Config.WrapSession] and// [ClientSessionCache] implementations to store and retrieve additional// data alongside this session.//// To allow different layers in a protocol stack to share this field,// applications must only append to it, not replace it, and must use entries// that can be recognized even if out of order (for example, by starting// with an id and version prefix).Extra [][]byte// EarlyData indicates whether the ticket can be used for 0-RTT in a QUIC// connection. The application may set this to false if it is true to// decline to offer 0-RTT even if supported.EarlyDatabool// contains filtered or unexported fields}

funcParseSessionState¶added ingo1.21.0

func ParseSessionState(data []byte) (*SessionState,error)

ParseSessionState parses aSessionState encoded bySessionState.Bytes.

func (*SessionState)Bytes¶added ingo1.21.0

func (s *SessionState) Bytes() ([]byte,error)

Bytes encodes the session, including any private fields, so that it can beparsed byParseSessionState. The encoding contains secret values criticalto the security of future and possibly past sessions.

The specific encoding should be considered opaque and may change incompatiblybetween Go versions.

type SignatureSchemeuint16

func (SignatureScheme)String¶added ingo1.15

func (iSignatureScheme) String()string