Skip to contentSkip to conversation

go: fix CVE-2022-41724, 41725

PATCH In review Joe Slater 2 participants 3 messages Apr 12, 2023 – Apr 13, 2023

lore
Share & tools
lore

Joe Slater

author
#0 lore raw

PATCH 1/1 go: fix CVE-2022-41724, 41725

Backport from go-1.19. The godebug package is needed by the fix to CVE-2022-41725.

Mostly a cherry-pick but exceptions are noted in comments marked "backport".

---
 ...01-go-fix-CVE-2022-41723-41724-41725.patch | 3373 +++++++++++++++++
 meta/recipes-devtools/go/go-1.17.13.inc       |    5 +-
 .../go/go-1.19/add_godebug.patch              |   84 +
 .../go/go-1.19/cve-2022-41724.patch           | 2391 ++++++++++++
 .../go/go-1.19/cve-2022-41725.patch           |  652 ++++
 5 files changed, 6504 insertions(+), 1 deletion(-)
 create mode 100644 meta/recipes-devtools/go/0001-go-fix-CVE-2022-41723-41724-41725.patch
 create mode 100644 meta/recipes-devtools/go/go-1.19/add_godebug.patch
 create mode 100644 meta/recipes-devtools/go/go-1.19/cve-2022-41724.patch
 create mode 100644 meta/recipes-devtools/go/go-1.19/cve-2022-41725.patch
