A Certificate is a chain of one or more certificates, leaf first.
Certificate[][]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.
OCSPStaple contains an optional OCSP response which will be served
to clients that request it.
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.
SignedCertificateTimestamps contains an optional list of Signed
Certificate Timestamps which will be served to clients that request it.
SupportedSignatureAlgorithms is an optional list restricting what
signature algorithms the PrivateKey can be used for.
func LoadX509KeyPair(certFile, keyFile string) (Certificate, error)
func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (Certificate, error)
func (*CertificateRequestInfo).SupportsCertificate(c *Certificate) error
func (*ClientHelloInfo).SupportsCertificate(c *Certificate) 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.
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.
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.
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.
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.
func NewLRUClientSessionCache(capacity int) ClientSessionCache
ClientSessionState contains the state needed by clients to resume TLS
sessions.
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 supported cipher suites for TLS versions up to
TLS 1.2. If CipherSuites is nil, a default list of secure cipher suites
is used, with a preference order based on hardware performance. The
default cipher suites might change over Go versions. Note that TLS 1.3
ciphersuites are not configurable.
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.
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.
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.
If zero, the maximum version supported by this package is used,
which is currently TLS 1.3.
MinVersion contains the minimum TLS version that is acceptable.
If zero, TLS 1.0 is currently taken as the minimum.
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.
PreferServerCipherSuites controls whether the server selects the
client's most preferred ciphersuite, or the server's most preferred
ciphersuite. If true then the server's preference, as expressed in
the order of elements in CipherSuites, is used.
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.
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
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 by
setting InsecureSkipVerify, or (for a server) when ClientAuth is
RequestClientCert or RequireAnyClientCert, then this callback will
be considered but the verifiedChains argument will always be nil.
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.
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.
func (*Config).Clone() *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 net/smtp.(*Client).StartTLS(config *Config) error
A Conn represents a secured connection.
It implements the net.Conn interface.
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
the Dialer's DialContext method.
LocalAddr returns the local network address.
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.
*T : io.Closer
*T : io.ReadCloser
*T : io.Reader
*T : io.ReadWriteCloser
*T : io.ReadWriter
*T : io.WriteCloser
*T : io.Writer
*T : net.Conn
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
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.
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 all
resumed connections.
Deprecated: there are conditions in which this value 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.
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.
Version is the TLS version used by the connection (e.g. VersionTLS12).
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.
func (*Conn).ConnectionState() ConnectionState
func net/smtp.(*Client).TLSConnectionState() (state ConnectionState, ok bool)
CurveID is the type of a TLS identifier for an elliptic curve. See
https://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-8.
In TLS 1.3, this type is called NamedGroup, but at this time this library
only supports Elliptic Curve based groups. See RFC 8446, Section 4.2.7.
( T) String() string
T : expvar.Var
T : fmt.Stringer
const CurveP256
const CurveP384
const CurveP521
const X25519
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.
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.
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.
( T) Error() string
T : error
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
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.
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.
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.
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.
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.
NoClientCert indicates that no client certificate should be requested
during the handshake, and if any certificates are sent they will not
be verified.
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.
The pages are generated with Goldsv0.2.5. (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.
