cfssl: Index | Examples | Files

package tls

import ""

Package tls partially implements TLS 1.2, as specified in RFC 5246.



Package Files

alert.go cfsslscan_common.go cfsslscan_handshake.go cipher_suites.go common.go conn.go handshake_client.go handshake_messages.go handshake_server.go key_agreement.go prf.go ticket.go tls.go


const (
    HashNone hashAlgID = iota
const (
    SigAnon sigAlgID = iota

Signature algorithms for TLS 1.2 (See RFC 5246, section A.4.1)

const (
    TLS_RSA_WITH_RC4_128_SHA                uint16 = 0x0005
    TLS_RSA_WITH_3DES_EDE_CBC_SHA           uint16 = 0x000a
    TLS_RSA_WITH_AES_128_CBC_SHA            uint16 = 0x002f
    TLS_RSA_WITH_AES_256_CBC_SHA            uint16 = 0x0035
    TLS_RSA_WITH_AES_128_GCM_SHA256         uint16 = 0x009c
    TLS_RSA_WITH_AES_256_GCM_SHA384         uint16 = 0x009d
    TLS_ECDHE_ECDSA_WITH_RC4_128_SHA        uint16 = 0xc007
    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA    uint16 = 0xc009
    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA    uint16 = 0xc00a
    TLS_ECDHE_RSA_WITH_RC4_128_SHA          uint16 = 0xc011
    TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA     uint16 = 0xc012
    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA      uint16 = 0xc013
    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA      uint16 = 0xc014
    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256   uint16 = 0xc02f
    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xc02b
    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384   uint16 = 0xc030
    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xc02c

    // TLS_FALLBACK_SCSV isn't a standard cipher suite but an indicator
    // that the client is doing version fallback. See
    TLS_FALLBACK_SCSV uint16 = 0x5600

A list of the possible cipher suite ids. Taken from

const (
    VersionSSL30 = 0x0300
    VersionTLS10 = 0x0301
    VersionTLS11 = 0x0302
    VersionTLS12 = 0x0303


var AllSignatureAndHashAlgorithms []SignatureAndHash

AllSignatureAndHashAlgorithms contains all possible signature and hash algorithm pairs that the can be advertised in a TLS 1.2 ClientHello.

var CipherSuites = map[uint16]CipherSuite{ /* 321 elements not displayed */


CipherSuites contains all values in the TLS Cipher Suite Registry

var Curves = map[CurveID]string{
    0:     "Unassigned",
    1:     "sect163k1",
    2:     "sect163r1",
    3:     "sect163r2",
    4:     "sect193r1",
    5:     "sect193r2",
    6:     "sect233k1",
    7:     "sect233r1",
    8:     "sect239k1",
    9:     "sect283k1",
    10:    "sect283r1",
    11:    "sect409k1",
    12:    "sect409r1",
    13:    "sect571k1",
    14:    "sect571r1",
    15:    "secp160k1",
    16:    "secp160r1",
    17:    "secp160r2",
    18:    "secp192k1",
    19:    "secp192r1",
    20:    "secp224k1",
    21:    "secp224r1",
    22:    "secp256k1",
    23:    "secp256r1",
    24:    "secp384r1",
    25:    "secp521r1",
    26:    "brainpoolP256r1",
    27:    "brainpoolP384r1",
    28:    "brainpoolP512r1",
    65281: "arbitrary_explicit_prime_curves",
    65282: "arbitrary_explicit_char2_curves",
var Versions = map[uint16]string{
    VersionSSL30: "SSL 3.0",
    VersionTLS10: "TLS 1.0",
    VersionTLS11: "TLS 1.1",
    VersionTLS12: "TLS 1.2",

TLSVersions is a list of the current SSL/TLS Versions implemented by Go

func Listen Uses

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

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.

func NewListener Uses

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

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.

type Certificate Uses

type Certificate struct {
    Certificate [][]byte
    // PrivateKey contains the private key corresponding to the public key
    // in Leaf. For a server, this must implement crypto.Signer and/or
    // crypto.Decrypter, with an RSA or ECDSA PublicKey. For a client
    // (performing client authentication), this must be a crypto.Signer
    // with an RSA or ECDSA PublicKey.
    PrivateKey crypto.PrivateKey
    // OCSPStaple contains an optional OCSP response which will be served
    // to clients that request it.
    OCSPStaple []byte
    // SignedCertificateTimestamps contains an optional list of Signed
    // Certificate Timestamps which will be served to clients that request it.
    SignedCertificateTimestamps [][]byte
    // Leaf is the parsed form of the leaf certificate, which may be
    // initialized using x509.ParseCertificate to reduce per-handshake
    // processing for TLS clients doing client authentication. If nil, the
    // leaf certificate will be parsed as needed.
    Leaf *x509.Certificate

A Certificate is a chain of one or more certificates, leaf first.

func LoadX509KeyPair Uses

func LoadX509KeyPair(certFile, keyFile string) (Certificate, error)

LoadX509KeyPair reads and parses a public/private key pair from a pair of files. The files must contain PEM encoded data. On successful return, Certificate.Leaf will be nil because the parsed form of the certificate is not retained.

func X509KeyPair Uses

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

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.

type CipherSuite Uses

type CipherSuite struct {
    Name, ShortName string
    // ForwardSecret cipher suites negotiate ephemeral keys, allowing forward secrecy.
    ForwardSecret bool
    EllipticCurve bool

CipherSuite describes an individual cipher suite, with long and short names and security properties.

func (CipherSuite) String Uses

func (c CipherSuite) String() string

Returns the (short) name of the cipher suite.

type ClientAuthType Uses

type ClientAuthType int

ClientAuthType declares the policy the server will follow for TLS Client Authentication.

const (
    NoClientCert ClientAuthType = iota

type ClientHelloInfo Uses

type ClientHelloInfo struct {
    // CipherSuites lists the CipherSuites supported by the client (e.g.
    // TLS_RSA_WITH_RC4_128_SHA).
    CipherSuites []uint16

    // ServerName indicates the name of the server requested by the client
    // in order to support virtual hosting. ServerName is only set if the
    // client is using SNI (see
    ServerName string

    // SupportedCurves lists the elliptic curves supported by the client.
    // SupportedCurves is set only if the Supported Elliptic Curves
    // Extension is being used (see
    SupportedCurves []CurveID

    // SupportedPoints lists the point formats supported by the client.
    // SupportedPoints is set only if the Supported Point Formats Extension
    // is being used (see
    SupportedPoints []uint8

ClientHelloInfo contains information from a ClientHello message in order to guide certificate selection in the GetCertificate callback.

type ClientSessionCache Uses

type ClientSessionCache interface {
    // Get searches for a ClientSessionState associated with the given key.
    // On return, ok is true if one was found.
    Get(sessionKey string) (session *ClientSessionState, ok bool)

    // Put adds the ClientSessionState to the cache with the given key.
    Put(sessionKey string, cs *ClientSessionState)

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.

func NewLRUClientSessionCache Uses

func NewLRUClientSessionCache(capacity int) ClientSessionCache

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

type ClientSessionState Uses

type ClientSessionState struct {
    // contains filtered or unexported fields

ClientSessionState contains the state needed by clients to resume TLS sessions.

type Config Uses

type Config struct {
    // Rand provides the source of entropy for nonces and RSA blinding.
    // If Rand is nil, TLS uses the cryptographic random reader in package
    // crypto/rand.
    // The Reader must be safe for use by multiple goroutines.
    Rand io.Reader

    // Time returns the current time as the number of seconds since the epoch.
    // If Time is nil, TLS uses time.Now.
    Time func() time.Time

    // Certificates contains one or more certificate chains
    // to present to the other side of the connection.
    // Server configurations must include at least one certificate
    // or else set GetCertificate.
    Certificates []Certificate

    // NameToCertificate maps from a certificate name to an element of
    // Certificates. Note that a certificate name can be of the form
    // '*' and so doesn't have to be a domain name as such.
    // See Config.BuildNameToCertificate
    // The nil value causes the first element of Certificates to be used
    // for all connections.
    NameToCertificate map[string]*Certificate

    // GetCertificate returns a Certificate based on the given
    // ClientHelloInfo. It will only be called if the client supplies SNI
    // information or if Certificates is empty.
    // If GetCertificate is nil or returns nil, then the certificate is
    // retrieved from NameToCertificate. If NameToCertificate is nil, the
    // first element of Certificates will be used.
    GetCertificate func(clientHello *ClientHelloInfo) (*Certificate, error)

    // RootCAs defines the set of root certificate authorities
    // that clients use when verifying server certificates.
    // If RootCAs is nil, TLS uses the host's root CA set.
    RootCAs *x509.CertPool

    // NextProtos is a list of supported, application level protocols.
    NextProtos []string

    // ServerName is used to verify the hostname on the returned
    // certificates unless InsecureSkipVerify is given. It is also included
    // in the client's handshake to support virtual hosting unless it is
    // an IP address.
    ServerName string

    // ClientAuth determines the server's policy for
    // TLS Client Authentication. The default is NoClientCert.
    ClientAuth ClientAuthType

    // ClientCAs defines the set of root certificate authorities
    // that servers use if required to verify a client certificate
    // by the policy in ClientAuth.
    ClientCAs *x509.CertPool

    // InsecureSkipVerify controls whether a client verifies the
    // server's certificate chain and host name.
    // If InsecureSkipVerify is true, TLS accepts any certificate
    // presented by the server and any host name in that certificate.
    // In this mode, TLS is susceptible to man-in-the-middle attacks.
    // This should be used only for testing.
    InsecureSkipVerify bool

    // CipherSuites is a list of supported cipher suites. If CipherSuites
    // is nil, TLS uses a list of suites supported by the implementation.
    CipherSuites []uint16

    // 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.
    PreferServerCipherSuites bool

    // SessionTicketsDisabled may be set to true to disable session ticket
    // (resumption) support.
    SessionTicketsDisabled bool

    // SessionTicketKey is used by TLS servers to provide session
    // resumption. See RFC 5077. If zero, it will be filled with
    // random data before the first server handshake.
    // If multiple servers are terminating connections for the same host
    // they should all have the same SessionTicketKey. If the
    // SessionTicketKey leaks, previously recorded and future TLS
    // connections using that key are compromised.
    SessionTicketKey [32]byte

    // SessionCache is a cache of ClientSessionState entries for TLS session
    // resumption.
    ClientSessionCache ClientSessionCache

    // MinVersion contains the minimum SSL/TLS version that is acceptable.
    // If zero, then TLS 1.0 is taken as the minimum.
    MinVersion uint16

    // MaxVersion contains the maximum SSL/TLS version that is acceptable.
    // If zero, then the maximum version supported by this package is used,
    // which is currently TLS 1.2.
    MaxVersion uint16

    // CurvePreferences contains the elliptic curves that will be used in
    // an ECDHE handshake, in preference order. If empty, the default will
    // be used.
    CurvePreferences []CurveID
    // contains filtered or unexported fields

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.

func (*Config) BuildNameToCertificate Uses

func (c *Config) BuildNameToCertificate()

BuildNameToCertificate parses c.Certificates and builds c.NameToCertificate from the CommonName and SubjectAlternateName fields of each of the leaf certificates.

func (*Config) SetSessionTicketKeys Uses

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

SetSessionTicketKeys updates the session ticket keys for a server. The first key will be used when creating new tickets, while all keys can 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.

type Conn Uses

type Conn struct {
    // contains filtered or unexported fields

A Conn represents a secured connection. It implements the net.Conn interface.

func Client Uses

func Client(conn net.Conn, config *Config) *Conn

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.

func Dial Uses

func Dial(network, addr string, config *Config) (*Conn, error)

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.


// Connecting with a custom root-certificate set.

const rootPEM = `

// 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", "", &tls.Config{
    RootCAs: roots,
if err != nil {
    panic("failed to connect: " + err.Error())

func DialWithDialer Uses

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

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.

func Server Uses

func Server(conn net.Conn, config *Config) *Conn

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.

func (*Conn) Close Uses

func (c *Conn) Close() error

Close closes the connection.

func (*Conn) ConnectionState Uses

func (c *Conn) ConnectionState() ConnectionState

ConnectionState returns basic TLS details about the connection.

func (*Conn) Handshake Uses

func (c *Conn) Handshake() error

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.

func (*Conn) LocalAddr Uses

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

LocalAddr returns the local network address.

func (*Conn) OCSPResponse Uses

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

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

func (*Conn) Read Uses

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

Read can be made to time out and return a net.Error with Timeout() == true after a fixed time limit; see SetDeadline and SetReadDeadline.

func (*Conn) RemoteAddr Uses

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

RemoteAddr returns the remote network address.

func (*Conn) SayHello Uses

func (c *Conn) SayHello(newSigAls []SignatureAndHash) (cipherID, curveType uint16, curveID CurveID, version uint16, certs [][]byte, err error)

SayHello constructs a simple Client Hello to a server, parses its serverHelloMsg response and returns the negotiated ciphersuite ID, and, if an EC cipher suite, the curve ID

func (*Conn) SetDeadline Uses

func (c *Conn) SetDeadline(t time.Time) error

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.

func (*Conn) SetReadDeadline Uses

func (c *Conn) SetReadDeadline(t time.Time) error

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

func (*Conn) SetWriteDeadline Uses

func (c *Conn) SetWriteDeadline(t time.Time) error

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.

func (*Conn) VerifyHostname Uses

func (c *Conn) VerifyHostname(host string) 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.

func (*Conn) Write Uses

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

Write writes data to the connection.

type ConnectionState Uses

type ConnectionState struct {
    Version                     uint16                // TLS version used by the connection (e.g. VersionTLS12)
    HandshakeComplete           bool                  // TLS handshake is complete
    DidResume                   bool                  // connection resumes a previous TLS connection
    CipherSuite                 uint16                // cipher suite in use (TLS_RSA_WITH_RC4_128_SHA, ...)
    NegotiatedProtocol          string                // negotiated next protocol (from Config.NextProtos)
    NegotiatedProtocolIsMutual  bool                  // negotiated protocol was advertised by server
    ServerName                  string                // server name requested by client, if any (server side only)
    PeerCertificates            []*x509.Certificate   // certificate chain presented by remote peer
    VerifiedChains              [][]*x509.Certificate // verified chains built from PeerCertificates
    SignedCertificateTimestamps [][]byte              // SCTs from the server, if any
    OCSPResponse                []byte                // stapled OCSP response from server, if any

    // TLSUnique contains the "tls-unique" channel binding value (see RFC
    // 5929, section 3). For resumed sessions this value will be nil
    // because resumption does not include enough context (see
    // This will change in
    // future versions of Go once the TLS master-secret fix has been
    // standardized and implemented.
    TLSUnique []byte

ConnectionState records basic TLS details about the connection.

type CurveID Uses

type CurveID uint16

CurveID is the type of a TLS identifier for an elliptic curve. See

const (
    CurveP256 CurveID = 23
    CurveP384 CurveID = 24
    CurveP521 CurveID = 25

type RecordHeaderError Uses

type RecordHeaderError struct {
    // Msg contains a human readable string that describes the error.
    Msg string
    // RecordHeader contains the five bytes of TLS record header that
    // triggered the error.
    RecordHeader [5]byte

RecordHeaderError results when a TLS record header is invalid.

func (RecordHeaderError) Error Uses

func (e RecordHeaderError) Error() string

type SignatureAndHash Uses

type SignatureAndHash struct {
    // contains filtered or unexported fields

SignatureAndHash mirrors the TLS 1.2, SignatureAndHashAlgorithm struct. See RFC 5246, section A.4.1.

func (SignatureAndHash) MarshalJSON Uses

func (sigAlg SignatureAndHash) MarshalJSON() ([]byte, error)

func (SignatureAndHash) String Uses

func (sigAlg SignatureAndHash) String() string


The crypto/tls package does not implement countermeasures against Lucky13 attacks on CBC-mode encryption. See and

Package tls imports 32 packages (graph) and is imported by 5 packages. Updated 2018-07-28. Refresh now. Tools for package owners.