meta/recipes-devtools/go/0001-go-fix-CVE-2022-41723-41724-41725.patch new file +3373 -0
new file mode 100644
index 0000000000..6be48ef11c
@@ -0,0 +1,3373 @@
+From e59535bbee31a45d871708cfa01f03df7f3a5564 Mon Sep 17 00:00:00 2001
+From: Joe Slater <[email protected]>
+Date: Fri, 7 Apr 2023 16:42:19 -0700
+Subject: [PATCH] go: fix CVE-2022-41723, 41724, 41725
+
+Issue: LIN1022-3364 LIN1022-3196 LIN1022-3195
+
+Backport from go-1.19.  The godebug package is needed by
+the fix to CVE-2022-41725.
+
+(LOCAL REV: NOT UPSTREAM) -- pending submission
+
+Signed-off-by: Joe Slater <[email protected]>
+---
+ meta/recipes-devtools/go/go-1.17.13.inc       |    6 +-
+ .../go/go-1.19/add_godebug.patch              |   84 +
+ .../go/go-1.19/cve-2022-41723.patch           |  171 ++
+ .../go/go-1.19/cve-2022-41724.patch           | 2391 +++++++++++++++++
+ .../go/go-1.19/cve-2022-41725.patch           |  652 +++++
+ 5 files changed, 3303 insertions(+), 1 deletion(-)
+ create mode 100644 meta/recipes-devtools/go/go-1.19/add_godebug.patch
+ create mode 100644 meta/recipes-devtools/go/go-1.19/cve-2022-41723.patch
+ create mode 100644 meta/recipes-devtools/go/go-1.19/cve-2022-41724.patch
+ create mode 100644 meta/recipes-devtools/go/go-1.19/cve-2022-41725.patch
+
+diff --git a/meta/recipes-devtools/go/go-1.17.13.inc b/meta/recipes-devtools/go/go-1.17.13.inc
+index a6081bdee7..7b08c50502 100644
+--- a/meta/recipes-devtools/go/go-1.17.13.inc
++++ b/meta/recipes-devtools/go/go-1.17.13.inc
+@@ -1,6 +1,6 @@
+ require go-common.inc
+ 
+-FILESEXTRAPATHS:prepend := "${FILE_DIRNAME}/go-1.18:"
++FILESEXTRAPATHS:prepend := "${FILE_DIRNAME}/go-1.19:${FILE_DIRNAME}/go-1.18:"
+ 
+ LIC_FILES_CHKSUM = "file://LICENSE;md5=5d4950ecb7b26d2c5e4e7b4e0dd74707"
+ 
+@@ -22,6 +22,10 @@ SRC_URI += "\
+     file://CVE-2022-41717.patch \
+     file://0001-archive-tar-limit-size-of-headers.patch \
+     file://0002-os-net-http-avoid-escapes-from-os.DirFS-and-http.Dir.patch \
++    file://cve-2022-41723.patch \
++    file://cve-2022-41724.patch \
++    file://add_godebug.patch \
++    file://cve-2022-41725.patch \
+ "
+ SRC_URI[main.sha256sum] = "a1a48b23afb206f95e7bbaa9b898d965f90826f6f1d1fc0c1d784ada0cd300fd"
+ 
+diff --git a/meta/recipes-devtools/go/go-1.19/add_godebug.patch b/meta/recipes-devtools/go/go-1.19/add_godebug.patch
+new file mode 100644
+index 0000000000..0c3d2d2855
+--- /dev/null
++++ b/meta/recipes-devtools/go/go-1.19/add_godebug.patch
+@@ -0,0 +1,84 @@
++
++Upstream-Status: Backport [see text]
++
++https://github.com/golong/go.git as of commit 22c1d18a27...
++Copy src/internal/godebug from go 1.19 since it does not
++exist in 1.17.
++
++Signed-off-by: Joe Slater <[email protected]>
++---
++
++--- /dev/null
+++++ go/src/internal/godebug/godebug.go
++@@ -0,0 +1,34 @@
+++// Copyright 2021 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 godebug parses the GODEBUG environment variable.
+++package godebug
+++
+++import "os"
+++
+++// Get returns the value for the provided GODEBUG key.
+++func Get(key string) string {
+++	return get(os.Getenv("GODEBUG"), key)
+++}
+++
+++// get returns the value part of key=value in s (a GODEBUG value).
+++func get(s, key string) string {
+++	for i := 0; i < len(s)-len(key)-1; i++ {
+++		if i > 0 && s[i-1] != ',' {
+++			continue
+++		}
+++		afterKey := s[i+len(key):]
+++		if afterKey[0] != '=' || s[i:i+len(key)] != key {
+++			continue
+++		}
+++		val := afterKey[1:]
+++		for i, b := range val {
+++			if b == ',' {
+++				return val[:i]
+++			}
+++		}
+++		return val
+++	}
+++	return ""
+++}
++--- /dev/null
+++++ go/src/internal/godebug/godebug_test.go
++@@ -0,0 +1,34 @@
+++// Copyright 2021 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 godebug
+++
+++import "testing"
+++
+++func TestGet(t *testing.T) {
+++	tests := []struct {
+++		godebug string
+++		key     string
+++		want    string
+++	}{
+++		{"", "", ""},
+++		{"", "foo", ""},
+++		{"foo=bar", "foo", "bar"},
+++		{"foo=bar,after=x", "foo", "bar"},
+++		{"before=x,foo=bar,after=x", "foo", "bar"},
+++		{"before=x,foo=bar", "foo", "bar"},
+++		{",,,foo=bar,,,", "foo", "bar"},
+++		{"foodecoy=wrong,foo=bar", "foo", "bar"},
+++		{"foo=", "foo", ""},
+++		{"foo", "foo", ""},
+++		{",foo", "foo", ""},
+++		{"foo=bar,baz", "loooooooong", ""},
+++	}
+++	for _, tt := range tests {
+++		got := get(tt.godebug, tt.key)
+++		if got != tt.want {
+++			t.Errorf("get(%q, %q) = %q; want %q", tt.godebug, tt.key, got, tt.want)
+++		}
+++	}
+++}
+diff --git a/meta/recipes-devtools/go/go-1.19/cve-2022-41723.patch b/meta/recipes-devtools/go/go-1.19/cve-2022-41723.patch
+new file mode 100644
+index 0000000000..05adf8daab
+--- /dev/null
++++ b/meta/recipes-devtools/go/go-1.19/cve-2022-41723.patch
+@@ -0,0 +1,171 @@
++From 5c3e11bd0b5c0a86e5beffcd4339b86a902b21c3 Mon Sep 17 00:00:00 2001
++From: Roland Shoemaker <[email protected]>
++Date: Mon, 6 Feb 2023 10:03:44 -0800
++Subject: [PATCH] [release-branch.go1.19] net/http: update bundled golang.org/x/net/http2
++
++Disable cmd/internal/moddeps test, since this update includes PRIVATE
++track fixes.
++
++Fixes CVE-2022-41723
++Fixes #58355
++Updates #57855
++
++Change-Id: Ie870562a6f6e44e4e8f57db6a0dde1a41a2b090c
++Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1728939
++Reviewed-by: Damien Neil <[email protected]>
++Reviewed-by: Julie Qiu <[email protected]>
++Reviewed-by: Tatiana Bradley <[email protected]>
++Run-TryBot: Roland Shoemaker <[email protected]>
++Reviewed-on: https://go-review.googlesource.com/c/go/+/468118
++TryBot-Result: Gopher Robot <[email protected]>
++Run-TryBot: Michael Pratt <[email protected]>
++Auto-Submit: Michael Pratt <[email protected]>
++Reviewed-by: Than McIntosh <[email protected]>
++---
++
++CVE: CVE-2022-41723
++
++Upstream-Status: Backport [see text]
++
++https://github.com/golong/go.git commit 5c3e11bd0...
++minor context change for moddeps_test.go
++
++Signed-off-by: Joe Slater <[email protected]>
++---
++ src/cmd/internal/moddeps/moddeps_test.go      |  2 +-
++ .../golang.org/x/net/http2/hpack/hpack.go     | 79 ++++++++++++-------
++ 2 files changed, 50 insertions(+), 31 deletions(-)
++
++--- go.orig/src/cmd/internal/moddeps/moddeps_test.go
+++++ go/src/cmd/internal/moddeps/moddeps_test.go
++@@ -34,8 +34,7 @@ import (
++ // See issues 36852, 41409, and 43687.
++ // (Also see golang.org/issue/27348.)
++ func TestAllDependencies(t *testing.T) {
++-	t.Skip("TODO(#57009): 1.19.4 contains unreleased changes from vendored modules")
++-	t.Skip("TODO(#53977): 1.18.5 contains unreleased changes from vendored modules")
+++	t.Skip("TODO(#58335): 1.19.4 contains unreleased changes from vendored modules")
++ 
++ 	goBin := testenv.GoToolPath(t)
++ 
++--- go.orig/src/vendor/golang.org/x/net/http2/hpack/hpack.go
+++++ go/src/vendor/golang.org/x/net/http2/hpack/hpack.go
++@@ -359,6 +359,7 @@ func (d *Decoder) parseFieldLiteral(n ui
++ 
++ 	var hf HeaderField
++ 	wantStr := d.emitEnabled || it.indexed()
+++	var undecodedName undecodedString
++ 	if nameIdx > 0 {
++ 		ihf, ok := d.at(nameIdx)
++ 		if !ok {
++@@ -366,15 +367,27 @@ func (d *Decoder) parseFieldLiteral(n ui
++ 		}
++ 		hf.Name = ihf.Name
++ 	} else {
++-		hf.Name, buf, err = d.readString(buf, wantStr)
+++		undecodedName, buf, err = d.readString(buf)
++ 		if err != nil {
++ 			return err
++ 		}
++ 	}
++-	hf.Value, buf, err = d.readString(buf, wantStr)
+++	undecodedValue, buf, err := d.readString(buf)
++ 	if err != nil {
++ 		return err
++ 	}
+++	if wantStr {
+++		if nameIdx <= 0 {
+++			hf.Name, err = d.decodeString(undecodedName)
+++			if err != nil {
+++				return err
+++			}
+++		}
+++		hf.Value, err = d.decodeString(undecodedValue)
+++		if err != nil {
+++			return err
+++		}
+++	}
++ 	d.buf = buf
++ 	if it.indexed() {
++ 		d.dynTab.add(hf)
++@@ -459,46 +472,52 @@ func readVarInt(n byte, p []byte) (i uin
++ 	return 0, origP, errNeedMore
++ }
++ 
++-// readString decodes an hpack string from p.
+++// readString reads an hpack string from p.
++ //
++-// wantStr is whether s will be used. If false, decompression and
++-// []byte->string garbage are skipped if s will be ignored
++-// anyway. This does mean that huffman decoding errors for non-indexed
++-// strings past the MAX_HEADER_LIST_SIZE are ignored, but the server
++-// is returning an error anyway, and because they're not indexed, the error
++-// won't affect the decoding state.
++-func (d *Decoder) readString(p []byte, wantStr bool) (s string, remain []byte, err error) {
+++// It returns a reference to the encoded string data to permit deferring decode costs
+++// until after the caller verifies all data is present.
+++func (d *Decoder) readString(p []byte) (u undecodedString, remain []byte, err error) {
++ 	if len(p) == 0 {
++-		return "", p, errNeedMore
+++		return u, p, errNeedMore
++ 	}
++ 	isHuff := p[0]&128 != 0
++ 	strLen, p, err := readVarInt(7, p)
++ 	if err != nil {
++-		return "", p, err
+++		return u, p, err
++ 	}
++ 	if d.maxStrLen != 0 && strLen > uint64(d.maxStrLen) {
++-		return "", nil, ErrStringLength
+++		// Returning an error here means Huffman decoding errors
+++		// for non-indexed strings past the maximum string length
+++		// are ignored, but the server is returning an error anyway
+++		// and because the string is not indexed the error will not
+++		// affect the decoding state.
+++		return u, nil, ErrStringLength
++ 	}
++ 	if uint64(len(p)) < strLen {
++-		return "", p, errNeedMore
++-	}
++-	if !isHuff {
++-		if wantStr {
++-			s = string(p[:strLen])
++-		}
++-		return s, p[strLen:], nil
+++		return u, p, errNeedMore
++ 	}
+++	u.isHuff = isHuff
+++	u.b = p[:strLen]
+++	return u, p[strLen:], nil
+++}
++ 
++-	if wantStr {
++-		buf := bufPool.Get().(*bytes.Buffer)
++-		buf.Reset() // don't trust others
++-		defer bufPool.Put(buf)
++-		if err := huffmanDecode(buf, d.maxStrLen, p[:strLen]); err != nil {
++-			buf.Reset()
++-			return "", nil, err
++-		}
+++type undecodedString struct {
+++	isHuff bool
+++	b      []byte
+++}
+++
+++func (d *Decoder) decodeString(u undecodedString) (string, error) {
+++	if !u.isHuff {
+++		return string(u.b), nil
+++	}
+++	buf := bufPool.Get().(*bytes.Buffer)
+++	buf.Reset() // don't trust others
+++	var s string
+++	err := huffmanDecode(buf, d.maxStrLen, u.b)
+++	if err == nil {
++ 		s = buf.String()
++-		buf.Reset() // be nice to GC
++ 	}
++-	return s, p[strLen:], nil
+++	buf.Reset() // be nice to GC
+++	bufPool.Put(buf)
+++	return s, err
++ }
+diff --git a/meta/recipes-devtools/go/go-1.19/cve-2022-41724.patch b/meta/recipes-devtools/go/go-1.19/cve-2022-41724.patch
+new file mode 100644
+index 0000000000..aacffbffcd
+--- /dev/null
++++ b/meta/recipes-devtools/go/go-1.19/cve-2022-41724.patch
+@@ -0,0 +1,2391 @@
++From 00b256e9e3c0fa02a278ec9dfc3e191e02ceaf80 Mon Sep 17 00:00:00 2001
++From: Roland Shoemaker <[email protected]>
++Date: Wed, 14 Dec 2022 09:43:16 -0800
++Subject: [PATCH] [release-branch.go1.19] crypto/tls: replace all usages of
++ BytesOrPanic
++
++Message marshalling makes use of BytesOrPanic a lot, under the
++assumption that it will never panic. This assumption was incorrect, and
++specifically crafted handshakes could trigger panics. Rather than just
++surgically replacing the usages of BytesOrPanic in paths that could
++panic, replace all usages of it with proper error returns in case there
++are other ways of triggering panics which we didn't find.
++
++In one specific case, the tree routed by expandLabel, we replace the
++usage of BytesOrPanic, but retain a panic. This function already
++explicitly panicked elsewhere, and returning an error from it becomes
++rather painful because it requires changing a large number of APIs.
++The marshalling is unlikely to ever panic, as the inputs are all either
++fixed length, or already limited to the sizes required. If it were to
++panic, it'd likely only be during development. A close inspection shows
++no paths for a user to cause a panic currently.
++
++This patches ends up being rather large, since it requires routing
++errors back through functions which previously had no error returns.
++Where possible I've tried to use helpers that reduce the verbosity
++of frequently repeated stanzas, and to make the diffs as minimal as
++possible.
++
++Thanks to Marten Seemann for reporting this issue.
++
++Updates #58001
++Fixes #58358
++Fixes CVE-2022-41724
++
++Change-Id: Ieb55867ef0a3e1e867b33f09421932510cb58851
++Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1679436
++Reviewed-by: Julie Qiu <[email protected]>
++TryBot-Result: Security TryBots <[email protected]>
++Run-TryBot: Roland Shoemaker <[email protected]>
++Reviewed-by: Damien Neil <[email protected]>
++(cherry picked from commit 0f3a44ad7b41cc89efdfad25278953e17d9c1e04)
++Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1728204
++Reviewed-by: Tatiana Bradley <[email protected]>
++Reviewed-on: https://go-review.googlesource.com/c/go/+/468117
++Auto-Submit: Michael Pratt <[email protected]>
++Run-TryBot: Michael Pratt <[email protected]>
++TryBot-Result: Gopher Robot <[email protected]>
++Reviewed-by: Than McIntosh <[email protected]>
++---
++
++CVE: CVE-2022-41724
++
++Upstream-Status: Backport [see text]
++
++https://github.com/golong/go.git commit 00b256e9e3c0fa...
++boring_test.go does not exist
++modified for conn.go and handshake_messages.go
++
++Signed-off-by: Joe Slater <[email protected]>
++
++---
++ src/crypto/tls/boring_test.go             |   2 +-
++ src/crypto/tls/common.go                  |   2 +-
++ src/crypto/tls/conn.go                    |  46 +-
++ src/crypto/tls/handshake_client.go        |  95 +--
++ src/crypto/tls/handshake_client_test.go   |   4 +-
++ src/crypto/tls/handshake_client_tls13.go  |  74 ++-
++ src/crypto/tls/handshake_messages.go      | 716 +++++++++++-----------
++ src/crypto/tls/handshake_messages_test.go |  19 +-
++ src/crypto/tls/handshake_server.go        |  73 ++-
++ src/crypto/tls/handshake_server_test.go   |  31 +-
++ src/crypto/tls/handshake_server_tls13.go  |  71 ++-
++ src/crypto/tls/key_schedule.go            |  19 +-
++ src/crypto/tls/ticket.go                  |   8 +-
++ 13 files changed, 657 insertions(+), 503 deletions(-)
++
++--- go.orig/src/crypto/tls/common.go
+++++ go/src/crypto/tls/common.go
++@@ -1357,7 +1357,7 @@ func (c *Certificate) leaf() (*x509.Cert
++ }
++ 
++ type handshakeMessage interface {
++-	marshal() []byte
+++	marshal() ([]byte, error)
++ 	unmarshal([]byte) bool
++ }
++ 
++--- go.orig/src/crypto/tls/conn.go
+++++ go/src/crypto/tls/conn.go
++@@ -994,18 +994,46 @@ func (c *Conn) writeRecordLocked(typ rec
++ 	return n, nil
++ }
++ 
++-// writeRecord writes a TLS record with the given type and payload to the
++-// connection and updates the record layer state.
++-func (c *Conn) writeRecord(typ recordType, data []byte) (int, error) {
+++// writeHandshakeRecord writes a handshake message to the connection and updates
+++// the record layer state. If transcript is non-nil the marshalled message is
+++// written to it.
+++func (c *Conn) writeHandshakeRecord(msg handshakeMessage, transcript transcriptHash) (int, error) {
++ 	c.out.Lock()
++ 	defer c.out.Unlock()
++ 
++-	return c.writeRecordLocked(typ, data)
+++	data, err := msg.marshal()
+++	if err != nil {
+++		return 0, err
+++	}
+++	if transcript != nil {
+++		transcript.Write(data)
+++	}
+++
+++	return c.writeRecordLocked(recordTypeHandshake, data)
+++}
+++
+++// writeChangeCipherRecord writes a ChangeCipherSpec message to the connection and
+++// updates the record layer state.
+++func (c *Conn) writeChangeCipherRecord() error {
+++	c.out.Lock()
+++	defer c.out.Unlock()
+++	_, err := c.writeRecordLocked(recordTypeChangeCipherSpec, []byte{1})
+++	return err
++ }
++ 
++ // readHandshake reads the next handshake message from
++-// the record layer.
++-func (c *Conn) readHandshake() (interface{}, error) {
+++// the record layer. If transcript is non-nil, the message
+++// is written to the passed transcriptHash.
+++
+++// backport 00b256e9e3c0fa02a278ec9dfc3e191e02ceaf80 
+++//
+++// Commit wants to set this to
+++//
+++// func (c *Conn) readHandshake(transcript transcriptHash) (any, error) {
+++//
+++// but that does not compile.  Retain the original interface{} argument.
+++//
+++func (c *Conn) readHandshake(transcript transcriptHash) (interface{}, error) {
++ 	for c.hand.Len() < 4 {
++ 		if err := c.readRecord(); err != nil {
++ 			return nil, err
++@@ -1084,6 +1112,11 @@ func (c *Conn) readHandshake() (interfac
++ 	if !m.unmarshal(data) {
++ 		return nil, c.in.setErrorLocked(c.sendAlert(alertUnexpectedMessage))
++ 	}
+++
+++	if transcript != nil {
+++		transcript.Write(data)
+++	}
+++
++ 	return m, nil
++ }
++ 
++@@ -1159,7 +1192,7 @@ func (c *Conn) handleRenegotiation() err
++ 		return errors.New("tls: internal error: unexpected renegotiation")
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -1205,7 +1238,7 @@ func (c *Conn) handlePostHandshakeMessag
++ 		return c.handleRenegotiation()
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -1241,7 +1274,11 @@ func (c *Conn) handleKeyUpdate(keyUpdate
++ 		defer c.out.Unlock()
++ 
++ 		msg := &keyUpdateMsg{}
++-		_, err := c.writeRecordLocked(recordTypeHandshake, msg.marshal())
+++		msgBytes, err := msg.marshal()
+++		if err != nil {
+++			return err
+++		}
+++		_, err = c.writeRecordLocked(recordTypeHandshake, msgBytes)
++ 		if err != nil {
++ 			// Surface the error at the next write.
++ 			c.out.setErrorLocked(err)
++--- go.orig/src/crypto/tls/handshake_client.go
+++++ go/src/crypto/tls/handshake_client.go
++@@ -157,7 +157,10 @@ func (c *Conn) clientHandshake(ctx conte
++ 	}
++ 	c.serverName = hello.serverName
++ 
++-	cacheKey, session, earlySecret, binderKey := c.loadSession(hello)
+++	cacheKey, session, earlySecret, binderKey, err := c.loadSession(hello)
+++	if err != nil {
+++		return err
+++	}
++ 	if cacheKey != "" && session != nil {
++ 		defer func() {
++ 			// If we got a handshake failure when resuming a session, throw away
++@@ -172,11 +175,12 @@ func (c *Conn) clientHandshake(ctx conte
++ 		}()
++ 	}
++ 
++-	if _, err := c.writeRecord(recordTypeHandshake, hello.marshal()); err != nil {
+++	if _, err := c.writeHandshakeRecord(hello, nil); err != nil {
++ 		return err
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	// serverHelloMsg is not included in the transcript
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -241,9 +245,9 @@ func (c *Conn) clientHandshake(ctx conte
++ }
++ 
++ func (c *Conn) loadSession(hello *clientHelloMsg) (cacheKey string,
++-	session *ClientSessionState, earlySecret, binderKey []byte) {
+++	session *ClientSessionState, earlySecret, binderKey []byte, err error) {
++ 	if c.config.SessionTicketsDisabled || c.config.ClientSessionCache == nil {
++-		return "", nil, nil, nil
+++		return "", nil, nil, nil, nil
++ 	}
++ 
++ 	hello.ticketSupported = true
++@@ -258,14 +262,14 @@ func (c *Conn) loadSession(hello *client
++ 	// renegotiation is primarily used to allow a client to send a client
++ 	// certificate, which would be skipped if session resumption occurred.
++ 	if c.handshakes != 0 {
++-		return "", nil, nil, nil
+++		return "", nil, nil, nil, nil
++ 	}
++ 
++ 	// Try to resume a previously negotiated TLS session, if available.
++ 	cacheKey = clientSessionCacheKey(c.conn.RemoteAddr(), c.config)
++ 	session, ok := c.config.ClientSessionCache.Get(cacheKey)
++ 	if !ok || session == nil {
++-		return cacheKey, nil, nil, nil
+++		return cacheKey, nil, nil, nil, nil
++ 	}
++ 
++ 	// Check that version used for the previous session is still valid.
++@@ -277,7 +281,7 @@ func (c *Conn) loadSession(hello *client
++ 		}
++ 	}
++ 	if !versOk {
++-		return cacheKey, nil, nil, nil
+++		return cacheKey, nil, nil, nil, nil
++ 	}
++ 
++ 	// Check that the cached server certificate is not expired, and that it's
++@@ -286,16 +290,16 @@ func (c *Conn) loadSession(hello *client
++ 	if !c.config.InsecureSkipVerify {
++ 		if len(session.verifiedChains) == 0 {
++ 			// The original connection had InsecureSkipVerify, while this doesn't.
++-			return cacheKey, nil, nil, nil
+++			return cacheKey, nil, nil, nil, nil
++ 		}
++ 		serverCert := session.serverCertificates[0]
++ 		if c.config.time().After(serverCert.NotAfter) {
++ 			// Expired certificate, delete the entry.
++ 			c.config.ClientSessionCache.Put(cacheKey, nil)
++-			return cacheKey, nil, nil, nil
+++			return cacheKey, nil, nil, nil, nil
++ 		}
++ 		if err := serverCert.VerifyHostname(c.config.ServerName); err != nil {
++-			return cacheKey, nil, nil, nil
+++			return cacheKey, nil, nil, nil, nil
++ 		}
++ 	}
++ 
++@@ -303,7 +307,7 @@ func (c *Conn) loadSession(hello *client
++ 		// In TLS 1.2 the cipher suite must match the resumed session. Ensure we
++ 		// are still offering it.
++ 		if mutualCipherSuite(hello.cipherSuites, session.cipherSuite) == nil {
++-			return cacheKey, nil, nil, nil
+++			return cacheKey, nil, nil, nil, nil
++ 		}
++ 
++ 		hello.sessionTicket = session.sessionTicket
++@@ -313,14 +317,14 @@ func (c *Conn) loadSession(hello *client
++ 	// Check that the session ticket is not expired.
++ 	if c.config.time().After(session.useBy) {
++ 		c.config.ClientSessionCache.Put(cacheKey, nil)
++-		return cacheKey, nil, nil, nil
+++		return cacheKey, nil, nil, nil, nil
++ 	}
++ 
++ 	// In TLS 1.3 the KDF hash must match the resumed session. Ensure we
++ 	// offer at least one cipher suite with that hash.
++ 	cipherSuite := cipherSuiteTLS13ByID(session.cipherSuite)
++ 	if cipherSuite == nil {
++-		return cacheKey, nil, nil, nil
+++		return cacheKey, nil, nil, nil, nil
++ 	}
++ 	cipherSuiteOk := false
++ 	for _, offeredID := range hello.cipherSuites {
++@@ -331,7 +335,7 @@ func (c *Conn) loadSession(hello *client
++ 		}
++ 	}
++ 	if !cipherSuiteOk {
++-		return cacheKey, nil, nil, nil
+++		return cacheKey, nil, nil, nil, nil
++ 	}
++ 
++ 	// Set the pre_shared_key extension. See RFC 8446, Section 4.2.11.1.
++@@ -349,9 +353,15 @@ func (c *Conn) loadSession(hello *client
++ 	earlySecret = cipherSuite.extract(psk, nil)
++ 	binderKey = cipherSuite.deriveSecret(earlySecret, resumptionBinderLabel, nil)
++ 	transcript := cipherSuite.hash.New()
++-	transcript.Write(hello.marshalWithoutBinders())
+++	helloBytes, err := hello.marshalWithoutBinders()
+++	if err != nil {
+++		return "", nil, nil, nil, err
+++	}
+++	transcript.Write(helloBytes)
++ 	pskBinders := [][]byte{cipherSuite.finishedHash(binderKey, transcript)}
++-	hello.updateBinders(pskBinders)
+++	if err := hello.updateBinders(pskBinders); err != nil {
+++		return "", nil, nil, nil, err
+++	}
++ 
++ 	return
++ }
++@@ -396,8 +406,12 @@ func (hs *clientHandshakeState) handshak
++ 		hs.finishedHash.discardHandshakeBuffer()
++ 	}
++ 
++-	hs.finishedHash.Write(hs.hello.marshal())
++-	hs.finishedHash.Write(hs.serverHello.marshal())
+++	if err := transcriptMsg(hs.hello, &hs.finishedHash); err != nil {
+++		return err
+++	}
+++	if err := transcriptMsg(hs.serverHello, &hs.finishedHash); err != nil {
+++		return err
+++	}
++ 
++ 	c.buffering = true
++ 	c.didResume = isResume
++@@ -468,7 +482,7 @@ func (hs *clientHandshakeState) pickCiph
++ func (hs *clientHandshakeState) doFullHandshake() error {
++ 	c := hs.c
++ 
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(&hs.finishedHash)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -477,9 +491,8 @@ func (hs *clientHandshakeState) doFullHa
++ 		c.sendAlert(alertUnexpectedMessage)
++ 		return unexpectedMessageError(certMsg, msg)
++ 	}
++-	hs.finishedHash.Write(certMsg.marshal())
++ 
++-	msg, err = c.readHandshake()
+++	msg, err = c.readHandshake(&hs.finishedHash)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -497,11 +510,10 @@ func (hs *clientHandshakeState) doFullHa
++ 			c.sendAlert(alertUnexpectedMessage)
++ 			return errors.New("tls: received unexpected CertificateStatus message")
++ 		}
++-		hs.finishedHash.Write(cs.marshal())
++ 
++ 		c.ocspResponse = cs.response
++ 
++-		msg, err = c.readHandshake()
+++		msg, err = c.readHandshake(&hs.finishedHash)
++ 		if err != nil {
++ 			return err
++ 		}
++@@ -530,14 +542,13 @@ func (hs *clientHandshakeState) doFullHa
++ 
++ 	skx, ok := msg.(*serverKeyExchangeMsg)
++ 	if ok {
++-		hs.finishedHash.Write(skx.marshal())
++ 		err = keyAgreement.processServerKeyExchange(c.config, hs.hello, hs.serverHello, c.peerCertificates[0], skx)
++ 		if err != nil {
++ 			c.sendAlert(alertUnexpectedMessage)
++ 			return err
++ 		}
++ 
++-		msg, err = c.readHandshake()
+++		msg, err = c.readHandshake(&hs.finishedHash)
++ 		if err != nil {
++ 			return err
++ 		}
++@@ -548,7 +559,6 @@ func (hs *clientHandshakeState) doFullHa
++ 	certReq, ok := msg.(*certificateRequestMsg)
++ 	if ok {
++ 		certRequested = true
++-		hs.finishedHash.Write(certReq.marshal())
++ 
++ 		cri := certificateRequestInfoFromMsg(hs.ctx, c.vers, certReq)
++ 		if chainToSend, err = c.getClientCertificate(cri); err != nil {
++@@ -556,7 +566,7 @@ func (hs *clientHandshakeState) doFullHa
++ 			return err
++ 		}
++ 
++-		msg, err = c.readHandshake()
+++		msg, err = c.readHandshake(&hs.finishedHash)
++ 		if err != nil {
++ 			return err
++ 		}
++@@ -567,7 +577,6 @@ func (hs *clientHandshakeState) doFullHa
++ 		c.sendAlert(alertUnexpectedMessage)
++ 		return unexpectedMessageError(shd, msg)
++ 	}
++-	hs.finishedHash.Write(shd.marshal())
++ 
++ 	// If the server requested a certificate then we have to send a
++ 	// Certificate message, even if it's empty because we don't have a
++@@ -575,8 +584,7 @@ func (hs *clientHandshakeState) doFullHa
++ 	if certRequested {
++ 		certMsg = new(certificateMsg)
++ 		certMsg.certificates = chainToSend.Certificate
++-		hs.finishedHash.Write(certMsg.marshal())
++-		if _, err := c.writeRecord(recordTypeHandshake, certMsg.marshal()); err != nil {
+++		if _, err := hs.c.writeHandshakeRecord(certMsg, &hs.finishedHash); err != nil {
++ 			return err
++ 		}
++ 	}
++@@ -587,8 +595,7 @@ func (hs *clientHandshakeState) doFullHa
++ 		return err
++ 	}
++ 	if ckx != nil {
++-		hs.finishedHash.Write(ckx.marshal())
++-		if _, err := c.writeRecord(recordTypeHandshake, ckx.marshal()); err != nil {
+++		if _, err := hs.c.writeHandshakeRecord(ckx, &hs.finishedHash); err != nil {
++ 			return err
++ 		}
++ 	}
++@@ -635,8 +642,7 @@ func (hs *clientHandshakeState) doFullHa
++ 			return err
++ 		}
++ 
++-		hs.finishedHash.Write(certVerify.marshal())
++-		if _, err := c.writeRecord(recordTypeHandshake, certVerify.marshal()); err != nil {
+++		if _, err := hs.c.writeHandshakeRecord(certVerify, &hs.finishedHash); err != nil {
++ 			return err
++ 		}
++ 	}
++@@ -771,7 +777,10 @@ func (hs *clientHandshakeState) readFini
++ 		return err
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	// finishedMsg is included in the transcript, but not until after we
+++	// check the client version, since the state before this message was
+++	// sent is used during verification.
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -787,7 +796,11 @@ func (hs *clientHandshakeState) readFini
++ 		c.sendAlert(alertHandshakeFailure)
++ 		return errors.New("tls: server's Finished message was incorrect")
++ 	}
++-	hs.finishedHash.Write(serverFinished.marshal())
+++
+++	if err := transcriptMsg(serverFinished, &hs.finishedHash); err != nil {
+++		return err
+++	}
+++
++ 	copy(out, verify)
++ 	return nil
++ }
++@@ -798,7 +811,7 @@ func (hs *clientHandshakeState) readSess
++ 	}
++ 
++ 	c := hs.c
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(&hs.finishedHash)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -807,7 +820,6 @@ func (hs *clientHandshakeState) readSess
++ 		c.sendAlert(alertUnexpectedMessage)
++ 		return unexpectedMessageError(sessionTicketMsg, msg)
++ 	}
++-	hs.finishedHash.Write(sessionTicketMsg.marshal())
++ 
++ 	hs.session = &ClientSessionState{
++ 		sessionTicket:      sessionTicketMsg.ticket,
++@@ -827,14 +839,13 @@ func (hs *clientHandshakeState) readSess
++ func (hs *clientHandshakeState) sendFinished(out []byte) error {
++ 	c := hs.c
++ 
++-	if _, err := c.writeRecord(recordTypeChangeCipherSpec, []byte{1}); err != nil {
+++	if err := c.writeChangeCipherRecord(); err != nil {
++ 		return err
++ 	}
++ 
++ 	finished := new(finishedMsg)
++ 	finished.verifyData = hs.finishedHash.clientSum(hs.masterSecret)
++-	hs.finishedHash.Write(finished.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, finished.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(finished, &hs.finishedHash); err != nil {
++ 		return err
++ 	}
++ 	copy(out, finished.verifyData)
++--- go.orig/src/crypto/tls/handshake_client_test.go
+++++ go/src/crypto/tls/handshake_client_test.go
++@@ -1257,7 +1257,7 @@ func TestServerSelectingUnconfiguredAppl
++ 		cipherSuite:  TLS_RSA_WITH_AES_128_GCM_SHA256,
++ 		alpnProtocol: "how-about-this",
++ 	}
++-	serverHelloBytes := serverHello.marshal()
+++	serverHelloBytes := mustMarshal(t, serverHello)
++ 
++ 	s.Write([]byte{
++ 		byte(recordTypeHandshake),
++@@ -1500,7 +1500,7 @@ func TestServerSelectingUnconfiguredCiph
++ 		random:      make([]byte, 32),
++ 		cipherSuite: TLS_RSA_WITH_AES_256_GCM_SHA384,
++ 	}
++-	serverHelloBytes := serverHello.marshal()
+++	serverHelloBytes := mustMarshal(t, serverHello)
++ 
++ 	s.Write([]byte{
++ 		byte(recordTypeHandshake),
++--- go.orig/src/crypto/tls/handshake_client_tls13.go
+++++ go/src/crypto/tls/handshake_client_tls13.go
++@@ -58,7 +58,10 @@ func (hs *clientHandshakeStateTLS13) han
++ 	}
++ 
++ 	hs.transcript = hs.suite.hash.New()
++-	hs.transcript.Write(hs.hello.marshal())
+++
+++	if err := transcriptMsg(hs.hello, hs.transcript); err != nil {
+++		return err
+++	}
++ 
++ 	if bytes.Equal(hs.serverHello.random, helloRetryRequestRandom) {
++ 		if err := hs.sendDummyChangeCipherSpec(); err != nil {
++@@ -69,7 +72,9 @@ func (hs *clientHandshakeStateTLS13) han
++ 		}
++ 	}
++ 
++-	hs.transcript.Write(hs.serverHello.marshal())
+++	if err := transcriptMsg(hs.serverHello, hs.transcript); err != nil {
+++		return err
+++	}
++ 
++ 	c.buffering = true
++ 	if err := hs.processServerHello(); err != nil {
++@@ -168,8 +173,7 @@ func (hs *clientHandshakeStateTLS13) sen
++ 	}
++ 	hs.sentDummyCCS = true
++ 
++-	_, err := hs.c.writeRecord(recordTypeChangeCipherSpec, []byte{1})
++-	return err
+++	return hs.c.writeChangeCipherRecord()
++ }
++ 
++ // processHelloRetryRequest handles the HRR in hs.serverHello, modifies and
++@@ -184,7 +188,9 @@ func (hs *clientHandshakeStateTLS13) pro
++ 	hs.transcript.Reset()
++ 	hs.transcript.Write([]byte{typeMessageHash, 0, 0, uint8(len(chHash))})
++ 	hs.transcript.Write(chHash)
++-	hs.transcript.Write(hs.serverHello.marshal())
+++	if err := transcriptMsg(hs.serverHello, hs.transcript); err != nil {
+++		return err
+++	}
++ 
++ 	// The only HelloRetryRequest extensions we support are key_share and
++ 	// cookie, and clients must abort the handshake if the HRR would not result
++@@ -249,10 +255,18 @@ func (hs *clientHandshakeStateTLS13) pro
++ 			transcript := hs.suite.hash.New()
++ 			transcript.Write([]byte{typeMessageHash, 0, 0, uint8(len(chHash))})
++ 			transcript.Write(chHash)
++-			transcript.Write(hs.serverHello.marshal())
++-			transcript.Write(hs.hello.marshalWithoutBinders())
+++			if err := transcriptMsg(hs.serverHello, hs.transcript); err != nil {
+++				return err
+++			}
+++			helloBytes, err := hs.hello.marshalWithoutBinders()
+++			if err != nil {
+++				return err
+++			}
+++			transcript.Write(helloBytes)
++ 			pskBinders := [][]byte{hs.suite.finishedHash(hs.binderKey, transcript)}
++-			hs.hello.updateBinders(pskBinders)
+++			if err := hs.hello.updateBinders(pskBinders); err != nil {
+++				return err
+++			}
++ 		} else {
++ 			// Server selected a cipher suite incompatible with the PSK.
++ 			hs.hello.pskIdentities = nil
++@@ -260,12 +274,12 @@ func (hs *clientHandshakeStateTLS13) pro
++ 		}
++ 	}
++ 
++-	hs.transcript.Write(hs.hello.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, hs.hello.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(hs.hello, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	// serverHelloMsg is not included in the transcript
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -354,6 +368,7 @@ func (hs *clientHandshakeStateTLS13) est
++ 	if !hs.usingPSK {
++ 		earlySecret = hs.suite.extract(nil, nil)
++ 	}
+++
++ 	handshakeSecret := hs.suite.extract(sharedKey,
++ 		hs.suite.deriveSecret(earlySecret, "derived", nil))
++ 
++@@ -384,7 +399,7 @@ func (hs *clientHandshakeStateTLS13) est
++ func (hs *clientHandshakeStateTLS13) readServerParameters() error {
++ 	c := hs.c
++ 
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(hs.transcript)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -394,7 +409,6 @@ func (hs *clientHandshakeStateTLS13) rea
++ 		c.sendAlert(alertUnexpectedMessage)
++ 		return unexpectedMessageError(encryptedExtensions, msg)
++ 	}
++-	hs.transcript.Write(encryptedExtensions.marshal())
++ 
++ 	if err := checkALPN(hs.hello.alpnProtocols, encryptedExtensions.alpnProtocol); err != nil {
++ 		c.sendAlert(alertUnsupportedExtension)
++@@ -423,18 +437,16 @@ func (hs *clientHandshakeStateTLS13) rea
++ 		return nil
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(hs.transcript)
++ 	if err != nil {
++ 		return err
++ 	}
++ 
++ 	certReq, ok := msg.(*certificateRequestMsgTLS13)
++ 	if ok {
++-		hs.transcript.Write(certReq.marshal())
++-
++ 		hs.certReq = certReq
++ 
++-		msg, err = c.readHandshake()
+++		msg, err = c.readHandshake(hs.transcript)
++ 		if err != nil {
++ 			return err
++ 		}
++@@ -449,7 +461,6 @@ func (hs *clientHandshakeStateTLS13) rea
++ 		c.sendAlert(alertDecodeError)
++ 		return errors.New("tls: received empty certificates message")
++ 	}
++-	hs.transcript.Write(certMsg.marshal())
++ 
++ 	c.scts = certMsg.certificate.SignedCertificateTimestamps
++ 	c.ocspResponse = certMsg.certificate.OCSPStaple
++@@ -458,7 +469,10 @@ func (hs *clientHandshakeStateTLS13) rea
++ 		return err
++ 	}
++ 
++-	msg, err = c.readHandshake()
+++	// certificateVerifyMsg is included in the transcript, but not until
+++	// after we verify the handshake signature, since the state before
+++	// this message was sent is used.
+++	msg, err = c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -489,7 +503,9 @@ func (hs *clientHandshakeStateTLS13) rea
++ 		return errors.New("tls: invalid signature by the server certificate: " + err.Error())
++ 	}
++ 
++-	hs.transcript.Write(certVerify.marshal())
+++	if err := transcriptMsg(certVerify, hs.transcript); err != nil {
+++		return err
+++	}
++ 
++ 	return nil
++ }
++@@ -497,7 +513,10 @@ func (hs *clientHandshakeStateTLS13) rea
++ func (hs *clientHandshakeStateTLS13) readServerFinished() error {
++ 	c := hs.c
++ 
++-	msg, err := c.readHandshake()
+++	// finishedMsg is included in the transcript, but not until after we
+++	// check the client version, since the state before this message was
+++	// sent is used during verification.
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -514,7 +533,9 @@ func (hs *clientHandshakeStateTLS13) rea
++ 		return errors.New("tls: invalid server finished hash")
++ 	}
++ 
++-	hs.transcript.Write(finished.marshal())
+++	if err := transcriptMsg(finished, hs.transcript); err != nil {
+++		return err
+++	}
++ 
++ 	// Derive secrets that take context through the server Finished.
++ 
++@@ -563,8 +584,7 @@ func (hs *clientHandshakeStateTLS13) sen
++ 	certMsg.scts = hs.certReq.scts && len(cert.SignedCertificateTimestamps) > 0
++ 	certMsg.ocspStapling = hs.certReq.ocspStapling && len(cert.OCSPStaple) > 0
++ 
++-	hs.transcript.Write(certMsg.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, certMsg.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(certMsg, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -601,8 +621,7 @@ func (hs *clientHandshakeStateTLS13) sen
++ 	}
++ 	certVerifyMsg.signature = sig
++ 
++-	hs.transcript.Write(certVerifyMsg.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, certVerifyMsg.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(certVerifyMsg, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -616,8 +635,7 @@ func (hs *clientHandshakeStateTLS13) sen
++ 		verifyData: hs.suite.finishedHash(c.out.trafficSecret, hs.transcript),
++ 	}
++ 
++-	hs.transcript.Write(finished.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, finished.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(finished, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++--- go.orig/src/crypto/tls/handshake_messages.go
+++++ go/src/crypto/tls/handshake_messages.go
++@@ -5,6 +5,7 @@
++ package tls
++ 
++ import (
+++	"errors"
++ 	"fmt"
++ 	"strings"
++ 
++@@ -94,9 +95,181 @@ type clientHelloMsg struct {
++ 	pskBinders                       [][]byte
++ }
++ 
++-func (m *clientHelloMsg) marshal() []byte {
+++func (m *clientHelloMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
+++	}
+++
+++	var exts cryptobyte.Builder
+++	if len(m.serverName) > 0 {
+++		// RFC 6066, Section 3
+++		exts.AddUint16(extensionServerName)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddUint8(0) // name_type = host_name
+++				exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++					exts.AddBytes([]byte(m.serverName))
+++				})
+++			})
+++		})
+++	}
+++	if m.ocspStapling {
+++		// RFC 4366, Section 3.6
+++		exts.AddUint16(extensionStatusRequest)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint8(1)  // status_type = ocsp
+++			exts.AddUint16(0) // empty responder_id_list
+++			exts.AddUint16(0) // empty request_extensions
+++		})
+++	}
+++	if len(m.supportedCurves) > 0 {
+++		// RFC 4492, sections 5.1.1 and RFC 8446, Section 4.2.7
+++		exts.AddUint16(extensionSupportedCurves)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, curve := range m.supportedCurves {
+++					exts.AddUint16(uint16(curve))
+++				}
+++			})
+++		})
+++	}
+++	if len(m.supportedPoints) > 0 {
+++		// RFC 4492, Section 5.1.2
+++		exts.AddUint16(extensionSupportedPoints)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.supportedPoints)
+++			})
+++		})
+++	}
+++	if m.ticketSupported {
+++		// RFC 5077, Section 3.2
+++		exts.AddUint16(extensionSessionTicket)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddBytes(m.sessionTicket)
+++		})
+++	}
+++	if len(m.supportedSignatureAlgorithms) > 0 {
+++		// RFC 5246, Section 7.4.1.4.1
+++		exts.AddUint16(extensionSignatureAlgorithms)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, sigAlgo := range m.supportedSignatureAlgorithms {
+++					exts.AddUint16(uint16(sigAlgo))
+++				}
+++			})
+++		})
+++	}
+++	if len(m.supportedSignatureAlgorithmsCert) > 0 {
+++		// RFC 8446, Section 4.2.3
+++		exts.AddUint16(extensionSignatureAlgorithmsCert)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, sigAlgo := range m.supportedSignatureAlgorithmsCert {
+++					exts.AddUint16(uint16(sigAlgo))
+++				}
+++			})
+++		})
+++	}
+++	if m.secureRenegotiationSupported {
+++		// RFC 5746, Section 3.2
+++		exts.AddUint16(extensionRenegotiationInfo)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.secureRenegotiation)
+++			})
+++		})
+++	}
+++	if len(m.alpnProtocols) > 0 {
+++		// RFC 7301, Section 3.1
+++		exts.AddUint16(extensionALPN)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, proto := range m.alpnProtocols {
+++					exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++						exts.AddBytes([]byte(proto))
+++					})
+++				}
+++			})
+++		})
+++	}
+++	if m.scts {
+++		// RFC 6962, Section 3.3.1
+++		exts.AddUint16(extensionSCT)
+++		exts.AddUint16(0) // empty extension_data
+++	}
+++	if len(m.supportedVersions) > 0 {
+++		// RFC 8446, Section 4.2.1
+++		exts.AddUint16(extensionSupportedVersions)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, vers := range m.supportedVersions {
+++					exts.AddUint16(vers)
+++				}
+++			})
+++		})
+++	}
+++	if len(m.cookie) > 0 {
+++		// RFC 8446, Section 4.2.2
+++		exts.AddUint16(extensionCookie)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.cookie)
+++			})
+++		})
+++	}
+++	if len(m.keyShares) > 0 {
+++		// RFC 8446, Section 4.2.8
+++		exts.AddUint16(extensionKeyShare)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, ks := range m.keyShares {
+++					exts.AddUint16(uint16(ks.group))
+++					exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++						exts.AddBytes(ks.data)
+++					})
+++				}
+++			})
+++		})
+++	}
+++	if m.earlyData {
+++		// RFC 8446, Section 4.2.10
+++		exts.AddUint16(extensionEarlyData)
+++		exts.AddUint16(0) // empty extension_data
+++	}
+++	if len(m.pskModes) > 0 {
+++		// RFC 8446, Section 4.2.9
+++		exts.AddUint16(extensionPSKModes)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.pskModes)
+++			})
+++		})
+++	}
+++	if len(m.pskIdentities) > 0 { // pre_shared_key must be the last extension
+++		// RFC 8446, Section 4.2.11
+++		exts.AddUint16(extensionPreSharedKey)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, psk := range m.pskIdentities {
+++					exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++						exts.AddBytes(psk.label)
+++					})
+++					exts.AddUint32(psk.obfuscatedTicketAge)
+++				}
+++			})
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, binder := range m.pskBinders {
+++					exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++						exts.AddBytes(binder)
+++					})
+++				}
+++			})
+++		})
+++	}
+++	extBytes, err := exts.Bytes()
+++	if err != nil {
+++		return nil, err
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -116,219 +289,53 @@ func (m *clientHelloMsg) marshal() []byt
++ 			b.AddBytes(m.compressionMethods)
++ 		})
++ 
++-		// If extensions aren't present, omit them.
++-		var extensionsPresent bool
++-		bWithoutExtensions := *b
++-
++-		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-			if len(m.serverName) > 0 {
++-				// RFC 6066, Section 3
++-				b.AddUint16(extensionServerName)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddUint8(0) // name_type = host_name
++-						b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-							b.AddBytes([]byte(m.serverName))
++-						})
++-					})
++-				})
++-			}
++-			if m.ocspStapling {
++-				// RFC 4366, Section 3.6
++-				b.AddUint16(extensionStatusRequest)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint8(1)  // status_type = ocsp
++-					b.AddUint16(0) // empty responder_id_list
++-					b.AddUint16(0) // empty request_extensions
++-				})
++-			}
++-			if len(m.supportedCurves) > 0 {
++-				// RFC 4492, sections 5.1.1 and RFC 8446, Section 4.2.7
++-				b.AddUint16(extensionSupportedCurves)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, curve := range m.supportedCurves {
++-							b.AddUint16(uint16(curve))
++-						}
++-					})
++-				})
++-			}
++-			if len(m.supportedPoints) > 0 {
++-				// RFC 4492, Section 5.1.2
++-				b.AddUint16(extensionSupportedPoints)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.supportedPoints)
++-					})
++-				})
++-			}
++-			if m.ticketSupported {
++-				// RFC 5077, Section 3.2
++-				b.AddUint16(extensionSessionTicket)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddBytes(m.sessionTicket)
++-				})
++-			}
++-			if len(m.supportedSignatureAlgorithms) > 0 {
++-				// RFC 5246, Section 7.4.1.4.1
++-				b.AddUint16(extensionSignatureAlgorithms)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, sigAlgo := range m.supportedSignatureAlgorithms {
++-							b.AddUint16(uint16(sigAlgo))
++-						}
++-					})
++-				})
++-			}
++-			if len(m.supportedSignatureAlgorithmsCert) > 0 {
++-				// RFC 8446, Section 4.2.3
++-				b.AddUint16(extensionSignatureAlgorithmsCert)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, sigAlgo := range m.supportedSignatureAlgorithmsCert {
++-							b.AddUint16(uint16(sigAlgo))
++-						}
++-					})
++-				})
++-			}
++-			if m.secureRenegotiationSupported {
++-				// RFC 5746, Section 3.2
++-				b.AddUint16(extensionRenegotiationInfo)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.secureRenegotiation)
++-					})
++-				})
++-			}
++-			if len(m.alpnProtocols) > 0 {
++-				// RFC 7301, Section 3.1
++-				b.AddUint16(extensionALPN)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, proto := range m.alpnProtocols {
++-							b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-								b.AddBytes([]byte(proto))
++-							})
++-						}
++-					})
++-				})
++-			}
++-			if m.scts {
++-				// RFC 6962, Section 3.3.1
++-				b.AddUint16(extensionSCT)
++-				b.AddUint16(0) // empty extension_data
++-			}
++-			if len(m.supportedVersions) > 0 {
++-				// RFC 8446, Section 4.2.1
++-				b.AddUint16(extensionSupportedVersions)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, vers := range m.supportedVersions {
++-							b.AddUint16(vers)
++-						}
++-					})
++-				})
++-			}
++-			if len(m.cookie) > 0 {
++-				// RFC 8446, Section 4.2.2
++-				b.AddUint16(extensionCookie)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.cookie)
++-					})
++-				})
++-			}
++-			if len(m.keyShares) > 0 {
++-				// RFC 8446, Section 4.2.8
++-				b.AddUint16(extensionKeyShare)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, ks := range m.keyShares {
++-							b.AddUint16(uint16(ks.group))
++-							b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-								b.AddBytes(ks.data)
++-							})
++-						}
++-					})
++-				})
++-			}
++-			if m.earlyData {
++-				// RFC 8446, Section 4.2.10
++-				b.AddUint16(extensionEarlyData)
++-				b.AddUint16(0) // empty extension_data
++-			}
++-			if len(m.pskModes) > 0 {
++-				// RFC 8446, Section 4.2.9
++-				b.AddUint16(extensionPSKModes)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.pskModes)
++-					})
++-				})
++-			}
++-			if len(m.pskIdentities) > 0 { // pre_shared_key must be the last extension
++-				// RFC 8446, Section 4.2.11
++-				b.AddUint16(extensionPreSharedKey)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, psk := range m.pskIdentities {
++-							b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-								b.AddBytes(psk.label)
++-							})
++-							b.AddUint32(psk.obfuscatedTicketAge)
++-						}
++-					})
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, binder := range m.pskBinders {
++-							b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-								b.AddBytes(binder)
++-							})
++-						}
++-					})
++-				})
++-			}
++-
++-			extensionsPresent = len(b.BytesOrPanic()) > 2
++-		})
++-
++-		if !extensionsPresent {
++-			*b = bWithoutExtensions
++-		}
++-	})
+++		if len(extBytes) > 0 {
+++			b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
+++				b.AddBytes(extBytes)
+++			})
+++ 		}
+++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ // marshalWithoutBinders returns the ClientHello through the
++ // PreSharedKeyExtension.identities field, according to RFC 8446, Section
++ // 4.2.11.2. Note that m.pskBinders must be set to slices of the correct length.
++-func (m *clientHelloMsg) marshalWithoutBinders() []byte {
+++func (m *clientHelloMsg) marshalWithoutBinders() ([]byte, error) {
++ 	bindersLen := 2 // uint16 length prefix
++ 	for _, binder := range m.pskBinders {
++ 		bindersLen += 1 // uint8 length prefix
++ 		bindersLen += len(binder)
++ 	}
++ 
++-	fullMessage := m.marshal()
++-	return fullMessage[:len(fullMessage)-bindersLen]
+++	fullMessage, err := m.marshal()
+++	if err != nil {
+++		return nil, err
+++	}
+++	return fullMessage[:len(fullMessage)-bindersLen], nil
++ }
++ 
++ // updateBinders updates the m.pskBinders field, if necessary updating the
++ // cached marshaled representation. The supplied binders must have the same
++ // length as the current m.pskBinders.
++-func (m *clientHelloMsg) updateBinders(pskBinders [][]byte) {
+++func (m *clientHelloMsg) updateBinders(pskBinders [][]byte) error {
++ 	if len(pskBinders) != len(m.pskBinders) {
++-		panic("tls: internal error: pskBinders length mismatch")
+++		return errors.New("tls: internal error: pskBinders length mismatch")
++ 	}
++ 	for i := range m.pskBinders {
++ 		if len(pskBinders[i]) != len(m.pskBinders[i]) {
++-			panic("tls: internal error: pskBinders length mismatch")
+++			return errors.New("tls: internal error: pskBinders length mismatch")
++ 		}
++ 	}
++ 	m.pskBinders = pskBinders
++ 	if m.raw != nil {
++-		lenWithoutBinders := len(m.marshalWithoutBinders())
+++		helloBytes, err := m.marshalWithoutBinders()
+++		if err != nil {
+++			return err
+++		}
+++		lenWithoutBinders := len(helloBytes)
++ 		// TODO(filippo): replace with NewFixedBuilder once CL 148882 is imported.
++ 		b := cryptobyte.NewBuilder(m.raw[:lenWithoutBinders])
++ 		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++@@ -339,9 +346,11 @@ func (m *clientHelloMsg) updateBinders(p
++ 			}
++ 		})
++ 		if len(b.BytesOrPanic()) != len(m.raw) {
++-			panic("tls: internal error: failed to update binders")
+++			return errors.New("tls: internal error: failed to update binders")
++ 		}
++ 	}
+++
+++	return nil
++ }
++ 
++ func (m *clientHelloMsg) unmarshal(data []byte) bool {
++@@ -613,9 +622,98 @@ type serverHelloMsg struct {
++ 	selectedGroup CurveID
++ }
++ 
++-func (m *serverHelloMsg) marshal() []byte {
+++func (m *serverHelloMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
+++	}
+++
+++	var exts cryptobyte.Builder
+++	if m.ocspStapling {
+++		exts.AddUint16(extensionStatusRequest)
+++		exts.AddUint16(0) // empty extension_data
+++	}
+++	if m.ticketSupported {
+++		exts.AddUint16(extensionSessionTicket)
+++		exts.AddUint16(0) // empty extension_data
+++	}
+++	if m.secureRenegotiationSupported {
+++		exts.AddUint16(extensionRenegotiationInfo)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.secureRenegotiation)
+++			})
+++		})
+++	}
+++	if len(m.alpnProtocol) > 0 {
+++		exts.AddUint16(extensionALPN)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++					exts.AddBytes([]byte(m.alpnProtocol))
+++				})
+++			})
+++		})
+++	}
+++	if len(m.scts) > 0 {
+++		exts.AddUint16(extensionSCT)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				for _, sct := range m.scts {
+++					exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++						exts.AddBytes(sct)
+++					})
+++				}
+++			})
+++		})
+++	}
+++	if m.supportedVersion != 0 {
+++		exts.AddUint16(extensionSupportedVersions)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16(m.supportedVersion)
+++		})
+++	}
+++	if m.serverShare.group != 0 {
+++		exts.AddUint16(extensionKeyShare)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16(uint16(m.serverShare.group))
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.serverShare.data)
+++			})
+++		})
+++	}
+++	if m.selectedIdentityPresent {
+++		exts.AddUint16(extensionPreSharedKey)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16(m.selectedIdentity)
+++		})
+++	}
+++
+++	if len(m.cookie) > 0 {
+++		exts.AddUint16(extensionCookie)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.cookie)
+++			})
+++		})
+++	}
+++	if m.selectedGroup != 0 {
+++		exts.AddUint16(extensionKeyShare)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint16(uint16(m.selectedGroup))
+++		})
+++	}
+++	if len(m.supportedPoints) > 0 {
+++		exts.AddUint16(extensionSupportedPoints)
+++		exts.AddUint16LengthPrefixed(func(exts *cryptobyte.Builder) {
+++			exts.AddUint8LengthPrefixed(func(exts *cryptobyte.Builder) {
+++				exts.AddBytes(m.supportedPoints)
+++			})
+++		})
+++	}
+++
+++	extBytes, err := exts.Bytes()
+++	if err != nil {
+++		return nil, err
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -629,104 +727,15 @@ func (m *serverHelloMsg) marshal() []byt
++ 		b.AddUint16(m.cipherSuite)
++ 		b.AddUint8(m.compressionMethod)
++ 
++-		// If extensions aren't present, omit them.
++-		var extensionsPresent bool
++-		bWithoutExtensions := *b
++-
++-		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-			if m.ocspStapling {
++-				b.AddUint16(extensionStatusRequest)
++-				b.AddUint16(0) // empty extension_data
++-			}
++-			if m.ticketSupported {
++-				b.AddUint16(extensionSessionTicket)
++-				b.AddUint16(0) // empty extension_data
++-			}
++-			if m.secureRenegotiationSupported {
++-				b.AddUint16(extensionRenegotiationInfo)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.secureRenegotiation)
++-					})
++-				})
++-			}
++-			if len(m.alpnProtocol) > 0 {
++-				b.AddUint16(extensionALPN)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-							b.AddBytes([]byte(m.alpnProtocol))
++-						})
++-					})
++-				})
++-			}
++-			if len(m.scts) > 0 {
++-				b.AddUint16(extensionSCT)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						for _, sct := range m.scts {
++-							b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-								b.AddBytes(sct)
++-							})
++-						}
++-					})
++-				})
++-			}
++-			if m.supportedVersion != 0 {
++-				b.AddUint16(extensionSupportedVersions)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16(m.supportedVersion)
++-				})
++-			}
++-			if m.serverShare.group != 0 {
++-				b.AddUint16(extensionKeyShare)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16(uint16(m.serverShare.group))
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.serverShare.data)
++-					})
++-				})
++-			}
++-			if m.selectedIdentityPresent {
++-				b.AddUint16(extensionPreSharedKey)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16(m.selectedIdentity)
++-				})
++-			}
++-
++-			if len(m.cookie) > 0 {
++-				b.AddUint16(extensionCookie)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.cookie)
++-					})
++-				})
++-			}
++-			if m.selectedGroup != 0 {
++-				b.AddUint16(extensionKeyShare)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint16(uint16(m.selectedGroup))
++-				})
++-			}
++-			if len(m.supportedPoints) > 0 {
++-				b.AddUint16(extensionSupportedPoints)
++-				b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
++-					b.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++-						b.AddBytes(m.supportedPoints)
++-					})
++-				})
++-			}
++-
++-			extensionsPresent = len(b.BytesOrPanic()) > 2
++-		})
++-
++-		if !extensionsPresent {
++-			*b = bWithoutExtensions
+++		if len(extBytes) > 0 {
+++			b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
+++				b.AddBytes(extBytes)
+++			})
++ 		}
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *serverHelloMsg) unmarshal(data []byte) bool {
++@@ -844,9 +853,9 @@ type encryptedExtensionsMsg struct {
++ 	alpnProtocol string
++ }
++ 
++-func (m *encryptedExtensionsMsg) marshal() []byte {
+++func (m *encryptedExtensionsMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -866,8 +875,9 @@ func (m *encryptedExtensionsMsg) marshal
++ 		})
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *encryptedExtensionsMsg) unmarshal(data []byte) bool {
++@@ -915,10 +925,10 @@ func (m *encryptedExtensionsMsg) unmarsh
++ 
++ type endOfEarlyDataMsg struct{}
++ 
++-func (m *endOfEarlyDataMsg) marshal() []byte {
+++func (m *endOfEarlyDataMsg) marshal() ([]byte, error) {
++ 	x := make([]byte, 4)
++ 	x[0] = typeEndOfEarlyData
++-	return x
+++	return x, nil
++ }
++ 
++ func (m *endOfEarlyDataMsg) unmarshal(data []byte) bool {
++@@ -930,9 +940,9 @@ type keyUpdateMsg struct {
++ 	updateRequested bool
++ }
++ 
++-func (m *keyUpdateMsg) marshal() []byte {
+++func (m *keyUpdateMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -945,8 +955,9 @@ func (m *keyUpdateMsg) marshal() []byte
++ 		}
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *keyUpdateMsg) unmarshal(data []byte) bool {
++@@ -978,9 +989,9 @@ type newSessionTicketMsgTLS13 struct {
++ 	maxEarlyData uint32
++ }
++ 
++-func (m *newSessionTicketMsgTLS13) marshal() []byte {
+++func (m *newSessionTicketMsgTLS13) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -1005,8 +1016,9 @@ func (m *newSessionTicketMsgTLS13) marsh
++ 		})
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *newSessionTicketMsgTLS13) unmarshal(data []byte) bool {
++@@ -1059,9 +1071,9 @@ type certificateRequestMsgTLS13 struct {
++ 	certificateAuthorities           [][]byte
++ }
++ 
++-func (m *certificateRequestMsgTLS13) marshal() []byte {
+++func (m *certificateRequestMsgTLS13) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -1120,8 +1132,9 @@ func (m *certificateRequestMsgTLS13) mar
++ 		})
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *certificateRequestMsgTLS13) unmarshal(data []byte) bool {
++@@ -1205,9 +1218,9 @@ type certificateMsg struct {
++ 	certificates [][]byte
++ }
++ 
++-func (m *certificateMsg) marshal() (x []byte) {
+++func (m *certificateMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var i int
++@@ -1216,7 +1229,7 @@ func (m *certificateMsg) marshal() (x []
++ 	}
++ 
++ 	length := 3 + 3*len(m.certificates) + i
++-	x = make([]byte, 4+length)
+++	x := make([]byte, 4+length)
++ 	x[0] = typeCertificate
++ 	x[1] = uint8(length >> 16)
++ 	x[2] = uint8(length >> 8)
++@@ -1237,7 +1250,7 @@ func (m *certificateMsg) marshal() (x []
++ 	}
++ 
++ 	m.raw = x
++-	return
+++	return m.raw, nil
++ }
++ 
++ func (m *certificateMsg) unmarshal(data []byte) bool {
++@@ -1284,9 +1297,9 @@ type certificateMsgTLS13 struct {
++ 	scts         bool
++ }
++ 
++-func (m *certificateMsgTLS13) marshal() []byte {
+++func (m *certificateMsgTLS13) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -1304,8 +1317,9 @@ func (m *certificateMsgTLS13) marshal()
++ 		marshalCertificate(b, certificate)
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func marshalCertificate(b *cryptobyte.Builder, certificate Certificate) {
++@@ -1428,9 +1442,9 @@ type serverKeyExchangeMsg struct {
++ 	key []byte
++ }
++ 
++-func (m *serverKeyExchangeMsg) marshal() []byte {
+++func (m *serverKeyExchangeMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 	length := len(m.key)
++ 	x := make([]byte, length+4)
++@@ -1441,7 +1455,7 @@ func (m *serverKeyExchangeMsg) marshal()
++ 	copy(x[4:], m.key)
++ 
++ 	m.raw = x
++-	return x
+++	return x, nil
++ }
++ 
++ func (m *serverKeyExchangeMsg) unmarshal(data []byte) bool {
++@@ -1458,9 +1472,9 @@ type certificateStatusMsg struct {
++ 	response []byte
++ }
++ 
++-func (m *certificateStatusMsg) marshal() []byte {
+++func (m *certificateStatusMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -1472,8 +1486,9 @@ func (m *certificateStatusMsg) marshal()
++ 		})
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *certificateStatusMsg) unmarshal(data []byte) bool {
++@@ -1492,10 +1507,10 @@ func (m *certificateStatusMsg) unmarshal
++ 
++ type serverHelloDoneMsg struct{}
++ 
++-func (m *serverHelloDoneMsg) marshal() []byte {
+++func (m *serverHelloDoneMsg) marshal() ([]byte, error) {
++ 	x := make([]byte, 4)
++ 	x[0] = typeServerHelloDone
++-	return x
+++	return x, nil
++ }
++ 
++ func (m *serverHelloDoneMsg) unmarshal(data []byte) bool {
++@@ -1507,9 +1522,9 @@ type clientKeyExchangeMsg struct {
++ 	ciphertext []byte
++ }
++ 
++-func (m *clientKeyExchangeMsg) marshal() []byte {
+++func (m *clientKeyExchangeMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 	length := len(m.ciphertext)
++ 	x := make([]byte, length+4)
++@@ -1520,7 +1535,7 @@ func (m *clientKeyExchangeMsg) marshal()
++ 	copy(x[4:], m.ciphertext)
++ 
++ 	m.raw = x
++-	return x
+++	return x, nil
++ }
++ 
++ func (m *clientKeyExchangeMsg) unmarshal(data []byte) bool {
++@@ -1541,9 +1556,9 @@ type finishedMsg struct {
++ 	verifyData []byte
++ }
++ 
++-func (m *finishedMsg) marshal() []byte {
+++func (m *finishedMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -1552,8 +1567,9 @@ func (m *finishedMsg) marshal() []byte {
++ 		b.AddBytes(m.verifyData)
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *finishedMsg) unmarshal(data []byte) bool {
++@@ -1575,9 +1591,9 @@ type certificateRequestMsg struct {
++ 	certificateAuthorities       [][]byte
++ }
++ 
++-func (m *certificateRequestMsg) marshal() (x []byte) {
+++func (m *certificateRequestMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	// See RFC 4346, Section 7.4.4.
++@@ -1592,7 +1608,7 @@ func (m *certificateRequestMsg) marshal(
++ 		length += 2 + 2*len(m.supportedSignatureAlgorithms)
++ 	}
++ 
++-	x = make([]byte, 4+length)
+++	x := make([]byte, 4+length)
++ 	x[0] = typeCertificateRequest
++ 	x[1] = uint8(length >> 16)
++ 	x[2] = uint8(length >> 8)
++@@ -1627,7 +1643,7 @@ func (m *certificateRequestMsg) marshal(
++ 	}
++ 
++ 	m.raw = x
++-	return
+++	return m.raw, nil
++ }
++ 
++ func (m *certificateRequestMsg) unmarshal(data []byte) bool {
++@@ -1713,9 +1729,9 @@ type certificateVerifyMsg struct {
++ 	signature             []byte
++ }
++ 
++-func (m *certificateVerifyMsg) marshal() (x []byte) {
+++func (m *certificateVerifyMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	var b cryptobyte.Builder
++@@ -1729,8 +1745,9 @@ func (m *certificateVerifyMsg) marshal()
++ 		})
++ 	})
++ 
++-	m.raw = b.BytesOrPanic()
++-	return m.raw
+++	var err error
+++	m.raw, err = b.Bytes()
+++	return m.raw, err
++ }
++ 
++ func (m *certificateVerifyMsg) unmarshal(data []byte) bool {
++@@ -1753,15 +1770,15 @@ type newSessionTicketMsg struct {
++ 	ticket []byte
++ }
++ 
++-func (m *newSessionTicketMsg) marshal() (x []byte) {
+++func (m *newSessionTicketMsg) marshal() ([]byte, error) {
++ 	if m.raw != nil {
++-		return m.raw
+++		return m.raw, nil
++ 	}
++ 
++ 	// See RFC 5077, Section 3.3.
++ 	ticketLen := len(m.ticket)
++ 	length := 2 + 4 + ticketLen
++-	x = make([]byte, 4+length)
+++	x := make([]byte, 4+length)
++ 	x[0] = typeNewSessionTicket
++ 	x[1] = uint8(length >> 16)
++ 	x[2] = uint8(length >> 8)
++@@ -1772,7 +1789,7 @@ func (m *newSessionTicketMsg) marshal()
++ 
++ 	m.raw = x
++ 
++-	return
+++	return m.raw, nil
++ }
++ 
++ func (m *newSessionTicketMsg) unmarshal(data []byte) bool {
++@@ -1800,10 +1817,25 @@ func (m *newSessionTicketMsg) unmarshal(
++ type helloRequestMsg struct {
++ }
++ 
++-func (*helloRequestMsg) marshal() []byte {
++-	return []byte{typeHelloRequest, 0, 0, 0}
+++func (*helloRequestMsg) marshal() ([]byte, error) {
+++	return []byte{typeHelloRequest, 0, 0, 0}, nil
++ }
++ 
++ func (*helloRequestMsg) unmarshal(data []byte) bool {
++ 	return len(data) == 4
++ }
+++
+++type transcriptHash interface {
+++	Write([]byte) (int, error)
+++}
+++
+++// transcriptMsg is a helper used to marshal and hash messages which typically
+++// are not written to the wire, and as such aren't hashed during Conn.writeRecord.
+++func transcriptMsg(msg handshakeMessage, h transcriptHash) error {
+++	data, err := msg.marshal()
+++	if err != nil {
+++		return err
+++	}
+++	h.Write(data)
+++	return nil
+++}
++--- go.orig/src/crypto/tls/handshake_messages_test.go
+++++ go/src/crypto/tls/handshake_messages_test.go
++@@ -37,6 +37,15 @@ var tests = []interface{}{
++ 	&certificateMsgTLS13{},
++ }
++ 
+++func mustMarshal(t *testing.T, msg handshakeMessage) []byte {
+++	t.Helper()
+++	b, err := msg.marshal()
+++	if err != nil {
+++		t.Fatal(err)
+++	}
+++	return b
+++}
+++
++ func TestMarshalUnmarshal(t *testing.T) {
++ 	rand := rand.New(rand.NewSource(time.Now().UnixNano()))
++ 
++@@ -55,7 +64,7 @@ func TestMarshalUnmarshal(t *testing.T)
++ 			}
++ 
++ 			m1 := v.Interface().(handshakeMessage)
++-			marshaled := m1.marshal()
+++			marshaled := mustMarshal(t, m1)
++ 			m2 := iface.(handshakeMessage)
++ 			if !m2.unmarshal(marshaled) {
++ 				t.Errorf("#%d failed to unmarshal %#v %x", i, m1, marshaled)
++@@ -408,12 +417,12 @@ func TestRejectEmptySCTList(t *testing.T
++ 
++ 	var random [32]byte
++ 	sct := []byte{0x42, 0x42, 0x42, 0x42}
++-	serverHello := serverHelloMsg{
+++	serverHello := &serverHelloMsg{
++ 		vers:   VersionTLS12,
++ 		random: random[:],
++ 		scts:   [][]byte{sct},
++ 	}
++-	serverHelloBytes := serverHello.marshal()
+++	serverHelloBytes := mustMarshal(t, serverHello)
++ 
++ 	var serverHelloCopy serverHelloMsg
++ 	if !serverHelloCopy.unmarshal(serverHelloBytes) {
++@@ -451,12 +460,12 @@ func TestRejectEmptySCT(t *testing.T) {
++ 	// not be zero length.
++ 
++ 	var random [32]byte
++-	serverHello := serverHelloMsg{
+++	serverHello := &serverHelloMsg{
++ 		vers:   VersionTLS12,
++ 		random: random[:],
++ 		scts:   [][]byte{nil},
++ 	}
++-	serverHelloBytes := serverHello.marshal()
+++	serverHelloBytes := mustMarshal(t, serverHello)
++ 
++ 	var serverHelloCopy serverHelloMsg
++ 	if serverHelloCopy.unmarshal(serverHelloBytes) {
++--- go.orig/src/crypto/tls/handshake_server.go
+++++ go/src/crypto/tls/handshake_server.go
++@@ -129,7 +129,9 @@ func (hs *serverHandshakeState) handshak
++ 
++ // readClientHello reads a ClientHello message and selects the protocol version.
++ func (c *Conn) readClientHello(ctx context.Context) (*clientHelloMsg, error) {
++-	msg, err := c.readHandshake()
+++	// clientHelloMsg is included in the transcript, but we haven't initialized
+++	// it yet. The respective handshake functions will record it themselves.
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return nil, err
++ 	}
++@@ -456,9 +458,10 @@ func (hs *serverHandshakeState) doResume
++ 	hs.hello.ticketSupported = hs.sessionState.usedOldKey
++ 	hs.finishedHash = newFinishedHash(c.vers, hs.suite)
++ 	hs.finishedHash.discardHandshakeBuffer()
++-	hs.finishedHash.Write(hs.clientHello.marshal())
++-	hs.finishedHash.Write(hs.hello.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, hs.hello.marshal()); err != nil {
+++	if err := transcriptMsg(hs.clientHello, &hs.finishedHash); err != nil {
+++		return err
+++	}
+++	if _, err := hs.c.writeHandshakeRecord(hs.hello, &hs.finishedHash); err != nil {
++ 		return err
++ 	}
++ 
++@@ -496,24 +499,23 @@ func (hs *serverHandshakeState) doFullHa
++ 		// certificates won't be used.
++ 		hs.finishedHash.discardHandshakeBuffer()
++ 	}
++-	hs.finishedHash.Write(hs.clientHello.marshal())
++-	hs.finishedHash.Write(hs.hello.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, hs.hello.marshal()); err != nil {
+++	if err := transcriptMsg(hs.clientHello, &hs.finishedHash); err != nil {
+++		return err
+++	}
+++	if _, err := hs.c.writeHandshakeRecord(hs.hello, &hs.finishedHash); err != nil {
++ 		return err
++ 	}
++ 
++ 	certMsg := new(certificateMsg)
++ 	certMsg.certificates = hs.cert.Certificate
++-	hs.finishedHash.Write(certMsg.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, certMsg.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(certMsg, &hs.finishedHash); err != nil {
++ 		return err
++ 	}
++ 
++ 	if hs.hello.ocspStapling {
++ 		certStatus := new(certificateStatusMsg)
++ 		certStatus.response = hs.cert.OCSPStaple
++-		hs.finishedHash.Write(certStatus.marshal())
++-		if _, err := c.writeRecord(recordTypeHandshake, certStatus.marshal()); err != nil {
+++		if _, err := hs.c.writeHandshakeRecord(certStatus, &hs.finishedHash); err != nil {
++ 			return err
++ 		}
++ 	}
++@@ -525,8 +527,7 @@ func (hs *serverHandshakeState) doFullHa
++ 		return err
++ 	}
++ 	if skx != nil {
++-		hs.finishedHash.Write(skx.marshal())
++-		if _, err := c.writeRecord(recordTypeHandshake, skx.marshal()); err != nil {
+++		if _, err := hs.c.writeHandshakeRecord(skx, &hs.finishedHash); err != nil {
++ 			return err
++ 		}
++ 	}
++@@ -552,15 +553,13 @@ func (hs *serverHandshakeState) doFullHa
++ 		if c.config.ClientCAs != nil {
++ 			certReq.certificateAuthorities = c.config.ClientCAs.Subjects()
++ 		}
++-		hs.finishedHash.Write(certReq.marshal())
++-		if _, err := c.writeRecord(recordTypeHandshake, certReq.marshal()); err != nil {
+++		if _, err := hs.c.writeHandshakeRecord(certReq, &hs.finishedHash); err != nil {
++ 			return err
++ 		}
++ 	}
++ 
++ 	helloDone := new(serverHelloDoneMsg)
++-	hs.finishedHash.Write(helloDone.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, helloDone.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(helloDone, &hs.finishedHash); err != nil {
++ 		return err
++ 	}
++ 
++@@ -570,7 +569,7 @@ func (hs *serverHandshakeState) doFullHa
++ 
++ 	var pub crypto.PublicKey // public key for client auth, if any
++ 
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(&hs.finishedHash)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -583,7 +582,6 @@ func (hs *serverHandshakeState) doFullHa
++ 			c.sendAlert(alertUnexpectedMessage)
++ 			return unexpectedMessageError(certMsg, msg)
++ 		}
++-		hs.finishedHash.Write(certMsg.marshal())
++ 
++ 		if err := c.processCertsFromClient(Certificate{
++ 			Certificate: certMsg.certificates,
++@@ -594,7 +592,7 @@ func (hs *serverHandshakeState) doFullHa
++ 			pub = c.peerCertificates[0].PublicKey
++ 		}
++ 
++-		msg, err = c.readHandshake()
+++		msg, err = c.readHandshake(&hs.finishedHash)
++ 		if err != nil {
++ 			return err
++ 		}
++@@ -612,7 +610,6 @@ func (hs *serverHandshakeState) doFullHa
++ 		c.sendAlert(alertUnexpectedMessage)
++ 		return unexpectedMessageError(ckx, msg)
++ 	}
++-	hs.finishedHash.Write(ckx.marshal())
++ 
++ 	preMasterSecret, err := keyAgreement.processClientKeyExchange(c.config, hs.cert, ckx, c.vers)
++ 	if err != nil {
++@@ -632,7 +629,10 @@ func (hs *serverHandshakeState) doFullHa
++ 	// to the client's certificate. This allows us to verify that the client is in
++ 	// possession of the private key of the certificate.
++ 	if len(c.peerCertificates) > 0 {
++-		msg, err = c.readHandshake()
+++		// certificateVerifyMsg is included in the transcript, but not until
+++		// after we verify the handshake signature, since the state before
+++		// this message was sent is used.
+++		msg, err = c.readHandshake(nil)
++ 		if err != nil {
++ 			return err
++ 		}
++@@ -667,7 +667,9 @@ func (hs *serverHandshakeState) doFullHa
++ 			return errors.New("tls: invalid signature by the client certificate: " + err.Error())
++ 		}
++ 
++-		hs.finishedHash.Write(certVerify.marshal())
+++		if err := transcriptMsg(certVerify, &hs.finishedHash); err != nil {
+++			return err
+++		}
++ 	}
++ 
++ 	hs.finishedHash.discardHandshakeBuffer()
++@@ -707,7 +709,10 @@ func (hs *serverHandshakeState) readFini
++ 		return err
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	// finishedMsg is included in the transcript, but not until after we
+++	// check the client version, since the state before this message was
+++	// sent is used during verification.
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -724,7 +729,10 @@ func (hs *serverHandshakeState) readFini
++ 		return errors.New("tls: client's Finished message is incorrect")
++ 	}
++ 
++-	hs.finishedHash.Write(clientFinished.marshal())
+++	if err := transcriptMsg(clientFinished, &hs.finishedHash); err != nil {
+++		return err
+++	}
+++
++ 	copy(out, verify)
++ 	return nil
++ }
++@@ -758,14 +766,16 @@ func (hs *serverHandshakeState) sendSess
++ 		masterSecret: hs.masterSecret,
++ 		certificates: certsFromClient,
++ 	}
++-	var err error
++-	m.ticket, err = c.encryptTicket(state.marshal())
+++	stateBytes, err := state.marshal()
+++	if err != nil {
+++		return err
+++	}
+++	m.ticket, err = c.encryptTicket(stateBytes)
++ 	if err != nil {
++ 		return err
++ 	}
++ 
++-	hs.finishedHash.Write(m.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, m.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(m, &hs.finishedHash); err != nil {
++ 		return err
++ 	}
++ 
++@@ -775,14 +785,13 @@ func (hs *serverHandshakeState) sendSess
++ func (hs *serverHandshakeState) sendFinished(out []byte) error {
++ 	c := hs.c
++ 
++-	if _, err := c.writeRecord(recordTypeChangeCipherSpec, []byte{1}); err != nil {
+++	if err := c.writeChangeCipherRecord(); err != nil {
++ 		return err
++ 	}
++ 
++ 	finished := new(finishedMsg)
++ 	finished.verifyData = hs.finishedHash.serverSum(hs.masterSecret)
++-	hs.finishedHash.Write(finished.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, finished.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(finished, &hs.finishedHash); err != nil {
++ 		return err
++ 	}
++ 
++--- go.orig/src/crypto/tls/handshake_server_test.go
+++++ go/src/crypto/tls/handshake_server_test.go
++@@ -30,6 +30,13 @@ func testClientHello(t *testing.T, serve
++ 	testClientHelloFailure(t, serverConfig, m, "")
++ }
++ 
+++// testFatal is a hack to prevent the compiler from complaining that there is a
+++// call to t.Fatal from a non-test goroutine
+++func testFatal(t *testing.T, err error) {
+++	t.Helper()
+++	t.Fatal(err)
+++}
+++
++ func testClientHelloFailure(t *testing.T, serverConfig *Config, m handshakeMessage, expectedSubStr string) {
++ 	c, s := localPipe(t)
++ 	go func() {
++@@ -37,7 +44,9 @@ func testClientHelloFailure(t *testing.T
++ 		if ch, ok := m.(*clientHelloMsg); ok {
++ 			cli.vers = ch.vers
++ 		}
++-		cli.writeRecord(recordTypeHandshake, m.marshal())
+++		if _, err := cli.writeHandshakeRecord(m, nil); err != nil {
+++			testFatal(t, err)
+++		}
++ 		c.Close()
++ 	}()
++ 	ctx := context.Background()
++@@ -194,7 +203,9 @@ func TestRenegotiationExtension(t *testi
++ 	go func() {
++ 		cli := Client(c, testConfig)
++ 		cli.vers = clientHello.vers
++-		cli.writeRecord(recordTypeHandshake, clientHello.marshal())
+++		if _, err := cli.writeHandshakeRecord(clientHello, nil); err != nil {
+++			testFatal(t, err)
+++		}
++ 
++ 		buf := make([]byte, 1024)
++ 		n, err := c.Read(buf)
++@@ -253,8 +264,10 @@ func TestTLS12OnlyCipherSuites(t *testin
++ 	go func() {
++ 		cli := Client(c, testConfig)
++ 		cli.vers = clientHello.vers
++-		cli.writeRecord(recordTypeHandshake, clientHello.marshal())
++-		reply, err := cli.readHandshake()
+++		if _, err := cli.writeHandshakeRecord(clientHello, nil); err != nil {
+++			testFatal(t, err)
+++		}
+++		reply, err := cli.readHandshake(nil)
++ 		c.Close()
++ 		if err != nil {
++ 			replyChan <- err
++@@ -308,8 +321,10 @@ func TestTLSPointFormats(t *testing.T) {
++ 			go func() {
++ 				cli := Client(c, testConfig)
++ 				cli.vers = clientHello.vers
++-				cli.writeRecord(recordTypeHandshake, clientHello.marshal())
++-				reply, err := cli.readHandshake()
+++				if _, err := cli.writeHandshakeRecord(clientHello, nil); err != nil {
+++					testFatal(t, err)
+++				}
+++				reply, err := cli.readHandshake(nil)
++ 				c.Close()
++ 				if err != nil {
++ 					replyChan <- err
++@@ -1425,7 +1440,9 @@ func TestSNIGivenOnFailure(t *testing.T)
++ 	go func() {
++ 		cli := Client(c, testConfig)
++ 		cli.vers = clientHello.vers
++-		cli.writeRecord(recordTypeHandshake, clientHello.marshal())
+++		if _, err := cli.writeHandshakeRecord(clientHello, nil); err != nil {
+++			testFatal(t, err)
+++		}
++ 		c.Close()
++ 	}()
++ 	conn := Server(s, serverConfig)
++--- go.orig/src/crypto/tls/handshake_server_tls13.go
+++++ go/src/crypto/tls/handshake_server_tls13.go
++@@ -298,7 +298,12 @@ func (hs *serverHandshakeStateTLS13) che
++ 			c.sendAlert(alertInternalError)
++ 			return errors.New("tls: internal error: failed to clone hash")
++ 		}
++-		transcript.Write(hs.clientHello.marshalWithoutBinders())
+++		clientHelloBytes, err := hs.clientHello.marshalWithoutBinders()
+++		if err != nil {
+++			c.sendAlert(alertInternalError)
+++			return err
+++		}
+++		transcript.Write(clientHelloBytes)
++ 		pskBinder := hs.suite.finishedHash(binderKey, transcript)
++ 		if !hmac.Equal(hs.clientHello.pskBinders[i], pskBinder) {
++ 			c.sendAlert(alertDecryptError)
++@@ -389,8 +394,7 @@ func (hs *serverHandshakeStateTLS13) sen
++ 	}
++ 	hs.sentDummyCCS = true
++ 
++-	_, err := hs.c.writeRecord(recordTypeChangeCipherSpec, []byte{1})
++-	return err
+++	return hs.c.writeChangeCipherRecord()
++ }
++ 
++ func (hs *serverHandshakeStateTLS13) doHelloRetryRequest(selectedGroup CurveID) error {
++@@ -398,7 +402,9 @@ func (hs *serverHandshakeStateTLS13) doH
++ 
++ 	// The first ClientHello gets double-hashed into the transcript upon a
++ 	// HelloRetryRequest. See RFC 8446, Section 4.4.1.
++-	hs.transcript.Write(hs.clientHello.marshal())
+++	if err := transcriptMsg(hs.clientHello, hs.transcript); err != nil {
+++		return err
+++	}
++ 	chHash := hs.transcript.Sum(nil)
++ 	hs.transcript.Reset()
++ 	hs.transcript.Write([]byte{typeMessageHash, 0, 0, uint8(len(chHash))})
++@@ -414,8 +420,7 @@ func (hs *serverHandshakeStateTLS13) doH
++ 		selectedGroup:     selectedGroup,
++ 	}
++ 
++-	hs.transcript.Write(helloRetryRequest.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, helloRetryRequest.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(helloRetryRequest, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -423,7 +428,8 @@ func (hs *serverHandshakeStateTLS13) doH
++ 		return err
++ 	}
++ 
++-	msg, err := c.readHandshake()
+++	// clientHelloMsg is not included in the transcript.
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -514,9 +520,10 @@ func illegalClientHelloChange(ch, ch1 *c
++ func (hs *serverHandshakeStateTLS13) sendServerParameters() error {
++ 	c := hs.c
++ 
++-	hs.transcript.Write(hs.clientHello.marshal())
++-	hs.transcript.Write(hs.hello.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, hs.hello.marshal()); err != nil {
+++	if err := transcriptMsg(hs.clientHello, hs.transcript); err != nil {
+++		return err
+++	}
+++	if _, err := hs.c.writeHandshakeRecord(hs.hello, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -559,8 +566,7 @@ func (hs *serverHandshakeStateTLS13) sen
++ 	encryptedExtensions.alpnProtocol = selectedProto
++ 	c.clientProtocol = selectedProto
++ 
++-	hs.transcript.Write(encryptedExtensions.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, encryptedExtensions.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(encryptedExtensions, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -589,8 +595,7 @@ func (hs *serverHandshakeStateTLS13) sen
++ 			certReq.certificateAuthorities = c.config.ClientCAs.Subjects()
++ 		}
++ 
++-		hs.transcript.Write(certReq.marshal())
++-		if _, err := c.writeRecord(recordTypeHandshake, certReq.marshal()); err != nil {
+++		if _, err := hs.c.writeHandshakeRecord(certReq, hs.transcript); err != nil {
++ 			return err
++ 		}
++ 	}
++@@ -601,8 +606,7 @@ func (hs *serverHandshakeStateTLS13) sen
++ 	certMsg.scts = hs.clientHello.scts && len(hs.cert.SignedCertificateTimestamps) > 0
++ 	certMsg.ocspStapling = hs.clientHello.ocspStapling && len(hs.cert.OCSPStaple) > 0
++ 
++-	hs.transcript.Write(certMsg.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, certMsg.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(certMsg, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -633,8 +637,7 @@ func (hs *serverHandshakeStateTLS13) sen
++ 	}
++ 	certVerifyMsg.signature = sig
++ 
++-	hs.transcript.Write(certVerifyMsg.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, certVerifyMsg.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(certVerifyMsg, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -648,8 +651,7 @@ func (hs *serverHandshakeStateTLS13) sen
++ 		verifyData: hs.suite.finishedHash(c.out.trafficSecret, hs.transcript),
++ 	}
++ 
++-	hs.transcript.Write(finished.marshal())
++-	if _, err := c.writeRecord(recordTypeHandshake, finished.marshal()); err != nil {
+++	if _, err := hs.c.writeHandshakeRecord(finished, hs.transcript); err != nil {
++ 		return err
++ 	}
++ 
++@@ -710,7 +712,9 @@ func (hs *serverHandshakeStateTLS13) sen
++ 	finishedMsg := &finishedMsg{
++ 		verifyData: hs.clientFinished,
++ 	}
++-	hs.transcript.Write(finishedMsg.marshal())
+++	if err := transcriptMsg(finishedMsg, hs.transcript); err != nil {
+++		return err
+++	}
++ 
++ 	if !hs.shouldSendSessionTickets() {
++ 		return nil
++@@ -735,8 +739,12 @@ func (hs *serverHandshakeStateTLS13) sen
++ 			SignedCertificateTimestamps: c.scts,
++ 		},
++ 	}
++-	var err error
++-	m.label, err = c.encryptTicket(state.marshal())
+++	stateBytes, err := state.marshal()
+++	if err != nil {
+++		c.sendAlert(alertInternalError)
+++		return err
+++	}
+++	m.label, err = c.encryptTicket(stateBytes)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -755,7 +763,7 @@ func (hs *serverHandshakeStateTLS13) sen
++ 	// ticket_nonce, which must be unique per connection, is always left at
++ 	// zero because we only ever send one ticket per connection.
++ 
++-	if _, err := c.writeRecord(recordTypeHandshake, m.marshal()); err != nil {
+++	if _, err := c.writeHandshakeRecord(m, nil); err != nil {
++ 		return err
++ 	}
++ 
++@@ -780,7 +788,7 @@ func (hs *serverHandshakeStateTLS13) rea
++ 	// If we requested a client certificate, then the client must send a
++ 	// certificate message. If it's empty, no CertificateVerify is sent.
++ 
++-	msg, err := c.readHandshake()
+++	msg, err := c.readHandshake(hs.transcript)
++ 	if err != nil {
++ 		return err
++ 	}
++@@ -790,7 +798,6 @@ func (hs *serverHandshakeStateTLS13) rea
++ 		c.sendAlert(alertUnexpectedMessage)
++ 		return unexpectedMessageError(certMsg, msg)
++ 	}
++-	hs.transcript.Write(certMsg.marshal())
++ 
++ 	if err := c.processCertsFromClient(certMsg.certificate); err != nil {
++ 		return err
++@@ -804,7 +811,10 @@ func (hs *serverHandshakeStateTLS13) rea
++ 	}
++ 
++ 	if len(certMsg.certificate.Certificate) != 0 {
++-		msg, err = c.readHandshake()
+++		// certificateVerifyMsg is included in the transcript, but not until
+++		// after we verify the handshake signature, since the state before
+++		// this message was sent is used.
+++		msg, err = c.readHandshake(nil)
++ 		if err != nil {
++ 			return err
++ 		}
++@@ -835,7 +845,9 @@ func (hs *serverHandshakeStateTLS13) rea
++ 			return errors.New("tls: invalid signature by the client certificate: " + err.Error())
++ 		}
++ 
++-		hs.transcript.Write(certVerify.marshal())
+++		if err := transcriptMsg(certVerify, hs.transcript); err != nil {
+++			return err
+++		}
++ 	}
++ 
++ 	// If we waited until the client certificates to send session tickets, we
++@@ -850,7 +862,8 @@ func (hs *serverHandshakeStateTLS13) rea
++ func (hs *serverHandshakeStateTLS13) readClientFinished() error {
++ 	c := hs.c
++ 
++-	msg, err := c.readHandshake()
+++	// finishedMsg is not included in the transcript.
+++	msg, err := c.readHandshake(nil)
++ 	if err != nil {
++ 		return err
++ 	}
++--- go.orig/src/crypto/tls/key_schedule.go
+++++ go/src/crypto/tls/key_schedule.go
++@@ -8,6 +8,7 @@ import (
++ 	"crypto/elliptic"
++ 	"crypto/hmac"
++ 	"errors"
+++	"fmt"
++ 	"hash"
++ 	"io"
++ 	"math/big"
++@@ -42,8 +43,24 @@ func (c *cipherSuiteTLS13) expandLabel(s
++ 	hkdfLabel.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) {
++ 		b.AddBytes(context)
++ 	})
+++	hkdfLabelBytes, err := hkdfLabel.Bytes()
+++	if err != nil {
+++		// Rather than calling BytesOrPanic, we explicitly handle this error, in
+++		// order to provide a reasonable error message. It should be basically
+++		// impossible for this to panic, and routing errors back through the
+++		// tree rooted in this function is quite painful. The labels are fixed
+++		// size, and the context is either a fixed-length computed hash, or
+++		// parsed from a field which has the same length limitation. As such, an
+++		// error here is likely to only be caused during development.
+++		//
+++		// NOTE: another reasonable approach here might be to return a
+++		// randomized slice if we encounter an error, which would break the
+++		// connection, but avoid panicking. This would perhaps be safer but
+++		// significantly more confusing to users.
+++		panic(fmt.Errorf("failed to construct HKDF label: %s", err))
+++	}
++ 	out := make([]byte, length)
++-	n, err := hkdf.Expand(c.hash.New, secret, hkdfLabel.BytesOrPanic()).Read(out)
+++	n, err := hkdf.Expand(c.hash.New, secret, hkdfLabelBytes).Read(out)
++ 	if err != nil || n != length {
++ 		panic("tls: HKDF-Expand-Label invocation failed unexpectedly")
++ 	}
++--- go.orig/src/crypto/tls/ticket.go
+++++ go/src/crypto/tls/ticket.go
++@@ -32,7 +32,7 @@ type sessionState struct {
++ 	usedOldKey bool
++ }
++ 
++-func (m *sessionState) marshal() []byte {
+++func (m *sessionState) marshal() ([]byte, error) {
++ 	var b cryptobyte.Builder
++ 	b.AddUint16(m.vers)
++ 	b.AddUint16(m.cipherSuite)
++@@ -47,7 +47,7 @@ func (m *sessionState) marshal() []byte
++ 			})
++ 		}
++ 	})
++-	return b.BytesOrPanic()
+++	return b.Bytes()
++ }
++ 
++ func (m *sessionState) unmarshal(data []byte) bool {
++@@ -86,7 +86,7 @@ type sessionStateTLS13 struct {
++ 	certificate      Certificate // CertificateEntry certificate_list<0..2^24-1>;
++ }
++ 
++-func (m *sessionStateTLS13) marshal() []byte {
+++func (m *sessionStateTLS13) marshal() ([]byte, error) {
++ 	var b cryptobyte.Builder
++ 	b.AddUint16(VersionTLS13)
++ 	b.AddUint8(0) // revision
++@@ -96,7 +96,7 @@ func (m *sessionStateTLS13) marshal() []
++ 		b.AddBytes(m.resumptionSecret)
++ 	})
++ 	marshalCertificate(&b, m.certificate)
++-	return b.BytesOrPanic()
+++	return b.Bytes()
++ }
++ 
++ func (m *sessionStateTLS13) unmarshal(data []byte) bool {
+diff --git a/meta/recipes-devtools/go/go-1.19/cve-2022-41725.patch b/meta/recipes-devtools/go/go-1.19/cve-2022-41725.patch
+new file mode 100644
+index 0000000000..a71d07e3f1
+--- /dev/null
++++ b/meta/recipes-devtools/go/go-1.19/cve-2022-41725.patch
+@@ -0,0 +1,652 @@
++From 5c55ac9bf1e5f779220294c843526536605f42ab Mon Sep 17 00:00:00 2001
++From: Damien Neil <[email protected]>
++Date: Wed, 25 Jan 2023 09:27:01 -0800
++Subject: [PATCH] [release-branch.go1.19] mime/multipart: limit memory/inode
++ consumption of ReadForm
++
++Reader.ReadForm is documented as storing "up to maxMemory bytes + 10MB"
++in memory. Parsed forms can consume substantially more memory than
++this limit, since ReadForm does not account for map entry overhead
++and MIME headers.
++
++In addition, while the amount of disk memory consumed by ReadForm can
++be constrained by limiting the size of the parsed input, ReadForm will
++create one temporary file per form part stored on disk, potentially
++consuming a large number of inodes.
++
++Update ReadForm's memory accounting to include part names,
++MIME headers, and map entry overhead.
++
++Update ReadForm to store all on-disk file parts in a single
++temporary file.
++
++Files returned by FileHeader.Open are documented as having a concrete
++type of *os.File when a file is stored on disk. The change to use a
++single temporary file for all parts means that this is no longer the
++case when a form contains more than a single file part stored on disk.
++
++The previous behavior of storing each file part in a separate disk
++file may be reenabled with GODEBUG=multipartfiles=distinct.
++
++Update Reader.NextPart and Reader.NextRawPart to set a 10MiB cap
++on the size of MIME headers.
++
++Thanks to Jakob Ackermann (@das7pad) for reporting this issue.
++
++Updates #58006
++Fixes #58362
++Fixes CVE-2022-41725
++
++Change-Id: Ibd780a6c4c83ac8bcfd3cbe344f042e9940f2eab
++Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1714276
++Reviewed-by: Julie Qiu <[email protected]>
++TryBot-Result: Security TryBots <[email protected]>
++Reviewed-by: Roland Shoemaker <[email protected]>
++Run-TryBot: Damien Neil <[email protected]>
++(cherry picked from commit ed4664330edcd91b24914c9371c377c132dbce8c)
++Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1728949
++Reviewed-by: Tatiana Bradley <[email protected]>
++Run-TryBot: Roland Shoemaker <[email protected]>
++Reviewed-by: Damien Neil <[email protected]>
++Reviewed-on: https://go-review.googlesource.com/c/go/+/468116
++TryBot-Result: Gopher Robot <[email protected]>
++Reviewed-by: Than McIntosh <[email protected]>
++Run-TryBot: Michael Pratt <[email protected]>
++Auto-Submit: Michael Pratt <[email protected]>
++---
++
++CVE: CVE-2022-41725
++
++Upstream-Status: Backport [see text]
++
++https://github.com/golong/go.git commit 5c55ac9bf1e5...
++modified for reader.go
++
++Signed-off-by: Joe Slater <[email protected]>
++
++___
++ src/mime/multipart/formdata.go       | 132 ++++++++++++++++++++-----
++ src/mime/multipart/formdata_test.go  | 140 ++++++++++++++++++++++++++-
++ src/mime/multipart/multipart.go      |  25 +++--
++ src/mime/multipart/readmimeheader.go |  14 +++
++ src/net/http/request_test.go         |   2 +-
++ src/net/textproto/reader.go          |  20 +++-
++ 6 files changed, 295 insertions(+), 38 deletions(-)
++ create mode 100644 src/mime/multipart/readmimeheader.go
++
++--- go.orig/src/mime/multipart/formdata.go
+++++ go/src/mime/multipart/formdata.go
++@@ -7,6 +7,7 @@ package multipart
++ import (
++ 	"bytes"
++ 	"errors"
+++	"internal/godebug"
++ 	"io"
++ 	"math"
++ 	"net/textproto"
++@@ -33,23 +34,58 @@ func (r *Reader) ReadForm(maxMemory int6
++ 
++ func (r *Reader) readForm(maxMemory int64) (_ *Form, err error) {
++ 	form := &Form{make(map[string][]string), make(map[string][]*FileHeader)}
+++	var (
+++		file    *os.File
+++		fileOff int64
+++	)
+++	numDiskFiles := 0
+++	multipartFiles := godebug.Get("multipartfiles")
+++	combineFiles := multipartFiles != "distinct"
++ 	defer func() {
+++		if file != nil {
+++			if cerr := file.Close(); err == nil {
+++				err = cerr
+++			}
+++		}
+++		if combineFiles && numDiskFiles > 1 {
+++			for _, fhs := range form.File {
+++				for _, fh := range fhs {
+++					fh.tmpshared = true
+++				}
+++			}
+++		}
++ 		if err != nil {
++ 			form.RemoveAll()
+++			if file != nil {
+++				os.Remove(file.Name())
+++			}
++ 		}
++ 	}()
++ 
++-	// Reserve an additional 10 MB for non-file parts.
++-	maxValueBytes := maxMemory + int64(10<<20)
++-	if maxValueBytes <= 0 {
+++	// maxFileMemoryBytes is the maximum bytes of file data we will store in memory.
+++	// Data past this limit is written to disk.
+++	// This limit strictly applies to content, not metadata (filenames, MIME headers, etc.),
+++	// since metadata is always stored in memory, not disk.
+++	//
+++	// maxMemoryBytes is the maximum bytes we will store in memory, including file content,
+++	// non-file part values, metdata, and map entry overhead.
+++	//
+++	// We reserve an additional 10 MB in maxMemoryBytes for non-file data.
+++	//
+++	// The relationship between these parameters, as well as the overly-large and
+++	// unconfigurable 10 MB added on to maxMemory, is unfortunate but difficult to change
+++	// within the constraints of the API as documented.
+++	maxFileMemoryBytes := maxMemory
+++	maxMemoryBytes := maxMemory + int64(10<<20)
+++	if maxMemoryBytes <= 0 {
++ 		if maxMemory < 0 {
++-			maxValueBytes = 0
+++			maxMemoryBytes = 0
++ 		} else {
++-			maxValueBytes = math.MaxInt64
+++			maxMemoryBytes = math.MaxInt64
++ 		}
++ 	}
++ 	for {
++-		p, err := r.NextPart()
+++		p, err := r.nextPart(false, maxMemoryBytes)
++ 		if err == io.EOF {
++ 			break
++ 		}
++@@ -63,16 +99,27 @@ func (r *Reader) readForm(maxMemory int6
++ 		}
++ 		filename := p.FileName()
++ 
+++		// Multiple values for the same key (one map entry, longer slice) are cheaper
+++		// than the same number of values for different keys (many map entries), but
+++		// using a consistent per-value cost for overhead is simpler.
+++		maxMemoryBytes -= int64(len(name))
+++		maxMemoryBytes -= 100 // map overhead
+++		if maxMemoryBytes < 0 {
+++			// We can't actually take this path, since nextPart would already have
+++			// rejected the MIME headers for being too large. Check anyway.
+++			return nil, ErrMessageTooLarge
+++		}
+++
++ 		var b bytes.Buffer
++ 
++ 		if filename == "" {
++ 			// value, store as string in memory
++-			n, err := io.CopyN(&b, p, maxValueBytes+1)
+++			n, err := io.CopyN(&b, p, maxMemoryBytes+1)
++ 			if err != nil && err != io.EOF {
++ 				return nil, err
++ 			}
++-			maxValueBytes -= n
++-			if maxValueBytes < 0 {
+++			maxMemoryBytes -= n
+++			if maxMemoryBytes < 0 {
++ 				return nil, ErrMessageTooLarge
++ 			}
++ 			form.Value[name] = append(form.Value[name], b.String())
++@@ -80,35 +127,45 @@ func (r *Reader) readForm(maxMemory int6
++ 		}
++ 
++ 		// file, store in memory or on disk
+++		maxMemoryBytes -= mimeHeaderSize(p.Header)
+++		if maxMemoryBytes < 0 {
+++			return nil, ErrMessageTooLarge
+++		}
++ 		fh := &FileHeader{
++ 			Filename: filename,
++ 			Header:   p.Header,
++ 		}
++-		n, err := io.CopyN(&b, p, maxMemory+1)
+++		n, err := io.CopyN(&b, p, maxFileMemoryBytes+1)
++ 		if err != nil && err != io.EOF {
++ 			return nil, err
++ 		}
++-		if n > maxMemory {
++-			// too big, write to disk and flush buffer
++-			file, err := os.CreateTemp("", "multipart-")
++-			if err != nil {
++-				return nil, err
+++		if n > maxFileMemoryBytes {
+++			if file == nil {
+++				file, err = os.CreateTemp(r.tempDir, "multipart-")
+++				if err != nil {
+++					return nil, err
+++				}
++ 			}
+++			numDiskFiles++
++ 			size, err := io.Copy(file, io.MultiReader(&b, p))
++-			if cerr := file.Close(); err == nil {
++-				err = cerr
++-			}
++ 			if err != nil {
++-				os.Remove(file.Name())
++ 				return nil, err
++ 			}
++ 			fh.tmpfile = file.Name()
++ 			fh.Size = size
+++			fh.tmpoff = fileOff
+++			fileOff += size
+++			if !combineFiles {
+++				if err := file.Close(); err != nil {
+++					return nil, err
+++				}
+++				file = nil
+++			}
++ 		} else {
++ 			fh.content = b.Bytes()
++ 			fh.Size = int64(len(fh.content))
++-			maxMemory -= n
++-			maxValueBytes -= n
+++			maxFileMemoryBytes -= n
+++			maxMemoryBytes -= n
++ 		}
++ 		form.File[name] = append(form.File[name], fh)
++ 	}
++@@ -116,6 +173,17 @@ func (r *Reader) readForm(maxMemory int6
++ 	return form, nil
++ }
++ 
+++func mimeHeaderSize(h textproto.MIMEHeader) (size int64) {
+++	for k, vs := range h {
+++		size += int64(len(k))
+++		size += 100 // map entry overhead
+++		for _, v := range vs {
+++			size += int64(len(v))
+++		}
+++	}
+++	return size
+++}
+++
++ // Form is a parsed multipart form.
++ // Its File parts are stored either in memory or on disk,
++ // and are accessible via the *FileHeader's Open method.
++@@ -133,7 +201,7 @@ func (f *Form) RemoveAll() error {
++ 		for _, fh := range fhs {
++ 			if fh.tmpfile != "" {
++ 				e := os.Remove(fh.tmpfile)
++-				if e != nil && err == nil {
+++				if e != nil && !errors.Is(e, os.ErrNotExist) && err == nil {
++ 					err = e
++ 				}
++ 			}
++@@ -148,15 +216,25 @@ type FileHeader struct {
++ 	Header   textproto.MIMEHeader
++ 	Size     int64
++ 
++-	content []byte
++-	tmpfile string
+++	content   []byte
+++	tmpfile   string
+++	tmpoff    int64
+++	tmpshared bool
++ }
++ 
++ // Open opens and returns the FileHeader's associated File.
++ func (fh *FileHeader) Open() (File, error) {
++ 	if b := fh.content; b != nil {
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

meta/recipes-devtools/go/go-1.17.13.inc +4 -1
index 14d58932dc..23380f04c3 100644

Lines of this file are not shown. View the raw message.

meta/recipes-devtools/go/go-1.19/add_godebug.patch new file +84 -0

84 lines not on this page · raw message

meta/recipes-devtools/go/go-1.19/cve-2022-41724.patch new file +2391 -0

2,391 lines not on this page · raw message

meta/recipes-devtools/go/go-1.19/cve-2022-41725.patch new file +652 -0

652 lines not on this page · raw message

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.25.1

Part of the diff is not shown here. View the raw message.

#1 lore raw

Hello Joe,

Quoted 10 lines · On Wed, 12 Apr 2023 11:32:06 -0700 "Joe Slater" <[email protected]>…

Backport from go-1.19. The godebug package is needed by the fix to CVE-2022-41725.

Mostly a cherry-pick but exceptions are noted in comments marked "backport".

---
 ...01-go-fix-CVE-2022-41723-41724-41725.patch | 3373 +++++++++++++++++
 meta/recipes-devtools/go/go-1.17.13.inc       |    5 +-

I understand this patch is wrong, being mased on kirkstone, so you sent a fixed versions with the '[kirkstone]' subject tag shortly after, and this one should be ignored. Is this correct?

Best regards,
Luca

Signature · 3 lines
Luca Ceresoli, Bootlin
Embedded Linux and Kernel engineering
https://bootlin.com
#2 lore raw
Quoted 21 lines

-----Original Message-----
From: Luca Ceresoli <[email protected]>
Sent: Wednesday, April 12, 2023 1:39 PM
To: Slater, Joseph <[email protected]>
Cc: [email protected]; MacLeod, Randy <[email protected]>
Subject: Re: [oe-core][PATCH 1/1] go: fix CVE-2022-41724, 41725

Hello Joe,

Quoted 6 lines · On Wed, 12 Apr 2023 11:32:06 -0700 "Joe Slater" <[email protected]>…

Backport from go-1.19. The godebug package is needed by the fix to CVE-2022-41725.

Mostly a cherry-pick but exceptions are noted in comments marked "backport".

Quoted 8 lines
Quoted 4 lines
---
 ...01-go-fix-CVE-2022-41723-41724-41725.patch | 3373 +++++++++++++++++
 meta/recipes-devtools/go/go-1.17.13.inc       |    5 +-

I understand this patch is wrong, being mased on kirkstone, so you sent a fixed versions with the '[kirkstone]' subject tag shortly after, and this one should be ignored. Is this correct?

[Slater, Joseph] Yes, sorry for the noise. I forgot the kirkstone label. I think this patch also includes a bogus file I somehow committed while switching branches and generating patches for my internal use.

Joe

Quoted 8 lines

Best regards,
Luca

--
Luca Ceresoli, Bootlin
Embedded Linux and Kernel engineering
https://bootlin.com