Run Format

Source file src/pkg/crypto/tls/tls.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Package tls partially implements TLS 1.2, as specified in RFC 5246.
     6	package tls
     7	
     8	import (
     9		"crypto"
    10		"crypto/ecdsa"
    11		"crypto/rsa"
    12		"crypto/x509"
    13		"encoding/pem"
    14		"errors"
    15		"io/ioutil"
    16		"net"
    17		"strings"
    18	)
    19	
    20	// Server returns a new TLS server side connection
    21	// using conn as the underlying transport.
    22	// The configuration config must be non-nil and must have
    23	// at least one certificate.
    24	func Server(conn net.Conn, config *Config) *Conn {
    25		return &Conn{conn: conn, config: config}
    26	}
    27	
    28	// Client returns a new TLS client side connection
    29	// using conn as the underlying transport.
    30	// Client interprets a nil configuration as equivalent to
    31	// the zero configuration; see the documentation of Config
    32	// for the defaults.
    33	func Client(conn net.Conn, config *Config) *Conn {
    34		return &Conn{conn: conn, config: config, isClient: true}
    35	}
    36	
    37	// A listener implements a network listener (net.Listener) for TLS connections.
    38	type listener struct {
    39		net.Listener
    40		config *Config
    41	}
    42	
    43	// Accept waits for and returns the next incoming TLS connection.
    44	// The returned connection c is a *tls.Conn.
    45	func (l *listener) Accept() (c net.Conn, err error) {
    46		c, err = l.Listener.Accept()
    47		if err != nil {
    48			return
    49		}
    50		c = Server(c, l.config)
    51		return
    52	}
    53	
    54	// NewListener creates a Listener which accepts connections from an inner
    55	// Listener and wraps each connection with Server.
    56	// The configuration config must be non-nil and must have
    57	// at least one certificate.
    58	func NewListener(inner net.Listener, config *Config) net.Listener {
    59		l := new(listener)
    60		l.Listener = inner
    61		l.config = config
    62		return l
    63	}
    64	
    65	// Listen creates a TLS listener accepting connections on the
    66	// given network address using net.Listen.
    67	// The configuration config must be non-nil and must have
    68	// at least one certificate.
    69	func Listen(network, laddr string, config *Config) (net.Listener, error) {
    70		if config == nil || len(config.Certificates) == 0 {
    71			return nil, errors.New("tls.Listen: no certificates in configuration")
    72		}
    73		l, err := net.Listen(network, laddr)
    74		if err != nil {
    75			return nil, err
    76		}
    77		return NewListener(l, config), nil
    78	}
    79	
    80	// Dial connects to the given network address using net.Dial
    81	// and then initiates a TLS handshake, returning the resulting
    82	// TLS connection.
    83	// Dial interprets a nil configuration as equivalent to
    84	// the zero configuration; see the documentation of Config
    85	// for the defaults.
    86	func Dial(network, addr string, config *Config) (*Conn, error) {
    87		raddr := addr
    88		c, err := net.Dial(network, raddr)
    89		if err != nil {
    90			return nil, err
    91		}
    92	
    93		colonPos := strings.LastIndex(raddr, ":")
    94		if colonPos == -1 {
    95			colonPos = len(raddr)
    96		}
    97		hostname := raddr[:colonPos]
    98	
    99		if config == nil {
   100			config = defaultConfig()
   101		}
   102		// If no ServerName is set, infer the ServerName
   103		// from the hostname we're connecting to.
   104		if config.ServerName == "" {
   105			// Make a copy to avoid polluting argument or default.
   106			c := *config
   107			c.ServerName = hostname
   108			config = &c
   109		}
   110		conn := Client(c, config)
   111		if err = conn.Handshake(); err != nil {
   112			c.Close()
   113			return nil, err
   114		}
   115		return conn, nil
   116	}
   117	
   118	// LoadX509KeyPair reads and parses a public/private key pair from a pair of
   119	// files. The files must contain PEM encoded data.
   120	func LoadX509KeyPair(certFile, keyFile string) (cert Certificate, err error) {
   121		certPEMBlock, err := ioutil.ReadFile(certFile)
   122		if err != nil {
   123			return
   124		}
   125		keyPEMBlock, err := ioutil.ReadFile(keyFile)
   126		if err != nil {
   127			return
   128		}
   129		return X509KeyPair(certPEMBlock, keyPEMBlock)
   130	}
   131	
   132	// X509KeyPair parses a public/private key pair from a pair of
   133	// PEM encoded data.
   134	func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (cert Certificate, err error) {
   135		var certDERBlock *pem.Block
   136		for {
   137			certDERBlock, certPEMBlock = pem.Decode(certPEMBlock)
   138			if certDERBlock == nil {
   139				break
   140			}
   141			if certDERBlock.Type == "CERTIFICATE" {
   142				cert.Certificate = append(cert.Certificate, certDERBlock.Bytes)
   143			}
   144		}
   145	
   146		if len(cert.Certificate) == 0 {
   147			err = errors.New("crypto/tls: failed to parse certificate PEM data")
   148			return
   149		}
   150	
   151		var keyDERBlock *pem.Block
   152		for {
   153			keyDERBlock, keyPEMBlock = pem.Decode(keyPEMBlock)
   154			if keyDERBlock == nil {
   155				err = errors.New("crypto/tls: failed to parse key PEM data")
   156				return
   157			}
   158			if keyDERBlock.Type == "PRIVATE KEY" || strings.HasSuffix(keyDERBlock.Type, " PRIVATE KEY") {
   159				break
   160			}
   161		}
   162	
   163		cert.PrivateKey, err = parsePrivateKey(keyDERBlock.Bytes)
   164		if err != nil {
   165			return
   166		}
   167	
   168		// We don't need to parse the public key for TLS, but we so do anyway
   169		// to check that it looks sane and matches the private key.
   170		x509Cert, err := x509.ParseCertificate(cert.Certificate[0])
   171		if err != nil {
   172			return
   173		}
   174	
   175		switch pub := x509Cert.PublicKey.(type) {
   176		case *rsa.PublicKey:
   177			priv, ok := cert.PrivateKey.(*rsa.PrivateKey)
   178			if !ok {
   179				err = errors.New("crypto/tls: private key type does not match public key type")
   180				return
   181			}
   182			if pub.N.Cmp(priv.N) != 0 {
   183				err = errors.New("crypto/tls: private key does not match public key")
   184				return
   185			}
   186		case *ecdsa.PublicKey:
   187			priv, ok := cert.PrivateKey.(*ecdsa.PrivateKey)
   188			if !ok {
   189				err = errors.New("crypto/tls: private key type does not match public key type")
   190				return
   191	
   192			}
   193			if pub.X.Cmp(priv.X) != 0 || pub.Y.Cmp(priv.Y) != 0 {
   194				err = errors.New("crypto/tls: private key does not match public key")
   195				return
   196			}
   197		default:
   198			err = errors.New("crypto/tls: unknown public key algorithm")
   199			return
   200		}
   201	
   202		return
   203	}
   204	
   205	// Attempt to parse the given private key DER block. OpenSSL 0.9.8 generates
   206	// PKCS#1 private keys by default, while OpenSSL 1.0.0 generates PKCS#8 keys.
   207	// OpenSSL ecparam generates SEC1 EC private keys for ECDSA. We try all three.
   208	func parsePrivateKey(der []byte) (crypto.PrivateKey, error) {
   209		if key, err := x509.ParsePKCS1PrivateKey(der); err == nil {
   210			return key, nil
   211		}
   212		if key, err := x509.ParsePKCS8PrivateKey(der); err == nil {
   213			switch key := key.(type) {
   214			case *rsa.PrivateKey, *ecdsa.PrivateKey:
   215				return key, nil
   216			default:
   217				return nil, errors.New("crypto/tls: found unknown private key type in PKCS#8 wrapping")
   218			}
   219		}
   220		if key, err := x509.ParseECPrivateKey(der); err == nil {
   221			return key, nil
   222		}
   223	
   224		return nil, errors.New("crypto/tls: failed to parse private key")
   225	}

View as plain text