src/pkg/crypto/tls/record_process.go - go - Git at Google

 // 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

 // A recordProcessor accepts reassembled records, decrypts and verifies them
 // and routes them either to the handshake processor, to up to the application.
 // It also accepts requests from the application for the current connection
 // state, or for a notification when the state changes.

 import (
 	"container/list"
 	"crypto/subtle"
 	"hash"
 )

 // getConnectionState is a request from the application to get the current
 // ConnectionState.
 type getConnectionState struct {
 	reply chan<- ConnectionState
 }

 // waitConnectionState is a request from the application to be notified when
 // the connection state changes.
 type waitConnectionState struct {
 	reply chan<- ConnectionState
 }

 // connectionStateChange is a message from the handshake processor that the
 // connection state has changed.
 type connectionStateChange struct {
 	connState ConnectionState
 }

 // changeCipherSpec is a message send to the handshake processor to signal that
 // the peer is switching ciphers.
 type changeCipherSpec struct{}

 // newCipherSpec is a message from the handshake processor that future
 // records should be processed with a new cipher and MAC function.
 type newCipherSpec struct {
 	encrypt encryptor
 	mac     hash.Hash
 }

 type recordProcessor struct {
 	decrypt       encryptor
 	mac           hash.Hash
 	seqNum        uint64
 	handshakeBuf  []byte
 	appDataChan   chan<- []byte
 	requestChan   <-chan interface{}
 	controlChan   <-chan interface{}
 	recordChan    <-chan *record
 	handshakeChan chan<- interface{}

 	// recordRead is nil when we don't wish to read any more.
 	recordRead <-chan *record
 	// appDataSend is nil when len(appData) == 0.
 	appDataSend chan<- []byte
 	// appData contains any application data queued for upstream.
 	appData []byte
 	// A list of channels waiting for connState to change.
 	waitQueue *list.List
 	connState ConnectionState
 	shutdown  bool
 	header    [13]byte
 }

 // drainRequestChannel processes messages from the request channel until it's closed.
 func drainRequestChannel(requestChan <-chan interface{}, c ConnectionState) {
 	for v := range requestChan {
 		if closed(requestChan) {
 			return
 		}
 		switch r := v.(type) {
 		case getConnectionState:
 			r.reply <- c
 		case waitConnectionState:
 			r.reply <- c
 		}
 	}
 }

 func (p *recordProcessor) loop(appDataChan chan<- []byte, requestChan <-chan interface{}, controlChan <-chan interface{}, recordChan <-chan *record, handshakeChan chan<- interface{}) {
 	noop := nop{}
 	p.decrypt = noop
 	p.mac = noop
 	p.waitQueue = list.New()

 	p.appDataChan = appDataChan
 	p.requestChan = requestChan
 	p.controlChan = controlChan
 	p.recordChan = recordChan
 	p.handshakeChan = handshakeChan
 	p.recordRead = recordChan

 	for !p.shutdown {
 		select {
 		case p.appDataSend <- p.appData:
 			p.appData = nil
 			p.appDataSend = nil
 			p.recordRead = p.recordChan
 		case c := <-controlChan:
 			p.processControlMsg(c)
 		case r := <-requestChan:
 			p.processRequestMsg(r)
 		case r := <-p.recordRead:
 			p.processRecord(r)
 		}
 	}

 	p.wakeWaiters()
 	go drainRequestChannel(p.requestChan, p.connState)
 	go func() {
 		for _ = range controlChan {
 		}
 	}()

 	close(handshakeChan)
 	if len(p.appData) > 0 {
 		appDataChan <- p.appData
 	}
 	close(appDataChan)
 }

 func (p *recordProcessor) processRequestMsg(requestMsg interface{}) {
 	if closed(p.requestChan) {
 		p.shutdown = true
 		return
 	}

 	switch r := requestMsg.(type) {
 	case getConnectionState:
 		r.reply <- p.connState
 	case waitConnectionState:
 		if p.connState.HandshakeComplete {
 			r.reply <- p.connState
 		}
 		p.waitQueue.PushBack(r.reply)
 	}
 }

 func (p *recordProcessor) processControlMsg(msg interface{}) {
 	connState, ok := msg.(ConnectionState)
 	if !ok || closed(p.controlChan) {
 		p.shutdown = true
 		return
 	}

 	p.connState = connState
 	p.wakeWaiters()
 }

 func (p *recordProcessor) wakeWaiters() {
 	for i := p.waitQueue.Front(); i != nil; i = i.Next() {
 		i.Value.(chan<- ConnectionState) <- p.connState
 	}
 	p.waitQueue.Init()
 }

 func (p *recordProcessor) processRecord(r *record) {
 	if closed(p.recordChan) {
 		p.shutdown = true
 		return
 	}

 	p.decrypt.XORKeyStream(r.payload)
 	if len(r.payload) < p.mac.Size() {
 		p.error(alertBadRecordMAC)
 		return
 	}

 	fillMACHeader(&p.header, p.seqNum, len(r.payload)-p.mac.Size(), r)
 	p.seqNum++

 	p.mac.Reset()
 	p.mac.Write(p.header[0:13])
 	p.mac.Write(r.payload[0 : len(r.payload)-p.mac.Size()])
 	macBytes := p.mac.Sum()

 	if subtle.ConstantTimeCompare(macBytes, r.payload[len(r.payload)-p.mac.Size():]) != 1 {
 		p.error(alertBadRecordMAC)
 		return
 	}

 	switch r.contentType {
 	case recordTypeHandshake:
 		p.processHandshakeRecord(r.payload[0 : len(r.payload)-p.mac.Size()])
 	case recordTypeChangeCipherSpec:
 		if len(r.payload) != 1 || r.payload[0] != 1 {
 			p.error(alertUnexpectedMessage)
 			return
 		}

 		p.handshakeChan <- changeCipherSpec{}
 		newSpec, ok := (<-p.controlChan).(*newCipherSpec)
 		if !ok {
 			p.connState.Error = alertUnexpectedMessage
 			p.shutdown = true
 			return
 		}
 		p.decrypt = newSpec.encrypt
 		p.mac = newSpec.mac
 		p.seqNum = 0
 	case recordTypeApplicationData:
 		if p.connState.HandshakeComplete == false {
 			p.error(alertUnexpectedMessage)
 			return
 		}
 		p.recordRead = nil
 		p.appData = r.payload[0 : len(r.payload)-p.mac.Size()]
 		p.appDataSend = p.appDataChan
 	default:
 		p.error(alertUnexpectedMessage)
 		return
 	}
 }

 func (p *recordProcessor) processHandshakeRecord(data []byte) {
 	if p.handshakeBuf == nil {
 		p.handshakeBuf = data
 	} else {
 		if len(p.handshakeBuf) > maxHandshakeMsg {
 			p.error(alertInternalError)
 			return
 		}
 		newBuf := make([]byte, len(p.handshakeBuf)+len(data))
 		copy(newBuf, p.handshakeBuf)
 		copy(newBuf[len(p.handshakeBuf):], data)
 		p.handshakeBuf = newBuf
 	}

 	for len(p.handshakeBuf) >= 4 {
 		handshakeLen := int(p.handshakeBuf[1])<<16 |
 			int(p.handshakeBuf[2])<<8 |
 			int(p.handshakeBuf[3])
 		if handshakeLen+4 > len(p.handshakeBuf) {
 			break
 		}

 		bytes := p.handshakeBuf[0 : handshakeLen+4]
 		p.handshakeBuf = p.handshakeBuf[handshakeLen+4:]
 		if bytes[0] == typeFinished {
 			// Special case because Finished is synchronous: the
 			// handshake handler has to tell us if it's ok to start
 			// forwarding application data.
 			m := new(finishedMsg)
 			if !m.unmarshal(bytes) {
 				p.error(alertUnexpectedMessage)
 			}
 			p.handshakeChan <- m
 			var ok bool
 			p.connState, ok = (<-p.controlChan).(ConnectionState)
 			if !ok || p.connState.Error != 0 {
 				p.shutdown = true
 				return
 			}
 		} else {
 			msg, ok := parseHandshakeMsg(bytes)
 			if !ok {
 				p.error(alertUnexpectedMessage)
 				return
 			}
 			p.handshakeChan <- msg
 		}
 	}
 }

 func (p *recordProcessor) error(err alertType) {
 	close(p.handshakeChan)
 	p.connState.Error = err
 	p.wakeWaiters()
 	p.shutdown = true
 }

 func parseHandshakeMsg(data []byte) (interface{}, bool) {
 	var m interface {
 		unmarshal([]byte) bool
 	}

 	switch data[0] {
 	case typeClientHello:
 		m = new(clientHelloMsg)
 	case typeServerHello:
 		m = new(serverHelloMsg)
 	case typeCertificate:
 		m = new(certificateMsg)
 	case typeServerHelloDone:
 		m = new(serverHelloDoneMsg)
 	case typeClientKeyExchange:
 		m = new(clientKeyExchangeMsg)
 	case typeNextProtocol:
 		m = new(nextProtoMsg)
 	default:
 		return nil, false
 	}

 	ok := m.unmarshal(data)
 	return m, ok
 }
	// 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

	// A recordProcessor accepts reassembled records, decrypts and verifies them
	// and routes them either to the handshake processor, to up to the application.
	// It also accepts requests from the application for the current connection
	// state, or for a notification when the state changes.

	import (
	"container/list"
	"crypto/subtle"
	"hash"
	)

	// getConnectionState is a request from the application to get the current
	// ConnectionState.
	type getConnectionState struct {
	reply chan<- ConnectionState
	}

	// waitConnectionState is a request from the application to be notified when
	// the connection state changes.
	type waitConnectionState struct {
	reply chan<- ConnectionState
	}

	// connectionStateChange is a message from the handshake processor that the
	// connection state has changed.
	type connectionStateChange struct {
	connState ConnectionState
	}

	// changeCipherSpec is a message send to the handshake processor to signal that
	// the peer is switching ciphers.
	type changeCipherSpec struct{}

	// newCipherSpec is a message from the handshake processor that future
	// records should be processed with a new cipher and MAC function.
	type newCipherSpec struct {
	encrypt encryptor
	mac hash.Hash
	}

	type recordProcessor struct {
	decrypt encryptor
	mac hash.Hash
	seqNum uint64
	handshakeBuf []byte
	appDataChan chan<- []byte
	requestChan <-chan interface{}
	controlChan <-chan interface{}
	recordChan <-chan *record
	handshakeChan chan<- interface{}

	// recordRead is nil when we don't wish to read any more.
	recordRead <-chan *record
	// appDataSend is nil when len(appData) == 0.
	appDataSend chan<- []byte
	// appData contains any application data queued for upstream.
	appData []byte
	// A list of channels waiting for connState to change.
	waitQueue *list.List
	connState ConnectionState
	shutdown bool
	header [13]byte
	}

	// drainRequestChannel processes messages from the request channel until it's closed.
	func drainRequestChannel(requestChan <-chan interface{}, c ConnectionState) {
	for v := range requestChan {
	if closed(requestChan) {
	return
	}
	switch r := v.(type) {
	case getConnectionState:
	r.reply <- c
	case waitConnectionState:
	r.reply <- c
	}
	}
	}

	func (p recordProcessor) loop(appDataChan chan<- []byte, requestChan <-chan interface{}, controlChan <-chan interface{}, recordChan <-chan record, handshakeChan chan<- interface{}) {
	noop := nop{}
	p.decrypt = noop
	p.mac = noop
	p.waitQueue = list.New()

	p.appDataChan = appDataChan
	p.requestChan = requestChan
	p.controlChan = controlChan
	p.recordChan = recordChan
	p.handshakeChan = handshakeChan
	p.recordRead = recordChan

	for !p.shutdown {
	select {
	case p.appDataSend <- p.appData:
	p.appData = nil
	p.appDataSend = nil
	p.recordRead = p.recordChan
	case c := <-controlChan:
	p.processControlMsg(c)
	case r := <-requestChan:
	p.processRequestMsg(r)
	case r := <-p.recordRead:
	p.processRecord(r)
	}
	}

	p.wakeWaiters()
	go drainRequestChannel(p.requestChan, p.connState)
	go func() {
	for _ = range controlChan {
	}
	}()

	close(handshakeChan)
	if len(p.appData) > 0 {
	appDataChan <- p.appData
	}
	close(appDataChan)
	}

	func (p *recordProcessor) processRequestMsg(requestMsg interface{}) {
	if closed(p.requestChan) {
	p.shutdown = true
	return
	}

	switch r := requestMsg.(type) {
	case getConnectionState:
	r.reply <- p.connState
	case waitConnectionState:
	if p.connState.HandshakeComplete {
	r.reply <- p.connState
	}
	p.waitQueue.PushBack(r.reply)
	}
	}

	func (p *recordProcessor) processControlMsg(msg interface{}) {
	connState, ok := msg.(ConnectionState)
	if !ok \|\| closed(p.controlChan) {
	p.shutdown = true
	return
	}

	p.connState = connState
	p.wakeWaiters()
	}

	func (p *recordProcessor) wakeWaiters() {
	for i := p.waitQueue.Front(); i != nil; i = i.Next() {
	i.Value.(chan<- ConnectionState) <- p.connState
	}
	p.waitQueue.Init()
	}

	func (p recordProcessor) processRecord(r record) {
	if closed(p.recordChan) {
	p.shutdown = true
	return
	}

	p.decrypt.XORKeyStream(r.payload)
	if len(r.payload) < p.mac.Size() {
	p.error(alertBadRecordMAC)
	return
	}

	fillMACHeader(&p.header, p.seqNum, len(r.payload)-p.mac.Size(), r)
	p.seqNum++

	p.mac.Reset()
	p.mac.Write(p.header[0:13])
	p.mac.Write(r.payload[0 : len(r.payload)-p.mac.Size()])
	macBytes := p.mac.Sum()

	if subtle.ConstantTimeCompare(macBytes, r.payload[len(r.payload)-p.mac.Size():]) != 1 {
	p.error(alertBadRecordMAC)
	return
	}

	switch r.contentType {
	case recordTypeHandshake:
	p.processHandshakeRecord(r.payload[0 : len(r.payload)-p.mac.Size()])
	case recordTypeChangeCipherSpec:
	if len(r.payload) != 1 \|\| r.payload[0] != 1 {
	p.error(alertUnexpectedMessage)
	return
	}

	p.handshakeChan <- changeCipherSpec{}
	newSpec, ok := (<-p.controlChan).(*newCipherSpec)
	if !ok {
	p.connState.Error = alertUnexpectedMessage
	p.shutdown = true
	return
	}
	p.decrypt = newSpec.encrypt
	p.mac = newSpec.mac
	p.seqNum = 0
	case recordTypeApplicationData:
	if p.connState.HandshakeComplete == false {
	p.error(alertUnexpectedMessage)
	return
	}
	p.recordRead = nil
	p.appData = r.payload[0 : len(r.payload)-p.mac.Size()]
	p.appDataSend = p.appDataChan
	default:
	p.error(alertUnexpectedMessage)
	return
	}
	}

	func (p *recordProcessor) processHandshakeRecord(data []byte) {
	if p.handshakeBuf == nil {
	p.handshakeBuf = data
	} else {
	if len(p.handshakeBuf) > maxHandshakeMsg {
	p.error(alertInternalError)
	return
	}
	newBuf := make([]byte, len(p.handshakeBuf)+len(data))
	copy(newBuf, p.handshakeBuf)
	copy(newBuf[len(p.handshakeBuf):], data)
	p.handshakeBuf = newBuf
	}

	for len(p.handshakeBuf) >= 4 {
	handshakeLen := int(p.handshakeBuf[1])<<16 \|
	int(p.handshakeBuf[2])<<8 \|
	int(p.handshakeBuf[3])
	if handshakeLen+4 > len(p.handshakeBuf) {
	break
	}

	bytes := p.handshakeBuf[0 : handshakeLen+4]
	p.handshakeBuf = p.handshakeBuf[handshakeLen+4:]
	if bytes[0] == typeFinished {
	// Special case because Finished is synchronous: the
	// handshake handler has to tell us if it's ok to start
	// forwarding application data.
	m := new(finishedMsg)
	if !m.unmarshal(bytes) {
	p.error(alertUnexpectedMessage)
	}
	p.handshakeChan <- m
	var ok bool
	p.connState, ok = (<-p.controlChan).(ConnectionState)
	if !ok \|\| p.connState.Error != 0 {
	p.shutdown = true
	return
	}
	} else {
	msg, ok := parseHandshakeMsg(bytes)
	if !ok {
	p.error(alertUnexpectedMessage)
	return
	}
	p.handshakeChan <- msg
	}
	}
	}

	func (p *recordProcessor) error(err alertType) {
	close(p.handshakeChan)
	p.connState.Error = err
	p.wakeWaiters()
	p.shutdown = true
	}

	func parseHandshakeMsg(data []byte) (interface{}, bool) {
	var m interface {
	unmarshal([]byte) bool
	}

	switch data[0] {
	case typeClientHello:
	m = new(clientHelloMsg)
	case typeServerHello:
	m = new(serverHelloMsg)
	case typeCertificate:
	m = new(certificateMsg)
	case typeServerHelloDone:
	m = new(serverHelloDoneMsg)
	case typeClientKeyExchange:
	m = new(clientKeyExchangeMsg)
	case typeNextProtocol:
	m = new(nextProtoMsg)
	default:
	return nil, false
	}

	ok := m.unmarshal(data)
	return m, ok
	}