@ttsc/darwin-x64 0.13.1 → 0.14.0-dev.20260528

package/bin/go/VERSION

@@ -1,2 +1,2 @@
-go1.26.3
-time 2026-05-04T20:36:18Z
+go1.26.0
+time 2026-02-10T01:22:00Z

package/bin/go/src/archive/tar/format.go

@@ -147,12 +147,6 @@ const (
 	// Max length of a special file (PAX header, GNU long name or link).
 	// This matches the limit used by libarchive.
 	maxSpecialFileSize = 1 << 20
-
-	// Maximum number of sparse file entries.
-	// We should never actually hit this limit
-	// (every sparse encoding will first be limited by maxSpecialFileSize),
-	// but this adds an additional layer of defense.
-	maxSparseFileEntries = 1 << 20
 )
 
 // blockPadding computes the number of bytes needed to pad offset up to the

package/bin/go/src/archive/tar/reader.go

@@ -490,8 +490,7 @@ func (tr *Reader) readOldGNUSparseMap(hdr *Header, blk *block) (sparseDatas, err
 	}
 	s := blk.toGNU().sparse()
 	spd := make(sparseDatas, 0, s.maxEntries())
-	totalSize := len(s)
-	for totalSize < maxSpecialFileSize {
+	for {
 		for i := 0; i < s.maxEntries(); i++ {
 			// This termination condition is identical to GNU and BSD tar.
 			if s.entry(i).offset()[0] == 0x00 {
@@ -502,11 +501,7 @@ func (tr *Reader) readOldGNUSparseMap(hdr *Header, blk *block) (sparseDatas, err
 			if p.err != nil {
 				return nil, p.err
 			}
-			var err error
-			spd, err = appendSparseEntry(spd, sparseEntry{Offset: offset, Length: length})
-			if err != nil {
-				return nil, err
-			}
+			spd = append(spd, sparseEntry{Offset: offset, Length: length})
 		}
 
 		if s.isExtended()[0] > 0 {
@@ -515,12 +510,10 @@ func (tr *Reader) readOldGNUSparseMap(hdr *Header, blk *block) (sparseDatas, err
 				return nil, err
 			}
 			s = blk.toSparse()
-			totalSize += len(s)
 			continue
 		}
 		return spd, nil // Done
 	}
-	return nil, errSparseTooLong
 }
 
 // readGNUSparseMap1x0 reads the sparse map as stored in GNU's PAX sparse format
@@ -593,10 +586,7 @@ func readGNUSparseMap1x0(r io.Reader) (sparseDatas, error) {
 		if err1 != nil || err2 != nil {
 			return nil, ErrHeader
 		}
-		spd, err = appendSparseEntry(spd, sparseEntry{Offset: offset, Length: length})
-		if err != nil {
-			return nil, err
-		}
+		spd = append(spd, sparseEntry{Offset: offset, Length: length})
 	}
 	return spd, nil
 }
@@ -630,22 +620,12 @@ func readGNUSparseMap0x1(paxHdrs map[string]string) (sparseDatas, error) {
 		if err1 != nil || err2 != nil {
 			return nil, ErrHeader
 		}
-		spd, err = appendSparseEntry(spd, sparseEntry{Offset: offset, Length: length})
-		if err != nil {
-			return nil, err
-		}
+		spd = append(spd, sparseEntry{Offset: offset, Length: length})
 		sparseMap = sparseMap[2:]
 	}
 	return spd, nil
 }
 
-func appendSparseEntry(spd sparseDatas, ent sparseEntry) (sparseDatas, error) {
-	if len(spd) >= maxSparseFileEntries {
-		return nil, errSparseTooLong
-	}
-	return append(spd, ent), nil
-}
-
 // Read reads from the current file in the tar archive.
 // It returns (0, io.EOF) when it reaches the end of that file,
 // until [Next] is called to advance to the next file.

package/bin/go/src/builtin/builtin.go

@@ -122,10 +122,6 @@ type Type int
 // invocation.
 type Type1 int
 
