aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-lc/ssl/test/runner/handshake_server.go

@@ -20,6 +20,7 @@ import (
 	"time"
 
 	"boringssl.googlesource.com/boringssl/ssl/test/runner/hpke"
+	"golang.org/x/crypto/cryptobyte"
 )
 
 // serverHandshakeState contains details of a server handshake in progress.
@@ -2435,18 +2436,18 @@ func checkClientHellosEqual(a, b []byte, isDTLS bool, ignoreExtensions []uint16)
 	}
 
 	// Skip the handshake message header.
-	aReader := byteReader(a[4:])
-	bReader := byteReader(b[4:])
+	aReader := cryptobyte.String(a[4:])
+	bReader := cryptobyte.String(b[4:])
 
 	var aVers, bVers uint16
 	var aRandom, bRandom []byte
 	var aSessionID, bSessionID []byte
-	if !aReader.readU16(&aVers) ||
-		!bReader.readU16(&bVers) ||
-		!aReader.readBytes(&aRandom, 32) ||
-		!bReader.readBytes(&bRandom, 32) ||
-		!aReader.readU8LengthPrefixedBytes(&aSessionID) ||
-		!bReader.readU8LengthPrefixedBytes(&bSessionID) {
+	if !aReader.ReadUint16(&aVers) ||
+		!bReader.ReadUint16(&bVers) ||
+		!aReader.ReadBytes(&aRandom, 32) ||
+		!bReader.ReadBytes(&bRandom, 32) ||
+		!readUint8LengthPrefixedBytes(&aReader, &aSessionID) ||
+		!readUint8LengthPrefixedBytes(&bReader, &bSessionID) {
 		return errors.New("tls: could not parse ClientHello")
 	}
 
@@ -2466,17 +2467,17 @@ func checkClientHellosEqual(a, b []byte, isDTLS bool, ignoreExtensions []uint16)
 		// cookie altogether. If we implement DTLS 1.3, we'll need to ensure
 		// that parsing logic above this function rejects this cookie.
 		var aCookie, bCookie []byte
-		if !aReader.readU8LengthPrefixedBytes(&aCookie) ||
-			!bReader.readU8LengthPrefixedBytes(&bCookie) {
+		if !readUint8LengthPrefixedBytes(&aReader, &aCookie) ||
+			!readUint8LengthPrefixedBytes(&bReader, &bCookie) {
 			return errors.New("tls: could not parse ClientHello")
 		}
 	}
 
 	var aCipherSuites, bCipherSuites, aCompressionMethods, bCompressionMethods []byte
-	if !aReader.readU16LengthPrefixedBytes(&aCipherSuites) ||
-		!bReader.readU16LengthPrefixedBytes(&bCipherSuites) ||
-		!aReader.readU8LengthPrefixedBytes(&aCompressionMethods) ||
-		!bReader.readU8LengthPrefixedBytes(&bCompressionMethods) {
+	if !readUint16LengthPrefixedBytes(&aReader, &aCipherSuites) ||
+		!readUint16LengthPrefixedBytes(&bReader, &bCipherSuites) ||
+		!readUint8LengthPrefixedBytes(&aReader, &aCompressionMethods) ||
+		!readUint8LengthPrefixedBytes(&bReader, &bCompressionMethods) {
 		return errors.New("tls: could not parse ClientHello")
 	}
 	if !bytes.Equal(aCipherSuites, bCipherSuites) {
@@ -2491,9 +2492,9 @@ func checkClientHellosEqual(a, b []byte, isDTLS bool, ignoreExtensions []uint16)
 		return nil
 	}
 
-	var aExtensions, bExtensions byteReader
-	if !aReader.readU16LengthPrefixed(&aExtensions) ||
-		!bReader.readU16LengthPrefixed(&bExtensions) ||
+	var aExtensions, bExtensions cryptobyte.String
+	if !aReader.ReadUint16LengthPrefixed(&aExtensions) ||
+		!bReader.ReadUint16LengthPrefixed(&bExtensions) ||
 		len(aReader) != 0 ||
 		len(bReader) != 0 {
 		return errors.New("tls: could not parse ClientHello")
@@ -2502,8 +2503,8 @@ func checkClientHellosEqual(a, b []byte, isDTLS bool, ignoreExtensions []uint16)
 	for len(aExtensions) != 0 {
 		var aID uint16
 		var aBody []byte
-		if !aExtensions.readU16(&aID) ||
-			!aExtensions.readU16LengthPrefixedBytes(&aBody) {
+		if !aExtensions.ReadUint16(&aID) ||
+			!readUint16LengthPrefixedBytes(&aExtensions, &aBody) {
 			return errors.New("tls: could not parse ClientHello")
 		}
 		if _, ok := ignoreExtensionsSet[aID]; ok {
@@ -2516,8 +2517,8 @@ func checkClientHellosEqual(a, b []byte, isDTLS bool, ignoreExtensions []uint16)
 			}
 			var bID uint16
 			var bBody []byte
-			if !bExtensions.readU16(&bID) ||
-				!bExtensions.readU16LengthPrefixedBytes(&bBody) {
+			if !bExtensions.ReadUint16(&bID) ||
+				!readUint16LengthPrefixedBytes(&bExtensions, &bBody) {
 				return errors.New("tls: could not parse ClientHello")
 			}
 			if _, ok := ignoreExtensionsSet[bID]; ok {
@@ -2538,8 +2539,8 @@ func checkClientHellosEqual(a, b []byte, isDTLS bool, ignoreExtensions []uint16)
 	for len(bExtensions) != 0 {
 		var id uint16
 		var body []byte
-		if !bExtensions.readU16(&id) ||
-			!bExtensions.readU16LengthPrefixedBytes(&body) {
+		if !bExtensions.ReadUint16(&id) ||
+			!readUint16LengthPrefixedBytes(&bExtensions, &body) {
 			return errors.New("tls: could not parse ClientHello")
 		}
 		if _, ok := ignoreExtensionsSet[id]; !ok {

data/aws-crt-ffi/crt/aws-lc/ssl/test/runner/prf.go

@@ -13,6 +13,7 @@ import (
 	"encoding"
 	"hash"
 
+	"golang.org/x/crypto/cryptobyte"
 	"golang.org/x/crypto/hkdf"
 )
 
@@ -228,15 +229,15 @@ type finishedHash struct {
 }
 
 func (h *finishedHash) UpdateForHelloRetryRequest() {
-	data := newByteBuilder()
-	data.addU8(typeMessageHash)
-	data.addU24(h.hash.Size())
-	data.addBytes(h.Sum())
+	data := cryptobyte.NewBuilder(nil)
+	data.AddUint8(typeMessageHash)
+	data.AddUint24(uint32(h.hash.Size()))
+	data.AddBytes(h.Sum())
 	h.hash = h.suite.hash().New()
 	if h.buffer != nil {
 		h.buffer = []byte{}
 	}
-	h.Write(data.finish())
+	h.Write(data.BytesOrPanic())
 }
 
 func (h *finishedHash) Write(msg []byte) (n int, err error) {

data/aws-crt-ffi/crt/aws-lc/ssl/test/runner/runner.go

@@ -48,6 +48,7 @@ import (
 	"boringssl.googlesource.com/boringssl/ssl/test/runner/hpke"
 	"boringssl.googlesource.com/boringssl/ssl/test/runner/ssl_transfer"
 	"boringssl.googlesource.com/boringssl/util/testresult"
+	"golang.org/x/crypto/cryptobyte"
 )
 
 var (
@@ -860,10 +861,10 @@ func doExchange(test *testCase, config *Config, conn net.Conn, isResume bool, tr
 				if err := os.MkdirAll(dir, 0755); err != nil {
 					return err
 				}
-				bb := newByteBuilder()
-				bb.addU24LengthPrefixed().addBytes(encodedInner)
-				bb.addBytes(outer)
-				return os.WriteFile(filepath.Join(dir, name), bb.finish(), 0644)
+				bb := cryptobyte.NewBuilder(nil)
+				addUint24LengthPrefixedBytes(bb, encodedInner)
+				bb.AddBytes(outer)
+				return os.WriteFile(filepath.Join(dir, name), bb.BytesOrPanic(), 0644)
 			}
 		}
 
@@ -1289,9 +1290,12 @@ var (
 )
 
 type shimProcess struct {
-	cmd            *exec.Cmd
-	waitChan       chan error
-	listener       *net.TCPListener
+	cmd *exec.Cmd
+	// done is closed when the process has exited. At that point, childErr may be
+	// read for the result.
+	done           chan struct{}
+	childErr       error
+	listener       *shimListener
 	stdout, stderr bytes.Buffer
 	// default value is false.
 	// This is marked as true in |(s *shimProcess) wait()|.
@@ -1301,28 +1305,32 @@ type shimProcess struct {
 // newShimProcess starts a new shim with the specified executable, flags, and
 // environment. It internally creates a TCP listener and adds the the -port
 // flag.
-func newShimProcess(shimPath string, flags []string, env []string) (*shimProcess, error) {
-	shim := new(shimProcess)
-	var err error
-	shim.listener, err = net.ListenTCP("tcp", &net.TCPAddr{IP: net.IPv6loopback})
-	if err != nil {
-		shim.listener, err = net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IP{127, 0, 0, 1}})
-	}
+func newShimProcess(dispatcher *shimDispatcher, shimPath string, flags []string, env []string) (*shimProcess, error) {
+	listener, err := dispatcher.NewShim()
 	if err != nil {
 		return nil, err
 	}
 
-	flags = append([]string{"-port", strconv.Itoa(shim.listener.Addr().(*net.TCPAddr).Port)}, flags...)
+	shim := &shimProcess{listener: listener}
+	cmdFlags := []string{
+		"-port", strconv.Itoa(listener.Port()),
+		"-shim-id", strconv.FormatUint(listener.ShimID(), 10),
+	}
+	if listener.IsIPv6() {
+		cmdFlags = append(cmdFlags, "-ipv6")
+	}
+	cmdFlags = append(cmdFlags, flags...)
+
 	if *useValgrind {
-		shim.cmd = valgrindOf(false, shimPath, flags...)
+		shim.cmd = valgrindOf(false, shimPath, cmdFlags...)
 	} else if *useGDB {
-		shim.cmd = gdbOf(shimPath, flags...)
+		shim.cmd = gdbOf(shimPath, cmdFlags...)
 	} else if *useLLDB {
-		shim.cmd = lldbOf(shimPath, flags...)
+		shim.cmd = lldbOf(shimPath, cmdFlags...)
 	} else if *useRR {
-		shim.cmd = rrOf(shimPath, flags...)
+		shim.cmd = rrOf(shimPath, cmdFlags...)
 	} else {
-		shim.cmd = exec.Command(shimPath, flags...)
+		shim.cmd = exec.Command(shimPath, cmdFlags...)
 	}
 	shim.cmd.Stdin = os.Stdin
 	shim.cmd.Stdout = &shim.stdout
@@ -1334,37 +1342,24 @@ func newShimProcess(shimPath string, flags []string, env []string) (*shimProcess
 		return nil, err
 	}
 	shim.idled = false
-	shim.waitChan = make(chan error, 1)
-	go func() { shim.waitChan <- shim.cmd.Wait() }()
+
+	shim.done = make(chan struct{})
+	go func() {
+		shim.childErr = shim.cmd.Wait()
+		shim.listener.Close()
+		close(shim.done)
+	}()
 	return shim, nil
 }
 
 // accept returns a new TCP connection with the shim process, or returns an
 // error on timeout or shim exit.
 func (s *shimProcess) accept() (net.Conn, error) {
-	type connOrError struct {
-		conn net.Conn
-		err  error
-	}
-	connChan := make(chan connOrError, 1)
-	go func() {
-		if !useDebugger() {
-			s.listener.SetDeadline(time.Now().Add(*idleTimeout))
-		}
-		conn, err := s.listener.Accept()
-		connChan <- connOrError{conn, err}
-		close(connChan)
-	}()
-	select {
-	case result := <-connChan:
-		return result.conn, result.err
-	case childErr := <-s.waitChan:
-		s.waitChan <- childErr
-		if childErr == nil {
-			return nil, fmt.Errorf("child exited early with no error")
-		}
-		return nil, fmt.Errorf("child exited early: %s", childErr)
+	var deadline time.Time
+	if !useDebugger() {
+		deadline = time.Now().Add(*idleTimeout)
 	}
+	return s.listener.Accept(deadline)
 }
 
 // wait finishes the test and waits for the shim process to exit.
@@ -1387,9 +1382,8 @@ func (s *shimProcess) wait() error {
 		defer waitTimeout.Stop()
 	}
 
-	err := <-s.waitChan
-	s.waitChan <- err
-	return err
+	<-s.done
+	return s.childErr
 }
 
 // close releases resources associated with the shimProcess. This is safe to
@@ -1479,7 +1473,7 @@ const shimInitialWrite = "hello"
 // the test name is renamed with (|test.name| + |SSL_TRANSFER_SUFFIX|).
 const SSL_TRANSFER_SUFFIX = "-SSL_Transfer"
 
-func runTest(statusChan chan statusMsg, test *testCase, shimPath string, mallocNumToFail int64) error {
+func runTest(dispatcher *shimDispatcher, statusChan chan statusMsg, test *testCase, shimPath string, mallocNumToFail int64) error {
 	// Help debugging panics on the Go side.
 	defer func() {
 		if r := recover(); r != nil {
@@ -1690,7 +1684,7 @@ func runTest(statusChan chan statusMsg, test *testCase, shimPath string, mallocN
 		env = append(env, "_MALLOC_CHECK=1")
 	}
 
-	shim, err := newShimProcess(shimPath, flags, env)
+	shim, err := newShimProcess(dispatcher, shimPath, flags, env)
 	if err != nil {
 		return err
 	}
@@ -1703,7 +1697,7 @@ func runTest(statusChan chan statusMsg, test *testCase, shimPath string, mallocN
 	// shim is marked as idled only when |idleTimeout| is reached.
 	// This retry fix is scoped with "InvalidChannelIDSignature-TLS13-TLS-Sync-SplitHandshakeRecords".
 	if shim.idled && test.name == "InvalidChannelIDSignature-TLS13-TLS-Sync-SplitHandshakeRecords" {
-		shim, err = newShimProcess(shimPath, flags, env)
+		shim, err := newShimProcess(dispatcher, shimPath, flags, env)
 		if err != nil {
 			return err
 		}
@@ -19840,7 +19834,7 @@ func addMultipleCertSlotTests() {
 	}
 }
 
-func worker(statusChan chan statusMsg, c chan *testCase, shimPath string, wg *sync.WaitGroup) {
+func worker(dispatcher *shimDispatcher, statusChan chan statusMsg, c chan *testCase, shimPath string, wg *sync.WaitGroup) {
 	defer wg.Done()
 
 	for test := range c {
@@ -19849,7 +19843,7 @@ func worker(statusChan chan statusMsg, c chan *testCase, shimPath string, wg *sy
 		if *mallocTest >= 0 {
 			for mallocNumToFail := int64(*mallocTest); ; mallocNumToFail++ {
 				statusChan <- statusMsg{test: test, statusType: statusStarted}
-				if err = runTest(statusChan, test, shimPath, mallocNumToFail); err != errMoreMallocs {
+				if err = runTest(dispatcher, statusChan, test, shimPath, mallocNumToFail); err != errMoreMallocs {
 					if err != nil {
 						fmt.Printf("\n\nmalloc test failed at %d: %s\n", mallocNumToFail, err)
 					}
@@ -19859,11 +19853,11 @@ func worker(statusChan chan statusMsg, c chan *testCase, shimPath string, wg *sy
 		} else if *repeatUntilFailure {
 			for err == nil {
 				statusChan <- statusMsg{test: test, statusType: statusStarted}
-				err = runTest(statusChan, test, shimPath, -1)
+				err = runTest(dispatcher, statusChan, test, shimPath, -1)
 			}
 		} else {
 			statusChan <- statusMsg{test: test, statusType: statusStarted}
-			err = runTest(statusChan, test, shimPath, -1)
+			err = runTest(dispatcher, statusChan, test, shimPath, -1)
 		}
 		statusChan <- statusMsg{test: test, statusType: statusDone, err: err}
 	}
@@ -20197,6 +20191,13 @@ func main() {
 
 	checkTests()
 
+	dispatcher, err := newShimDispatcher()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error opening socket: %s", err)
+		os.Exit(1)
+	}
+	defer dispatcher.Close()
+
 	numWorkers := *numWorkersFlag
 	if useDebugger() {
 		numWorkers = 1
@@ -20211,7 +20212,7 @@ func main() {
 	var wg sync.WaitGroup
 	for i := 0; i < numWorkers; i++ {
 		wg.Add(1)
-		go worker(statusChan, testChan, *shimPath, &wg)
+		go worker(dispatcher, statusChan, testChan, *shimPath, &wg)
 	}
 
 	var oneOfPatternIfAny, noneOfPattern []string

data/aws-crt-ffi/crt/aws-lc/ssl/test/runner/shim_dispatcher.go

@@ -0,0 +1,188 @@
+// Copyright (c) 2023, Google Inc.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+package runner
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"sync"
+	"time"
+)
+
+type shimDispatcher struct {
+	lock       sync.Mutex
+	nextShimID uint64
+	listener   *net.TCPListener
+	shims      map[uint64]*shimListener
+	err        error
+}
+
+func newShimDispatcher() (*shimDispatcher, error) {
+	listener, err := net.ListenTCP("tcp", &net.TCPAddr{IP: net.IPv6loopback})
+	if err != nil {
+		listener, err = net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IP{127, 0, 0, 1}})
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	d := &shimDispatcher{listener: listener, shims: make(map[uint64]*shimListener)}
+	go d.acceptLoop()
+	return d, nil
+}
+
+func (d *shimDispatcher) NewShim() (*shimListener, error) {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+	if d.err != nil {
+		return nil, d.err
+	}
+
+	l := &shimListener{dispatcher: d, shimID: d.nextShimID, connChan: make(chan net.Conn, 1)}
+	d.shims[l.shimID] = l
+	d.nextShimID++
+	return l, nil
+}
+
+func (d *shimDispatcher) unregisterShim(l *shimListener) {
+	d.lock.Lock()
+	delete(d.shims, l.shimID)
+	d.lock.Unlock()
+}
+
+func (d *shimDispatcher) acceptLoop() {
+	for {
+		conn, err := d.listener.Accept()
+		if err != nil {
+			// Something went wrong. Shut down the listener.
+			d.closeWithError(err)
+			return
+		}
+
+		go func() {
+			if err := d.dispatch(conn); err != nil {
+				// To be robust against port scanners, etc., we log a warning
+				// but otherwise treat undispatchable connections as non-fatal.
+				fmt.Fprintf(os.Stderr, "Error dispatching connection: %s\n", err)
+				conn.Close()
+			}
+		}()
+	}
+}
+
+func (d *shimDispatcher) dispatch(conn net.Conn) error {
+	conn.SetReadDeadline(time.Now().Add(*idleTimeout))
+	var buf [8]byte
+	if _, err := io.ReadFull(conn, buf[:]); err != nil {
+		return err
+	}
+	conn.SetReadDeadline(time.Time{})
+
+	shimID := binary.LittleEndian.Uint64(buf[:])
+	d.lock.Lock()
+	shim, ok := d.shims[shimID]
+	d.lock.Unlock()
+	if !ok {
+		return fmt.Errorf("shim ID %d not found", shimID)
+	}
+
+	shim.connChan <- conn
+	return nil
+}
+
+func (d *shimDispatcher) Close() error {
+	return d.closeWithError(net.ErrClosed)
+}
+
+func (d *shimDispatcher) closeWithError(err error) error {
+	closeErr := d.listener.Close()
+
+	d.lock.Lock()
+	shims := d.shims
+	d.shims = make(map[uint64]*shimListener)
+	d.err = err
+	d.lock.Unlock()
+
+	for _, shim := range shims {
+		shim.closeWithError(err)
+	}
+	return closeErr
+}
+
+type shimListener struct {
+	dispatcher *shimDispatcher
+	shimID     uint64
+	// connChan contains connections from the dispatcher. On fatal error, it is
+	// closed, with the error available in err.
+	connChan chan net.Conn
+	err      error
+	lock     sync.Mutex
+}
+
+func (l *shimListener) Port() int {
+	return l.dispatcher.listener.Addr().(*net.TCPAddr).Port
+}
+
+func (l *shimListener) IsIPv6() bool {
+	return len(l.dispatcher.listener.Addr().(*net.TCPAddr).IP) == net.IPv6len
+}
+
+func (l *shimListener) ShimID() uint64 {
+	return l.shimID
+}
+
+func (l *shimListener) Close() error {
+	l.dispatcher.unregisterShim(l)
+	l.closeWithError(net.ErrClosed)
+	return nil
+}
+
+func (l *shimListener) closeWithError(err error) {
+	// Multiple threads may close the listener at once, so protect closing with
+	// a lock.
+	l.lock.Lock()
+	if l.err == nil {
+		l.err = err
+		close(l.connChan)
+	}
+	l.lock.Unlock()
+}
+
+func (l *shimListener) Accept(deadline time.Time) (net.Conn, error) {
+	var timerChan <-chan time.Time
+	if !deadline.IsZero() {
+		remaining := time.Until(deadline)
+		if remaining < 0 {
+			return nil, context.DeadlineExceeded
+		}
+		timer := time.NewTimer(remaining)
+		defer timer.Stop()
+		timerChan = timer.C
+	}
+
+	select {
+	case <-timerChan:
+		return nil, context.DeadlineExceeded
+	case conn, ok := <-l.connChan:
+		if !ok {
+			return nil, l.err
+		}
+		return conn, nil
+	}
+}

data/aws-crt-ffi/crt/aws-lc/ssl/test/runner/ticket.go

@@ -13,6 +13,8 @@ import (
 	"errors"
 	"io"
 	"time"
+
+	"golang.org/x/crypto/cryptobyte"
 )
 
 // sessionState contains the information that is serialized into a session
@@ -35,49 +37,45 @@ type sessionState struct {
 }
 
 func (s *sessionState) marshal() []byte {
-	msg := newByteBuilder()
-	msg.addU16(s.vers)
-	msg.addU16(s.cipherSuite)
-	secret := msg.addU16LengthPrefixed()
-	secret.addBytes(s.secret)
-	handshakeHash := msg.addU16LengthPrefixed()
-	handshakeHash.addBytes(s.handshakeHash)
-	msg.addU16(uint16(len(s.certificates)))
+	msg := cryptobyte.NewBuilder(nil)
+	msg.AddUint16(s.vers)
+	msg.AddUint16(s.cipherSuite)
+	addUint16LengthPrefixedBytes(msg, s.secret)
+	addUint16LengthPrefixedBytes(msg, s.handshakeHash)
+	msg.AddUint16(uint16(len(s.certificates)))
 	for _, cert := range s.certificates {
-		certMsg := msg.addU32LengthPrefixed()
-		certMsg.addBytes(cert)
+		addUint24LengthPrefixedBytes(msg, cert)
 	}
 
 	if s.extendedMasterSecret {
-		msg.addU8(1)
+		msg.AddUint8(1)
 	} else {
-		msg.addU8(0)
+		msg.AddUint8(0)
 	}
 
 	if s.vers >= VersionTLS13 {
-		msg.addU64(uint64(s.ticketCreationTime.UnixNano()))
-		msg.addU64(uint64(s.ticketExpiration.UnixNano()))
-		msg.addU32(s.ticketFlags)
-		msg.addU32(s.ticketAgeAdd)
+		msg.AddUint64(uint64(s.ticketCreationTime.UnixNano()))
+		msg.AddUint64(uint64(s.ticketExpiration.UnixNano()))
+		msg.AddUint32(s.ticketFlags)
+		msg.AddUint32(s.ticketAgeAdd)
 	}
 
-	earlyALPN := msg.addU16LengthPrefixed()
-	earlyALPN.addBytes(s.earlyALPN)
+	addUint16LengthPrefixedBytes(msg, s.earlyALPN)
 
 	if s.hasApplicationSettings {
-		msg.addU8(1)
-		msg.addU16LengthPrefixed().addBytes(s.localApplicationSettings)
-		msg.addU16LengthPrefixed().addBytes(s.peerApplicationSettings)
+		msg.AddUint8(1)
+		addUint16LengthPrefixedBytes(msg, s.localApplicationSettings)
+		addUint16LengthPrefixedBytes(msg, s.peerApplicationSettings)
 	} else {
-		msg.addU8(0)
+		msg.AddUint8(0)
 	}
 
-	return msg.finish()
+	return msg.BytesOrPanic()
 }
 
-func readBool(reader *byteReader, out *bool) bool {
+func readBool(reader *cryptobyte.String, out *bool) bool {
 	var value uint8
-	if !reader.readU8(&value) {
+	if !reader.ReadUint8(&value) {
 		return false
 	}
 	if value == 0 {
@@ -92,19 +90,19 @@ func readBool(reader *byteReader, out *bool) bool {
 }
 
 func (s *sessionState) unmarshal(data []byte) bool {
-	reader := byteReader(data)
+	reader := cryptobyte.String(data)
 	var numCerts uint16
-	if !reader.readU16(&s.vers) ||
-		!reader.readU16(&s.cipherSuite) ||
-		!reader.readU16LengthPrefixedBytes(&s.secret) ||
-		!reader.readU16LengthPrefixedBytes(&s.handshakeHash) ||
-		!reader.readU16(&numCerts) {
+	if !reader.ReadUint16(&s.vers) ||
+		!reader.ReadUint16(&s.cipherSuite) ||
+		!readUint16LengthPrefixedBytes(&reader, &s.secret) ||
+		!readUint16LengthPrefixedBytes(&reader, &s.handshakeHash) ||
+		!reader.ReadUint16(&numCerts) {
 		return false
 	}
 
 	s.certificates = make([][]byte, int(numCerts))
 	for i := range s.certificates {
-		if !reader.readU32LengthPrefixedBytes(&s.certificates[i]) {
+		if !readUint24LengthPrefixedBytes(&reader, &s.certificates[i]) {
 			return false
 		}
 	}
@@ -115,24 +113,24 @@ func (s *sessionState) unmarshal(data []byte) bool {
 
 	if s.vers >= VersionTLS13 {
 		var ticketCreationTime, ticketExpiration uint64
-		if !reader.readU64(&ticketCreationTime) ||
-			!reader.readU64(&ticketExpiration) ||
-			!reader.readU32(&s.ticketFlags) ||
-			!reader.readU32(&s.ticketAgeAdd) {
+		if !reader.ReadUint64(&ticketCreationTime) ||
+			!reader.ReadUint64(&ticketExpiration) ||
+			!reader.ReadUint32(&s.ticketFlags) ||
+			!reader.ReadUint32(&s.ticketAgeAdd) {
 			return false
 		}
 		s.ticketCreationTime = time.Unix(0, int64(ticketCreationTime))
 		s.ticketExpiration = time.Unix(0, int64(ticketExpiration))
 	}
 
-	if !reader.readU16LengthPrefixedBytes(&s.earlyALPN) ||
+	if !readUint16LengthPrefixedBytes(&reader, &s.earlyALPN) ||
 		!readBool(&reader, &s.hasApplicationSettings) {
 		return false
 	}
 
 	if s.hasApplicationSettings {
-		if !reader.readU16LengthPrefixedBytes(&s.localApplicationSettings) ||
-			!reader.readU16LengthPrefixedBytes(&s.peerApplicationSettings) {
+		if !readUint16LengthPrefixedBytes(&reader, &s.localApplicationSettings) ||
+			!readUint16LengthPrefixedBytes(&reader, &s.peerApplicationSettings) {
 			return false
 		}
 	}