Code Examples
package main
import (
"crypto/tls"
"log"
"net/http"
"net/http/httptest"
"os"
)
// zeroSource is an io.Reader that returns an unlimited number of zero bytes.
type zeroSource struct{}
func (zeroSource) Read(b []byte) (n int, err error) {
for i := range b {
b[i] = 0
}
return len(b), nil
}
func main() {
// Debugging TLS applications by decrypting a network traffic capture.
// WARNING: Use of KeyLogWriter compromises security and should only be
// used for debugging.
// Dummy test HTTP server for the example with insecure random so output is
// reproducible.
server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
server.TLS = &tls.Config{
Rand: zeroSource{}, // for example only; don't do this.
}
server.StartTLS()
defer server.Close()
// Typically the log would go to an open file:
// w, err := os.OpenFile("tls-secrets.txt", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
w := os.Stdout
client := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
KeyLogWriter: w,
Rand: zeroSource{}, // for reproducible output; don't do this.
InsecureSkipVerify: true, // test server certificate is not trusted.
},
},
}
resp, err := client.Get(server.URL)
if err != nil {
log.Fatalf("Failed to get URL: %v", err)
}
resp.Body.Close()
// The resulting file can be used with Wireshark to decrypt the TLS
// connection by setting (Pre)-Master-Secret log filename in SSL Protocol
// preferences.
}
package main
import (
"crypto/tls"
"crypto/x509"
)
func main() {
// VerifyConnection can be used to replace and customize connection
// verification. This example shows a VerifyConnection implementation that
// will be approximately equivalent to what crypto/tls does normally to
// verify the peer's certificate.
// Client side configuration.
_ = &tls.Config{
// Set InsecureSkipVerify to skip the default validation we are
// replacing. This will not disable VerifyConnection.
InsecureSkipVerify: true,
VerifyConnection: func(cs tls.ConnectionState) error {
opts := x509.VerifyOptions{
DNSName: cs.ServerName,
Intermediates: x509.NewCertPool(),
}
for _, cert := range cs.PeerCertificates[1:] {
opts.Intermediates.AddCert(cert)
}
_, err := cs.PeerCertificates[0].Verify(opts)
return err
},
}
// Server side configuration.
_ = &tls.Config{
// Require client certificates (or VerifyConnection will run anyway and
// panic accessing cs.PeerCertificates[0]) but don't verify them with the
// default verifier. This will not disable VerifyConnection.
ClientAuth: tls.RequireAnyClientCert,
VerifyConnection: func(cs tls.ConnectionState) error {
opts := x509.VerifyOptions{
DNSName: cs.ServerName,
Intermediates: x509.NewCertPool(),
KeyUsages: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
}
for _, cert := range cs.PeerCertificates[1:] {
opts.Intermediates.AddCert(cert)
}
_, err := cs.PeerCertificates[0].Verify(opts)
return err
},
}
// Note that when certificates are not handled by the default verifier
// ConnectionState.VerifiedChains will be nil.
}
package main
import (
"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-----
MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G
A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp
Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1
MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG
A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL
v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8
eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq
tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd
C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa
zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB
mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH
V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n
bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG
3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs
J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO
291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS
ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd
AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7
TBj0/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()
}
package main
import (
"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
}
package main
import (
"crypto/tls"
"log"
)
func main() {
certPem := []byte(`-----BEGIN CERTIFICATE-----
MIIBhTCCASugAwIBAgIQIRi6zePL6mKjOipn+dNuaTAKBggqhkjOPQQDAjASMRAw
DgYDVQQKEwdBY21lIENvMB4XDTE3MTAyMDE5NDMwNloXDTE4MTAyMDE5NDMwNlow
EjEQMA4GA1UEChMHQWNtZSBDbzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD0d
7VNhbWvZLWPuj/RtHFjvtJBEwOkhbN/BnnE8rnZR8+sbwnc/KhCk3FhnpHZnQz7B
5aETbbIgmuvewdjvSBSjYzBhMA4GA1UdDwEB/wQEAwICpDATBgNVHSUEDDAKBggr
BgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MCkGA1UdEQQiMCCCDmxvY2FsaG9zdDo1
NDUzgg4xMjcuMC4wLjE6NTQ1MzAKBggqhkjOPQQDAgNIADBFAiEA2zpJEPQyz6/l
Wf86aX6PepsntZv2GYlA5UpabfT2EZICICpJ5h/iI+i341gBmLiAFQOyTDT+/wQc
6MF9+Yw1Yy0t
-----END CERTIFICATE-----`)
keyPem := []byte(`-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIIrYSSNQFaA2Hwf1duRSxKtLYX5CB04fSeQ6tF1aY/PuoAoGCCqGSM49
AwEHoUQDQgAEPR3tU2Fta9ktY+6P9G0cWO+0kETA6SFs38GecTyudlHz6xvCdz8q
EKTcWGekdmdDPsHloRNtsiCa697B2O9IFA==
-----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 main
import (
"crypto/tls"
"log"
"net/http"
"time"
)
func main() {
certPem := []byte(`-----BEGIN CERTIFICATE-----
MIIBhTCCASugAwIBAgIQIRi6zePL6mKjOipn+dNuaTAKBggqhkjOPQQDAjASMRAw
DgYDVQQKEwdBY21lIENvMB4XDTE3MTAyMDE5NDMwNloXDTE4MTAyMDE5NDMwNlow
EjEQMA4GA1UEChMHQWNtZSBDbzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABD0d
7VNhbWvZLWPuj/RtHFjvtJBEwOkhbN/BnnE8rnZR8+sbwnc/KhCk3FhnpHZnQz7B
5aETbbIgmuvewdjvSBSjYzBhMA4GA1UdDwEB/wQEAwICpDATBgNVHSUEDDAKBggr
BgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MCkGA1UdEQQiMCCCDmxvY2FsaG9zdDo1
NDUzgg4xMjcuMC4wLjE6NTQ1MzAKBggqhkjOPQQDAgNIADBFAiEA2zpJEPQyz6/l
Wf86aX6PepsntZv2GYlA5UpabfT2EZICICpJ5h/iI+i341gBmLiAFQOyTDT+/wQc
6MF9+Yw1Yy0t
-----END CERTIFICATE-----`)
keyPem := []byte(`-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIIrYSSNQFaA2Hwf1duRSxKtLYX5CB04fSeQ6tF1aY/PuoAoGCCqGSM49
AwEHoUQDQgAEPR3tU2Fta9ktY+6P9G0cWO+0kETA6SFs38GecTyudlHz6xvCdz8q
EKTcWGekdmdDPsHloRNtsiCa697B2O9IFA==
-----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("", ""))
}
Package-Level Type Names (total 77, in which 24 are exported)
/* sort exporteds by: | */
An AlertError is a TLS alert.
When using a QUIC transport, QUICConn methods will return an error
which wraps AlertError rather than sending a TLS alert.( AlertError) Error() string
AlertError : error
CertificateRequestInfo contains information from a server's
CertificateRequest message, which is used to demand a certificate and proof
of control from a client. 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. SignatureSchemes lists the signature schemes that the server is
willing to verify. Version is the TLS version that was negotiated for this connection. ctx is the context of the handshake that is in progress. 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. SupportsCertificate returns nil if the provided certificate is supported by
the server that sent the CertificateRequest. Otherwise, it returns an error
describing the reason for the incompatibility.
func certificateRequestInfoFromMsg(ctx context.Context, vers uint16, certReq *certificateRequestMsg) *CertificateRequestInfo
func (*Conn).getClientCertificate(cri *CertificateRequestInfo) (*Certificate, error)
CertificateVerificationError is returned when certificate verification fails during the handshake.Errerror UnverifiedCertificates and its contents should not be modified.(*CertificateVerificationError) Error() string(*CertificateVerificationError) Unwrap() error
*CertificateVerificationError : error
*CertificateVerificationError : github.com/go-faster/errors.Wrapper
CipherSuite is a TLS cipher suite. Note that most functions in this package
accept and expose cipher suite IDs instead of this type.IDuint16 Insecure is true if the cipher suite has known security issues
due to its primitives, design, or implementation.Namestring Supported versions is the list of TLS protocol versions that can
negotiate this cipher suite.
func CipherSuites() []*CipherSuite
func InsecureCipherSuites() []*CipherSuite
ClientHelloInfo contains information from a ClientHello message in order to
guide application logic in the GetCertificate and GetConfigForClient callbacks. CipherSuites lists the CipherSuites supported by the client (e.g.
TLS_AES_128_GCM_SHA256, TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256). 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. 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 (see RFC 4366, Section 3.1). 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 (see RFC 5246, Section 7.4.1.4.1). SupportedCurves lists the elliptic curves supported by the client.
SupportedCurves is set only if the Supported Elliptic Curves
Extension is being used (see RFC 4492, Section 5.1.1). SupportedPoints lists the point formats supported by the client.
SupportedPoints is set only if the Supported Point Formats Extension
is being used (see RFC 4492, Section 5.1.2). SupportedProtos lists the application protocols supported by the client.
SupportedProtos is set only if the Application-Layer Protocol
Negotiation Extension is being used (see RFC 7301, Section 3.1).
Servers can select a protocol by setting Config.NextProtos in a
GetConfigForClient return value. 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. config is embedded by the GetCertificate or GetConfigForClient caller,
for use with SupportsCertificate. ctx is the context of the handshake that is in progress. 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. SupportsCertificate returns nil if the provided certificate is supported by
the client that sent the ClientHello. Otherwise, it returns an error
describing the reason for the incompatibility.
If this ClientHelloInfo was passed to a GetConfigForClient or GetCertificate
callback, this method will take into account the associated Config. Note that
if GetConfigForClient returns a different Config, the change can't be
accounted for by this method.
This function will call x509.ParseCertificate unless c.Leaf is set, which can
incur a significant performance cost.
func clientHelloInfo(ctx context.Context, c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo
func (*Config).getCertificate(clientHello *ClientHelloInfo) (*Certificate, error)
ClientSessionCache is a cache of ClientSessionState objects that can be used
by a client to resume a TLS session with a given server. ClientSessionCache
implementations should expect to be called concurrently from different
goroutines. Up to TLS 1.2, only ticket-based resumption is supported, not
SessionID-based resumption. In TLS 1.3 they were merged into PSK modes, which
are supported via this interface. Get searches for a ClientSessionState associated with the given key.
On return, ok is true if one was found. 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.
*lruSessionCache
func NewLRUClientSessionCache(capacity int) ClientSessionCache
ClientSessionState contains the state needed by a client to
resume a previous TLS session.session*SessionStateticket[]byte ResumptionState returns the session ticket sent by the server (also known as
the session's identity) and the state necessary to resume this session.
It can be called by [ClientSessionCache.Put] to serialize (with
[SessionState.Bytes]) and store the session.
func NewResumptionState(ticket []byte, state *SessionState) (*ClientSessionState, error)
func ClientSessionCache.Get(sessionKey string) (session *ClientSessionState, ok bool)
func ClientSessionCache.Put(sessionKey string, cs *ClientSessionState)
A Config structure is used to configure a TLS client or server.
After one has been passed to a TLS function it must not be
modified. A Config may be reused; the tls package will also not
modify it. 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. 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. ClientAuth determines the server's policy for
TLS Client Authentication. The default is NoClientCert. ClientCAs defines the set of root certificate authorities
that servers use if required to verify a client certificate
by the policy in ClientAuth. ClientSessionCache is a cache of ClientSessionState entries for TLS
session resumption. It is only used by clients. CurvePreferences contains the elliptic curves that will be used in
an ECDHE handshake, in preference order. If empty, the default will
be used. The client will use the first preference as the type for
its key share in TLS 1.3. This may change in the future. 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. 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. 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. 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). 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. 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.
See https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS/Key_Log_Format.
Use of KeyLogWriter compromises security and should only be
used for debugging. 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. MinVersion contains the minimum TLS version that is acceptable.
By default, TLS 1.2 is currently used as the minimum when acting as a
client, and TLS 1.0 when acting as a server. TLS 1.0 is the minimum
supported by this package, both as a client and as a server.
The client-side default can temporarily be reverted to TLS 1.0 by
including the value "x509sha1=1" in the GODEBUG environment variable.
Note that this option will be removed in Go 1.19 (but it will still be
possible to set this field to VersionTLS10 explicitly). 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. 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. 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. 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. Renegotiation controls what types of renegotiation are supported.
The default, none, is correct for the vast majority of applications. 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. 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. SessionTicketKey is used by TLS servers to provide session resumption.
See RFC 5077 and the PSK mode of RFC 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. 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. Time returns the current time as the number of seconds since the epoch.
If Time is nil, TLS uses time.Now. 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. 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. 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. 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. autoSessionTicketKeys is like sessionTicketKeys but is owned by the
auto-rotation logic. See Config.ticketKeys. mutex protects sessionTicketKeys and autoSessionTicketKeys. sessionTicketKeys contains zero or more ticket keys. If set, it means
the keys were set with SessionTicketKey or SetSessionTicketKeys. The
first key is used for new tickets and any subsequent keys can be used to
decrypt old tickets. The slice contents are not protected by the mutex
and are immutable. BuildNameToCertificate parses c.Certificates and builds c.NameToCertificate
from the CommonName and SubjectAlternateName fields of each of the leaf
certificates.
Deprecated: NameToCertificate only allows associating a single certificate
with a given name. Leave that field nil to let the library select the first
compatible chain from Certificates. Clone returns a shallow clone of c or nil if c is nil. It is safe to clone a Config that is
being used concurrently by a TLS client or server. DecryptTicket decrypts a ticket encrypted by [Config.EncryptTicket]. It can
be used as a [Config.UnwrapSession] implementation.
If the ticket can't be decrypted or parsed, DecryptTicket returns (nil, nil). EncryptTicket encrypts a ticket with the Config's configured (or default)
session ticket keys. It can be used as a [Config.WrapSession] implementation. SetSessionTicketKeys updates the session ticket keys for a server.
The first key will be used when creating new tickets, while all keys can be
used for decrypting tickets. It is safe to call this function while the
server is running in order to rotate the session ticket keys. The function
will 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 should
all have the same session ticket keys. If the session ticket keys leaks,
previously recorded and future TLS connections using those keys might be
compromised.(*Config) cipherSuites() []uint16(*Config) curvePreferences() []CurveID(*Config) decryptTicket(encrypted []byte, ticketKeys []ticketKey) []byte(*Config) encryptTicket(state []byte, ticketKeys []ticketKey) ([]byte, error) getCertificate returns the best certificate for the given ClientHelloInfo,
defaulting to the first element of c.Certificates. initLegacySessionTicketKeyRLocked ensures the legacy SessionTicketKey field is
randomized if empty, and that sessionTicketKeys is populated from it otherwise.(*Config) maxSupportedVersion(isClient bool) uint16 mutualVersion returns the protocol version to use given the advertised
versions of the peer. Priority is given to the peer preference order.(*Config) rand() io.Reader(*Config) supportedVersions(isClient bool) []uint16(*Config) supportsCurve(curve CurveID) bool ticketKeyFromBytes converts from the external representation of a session
ticket key to a ticketKey. Externally, session ticket keys are 32 random
bytes and this function expands that into sufficient name and key material. ticketKeys returns the ticketKeys for this connection.
If configForClient has explicitly set keys, those will
be returned. Otherwise, the keys on c will be used and
may be rotated if auto-managed.
During rotation, any expired session ticket keys are deleted from
c.sessionTicketKeys. If the session ticket key that is currently
encrypting tickets (ie. the first ticketKey in c.sessionTicketKeys)
is not fresh, then a new session ticket key will be
created and prepended to c.sessionTicketKeys.(*Config) time() time.Time(*Config) writeKeyLog(label string, clientRandom, secret []byte) error
func (*Config).Clone() *Config
func defaultConfig() *Config
func net/http.cloneTLSConfig(cfg *Config) *Config
func Client(conn net.Conn, config *Config) *Conn
func Dial(network, addr string, config *Config) (*Conn, error)
func DialWithDialer(dialer *net.Dialer, network, addr string, config *Config) (*Conn, error)
func Listen(network, laddr string, config *Config) (net.Listener, error)
func NewListener(inner net.Listener, config *Config) net.Listener
func Server(conn net.Conn, config *Config) *Conn
func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, config *Config) (*Conn, error)
func fipsCipherSuites(c *Config) []uint16
func fipsCurvePreferences(c *Config) []CurveID
func fipsMaxVersion(c *Config) uint16
func fipsMinVersion(c *Config) uint16
func supportsECDHE(c *Config, supportedCurves []CurveID, supportedPoints []uint8) bool
func (*Config).ticketKeys(configForClient *Config) []ticketKey
func net/http.cloneTLSConfig(cfg *Config) *Config
var emptyConfig
A Conn represents a secured connection.
It implements the net.Conn interface. activeCall indicates whether Close has been call in the low bit.
the rest of the bits are the number of goroutines in Conn.Write. activeCertHandles contains the cache handles to certificates in
peerCertificates that are used to track active references. // whether records are buffered in sendBuf bytesSent counts the bytes of application data sent.
packetsSent counts packets.cipherSuiteuint16 clientFinished and serverFinished contain the Finished message sent
by the client or server in the most recent handshake. This is
retained to support the renegotiation extension and tls-unique
channel-binding. clientFinishedIsFirst is true if the client sent the first Finished
message during the most recent handshake. This is recorded because
the first transmitted Finished message is the tls-unique
channel-binding value. clientProtocol is the negotiated ALPN protocol. closeNotifyErr is any error from sending the alertCloseNotify record. closeNotifySent is true if the Conn attempted to send an
alertCloseNotify record. // configuration passed to constructor constant // whether this connection was a session resumption ekm is a closure for exporting keying material.extMasterSecretbool // handshake data waiting to be read // error resulting from handshake // (*Conn).clientHandshake or serverHandshake constant after handshake; protected by handshakeMutex handshakes counts the number of handshakes performed on the
connection so far. If renegotiation is disabled then this is either
zero or one. // version has been negotiated input/output // application data waiting to be read, from rawInput.NextisClientbool isHandshakeComplete is true if the connection is currently transferring
application data (i.e. is not currently processing a handshake).
isHandshakeComplete is true implies handshakeErr == nil. // stapled OCSP response input/outputpacketsSentint64peerCertificates[]*x509.Certificate // nil for non-QUIC connections // raw input, starting with a record header resumptionSecret is the resumption_master_secret for handling
or sending NewSessionTicket messages. retryCount counts the number of consecutive non-advancing records
received by Conn.readRecord. That is, records that neither advance the
handshake, nor deliver application data. Protected by in.Mutex. // signed certificate timestamps from server secureRenegotiation is true if the server echoed the secure
renegotiation extension. (This is meaningless as a server because
renegotiation is not supported in that case.) // a buffer of records waiting to be sentserverFinished[12]byte serverName contains the server name indicated by the client, if any. ticketKeys is the set of active session ticket keys for this
connection. The first one is used to encrypt new tickets and
all are tried to decrypt tickets.tmp[16]byte verifiedChains contains the certificate chains that we built, as
opposed to the ones presented by the server. // TLS version Close closes the connection. CloseWrite shuts down the writing side of the connection. It should only be
called once the handshake has completed and does not call CloseWrite on the
underlying connection. Most callers should just use Close. ConnectionState returns basic TLS details about the connection. Handshake runs the client or server handshake
protocol if it has not yet been run.
Most uses of this package need not call Handshake explicitly: the
first Read or Write will call it automatically.
For control over canceling or setting a timeout on a handshake, use
HandshakeContext or the Dialer's DialContext method instead.
In order to avoid denial of service attacks, the maximum RSA key size allowed
in certificates sent by either the TLS server or client is limited to 8192
bits. This limit can be overridden by setting tlsmaxrsasize in the GODEBUG
environment variable (e.g. GODEBUG=tlsmaxrsasize=4096). HandshakeContext runs the client or server handshake
protocol if it has not yet been run.
The provided Context must be non-nil. If the context is canceled before
the handshake is complete, the handshake is interrupted and an error is returned.
Once the handshake has completed, cancellation of the context will not affect the
connection.
Most uses of this package need not call HandshakeContext explicitly: the
first Read or Write will call it automatically. LocalAddr returns the local network address. NetConn returns the underlying connection that is wrapped by c.
Note that writing to or reading from this connection directly will corrupt the
TLS session. OCSPResponse returns the stapled OCSP response from the TLS server, if
any. (Only valid for client connections.) Read reads data from the connection.
As Read calls Handshake, in order to prevent indefinite blocking a deadline
must be set for both Read and Write before Read is called when the handshake
has not yet completed. See SetDeadline, SetReadDeadline, and
SetWriteDeadline. RemoteAddr returns the remote network address. SetDeadline sets the read and write deadlines associated with the connection.
A zero value for t means Read and 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. SetReadDeadline sets the read deadline on the underlying connection.
A zero value for t means Read will not time out. SetWriteDeadline sets the write deadline on the underlying connection.
A zero value for t means 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. VerifyHostname checks that the peer certificate chain is valid for
connecting to host. If so, it returns nil; if not, it returns an error
describing the problem. Write writes data to the connection.
As Write calls Handshake, in order to prevent indefinite blocking a deadline
must be set for both Read and Write before Write is called when the handshake
has not yet completed. See SetDeadline, SetReadDeadline, and
SetWriteDeadline.(*Conn) clientHandshake(ctx context.Context) (err error) clientSessionCacheKey returns a key used to cache sessionTickets that could
be used to resume previously negotiated TLS sessions with a server.(*Conn) closeNotify() error(*Conn) connectionStateLocked() ConnectionState(*Conn) flush() (int, error)(*Conn) getClientCertificate(cri *CertificateRequestInfo) (*Certificate, error)(*Conn) handleKeyUpdate(keyUpdate *keyUpdateMsg) error(*Conn) handleNewSessionTicket(msg *newSessionTicketMsgTLS13) error handlePostHandshakeMessage processes a handshake message arrived after the
handshake is complete. Up to TLS 1.2, it indicates the start of a renegotiation. handleRenegotiation processes a HelloRequest handshake message.(*Conn) handshakeContext(ctx context.Context) (ret error)(*Conn) loadSession(hello *clientHelloMsg) (session *SessionState, earlySecret, binderKey []byte, err error)(*Conn) makeClientHello() (*clientHelloMsg, *ecdh.PrivateKey, error) maxPayloadSizeForWrite returns the maximum TLS payload size to use for the
next application data record. There is the following trade-off:
- For latency-sensitive applications, such as web browsing, each TLS
record should fit in one TCP segment.
- For throughput-sensitive applications, such as large file transfers,
larger TLS records better amortize framing and encryption overheads.
A simple heuristic that works well in practice is to use small records for
the first 1MB of data, then use larger records for subsequent data, and
reset back to smaller records after the connection becomes idle. See "High
Performance Web Networking", Chapter 4, or:
https://www.igvita.com/2013/10/24/optimizing-tls-record-size-and-buffering-latency/
In the interests of simplicity and determinism, this code does not attempt
to reset the record size once the connection is idle, however.(*Conn) newRecordHeaderError(conn net.Conn, msg string) (err RecordHeaderError)(*Conn) pickTLSVersion(serverHello *serverHelloMsg) error processCertsFromClient takes a chain of client certificates either from a
Certificates message and verifies them.(*Conn) quicGetTransportParameters() ([]byte, error)(*Conn) quicHandshakeComplete()(*Conn) quicReadHandshakeBytes(n int) error(*Conn) quicRejectedEarlyData()(*Conn) quicSetReadSecret(level QUICEncryptionLevel, suite uint16, secret []byte)(*Conn) quicSetTransportParameters(params []byte)(*Conn) quicSetWriteSecret(level QUICEncryptionLevel, suite uint16, secret []byte) quicWaitForSignal notifies the QUICConn that handshake progress is blocked,
and waits for a signal that the handshake should proceed.
The handshake may become blocked waiting for handshake bytes
or for the user to provide transport parameters.(*Conn) quicWriteCryptoData(level QUICEncryptionLevel, data []byte)(*Conn) readChangeCipherSpec() error readClientHello reads a ClientHello message and selects the protocol version. readFromUntil reads from r into c.rawInput until c.rawInput contains
at least n bytes or else returns an error. readHandshake reads the next handshake message from
the record layer. If transcript is non-nil, the message
is written to the passed transcriptHash. readHandshakeBytes reads handshake data until c.hand contains at least n bytes.(*Conn) readRecord() error readRecordOrCCS reads one or more TLS records from the connection and
updates the record layer state. Some invariants:
- c.in must be locked
- c.input must be empty
During the handshake one and only one of the following will happen:
- c.hand grows
- c.in.changeCipherSpec is called
- an error is returned
After the handshake one and only one of the following will happen:
- c.hand grows
- c.input is set
- an error is returned retryReadRecord recurs into readRecordOrCCS to drop a non-advancing record, like
a warning alert, empty application_data, or a change_cipher_spec in TLS 1.3. sendAlert sends a TLS alert message. sendAlertLocked sends a TLS alert message.(*Conn) sendSessionTicket(earlyData bool) error serverHandshake performs a TLS handshake as a server. sessionState returns a partially filled-out [SessionState] with information
from the current connection.(*Conn) unmarshalHandshakeMessage(data []byte, transcript transcriptHash) (handshakeMessage, error) verifyServerCertificate parses and verifies the provided chain, setting
c.verifiedChains and c.peerCertificates or sending the appropriate alert.(*Conn) write(data []byte) (int, error) writeChangeCipherRecord writes a ChangeCipherSpec message to the connection and
updates the record layer state. writeHandshakeRecord writes a handshake message to the connection and updates
the record layer state. If transcript is non-nil the marshalled message is
written to it. writeRecordLocked writes a TLS record with the given type and payload to the
connection and updates the record layer state.
*Conn : internal/bisect.Writer
*Conn : io.Closer
*Conn : io.ReadCloser
*Conn : io.Reader
*Conn : io.ReadWriteCloser
*Conn : io.ReadWriter
*Conn : io.WriteCloser
*Conn : io.Writer
*Conn : net.Conn
*Conn : transcriptHash
*Conn : net/http.closeWriter
*Conn : net/http.http2connectionStater
func Client(conn net.Conn, config *Config) *Conn
func Dial(network, addr string, config *Config) (*Conn, error)
func DialWithDialer(dialer *net.Dialer, network, addr string, config *Config) (*Conn, error)
func Server(conn net.Conn, config *Config) *Conn
func dial(ctx context.Context, netDialer *net.Dialer, network, addr string, config *Config) (*Conn, error)
func clientHelloInfo(ctx context.Context, c *Conn, clientHello *clientHelloMsg) *ClientHelloInfo
func newQUICConn(conn *Conn) *QUICConn
func net/http.http2tlsUnderlyingConn(tc *Conn) net.Conn
ConnectionState records basic TLS details about the connection. CipherSuite is the cipher suite negotiated for the connection (e.g.
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS_AES_128_GCM_SHA256). DidResume is true if this connection was successfully resumed from a
previous session with a session ticket or similar mechanism. HandshakeComplete is true if the handshake has concluded. NegotiatedProtocol is the application protocol negotiated with ALPN. NegotiatedProtocolIsMutual used to indicate a mutual NPN negotiation.
Deprecated: this value is always true. OCSPResponse is a stapled Online Certificate Status Protocol (OCSP)
response provided by the peer for the leaf certificate, if any. 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. 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. SignedCertificateTimestamps is a list of SCTs provided by the peer
through the TLS handshake for the leaf certificate, if any. TLSUnique contains the "tls-unique" channel binding value (see RFC 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). 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. Version is the TLS version used by the connection (e.g. VersionTLS12). ekm is a closure exposed via ExportKeyingMaterial. ExportKeyingMaterial returns length bytes of exported key material in a new
slice as defined in RFC 5705. If context is nil, it is not used as part of
the seed. If the connection was set to allow renegotiation via
Config.Renegotiation, this function will return an error.
There are conditions in which the returned values might not be unique to a
connection. See the Security Considerations sections of RFC 5705 and RFC 7627,
and https://mitls.org/pages/attacks/3SHAKE#channelbindings.
func (*Conn).ConnectionState() ConnectionState
func (*QUICConn).ConnectionState() ConnectionState
func (*Conn).connectionStateLocked() ConnectionState
func (*Config).DecryptTicket(identity []byte, cs ConnectionState) (*SessionState, error)
func (*Config).EncryptTicket(cs ConnectionState, ss *SessionState) ([]byte, error)
Dialer dials TLS connections given a configuration and a Dialer for the
underlying connection. 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. 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. Dial connects to the given network address and initiates a TLS
handshake, returning the resulting TLS connection.
The returned Conn, if any, will always be of type *Conn.
Dial uses context.Background internally; to specify the context,
use DialContext. DialContext connects to the given network address and initiates a TLS
handshake, returning the resulting TLS connection.
The provided Context must be non-nil. If the context expires before
the connection is complete, an error is returned. Once successfully
connected, any expiration of the context will not affect the
connection.
The returned Conn, if any, will always be of type *Conn.(*Dialer) netDialer() *net.Dialer
*Dialer : golang.org/x/net/proxy.ContextDialer
*Dialer : golang.org/x/net/proxy.Dialer
A QUICConn represents a connection which uses a QUIC implementation as the underlying
transport as described in RFC 9001.
Methods of QUICConn are not safe for concurrent use.conn*ConnsessionTicketSentbool Close closes the connection and stops any in-progress handshake. ConnectionState returns basic TLS details about the connection. HandleData handles handshake bytes received from the peer.
It may produce connection events, which may be read with NextEvent. NextEvent returns the next event occurring on the connection.
It returns an event with a Kind of QUICNoEvent when no events are available. SendSessionTicket sends a session ticket to the client.
It produces connection events, which may be read with NextEvent.
Currently, it can only be called once. SetTransportParameters sets the transport parameters to send to the peer.
Server connections may delay setting the transport parameters until after
receiving the client's transport parameters. See QUICTransportParametersRequired. Start starts the client or server handshake protocol.
It may produce connection events, which may be read with NextEvent.
Start must be called at most once.
*QUICConn : io.Closer
*QUICConn : net/http.http2connectionStater
func QUICClient(config *QUICConfig) *QUICConn
func QUICServer(config *QUICConfig) *QUICConn
func newQUICConn(conn *Conn) *QUICConn
A QUICEvent is an event occurring on a QUIC connection.
The type of event is specified by the Kind field.
The contents of the other fields are kind-specific. Set for QUICTransportParameters, QUICSetReadSecret, QUICSetWriteSecret, and QUICWriteData.
The contents are owned by crypto/tls, and are valid until the next NextEvent call.KindQUICEventKind Set for QUICSetReadSecret, QUICSetWriteSecret, and QUICWriteData. Set for QUICSetReadSecret and QUICSetWriteSecret.
func (*QUICConn).NextEvent() QUICEvent
EarlyData specifies whether the ticket may be used for 0-RTT.
func (*QUICConn).SendSessionTicket(opts QUICSessionTicketOptions) error
RecordHeaderError is returned when a TLS record header is invalid. 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. Msg contains a human readable string that describes the error. RecordHeader contains the five bytes of TLS record header that
triggered the error.( RecordHeaderError) Error() string
RecordHeaderError : error
func (*Conn).newRecordHeaderError(conn net.Conn, msg string) (err RecordHeaderError)
RenegotiationSupport enumerates the different levels of support for TLS
renegotiation. TLS renegotiation is the act of performing subsequent
handshakes on a connection after the first. This significantly complicates
the state machine and has been the source of numerous, subtle security
issues. Initiating a renegotiation is not supported, but support for
accepting renegotiation requests may be enabled.
Even when enabled, the server may not change its identity between handshakes
(i.e. the leaf certificate must be the same). Additionally, concurrent
handshake and application data flow is not permitted so renegotiation can
only be used with protocols that synchronise with the renegotiation, such as
HTTPS.
Renegotiation is not defined in TLS 1.3.
const RenegotiateFreelyAsClient
const RenegotiateNever
const RenegotiateOnceAsClient
A SessionState is a resumable session. 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. 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 a id and version prefix).activeCertHandles[]*activeCertageAdduint32 // only set if EarlyData is truecipherSuiteuint16 createdAt is the generation time of the secret on the sever (which for
TLS 1.0–1.2 might be earlier than the current session) and the time at
which the ticket was received on the client. // seconds since UNIX epochextMasterSecretboolisClientboolocspResponse[]bytepeerCertificates[]*x509.Certificatescts[][]byte // master secret for TLS 1.2, or the PSK for TLS 1.3 Client-side TLS 1.3-only fields. // seconds since UNIX epochverifiedChains[][]*x509.Certificateversionuint16 Bytes encodes the session, including any private fields, so that it can be
parsed by [ParseSessionState]. The encoding contains secret values critical
to the security of future and possibly past sessions.
The specific encoding should be considered opaque and may change incompatibly
between Go versions.
func ParseSessionState(data []byte) (*SessionState, error)
func (*ClientSessionState).ResumptionState() (ticket []byte, state *SessionState, err error)
func (*Config).DecryptTicket(identity []byte, cs ConnectionState) (*SessionState, error)
func (*Conn).loadSession(hello *clientHelloMsg) (session *SessionState, earlySecret, binderKey []byte, err error)
func (*Conn).sessionState() (*SessionState, error)
func NewResumptionState(ticket []byte, state *SessionState) (*ClientSessionState, error)
func (*Config).EncryptTicket(cs ConnectionState, ss *SessionState) ([]byte, error)
activeCert is a handle to a certificate held in the cache. Once there are
no alive activeCerts for a given certificate, the certificate is removed
from the cache by a finalizer.cert*x509.Certificate
NonceSize returns the size of the nonce that must be passed to Seal
and Open. Open decrypts and authenticates ciphertext, authenticates the
additional data and, if successful, appends the resulting plaintext
to dst, returning the updated slice. The nonce must be NonceSize()
bytes long and both it and the additional data must match the
value passed to Seal.
To reuse ciphertext's storage for the decrypted output, use ciphertext[:0]
as dst. Otherwise, the remaining capacity of dst must not overlap plaintext.
Even if the function fails, the contents of dst, up to its capacity,
may be overwritten. Overhead returns the maximum difference between the lengths of a
plaintext and its ciphertext. Seal encrypts and authenticates plaintext, authenticates the
additional data and appends the result to dst, returning the updated
slice. The nonce must be NonceSize() bytes long and unique for all
time, for a given key.
To reuse plaintext's storage for the encrypted output, use plaintext[:0]
as dst. Otherwise, the remaining capacity of dst must not overlap plaintext. explicitNonceLen returns the number of bytes of explicit nonce
included in each record. This is eight for older AEADs and
zero for modern ones.
*prefixNonceAEAD
*xorNonceAEAD
aead : crypto/cipher.AEAD
func aeadAESGCM(key, noncePrefix []byte) aead
func aeadAESGCMTLS13(key, nonceMask []byte) aead
func aeadChaCha20Poly1305(key, nonceMask []byte) aead
atLeastReader reads from R, stopping with EOF once at least N bytes have been
read. It is different from an io.LimitedReader in that it doesn't cut short
the last Read call, and in that it considers an early EOF an error. // max bytes remaining // underlying reader(*atLeastReader) Read(p []byte) (int, error)
*atLeastReader : io.Reader
cbcMode is an interface for block ciphers using cipher block chaining. BlockSize returns the mode's block size. CryptBlocks encrypts or decrypts a number of blocks. The length of
src must be a multiple of the block size. Dst and src must overlap
entirely or not at all.
If len(dst) < len(src), CryptBlocks should panic. It is acceptable
to pass a dst bigger than src, and in that case, CryptBlocks will
only update dst[:len(src)] and will not touch the rest of dst.
Multiple calls to CryptBlocks behave as if the concatenation of
the src buffers was passed in a single run. That is, BlockMode
maintains state and does not reset at each CryptBlocks call.( cbcMode) SetIV([]byte)
*crypto/cipher.cbcDecrypter
*crypto/cipher.cbcEncrypter
cbcMode : crypto/cipher.BlockMode
cbcMode : github.com/gotd/ige.IGE
certCache implements an intern table for reference counted x509.Certificates,
implemented in a similar fashion to BoringSSL's CRYPTO_BUFFER_POOL. This
allows for a single x509.Certificate to be kept in memory and referenced from
multiple Conns. Returned references should not be mutated by callers. Certificates
are still safe to use after they are removed from the cache.
Certificates are returned wrapped in an activeCert struct that should be held by
the caller. When references to the activeCert are freed, the number of references
to the certificate in the cache is decremented. Once the number of references
reaches zero, the entry is evicted from the cache.
The main difference between this implementation and CRYPTO_BUFFER_POOL is that
CRYPTO_BUFFER_POOL is a more generic structure which supports blobs of data,
rather than specific structures. Since we only care about x509.Certificates,
certCache is implemented as a specific cache, rather than a generic one.
See https://boringssl.googlesource.com/boringssl/+/master/include/openssl/pool.h
and https://boringssl.googlesource.com/boringssl/+/master/crypto/pool/pool.c
for the BoringSSL reference.Mapsync.Map dirty contains the portion of the map's contents that require mu to be
held. To ensure that the dirty map can be promoted to the read map quickly,
it also includes all of the non-expunged entries in the read map.
Expunged entries are not stored in the dirty map. An expunged entry in the
clean map must be unexpunged and added to the dirty map before a new value
can be stored to it.
If the dirty map is nil, the next write to the map will initialize it by
making a shallow copy of the clean map, omitting stale entries. misses counts the number of loads since the read map was last updated that
needed to lock mu to determine whether the key was present.
Once enough misses have occurred to cover the cost of copying the dirty
map, the dirty map will be promoted to the read map (in the unamended
state) and the next store to the map will make a new dirty copy.Map.musync.Mutex read contains the portion of the map's contents that are safe for
concurrent access (with or without mu held).
The read field itself is always safe to load, but must only be stored with
mu held.
Entries stored in read may be updated concurrently without mu, but updating
a previously-expunged entry requires that the entry be copied to the dirty
map and unexpunged with mu held. CompareAndDelete deletes the entry for key if its value is equal to old.
The old value must be of a comparable type.
If there is no current value for key in the map, CompareAndDelete
returns false (even if the old value is the nil interface value). CompareAndSwap swaps the old and new values for key
if the value stored in the map is equal to old.
The old value must be of a comparable type. Delete deletes the value for a key. Load returns the value stored in the map for a key, or nil if no
value is present.
The ok result indicates whether value was found in the map. LoadAndDelete deletes the value for a key, returning the previous value if any.
The loaded result reports whether the key was present. LoadOrStore returns the existing value for the key if present.
Otherwise, it stores and returns the given value.
The loaded result is true if the value was loaded, false if stored. Range calls f sequentially for each key and value present in the map.
If f returns false, range stops the iteration.
Range does not necessarily correspond to any consistent snapshot of the Map's
contents: no key will be visited more than once, but if the value for any key
is stored or deleted concurrently (including by f), Range may reflect any
mapping for that key from any point during the Range call. Range does not
block other methods on the receiver; even f itself may call any method on m.
Range may be O(N) with the number of elements in the map even if f returns
false after a constant number of calls. Store sets the value for a key. Swap swaps the value for a key and returns the previous value if any.
The loaded result reports whether the key was present. active increments the number of references to the entry, wraps the
certificate in the entry in an activeCert, and sets the finalizer.
Note that there is a race between active and the finalizer set on the
returned activeCert, triggered if active is called after the ref count is
decremented such that refs may be > 0 when evict is called. We consider this
safe, since the caller holding an activeCert for an entry that is no longer
in the cache is fine, with the only side effect being the memory overhead of
there being more than one distinct reference to a certificate alive at once.(*certCache) dirtyLocked() evict removes a cacheEntry from the cache.(*certCache) loadReadOnly() sync.readOnly(*certCache) missLocked() newCert returns a x509.Certificate parsed from der. If there is already a copy
of the certificate in the cache, a reference to the existing certificate will
be returned. Otherwise, a fresh certificate will be added to the cache, and
the reference returned. The returned reference should not be mutated.
var globalCertCache *certCache
A cipherSuiteTLS13 defines only the pair of the AEAD algorithm and hash
algorithm to be used with HKDF. See RFC 8446, Appendix B.4.aeadfunc(key, fixedNonce []byte) aeadhashcrypto.Hashiduint16keyLenint deriveSecret implements Derive-Secret from RFC 8446, Section 7.1. expandLabel implements HKDF-Expand-Label from RFC 8446, Section 7.1. exportKeyingMaterial implements RFC5705 exporters for TLS 1.3 according to
RFC 8446, Section 7.5. extract implements HKDF-Extract with the cipher suite hash. finishedHash generates the Finished verify_data or PskBinderEntry according
to RFC 8446, Section 4.4.4. See sections 4.4 and 4.2.11.2 for the baseKey
selection. nextTrafficSecret generates the next traffic secret, given the current one,
according to RFC 8446, Section 7.2. trafficKey generates traffic keys according to RFC 8446, Section 7.3.
func cipherSuiteTLS13ByID(id uint16) *cipherSuiteTLS13
func mutualCipherSuiteTLS13(have []uint16, want uint16) *cipherSuiteTLS13
BlockSize returns the hash's underlying block size.
The Write method must be able to accept any amount
of data, but it may operate more efficiently if all writes
are a multiple of the block size.( constantTimeHash) ConstantTimeSum(b []byte) []byte Reset resets the Hash to its initial state. Size returns the number of bytes Sum will return. Sum appends the current hash to b and returns the resulting slice.
It does not change the underlying hash state.( constantTimeHash) Write([]byte) (int, error)
*crypto/sha1.digest
constantTimeHash : hash.Hash
constantTimeHash : internal/bisect.Writer
constantTimeHash : io.Writer
constantTimeHash : transcriptHash
cthWrapper wraps any hash.Hash that implements ConstantTimeSum, and replaces
with that all calls to Sum. It's used to obtain a ConstantTimeSum-based HMAC.hconstantTimeHash(*cthWrapper) BlockSize() int(*cthWrapper) Reset()(*cthWrapper) Size() int(*cthWrapper) Sum(b []byte) []byte(*cthWrapper) Write(p []byte) (int, error)
*cthWrapper : hash.Hash
*cthWrapper : internal/bisect.Writer
*cthWrapper : io.Writer
*cthWrapper : transcriptHash
A finishedHash calculates the hash of a set of handshake messages suitable
for including in a Finished message. In TLS 1.2, a full buffer is sadly required.clienthash.Hash Prior to TLS 1.2, an additional MD5 hash is required.prffunc(result, secret, label, seed []byte)serverhash.HashserverMD5hash.Hashversionuint16( finishedHash) Sum() []byte(*finishedHash) Write(msg []byte) (n int, err error) clientSum returns the contents of the verify_data member of a client's
Finished message. discardHandshakeBuffer is called when there is no more need to
buffer the entirety of the handshake messages. hashForClientCertificate returns the handshake messages so far, pre-hashed if
necessary, suitable for signing by a TLS client certificate. serverSum returns the contents of the verify_data member of a server's
Finished message.
*finishedHash : internal/bisect.Writer
*finishedHash : io.Writer
*finishedHash : transcriptHash
func newFinishedHash(version uint16, cipherSuite *cipherSuite) finishedHash
A halfConn represents one direction of the record layer
connection, either sending or receiving.Mutexsync.Mutex // cipher algorithm // first permanent error // current QUIC encryption levelmachash.HashMutex.semauint32Mutex.stateint32 // next encryption state // next MAC algorithm // to avoid allocs; interface method args escape // 64-bit sequence number // current TLS 1.3 traffic secret // protocol version Lock locks m.
If the lock is already in use, the calling goroutine
blocks until the mutex is available. TryLock tries to lock m and reports whether it succeeded.
Note that while correct uses of TryLock do exist, they are rare,
and use of TryLock is often a sign of a deeper problem
in a particular use of mutexes. Unlock unlocks m.
It is a run-time error if m is not locked on entry to Unlock.
A locked Mutex is not associated with a particular goroutine.
It is allowed for one goroutine to lock a Mutex and then
arrange for another goroutine to unlock it. changeCipherSpec changes the encryption and MAC states
to the ones previously passed to prepareCipherSpec. decrypt authenticates and decrypts the record if protection is active at
this stage. The returned plaintext might overlap with the input. encrypt encrypts payload, adding the appropriate nonce and/or MAC, and
appends it to record, which must already contain the record header. explicitNonceLen returns the number of bytes of explicit nonce or IV included
in each record. Explicit nonces are present only in CBC modes after TLS 1.0
and in certain AEAD modes in TLS 1.2. incSeq increments the sequence number.(*halfConn) lockSlow() prepareCipherSpec sets the encryption and MAC states
that a subsequent changeCipherSpec will use.(*halfConn) setErrorLocked(err error) error(*halfConn) setTrafficSecret(suite *cipherSuiteTLS13, level QUICEncryptionLevel, secret []byte)(*halfConn) unlockSlow(new int32)
*halfConn : sync.Locker
A listener implements a network listener (net.Listener) for TLS connections.Listenernet.Listenerconfig*Config Accept waits for and returns the next incoming TLS connection.
The returned connection is of type *Conn. Addr returns the listener's network address. Close closes the listener.
Any blocked Accept operations will be unblocked and return errors.
listener : io.Closer
*listener : net.Listener
lruSessionCache is a ClientSessionCache implementation that uses an LRU
caching strategy.Mutexsync.Mutexcapacityintmmap[string]*list.ElementMutex.semauint32Mutex.stateint32q*list.List Get returns the ClientSessionState value associated with a given key. It
returns (nil, false) if no value is found. Lock locks m.
If the lock is already in use, the calling goroutine
blocks until the mutex is available. Put adds the provided (sessionKey, cs) pair to the cache. If cs is nil, the entry
corresponding to sessionKey is removed from the cache instead. TryLock tries to lock m and reports whether it succeeded.
Note that while correct uses of TryLock do exist, they are rare,
and use of TryLock is often a sign of a deeper problem
in a particular use of mutexes. Unlock unlocks m.
It is a run-time error if m is not locked on entry to Unlock.
A locked Mutex is not associated with a particular goroutine.
It is allowed for one goroutine to lock a Mutex and then
arrange for another goroutine to unlock it.(*lruSessionCache) lockSlow()(*lruSessionCache) unlockSlow(new int32)
*lruSessionCache : ClientSessionCache
*lruSessionCache : sync.Locker
The marshalingFunction type is an adapter to allow the use of ordinary
functions as cryptobyte.MarshalingValue.( marshalingFunction) Marshal(b *cryptobyte.Builder) error
marshalingFunction : vendor/golang.org/x/crypto/cryptobyte.MarshalingValue
prefixNonceAEAD wraps an AEAD and prefixes a fixed portion of the nonce to
each call.aeadcipher.AEAD nonce contains the fixed part of the nonce in the first four bytes.(*prefixNonceAEAD) NonceSize() int(*prefixNonceAEAD) Open(out, nonce, ciphertext, additionalData []byte) ([]byte, error)(*prefixNonceAEAD) Overhead() int(*prefixNonceAEAD) Seal(out, nonce, plaintext, additionalData []byte) []byte(*prefixNonceAEAD) explicitNonceLen() int
*prefixNonceAEAD : crypto/cipher.AEAD
*prefixNonceAEAD : aead
TLS 1.3 PSK Identity. Can be a Session Ticket, or a reference to a saved
session. See RFC 8446, Section 4.2.11.label[]byteobfuscatedTicketAgeuint32
// handshake is waiting for data, closed when donecancelcontext.CancelFunc // handshake has been canceled eventArr is a statically allocated event array, large enough to handle
the usual maximum number of events resulting from a single call: transport
parameters, Initial data, Early read secret, Handshake write and read
secrets, Handshake data, Application write secret, Application data.events[]QUICEventnextEventint readbuf is shared between HandleData and the handshake goroutine.
HandshakeCryptoData passes ownership to the handshake goroutine by
reading from signalc, and reclaims ownership by reading from blockedc. // handshake data is available to be readstartedbool // to send to the peer
xorNonceAEAD wraps an AEAD by XORing in a fixed pattern to the nonce
before each call.aeadcipher.AEADnonceMask[12]byte(*xorNonceAEAD) NonceSize() int(*xorNonceAEAD) Open(out, nonce, ciphertext, additionalData []byte) ([]byte, error)(*xorNonceAEAD) Overhead() int(*xorNonceAEAD) Seal(out, nonce, plaintext, additionalData []byte) []byte(*xorNonceAEAD) explicitNonceLen() int
*xorNonceAEAD : crypto/cipher.AEAD
*xorNonceAEAD : aead
Package-Level Functions (total 98, in which 17 are exported)
CipherSuiteName returns the standard name for the passed cipher suite ID
(e.g. "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"), or a fallback representation
of the ID value if the cipher suite is not implemented by this package.
CipherSuites returns a list of cipher suites currently implemented by this
package, excluding those with security issues, which are returned by
InsecureCipherSuites.
The list is sorted by ID. Note that the default cipher suites selected by
this package might depend on logic that can't be captured by a static list,
and might not match those returned by this function.
Client returns a new TLS client side connection
using conn as the underlying transport.
The config cannot be nil: users must set either ServerName or
InsecureSkipVerify in the config.
Dial connects to the given network address using net.Dial
and then initiates a TLS handshake, returning the resulting
TLS connection.
Dial interprets a nil configuration as equivalent to
the zero configuration; see the documentation of Config
for the defaults.
DialWithDialer connects to the given network address using dialer.Dial and
then initiates a TLS handshake, returning the resulting TLS connection. Any
timeout or deadline given in the dialer apply to connection and TLS
handshake as a whole.
DialWithDialer interprets a nil configuration as equivalent to the zero
configuration; see the documentation of Config for the defaults.
DialWithDialer uses context.Background internally; to specify the context,
use Dialer.DialContext with NetDialer set to the desired dialer.
InsecureCipherSuites returns a list of cipher suites currently implemented by
this package and which have security issues.
Most applications should not use the cipher suites in this list, and should
only use those returned by CipherSuites.
Listen creates a TLS listener accepting connections on the
given network address using net.Listen.
The configuration config must be non-nil and must include
at least one certificate or else set GetCertificate.
LoadX509KeyPair reads and parses a public/private key pair from a pair
of files. The files must contain PEM encoded data. The certificate file
may contain intermediate certificates following the leaf certificate to
form a certificate chain. On successful return, Certificate.Leaf will
be nil because the parsed form of the certificate is not retained.
NewListener creates a Listener which accepts connections from an inner
Listener and wraps each connection with Server.
The configuration config must be non-nil and must include
at least one certificate or else set GetCertificate.
NewLRUClientSessionCache returns a ClientSessionCache with the given
capacity that uses an LRU strategy. If capacity is < 1, a default capacity
is used instead.
NewResumptionState returns a state value that can be returned by
[ClientSessionCache.Get] to resume a previous session.
state needs to be returned by [ParseSessionState], and the ticket and session
state must have been returned by [ClientSessionState.ResumptionState].
ParseSessionState parses a [SessionState] encoded by [SessionState.Bytes].
QUICClient returns a new TLS client side connection using QUICTransport as the
underlying transport. The config cannot be nil.
The config's MinVersion must be at least TLS 1.3.
QUICServer returns a new TLS server side connection using QUICTransport as the
underlying transport. The config cannot be nil.
The config's MinVersion must be at least TLS 1.3.
Server returns a new TLS server side connection
using conn as the underlying transport.
The configuration config must be non-nil and must include
at least one certificate or else set GetCertificate.
VersionName returns the name for the provided TLS version number
(e.g. "TLS 1.3"), or a fallback representation of the value if the
version is not implemented by this package.
X509KeyPair parses a public/private key pair from a pair of
PEM encoded data. On successful return, Certificate.Leaf will be nil because
the parsed form of the certificate is not retained.
addBytesWithLength appends a sequence of bytes to the cryptobyte.Builder. If
the length of the sequence is not the value specified, it produces an error.
addUint64 appends a big-endian, 64-bit value to the cryptobyte.Builder.
aesgcmPreferred returns whether the first known cipher in the preference list
is an AES-GCM cipher, implying the peer has hardware support for it.
certificateRequestInfoFromMsg generates a CertificateRequestInfo from a TLS
<= 1.2 CertificateRequest, making an effort to fill in missing information.
cloneHash uses the encoding.BinaryMarshaler and encoding.BinaryUnmarshaler
interfaces implemented by standard library hashes to clone the state of in
to a new instance of h. It returns nil if the operation fails.
ekmFromMasterSecret generates exported keying material as defined in RFC 5705.
extMasterFromPreMasterSecret generates the extended master secret from the
pre-master secret. See RFC 7627.
extractPadding returns, in constant time, the length of the padding to remove
from the end of payload. It also returns a byte which is equal to 255 if the
padding was valid and 0 otherwise. See RFC 2246, Section 6.2.3.2.
generateECDHEKey returns a PrivateKey that implements Diffie-Hellman
according to RFC 8446, Section 4.2.8.2.
hashForServerKeyExchange hashes the given slices and returns their digest
using the given hash function (for >= TLS 1.2) or using a default based on
the sigType (for earlier TLS versions). For Ed25519 signatures, which don't
do pre-hashing, it returns the concatenation of the slices.
hostnameInSNI converts name into an appropriate hostname for SNI.
Literal IP addresses and absolute FQDNs are not permitted as SNI values.
See RFC 6066, Section 3.
illegalClientHelloChange reports whether the two ClientHello messages are
different, with the exception of the changes allowed before and after a
HelloRetryRequest. See RFC 8446, Section 4.1.2.
keysFromMasterSecret generates the connection keys from the master
secret, given the lengths of the MAC key, cipher key and IV, as defined in
RFC 2246, Section 6.3.
legacyTypeAndHashFromPublicKey returns the fixed signature type and crypto.Hash for
a given public key used with TLS 1.0 and 1.1, before the introduction of
signature algorithm negotiation.
macSHA1 returns a SHA-1 based constant time MAC.
macSHA256 returns a SHA-256 based MAC. This is only supported in TLS 1.2 and
is currently only used in disabled-by-default cipher suites.
negotiateALPN picks a shared ALPN protocol that both sides support in server
preference order. If ALPN is not configured or the peer doesn't support it,
it returns "" and no error.
noExportedKeyingMaterial is used as a value of
ConnectionState.ekm when renegotiation is enabled and thus
we wish to fail all key-material export requests.
Attempt to parse the given private key DER block. OpenSSL 0.9.8 generates
PKCS #1 private keys by default, while OpenSSL 1.0.0 generates PKCS #8 keys.
OpenSSL ecparam generates SEC1 EC private keys for ECDSA. We try all three.
pHash implements the P_hash function, as defined in RFC 4346, Section 5.
prf10 implements the TLS 1.0 pseudo-random function, as defined in RFC 2246, Section 5.
prf12 implements the TLS 1.2 pseudo-random function, as defined in RFC 5246, Section 5.
selectCipherSuite returns the first TLS 1.0–1.2 cipher suite from ids which
is also in supportedIDs and passes the ok filter.
selectSignatureScheme picks a SignatureScheme from the peer's preference list
that works with the selected certificate. It's only called for protocol
versions that support signature algorithms, so TLS 1.2 and 1.3.
sha1Hash calculates a SHA1 hash over the given byte slices.
signatureSchemesForCertificate returns the list of supported SignatureSchemes
for a given certificate, based on the public key and the protocol version,
and optionally filtered by its explicit SupportedSignatureAlgorithms.
This function must be kept in sync with supportedSignatureAlgorithms.
FIPS filtering is applied in the caller, selectSignatureScheme.
signedMessage returns the pre-hashed (if necessary) message to be signed by
certificate keys in TLS 1.3. See RFC 8446, Section 4.4.3.
sliceForAppend extends the input slice by n bytes. head is the full extended
slice, while tail is the appended part. If the original slice has sufficient
capacity no allocation is performed.
Split a premaster secret in two as specified in RFC 4346, Section 5.
supportedVersionsFromMax returns a list of supported versions derived from a
legacy maximum version value. Note that only versions supported by this
library are returned. Any newer peer will use supportedVersions anyway.
supportsECDHE returns whether ECDHE key exchanges can be used with this
pre-TLS 1.3 client.
tls10MAC implements the TLS 1.0 MAC function. RFC 2246, Section 6.2.3.
transcriptMsg is a helper used to marshal and hash messages which typically
are not written to the wire, and as such aren't hashed during Conn.writeRecord.
typeAndHashFromSignatureScheme returns the corresponding signature type and
crypto.Hash for a given TLS SignatureScheme.
cipherSuitesPreferenceOrder is the order in which we'll select (on the
server) or advertise (on the client) TLS 1.0–1.2 cipher suites.
Cipher suites are filtered but not reordered based on the application and
peer's preferences, meaning we'll never select a suite lower in this list if
any higher one is available. This makes it more defensible to keep weaker
cipher suites enabled, especially on the server side where we get the last
word, since there are no known downgrade attacks on cipher suites selection.
The list is sorted by applying the following priority rules, stopping at the
first (most important) applicable one:
- Anything else comes before RC4
RC4 has practically exploitable biases. See https://www.rc4nomore.com.
- Anything else comes before CBC_SHA256
SHA-256 variants of the CBC ciphersuites don't implement any Lucky13
countermeasures. See http://www.isg.rhul.ac.uk/tls/Lucky13.html and
https://www.imperialviolet.org/2013/02/04/luckythirteen.html.
- Anything else comes before 3DES
3DES has 64-bit blocks, which makes it fundamentally susceptible to
birthday attacks. See https://sweet32.info.
- ECDHE comes before anything else
Once we got the broken stuff out of the way, the most important
property a cipher suite can have is forward secrecy. We don't
implement FFDHE, so that means ECDHE.
- AEADs come before CBC ciphers
Even with Lucky13 countermeasures, MAC-then-Encrypt CBC cipher suites
are fundamentally fragile, and suffered from an endless sequence of
padding oracle attacks. See https://eprint.iacr.org/2015/1129,
https://www.imperialviolet.org/2014/12/08/poodleagain.html, and
https://blog.cloudflare.com/yet-another-padding-oracle-in-openssl-cbc-ciphersuites/.
- AES comes before ChaCha20
When AES hardware is available, AES-128-GCM and AES-256-GCM are faster
than ChaCha20Poly1305.
When AES hardware is not available, AES-128-GCM is one or more of: much
slower, way more complex, and less safe (because not constant time)
than ChaCha20Poly1305.
We use this list if we think both peers have AES hardware, and
cipherSuitesPreferenceOrderNoAES otherwise.
- AES-128 comes before AES-256
The only potential advantages of AES-256 are better multi-target
margins, and hypothetical post-quantum properties. Neither apply to
TLS, and AES-256 is slower due to its four extra rounds (which don't
contribute to the advantages above).
- ECDSA comes before RSA
The relative order of ECDSA and RSA cipher suites doesn't matter,
as they depend on the certificate. Pick one to get a stable order.
defaultCipherSuitesTLS13 is also the preference order, since there are no
disabled by default TLS 1.3 cipher suites. The same AES vs ChaCha20 logic as
cipherSuitesPreferenceOrder applies.
defaultSupportedSignatureAlgorithms contains the signature and hash algorithms that
the code advertises as supported in a TLS 1.2+ ClientHello and in a TLS 1.2+
CertificateRequest. The two fields are merged to match with TLS 1.3.
Note that in TLS 1.2, the ECDSA algorithms are not constrained to P-256, etc.
deprecatedSessionTicketKey is set as the prefix of SessionTicketKey if it was
randomized for backwards compatibility but is not in use.
directSigning is a standard Hash value that signals that no pre-hashing
should be performed, and that the input should be signed directly. It is the
hash function associated with the Ed25519 signature scheme.
disabledCipherSuites are not used unless explicitly listed in
Config.CipherSuites. They MUST be at the end of cipherSuitesPreferenceOrder.
testingOnlyForceDowngradeCanary is set in tests to force the server side to
include downgrade canaries even if it's using its highers supported version.
NoClientCert indicates that no client certificate should be requested
during the handshake, and if any certificates are sent they will not
be verified.
QUICHandshakeDone indicates that the TLS handshake has completed.
QUICNoEvent indicates that there are no events available.
QUICRejectedEarlyData indicates that the server rejected 0-RTT data even
if we offered it. It's returned before QUICEncryptionLevelApplication
keys are returned.
QUICSetReadSecret and QUICSetWriteSecret provide the read and write
secrets for a given encryption level.
QUICEvent.Level, QUICEvent.Data, and QUICEvent.Suite are set.
Secrets for the Initial encryption level are derived from the initial
destination connection ID, and are not provided by the QUICConn.
QUICTransportParameters provides the peer's QUIC transport parameters.
QUICEvent.Data is set.
QUICTransportParametersRequired indicates that the caller must provide
QUIC transport parameters to send to the peer. The caller should set
the transport parameters with QUICConn.SetTransportParameters and call
QUICConn.NextEvent again.
If transport parameters are set before calling QUICConn.Start, the
connection will never generate a QUICTransportParametersRequired event.
QUICWriteData provides data to send to the peer in CRYPTO frames.
QUICEvent.Data is set.
RenegotiateFreelyAsClient allows a remote server to repeatedly
request renegotiation.
RenegotiateNever disables renegotiation.
RenegotiateOnceAsClient allows a remote server to request
renegotiation once per connection.
RequestClientCert indicates that a client certificate should be requested
during the handshake, but does not require that the client send any
certificates.
RequireAndVerifyClientCert indicates that a client certificate should be requested
during the handshake, and that at least one valid certificate is required
to be sent by the client.
RequireAnyClientCert indicates that a client certificate should be requested
during the handshake, and that at least one certificate is required to be
sent by the client, but that certificate is not required to be valid.
TLS 1.3 cipher suites.
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
Legacy names for the corresponding cipher suites with the correct _SHA256
suffix, retained for backward compatibility.
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
TLS_FALLBACK_SCSV isn't a standard cipher suite but an indicator
that the client is doing version fallback. See RFC 7507.
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
A list of cipher suite IDs that are, or have been, implemented by this
package.
See https://www.iana.org/assignments/tls-parameters/tls-parameters.xml
TLS 1.0 - 1.2 cipher suites.
VerifyClientCertIfGiven indicates that a client certificate should be requested
during the handshake, but does not require that the client sends a
certificate. If the client does send a certificate it is required to be
valid.
Deprecated: SSLv3 is cryptographically broken, and is no longer
supported by this package. See golang.org/issue/32716.
downgradeCanaryTLS12 or downgradeCanaryTLS11 is embedded in the server
random as a downgrade protection if the server would be capable of
negotiating a higher version. See RFC 8446, Section 4.1.3.
maxClientPSKIdentities is the number of client PSK identities the server will
attempt to validate. It will ignore the rest not to let cheap ClientHello
messages cause too much work in session ticket decryption attempts.
constmaxHandshake = 65536 // maximum handshake we support (protocol max is 16 MB)
Signature algorithms (for internal signaling use). Starting at 225 to avoid overlap with
TLS 1.2 codepoints (RFC 5246, Appendix A.4.1), with which these have nothing to do.
Signature algorithms (for internal signaling use). Starting at 225 to avoid overlap with
TLS 1.2 codepoints (RFC 5246, Appendix A.4.1), with which these have nothing to do.
Signature algorithms (for internal signaling use). Starting at 225 to avoid overlap with
TLS 1.2 codepoints (RFC 5246, Appendix A.4.1), with which these have nothing to do.
Signature algorithms (for internal signaling use). Starting at 225 to avoid overlap with
TLS 1.2 codepoints (RFC 5246, Appendix A.4.1), with which these have nothing to do.
TLS CertificateStatusType (RFC 3546)
suiteECDHE indicates that the cipher suite involves elliptic curve
Diffie-Hellman. This means that it should only be selected when the
client indicates that it supports ECC with a curve and point format
that we're happy with.
suiteECSign indicates that the cipher suite involves an ECDSA or
EdDSA signature and therefore may only be selected when the server's
certificate is ECDSA or EdDSA. If this is not set then the cipher suite
is RSA based.
suiteSHA384 indicates that the cipher suite uses SHA384 as the
handshake hash.
suiteTLS12 indicates that the cipher suite should only be advertised
and accepted when using TLS 1.2.
tcpMSSEstimate is a conservative estimate of the TCP maximum segment
size (MSS). A constant is used, rather than querying the kernel for
the actual MSS, to avoid complexity. The value here is the IPv6
minimum MTU (1280 bytes) minus the overhead of an IPv6 header (40
bytes) and a TCP header with timestamps (32 bytes).
ticketKeyLifetime is how long a ticket key remains valid and can be used to
resume a client connection.
ticketKeyRotation is how often the server should rotate the session ticket key
that is used for new tickets.
The pages are generated with Goldsv0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.