-// TypeOrExpr is here for the purposes of documentation only. It is a stand-in
-// for either a Go type or an expression.
-type TypeOrExpr int
-
 // IntegerType is here for the purposes of documentation only. It is a stand-in
 // for any integer type: int, uint, int8 etc.
 type IntegerType int
@@ -224,15 +220,10 @@ func max[T cmp.Ordered](x T, y ...T) T
 // min will return NaN.
 func min[T cmp.Ordered](x T, y ...T) T
 
-// The built-in function new allocates a new, initialized variable and returns
-// a pointer to it. It accepts a single argument, which may be either a type
-// or an expression.
-// If the argument is a type T, then new(T) allocates a variable of type T
-// initialized to its zero value.
-// Otherwise, the argument is an expression x and new(x) allocates a variable
-// of the type of x initialized to the value of x. If that value is an untyped
-// constant, it is first implicitly converted to its default type.
-func new(TypeOrExpr) *Type
+// The new built-in function allocates memory. The first argument is a type,
+// not a value, and the value returned is a pointer to a newly
+// allocated zero value of that type.
+func new(Type) *Type
 
 // The complex built-in function constructs a complex value from two
 // floating-point values. The real and imaginary parts must be of the same

package/bin/go/src/crypto/fips140/fips140.go

@@ -2,12 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package fips140 provides information about the FIPS 140-3 Go Cryptographic
-// Module and FIPS 140-3 mode.
-//
-// For more details, see the [FIPS 140-3 documentation].
-//
-// [FIPS 140-3 documentation]: https://go.dev/doc/security/fips140
 package fips140
 
 import (

package/bin/go/src/crypto/internal/fips140/drbg/rand.go

@@ -9,11 +9,55 @@
 package drbg
 
 import (
+	entropy "crypto/internal/entropy/v1.0.0"
 	"crypto/internal/fips140"
 	"crypto/internal/sysrand"
 	"io"
+	"sync"
+	"sync/atomic"
 )
 
+// memory is a scratch buffer that is accessed between samples by the entropy
+// source to expose it to memory access timings.
+//
+// We reuse it and share it between Seed calls to avoid the significant (~500µs)
+// cost of zeroing a new allocation every time. The entropy source accesses it
+// using atomics (and doesn't care about its contents).
+//
+// It should end up in the .noptrbss section, and become backed by physical pages
+// at first use. This ensures that programs that do not use the FIPS 140-3 module
+// do not incur any memory use or initialization penalties.
+var memory entropy.ScratchBuffer
+
+func getEntropy() *[SeedSize]byte {
+	var retries int
+	seed, err := entropy.Seed(&memory)
+	for err != nil {
+		// The CPU jitter-based SP 800-90B entropy source has a non-negligible
+		// chance of failing the startup health tests.
+		//
+		// Each time it does, it enters a permanent failure state, and we
+		// restart it anew. This is not expected to happen more than a few times
+		// in a row.
+		if retries++; retries > 100 {
+			panic("fips140/drbg: failed to obtain initial entropy")
+		}
+		seed, err = entropy.Seed(&memory)
+	}
+	return &seed
+}
+
+// getEntropy is very slow (~500µs), so we don't want it on the hot path.
+// We keep both a persistent DRBG instance and a pool of additional instances.
+// Occasional uses will use drbgInstance, even if the pool was emptied since the
+// last use. Frequent concurrent uses will fill the pool and use it.
+var drbgInstance atomic.Pointer[Counter]
+var drbgPool = sync.Pool{
+	New: func() any {
+		return NewCounter(getEntropy())
+	},
+}
+
 // Read fills b with cryptographically secure random bytes. In FIPS mode, it
 // uses an SP 800-90A Rev. 1 Deterministic Random Bit Generator (DRBG).
 // Otherwise, it uses the operating system's random number generator.
@@ -32,7 +76,37 @@ func Read(b []byte) {
 		return
 	}
 
-	readFromEntropy(b)
+	// At every read, 128 random bits from the operating system are mixed as
+	// additional input, to make the output as strong as non-FIPS randomness.
+	// This is not credited as entropy for FIPS purposes, as allowed by Section
+	// 8.7.2: "Note that a DRBG does not rely on additional input to provide
+	// entropy, even though entropy could be provided in the additional input".
+	additionalInput := new([SeedSize]byte)
+	sysrand.Read(additionalInput[:16])
+
+	drbg := drbgInstance.Swap(nil)
+	if drbg == nil {
+		drbg = drbgPool.Get().(*Counter)
+	}
+	defer func() {
+		if !drbgInstance.CompareAndSwap(nil, drbg) {
+			drbgPool.Put(drbg)
+		}
+	}()
+
+	for len(b) > 0 {
+		size := min(len(b), maxRequestSize)
+		if reseedRequired := drbg.Generate(b[:size], additionalInput); reseedRequired {
+			// See SP 800-90A Rev. 1, Section 9.3.1, Steps 6-8, as explained in
+			// Section 9.3.2: if Generate reports a reseed is required, the
+			// additional input is passed to Reseed along with the entropy and
+			// then nulled before the next Generate call.
+			drbg.Reseed(getEntropy(), additionalInput)
+			additionalInput = nil
+			continue
+		}
+		b = b[size:]
+	}
 }
 
 var testingReader io.Reader

