t.Run(fmt.Sprintf("curve=%d", curveid), func(t *testing.T) {
			clientConfig := testConfig.Clone()
			clientConfig.CurvePreferences = []CurveID{curveid}
			if curveid == x25519Kyber768Draft00 {
				// x25519Kyber768Draft00 is not supported standalone.
				clientConfig.CurvePreferences = append(clientConfig.CurvePreferences, X25519)
			}
			if _, _, err := testHandshake(t, clientConfig, serverConfig); err != nil {

	return xhttp.ConnSettings{
		LookupHost:       globalDNSCache.LookupHost,
		DialTimeout:      rest.DefaultTimeout,
		RootCAs:          globalRootCAs,
		CipherSuites:     fips.TLSCiphers(),
		CurvePreferences: fips.TLSCurveIDs(),
		EnableHTTP2:      false,
		TCPOptions:       globalTCPOptions,
	}.NewInternodeHTTPTransport(maxIdleConnsPerHost)
}

// NewHTTPTransportWithClientCerts returns a new http configuration

	if len(*curves) != 0 {
		for _, curveStr := range *curves {
			id, err := strconv.Atoi(curveStr)
			if err != nil {
				log.Fatalf("failed to parse curve id %q: %s", curveStr, err)
			}
			cfg.CurvePreferences = append(cfg.CurvePreferences, CurveID(id))
		}
	}

	for i := 0; i < *resumeCount+1; i++ {
		if i > 0 && (*onResumeECHConfigListB64 != "") {
			echConfigList, err := base64.StdEncoding.DecodeString(*onResumeECHConfigListB64)

		extendedMasterSecret:         true,
		ocspStapling:                 true,
		scts:                         true,
		serverName:                   hostnameInSNI(config.ServerName),
		supportedCurves:              config.curvePreferences(maxVersion),
		supportedPoints:              []uint8{pointFormatUncompressed},
		secureRenegotiationSupported: true,
		alpnProtocols:                config.NextProtos,
		supportedVersions:            supportedVersions,

		// because we currently only support it at all when CurvePreferences is
		// empty, which will cause us to also send a key share for it.
		//
		// This will have to change once we support selecting hybrid KEMs
		// without sending key shares for them.
		if _, ok := curveForCurveID(curveID); !ok {
			c.sendAlert(alertInternalError)
			return errors.New("tls: CurvePreferences includes unsupported curve")
		}

			break
		}
	}

	if curveID == 0 {
		return nil, errors.New("tls: no supported elliptic curves offered")
	}
	if _, ok := curveForCurveID(curveID); !ok {
		return nil, errors.New("tls: CurvePreferences includes unsupported curve")
	}

	key, err := generateECDHEKey(config.rand(), curveID)
	if err != nil {
		return nil, err
	}
	ka.key = key

	// See RFC 4492, Section 5.4.

	// priority to key shares, to avoid a HelloRetryRequest round-trip.
	var selectedGroup CurveID
	var clientKeyShare *keyShare
	preferredGroups := c.config.curvePreferences(c.vers)
	for _, preferredGroup := range preferredGroups {
		ki := slices.IndexFunc(hs.clientHello.keyShares, func(ks keyShare) bool {
			return ks.group == preferredGroup
		})
		if ki != -1 {

		Rand:               zeroSource{},
		Certificates:       make([]Certificate, 2),
		InsecureSkipVerify: true,
		CipherSuites:       allCipherSuites(),
		CurvePreferences:   []CurveID{X25519, CurveP256, CurveP384, CurveP521},
		MinVersion:         VersionTLS10,
		MaxVersion:         VersionTLS13,
	}
	testConfig.Certificates[0].Certificate = [][]byte{testRSACertificate}

Go 1.23 enabled the experimental post-quantum key exchange mechanism
X25519Kyber768Draft00 by default. The default can be reverted using the
[`tlskyber` setting](/pkg/crypto/tls/#Config.CurvePreferences).

Go 1.23 changed the behavior of
[crypto/x509.ParseCertificate](/pkg/crypto/x509/#ParseCertificate) to reject
serial numbers that are negative. This change can be reverted with