Documentation ¶
Overview ¶
Package tls partially implements TLS 1.2, as specified in RFC 5246, and TLS 1.3, as specified in RFC 8446.
Index ¶
- Constants
- func CipherSuiteName(id uint16) string
- func ContainsObfuscatedSessionTicketCipherSuite(cipherSuites []uint16) bool
- func InitSessionTicketKeys(conf *Config)
- func Listen(network, laddr string, config *ExtendedTLSConfig) (net.Listener, error)
- func NewListener(inner net.Listener, config *ExtendedTLSConfig) net.Listener
- func ParseSessionState(data []byte) (*sessionState, error)
- func ReadClientHelloRandom(data []byte) ([]byte, error)
- func VersionName(version uint16) string
- type AlertError
- type Certificate
- type CertificateRequestInfo
- type CertificateVerificationError
- type CipherSuite
- type ClientAuthType
- type ClientHelloInfo
- type ClientSessionCache
- type ClientSessionState
- type Config
- type Conn
- func (c *Conn) Close() error
- func (c *Conn) CloseWrite() error
- func (c *Conn) ConnectionState() ConnectionState
- func (c *Conn) Handshake() error
- func (c *Conn) HandshakeContext(ctx context.Context) error
- func (c *Conn) LocalAddr() net.Addr
- func (c *Conn) NetConn() net.Conn
- func (c *Conn) OCSPResponse() []byte
- func (c *Conn) Read(b []byte) (int, error)
- func (c *Conn) RemoteAddr() net.Addr
- func (c *Conn) SetDeadline(t time.Time) error
- func (c *Conn) SetReadDeadline(t time.Time) error
- func (c *Conn) SetWriteDeadline(t time.Time) error
- func (c *Conn) VerifyHostname(host string) error
- func (c *Conn) Write(b []byte) (int, error)
- type ConnectionState
- type CurveID
- type Dialer
- type ExtendedTLSConfig
- type ExtraConfig
- type ObfuscatedClientSessionState
- type QUICConfig
- type QUICConn
- func (q *QUICConn) Close() error
- func (q *QUICConn) ConnectionState() ConnectionState
- func (q *QUICConn) HandleData(level QUICEncryptionLevel, data []byte) error
- func (q *QUICConn) NextEvent() QUICEvent
- func (q *QUICConn) SendSessionTicket(opts QUICSessionTicketOptions) error
- func (q *QUICConn) SetTransportParameters(params []byte)
- func (q *QUICConn) Start(ctx context.Context) error
- type QUICEncryptionLevel
- type QUICEvent
- type QUICEventKind
- type QUICSessionTicketOptions
- type RecordHeaderError
- type RenegotiationSupport
- type SessionState
- type SignatureScheme
- Bugs
Examples ¶
Constants ¶
const ( // TLS 1.0 - 1.2 cipher suites. 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_CBC_SHA256 uint16 = 0x003c 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_ECDSA_WITH_AES_128_CBC_SHA256 uint16 = 0xc023 TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0xc027 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_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xcca8 TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xcca9 // TLS 1.3 cipher suites. TLS_AES_128_GCM_SHA256 uint16 = 0x1301 TLS_AES_256_GCM_SHA384 uint16 = 0x1302 TLS_CHACHA20_POLY1305_SHA256 uint16 = 0x1303 // TLS_FALLBACK_SCSV isn't a standard cipher suite but an indicator // that the client is doing version fallback. See RFC 7507. TLS_FALLBACK_SCSV uint16 = 0x5600 // Legacy names for the corresponding cipher suites with the correct _SHA256 // suffix, retained for backward compatibility. TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 = TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 = TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 )
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
const ( VersionTLS10 = 0x0301 VersionTLS11 = 0x0302 VersionTLS12 = 0x0303 VersionTLS13 = 0x0304 // Deprecated: SSLv3 is cryptographically broken, and is no longer // supported by this package. See golang.org/issue/32716. VersionSSL30 = 0x0300 )
const ( NoClientCert = tls.NoClientCert RequestClientCert = tls.RequestClientCert RequireAnyClientCert = tls.RequireAnyClientCert VerifyClientCertIfGiven = tls.VerifyClientCertIfGiven RequireAndVerifyClientCert = tls.RequireAndVerifyClientCert )
const ( // RenegotiateNever disables renegotiation. RenegotiateNever = tls.RenegotiateNever // RenegotiateOnceAsClient allows a remote server to request // renegotiation once per connection. RenegotiateOnceAsClient = tls.RenegotiateOnceAsClient // RenegotiateFreelyAsClient allows a remote server to repeatedly // request renegotiation. RenegotiateFreelyAsClient = tls.RenegotiateFreelyAsClient )
const ( QUICEncryptionLevelInitial = QUICEncryptionLevel(iota) QUICEncryptionLevelEarly QUICEncryptionLevelHandshake QUICEncryptionLevelApplication )
Variables ¶
This section is empty.
Functions ¶
func CipherSuiteName ¶
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.
func InitSessionTicketKeys ¶
func InitSessionTicketKeys(conf *Config)
InitSessionTicketKeys triggers the initialization of session ticket keys.
func Listen ¶
func Listen(network, laddr string, config *ExtendedTLSConfig) (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 ¶
func NewListener(inner net.Listener, config *ExtendedTLSConfig) 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.
func ParseSessionState ¶
ParseSessionState parses a SessionState encoded by [SessionState.Bytes].
func VersionName ¶
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.
Types ¶
type AlertError ¶
type AlertError uint8
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.
func (AlertError) Error ¶
func (e AlertError) Error() string
type Certificate ¶
type Certificate = tls.Certificate
func LoadX509KeyPair ¶
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. 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.
Example ¶
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 }
Output:
func X509KeyPair ¶
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.
Example ¶
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 }
Output:
Example (HttpServer) ¶
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("", "")) }
Output:
type CertificateRequestInfo ¶
type CertificateRequestInfo = tls.CertificateRequestInfo
CertificateRequestInfo contains information from a server's CertificateRequest message, which is used to demand a certificate and proof of control from a client.
type CertificateVerificationError ¶
type CertificateVerificationError = tls.CertificateVerificationError
CertificateVerificationError is returned when certificate verification fails during the handshake.
type CipherSuite ¶
type CipherSuite struct { ID uint16 Name string // Supported versions is the list of TLS protocol versions that can // negotiate this cipher suite. SupportedVersions []uint16 // Insecure is true if the cipher suite has known security issues // due to its primitives, design, or implementation. Insecure bool }
CipherSuite is a TLS cipher suite. Note that most functions in this package accept and expose cipher suite IDs instead of this type.
func CipherSuites ¶
func CipherSuites() []*CipherSuite
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.
func InsecureCipherSuites ¶
func InsecureCipherSuites() []*CipherSuite
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.
type ClientHelloInfo ¶
type ClientHelloInfo = tls.ClientHelloInfo
type ClientSessionCache ¶
type ClientSessionCache = tls.ClientSessionCache
func NewLRUClientSessionCache ¶
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 ¶
type ClientSessionState = tls.ClientSessionState
func NewResumptionState ¶
func NewResumptionState(ticket []byte, state *sessionState) (*ClientSessionState, error)
NewResumptionState returns a state value that can be returned by [ClientSessionCache.Get] to resume a previous session.
state needs to be returned by ParseSessionState, and the ticket and session state must have been returned by [ClientSessionState.ResumptionState].
type Config ¶
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.
Example (KeyLogWriter) ¶
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. }
Output:
Example (VerifyConnection) ¶
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. }
Output:
type Conn ¶
type Conn struct {
// contains filtered or unexported fields
}
A Conn represents a secured connection. It implements the net.Conn interface.
func Client ¶
func Client(conn net.Conn, config *ExtendedTLSConfig) *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 ¶
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.
Example ¶
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() }
Output:
func DialWithDialer ¶
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.
func Server ¶
func Server(conn net.Conn, config *ExtendedTLSConfig) *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) CloseWrite ¶
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.
func (*Conn) ConnectionState ¶
func (c *Conn) ConnectionState() ConnectionState
ConnectionState returns basic TLS details about the connection.
func (*Conn) Handshake ¶
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).
func (*Conn) HandshakeContext ¶
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.
func (*Conn) NetConn ¶
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.
func (*Conn) OCSPResponse ¶
OCSPResponse returns the stapled OCSP response from the TLS server, if any. (Only valid for client connections.)
func (*Conn) Read ¶
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.
func (*Conn) RemoteAddr ¶
RemoteAddr returns the remote network address.
func (*Conn) SetDeadline ¶
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 ¶
SetReadDeadline sets the read deadline on the underlying connection. A zero value for t means Read will not time out.
func (*Conn) SetWriteDeadline ¶
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 ¶
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.
type ConnectionState ¶
type ConnectionState = tls.ConnectionState
ConnectionState records basic TLS details about the connection.
type Dialer ¶
type Dialer struct { // NetDialer is the optional dialer to use for the TLS connections' // underlying TCP connections. // A nil NetDialer is equivalent to the net.Dialer zero value. NetDialer *net.Dialer // Config is the TLS configuration to use for new connections. // A nil configuration is equivalent to the zero // configuration; see the documentation of Config for the // defaults. Config *Config }
Dialer dials TLS connections given a configuration and a Dialer for the underlying connection.
func (*Dialer) Dial ¶
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.
func (*Dialer) 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.
type ExtendedTLSConfig ¶
type ExtendedTLSConfig struct { TLSConfig *Config ExtraConfig *ExtraConfig }
[Psiphon] ExtendedTLSConfig wraps crypto/tls.Config and Psiphon-specific configurations.
type ExtraConfig ¶
type ExtraConfig struct { // ClientHelloPRNG is used for Client Hello randomization and replay. ClientHelloPRNG *prng.PRNG // GetClientHelloRandom is used to supply a specific value in the TLS // Client Hello random field. This is used to send an anti-probing // message, indistinguishable from random, that proves knowlegde of a // shared secret key. GetClientHelloRandom func() ([]byte, error) // UseObfuscatedSessionTickets should be set when using obfuscated session // tickets. This setting ensures that checkForResumption operates in a way // that is compatible with the obfuscated session ticket scheme. // // This flag doesn't fully configure obfuscated session tickets. // SessionTicketKey and SetSessionTicketKeys must also be intialized. See the // setup in psiphon/server.MeekServer.makeMeekTLSConfig. // // See the comment for NewObfuscatedClientSessionState for more details on // obfuscated session tickets. UseObfuscatedSessionTickets bool // PassthroughAddress, when not blank, enables passthrough mode. It is a // network address, host and port, to which client traffic is relayed when // the client fails anti-probing tests. // // The PassthroughAddress is expected to be a TCP endpoint. Passthrough is // triggered when a ClientHello random field doesn't have a valid value, as // determined by PassthroughKey. PassthroughAddress string // PassthroughVerifyMessage must be set when passthrough mode is enabled. The // function must return true for valid passthrough messages and false // otherwise. PassthroughVerifyMessage func([]byte) bool // PassthroughHistoryAddNew must be set when passthough mode is enabled. The // function should check that a ClientHello random value has not been // previously observed, returning true only for a newly observed value. Any // logging is the callback's responsibility. PassthroughHistoryAddNew func( clientIP string, clientRandom []byte) bool // PassthroughLogInvalidMessage must be set when passthough mode is enabled. // The function should log an invalid ClientHello random value event. PassthroughLogInvalidMessage func(clientIP string) }
[Psiphon]
type ObfuscatedClientSessionState ¶
type ObfuscatedClientSessionState struct { SessionTicket []uint8 Vers uint16 CipherSuite uint16 MasterSecret []byte ServerCertificates []*x509.Certificate VerifiedChains [][]*x509.Certificate UseEMS bool }
[Psiphon]
func NewObfuscatedClientSessionState ¶
func NewObfuscatedClientSessionState(sharedSecret [32]byte) (*ObfuscatedClientSessionState, error)
[Psiphon] NewObfuscatedClientSessionState produces obfuscated session tickets.
Obfuscated Session Tickets ¶
Obfuscated session tickets is a network traffic obfuscation protocol that appears to be valid TLS using session tickets. The client actually generates the session ticket and encrypts it with a shared secret, enabling a TLS session that entirely skips the most fingerprintable aspects of TLS. The scheme is described here: https://lists.torproject.org/pipermail/tor-dev/2016-September/011354.html
Circumvention notes:
- TLS session ticket implementations are widespread: https://istlsfastyet.com/#cdn-paas.
- An adversary cannot easily block session ticket capability, as this requires a downgrade attack against TLS.
- Anti-probing defence is provided, as the adversary must use the correct obfuscation shared secret to form valid obfuscation session ticket; otherwise server offers standard session tickets.
- Limitation: an adversary with the obfuscation shared secret can decrypt the session ticket and observe the plaintext traffic. It's assumed that the adversary will not learn the obfuscated shared secret without also learning the address of the TLS server and blocking it anyway; it's also assumed that the TLS payload is not plaintext but is protected with some other security layer (e.g., SSH).
Implementation notes:
- The TLS ClientHello includes an SNI field, even when using session tickets, so the client should populate the ServerName.
- Server should set its SetSessionTicketKeys with first a standard key, followed by the obfuscation shared secret.
- Since the client creates the session ticket, it selects parameters that were not negotiated with the server, such as the cipher suite. It's implicitly assumed that the server can support the selected parameters.
- Obfuscated session tickets are not supported for TLS 1.3 _clients_, which use a distinct scheme. Obfuscated session ticket support in this package is intended to support TLS 1.2 clients.
type QUICConfig ¶
type QUICConfig struct { TLSConfig *Config // [Psiphon] ExtraConfig *ExtraConfig }
A QUICConfig configures a QUICConn.
type QUICConn ¶
type QUICConn struct {
// contains filtered or unexported fields
}
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.
func QUICClient ¶
func QUICClient(config *QUICConfig) *QUICConn
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.
func QUICServer ¶
func QUICServer(config *QUICConfig) *QUICConn
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.
func (*QUICConn) ConnectionState ¶
func (q *QUICConn) ConnectionState() ConnectionState
ConnectionState returns basic TLS details about the connection.
func (*QUICConn) HandleData ¶
func (q *QUICConn) HandleData(level QUICEncryptionLevel, data []byte) error
HandleData handles handshake bytes received from the peer. It may produce connection events, which may be read with NextEvent.
func (*QUICConn) NextEvent ¶
NextEvent returns the next event occurring on the connection. It returns an event with a Kind of QUICNoEvent when no events are available.
func (*QUICConn) SendSessionTicket ¶
func (q *QUICConn) SendSessionTicket(opts QUICSessionTicketOptions) error
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.
func (*QUICConn) SetTransportParameters ¶
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.
type QUICEncryptionLevel ¶
type QUICEncryptionLevel int
QUICEncryptionLevel represents a QUIC encryption level used to transmit handshake messages.
func (QUICEncryptionLevel) String ¶
func (l QUICEncryptionLevel) String() string
type QUICEvent ¶
type QUICEvent struct { Kind QUICEventKind // Set for QUICSetReadSecret, QUICSetWriteSecret, and QUICWriteData. Level QUICEncryptionLevel // Set for QUICTransportParameters, QUICSetReadSecret, QUICSetWriteSecret, and QUICWriteData. // The contents are owned by crypto/tls, and are valid until the next NextEvent call. Data []byte // Set for QUICSetReadSecret and QUICSetWriteSecret. Suite uint16 }
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.
type QUICEventKind ¶
type QUICEventKind int
A QUICEventKind is a type of operation on a QUIC connection.
const ( // QUICNoEvent indicates that there are no events available. QUICNoEvent QUICEventKind = iota // 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. QUICSetReadSecret QUICSetWriteSecret // QUICWriteData provides data to send to the peer in CRYPTO frames. // QUICEvent.Data is set. QUICWriteData // QUICTransportParameters provides the peer's QUIC transport parameters. // QUICEvent.Data is set. QUICTransportParameters // 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. QUICTransportParametersRequired // QUICRejectedEarlyData indicates that the server rejected 0-RTT data even // if we offered it. It's returned before QUICEncryptionLevelApplication // keys are returned. QUICRejectedEarlyData // QUICHandshakeDone indicates that the TLS handshake has completed. QUICHandshakeDone )
type QUICSessionTicketOptions ¶
type QUICSessionTicketOptions struct { // EarlyData specifies whether the ticket may be used for 0-RTT. EarlyData bool }
type RecordHeaderError ¶
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 // 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. Conn net.Conn }
RecordHeaderError is returned when a TLS record header is invalid.
func (RecordHeaderError) Error ¶
func (e RecordHeaderError) Error() string
type RenegotiationSupport ¶
type RenegotiationSupport = tls.RenegotiationSupport
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.
type SignatureScheme ¶
type SignatureScheme = tls.SignatureScheme
SignatureScheme is a tls.SignatureScheme
const ( // RSASSA-PKCS1-v1_5 algorithms. PKCS1WithSHA256 SignatureScheme = 0x0401 PKCS1WithSHA384 SignatureScheme = 0x0501 PKCS1WithSHA512 SignatureScheme = 0x0601 // RSASSA-PSS algorithms with public key OID rsaEncryption. PSSWithSHA256 SignatureScheme = 0x0804 PSSWithSHA384 SignatureScheme = 0x0805 PSSWithSHA512 SignatureScheme = 0x0806 // ECDSA algorithms. Only constrained to a specific curve in TLS 1.3. ECDSAWithP256AndSHA256 SignatureScheme = 0x0403 ECDSAWithP384AndSHA384 SignatureScheme = 0x0503 ECDSAWithP521AndSHA512 SignatureScheme = 0x0603 // EdDSA algorithms. Ed25519 SignatureScheme = 0x0807 // Legacy signature and hash algorithms for TLS 1.2. PKCS1WithSHA1 SignatureScheme = 0x0201 ECDSAWithSHA1 SignatureScheme = 0x0203 )
Notes ¶
Bugs ¶
The crypto/tls package only implements some countermeasures against Lucky13 attacks on CBC-mode encryption, and only on SHA1 variants. See http://www.isg.rhul.ac.uk/tls/TLStiming.pdf and https://www.imperialviolet.org/2013/02/04/luckythirteen.html.