...
Run Format

Source file src/crypto/tls/conn.go

  // Copyright 2010 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.
  
  // TLS low level connection and record layer
  
  package tls
  
  import (
  	"bytes"
  	"crypto/cipher"
  	"crypto/subtle"
  	"crypto/x509"
  	"errors"
  	"fmt"
  	"io"
  	"net"
  	"sync"
  	"sync/atomic"
  	"time"
  )
  
  // A Conn represents a secured connection.
  // It implements the net.Conn interface.
  type Conn struct {
  	// constant
  	conn     net.Conn
  	isClient bool
  
  	// constant after handshake; protected by handshakeMutex
  	handshakeMutex sync.Mutex // handshakeMutex < in.Mutex, out.Mutex, errMutex
  	// handshakeCond, if not nil, indicates that a goroutine is committed
  	// to running the handshake for this Conn. Other goroutines that need
  	// to wait for the handshake can wait on this, under handshakeMutex.
  	handshakeCond *sync.Cond
  	handshakeErr  error   // error resulting from handshake
  	vers          uint16  // TLS version
  	haveVers      bool    // version has been negotiated
  	config        *Config // configuration passed to constructor
  	// handshakeComplete is true if the connection is currently transferring
  	// application data (i.e. is not currently processing a handshake).
  	handshakeComplete bool
  	// handshakes counts the number of handshakes performed on the
  	// connection so far. If renegotiation is disabled then this is either
  	// zero or one.
  	handshakes       int
  	didResume        bool // whether this connection was a session resumption
  	cipherSuite      uint16
  	ocspResponse     []byte   // stapled OCSP response
  	scts             [][]byte // signed certificate timestamps from server
  	peerCertificates []*x509.Certificate
  	// verifiedChains contains the certificate chains that we built, as
  	// opposed to the ones presented by the server.
  	verifiedChains [][]*x509.Certificate
  	// serverName contains the server name indicated by the client, if any.
  	serverName string
  	// secureRenegotiation is true if the server echoed the secure
  	// renegotiation extension. (This is meaningless as a server because
  	// renegotiation is not supported in that case.)
  	secureRenegotiation bool
  
  	// clientFinishedIsFirst is true if the client sent the first Finished
  	// message during the most recent handshake. This is recorded because
  	// the first transmitted Finished message is the tls-unique
  	// channel-binding value.
  	clientFinishedIsFirst bool
  
  	// closeNotifyErr is any error from sending the alertCloseNotify record.
  	closeNotifyErr error
  	// closeNotifySent is true if the Conn attempted to send an
  	// alertCloseNotify record.
  	closeNotifySent bool
  
  	// clientFinished and serverFinished contain the Finished message sent
  	// by the client or server in the most recent handshake. This is
  	// retained to support the renegotiation extension and tls-unique
  	// channel-binding.
  	clientFinished [12]byte
  	serverFinished [12]byte
  
  	clientProtocol         string
  	clientProtocolFallback bool
  
  	// input/output
  	in, out   halfConn     // in.Mutex < out.Mutex
  	rawInput  *block       // raw input, right off the wire
  	input     *block       // application data waiting to be read
  	hand      bytes.Buffer // handshake data waiting to be read
  	buffering bool         // whether records are buffered in sendBuf
  	sendBuf   []byte       // a buffer of records waiting to be sent
  
  	// bytesSent counts the bytes of application data sent.
  	// packetsSent counts packets.
  	bytesSent   int64
  	packetsSent int64
  
  	// activeCall is an atomic int32; the low bit is whether Close has
  	// been called. the rest of the bits are the number of goroutines
  	// in Conn.Write.
  	activeCall int32
  
  	tmp [16]byte
  }
  
  // Access to net.Conn methods.
  // Cannot just embed net.Conn because that would
  // export the struct field too.
  
  // LocalAddr returns the local network address.
  func (c *Conn) LocalAddr() net.Addr {
  	return c.conn.LocalAddr()
  }
  
  // RemoteAddr returns the remote network address.
  func (c *Conn) RemoteAddr() net.Addr {
  	return c.conn.RemoteAddr()
  }
  
  // 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 (c *Conn) SetDeadline(t time.Time) error {
  	return c.conn.SetDeadline(t)
  }
  
  // SetReadDeadline sets the read deadline on the underlying connection.
  // A zero value for t means Read will not time out.
  func (c *Conn) SetReadDeadline(t time.Time) error {
  	return c.conn.SetReadDeadline(t)
  }
  
  // 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 (c *Conn) SetWriteDeadline(t time.Time) error {
  	return c.conn.SetWriteDeadline(t)
  }
  
  // A halfConn represents one direction of the record layer
  // connection, either sending or receiving.
  type halfConn struct {
  	sync.Mutex
  
  	err            error       // first permanent error
  	version        uint16      // protocol version
  	cipher         interface{} // cipher algorithm
  	mac            macFunction
  	seq            [8]byte  // 64-bit sequence number
  	bfree          *block   // list of free blocks
  	additionalData [13]byte // to avoid allocs; interface method args escape
  
  	nextCipher interface{} // next encryption state
  	nextMac    macFunction // next MAC algorithm
  
  	// used to save allocating a new buffer for each MAC.
  	inDigestBuf, outDigestBuf []byte
  }
  
  func (hc *halfConn) setErrorLocked(err error) error {
  	hc.err = err
  	return err
  }
  
  // prepareCipherSpec sets the encryption and MAC states
  // that a subsequent changeCipherSpec will use.
  func (hc *halfConn) prepareCipherSpec(version uint16, cipher interface{}, mac macFunction) {
  	hc.version = version
  	hc.nextCipher = cipher
  	hc.nextMac = mac
  }
  
  // changeCipherSpec changes the encryption and MAC states
  // to the ones previously passed to prepareCipherSpec.
  func (hc *halfConn) changeCipherSpec() error {
  	if hc.nextCipher == nil {
  		return alertInternalError
  	}
  	hc.cipher = hc.nextCipher
  	hc.mac = hc.nextMac
  	hc.nextCipher = nil
  	hc.nextMac = nil
  	for i := range hc.seq {
  		hc.seq[i] = 0
  	}
  	return nil
  }
  
  // incSeq increments the sequence number.
  func (hc *halfConn) incSeq() {
  	for i := 7; i >= 0; i-- {
  		hc.seq[i]++
  		if hc.seq[i] != 0 {
  			return
  		}
  	}
  
  	// Not allowed to let sequence number wrap.
  	// Instead, must renegotiate before it does.
  	// Not likely enough to bother.
  	panic("TLS: sequence number wraparound")
  }
  
  // extractPadding returns, in constant time, the length of the padding to remove
  // from the end of payload. It also returns a byte which is equal to 255 if the
  // padding was valid and 0 otherwise. See RFC 2246, section 6.2.3.2
  func extractPadding(payload []byte) (toRemove int, good byte) {
  	if len(payload) < 1 {
  		return 0, 0
  	}
  
  	paddingLen := payload[len(payload)-1]
  	t := uint(len(payload)-1) - uint(paddingLen)
  	// if len(payload) >= (paddingLen - 1) then the MSB of t is zero
  	good = byte(int32(^t) >> 31)
  
  	toCheck := 255 // the maximum possible padding length
  	// The length of the padded data is public, so we can use an if here
  	if toCheck+1 > len(payload) {
  		toCheck = len(payload) - 1
  	}
  
  	for i := 0; i < toCheck; i++ {
  		t := uint(paddingLen) - uint(i)
  		// if i <= paddingLen then the MSB of t is zero
  		mask := byte(int32(^t) >> 31)
  		b := payload[len(payload)-1-i]
  		good &^= mask&paddingLen ^ mask&b
  	}
  
  	// We AND together the bits of good and replicate the result across
  	// all the bits.
  	good &= good << 4
  	good &= good << 2
  	good &= good << 1
  	good = uint8(int8(good) >> 7)
  
  	toRemove = int(paddingLen) + 1
  	return
  }
  
  // extractPaddingSSL30 is a replacement for extractPadding in the case that the
  // protocol version is SSLv3. In this version, the contents of the padding
  // are random and cannot be checked.
  func extractPaddingSSL30(payload []byte) (toRemove int, good byte) {
  	if len(payload) < 1 {
  		return 0, 0
  	}
  
  	paddingLen := int(payload[len(payload)-1]) + 1
  	if paddingLen > len(payload) {
  		return 0, 0
  	}
  
  	return paddingLen, 255
  }
  
  func roundUp(a, b int) int {
  	return a + (b-a%b)%b
  }
  
  // cbcMode is an interface for block ciphers using cipher block chaining.
  type cbcMode interface {
  	cipher.BlockMode
  	SetIV([]byte)
  }
  
  // decrypt checks and strips the mac and decrypts the data in b. Returns a
  // success boolean, the number of bytes to skip from the start of the record in
  // order to get the application payload, and an optional alert value.
  func (hc *halfConn) decrypt(b *block) (ok bool, prefixLen int, alertValue alert) {
  	// pull out payload
  	payload := b.data[recordHeaderLen:]
  
  	macSize := 0
  	if hc.mac != nil {
  		macSize = hc.mac.Size()
  	}
  
  	paddingGood := byte(255)
  	paddingLen := 0
  	explicitIVLen := 0
  
  	// decrypt
  	if hc.cipher != nil {
  		switch c := hc.cipher.(type) {
  		case cipher.Stream:
  			c.XORKeyStream(payload, payload)
  		case aead:
  			explicitIVLen = c.explicitNonceLen()
  			if len(payload) < explicitIVLen {
  				return false, 0, alertBadRecordMAC
  			}
  			nonce := payload[:explicitIVLen]
  			payload = payload[explicitIVLen:]
  
  			if len(nonce) == 0 {
  				nonce = hc.seq[:]
  			}
  
  			copy(hc.additionalData[:], hc.seq[:])
  			copy(hc.additionalData[8:], b.data[:3])
  			n := len(payload) - c.Overhead()
  			hc.additionalData[11] = byte(n >> 8)
  			hc.additionalData[12] = byte(n)
  			var err error
  			payload, err = c.Open(payload[:0], nonce, payload, hc.additionalData[:])
  			if err != nil {
  				return false, 0, alertBadRecordMAC
  			}
  			b.resize(recordHeaderLen + explicitIVLen + len(payload))
  		case cbcMode:
  			blockSize := c.BlockSize()
  			if hc.version >= VersionTLS11 {
  				explicitIVLen = blockSize
  			}
  
  			if len(payload)%blockSize != 0 || len(payload) < roundUp(explicitIVLen+macSize+1, blockSize) {
  				return false, 0, alertBadRecordMAC
  			}
  
  			if explicitIVLen > 0 {
  				c.SetIV(payload[:explicitIVLen])
  				payload = payload[explicitIVLen:]
  			}
  			c.CryptBlocks(payload, payload)
  			if hc.version == VersionSSL30 {
  				paddingLen, paddingGood = extractPaddingSSL30(payload)
  			} else {
  				paddingLen, paddingGood = extractPadding(payload)
  
  				// To protect against CBC padding oracles like Lucky13, the data
  				// past paddingLen (which is secret) is passed to the MAC
  				// function as extra data, to be fed into the HMAC after
  				// computing the digest. This makes the MAC constant time as
  				// long as the digest computation is constant time and does not
  				// affect the subsequent write.
  			}
  		default:
  			panic("unknown cipher type")
  		}
  	}
  
  	// check, strip mac
  	if hc.mac != nil {
  		if len(payload) < macSize {
  			return false, 0, alertBadRecordMAC
  		}
  
  		// strip mac off payload, b.data
  		n := len(payload) - macSize - paddingLen
  		n = subtle.ConstantTimeSelect(int(uint32(n)>>31), 0, n) // if n < 0 { n = 0 }
  		b.data[3] = byte(n >> 8)
  		b.data[4] = byte(n)
  		remoteMAC := payload[n : n+macSize]
  		localMAC := hc.mac.MAC(hc.inDigestBuf, hc.seq[0:], b.data[:recordHeaderLen], payload[:n], payload[n+macSize:])
  
  		if subtle.ConstantTimeCompare(localMAC, remoteMAC) != 1 || paddingGood != 255 {
  			return false, 0, alertBadRecordMAC
  		}
  		hc.inDigestBuf = localMAC
  
  		b.resize(recordHeaderLen + explicitIVLen + n)
  	}
  	hc.incSeq()
  
  	return true, recordHeaderLen + explicitIVLen, 0
  }
  
  // padToBlockSize calculates the needed padding block, if any, for a payload.
  // On exit, prefix aliases payload and extends to the end of the last full
  // block of payload. finalBlock is a fresh slice which contains the contents of
  // any suffix of payload as well as the needed padding to make finalBlock a
  // full block.
  func padToBlockSize(payload []byte, blockSize int) (prefix, finalBlock []byte) {
  	overrun := len(payload) % blockSize
  	paddingLen := blockSize - overrun
  	prefix = payload[:len(payload)-overrun]
  	finalBlock = make([]byte, blockSize)
  	copy(finalBlock, payload[len(payload)-overrun:])
  	for i := overrun; i < blockSize; i++ {
  		finalBlock[i] = byte(paddingLen - 1)
  	}
  	return
  }
  
  // encrypt encrypts and macs the data in b.
  func (hc *halfConn) encrypt(b *block, explicitIVLen int) (bool, alert) {
  	// mac
  	if hc.mac != nil {
  		mac := hc.mac.MAC(hc.outDigestBuf, hc.seq[0:], b.data[:recordHeaderLen], b.data[recordHeaderLen+explicitIVLen:], nil)
  
  		n := len(b.data)
  		b.resize(n + len(mac))
  		copy(b.data[n:], mac)
  		hc.outDigestBuf = mac
  	}
  
  	payload := b.data[recordHeaderLen:]
  
  	// encrypt
  	if hc.cipher != nil {
  		switch c := hc.cipher.(type) {
  		case cipher.Stream:
  			c.XORKeyStream(payload, payload)
  		case aead:
  			payloadLen := len(b.data) - recordHeaderLen - explicitIVLen
  			b.resize(len(b.data) + c.Overhead())
  			nonce := b.data[recordHeaderLen : recordHeaderLen+explicitIVLen]
  			if len(nonce) == 0 {
  				nonce = hc.seq[:]
  			}
  			payload := b.data[recordHeaderLen+explicitIVLen:]
  			payload = payload[:payloadLen]
  
  			copy(hc.additionalData[:], hc.seq[:])
  			copy(hc.additionalData[8:], b.data[:3])
  			hc.additionalData[11] = byte(payloadLen >> 8)
  			hc.additionalData[12] = byte(payloadLen)
  
  			c.Seal(payload[:0], nonce, payload, hc.additionalData[:])
  		case cbcMode:
  			blockSize := c.BlockSize()
  			if explicitIVLen > 0 {
  				c.SetIV(payload[:explicitIVLen])
  				payload = payload[explicitIVLen:]
  			}
  			prefix, finalBlock := padToBlockSize(payload, blockSize)
  			b.resize(recordHeaderLen + explicitIVLen + len(prefix) + len(finalBlock))
  			c.CryptBlocks(b.data[recordHeaderLen+explicitIVLen:], prefix)
  			c.CryptBlocks(b.data[recordHeaderLen+explicitIVLen+len(prefix):], finalBlock)
  		default:
  			panic("unknown cipher type")
  		}
  	}
  
  	// update length to include MAC and any block padding needed.
  	n := len(b.data) - recordHeaderLen
  	b.data[3] = byte(n >> 8)
  	b.data[4] = byte(n)
  	hc.incSeq()
  
  	return true, 0
  }
  
  // A block is a simple data buffer.
  type block struct {
  	data []byte
  	off  int // index for Read
  	link *block
  }
  
  // resize resizes block to be n bytes, growing if necessary.
  func (b *block) resize(n int) {
  	if n > cap(b.data) {
  		b.reserve(n)
  	}
  	b.data = b.data[0:n]
  }
  
  // reserve makes sure that block contains a capacity of at least n bytes.
  func (b *block) reserve(n int) {
  	if cap(b.data) >= n {
  		return
  	}
  	m := cap(b.data)
  	if m == 0 {
  		m = 1024
  	}
  	for m < n {
  		m *= 2
  	}
  	data := make([]byte, len(b.data), m)
  	copy(data, b.data)
  	b.data = data
  }
  
  // readFromUntil reads from r into b until b contains at least n bytes
  // or else returns an error.
  func (b *block) readFromUntil(r io.Reader, n int) error {
  	// quick case
  	if len(b.data) >= n {
  		return nil
  	}
  
  	// read until have enough.
  	b.reserve(n)
  	for {
  		m, err := r.Read(b.data[len(b.data):cap(b.data)])
  		b.data = b.data[0 : len(b.data)+m]
  		if len(b.data) >= n {
  			// TODO(bradfitz,agl): slightly suspicious
  			// that we're throwing away r.Read's err here.
  			break
  		}
  		if err != nil {
  			return err
  		}
  	}
  	return nil
  }
  
  func (b *block) Read(p []byte) (n int, err error) {
  	n = copy(p, b.data[b.off:])
  	b.off += n
  	return
  }
  
  // newBlock allocates a new block, from hc's free list if possible.
  func (hc *halfConn) newBlock() *block {
  	b := hc.bfree
  	if b == nil {
  		return new(block)
  	}
  	hc.bfree = b.link
  	b.link = nil
  	b.resize(0)
  	return b
  }
  
  // freeBlock returns a block to hc's free list.
  // The protocol is such that each side only has a block or two on
  // its free list at a time, so there's no need to worry about
  // trimming the list, etc.
  func (hc *halfConn) freeBlock(b *block) {
  	b.link = hc.bfree
  	hc.bfree = b
  }
  
  // splitBlock splits a block after the first n bytes,
  // returning a block with those n bytes and a
  // block with the remainder.  the latter may be nil.
  func (hc *halfConn) splitBlock(b *block, n int) (*block, *block) {
  	if len(b.data) <= n {
  		return b, nil
  	}
  	bb := hc.newBlock()
  	bb.resize(len(b.data) - n)
  	copy(bb.data, b.data[n:])
  	b.data = b.data[0:n]
  	return b, bb
  }
  
  // RecordHeaderError results when a TLS record header is invalid.
  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
  }
  
  func (e RecordHeaderError) Error() string { return "tls: " + e.Msg }
  
  func (c *Conn) newRecordHeaderError(msg string) (err RecordHeaderError) {
  	err.Msg = msg
  	copy(err.RecordHeader[:], c.rawInput.data)
  	return err
  }
  
  // readRecord reads the next TLS record from the connection
  // and updates the record layer state.
  // c.in.Mutex <= L; c.input == nil.
  func (c *Conn) readRecord(want recordType) error {
  	// Caller must be in sync with connection:
  	// handshake data if handshake not yet completed,
  	// else application data.
  	switch want {
  	default:
  		c.sendAlert(alertInternalError)
  		return c.in.setErrorLocked(errors.New("tls: unknown record type requested"))
  	case recordTypeHandshake, recordTypeChangeCipherSpec:
  		if c.handshakeComplete {
  			c.sendAlert(alertInternalError)
  			return c.in.setErrorLocked(errors.New("tls: handshake or ChangeCipherSpec requested while not in handshake"))
  		}
  	case recordTypeApplicationData:
  		if !c.handshakeComplete {
  			c.sendAlert(alertInternalError)
  			return c.in.setErrorLocked(errors.New("tls: application data record requested while in handshake"))
  		}
  	}
  
  Again:
  	if c.rawInput == nil {
  		c.rawInput = c.in.newBlock()
  	}
  	b := c.rawInput
  
  	// Read header, payload.
  	if err := b.readFromUntil(c.conn, recordHeaderLen); err != nil {
  		// RFC suggests that EOF without an alertCloseNotify is
  		// an error, but popular web sites seem to do this,
  		// so we can't make it an error.
  		// if err == io.EOF {
  		// 	err = io.ErrUnexpectedEOF
  		// }
  		if e, ok := err.(net.Error); !ok || !e.Temporary() {
  			c.in.setErrorLocked(err)
  		}
  		return err
  	}
  	typ := recordType(b.data[0])
  
  	// No valid TLS record has a type of 0x80, however SSLv2 handshakes
  	// start with a uint16 length where the MSB is set and the first record
  	// is always < 256 bytes long. Therefore typ == 0x80 strongly suggests
  	// an SSLv2 client.
  	if want == recordTypeHandshake && typ == 0x80 {
  		c.sendAlert(alertProtocolVersion)
  		return c.in.setErrorLocked(c.newRecordHeaderError("unsupported SSLv2 handshake received"))
  	}
  
  	vers := uint16(b.data[1])<<8 | uint16(b.data[2])
  	n := int(b.data[3])<<8 | int(b.data[4])
  	if c.haveVers && vers != c.vers {
  		c.sendAlert(alertProtocolVersion)
  		msg := fmt.Sprintf("received record with version %x when expecting version %x", vers, c.vers)
  		return c.in.setErrorLocked(c.newRecordHeaderError(msg))
  	}
  	if n > maxCiphertext {
  		c.sendAlert(alertRecordOverflow)
  		msg := fmt.Sprintf("oversized record received with length %d", n)
  		return c.in.setErrorLocked(c.newRecordHeaderError(msg))
  	}
  	if !c.haveVers {
  		// First message, be extra suspicious: this might not be a TLS
  		// client. Bail out before reading a full 'body', if possible.
  		// The current max version is 3.3 so if the version is >= 16.0,
  		// it's probably not real.
  		if (typ != recordTypeAlert && typ != want) || vers >= 0x1000 {
  			c.sendAlert(alertUnexpectedMessage)
  			return c.in.setErrorLocked(c.newRecordHeaderError("first record does not look like a TLS handshake"))
  		}
  	}
  	if err := b.readFromUntil(c.conn, recordHeaderLen+n); err != nil {
  		if err == io.EOF {
  			err = io.ErrUnexpectedEOF
  		}
  		if e, ok := err.(net.Error); !ok || !e.Temporary() {
  			c.in.setErrorLocked(err)
  		}
  		return err
  	}
  
  	// Process message.
  	b, c.rawInput = c.in.splitBlock(b, recordHeaderLen+n)
  	ok, off, alertValue := c.in.decrypt(b)
  	if !ok {
  		c.in.freeBlock(b)
  		return c.in.setErrorLocked(c.sendAlert(alertValue))
  	}
  	b.off = off
  	data := b.data[b.off:]
  	if len(data) > maxPlaintext {
  		err := c.sendAlert(alertRecordOverflow)
  		c.in.freeBlock(b)
  		return c.in.setErrorLocked(err)
  	}
  
  	switch typ {
  	default:
  		c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
  
  	case recordTypeAlert:
  		if len(data) != 2 {
  			c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
  			break
  		}
  		if alert(data[1]) == alertCloseNotify {
  			c.in.setErrorLocked(io.EOF)
  			break
  		}
  		switch data[0] {
  		case alertLevelWarning:
  			// drop on the floor
  			c.in.freeBlock(b)
  			goto Again
  		case alertLevelError:
  			c.in.setErrorLocked(&net.OpError{Op: "remote error", Err: alert(data[1])})
  		default:
  			c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
  		}
  
  	case recordTypeChangeCipherSpec:
  		if typ != want || len(data) != 1 || data[0] != 1 {
  			c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
  			break
  		}
  		err := c.in.changeCipherSpec()
  		if err != nil {
  			c.in.setErrorLocked(c.sendAlert(err.(alert)))
  		}
  
  	case recordTypeApplicationData:
  		if typ != want {
  			c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
  			break
  		}
  		c.input = b
  		b = nil
  
  	case recordTypeHandshake:
  		// TODO(rsc): Should at least pick off connection close.
  		if typ != want && !(c.isClient && c.config.Renegotiation != RenegotiateNever) {
  			return c.in.setErrorLocked(c.sendAlert(alertNoRenegotiation))
  		}
  		c.hand.Write(data)
  	}
  
  	if b != nil {
  		c.in.freeBlock(b)
  	}
  	return c.in.err
  }
  
  // sendAlert sends a TLS alert message.
  // c.out.Mutex <= L.
  func (c *Conn) sendAlertLocked(err alert) error {
  	switch err {
  	case alertNoRenegotiation, alertCloseNotify:
  		c.tmp[0] = alertLevelWarning
  	default:
  		c.tmp[0] = alertLevelError
  	}
  	c.tmp[1] = byte(err)
  
  	_, writeErr := c.writeRecordLocked(recordTypeAlert, c.tmp[0:2])
  	if err == alertCloseNotify {
  		// closeNotify is a special case in that it isn't an error.
  		return writeErr
  	}
  
  	return c.out.setErrorLocked(&net.OpError{Op: "local error", Err: err})
  }
  
  // sendAlert sends a TLS alert message.
  // L < c.out.Mutex.
  func (c *Conn) sendAlert(err alert) error {
  	c.out.Lock()
  	defer c.out.Unlock()
  	return c.sendAlertLocked(err)
  }
  
  const (
  	// tcpMSSEstimate is a conservative estimate of the TCP maximum segment
  	// size (MSS). A constant is used, rather than querying the kernel for
  	// the actual MSS, to avoid complexity. The value here is the IPv6
  	// minimum MTU (1280 bytes) minus the overhead of an IPv6 header (40
  	// bytes) and a TCP header with timestamps (32 bytes).
  	tcpMSSEstimate = 1208
  
  	// recordSizeBoostThreshold is the number of bytes of application data
  	// sent after which the TLS record size will be increased to the
  	// maximum.
  	recordSizeBoostThreshold = 128 * 1024
  )
  
  // maxPayloadSizeForWrite returns the maximum TLS payload size to use for the
  // next application data record. There is the following trade-off:
  //
  //   - For latency-sensitive applications, such as web browsing, each TLS
  //     record should fit in one TCP segment.
  //   - For throughput-sensitive applications, such as large file transfers,
  //     larger TLS records better amortize framing and encryption overheads.
  //
  // A simple heuristic that works well in practice is to use small records for
  // the first 1MB of data, then use larger records for subsequent data, and
  // reset back to smaller records after the connection becomes idle. See "High
  // Performance Web Networking", Chapter 4, or:
  // https://www.igvita.com/2013/10/24/optimizing-tls-record-size-and-buffering-latency/
  //
  // In the interests of simplicity and determinism, this code does not attempt
  // to reset the record size once the connection is idle, however.
  //
  // c.out.Mutex <= L.
  func (c *Conn) maxPayloadSizeForWrite(typ recordType, explicitIVLen int) int {
  	if c.config.DynamicRecordSizingDisabled || typ != recordTypeApplicationData {
  		return maxPlaintext
  	}
  
  	if c.bytesSent >= recordSizeBoostThreshold {
  		return maxPlaintext
  	}
  
  	// Subtract TLS overheads to get the maximum payload size.
  	macSize := 0
  	if c.out.mac != nil {
  		macSize = c.out.mac.Size()
  	}
  
  	payloadBytes := tcpMSSEstimate - recordHeaderLen - explicitIVLen
  	if c.out.cipher != nil {
  		switch ciph := c.out.cipher.(type) {
  		case cipher.Stream:
  			payloadBytes -= macSize
  		case cipher.AEAD:
  			payloadBytes -= ciph.Overhead()
  		case cbcMode:
  			blockSize := ciph.BlockSize()
  			// The payload must fit in a multiple of blockSize, with
  			// room for at least one padding byte.
  			payloadBytes = (payloadBytes & ^(blockSize - 1)) - 1
  			// The MAC is appended before padding so affects the
  			// payload size directly.
  			payloadBytes -= macSize
  		default:
  			panic("unknown cipher type")
  		}
  	}
  
  	// Allow packet growth in arithmetic progression up to max.
  	pkt := c.packetsSent
  	c.packetsSent++
  	if pkt > 1000 {
  		return maxPlaintext // avoid overflow in multiply below
  	}
  
  	n := payloadBytes * int(pkt+1)
  	if n > maxPlaintext {
  		n = maxPlaintext
  	}
  	return n
  }
  
  // c.out.Mutex <= L.
  func (c *Conn) write(data []byte) (int, error) {
  	if c.buffering {
  		c.sendBuf = append(c.sendBuf, data...)
  		return len(data), nil
  	}
  
  	n, err := c.conn.Write(data)
  	c.bytesSent += int64(n)
  	return n, err
  }
  
  func (c *Conn) flush() (int, error) {
  	if len(c.sendBuf) == 0 {
  		return 0, nil
  	}
  
  	n, err := c.conn.Write(c.sendBuf)
  	c.bytesSent += int64(n)
  	c.sendBuf = nil
  	c.buffering = false
  	return n, err
  }
  
  // writeRecordLocked writes a TLS record with the given type and payload to the
  // connection and updates the record layer state.
  // c.out.Mutex <= L.
  func (c *Conn) writeRecordLocked(typ recordType, data []byte) (int, error) {
  	b := c.out.newBlock()
  	defer c.out.freeBlock(b)
  
  	var n int
  	for len(data) > 0 {
  		explicitIVLen := 0
  		explicitIVIsSeq := false
  
  		var cbc cbcMode
  		if c.out.version >= VersionTLS11 {
  			var ok bool
  			if cbc, ok = c.out.cipher.(cbcMode); ok {
  				explicitIVLen = cbc.BlockSize()
  			}
  		}
  		if explicitIVLen == 0 {
  			if c, ok := c.out.cipher.(aead); ok {
  				explicitIVLen = c.explicitNonceLen()
  
  				// The AES-GCM construction in TLS has an
  				// explicit nonce so that the nonce can be
  				// random. However, the nonce is only 8 bytes
  				// which is too small for a secure, random
  				// nonce. Therefore we use the sequence number
  				// as the nonce.
  				explicitIVIsSeq = explicitIVLen > 0
  			}
  		}
  		m := len(data)
  		if maxPayload := c.maxPayloadSizeForWrite(typ, explicitIVLen); m > maxPayload {
  			m = maxPayload
  		}
  		b.resize(recordHeaderLen + explicitIVLen + m)
  		b.data[0] = byte(typ)
  		vers := c.vers
  		if vers == 0 {
  			// Some TLS servers fail if the record version is
  			// greater than TLS 1.0 for the initial ClientHello.
  			vers = VersionTLS10
  		}
  		b.data[1] = byte(vers >> 8)
  		b.data[2] = byte(vers)
  		b.data[3] = byte(m >> 8)
  		b.data[4] = byte(m)
  		if explicitIVLen > 0 {
  			explicitIV := b.data[recordHeaderLen : recordHeaderLen+explicitIVLen]
  			if explicitIVIsSeq {
  				copy(explicitIV, c.out.seq[:])
  			} else {
  				if _, err := io.ReadFull(c.config.rand(), explicitIV); err != nil {
  					return n, err
  				}
  			}
  		}
  		copy(b.data[recordHeaderLen+explicitIVLen:], data)
  		c.out.encrypt(b, explicitIVLen)
  		if _, err := c.write(b.data); err != nil {
  			return n, err
  		}
  		n += m
  		data = data[m:]
  	}
  
  	if typ == recordTypeChangeCipherSpec {
  		if err := c.out.changeCipherSpec(); err != nil {
  			return n, c.sendAlertLocked(err.(alert))
  		}
  	}
  
  	return n, nil
  }
  
  // writeRecord writes a TLS record with the given type and payload to the
  // connection and updates the record layer state.
  // L < c.out.Mutex.
  func (c *Conn) writeRecord(typ recordType, data []byte) (int, error) {
  	c.out.Lock()
  	defer c.out.Unlock()
  
  	return c.writeRecordLocked(typ, data)
  }
  
  // readHandshake reads the next handshake message from
  // the record layer.
  // c.in.Mutex < L; c.out.Mutex < L.
  func (c *Conn) readHandshake() (interface{}, error) {
  	for c.hand.Len() < 4 {
  		if err := c.in.err; err != nil {
  			return nil, err
  		}
  		if err := c.readRecord(recordTypeHandshake); err != nil {
  			return nil, err
  		}
  	}
  
  	data := c.hand.Bytes()
  	n := int(data[1])<<16 | int(data[2])<<8 | int(data[3])
  	if n > maxHandshake {
  		c.sendAlertLocked(alertInternalError)
  		return nil, c.in.setErrorLocked(fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshake))
  	}
  	for c.hand.Len() < 4+n {
  		if err := c.in.err; err != nil {
  			return nil, err
  		}
  		if err := c.readRecord(recordTypeHandshake); err != nil {
  			return nil, err
  		}
  	}
  	data = c.hand.Next(4 + n)
  	var m handshakeMessage
  	switch data[0] {
  	case typeHelloRequest:
  		m = new(helloRequestMsg)
  	case typeClientHello:
  		m = new(clientHelloMsg)
  	case typeServerHello:
  		m = new(serverHelloMsg)
  	case typeNewSessionTicket:
  		m = new(newSessionTicketMsg)
  	case typeCertificate:
  		m = new(certificateMsg)
  	case typeCertificateRequest:
  		m = &certificateRequestMsg{
  			hasSignatureAndHash: c.vers >= VersionTLS12,
  		}
  	case typeCertificateStatus:
  		m = new(certificateStatusMsg)
  	case typeServerKeyExchange:
  		m = new(serverKeyExchangeMsg)
  	case typeServerHelloDone:
  		m = new(serverHelloDoneMsg)
  	case typeClientKeyExchange:
  		m = new(clientKeyExchangeMsg)
  	case typeCertificateVerify:
  		m = &certificateVerifyMsg{
  			hasSignatureAndHash: c.vers >= VersionTLS12,
  		}
  	case typeNextProtocol:
  		m = new(nextProtoMsg)
  	case typeFinished:
  		m = new(finishedMsg)
  	default:
  		return nil, c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
  	}
  
  	// The handshake message unmarshalers
  	// expect to be able to keep references to data,
  	// so pass in a fresh copy that won't be overwritten.
  	data = append([]byte(nil), data...)
  
  	if !m.unmarshal(data) {
  		return nil, c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
  	}
  	return m, nil
  }
  
  var (
  	errClosed   = errors.New("tls: use of closed connection")
  	errShutdown = errors.New("tls: protocol is shutdown")
  )
  
  // Write writes data to the connection.
  func (c *Conn) Write(b []byte) (int, error) {
  	// interlock with Close below
  	for {
  		x := atomic.LoadInt32(&c.activeCall)
  		if x&1 != 0 {
  			return 0, errClosed
  		}
  		if atomic.CompareAndSwapInt32(&c.activeCall, x, x+2) {
  			defer atomic.AddInt32(&c.activeCall, -2)
  			break
  		}
  	}
  
  	if err := c.Handshake(); err != nil {
  		return 0, err
  	}
  
  	c.out.Lock()
  	defer c.out.Unlock()
  
  	if err := c.out.err; err != nil {
  		return 0, err
  	}
  
  	if !c.handshakeComplete {
  		return 0, alertInternalError
  	}
  
  	if c.closeNotifySent {
  		return 0, errShutdown
  	}
  
  	// SSL 3.0 and TLS 1.0 are susceptible to a chosen-plaintext
  	// attack when using block mode ciphers due to predictable IVs.
  	// This can be prevented by splitting each Application Data
  	// record into two records, effectively randomizing the IV.
  	//
  	// http://www.openssl.org/~bodo/tls-cbc.txt
  	// https://bugzilla.mozilla.org/show_bug.cgi?id=665814
  	// http://www.imperialviolet.org/2012/01/15/beastfollowup.html
  
  	var m int
  	if len(b) > 1 && c.vers <= VersionTLS10 {
  		if _, ok := c.out.cipher.(cipher.BlockMode); ok {
  			n, err := c.writeRecordLocked(recordTypeApplicationData, b[:1])
  			if err != nil {
  				return n, c.out.setErrorLocked(err)
  			}
  			m, b = 1, b[1:]
  		}
  	}
  
  	n, err := c.writeRecordLocked(recordTypeApplicationData, b)
  	return n + m, c.out.setErrorLocked(err)
  }
  
  // handleRenegotiation processes a HelloRequest handshake message.
  // c.in.Mutex <= L
  func (c *Conn) handleRenegotiation() error {
  	msg, err := c.readHandshake()
  	if err != nil {
  		return err
  	}
  
  	_, ok := msg.(*helloRequestMsg)
  	if !ok {
  		c.sendAlert(alertUnexpectedMessage)
  		return alertUnexpectedMessage
  	}
  
  	if !c.isClient {
  		return c.sendAlert(alertNoRenegotiation)
  	}
  
  	switch c.config.Renegotiation {
  	case RenegotiateNever:
  		return c.sendAlert(alertNoRenegotiation)
  	case RenegotiateOnceAsClient:
  		if c.handshakes > 1 {
  			return c.sendAlert(alertNoRenegotiation)
  		}
  	case RenegotiateFreelyAsClient:
  		// Ok.
  	default:
  		c.sendAlert(alertInternalError)
  		return errors.New("tls: unknown Renegotiation value")
  	}
  
  	c.handshakeMutex.Lock()
  	defer c.handshakeMutex.Unlock()
  
  	c.handshakeComplete = false
  	if c.handshakeErr = c.clientHandshake(); c.handshakeErr == nil {
  		c.handshakes++
  	}
  	return c.handshakeErr
  }
  
  // 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 (c *Conn) Read(b []byte) (n int, err error) {
  	if err = c.Handshake(); err != nil {
  		return
  	}
  	if len(b) == 0 {
  		// Put this after Handshake, in case people were calling
  		// Read(nil) for the side effect of the Handshake.
  		return
  	}
  
  	c.in.Lock()
  	defer c.in.Unlock()
  
  	// Some OpenSSL servers send empty records in order to randomize the
  	// CBC IV. So this loop ignores a limited number of empty records.
  	const maxConsecutiveEmptyRecords = 100
  	for emptyRecordCount := 0; emptyRecordCount <= maxConsecutiveEmptyRecords; emptyRecordCount++ {
  		for c.input == nil && c.in.err == nil {
  			if err := c.readRecord(recordTypeApplicationData); err != nil {
  				// Soft error, like EAGAIN
  				return 0, err
  			}
  			if c.hand.Len() > 0 {
  				// We received handshake bytes, indicating the
  				// start of a renegotiation.
  				if err := c.handleRenegotiation(); err != nil {
  					return 0, err
  				}
  			}
  		}
  		if err := c.in.err; err != nil {
  			return 0, err
  		}
  
  		n, err = c.input.Read(b)
  		if c.input.off >= len(c.input.data) {
  			c.in.freeBlock(c.input)
  			c.input = nil
  		}
  
  		// If a close-notify alert is waiting, read it so that
  		// we can return (n, EOF) instead of (n, nil), to signal
  		// to the HTTP response reading goroutine that the
  		// connection is now closed. This eliminates a race
  		// where the HTTP response reading goroutine would
  		// otherwise not observe the EOF until its next read,
  		// by which time a client goroutine might have already
  		// tried to reuse the HTTP connection for a new
  		// request.
  		// See https://codereview.appspot.com/76400046
  		// and https://golang.org/issue/3514
  		if ri := c.rawInput; ri != nil &&
  			n != 0 && err == nil &&
  			c.input == nil && len(ri.data) > 0 && recordType(ri.data[0]) == recordTypeAlert {
  			if recErr := c.readRecord(recordTypeApplicationData); recErr != nil {
  				err = recErr // will be io.EOF on closeNotify
  			}
  		}
  
  		if n != 0 || err != nil {
  			return n, err
  		}
  	}
  
  	return 0, io.ErrNoProgress
  }
  
  // Close closes the connection.
  func (c *Conn) Close() error {
  	// Interlock with Conn.Write above.
  	var x int32
  	for {
  		x = atomic.LoadInt32(&c.activeCall)
  		if x&1 != 0 {
  			return errClosed
  		}
  		if atomic.CompareAndSwapInt32(&c.activeCall, x, x|1) {
  			break
  		}
  	}
  	if x != 0 {
  		// io.Writer and io.Closer should not be used concurrently.
  		// If Close is called while a Write is currently in-flight,
  		// interpret that as a sign that this Close is really just
  		// being used to break the Write and/or clean up resources and
  		// avoid sending the alertCloseNotify, which may block
  		// waiting on handshakeMutex or the c.out mutex.
  		return c.conn.Close()
  	}
  
  	var alertErr error
  
  	c.handshakeMutex.Lock()
  	defer c.handshakeMutex.Unlock()
  	if c.handshakeComplete {
  		alertErr = c.closeNotify()
  	}
  
  	if err := c.conn.Close(); err != nil {
  		return err
  	}
  	return alertErr
  }
  
  var errEarlyCloseWrite = errors.New("tls: CloseWrite called before handshake complete")
  
  // 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 (c *Conn) CloseWrite() error {
  	c.handshakeMutex.Lock()
  	defer c.handshakeMutex.Unlock()
  	if !c.handshakeComplete {
  		return errEarlyCloseWrite
  	}
  
  	return c.closeNotify()
  }
  
  func (c *Conn) closeNotify() error {
  	c.out.Lock()
  	defer c.out.Unlock()
  
  	if !c.closeNotifySent {
  		c.closeNotifyErr = c.sendAlertLocked(alertCloseNotify)
  		c.closeNotifySent = true
  	}
  	return c.closeNotifyErr
  }
  
  // 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 (c *Conn) Handshake() error {
  	// c.handshakeErr and c.handshakeComplete are protected by
  	// c.handshakeMutex. In order to perform a handshake, we need to lock
  	// c.in also and c.handshakeMutex must be locked after c.in.
  	//
  	// However, if a Read() operation is hanging then it'll be holding the
  	// lock on c.in and so taking it here would cause all operations that
  	// need to check whether a handshake is pending (such as Write) to
  	// block.
  	//
  	// Thus we first take c.handshakeMutex to check whether a handshake is
  	// needed.
  	//
  	// If so then, previously, this code would unlock handshakeMutex and
  	// then lock c.in and handshakeMutex in the correct order to run the
  	// handshake. The problem was that it was possible for a Read to
  	// complete the handshake once handshakeMutex was unlocked and then
  	// keep c.in while waiting for network data. Thus a concurrent
  	// operation could be blocked on c.in.
  	//
  	// Thus handshakeCond is used to signal that a goroutine is committed
  	// to running the handshake and other goroutines can wait on it if they
  	// need. handshakeCond is protected by handshakeMutex.
  	c.handshakeMutex.Lock()
  	defer c.handshakeMutex.Unlock()
  
  	for {
  		if err := c.handshakeErr; err != nil {
  			return err
  		}
  		if c.handshakeComplete {
  			return nil
  		}
  		if c.handshakeCond == nil {
  			break
  		}
  
  		c.handshakeCond.Wait()
  	}
  
  	// Set handshakeCond to indicate that this goroutine is committing to
  	// running the handshake.
  	c.handshakeCond = sync.NewCond(&c.handshakeMutex)
  	c.handshakeMutex.Unlock()
  
  	c.in.Lock()
  	defer c.in.Unlock()
  
  	c.handshakeMutex.Lock()
  
  	// The handshake cannot have completed when handshakeMutex was unlocked
  	// because this goroutine set handshakeCond.
  	if c.handshakeErr != nil || c.handshakeComplete {
  		panic("handshake should not have been able to complete after handshakeCond was set")
  	}
  
  	if c.isClient {
  		c.handshakeErr = c.clientHandshake()
  	} else {
  		c.handshakeErr = c.serverHandshake()
  	}
  	if c.handshakeErr == nil {
  		c.handshakes++
  	} else {
  		// If an error occurred during the hadshake try to flush the
  		// alert that might be left in the buffer.
  		c.flush()
  	}
  
  	if c.handshakeErr == nil && !c.handshakeComplete {
  		panic("handshake should have had a result.")
  	}
  
  	// Wake any other goroutines that are waiting for this handshake to
  	// complete.
  	c.handshakeCond.Broadcast()
  	c.handshakeCond = nil
  
  	return c.handshakeErr
  }
  
  // ConnectionState returns basic TLS details about the connection.
  func (c *Conn) ConnectionState() ConnectionState {
  	c.handshakeMutex.Lock()
  	defer c.handshakeMutex.Unlock()
  
  	var state ConnectionState
  	state.HandshakeComplete = c.handshakeComplete
  	state.ServerName = c.serverName
  
  	if c.handshakeComplete {
  		state.Version = c.vers
  		state.NegotiatedProtocol = c.clientProtocol
  		state.DidResume = c.didResume
  		state.NegotiatedProtocolIsMutual = !c.clientProtocolFallback
  		state.CipherSuite = c.cipherSuite
  		state.PeerCertificates = c.peerCertificates
  		state.VerifiedChains = c.verifiedChains
  		state.SignedCertificateTimestamps = c.scts
  		state.OCSPResponse = c.ocspResponse
  		if !c.didResume {
  			if c.clientFinishedIsFirst {
  				state.TLSUnique = c.clientFinished[:]
  			} else {
  				state.TLSUnique = c.serverFinished[:]
  			}
  		}
  	}
  
  	return state
  }
  
  // OCSPResponse returns the stapled OCSP response from the TLS server, if
  // any. (Only valid for client connections.)
  func (c *Conn) OCSPResponse() []byte {
  	c.handshakeMutex.Lock()
  	defer c.handshakeMutex.Unlock()
  
  	return c.ocspResponse
  }
  
  // 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 (c *Conn) VerifyHostname(host string) error {
  	c.handshakeMutex.Lock()
  	defer c.handshakeMutex.Unlock()
  	if !c.isClient {
  		return errors.New("tls: VerifyHostname called on TLS server connection")
  	}
  	if !c.handshakeComplete {
  		return errors.New("tls: handshake has not yet been performed")
  	}
  	if len(c.verifiedChains) == 0 {
  		return errors.New("tls: handshake did not verify certificate chain")
  	}
  	return c.peerCertificates[0].VerifyHostname(host)
  }
  

View as plain text