package/bin/go/src/crypto/tls/conn.go

@@ -1363,7 +1363,7 @@ func (c *Conn) handleKeyUpdate(keyUpdate *keyUpdateMsg) error {
 	}
 
 	newSecret := cipherSuite.nextTrafficSecret(c.in.trafficSecret)
-	if err := c.setReadTrafficSecret(cipherSuite, QUICEncryptionLevelInitial, newSecret, keyUpdate.updateRequested); err != nil {
+	if err := c.setReadTrafficSecret(cipherSuite, QUICEncryptionLevelInitial, newSecret); err != nil {
 		return err
 	}
 
@@ -1683,16 +1683,12 @@ func (c *Conn) VerifyHostname(host string) error {
 // setReadTrafficSecret sets the read traffic secret for the given encryption level. If
 // being called at the same time as setWriteTrafficSecret, the caller must ensure the call
 // to setWriteTrafficSecret happens first so any alerts are sent at the write level.
-func (c *Conn) setReadTrafficSecret(suite *cipherSuiteTLS13, level QUICEncryptionLevel, secret []byte, locked bool) error {
+func (c *Conn) setReadTrafficSecret(suite *cipherSuiteTLS13, level QUICEncryptionLevel, secret []byte) error {
 	// Ensure that there are no buffered handshake messages before changing the
 	// read keys, since that can cause messages to be parsed that were encrypted
 	// using old keys which are no longer appropriate.
 	if c.hand.Len() != 0 {
-		if locked {
-			c.sendAlertLocked(alertUnexpectedMessage)
-		} else {
-			c.sendAlert(alertUnexpectedMessage)
-		}
+		c.sendAlert(alertUnexpectedMessage)
 		return errors.New("tls: handshake buffer not empty before setting read traffic secret")
 	}
 	c.in.setTrafficSecret(suite, level, secret)

package/bin/go/src/crypto/tls/handshake_client_tls13.go

@@ -492,7 +492,7 @@ func (hs *clientHandshakeStateTLS13) establishHandshakeKeys() error {
 	clientSecret := handshakeSecret.ClientHandshakeTrafficSecret(hs.transcript)
 	c.setWriteTrafficSecret(hs.suite, QUICEncryptionLevelHandshake, clientSecret)
 	serverSecret := handshakeSecret.ServerHandshakeTrafficSecret(hs.transcript)
-	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelHandshake, serverSecret, false); err != nil {
+	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelHandshake, serverSecret); err != nil {
 		return err
 	}
 
@@ -711,7 +711,7 @@ func (hs *clientHandshakeStateTLS13) readServerFinished() error {
 
 	hs.trafficSecret = hs.masterSecret.ClientApplicationTrafficSecret(hs.transcript)
 	serverSecret := hs.masterSecret.ServerApplicationTrafficSecret(hs.transcript)
-	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelApplication, serverSecret, false); err != nil {
+	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelApplication, serverSecret); err != nil {
 		return err
 	}
 

package/bin/go/src/crypto/tls/handshake_server_tls13.go

@@ -752,7 +752,7 @@ func (hs *serverHandshakeStateTLS13) sendServerParameters() error {
 	serverSecret := hs.handshakeSecret.ServerHandshakeTrafficSecret(hs.transcript)
 	c.setWriteTrafficSecret(hs.suite, QUICEncryptionLevelHandshake, serverSecret)
 	clientSecret := hs.handshakeSecret.ClientHandshakeTrafficSecret(hs.transcript)
-	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelHandshake, clientSecret, false); err != nil {
+	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelHandshake, clientSecret); err != nil {
 		return err
 	}
 
@@ -1136,7 +1136,7 @@ func (hs *serverHandshakeStateTLS13) readClientFinished() error {
 		return errors.New("tls: invalid client finished hash")
 	}
 
-	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelApplication, hs.trafficSecret, false); err != nil {
+	if err := c.setReadTrafficSecret(hs.suite, QUICEncryptionLevelApplication, hs.trafficSecret); err != nil {
 		return err
 	}
 

package/bin/go/src/crypto/tls/key_schedule.go

@@ -7,7 +7,6 @@ package tls
 import (
 	"crypto"
 	"crypto/ecdh"
-	"crypto/fips140"
 	"crypto/hmac"
 	"crypto/internal/fips140/tls13"
 	"crypto/mlkem"
@@ -166,14 +165,7 @@ type hybridKeyExchange struct {
 }
 
 func (ke *hybridKeyExchange) keyShares(rand io.Reader) (*keySharePrivateKeys, []keyShare, error) {
-	var (
-		priv       *keySharePrivateKeys
-		ecdhShares []keyShare
-		err        error
-	)
-	fips140.WithoutEnforcement(func() { // Hybrid of ML-KEM, which is Approved.
-		priv, ecdhShares, err = ke.ecdh.keyShares(rand)
-	})
+	priv, ecdhShares, err := ke.ecdh.keyShares(rand)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -209,14 +201,7 @@ func (ke *hybridKeyExchange) serverSharedSecret(rand io.Reader, clientKeyShare [
 		ecdhShareData = clientKeyShare[:ke.ecdhElementSize]
 		mlkemShareData = clientKeyShare[ke.ecdhElementSize:]
 	}
-	var (
-		ecdhSharedSecret []byte
-		ks               keyShare
-		err              error
-	)
-	fips140.WithoutEnforcement(func() { // Hybrid of ML-KEM, which is Approved.
-		ecdhSharedSecret, ks, err = ke.ecdh.serverSharedSecret(rand, ecdhShareData)
-	})
+	ecdhSharedSecret, ks, err := ke.ecdh.serverSharedSecret(rand, ecdhShareData)
 	if err != nil {
 		return nil, keyShare{}, err
 	}
@@ -249,13 +234,7 @@ func (ke *hybridKeyExchange) clientSharedSecret(priv *keySharePrivateKeys, serve
 		ecdhShareData = serverKeyShare[:ke.ecdhElementSize]
 		mlkemShareData = serverKeyShare[ke.ecdhElementSize:]
 	}
-	var (
-		ecdhSharedSecret []byte
-		err              error
-	)
-	fips140.WithoutEnforcement(func() { // Hybrid of ML-KEM, which is Approved.
-		ecdhSharedSecret, err = ke.ecdh.clientSharedSecret(priv, ecdhShareData)
-	})
+	ecdhSharedSecret, err := ke.ecdh.clientSharedSecret(priv, ecdhShareData)
 	if err != nil {
 		return nil, err
 	}

package/bin/go/src/crypto/x509/constraints.go

@@ -58,11 +58,11 @@ import (
 // of nameConstraintsSet, to handle constraints which define full email
 // addresses (i.e. 'test@example.com'). For bare domain constraints, we use the
 // dnsConstraints type described above, querying the domain portion of the email
-// address. For full email addresses, we also hold a map of email addresses with
-// the domain portion of the email lowercased, since it is case insensitive. When
-// looking up an email address in the constraint set, we first check the full
-// email address map, and if we don't find anything, we check the domain portion
-// of the email address against the dnsConstraints.
+// address. For full email addresses, we also hold a map of email addresses that
+// map the local portion of the email to the domain. When querying full email
+// addresses we then check if the local portion of the email is present in the
+// map, and if so case insensitively compare the domain portion of the
+// email.
 
 type nameConstraintsSet[T *net.IPNet | string, V net.IP | string] struct {
 	set []T
@@ -351,7 +351,6 @@ func newDNSConstraints(l []string, permitted bool) interface{ query(string) (str
 	if !permitted {
 		parentConstraints := map[string]string{}
 		for _, name := range nc.constraints.set {
-			name = strings.ToLower(name)
 			trimmedName := trimFirstLabel(name)
 			if trimmedName == "" {
 				continue
@@ -376,8 +375,7 @@ func (dnc *dnsConstraints) query(s string) (string, bool) {
 		return constraint, true
 	}
 
-	if !dnc.permitted && len(s) > 0 && s[0] == '*' {
-		s = strings.ToLower(s)
+	if !dnc.permitted && s[0] == '*' {
 		trimmed := trimFirstLabel(s)
 		if constraint, found := dnc.parentConstraints[trimmed]; found {
 			return constraint, true
@@ -389,22 +387,16 @@ func (dnc *dnsConstraints) query(s string) (string, bool) {
 type emailConstraints struct {
 	dnsConstraints interface{ query(string) (string, bool) }
 
-	// fullEmails is map of rfc2821Mailboxs that are fully specified in the
-	// constraints, which we need to check for separately since they don't
-	// follow the same matching rules as the domain-based constraints. The
-	// domain portion of the rfc2821Mailbox has been lowercased, since the
-	// domain portion is case insensitive. When checking the map for an email,
-	// the domain portion of the query should also be lowercased.
-	fullEmails map[rfc2821Mailbox]struct{}
+	fullEmails map[string]string
 }
 
 func newEmailConstraints(l []string, permitted bool) interface {
-	query(rfc2821Mailbox) (string, bool)
+	query(parsedEmail) (string, bool)
 } {
 	if len(l) == 0 {
 		return nil
 	}
-	exactMap := map[rfc2821Mailbox]struct{}{}
+	exactMap := map[string]string{}
 	var domains []string
 	for _, c := range l {
 		if !strings.ContainsRune(c, '@') {
@@ -419,8 +411,7 @@ func newEmailConstraints(l []string, permitted bool) interface {
 			// certificate since parsing.
 			continue
 		}
-		parsed.domain = strings.ToLower(parsed.domain)
-		exactMap[parsed] = struct{}{}
+		exactMap[parsed.local] = parsed.domain
 	}
 	ec := &emailConstraints{
 		fullEmails: exactMap,
@@ -431,16 +422,16 @@ func newEmailConstraints(l []string, permitted bool) interface {
 	return ec
 }
 
-func (ec *emailConstraints) query(s rfc2821Mailbox) (string, bool) {
-	if len(ec.fullEmails) > 0 {
-		if _, ok := ec.fullEmails[s]; ok {
-			return fmt.Sprintf("%s@%s", s.local, s.domain), true
+func (ec *emailConstraints) query(s parsedEmail) (string, bool) {
+	if len(ec.fullEmails) > 0 && strings.ContainsRune(s.email, '@') {
+		if domain, ok := ec.fullEmails[s.mailbox.local]; ok && strings.EqualFold(domain, s.mailbox.domain) {
+			return ec.fullEmails[s.email] + "@" + s.mailbox.domain, true
 		}
 	}
 	if ec.dnsConstraints == nil {
 		return "", false
 	}
-	constraint, found := ec.dnsConstraints.query(s.domain)
+	constraint, found := ec.dnsConstraints.query(s.mailbox.domain)
 	return constraint, found
 }
 
@@ -450,7 +441,7 @@ type constraints[T any, V any] struct {
 	excluded       interface{ query(V) (T, bool) }
 }
 
-func checkConstraints[T string | *net.IPNet, V any, P string | net.IP | parsedURI | rfc2821Mailbox](c constraints[T, V], s V, p P) error {
+func checkConstraints[T string | *net.IPNet, V any, P string | net.IP | parsedURI | parsedEmail](c constraints[T, V], s V, p P) error {
 	if c.permitted != nil {
 		if _, found := c.permitted.query(s); !found {
 			return fmt.Errorf("%s %q is not permitted by any constraint", c.constraintType, p)
@@ -468,13 +459,13 @@ type chainConstraints struct {
 	ip    constraints[*net.IPNet, net.IP]
 	dns   constraints[string, string]
 	uri   constraints[string, string]
-	email constraints[string, rfc2821Mailbox]
+	email constraints[string, parsedEmail]
 
 	index int
 	next  *chainConstraints
 }
 
-func (cc *chainConstraints) check(dns []string, uris []parsedURI, emails []rfc2821Mailbox, ips []net.IP) error {
+func (cc *chainConstraints) check(dns []string, uris []parsedURI, emails []parsedEmail, ips []net.IP) error {
 	for _, ip := range ips {
 		if err := checkConstraints(cc.ip, ip, ip); err != nil {
 			return err
@@ -497,8 +488,8 @@ func (cc *chainConstraints) check(dns []string, uris []parsedURI, emails []rfc28
 		}
 	}
 	for _, e := range emails {
-		if !domainNameValid(e.domain, false) {
-			return fmt.Errorf("x509: cannot parse rfc822Name %q", e)
+		if !domainNameValid(e.mailbox.domain, false) {
+			return fmt.Errorf("x509: cannot parse rfc822Name %q", e.mailbox)
 		}
 		if err := checkConstraints(cc.email, e, e); err != nil {
 			return err
@@ -518,7 +509,7 @@ func checkChainConstraints(chain []*Certificate) error {
 			ip:    constraints[*net.IPNet, net.IP]{"IP address", newIPNetConstraints(c.PermittedIPRanges), newIPNetConstraints(c.ExcludedIPRanges)},
 			dns:   constraints[string, string]{"DNS name", newDNSConstraints(c.PermittedDNSDomains, true), newDNSConstraints(c.ExcludedDNSDomains, false)},
 			uri:   constraints[string, string]{"URI", newDNSConstraints(c.PermittedURIDomains, true), newDNSConstraints(c.ExcludedURIDomains, false)},
-			email: constraints[string, rfc2821Mailbox]{"email address", newEmailConstraints(c.PermittedEmailAddresses, true), newEmailConstraints(c.ExcludedEmailAddresses, false)},
+			email: constraints[string, parsedEmail]{"email address", newEmailConstraints(c.PermittedEmailAddresses, true), newEmailConstraints(c.ExcludedEmailAddresses, false)},
 			index: i,
 		}
 		if currentConstraints == nil {
@@ -601,15 +592,24 @@ func parseURIs(uris []*url.URL) ([]parsedURI, error) {
 	return parsed, nil
 }
 
-func parseMailboxes(emails []string) ([]rfc2821Mailbox, error) {
-	parsed := make([]rfc2821Mailbox, 0, len(emails))
+type parsedEmail struct {
+	email   string
+	mailbox *rfc2821Mailbox
+}
+
+func (e parsedEmail) String() string {
+	return e.mailbox.local + "@" + e.mailbox.domain
+}
+
+func parseMailboxes(emails []string) ([]parsedEmail, error) {
+	parsed := make([]parsedEmail, 0, len(emails))
 	for _, email := range emails {
 		mailbox, ok := parseRFC2821Mailbox(email)
 		if !ok {
 			return nil, fmt.Errorf("cannot parse rfc822Name %q", email)
 		}
 		mailbox.domain = strings.ToLower(mailbox.domain)
-		parsed = append(parsed, mailbox)
+		parsed = append(parsed, parsedEmail{strings.ToLower(email), &mailbox})
 	}
 	return parsed, nil
 }

package/bin/go/src/crypto/x509/verify.go

@@ -253,10 +253,6 @@ type rfc2821Mailbox struct {
 	local, domain string
 }
 
-func (s rfc2821Mailbox) String() string {
-	return fmt.Sprintf("%s@%s", s.local, s.domain)
-}
-
 // parseRFC2821Mailbox parses an email address into local and domain parts,
 // based on the ABNF for a “Mailbox” from RFC 2821. According to RFC 5280,
 // Section 4.2.1.6 that's correct for an rfc822Name from a certificate: “The
@@ -720,8 +716,6 @@ func alreadyInChain(candidate *Certificate, chain []*Certificate) bool {
 // for failed checks due to different intermediates having the same Subject.
 const maxChainSignatureChecks = 100
 
-var errSignatureLimit = errors.New("x509: signature check attempts limit reached while verifying certificate chain")
-
 func (c *Certificate) buildChains(currentChain []*Certificate, sigChecks *int, opts *VerifyOptions) (chains [][]*Certificate, err error) {
 	var (
 		hintErr  error
@@ -729,16 +723,16 @@ func (c *Certificate) buildChains(currentChain []*Certificate, sigChecks *int, o
 	)
 
 	considerCandidate := func(certType int, candidate potentialParent) {
+		if candidate.cert.PublicKey == nil || alreadyInChain(candidate.cert, currentChain) {
+			return
+		}
+
 		if sigChecks == nil {
 			sigChecks = new(int)
 		}
 		*sigChecks++
 		if *sigChecks > maxChainSignatureChecks {
-			err = errSignatureLimit
-			return
-		}
-
-		if candidate.cert.PublicKey == nil || alreadyInChain(candidate.cert, currentChain) {
+			err = errors.New("x509: signature check attempts limit reached while verifying certificate chain")
 			return
 		}
 
@@ -779,20 +773,11 @@ func (c *Certificate) buildChains(currentChain []*Certificate, sigChecks *int, o
 		}
 	}
 
-candidateLoop:
-	for _, parents := range []struct {
-		certType   int
-		potentials []potentialParent
-	}{
-		{rootCertificate, opts.Roots.findPotentialParents(c)},
-		{intermediateCertificate, opts.Intermediates.findPotentialParents(c)},
-	} {
-		for _, parent := range parents.potentials {
-			considerCandidate(parents.certType, parent)
-			if err == errSignatureLimit {
-				break candidateLoop
-			}
-		}
+	for _, root := range opts.Roots.findPotentialParents(c) {
+		considerCandidate(rootCertificate, root)
+	}
+	for _, intermediate := range opts.Intermediates.findPotentialParents(c) {
+		considerCandidate(intermediateCertificate, intermediate)
 	}
 
 	if len(chains) > 0 {
@@ -1295,12 +1280,12 @@ func policiesValid(chain []*Certificate, opts VerifyOptions) bool {
 						} else {
 							// 6.1.4 (b) (3) (i) -- as updated by RFC 9618
 							pg.deleteLeaf(mapping.IssuerDomainPolicy)
+
+							// 6.1.4 (b) (3) (ii) -- as updated by RFC 9618
+							pg.prune()
 						}
 					}
 
-					// 6.1.4 (b) (3) (ii) -- as updated by RFC 9618
-					pg.prune()
-
 					for issuerStr, subjectPolicies := range mappings {
 						// 6.1.4 (b) (1) -- as updated by RFC 9618
 						if matching := pg.leafWithPolicy(OID{der: []byte(issuerStr)}); matching != nil {

package/bin/go/src/go/types/builtins.go

@@ -115,7 +115,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 				for _, u := range typeset(y.typ) {
 					if s, _ := u.(*Slice); s != nil && Identical(s.elem, universeByte) {
 						// typeset ⊇ {[]byte}
-					} else if u != nil && isString(u) {
+					} else if isString(u) {
 						// typeset ⊇ {string}
 						hasString = true
 					} else {
@@ -378,7 +378,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			for _, u := range typeset(y.typ) {
 				if s, _ := u.(*Slice); s != nil && Identical(s.elem, universeByte) {
 					// typeset ⊇ {[]byte}
-				} else if u != nil && isString(u) {
+				} else if isString(u) {
 					// typeset ⊇ {string}
 				} else {
 					special = false

package/bin/go/src/go/types/signature.go

@@ -74,9 +74,6 @@ func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params
 		last := params.At(n - 1).typ
 		var S *Slice
 		for t := range typeset(last) {
-			if t == nil {
-				break
-			}
 			var s *Slice
 			if isString(t) {
 				s = NewSlice(universeByte)