| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package tls partially implements TLS 1.2, as specified in RFC 5246. |
| package runner |
| |
| import ( |
| "bytes" |
| "crypto" |
| "crypto/ecdsa" |
| "crypto/rsa" |
| "crypto/x509" |
| "encoding/pem" |
| "errors" |
| "io/ioutil" |
| "net" |
| "strings" |
| "time" |
| |
| "boringssl.googlesource.com/boringssl/ssl/test/runner/ed25519" |
| ) |
| |
| // Server returns a new TLS server side connection |
| // using conn as the underlying transport. |
| // The configuration config must be non-nil and must have |
| // at least one certificate. |
| func Server(conn net.Conn, config *Config) *Conn { |
| c := &Conn{conn: conn, config: config} |
| c.init() |
| return c |
| } |
| |
| // Client returns a new TLS client side connection |
| // using conn as the underlying transport. |
| // The config cannot be nil: users must set either ServerHostname or |
| // InsecureSkipVerify in the config. |
| func Client(conn net.Conn, config *Config) *Conn { |
| c := &Conn{conn: conn, config: config, isClient: true} |
| c.init() |
| return c |
| } |
| |
| // A listener implements a network listener (net.Listener) for TLS connections. |
| type listener struct { |
| net.Listener |
| config *Config |
| } |
| |
| // Accept waits for and returns the next incoming TLS connection. |
| // The returned connection c is a *tls.Conn. |
| func (l *listener) Accept() (c net.Conn, err error) { |
| c, err = l.Listener.Accept() |
| if err != nil { |
| return |
| } |
| c = Server(c, l.config) |
| return |
| } |
| |
| // 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 have |
| // at least one certificate. |
| func NewListener(inner net.Listener, config *Config) net.Listener { |
| l := new(listener) |
| l.Listener = inner |
| l.config = config |
| return l |
| } |
| |
| // Listen creates a TLS listener accepting connections on the |
| // given network address using net.Listen. |
| // The configuration config must be non-nil and must have |
| // at least one certificate. |
| func Listen(network, laddr string, config *Config) (net.Listener, error) { |
| if config == nil || len(config.Certificates) == 0 { |
| return nil, errors.New("tls.Listen: no certificates in configuration") |
| } |
| l, err := net.Listen(network, laddr) |
| if err != nil { |
| return nil, err |
| } |
| return NewListener(l, config), nil |
| } |
| |
| type timeoutError struct{} |
| |
| func (timeoutError) Error() string { return "tls: DialWithDialer timed out" } |
| func (timeoutError) Timeout() bool { return true } |
| func (timeoutError) Temporary() bool { return true } |
| |
| // 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 DialWithDialer(dialer *net.Dialer, network, addr string, config *Config) (*Conn, error) { |
| // We want the Timeout and Deadline values from dialer to cover the |
| // whole process: TCP connection and TLS handshake. This means that we |
| // also need to start our own timers now. |
| timeout := dialer.Timeout |
| |
| if !dialer.Deadline.IsZero() { |
| deadlineTimeout := dialer.Deadline.Sub(time.Now()) |
| if timeout == 0 || deadlineTimeout < timeout { |
| timeout = deadlineTimeout |
| } |
| } |
| |
| var errChannel chan error |
| |
| if timeout != 0 { |
| errChannel = make(chan error, 2) |
| time.AfterFunc(timeout, func() { |
| errChannel <- timeoutError{} |
| }) |
| } |
| |
| rawConn, err := dialer.Dial(network, addr) |
| if err != nil { |
| return nil, err |
| } |
| |
| colonPos := strings.LastIndex(addr, ":") |
| if colonPos == -1 { |
| colonPos = len(addr) |
| } |
| hostname := addr[:colonPos] |
| |
| if config == nil { |
| config = defaultConfig() |
| } |
| // If no ServerName is set, infer the ServerName |
| // from the hostname we're connecting to. |
| if config.ServerName == "" { |
| // Make a copy to avoid polluting argument or default. |
| c := *config |
| c.ServerName = hostname |
| config = &c |
| } |
| |
| conn := Client(rawConn, config) |
| |
| if timeout == 0 { |
| err = conn.Handshake() |
| } else { |
| go func() { |
| errChannel <- conn.Handshake() |
| }() |
| |
| err = <-errChannel |
| } |
| |
| if err != nil { |
| rawConn.Close() |
| return nil, err |
| } |
| |
| return conn, nil |
| } |
| |
| // 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. |
| func Dial(network, addr string, config *Config) (*Conn, error) { |
| return DialWithDialer(new(net.Dialer), network, addr, config) |
| } |
| |
| // LoadX509KeyPair reads and parses a public/private key pair from a pair of |
| // files. The files must contain PEM encoded data. |
| func LoadX509KeyPair(certFile, keyFile string) (cert Certificate, err error) { |
| certPEMBlock, err := ioutil.ReadFile(certFile) |
| if err != nil { |
| return |
| } |
| keyPEMBlock, err := ioutil.ReadFile(keyFile) |
| if err != nil { |
| return |
| } |
| return X509KeyPair(certPEMBlock, keyPEMBlock) |
| } |
| |
| // X509KeyPair parses a public/private key pair from a pair of |
| // PEM encoded data. |
| func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (cert Certificate, err error) { |
| var certDERBlock *pem.Block |
| for { |
| certDERBlock, certPEMBlock = pem.Decode(certPEMBlock) |
| if certDERBlock == nil { |
| break |
| } |
| if certDERBlock.Type == "CERTIFICATE" { |
| cert.Certificate = append(cert.Certificate, certDERBlock.Bytes) |
| } |
| } |
| |
| if len(cert.Certificate) == 0 { |
| err = errors.New("crypto/tls: failed to parse certificate PEM data") |
| return |
| } |
| |
| var keyDERBlock *pem.Block |
| for { |
| keyDERBlock, keyPEMBlock = pem.Decode(keyPEMBlock) |
| if keyDERBlock == nil { |
| err = errors.New("crypto/tls: failed to parse key PEM data") |
| return |
| } |
| if keyDERBlock.Type == "PRIVATE KEY" || strings.HasSuffix(keyDERBlock.Type, " PRIVATE KEY") { |
| break |
| } |
| } |
| |
| cert.PrivateKey, err = parsePrivateKey(keyDERBlock.Bytes) |
| if err != nil { |
| return |
| } |
| |
| // We don't need to parse the public key for TLS, but we so do anyway |
| // to check that it looks sane and matches the private key. |
| x509Cert, err := x509.ParseCertificate(cert.Certificate[0]) |
| if err != nil { |
| return |
| } |
| |
| switch pub := getCertificatePublicKey(x509Cert).(type) { |
| case *rsa.PublicKey: |
| priv, ok := cert.PrivateKey.(*rsa.PrivateKey) |
| if !ok { |
| err = errors.New("crypto/tls: private key type does not match public key type") |
| return |
| } |
| if pub.N.Cmp(priv.N) != 0 { |
| err = errors.New("crypto/tls: private key does not match public key") |
| return |
| } |
| case *ecdsa.PublicKey: |
| priv, ok := cert.PrivateKey.(*ecdsa.PrivateKey) |
| if !ok { |
| err = errors.New("crypto/tls: private key type does not match public key type") |
| return |
| |
| } |
| if pub.X.Cmp(priv.X) != 0 || pub.Y.Cmp(priv.Y) != 0 { |
| err = errors.New("crypto/tls: private key does not match public key") |
| return |
| } |
| case ed25519.PublicKey: |
| priv, ok := cert.PrivateKey.(ed25519.PrivateKey) |
| if !ok { |
| err = errors.New("crypto/tls: private key type does not match public key type") |
| return |
| } |
| if !bytes.Equal(priv[32:], pub) { |
| err = errors.New("crypto/tls: private key does not match public key") |
| return |
| } |
| default: |
| err = errors.New("crypto/tls: unknown public key algorithm") |
| return |
| } |
| |
| return |
| } |
| |
| var ed25519SPKIPrefix = []byte{0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00} |
| |
| func isEd25519Certificate(cert *x509.Certificate) bool { |
| return bytes.HasPrefix(cert.RawSubjectPublicKeyInfo, ed25519SPKIPrefix) && len(cert.RawSubjectPublicKeyInfo) == len(ed25519SPKIPrefix)+32 |
| } |
| |
| func getCertificatePublicKey(cert *x509.Certificate) crypto.PublicKey { |
| if cert.PublicKey != nil { |
| return cert.PublicKey |
| } |
| |
| if isEd25519Certificate(cert) { |
| return ed25519.PublicKey(cert.RawSubjectPublicKeyInfo[len(ed25519SPKIPrefix):]) |
| } |
| |
| return nil |
| } |
| |
| var ed25519PKCS8Prefix = []byte{0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, |
| 0x04, 0x22, 0x04, 0x20} |
| |
| // 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. |
| func parsePrivateKey(der []byte) (crypto.PrivateKey, error) { |
| if key, err := x509.ParsePKCS1PrivateKey(der); err == nil { |
| return key, nil |
| } |
| if key, err := x509.ParsePKCS8PrivateKey(der); err == nil { |
| switch key := key.(type) { |
| case *rsa.PrivateKey, *ecdsa.PrivateKey: |
| return key, nil |
| default: |
| return nil, errors.New("crypto/tls: found unknown private key type in PKCS#8 wrapping") |
| } |
| } |
| if key, err := x509.ParseECPrivateKey(der); err == nil { |
| return key, nil |
| } |
| |
| if bytes.HasPrefix(der, ed25519PKCS8Prefix) && len(der) == len(ed25519PKCS8Prefix)+32 { |
| seed := der[len(ed25519PKCS8Prefix):] |
| _, key := ed25519.NewKeyPairFromSeed(seed) |
| return key, nil |
| } |
| |
| return nil, errors.New("crypto/tls: failed to parse private key") |
| } |