src/crypto/tls/handshake_client.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package tls
   6
   7 import (
   8         "bytes"
   9         "context"
  10         "crypto"
  11         "crypto/ecdh"
  12         "crypto/ecdsa"
  13         "crypto/ed25519"
  14         "crypto/rsa"
  15         "crypto/subtle"
  16         "crypto/x509"
  17         "errors"
  18         "fmt"
  19         "hash"
  20         "io"
  21         "net"
  22         "strings"
  23         "time"
  24 )
  25
  26 type clientHandshakeState struct {
  27         c            *Conn
  28         ctx          context.Context
  29         serverHello  *serverHelloMsg
  30         hello        *clientHelloMsg
  31         suite        *cipherSuite
  32         finishedHash finishedHash
  33         masterSecret []byte
  34         session      *SessionState // the session being resumed
  35         ticket       []byte        // a fresh ticket received during this handshake
  36 }
  37
  38 var testingOnlyForceClientHelloSignatureAlgorithms []SignatureScheme
  39
  40 func (c *Conn) makeClientHello() (*clientHelloMsg, *ecdh.PrivateKey, error) {
  41         config := c.config
  42         if len(config.ServerName) == 0 && !config.InsecureSkipVerify {
  43                 return nil, nil, errors.New("tls: either ServerName or InsecureSkipVerify must be specified in the tls.Config")
  44         }
  45
  46         nextProtosLength := 0
  47         for _, proto := range config.NextProtos {
  48                 if l := len(proto); l == 0 || l > 255 {
  49                         return nil, nil, errors.New("tls: invalid NextProtos value")
  50                 } else {
  51                         nextProtosLength += 1 + l
  52                 }
  53         }
  54         if nextProtosLength > 0xffff {
  55                 return nil, nil, errors.New("tls: NextProtos values too large")
  56         }
  57
  58         supportedVersions := config.supportedVersions(roleClient)
  59         if len(supportedVersions) == 0 {
  60                 return nil, nil, errors.New("tls: no supported versions satisfy MinVersion and MaxVersion")
  61         }
  62
  63         clientHelloVersion := config.maxSupportedVersion(roleClient)
  64         // The version at the beginning of the ClientHello was capped at TLS 1.2
  65         // for compatibility reasons. The supported_versions extension is used
  66         // to negotiate versions now. See RFC 8446, Section 4.2.1.
  67         if clientHelloVersion > VersionTLS12 {
  68                 clientHelloVersion = VersionTLS12
  69         }
  70
  71         hello := &clientHelloMsg{
  72                 vers:                         clientHelloVersion,
  73                 compressionMethods:           []uint8{compressionNone},
  74                 random:                       make([]byte, 32),
  75                 ocspStapling:                 true,
  76                 scts:                         true,
  77                 serverName:                   hostnameInSNI(config.ServerName),
  78                 supportedCurves:              config.curvePreferences(),
  79                 supportedPoints:              []uint8{pointFormatUncompressed},
  80                 secureRenegotiationSupported: true,
  81                 alpnProtocols:                config.NextProtos,
  82                 supportedVersions:            supportedVersions,
  83         }
  84
  85         if c.handshakes > 0 {
  86                 hello.secureRenegotiation = c.clientFinished[:]
  87         }
  88
  89         preferenceOrder := cipherSuitesPreferenceOrder
  90         if !hasAESGCMHardwareSupport {
  91                 preferenceOrder = cipherSuitesPreferenceOrderNoAES
  92         }
  93         configCipherSuites := config.cipherSuites()
  94         hello.cipherSuites = make([]uint16, 0, len(configCipherSuites))
  95
  96         for _, suiteId := range preferenceOrder {
  97                 suite := mutualCipherSuite(configCipherSuites, suiteId)
  98                 if suite == nil {
  99                         continue
 100                 }
 101                 // Don't advertise TLS 1.2-only cipher suites unless
 102                 // we're attempting TLS 1.2.
 103                 if hello.vers < VersionTLS12 && suite.flags&suiteTLS12 != 0 {
 104                         continue
 105                 }
 106                 hello.cipherSuites = append(hello.cipherSuites, suiteId)
 107         }
 108
 109         _, err := io.ReadFull(config.rand(), hello.random)
 110         if err != nil {
 111                 return nil, nil, errors.New("tls: short read from Rand: " + err.Error())
 112         }
 113
 114         // A random session ID is used to detect when the server accepted a ticket
 115         // and is resuming a session (see RFC 5077). In TLS 1.3, it's always set as
 116         // a compatibility measure (see RFC 8446, Section 4.1.2).
 117         //
 118         // The session ID is not set for QUIC connections (see RFC 9001, Section 8.4).
 119         if c.quic == nil {
 120                 hello.sessionId = make([]byte, 32)
 121                 if _, err := io.ReadFull(config.rand(), hello.sessionId); err != nil {
 122                         return nil, nil, errors.New("tls: short read from Rand: " + err.Error())
 123                 }
 124         }
 125
 126         if hello.vers >= VersionTLS12 {
 127                 hello.supportedSignatureAlgorithms = supportedSignatureAlgorithms()
 128         }
 129         if testingOnlyForceClientHelloSignatureAlgorithms != nil {
 130                 hello.supportedSignatureAlgorithms = testingOnlyForceClientHelloSignatureAlgorithms
 131         }
 132
 133         var key *ecdh.PrivateKey
 134         if hello.supportedVersions[0] == VersionTLS13 {
 135                 if hasAESGCMHardwareSupport {
 136                         hello.cipherSuites = append(hello.cipherSuites, defaultCipherSuitesTLS13...)
 137                 } else {
 138                         hello.cipherSuites = append(hello.cipherSuites, defaultCipherSuitesTLS13NoAES...)
 139                 }
 140
 141                 curveID := config.curvePreferences()[0]
 142                 if _, ok := curveForCurveID(curveID); !ok {
 143                         return nil, nil, errors.New("tls: CurvePreferences includes unsupported curve")
 144                 }
 145                 key, err = generateECDHEKey(config.rand(), curveID)
 146                 if err != nil {
 147                         return nil, nil, err
 148                 }
 149                 hello.keyShares = []keyShare{{group: curveID, data: key.PublicKey().Bytes()}}
 150         }
 151
 152         if c.quic != nil {
 153                 p, err := c.quicGetTransportParameters()
 154                 if err != nil {
 155                         return nil, nil, err
 156                 }
 157                 if p == nil {
 158                         p = []byte{}
 159                 }
 160                 hello.quicTransportParameters = p
 161         }
 162
 163         return hello, key, nil
 164 }
 165
 166 func (c *Conn) clientHandshake(ctx context.Context) (err error) {
 167         if c.config == nil {
 168                 c.config = defaultConfig()
 169         }
 170
 171         // This may be a renegotiation handshake, in which case some fields
 172         // need to be reset.
 173         c.didResume = false
 174
 175         hello, ecdheKey, err := c.makeClientHello()
 176         if err != nil {
 177                 return err
 178         }
 179         c.serverName = hello.serverName
 180
 181         session, earlySecret, binderKey, err := c.loadSession(hello)
 182         if err != nil {
 183                 return err
 184         }
 185         if session != nil {
 186                 defer func() {
 187                         // If we got a handshake failure when resuming a session, throw away
 188                         // the session ticket. See RFC 5077, Section 3.2.
 189                         //
 190                         // RFC 8446 makes no mention of dropping tickets on failure, but it
 191                         // does require servers to abort on invalid binders, so we need to
 192                         // delete tickets to recover from a corrupted PSK.
 193                         if err != nil {
 194                                 if cacheKey := c.clientSessionCacheKey(); cacheKey != "" {
 195                                         c.config.ClientSessionCache.Put(cacheKey, nil)
 196                                 }
 197                         }
 198                 }()
 199         }
 200
 201         if _, err := c.writeHandshakeRecord(hello, nil); err != nil {
 202                 return err
 203         }
 204
 205         // serverHelloMsg is not included in the transcript
 206         msg, err := c.readHandshake(nil)
 207         if err != nil {
 208                 return err
 209         }
 210
 211         serverHello, ok := msg.(*serverHelloMsg)
 212         if !ok {
 213                 c.sendAlert(alertUnexpectedMessage)
 214                 return unexpectedMessageError(serverHello, msg)
 215         }
 216
 217         if err := c.pickTLSVersion(serverHello); err != nil {
 218                 return err
 219         }
 220
 221         // If we are negotiating a protocol version that's lower than what we
 222         // support, check for the server downgrade canaries.
 223         // See RFC 8446, Section 4.1.3.
 224         maxVers := c.config.maxSupportedVersion(roleClient)
 225         tls12Downgrade := string(serverHello.random[24:]) == downgradeCanaryTLS12
 226         tls11Downgrade := string(serverHello.random[24:]) == downgradeCanaryTLS11
 227         if maxVers == VersionTLS13 && c.vers <= VersionTLS12 && (tls12Downgrade || tls11Downgrade) ||
 228                 maxVers == VersionTLS12 && c.vers <= VersionTLS11 && tls11Downgrade {
 229                 c.sendAlert(alertIllegalParameter)
 230                 return errors.New("tls: downgrade attempt detected, possibly due to a MitM attack or a broken middlebox")
 231         }
 232
 233         if c.vers == VersionTLS13 {
 234                 hs := &clientHandshakeStateTLS13{
 235                         c:           c,
 236                         ctx:         ctx,
 237                         serverHello: serverHello,
 238                         hello:       hello,
 239                         ecdheKey:    ecdheKey,
 240                         session:     session,
 241                         earlySecret: earlySecret,
 242                         binderKey:   binderKey,
 243                 }
 244
 245                 // In TLS 1.3, session tickets are delivered after the handshake.
 246                 return hs.handshake()
 247         }
 248
 249         hs := &clientHandshakeState{
 250                 c:           c,
 251                 ctx:         ctx,
 252                 serverHello: serverHello,
 253                 hello:       hello,
 254                 session:     session,
 255         }
 256
 257         if err := hs.handshake(); err != nil {
 258                 return err
 259         }
 260
 261         return nil
 262 }
 263
 264 func (c *Conn) loadSession(hello *clientHelloMsg) (
 265         session *SessionState, earlySecret, binderKey []byte, err error) {
 266         if c.config.SessionTicketsDisabled || c.config.ClientSessionCache == nil {
 267                 return nil, nil, nil, nil
 268         }
 269
 270         hello.ticketSupported = true
 271
 272         if hello.supportedVersions[0] == VersionTLS13 {
 273                 // Require DHE on resumption as it guarantees forward secrecy against
 274                 // compromise of the session ticket key. See RFC 8446, Section 4.2.9.
 275                 hello.pskModes = []uint8{pskModeDHE}
 276         }
 277
 278         // Session resumption is not allowed if renegotiating because
 279         // renegotiation is primarily used to allow a client to send a client
 280         // certificate, which would be skipped if session resumption occurred.
 281         if c.handshakes != 0 {
 282                 return nil, nil, nil, nil
 283         }
 284
 285         // Try to resume a previously negotiated TLS session, if available.
 286         cacheKey := c.clientSessionCacheKey()
 287         if cacheKey == "" {
 288                 return nil, nil, nil, nil
 289         }
 290         cs, ok := c.config.ClientSessionCache.Get(cacheKey)
 291         if !ok || cs == nil {
 292                 return nil, nil, nil, nil
 293         }
 294         session = cs.session
 295
 296         // Check that version used for the previous session is still valid.
 297         versOk := false
 298         for _, v := range hello.supportedVersions {
 299                 if v == session.version {
 300                         versOk = true
 301                         break
 302                 }
 303         }
 304         if !versOk {
 305                 return nil, nil, nil, nil
 306         }
 307
 308         // Check that the cached server certificate is not expired, and that it's
 309         // valid for the ServerName. This should be ensured by the cache key, but
 310         // protect the application from a faulty ClientSessionCache implementation.
 311         if !c.config.InsecureSkipVerify {
 312                 if len(session.verifiedChains) == 0 {
 313                         // The original connection had InsecureSkipVerify, while this doesn't.
 314                         return nil, nil, nil, nil
 315                 }
 316                 serverCert := session.peerCertificates[0]
 317                 if c.config.time().After(serverCert.NotAfter) {
 318                         // Expired certificate, delete the entry.
 319                         c.config.ClientSessionCache.Put(cacheKey, nil)
 320                         return nil, nil, nil, nil
 321                 }
 322                 if err := serverCert.VerifyHostname(c.config.ServerName); err != nil {
 323                         return nil, nil, nil, nil
 324                 }
 325         }
 326
 327         if session.version != VersionTLS13 {
 328                 // In TLS 1.2 the cipher suite must match the resumed session. Ensure we
 329                 // are still offering it.
 330                 if mutualCipherSuite(hello.cipherSuites, session.cipherSuite) == nil {
 331                         return nil, nil, nil, nil
 332                 }
 333
 334                 hello.sessionTicket = cs.ticket
 335                 return
 336         }
 337
 338         // Check that the session ticket is not expired.
 339         if c.config.time().After(time.Unix(int64(session.useBy), 0)) {
 340                 c.config.ClientSessionCache.Put(cacheKey, nil)
 341                 return nil, nil, nil, nil
 342         }
 343
 344         // In TLS 1.3 the KDF hash must match the resumed session. Ensure we
 345         // offer at least one cipher suite with that hash.
 346         cipherSuite := cipherSuiteTLS13ByID(session.cipherSuite)
 347         if cipherSuite == nil {
 348                 return nil, nil, nil, nil
 349         }
 350         cipherSuiteOk := false
 351         for _, offeredID := range hello.cipherSuites {
 352                 offeredSuite := cipherSuiteTLS13ByID(offeredID)
 353                 if offeredSuite != nil && offeredSuite.hash == cipherSuite.hash {
 354                         cipherSuiteOk = true
 355                         break
 356                 }
 357         }
 358         if !cipherSuiteOk {
 359                 return nil, nil, nil, nil
 360         }
 361
 362         // Set the pre_shared_key extension. See RFC 8446, Section 4.2.11.1.
 363         ticketAge := c.config.time().Sub(time.Unix(int64(session.createdAt), 0))
 364         identity := pskIdentity{
 365                 label:               cs.ticket,
 366                 obfuscatedTicketAge: uint32(ticketAge/time.Millisecond) + session.ageAdd,
 367         }
 368         hello.pskIdentities = []pskIdentity{identity}
 369         hello.pskBinders = [][]byte{make([]byte, cipherSuite.hash.Size())}
 370
 371         // Compute the PSK binders. See RFC 8446, Section 4.2.11.2.
 372         earlySecret = cipherSuite.extract(session.secret, nil)
 373         binderKey = cipherSuite.deriveSecret(earlySecret, resumptionBinderLabel, nil)
 374         transcript := cipherSuite.hash.New()
 375         helloBytes, err := hello.marshalWithoutBinders()
 376         if err != nil {
 377                 return nil, nil, nil, err
 378         }
 379         transcript.Write(helloBytes)
 380         pskBinders := [][]byte{cipherSuite.finishedHash(binderKey, transcript)}
 381         if err := hello.updateBinders(pskBinders); err != nil {
 382                 return nil, nil, nil, err
 383         }
 384
 385         return
 386 }
 387
 388 func (c *Conn) pickTLSVersion(serverHello *serverHelloMsg) error {
 389         peerVersion := serverHello.vers
 390         if serverHello.supportedVersion != 0 {
 391                 peerVersion = serverHello.supportedVersion
 392         }
 393
 394         vers, ok := c.config.mutualVersion(roleClient, []uint16{peerVersion})
 395         if !ok {
 396                 c.sendAlert(alertProtocolVersion)
 397                 return fmt.Errorf("tls: server selected unsupported protocol version %x", peerVersion)
 398         }
 399
 400         c.vers = vers
 401         c.haveVers = true
 402         c.in.version = vers
 403         c.out.version = vers
 404
 405         return nil
 406 }
 407
 408 // Does the handshake, either a full one or resumes old session. Requires hs.c,
 409 // hs.hello, hs.serverHello, and, optionally, hs.session to be set.
 410 func (hs *clientHandshakeState) handshake() error {
 411         c := hs.c
 412
 413         isResume, err := hs.processServerHello()
 414         if err != nil {
 415                 return err
 416         }
 417
 418         hs.finishedHash = newFinishedHash(c.vers, hs.suite)
 419
 420         // No signatures of the handshake are needed in a resumption.
 421         // Otherwise, in a full handshake, if we don't have any certificates
 422         // configured then we will never send a CertificateVerify message and
 423         // thus no signatures are needed in that case either.
 424         if isResume || (len(c.config.Certificates) == 0 && c.config.GetClientCertificate == nil) {
 425                 hs.finishedHash.discardHandshakeBuffer()
 426         }
 427
 428         if err := transcriptMsg(hs.hello, &hs.finishedHash); err != nil {
 429                 return err
 430         }
 431         if err := transcriptMsg(hs.serverHello, &hs.finishedHash); err != nil {
 432                 return err
 433         }
 434
 435         c.buffering = true
 436         c.didResume = isResume
 437         if isResume {
 438                 if err := hs.establishKeys(); err != nil {
 439                         return err
 440                 }
 441                 if err := hs.readSessionTicket(); err != nil {
 442                         return err
 443                 }
 444                 if err := hs.readFinished(c.serverFinished[:]); err != nil {
 445                         return err
 446                 }
 447                 c.clientFinishedIsFirst = false
 448                 // Make sure the connection is still being verified whether or not this
 449                 // is a resumption. Resumptions currently don't reverify certificates so
 450                 // they don't call verifyServerCertificate. See Issue 31641.
 451                 if c.config.VerifyConnection != nil {
 452                         if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
 453                                 c.sendAlert(alertBadCertificate)
 454                                 return err
 455                         }
 456                 }
 457                 if err := hs.sendFinished(c.clientFinished[:]); err != nil {
 458                         return err
 459                 }
 460                 if _, err := c.flush(); err != nil {
 461                         return err
 462                 }
 463         } else {
 464                 if err := hs.doFullHandshake(); err != nil {
 465                         return err
 466                 }
 467                 if err := hs.establishKeys(); err != nil {
 468                         return err
 469                 }
 470                 if err := hs.sendFinished(c.clientFinished[:]); err != nil {
 471                         return err
 472                 }
 473                 if _, err := c.flush(); err != nil {
 474                         return err
 475                 }
 476                 c.clientFinishedIsFirst = true
 477                 if err := hs.readSessionTicket(); err != nil {
 478                         return err
 479                 }
 480                 if err := hs.readFinished(c.serverFinished[:]); err != nil {
 481                         return err
 482                 }
 483         }
 484         if err := hs.saveSessionTicket(); err != nil {
 485                 return err
 486         }
 487
 488         c.ekm = ekmFromMasterSecret(c.vers, hs.suite, hs.masterSecret, hs.hello.random, hs.serverHello.random)
 489         c.isHandshakeComplete.Store(true)
 490
 491         return nil
 492 }
 493
 494 func (hs *clientHandshakeState) pickCipherSuite() error {
 495         if hs.suite = mutualCipherSuite(hs.hello.cipherSuites, hs.serverHello.cipherSuite); hs.suite == nil {
 496                 hs.c.sendAlert(alertHandshakeFailure)
 497                 return errors.New("tls: server chose an unconfigured cipher suite")
 498         }
 499
 500         hs.c.cipherSuite = hs.suite.id
 501         return nil
 502 }
 503
 504 func (hs *clientHandshakeState) doFullHandshake() error {
 505         c := hs.c
 506
 507         msg, err := c.readHandshake(&hs.finishedHash)
 508         if err != nil {
 509                 return err
 510         }
 511         certMsg, ok := msg.(*certificateMsg)
 512         if !ok || len(certMsg.certificates) == 0 {
 513                 c.sendAlert(alertUnexpectedMessage)
 514                 return unexpectedMessageError(certMsg, msg)
 515         }
 516
 517         msg, err = c.readHandshake(&hs.finishedHash)
 518         if err != nil {
 519                 return err
 520         }
 521
 522         cs, ok := msg.(*certificateStatusMsg)
 523         if ok {
 524                 // RFC4366 on Certificate Status Request:
 525                 // The server MAY return a "certificate_status" message.
 526
 527                 if !hs.serverHello.ocspStapling {
 528                         // If a server returns a "CertificateStatus" message, then the
 529                         // server MUST have included an extension of type "status_request"
 530                         // with empty "extension_data" in the extended server hello.
 531
 532                         c.sendAlert(alertUnexpectedMessage)
 533                         return errors.New("tls: received unexpected CertificateStatus message")
 534                 }
 535
 536                 c.ocspResponse = cs.response
 537
 538                 msg, err = c.readHandshake(&hs.finishedHash)
 539                 if err != nil {
 540                         return err
 541                 }
 542         }
 543
 544         if c.handshakes == 0 {
 545                 // If this is the first handshake on a connection, process and
 546                 // (optionally) verify the server's certificates.
 547                 if err := c.verifyServerCertificate(certMsg.certificates); err != nil {
 548                         return err
 549                 }
 550         } else {
 551                 // This is a renegotiation handshake. We require that the
 552                 // server's identity (i.e. leaf certificate) is unchanged and
 553                 // thus any previous trust decision is still valid.
 554                 //
 555                 // See https://mitls.org/pages/attacks/3SHAKE for the
 556                 // motivation behind this requirement.
 557                 if !bytes.Equal(c.peerCertificates[0].Raw, certMsg.certificates[0]) {
 558                         c.sendAlert(alertBadCertificate)
 559                         return errors.New("tls: server's identity changed during renegotiation")
 560                 }
 561         }
 562
 563         keyAgreement := hs.suite.ka(c.vers)
 564
 565         skx, ok := msg.(*serverKeyExchangeMsg)
 566         if ok {
 567                 err = keyAgreement.processServerKeyExchange(c.config, hs.hello, hs.serverHello, c.peerCertificates[0], skx)
 568                 if err != nil {
 569                         c.sendAlert(alertUnexpectedMessage)
 570                         return err
 571                 }
 572
 573                 msg, err = c.readHandshake(&hs.finishedHash)
 574                 if err != nil {
 575                         return err
 576                 }
 577         }
 578
 579         var chainToSend *Certificate
 580         var certRequested bool
 581         certReq, ok := msg.(*certificateRequestMsg)
 582         if ok {
 583                 certRequested = true
 584
 585                 cri := certificateRequestInfoFromMsg(hs.ctx, c.vers, certReq)
 586                 if chainToSend, err = c.getClientCertificate(cri); err != nil {
 587                         c.sendAlert(alertInternalError)
 588                         return err
 589                 }
 590
 591                 msg, err = c.readHandshake(&hs.finishedHash)
 592                 if err != nil {
 593                         return err
 594                 }
 595         }
 596
 597         shd, ok := msg.(*serverHelloDoneMsg)
 598         if !ok {
 599                 c.sendAlert(alertUnexpectedMessage)
 600                 return unexpectedMessageError(shd, msg)
 601         }
 602
 603         // If the server requested a certificate then we have to send a
 604         // Certificate message, even if it's empty because we don't have a
 605         // certificate to send.
 606         if certRequested {
 607                 certMsg = new(certificateMsg)
 608                 certMsg.certificates = chainToSend.Certificate
 609                 if _, err := hs.c.writeHandshakeRecord(certMsg, &hs.finishedHash); err != nil {
 610                         return err
 611                 }
 612         }
 613
 614         preMasterSecret, ckx, err := keyAgreement.generateClientKeyExchange(c.config, hs.hello, c.peerCertificates[0])
 615         if err != nil {
 616                 c.sendAlert(alertInternalError)
 617                 return err
 618         }
 619         if ckx != nil {
 620                 if _, err := hs.c.writeHandshakeRecord(ckx, &hs.finishedHash); err != nil {
 621                         return err
 622                 }
 623         }
 624
 625         if chainToSend != nil && len(chainToSend.Certificate) > 0 {
 626                 certVerify := &certificateVerifyMsg{}
 627
 628                 key, ok := chainToSend.PrivateKey.(crypto.Signer)
 629                 if !ok {
 630                         c.sendAlert(alertInternalError)
 631                         return fmt.Errorf("tls: client certificate private key of type %T does not implement crypto.Signer", chainToSend.PrivateKey)
 632                 }
 633
 634                 var sigType uint8
 635                 var sigHash crypto.Hash
 636                 if c.vers >= VersionTLS12 {
 637                         signatureAlgorithm, err := selectSignatureScheme(c.vers, chainToSend, certReq.supportedSignatureAlgorithms)
 638                         if err != nil {
 639                                 c.sendAlert(alertIllegalParameter)
 640                                 return err
 641                         }
 642                         sigType, sigHash, err = typeAndHashFromSignatureScheme(signatureAlgorithm)
 643                         if err != nil {
 644                                 return c.sendAlert(alertInternalError)
 645                         }
 646                         certVerify.hasSignatureAlgorithm = true
 647                         certVerify.signatureAlgorithm = signatureAlgorithm
 648                 } else {
 649                         sigType, sigHash, err = legacyTypeAndHashFromPublicKey(key.Public())
 650                         if err != nil {
 651                                 c.sendAlert(alertIllegalParameter)
 652                                 return err
 653                         }
 654                 }
 655
 656                 signed := hs.finishedHash.hashForClientCertificate(sigType, sigHash)
 657                 signOpts := crypto.SignerOpts(sigHash)
 658                 if sigType == signatureRSAPSS {
 659                         signOpts = &rsa.PSSOptions{SaltLength: rsa.PSSSaltLengthEqualsHash, Hash: sigHash}
 660                 }
 661                 certVerify.signature, err = key.Sign(c.config.rand(), signed, signOpts)
 662                 if err != nil {
 663                         c.sendAlert(alertInternalError)
 664                         return err
 665                 }
 666
 667                 if _, err := hs.c.writeHandshakeRecord(certVerify, &hs.finishedHash); err != nil {
 668                         return err
 669                 }
 670         }
 671
 672         hs.masterSecret = masterFromPreMasterSecret(c.vers, hs.suite, preMasterSecret, hs.hello.random, hs.serverHello.random)
 673         if err := c.config.writeKeyLog(keyLogLabelTLS12, hs.hello.random, hs.masterSecret); err != nil {
 674                 c.sendAlert(alertInternalError)
 675                 return errors.New("tls: failed to write to key log: " + err.Error())
 676         }
 677
 678         hs.finishedHash.discardHandshakeBuffer()
 679
 680         return nil
 681 }
 682
 683 func (hs *clientHandshakeState) establishKeys() error {
 684         c := hs.c
 685
 686         clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV :=
 687                 keysFromMasterSecret(c.vers, hs.suite, hs.masterSecret, hs.hello.random, hs.serverHello.random, hs.suite.macLen, hs.suite.keyLen, hs.suite.ivLen)
 688         var clientCipher, serverCipher any
 689         var clientHash, serverHash hash.Hash
 690         if hs.suite.cipher != nil {
 691                 clientCipher = hs.suite.cipher(clientKey, clientIV, false /* not for reading */)
 692                 clientHash = hs.suite.mac(clientMAC)
 693                 serverCipher = hs.suite.cipher(serverKey, serverIV, true /* for reading */)
 694                 serverHash = hs.suite.mac(serverMAC)
 695         } else {
 696                 clientCipher = hs.suite.aead(clientKey, clientIV)
 697                 serverCipher = hs.suite.aead(serverKey, serverIV)
 698         }
 699
 700         c.in.prepareCipherSpec(c.vers, serverCipher, serverHash)
 701         c.out.prepareCipherSpec(c.vers, clientCipher, clientHash)
 702         return nil
 703 }
 704
 705 func (hs *clientHandshakeState) serverResumedSession() bool {
 706         // If the server responded with the same sessionId then it means the
 707         // sessionTicket is being used to resume a TLS session.
 708         return hs.session != nil && hs.hello.sessionId != nil &&
 709                 bytes.Equal(hs.serverHello.sessionId, hs.hello.sessionId)
 710 }
 711
 712 func (hs *clientHandshakeState) processServerHello() (bool, error) {
 713         c := hs.c
 714
 715         if err := hs.pickCipherSuite(); err != nil {
 716                 return false, err
 717         }
 718
 719         if hs.serverHello.compressionMethod != compressionNone {
 720                 c.sendAlert(alertUnexpectedMessage)
 721                 return false, errors.New("tls: server selected unsupported compression format")
 722         }
 723
 724         if c.handshakes == 0 && hs.serverHello.secureRenegotiationSupported {
 725                 c.secureRenegotiation = true
 726                 if len(hs.serverHello.secureRenegotiation) != 0 {
 727                         c.sendAlert(alertHandshakeFailure)
 728                         return false, errors.New("tls: initial handshake had non-empty renegotiation extension")
 729                 }
 730         }
 731
 732         if c.handshakes > 0 && c.secureRenegotiation {
 733                 var expectedSecureRenegotiation [24]byte
 734                 copy(expectedSecureRenegotiation[:], c.clientFinished[:])
 735                 copy(expectedSecureRenegotiation[12:], c.serverFinished[:])
 736                 if !bytes.Equal(hs.serverHello.secureRenegotiation, expectedSecureRenegotiation[:]) {
 737                         c.sendAlert(alertHandshakeFailure)
 738                         return false, errors.New("tls: incorrect renegotiation extension contents")
 739                 }
 740         }
 741
 742         if err := checkALPN(hs.hello.alpnProtocols, hs.serverHello.alpnProtocol, false); err != nil {
 743                 c.sendAlert(alertUnsupportedExtension)
 744                 return false, err
 745         }
 746         c.clientProtocol = hs.serverHello.alpnProtocol
 747
 748         c.scts = hs.serverHello.scts
 749
 750         if !hs.serverResumedSession() {
 751                 return false, nil
 752         }
 753
 754         if hs.session.version != c.vers {
 755                 c.sendAlert(alertHandshakeFailure)
 756                 return false, errors.New("tls: server resumed a session with a different version")
 757         }
 758
 759         if hs.session.cipherSuite != hs.suite.id {
 760                 c.sendAlert(alertHandshakeFailure)
 761                 return false, errors.New("tls: server resumed a session with a different cipher suite")
 762         }
 763
 764         // Restore master secret and certificates from previous state
 765         hs.masterSecret = hs.session.secret
 766         c.peerCertificates = hs.session.peerCertificates
 767         c.activeCertHandles = hs.c.activeCertHandles
 768         c.verifiedChains = hs.session.verifiedChains
 769         c.ocspResponse = hs.session.ocspResponse
 770         // Let the ServerHello SCTs override the session SCTs from the original
 771         // connection, if any are provided
 772         if len(c.scts) == 0 && len(hs.session.scts) != 0 {
 773                 c.scts = hs.session.scts
 774         }
 775
 776         return true, nil
 777 }
 778
 779 // checkALPN ensure that the server's choice of ALPN protocol is compatible with
 780 // the protocols that we advertised in the Client Hello.
 781 func checkALPN(clientProtos []string, serverProto string, quic bool) error {
 782         if serverProto == "" {
 783                 if quic && len(clientProtos) > 0 {
 784                         // RFC 9001, Section 8.1
 785                         return errors.New("tls: server did not select an ALPN protocol")
 786                 }
 787                 return nil
 788         }
 789         if len(clientProtos) == 0 {
 790                 return errors.New("tls: server advertised unrequested ALPN extension")
 791         }
 792         for _, proto := range clientProtos {
 793                 if proto == serverProto {
 794                         return nil
 795                 }
 796         }
 797         return errors.New("tls: server selected unadvertised ALPN protocol")
 798 }
 799
 800 func (hs *clientHandshakeState) readFinished(out []byte) error {
 801         c := hs.c
 802
 803         if err := c.readChangeCipherSpec(); err != nil {
 804                 return err
 805         }
 806
 807         // finishedMsg is included in the transcript, but not until after we
 808         // check the client version, since the state before this message was
 809         // sent is used during verification.
 810         msg, err := c.readHandshake(nil)
 811         if err != nil {
 812                 return err
 813         }
 814         serverFinished, ok := msg.(*finishedMsg)
 815         if !ok {
 816                 c.sendAlert(alertUnexpectedMessage)
 817                 return unexpectedMessageError(serverFinished, msg)
 818         }
 819
 820         verify := hs.finishedHash.serverSum(hs.masterSecret)
 821         if len(verify) != len(serverFinished.verifyData) ||
 822                 subtle.ConstantTimeCompare(verify, serverFinished.verifyData) != 1 {
 823                 c.sendAlert(alertHandshakeFailure)
 824                 return errors.New("tls: server's Finished message was incorrect")
 825         }
 826
 827         if err := transcriptMsg(serverFinished, &hs.finishedHash); err != nil {
 828                 return err
 829         }
 830
 831         copy(out, verify)
 832         return nil
 833 }
 834
 835 func (hs *clientHandshakeState) readSessionTicket() error {
 836         if !hs.serverHello.ticketSupported {
 837                 return nil
 838         }
 839         c := hs.c
 840
 841         if !hs.hello.ticketSupported {
 842                 c.sendAlert(alertIllegalParameter)
 843                 return errors.New("tls: server sent unrequested session ticket")
 844         }
 845
 846         msg, err := c.readHandshake(&hs.finishedHash)
 847         if err != nil {
 848                 return err
 849         }
 850         sessionTicketMsg, ok := msg.(*newSessionTicketMsg)
 851         if !ok {
 852                 c.sendAlert(alertUnexpectedMessage)
 853                 return unexpectedMessageError(sessionTicketMsg, msg)
 854         }
 855
 856         hs.ticket = sessionTicketMsg.ticket
 857         return nil
 858 }
 859
 860 func (hs *clientHandshakeState) saveSessionTicket() error {
 861         if hs.ticket == nil {
 862                 return nil
 863         }
 864         c := hs.c
 865
 866         cacheKey := c.clientSessionCacheKey()
 867         if cacheKey == "" {
 868                 return nil
 869         }
 870
 871         session, err := c.sessionState()
 872         if err != nil {
 873                 return err
 874         }
 875         session.secret = hs.masterSecret
 876
 877         cs := &ClientSessionState{ticket: hs.ticket, session: session}
 878         c.config.ClientSessionCache.Put(cacheKey, cs)
 879         return nil
 880 }
 881
 882 func (hs *clientHandshakeState) sendFinished(out []byte) error {
 883         c := hs.c
 884
 885         if err := c.writeChangeCipherRecord(); err != nil {
 886                 return err
 887         }
 888
 889         finished := new(finishedMsg)
 890         finished.verifyData = hs.finishedHash.clientSum(hs.masterSecret)
 891         if _, err := hs.c.writeHandshakeRecord(finished, &hs.finishedHash); err != nil {
 892                 return err
 893         }
 894         copy(out, finished.verifyData)
 895         return nil
 896 }
 897
 898 // verifyServerCertificate parses and verifies the provided chain, setting
 899 // c.verifiedChains and c.peerCertificates or sending the appropriate alert.
 900 func (c *Conn) verifyServerCertificate(certificates [][]byte) error {
 901         activeHandles := make([]*activeCert, len(certificates))
 902         certs := make([]*x509.Certificate, len(certificates))
 903         for i, asn1Data := range certificates {
 904                 cert, err := globalCertCache.newCert(asn1Data)
 905                 if err != nil {
 906                         c.sendAlert(alertBadCertificate)
 907                         return errors.New("tls: failed to parse certificate from server: " + err.Error())
 908                 }
 909                 activeHandles[i] = cert
 910                 certs[i] = cert.cert
 911         }
 912
 913         if !c.config.InsecureSkipVerify {
 914                 opts := x509.VerifyOptions{
 915                         Roots:         c.config.RootCAs,
 916                         CurrentTime:   c.config.time(),
 917                         DNSName:       c.config.ServerName,
 918                         Intermediates: x509.NewCertPool(),
 919                 }
 920
 921                 for _, cert := range certs[1:] {
 922                         opts.Intermediates.AddCert(cert)
 923                 }
 924                 var err error
 925                 c.verifiedChains, err = certs[0].Verify(opts)
 926                 if err != nil {
 927                         c.sendAlert(alertBadCertificate)
 928                         return &CertificateVerificationError{UnverifiedCertificates: certs, Err: err}
 929                 }
 930         }
 931
 932         switch certs[0].PublicKey.(type) {
 933         case *rsa.PublicKey, *ecdsa.PublicKey, ed25519.PublicKey:
 934                 break
 935         default:
 936                 c.sendAlert(alertUnsupportedCertificate)
 937                 return fmt.Errorf("tls: server's certificate contains an unsupported type of public key: %T", certs[0].PublicKey)
 938         }
 939
 940         c.activeCertHandles = activeHandles
 941         c.peerCertificates = certs
 942
 943         if c.config.VerifyPeerCertificate != nil {
 944                 if err := c.config.VerifyPeerCertificate(certificates, c.verifiedChains); err != nil {
 945                         c.sendAlert(alertBadCertificate)
 946                         return err
 947                 }
 948         }
 949
 950         if c.config.VerifyConnection != nil {
 951                 if err := c.config.VerifyConnection(c.connectionStateLocked()); err != nil {
 952                         c.sendAlert(alertBadCertificate)
 953                         return err
 954                 }
 955         }
 956
 957         return nil
 958 }
 959
 960 // certificateRequestInfoFromMsg generates a CertificateRequestInfo from a TLS
 961 // <= 1.2 CertificateRequest, making an effort to fill in missing information.
 962 func certificateRequestInfoFromMsg(ctx context.Context, vers uint16, certReq *certificateRequestMsg) *CertificateRequestInfo {
 963         cri := &CertificateRequestInfo{
 964                 AcceptableCAs: certReq.certificateAuthorities,
 965                 Version:       vers,
 966                 ctx:           ctx,
 967         }
 968
 969         var rsaAvail, ecAvail bool
 970         for _, certType := range certReq.certificateTypes {
 971                 switch certType {
 972                 case certTypeRSASign:
 973                         rsaAvail = true
 974                 case certTypeECDSASign:
 975                         ecAvail = true
 976                 }
 977         }
 978
 979         if !certReq.hasSignatureAlgorithm {
 980                 // Prior to TLS 1.2, signature schemes did not exist. In this case we
 981                 // make up a list based on the acceptable certificate types, to help
 982                 // GetClientCertificate and SupportsCertificate select the right certificate.
 983                 // The hash part of the SignatureScheme is a lie here, because
 984                 // TLS 1.0 and 1.1 always use MD5+SHA1 for RSA and SHA1 for ECDSA.
 985                 switch {
 986                 case rsaAvail && ecAvail:
 987                         cri.SignatureSchemes = []SignatureScheme{
 988                                 ECDSAWithP256AndSHA256, ECDSAWithP384AndSHA384, ECDSAWithP521AndSHA512,
 989                                 PKCS1WithSHA256, PKCS1WithSHA384, PKCS1WithSHA512, PKCS1WithSHA1,
 990                         }
 991                 case rsaAvail:
 992                         cri.SignatureSchemes = []SignatureScheme{
 993                                 PKCS1WithSHA256, PKCS1WithSHA384, PKCS1WithSHA512, PKCS1WithSHA1,
 994                         }
 995                 case ecAvail:
 996                         cri.SignatureSchemes = []SignatureScheme{
 997                                 ECDSAWithP256AndSHA256, ECDSAWithP384AndSHA384, ECDSAWithP521AndSHA512,
 998                         }
 999                 }
1000                 return cri
1001         }
1002
1003         // Filter the signature schemes based on the certificate types.
1004         // See RFC 5246, Section 7.4.4 (where it calls this "somewhat complicated").
1005         cri.SignatureSchemes = make([]SignatureScheme, 0, len(certReq.supportedSignatureAlgorithms))
1006         for _, sigScheme := range certReq.supportedSignatureAlgorithms {
1007                 sigType, _, err := typeAndHashFromSignatureScheme(sigScheme)
1008                 if err != nil {
1009                         continue
1010                 }
1011                 switch sigType {
1012                 case signatureECDSA, signatureEd25519:
1013                         if ecAvail {
1014                                 cri.SignatureSchemes = append(cri.SignatureSchemes, sigScheme)
1015                         }
1016                 case signatureRSAPSS, signaturePKCS1v15:
1017                         if rsaAvail {
1018                                 cri.SignatureSchemes = append(cri.SignatureSchemes, sigScheme)
1019                         }
1020                 }
1021         }
1022
1023         return cri
1024 }
1025
1026 func (c *Conn) getClientCertificate(cri *CertificateRequestInfo) (*Certificate, error) {
1027         if c.config.GetClientCertificate != nil {
1028                 return c.config.GetClientCertificate(cri)
1029         }
1030
1031         for _, chain := range c.config.Certificates {
1032                 if err := cri.SupportsCertificate(&chain); err != nil {
1033                         continue
1034                 }
1035                 return &chain, nil
1036         }
1037
1038         // No acceptable certificate found. Don't send a certificate.
1039         return new(Certificate), nil
1040 }
1041
1042 // clientSessionCacheKey returns a key used to cache sessionTickets that could
1043 // be used to resume previously negotiated TLS sessions with a server.
1044 func (c *Conn) clientSessionCacheKey() string {
1045         if len(c.config.ServerName) > 0 {
1046                 return c.config.ServerName
1047         }
1048         if c.conn != nil {
1049                 return c.conn.RemoteAddr().String()
1050         }
1051         return ""
1052 }
1053
1054 // hostnameInSNI converts name into an appropriate hostname for SNI.
1055 // Literal IP addresses and absolute FQDNs are not permitted as SNI values.
1056 // See RFC 6066, Section 3.
1057 func hostnameInSNI(name string) string {
1058         host := name
1059         if len(host) > 0 && host[0] == '[' && host[len(host)-1] == ']' {
1060                 host = host[1 : len(host)-1]
1061         }
1062         if i := strings.LastIndex(host, "%"); i > 0 {
1063                 host = host[:i]
1064         }
1065         if net.ParseIP(host) != nil {
1066                 return ""
1067         }
1068         for len(name) > 0 && name[len(name)-1] == '.' {
1069                 name = name[:len(name)-1]
1070         }
1071         return name
1072 }