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

     1	// Copyright 2010 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	// TLS low level connection and record layer
     6	
     7	package tls
     8	
     9	import (
    10		"bytes"
    11		"crypto/cipher"
    12		"crypto/subtle"
    13		"crypto/x509"
    14		"errors"
    15		"io"
    16		"net"
    17		"sync"
    18		"time"
    19	)
    20	
    21	// A Conn represents a secured connection.
    22	// It implements the net.Conn interface.
    23	type Conn struct {
    24		// constant
    25		conn     net.Conn
    26		isClient bool
    27	
    28		// constant after handshake; protected by handshakeMutex
    29		handshakeMutex    sync.Mutex // handshakeMutex < in.Mutex, out.Mutex, errMutex
    30		vers              uint16     // TLS version
    31		haveVers          bool       // version has been negotiated
    32		config            *Config    // configuration passed to constructor
    33		handshakeComplete bool
    34		didResume         bool // whether this connection was a session resumption
    35		cipherSuite       uint16
    36		ocspResponse      []byte // stapled OCSP response
    37		peerCertificates  []*x509.Certificate
    38		// verifiedChains contains the certificate chains that we built, as
    39		// opposed to the ones presented by the server.
    40		verifiedChains [][]*x509.Certificate
    41		// serverName contains the server name indicated by the client, if any.
    42		serverName string
    43	
    44		clientProtocol         string
    45		clientProtocolFallback bool
    46	
    47		// first permanent error
    48		connErr
    49	
    50		// input/output
    51		in, out  halfConn     // in.Mutex < out.Mutex
    52		rawInput *block       // raw input, right off the wire
    53		input    *block       // application data waiting to be read
    54		hand     bytes.Buffer // handshake data waiting to be read
    55	
    56		tmp [16]byte
    57	}
    58	
    59	type connErr struct {
    60		mu    sync.Mutex
    61		value error
    62	}
    63	
    64	func (e *connErr) setError(err error) error {
    65		e.mu.Lock()
    66		defer e.mu.Unlock()
    67	
    68		if e.value == nil {
    69			e.value = err
    70		}
    71		return err
    72	}
    73	
    74	func (e *connErr) error() error {
    75		e.mu.Lock()
    76		defer e.mu.Unlock()
    77		return e.value
    78	}
    79	
    80	// Access to net.Conn methods.
    81	// Cannot just embed net.Conn because that would
    82	// export the struct field too.
    83	
    84	// LocalAddr returns the local network address.
    85	func (c *Conn) LocalAddr() net.Addr {
    86		return c.conn.LocalAddr()
    87	}
    88	
    89	// RemoteAddr returns the remote network address.
    90	func (c *Conn) RemoteAddr() net.Addr {
    91		return c.conn.RemoteAddr()
    92	}
    93	
    94	// SetDeadline sets the read and write deadlines associated with the connection.
    95	// A zero value for t means Read and Write will not time out.
    96	// After a Write has timed out, the TLS state is corrupt and all future writes will return the same error.
    97	func (c *Conn) SetDeadline(t time.Time) error {
    98		return c.conn.SetDeadline(t)
    99	}
   100	
   101	// SetReadDeadline sets the read deadline on the underlying connection.
   102	// A zero value for t means Read will not time out.
   103	func (c *Conn) SetReadDeadline(t time.Time) error {
   104		return c.conn.SetReadDeadline(t)
   105	}
   106	
   107	// SetWriteDeadline sets the write deadline on the underlying conneciton.
   108	// A zero value for t means Write will not time out.
   109	// After a Write has timed out, the TLS state is corrupt and all future writes will return the same error.
   110	func (c *Conn) SetWriteDeadline(t time.Time) error {
   111		return c.conn.SetWriteDeadline(t)
   112	}
   113	
   114	// A halfConn represents one direction of the record layer
   115	// connection, either sending or receiving.
   116	type halfConn struct {
   117		sync.Mutex
   118		version uint16      // protocol version
   119		cipher  interface{} // cipher algorithm
   120		mac     macFunction
   121		seq     [8]byte // 64-bit sequence number
   122		bfree   *block  // list of free blocks
   123	
   124		nextCipher interface{} // next encryption state
   125		nextMac    macFunction // next MAC algorithm
   126	
   127		// used to save allocating a new buffer for each MAC.
   128		inDigestBuf, outDigestBuf []byte
   129	}
   130	
   131	// prepareCipherSpec sets the encryption and MAC states
   132	// that a subsequent changeCipherSpec will use.
   133	func (hc *halfConn) prepareCipherSpec(version uint16, cipher interface{}, mac macFunction) {
   134		hc.version = version
   135		hc.nextCipher = cipher
   136		hc.nextMac = mac
   137	}
   138	
   139	// changeCipherSpec changes the encryption and MAC states
   140	// to the ones previously passed to prepareCipherSpec.
   141	func (hc *halfConn) changeCipherSpec() error {
   142		if hc.nextCipher == nil {
   143			return alertInternalError
   144		}
   145		hc.cipher = hc.nextCipher
   146		hc.mac = hc.nextMac
   147		hc.nextCipher = nil
   148		hc.nextMac = nil
   149		return nil
   150	}
   151	
   152	// incSeq increments the sequence number.
   153	func (hc *halfConn) incSeq() {
   154		for i := 7; i >= 0; i-- {
   155			hc.seq[i]++
   156			if hc.seq[i] != 0 {
   157				return
   158			}
   159		}
   160	
   161		// Not allowed to let sequence number wrap.
   162		// Instead, must renegotiate before it does.
   163		// Not likely enough to bother.
   164		panic("TLS: sequence number wraparound")
   165	}
   166	
   167	// resetSeq resets the sequence number to zero.
   168	func (hc *halfConn) resetSeq() {
   169		for i := range hc.seq {
   170			hc.seq[i] = 0
   171		}
   172	}
   173	
   174	// removePadding returns an unpadded slice, in constant time, which is a prefix
   175	// of the input. It also returns a byte which is equal to 255 if the padding
   176	// was valid and 0 otherwise. See RFC 2246, section 6.2.3.2
   177	func removePadding(payload []byte) ([]byte, byte) {
   178		if len(payload) < 1 {
   179			return payload, 0
   180		}
   181	
   182		paddingLen := payload[len(payload)-1]
   183		t := uint(len(payload)-1) - uint(paddingLen)
   184		// if len(payload) >= (paddingLen - 1) then the MSB of t is zero
   185		good := byte(int32(^t) >> 31)
   186	
   187		toCheck := 255 // the maximum possible padding length
   188		// The length of the padded data is public, so we can use an if here
   189		if toCheck+1 > len(payload) {
   190			toCheck = len(payload) - 1
   191		}
   192	
   193		for i := 0; i < toCheck; i++ {
   194			t := uint(paddingLen) - uint(i)
   195			// if i <= paddingLen then the MSB of t is zero
   196			mask := byte(int32(^t) >> 31)
   197			b := payload[len(payload)-1-i]
   198			good &^= mask&paddingLen ^ mask&b
   199		}
   200	
   201		// We AND together the bits of good and replicate the result across
   202		// all the bits.
   203		good &= good << 4
   204		good &= good << 2
   205		good &= good << 1
   206		good = uint8(int8(good) >> 7)
   207	
   208		toRemove := good&paddingLen + 1
   209		return payload[:len(payload)-int(toRemove)], good
   210	}
   211	
   212	// removePaddingSSL30 is a replacement for removePadding in the case that the
   213	// protocol version is SSLv3. In this version, the contents of the padding
   214	// are random and cannot be checked.
   215	func removePaddingSSL30(payload []byte) ([]byte, byte) {
   216		if len(payload) < 1 {
   217			return payload, 0
   218		}
   219	
   220		paddingLen := int(payload[len(payload)-1]) + 1
   221		if paddingLen > len(payload) {
   222			return payload, 0
   223		}
   224	
   225		return payload[:len(payload)-paddingLen], 255
   226	}
   227	
   228	func roundUp(a, b int) int {
   229		return a + (b-a%b)%b
   230	}
   231	
   232	// decrypt checks and strips the mac and decrypts the data in b.
   233	func (hc *halfConn) decrypt(b *block) (bool, alert) {
   234		// pull out payload
   235		payload := b.data[recordHeaderLen:]
   236	
   237		macSize := 0
   238		if hc.mac != nil {
   239			macSize = hc.mac.Size()
   240		}
   241	
   242		paddingGood := byte(255)
   243	
   244		// decrypt
   245		if hc.cipher != nil {
   246			switch c := hc.cipher.(type) {
   247			case cipher.Stream:
   248				c.XORKeyStream(payload, payload)
   249			case cipher.BlockMode:
   250				blockSize := c.BlockSize()
   251	
   252				if len(payload)%blockSize != 0 || len(payload) < roundUp(macSize+1, blockSize) {
   253					return false, alertBadRecordMAC
   254				}
   255	
   256				c.CryptBlocks(payload, payload)
   257				if hc.version == versionSSL30 {
   258					payload, paddingGood = removePaddingSSL30(payload)
   259				} else {
   260					payload, paddingGood = removePadding(payload)
   261				}
   262				b.resize(recordHeaderLen + len(payload))
   263	
   264				// note that we still have a timing side-channel in the
   265				// MAC check, below. An attacker can align the record
   266				// so that a correct padding will cause one less hash
   267				// block to be calculated. Then they can iteratively
   268				// decrypt a record by breaking each byte. See
   269				// "Password Interception in a SSL/TLS Channel", Brice
   270				// Canvel et al.
   271				//
   272				// However, our behavior matches OpenSSL, so we leak
   273				// only as much as they do.
   274			default:
   275				panic("unknown cipher type")
   276			}
   277		}
   278	
   279		// check, strip mac
   280		if hc.mac != nil {
   281			if len(payload) < macSize {
   282				return false, alertBadRecordMAC
   283			}
   284	
   285			// strip mac off payload, b.data
   286			n := len(payload) - macSize
   287			b.data[3] = byte(n >> 8)
   288			b.data[4] = byte(n)
   289			b.resize(recordHeaderLen + n)
   290			remoteMAC := payload[n:]
   291			localMAC := hc.mac.MAC(hc.inDigestBuf, hc.seq[0:], b.data)
   292			hc.incSeq()
   293	
   294			if subtle.ConstantTimeCompare(localMAC, remoteMAC) != 1 || paddingGood != 255 {
   295				return false, alertBadRecordMAC
   296			}
   297			hc.inDigestBuf = localMAC
   298		}
   299	
   300		return true, 0
   301	}
   302	
   303	// padToBlockSize calculates the needed padding block, if any, for a payload.
   304	// On exit, prefix aliases payload and extends to the end of the last full
   305	// block of payload. finalBlock is a fresh slice which contains the contents of
   306	// any suffix of payload as well as the needed padding to make finalBlock a
   307	// full block.
   308	func padToBlockSize(payload []byte, blockSize int) (prefix, finalBlock []byte) {
   309		overrun := len(payload) % blockSize
   310		paddingLen := blockSize - overrun
   311		prefix = payload[:len(payload)-overrun]
   312		finalBlock = make([]byte, blockSize)
   313		copy(finalBlock, payload[len(payload)-overrun:])
   314		for i := overrun; i < blockSize; i++ {
   315			finalBlock[i] = byte(paddingLen - 1)
   316		}
   317		return
   318	}
   319	
   320	// encrypt encrypts and macs the data in b.
   321	func (hc *halfConn) encrypt(b *block) (bool, alert) {
   322		// mac
   323		if hc.mac != nil {
   324			mac := hc.mac.MAC(hc.outDigestBuf, hc.seq[0:], b.data)
   325			hc.incSeq()
   326	
   327			n := len(b.data)
   328			b.resize(n + len(mac))
   329			copy(b.data[n:], mac)
   330			hc.outDigestBuf = mac
   331		}
   332	
   333		payload := b.data[recordHeaderLen:]
   334	
   335		// encrypt
   336		if hc.cipher != nil {
   337			switch c := hc.cipher.(type) {
   338			case cipher.Stream:
   339				c.XORKeyStream(payload, payload)
   340			case cipher.BlockMode:
   341				prefix, finalBlock := padToBlockSize(payload, c.BlockSize())
   342				b.resize(recordHeaderLen + len(prefix) + len(finalBlock))
   343				c.CryptBlocks(b.data[recordHeaderLen:], prefix)
   344				c.CryptBlocks(b.data[recordHeaderLen+len(prefix):], finalBlock)
   345			default:
   346				panic("unknown cipher type")
   347			}
   348		}
   349	
   350		// update length to include MAC and any block padding needed.
   351		n := len(b.data) - recordHeaderLen
   352		b.data[3] = byte(n >> 8)
   353		b.data[4] = byte(n)
   354	
   355		return true, 0
   356	}
   357	
   358	// A block is a simple data buffer.
   359	type block struct {
   360		data []byte
   361		off  int // index for Read
   362		link *block
   363	}
   364	
   365	// resize resizes block to be n bytes, growing if necessary.
   366	func (b *block) resize(n int) {
   367		if n > cap(b.data) {
   368			b.reserve(n)
   369		}
   370		b.data = b.data[0:n]
   371	}
   372	
   373	// reserve makes sure that block contains a capacity of at least n bytes.
   374	func (b *block) reserve(n int) {
   375		if cap(b.data) >= n {
   376			return
   377		}
   378		m := cap(b.data)
   379		if m == 0 {
   380			m = 1024
   381		}
   382		for m < n {
   383			m *= 2
   384		}
   385		data := make([]byte, len(b.data), m)
   386		copy(data, b.data)
   387		b.data = data
   388	}
   389	
   390	// readFromUntil reads from r into b until b contains at least n bytes
   391	// or else returns an error.
   392	func (b *block) readFromUntil(r io.Reader, n int) error {
   393		// quick case
   394		if len(b.data) >= n {
   395			return nil
   396		}
   397	
   398		// read until have enough.
   399		b.reserve(n)
   400		for {
   401			m, err := r.Read(b.data[len(b.data):cap(b.data)])
   402			b.data = b.data[0 : len(b.data)+m]
   403			if len(b.data) >= n {
   404				break
   405			}
   406			if err != nil {
   407				return err
   408			}
   409		}
   410		return nil
   411	}
   412	
   413	func (b *block) Read(p []byte) (n int, err error) {
   414		n = copy(p, b.data[b.off:])
   415		b.off += n
   416		return
   417	}
   418	
   419	// newBlock allocates a new block, from hc's free list if possible.
   420	func (hc *halfConn) newBlock() *block {
   421		b := hc.bfree
   422		if b == nil {
   423			return new(block)
   424		}
   425		hc.bfree = b.link
   426		b.link = nil
   427		b.resize(0)
   428		return b
   429	}
   430	
   431	// freeBlock returns a block to hc's free list.
   432	// The protocol is such that each side only has a block or two on
   433	// its free list at a time, so there's no need to worry about
   434	// trimming the list, etc.
   435	func (hc *halfConn) freeBlock(b *block) {
   436		b.link = hc.bfree
   437		hc.bfree = b
   438	}
   439	
   440	// splitBlock splits a block after the first n bytes,
   441	// returning a block with those n bytes and a
   442	// block with the remainder.  the latter may be nil.
   443	func (hc *halfConn) splitBlock(b *block, n int) (*block, *block) {
   444		if len(b.data) <= n {
   445			return b, nil
   446		}
   447		bb := hc.newBlock()
   448		bb.resize(len(b.data) - n)
   449		copy(bb.data, b.data[n:])
   450		b.data = b.data[0:n]
   451		return b, bb
   452	}
   453	
   454	// readRecord reads the next TLS record from the connection
   455	// and updates the record layer state.
   456	// c.in.Mutex <= L; c.input == nil.
   457	func (c *Conn) readRecord(want recordType) error {
   458		// Caller must be in sync with connection:
   459		// handshake data if handshake not yet completed,
   460		// else application data.  (We don't support renegotiation.)
   461		switch want {
   462		default:
   463			return c.sendAlert(alertInternalError)
   464		case recordTypeHandshake, recordTypeChangeCipherSpec:
   465			if c.handshakeComplete {
   466				return c.sendAlert(alertInternalError)
   467			}
   468		case recordTypeApplicationData:
   469			if !c.handshakeComplete {
   470				return c.sendAlert(alertInternalError)
   471			}
   472		}
   473	
   474	Again:
   475		if c.rawInput == nil {
   476			c.rawInput = c.in.newBlock()
   477		}
   478		b := c.rawInput
   479	
   480		// Read header, payload.
   481		if err := b.readFromUntil(c.conn, recordHeaderLen); err != nil {
   482			// RFC suggests that EOF without an alertCloseNotify is
   483			// an error, but popular web sites seem to do this,
   484			// so we can't make it an error.
   485			// if err == io.EOF {
   486			// 	err = io.ErrUnexpectedEOF
   487			// }
   488			if e, ok := err.(net.Error); !ok || !e.Temporary() {
   489				c.setError(err)
   490			}
   491			return err
   492		}
   493		typ := recordType(b.data[0])
   494	
   495		// No valid TLS record has a type of 0x80, however SSLv2 handshakes
   496		// start with a uint16 length where the MSB is set and the first record
   497		// is always < 256 bytes long. Therefore typ == 0x80 strongly suggests
   498		// an SSLv2 client.
   499		if want == recordTypeHandshake && typ == 0x80 {
   500			c.sendAlert(alertProtocolVersion)
   501			return errors.New("tls: unsupported SSLv2 handshake received")
   502		}
   503	
   504		vers := uint16(b.data[1])<<8 | uint16(b.data[2])
   505		n := int(b.data[3])<<8 | int(b.data[4])
   506		if c.haveVers && vers != c.vers {
   507			return c.sendAlert(alertProtocolVersion)
   508		}
   509		if n > maxCiphertext {
   510			return c.sendAlert(alertRecordOverflow)
   511		}
   512		if !c.haveVers {
   513			// First message, be extra suspicious:
   514			// this might not be a TLS client.
   515			// Bail out before reading a full 'body', if possible.
   516			// The current max version is 3.1.
   517			// If the version is >= 16.0, it's probably not real.
   518			// Similarly, a clientHello message encodes in
   519			// well under a kilobyte.  If the length is >= 12 kB,
   520			// it's probably not real.
   521			if (typ != recordTypeAlert && typ != want) || vers >= 0x1000 || n >= 0x3000 {
   522				return c.sendAlert(alertUnexpectedMessage)
   523			}
   524		}
   525		if err := b.readFromUntil(c.conn, recordHeaderLen+n); err != nil {
   526			if err == io.EOF {
   527				err = io.ErrUnexpectedEOF
   528			}
   529			if e, ok := err.(net.Error); !ok || !e.Temporary() {
   530				c.setError(err)
   531			}
   532			return err
   533		}
   534	
   535		// Process message.
   536		b, c.rawInput = c.in.splitBlock(b, recordHeaderLen+n)
   537		b.off = recordHeaderLen
   538		if ok, err := c.in.decrypt(b); !ok {
   539			return c.sendAlert(err)
   540		}
   541		data := b.data[b.off:]
   542		if len(data) > maxPlaintext {
   543			c.sendAlert(alertRecordOverflow)
   544			c.in.freeBlock(b)
   545			return c.error()
   546		}
   547	
   548		switch typ {
   549		default:
   550			c.sendAlert(alertUnexpectedMessage)
   551	
   552		case recordTypeAlert:
   553			if len(data) != 2 {
   554				c.sendAlert(alertUnexpectedMessage)
   555				break
   556			}
   557			if alert(data[1]) == alertCloseNotify {
   558				c.setError(io.EOF)
   559				break
   560			}
   561			switch data[0] {
   562			case alertLevelWarning:
   563				// drop on the floor
   564				c.in.freeBlock(b)
   565				goto Again
   566			case alertLevelError:
   567				c.setError(&net.OpError{Op: "remote error", Err: alert(data[1])})
   568			default:
   569				c.sendAlert(alertUnexpectedMessage)
   570			}
   571	
   572		case recordTypeChangeCipherSpec:
   573			if typ != want || len(data) != 1 || data[0] != 1 {
   574				c.sendAlert(alertUnexpectedMessage)
   575				break
   576			}
   577			err := c.in.changeCipherSpec()
   578			if err != nil {
   579				c.sendAlert(err.(alert))
   580			}
   581	
   582		case recordTypeApplicationData:
   583			if typ != want {
   584				c.sendAlert(alertUnexpectedMessage)
   585				break
   586			}
   587			c.input = b
   588			b = nil
   589	
   590		case recordTypeHandshake:
   591			// TODO(rsc): Should at least pick off connection close.
   592			if typ != want {
   593				return c.sendAlert(alertNoRenegotiation)
   594			}
   595			c.hand.Write(data)
   596		}
   597	
   598		if b != nil {
   599			c.in.freeBlock(b)
   600		}
   601		return c.error()
   602	}
   603	
   604	// sendAlert sends a TLS alert message.
   605	// c.out.Mutex <= L.
   606	func (c *Conn) sendAlertLocked(err alert) error {
   607		switch err {
   608		case alertNoRenegotiation, alertCloseNotify:
   609			c.tmp[0] = alertLevelWarning
   610		default:
   611			c.tmp[0] = alertLevelError
   612		}
   613		c.tmp[1] = byte(err)
   614		c.writeRecord(recordTypeAlert, c.tmp[0:2])
   615		// closeNotify is a special case in that it isn't an error:
   616		if err != alertCloseNotify {
   617			return c.setError(&net.OpError{Op: "local error", Err: err})
   618		}
   619		return nil
   620	}
   621	
   622	// sendAlert sends a TLS alert message.
   623	// L < c.out.Mutex.
   624	func (c *Conn) sendAlert(err alert) error {
   625		c.out.Lock()
   626		defer c.out.Unlock()
   627		return c.sendAlertLocked(err)
   628	}
   629	
   630	// writeRecord writes a TLS record with the given type and payload
   631	// to the connection and updates the record layer state.
   632	// c.out.Mutex <= L.
   633	func (c *Conn) writeRecord(typ recordType, data []byte) (n int, err error) {
   634		b := c.out.newBlock()
   635		for len(data) > 0 {
   636			m := len(data)
   637			if m > maxPlaintext {
   638				m = maxPlaintext
   639			}
   640			b.resize(recordHeaderLen + m)
   641			b.data[0] = byte(typ)
   642			vers := c.vers
   643			if vers == 0 {
   644				vers = maxVersion
   645			}
   646			b.data[1] = byte(vers >> 8)
   647			b.data[2] = byte(vers)
   648			b.data[3] = byte(m >> 8)
   649			b.data[4] = byte(m)
   650			copy(b.data[recordHeaderLen:], data)
   651			c.out.encrypt(b)
   652			_, err = c.conn.Write(b.data)
   653			if err != nil {
   654				break
   655			}
   656			n += m
   657			data = data[m:]
   658		}
   659		c.out.freeBlock(b)
   660	
   661		if typ == recordTypeChangeCipherSpec {
   662			err = c.out.changeCipherSpec()
   663			if err != nil {
   664				// Cannot call sendAlert directly,
   665				// because we already hold c.out.Mutex.
   666				c.tmp[0] = alertLevelError
   667				c.tmp[1] = byte(err.(alert))
   668				c.writeRecord(recordTypeAlert, c.tmp[0:2])
   669				return n, c.setError(&net.OpError{Op: "local error", Err: err})
   670			}
   671		}
   672		return
   673	}
   674	
   675	// readHandshake reads the next handshake message from
   676	// the record layer.
   677	// c.in.Mutex < L; c.out.Mutex < L.
   678	func (c *Conn) readHandshake() (interface{}, error) {
   679		for c.hand.Len() < 4 {
   680			if err := c.error(); err != nil {
   681				return nil, err
   682			}
   683			if err := c.readRecord(recordTypeHandshake); err != nil {
   684				return nil, err
   685			}
   686		}
   687	
   688		data := c.hand.Bytes()
   689		n := int(data[1])<<16 | int(data[2])<<8 | int(data[3])
   690		if n > maxHandshake {
   691			c.sendAlert(alertInternalError)
   692			return nil, c.error()
   693		}
   694		for c.hand.Len() < 4+n {
   695			if err := c.error(); err != nil {
   696				return nil, err
   697			}
   698			if err := c.readRecord(recordTypeHandshake); err != nil {
   699				return nil, err
   700			}
   701		}
   702		data = c.hand.Next(4 + n)
   703		var m handshakeMessage
   704		switch data[0] {
   705		case typeClientHello:
   706			m = new(clientHelloMsg)
   707		case typeServerHello:
   708			m = new(serverHelloMsg)
   709		case typeCertificate:
   710			m = new(certificateMsg)
   711		case typeCertificateRequest:
   712			m = new(certificateRequestMsg)
   713		case typeCertificateStatus:
   714			m = new(certificateStatusMsg)
   715		case typeServerKeyExchange:
   716			m = new(serverKeyExchangeMsg)
   717		case typeServerHelloDone:
   718			m = new(serverHelloDoneMsg)
   719		case typeClientKeyExchange:
   720			m = new(clientKeyExchangeMsg)
   721		case typeCertificateVerify:
   722			m = new(certificateVerifyMsg)
   723		case typeNextProtocol:
   724			m = new(nextProtoMsg)
   725		case typeFinished:
   726			m = new(finishedMsg)
   727		default:
   728			c.sendAlert(alertUnexpectedMessage)
   729			return nil, alertUnexpectedMessage
   730		}
   731	
   732		// The handshake message unmarshallers
   733		// expect to be able to keep references to data,
   734		// so pass in a fresh copy that won't be overwritten.
   735		data = append([]byte(nil), data...)
   736	
   737		if !m.unmarshal(data) {
   738			c.sendAlert(alertUnexpectedMessage)
   739			return nil, alertUnexpectedMessage
   740		}
   741		return m, nil
   742	}
   743	
   744	// Write writes data to the connection.
   745	func (c *Conn) Write(b []byte) (int, error) {
   746		if err := c.error(); err != nil {
   747			return 0, err
   748		}
   749	
   750		if err := c.Handshake(); err != nil {
   751			return 0, c.setError(err)
   752		}
   753	
   754		c.out.Lock()
   755		defer c.out.Unlock()
   756	
   757		if !c.handshakeComplete {
   758			return 0, alertInternalError
   759		}
   760	
   761		// SSL 3.0 and TLS 1.0 are susceptible to a chosen-plaintext
   762		// attack when using block mode ciphers due to predictable IVs.
   763		// This can be prevented by splitting each Application Data
   764		// record into two records, effectively randomizing the IV.
   765		//
   766		// http://www.openssl.org/~bodo/tls-cbc.txt
   767		// https://bugzilla.mozilla.org/show_bug.cgi?id=665814
   768		// http://www.imperialviolet.org/2012/01/15/beastfollowup.html
   769	
   770		var m int
   771		if len(b) > 1 && c.vers <= versionTLS10 {
   772			if _, ok := c.out.cipher.(cipher.BlockMode); ok {
   773				n, err := c.writeRecord(recordTypeApplicationData, b[:1])
   774				if err != nil {
   775					return n, c.setError(err)
   776				}
   777				m, b = 1, b[1:]
   778			}
   779		}
   780	
   781		n, err := c.writeRecord(recordTypeApplicationData, b)
   782		return n + m, c.setError(err)
   783	}
   784	
   785	// Read can be made to time out and return a net.Error with Timeout() == true
   786	// after a fixed time limit; see SetDeadline and SetReadDeadline.
   787	func (c *Conn) Read(b []byte) (n int, err error) {
   788		if err = c.Handshake(); err != nil {
   789			return
   790		}
   791	
   792		c.in.Lock()
   793		defer c.in.Unlock()
   794	
   795		for c.input == nil && c.error() == nil {
   796			if err := c.readRecord(recordTypeApplicationData); err != nil {
   797				// Soft error, like EAGAIN
   798				return 0, err
   799			}
   800		}
   801		if err := c.error(); err != nil {
   802			return 0, err
   803		}
   804		n, err = c.input.Read(b)
   805		if c.input.off >= len(c.input.data) {
   806			c.in.freeBlock(c.input)
   807			c.input = nil
   808		}
   809		return n, nil
   810	}
   811	
   812	// Close closes the connection.
   813	func (c *Conn) Close() error {
   814		var alertErr error
   815	
   816		c.handshakeMutex.Lock()
   817		defer c.handshakeMutex.Unlock()
   818		if c.handshakeComplete {
   819			alertErr = c.sendAlert(alertCloseNotify)
   820		}
   821	
   822		if err := c.conn.Close(); err != nil {
   823			return err
   824		}
   825		return alertErr
   826	}
   827	
   828	// Handshake runs the client or server handshake
   829	// protocol if it has not yet been run.
   830	// Most uses of this package need not call Handshake
   831	// explicitly: the first Read or Write will call it automatically.
   832	func (c *Conn) Handshake() error {
   833		c.handshakeMutex.Lock()
   834		defer c.handshakeMutex.Unlock()
   835		if err := c.error(); err != nil {
   836			return err
   837		}
   838		if c.handshakeComplete {
   839			return nil
   840		}
   841		if c.isClient {
   842			return c.clientHandshake()
   843		}
   844		return c.serverHandshake()
   845	}
   846	
   847	// ConnectionState returns basic TLS details about the connection.
   848	func (c *Conn) ConnectionState() ConnectionState {
   849		c.handshakeMutex.Lock()
   850		defer c.handshakeMutex.Unlock()
   851	
   852		var state ConnectionState
   853		state.HandshakeComplete = c.handshakeComplete
   854		if c.handshakeComplete {
   855			state.NegotiatedProtocol = c.clientProtocol
   856			state.DidResume = c.didResume
   857			state.NegotiatedProtocolIsMutual = !c.clientProtocolFallback
   858			state.CipherSuite = c.cipherSuite
   859			state.PeerCertificates = c.peerCertificates
   860			state.VerifiedChains = c.verifiedChains
   861			state.ServerName = c.serverName
   862		}
   863	
   864		return state
   865	}
   866	
   867	// OCSPResponse returns the stapled OCSP response from the TLS server, if
   868	// any. (Only valid for client connections.)
   869	func (c *Conn) OCSPResponse() []byte {
   870		c.handshakeMutex.Lock()
   871		defer c.handshakeMutex.Unlock()
   872	
   873		return c.ocspResponse
   874	}
   875	
   876	// VerifyHostname checks that the peer certificate chain is valid for
   877	// connecting to host.  If so, it returns nil; if not, it returns an error
   878	// describing the problem.
   879	func (c *Conn) VerifyHostname(host string) error {
   880		c.handshakeMutex.Lock()
   881		defer c.handshakeMutex.Unlock()
   882		if !c.isClient {
   883			return errors.New("VerifyHostname called on TLS server connection")
   884		}
   885		if !c.handshakeComplete {
   886			return errors.New("TLS handshake has not yet been performed")
   887		}
   888		return c.peerCertificates[0].VerifyHostname(host)
   889	}

View as plain text