src/pkg/crypto/tls/record_write.go

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

import (
	"fmt";
	"hash";
	"io";
)

// writerEnableApplicationData is a message which instructs recordWriter to
// start reading and transmitting data from the application data channel.
type writerEnableApplicationData struct{}

// writerChangeCipherSpec updates the encryption and MAC functions and resets
// the sequence count.
type writerChangeCipherSpec struct {
	encryptor	encryptor;
	mac		hash.Hash;
}

// writerSetVersion sets the version number bytes that we included in the
// record header for future records.
type writerSetVersion struct {
	major, minor uint8;
}

// A recordWriter accepts messages from the handshake processor and
// application data. It writes them to the outgoing connection and blocks on
// writing. It doesn't read from the application data channel until the
// handshake processor has signaled that the handshake is complete.
type recordWriter struct {
	writer		io.Writer;
	encryptor	encryptor;
	mac		hash.Hash;
	seqNum		uint64;
	major, minor	uint8;
	shutdown	bool;
	appChan		<-chan []byte;
	controlChan	<-chan interface{};
	header		[13]byte;
}

func (w *recordWriter) loop(writer io.Writer, appChan <-chan []byte, controlChan <-chan interface{}) {
	w.writer = writer;
	w.encryptor = nop{};
	w.mac = nop{};
	w.appChan = appChan;
	w.controlChan = controlChan;

	for !w.shutdown {
		msg := <-controlChan;
		if _, ok := msg.(writerEnableApplicationData); ok {
			break
		}
		w.processControlMessage(msg);
	}

	for !w.shutdown {
		// Always process control messages first.
		if controlMsg, ok := <-controlChan; ok {
			w.processControlMessage(controlMsg);
			continue;
		}

		select {
		case controlMsg := <-controlChan:
			w.processControlMessage(controlMsg)
		case appMsg := <-appChan:
			w.processAppMessage(appMsg)
		}
	}

	if !closed(appChan) {
		go func() {
			for _ = range appChan {
			}
		}()
	}
	if !closed(controlChan) {
		go func() {
			for _ = range controlChan {
			}
		}()
	}
}

// fillMACHeader generates a MAC header. See RFC 4346, section 6.2.3.1.
func fillMACHeader(header *[13]byte, seqNum uint64, length int, r *record) {
	header[0] = uint8(seqNum >> 56);
	header[1] = uint8(seqNum >> 48);
	header[2] = uint8(seqNum >> 40);
	header[3] = uint8(seqNum >> 32);
	header[4] = uint8(seqNum >> 24);
	header[5] = uint8(seqNum >> 16);
	header[6] = uint8(seqNum >> 8);
	header[7] = uint8(seqNum);
	header[8] = uint8(r.contentType);
	header[9] = r.major;
	header[10] = r.minor;
	header[11] = uint8(length >> 8);
	header[12] = uint8(length);
}

func (w *recordWriter) writeRecord(r *record) {
	w.mac.Reset();

	fillMACHeader(&w.header, w.seqNum, len(r.payload), r);

	w.mac.Write(w.header[0:13]);
	w.mac.Write(r.payload);
	macBytes := w.mac.Sum();

	w.encryptor.XORKeyStream(r.payload);
	w.encryptor.XORKeyStream(macBytes);

	length := len(r.payload) + len(macBytes);
	w.header[11] = uint8(length >> 8);
	w.header[12] = uint8(length);
	w.writer.Write(w.header[8:13]);
	w.writer.Write(r.payload);
	w.writer.Write(macBytes);

	w.seqNum++;
}

func (w *recordWriter) processControlMessage(controlMsg interface{}) {
	if controlMsg == nil {
		w.shutdown = true;
		return;
	}

	switch msg := controlMsg.(type) {
	case writerChangeCipherSpec:
		w.writeRecord(&record{recordTypeChangeCipherSpec, w.major, w.minor, []byte{0x01}});
		w.encryptor = msg.encryptor;
		w.mac = msg.mac;
		w.seqNum = 0;
	case writerSetVersion:
		w.major = msg.major;
		w.minor = msg.minor;
	case alert:
		w.writeRecord(&record{recordTypeAlert, w.major, w.minor, []byte{byte(msg.level), byte(msg.error)}})
	case handshakeMessage:
		// TODO(agl): marshal may return a slice too large for a single record.
		w.writeRecord(&record{recordTypeHandshake, w.major, w.minor, msg.marshal()})
	default:
		fmt.Printf("processControlMessage: unknown %#v\n", msg)
	}
}

func (w *recordWriter) processAppMessage(appMsg []byte) {
	if closed(w.appChan) {
		w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, []byte{byte(alertCloseNotify)}});
		w.shutdown = true;
		return;
	}

	var done int;
	for done < len(appMsg) {
		todo := len(appMsg);
		if todo > maxTLSPlaintext {
			todo = maxTLSPlaintext
		}
		w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, appMsg[done : done+todo]});
		done += todo;
	}
}