Debian Codegraph @

external/boringssl/ssl/test/runner/handshake_client.go

raw
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 runner
6
7 import (
8 "bytes"
9 "crypto/ecdsa"
10 "crypto/elliptic"
11 "crypto/rsa"
12 "crypto/subtle"
13 "crypto/x509"
14 "encoding/asn1"
15 "errors"
16 "fmt"
17 "io"
18 "math/big"
19 "net"
20 "strconv"
21 )
22
23 type clientHandshakeState struct {
24 c *Conn
25 serverHello *serverHelloMsg
26 hello *clientHelloMsg
27 suite *cipherSuite
28 finishedHash finishedHash
29 masterSecret []byte
30 session *ClientSessionState
31 finishedBytes []byte
32 }
33
34 func (c *Conn) clientHandshake() error {
35 if c.config == nil {
36 c.config = defaultConfig()
37 }
38
39 if len(c.config.ServerName) == 0 && !c.config.InsecureSkipVerify {
40 return errors.New("tls: either ServerName or InsecureSkipVerify must be specified in the tls.Config")
41 }
42
43 c.sendHandshakeSeq = 0
44 c.recvHandshakeSeq = 0
45
46 nextProtosLength := 0
47 for _, proto := range c.config.NextProtos {
48 if l := len(proto); l > 255 {
49 return errors.New("tls: invalid NextProtos value")
50 } else {
51 nextProtosLength += 1 + l
52 }
53 }
54 if nextProtosLength > 0xffff {
55 return errors.New("tls: NextProtos values too large")
56 }
57
58 hello := &clientHelloMsg{
59 isDTLS: c.isDTLS,
60 vers: c.config.maxVersion(),
61 compressionMethods: []uint8{compressionNone},
62 random: make([]byte, 32),
63 ocspStapling: true,
64 sctListSupported: true,
65 serverName: c.config.ServerName,
66 supportedCurves: c.config.curvePreferences(),
67 supportedPoints: []uint8{pointFormatUncompressed},
68 nextProtoNeg: len(c.config.NextProtos) > 0,
69 secureRenegotiation: []byte{},
70 alpnProtocols: c.config.NextProtos,
71 duplicateExtension: c.config.Bugs.DuplicateExtension,
72 channelIDSupported: c.config.ChannelID != nil,
73 npnLast: c.config.Bugs.SwapNPNAndALPN,
74 extendedMasterSecret: c.config.maxVersion() >= VersionTLS10,
75 srtpProtectionProfiles: c.config.SRTPProtectionProfiles,
76 srtpMasterKeyIdentifier: c.config.Bugs.SRTPMasterKeyIdentifer,
77 customExtension: c.config.Bugs.CustomExtension,
78 }
79
80 if c.config.Bugs.SendClientVersion != 0 {
81 hello.vers = c.config.Bugs.SendClientVersion
82 }
83
84 if c.config.Bugs.NoExtendedMasterSecret {
85 hello.extendedMasterSecret = false
86 }
87
88 if c.config.Bugs.NoSupportedCurves {
89 hello.supportedCurves = nil
90 }
91
92 if len(c.clientVerify) > 0 && !c.config.Bugs.EmptyRenegotiationInfo {
93 if c.config.Bugs.BadRenegotiationInfo {
94 hello.secureRenegotiation = append(hello.secureRenegotiation, c.clientVerify...)
95 hello.secureRenegotiation[0] ^= 0x80
96 } else {
97 hello.secureRenegotiation = c.clientVerify
98 }
99 }
100
101 if c.noRenegotiationInfo() {
102 hello.secureRenegotiation = nil
103 }
104
105 possibleCipherSuites := c.config.cipherSuites()
106 hello.cipherSuites = make([]uint16, 0, len(possibleCipherSuites))
107
108 NextCipherSuite:
109 for _, suiteId := range possibleCipherSuites {
110 for _, suite := range cipherSuites {
111 if suite.id != suiteId {
112 continue
113 }
114 // Don't advertise TLS 1.2-only cipher suites unless
115 // we're attempting TLS 1.2.
116 if hello.vers < VersionTLS12 && suite.flags&suiteTLS12 != 0 {
117 continue
118 }
119 // Don't advertise non-DTLS cipher suites on DTLS.
120 if c.isDTLS && suite.flags&suiteNoDTLS != 0 && !c.config.Bugs.EnableAllCiphersInDTLS {
121 continue
122 }
123 hello.cipherSuites = append(hello.cipherSuites, suiteId)
124 continue NextCipherSuite
125 }
126 }
127
128 if c.config.Bugs.SendRenegotiationSCSV {
129 hello.cipherSuites = append(hello.cipherSuites, renegotiationSCSV)
130 }
131
132 if c.config.Bugs.SendFallbackSCSV {
133 hello.cipherSuites = append(hello.cipherSuites, fallbackSCSV)
134 }
135
136 _, err := io.ReadFull(c.config.rand(), hello.random)
137 if err != nil {
138 c.sendAlert(alertInternalError)
139 return errors.New("tls: short read from Rand: " + err.Error())
140 }
141
142 if hello.vers >= VersionTLS12 && !c.config.Bugs.NoSignatureAndHashes {
143 hello.signatureAndHashes = c.config.signatureAndHashesForClient()
144 }
145
146 var session *ClientSessionState
147 var cacheKey string
148 sessionCache := c.config.ClientSessionCache
149
150 if sessionCache != nil {
151 hello.ticketSupported = !c.config.SessionTicketsDisabled
152
153 // Try to resume a previously negotiated TLS session, if
154 // available.
155 cacheKey = clientSessionCacheKey(c.conn.RemoteAddr(), c.config)
156 candidateSession, ok := sessionCache.Get(cacheKey)
157 if ok {
158 ticketOk := !c.config.SessionTicketsDisabled || candidateSession.sessionTicket == nil
159
160 // Check that the ciphersuite/version used for the
161 // previous session are still valid.
162 cipherSuiteOk := false
163 for _, id := range hello.cipherSuites {
164 if id == candidateSession.cipherSuite {
165 cipherSuiteOk = true
166 break
167 }
168 }
169
170 versOk := candidateSession.vers >= c.config.minVersion() &&
171 candidateSession.vers <= c.config.maxVersion()
172 if ticketOk && versOk && cipherSuiteOk {
173 session = candidateSession
174 }
175 }
176 }
177
178 if session != nil {
179 if session.sessionTicket != nil {
180 hello.sessionTicket = session.sessionTicket
181 if c.config.Bugs.CorruptTicket {
182 hello.sessionTicket = make([]byte, len(session.sessionTicket))
183 copy(hello.sessionTicket, session.sessionTicket)
184 if len(hello.sessionTicket) > 0 {
185 offset := 40
186 if offset > len(hello.sessionTicket) {
187 offset = len(hello.sessionTicket) - 1
188 }
189 hello.sessionTicket[offset] ^= 0x40
190 }
191 }
192 // A random session ID is used to detect when the
193 // server accepted the ticket and is resuming a session
194 // (see RFC 5077).
195 sessionIdLen := 16
196 if c.config.Bugs.OversizedSessionId {
197 sessionIdLen = 33
198 }
199 hello.sessionId = make([]byte, sessionIdLen)
200 if _, err := io.ReadFull(c.config.rand(), hello.sessionId); err != nil {
201 c.sendAlert(alertInternalError)
202 return errors.New("tls: short read from Rand: " + err.Error())
203 }
204 } else {
205 hello.sessionId = session.sessionId
206 }
207 }
208
209 var helloBytes []byte
210 if c.config.Bugs.SendV2ClientHello {
211 // Test that the peer left-pads random.
212 hello.random[0] = 0
213 v2Hello := &v2ClientHelloMsg{
214 vers: hello.vers,
215 cipherSuites: hello.cipherSuites,
216 // No session resumption for V2ClientHello.
217 sessionId: nil,
218 challenge: hello.random[1:],
219 }
220 helloBytes = v2Hello.marshal()
221 c.writeV2Record(helloBytes)
222 } else {
223 helloBytes = hello.marshal()
224 c.writeRecord(recordTypeHandshake, helloBytes)
225 }
226 c.dtlsFlushHandshake()
227
228 if err := c.simulatePacketLoss(nil); err != nil {
229 return err
230 }
231 msg, err := c.readHandshake()
232 if err != nil {
233 return err
234 }
235
236 if c.isDTLS {
237 helloVerifyRequest, ok := msg.(*helloVerifyRequestMsg)
238 if ok {
239 if helloVerifyRequest.vers != VersionTLS10 {
240 // Per RFC 6347, the version field in
241 // HelloVerifyRequest SHOULD be always DTLS
242 // 1.0. Enforce this for testing purposes.
243 return errors.New("dtls: bad HelloVerifyRequest version")
244 }
245
246 hello.raw = nil
247 hello.cookie = helloVerifyRequest.cookie
248 helloBytes = hello.marshal()
249 c.writeRecord(recordTypeHandshake, helloBytes)
250 c.dtlsFlushHandshake()
251
252 if err := c.simulatePacketLoss(nil); err != nil {
253 return err
254 }
255 msg, err = c.readHandshake()
256 if err != nil {
257 return err
258 }
259 }
260 }
261
262 serverHello, ok := msg.(*serverHelloMsg)
263 if !ok {
264 c.sendAlert(alertUnexpectedMessage)
265 return unexpectedMessageError(serverHello, msg)
266 }
267
268 c.vers, ok = c.config.mutualVersion(serverHello.vers)
269 if !ok {
270 c.sendAlert(alertProtocolVersion)
271 return fmt.Errorf("tls: server selected unsupported protocol version %x", serverHello.vers)
272 }
273 c.haveVers = true
274
275 suite := mutualCipherSuite(c.config.cipherSuites(), serverHello.cipherSuite)
276 if suite == nil {
277 c.sendAlert(alertHandshakeFailure)
278 return fmt.Errorf("tls: server selected an unsupported cipher suite")
279 }
280
281 if c.config.Bugs.RequireRenegotiationInfo && serverHello.secureRenegotiation == nil {
282 return errors.New("tls: renegotiation extension missing")
283 }
284
285 if len(c.clientVerify) > 0 && !c.noRenegotiationInfo() {
286 var expectedRenegInfo []byte
287 expectedRenegInfo = append(expectedRenegInfo, c.clientVerify...)
288 expectedRenegInfo = append(expectedRenegInfo, c.serverVerify...)
289 if !bytes.Equal(serverHello.secureRenegotiation, expectedRenegInfo) {
290 c.sendAlert(alertHandshakeFailure)
291 return fmt.Errorf("tls: renegotiation mismatch")
292 }
293 }
294
295 if expected := c.config.Bugs.ExpectedCustomExtension; expected != nil {
296 if serverHello.customExtension != *expected {
297 return fmt.Errorf("tls: bad custom extension contents %q", serverHello.customExtension)
298 }
299 }
300
301 hs := &clientHandshakeState{
302 c: c,
303 serverHello: serverHello,
304 hello: hello,
305 suite: suite,
306 finishedHash: newFinishedHash(c.vers, suite),
307 session: session,
308 }
309
310 hs.writeHash(helloBytes, hs.c.sendHandshakeSeq-1)
311 hs.writeServerHash(hs.serverHello.marshal())
312
313 if c.config.Bugs.EarlyChangeCipherSpec > 0 {
314 hs.establishKeys()
315 c.writeRecord(recordTypeChangeCipherSpec, []byte{1})
316 }
317
318 isResume, err := hs.processServerHello()
319 if err != nil {
320 return err
321 }
322
323 if isResume {
324 if c.config.Bugs.EarlyChangeCipherSpec == 0 {
325 if err := hs.establishKeys(); err != nil {
326 return err
327 }
328 }
329 if err := hs.readSessionTicket(); err != nil {
330 return err
331 }
332 if err := hs.readFinished(c.firstFinished[:]); err != nil {
333 return err
334 }
335 if err := hs.sendFinished(nil, isResume); err != nil {
336 return err
337 }
338 } else {
339 if err := hs.doFullHandshake(); err != nil {
340 return err
341 }
342 if err := hs.establishKeys(); err != nil {
343 return err
344 }
345 if err := hs.sendFinished(c.firstFinished[:], isResume); err != nil {
346 return err
347 }
348 // Most retransmits are triggered by a timeout, but the final
349 // leg of the handshake is retransmited upon re-receiving a
350 // Finished.
351 if err := c.simulatePacketLoss(func() {
352 c.writeRecord(recordTypeHandshake, hs.finishedBytes)
353 c.dtlsFlushHandshake()
354 }); err != nil {
355 return err
356 }
357 if err := hs.readSessionTicket(); err != nil {
358 return err
359 }
360 if err := hs.readFinished(nil); err != nil {
361 return err
362 }
363 }
364
365 if sessionCache != nil && hs.session != nil && session != hs.session {
366 if c.config.Bugs.RequireSessionTickets && len(hs.session.sessionTicket) == 0 {
367 return errors.New("tls: new session used session IDs instead of tickets")
368 }
369 sessionCache.Put(cacheKey, hs.session)
370 }
371
372 c.didResume = isResume
373 c.handshakeComplete = true
374 c.cipherSuite = suite
375 copy(c.clientRandom[:], hs.hello.random)
376 copy(c.serverRandom[:], hs.serverHello.random)
377 copy(c.masterSecret[:], hs.masterSecret)
378
379 return nil
380 }
381
382 func (hs *clientHandshakeState) doFullHandshake() error {
383 c := hs.c
384
385 var leaf *x509.Certificate
386 if hs.suite.flags&suitePSK == 0 {
387 msg, err := c.readHandshake()
388 if err != nil {
389 return err
390 }
391
392 certMsg, ok := msg.(*certificateMsg)
393 if !ok || len(certMsg.certificates) == 0 {
394 c.sendAlert(alertUnexpectedMessage)
395 return unexpectedMessageError(certMsg, msg)
396 }
397 hs.writeServerHash(certMsg.marshal())
398
399 certs := make([]*x509.Certificate, len(certMsg.certificates))
400 for i, asn1Data := range certMsg.certificates {
401 cert, err := x509.ParseCertificate(asn1Data)
402 if err != nil {
403 c.sendAlert(alertBadCertificate)
404 return errors.New("tls: failed to parse certificate from server: " + err.Error())
405 }
406 certs[i] = cert
407 }
408 leaf = certs[0]
409
410 if !c.config.InsecureSkipVerify {
411 opts := x509.VerifyOptions{
412 Roots: c.config.RootCAs,
413 CurrentTime: c.config.time(),
414 DNSName: c.config.ServerName,
415 Intermediates: x509.NewCertPool(),
416 }
417
418 for i, cert := range certs {
419 if i == 0 {
420 continue
421 }
422 opts.Intermediates.AddCert(cert)
423 }
424 c.verifiedChains, err = leaf.Verify(opts)
425 if err != nil {
426 c.sendAlert(alertBadCertificate)
427 return err
428 }
429 }
430
431 switch leaf.PublicKey.(type) {
432 case *rsa.PublicKey, *ecdsa.PublicKey:
433 break
434 default:
435 c.sendAlert(alertUnsupportedCertificate)
436 return fmt.Errorf("tls: server's certificate contains an unsupported type of public key: %T", leaf.PublicKey)
437 }
438
439 c.peerCertificates = certs
440 }
441
442 if hs.serverHello.ocspStapling {
443 msg, err := c.readHandshake()
444 if err != nil {
445 return err
446 }
447 cs, ok := msg.(*certificateStatusMsg)
448 if !ok {
449 c.sendAlert(alertUnexpectedMessage)
450 return unexpectedMessageError(cs, msg)
451 }
452 hs.writeServerHash(cs.marshal())
453
454 if cs.statusType == statusTypeOCSP {
455 c.ocspResponse = cs.response
456 }
457 }
458
459 msg, err := c.readHandshake()
460 if err != nil {
461 return err
462 }
463
464 keyAgreement := hs.suite.ka(c.vers)
465
466 skx, ok := msg.(*serverKeyExchangeMsg)
467 if ok {
468 hs.writeServerHash(skx.marshal())
469 err = keyAgreement.processServerKeyExchange(c.config, hs.hello, hs.serverHello, leaf, skx)
470 if err != nil {
471 c.sendAlert(alertUnexpectedMessage)
472 return err
473 }
474
475 msg, err = c.readHandshake()
476 if err != nil {
477 return err
478 }
479 }
480
481 var chainToSend *Certificate
482 var certRequested bool
483 certReq, ok := msg.(*certificateRequestMsg)
484 if ok {
485 certRequested = true
486
487 // RFC 4346 on the certificateAuthorities field:
488 // A list of the distinguished names of acceptable certificate
489 // authorities. These distinguished names may specify a desired
490 // distinguished name for a root CA or for a subordinate CA;
491 // thus, this message can be used to describe both known roots
492 // and a desired authorization space. If the
493 // certificate_authorities list is empty then the client MAY
494 // send any certificate of the appropriate
495 // ClientCertificateType, unless there is some external
496 // arrangement to the contrary.
497
498 hs.writeServerHash(certReq.marshal())
499
500 var rsaAvail, ecdsaAvail bool
501 for _, certType := range certReq.certificateTypes {
502 switch certType {
503 case CertTypeRSASign:
504 rsaAvail = true
505 case CertTypeECDSASign:
506 ecdsaAvail = true
507 }
508 }
509
510 // We need to search our list of client certs for one
511 // where SignatureAlgorithm is RSA and the Issuer is in
512 // certReq.certificateAuthorities
513 findCert:
514 for i, chain := range c.config.Certificates {
515 if !rsaAvail && !ecdsaAvail {
516 continue
517 }
518
519 for j, cert := range chain.Certificate {
520 x509Cert := chain.Leaf
521 // parse the certificate if this isn't the leaf
522 // node, or if chain.Leaf was nil
523 if j != 0 || x509Cert == nil {
524 if x509Cert, err = x509.ParseCertificate(cert); err != nil {
525 c.sendAlert(alertInternalError)
526 return errors.New("tls: failed to parse client certificate #" + strconv.Itoa(i) + ": " + err.Error())
527 }
528 }
529
530 switch {
531 case rsaAvail && x509Cert.PublicKeyAlgorithm == x509.RSA:
532 case ecdsaAvail && x509Cert.PublicKeyAlgorithm == x509.ECDSA:
533 default:
534 continue findCert
535 }
536
537 if len(certReq.certificateAuthorities) == 0 {
538 // they gave us an empty list, so just take the
539 // first RSA cert from c.config.Certificates
540 chainToSend = &chain
541 break findCert
542 }
543
544 for _, ca := range certReq.certificateAuthorities {
545 if bytes.Equal(x509Cert.RawIssuer, ca) {
546 chainToSend = &chain
547 break findCert
548 }
549 }
550 }
551 }
552
553 msg, err = c.readHandshake()
554 if err != nil {
555 return err
556 }
557 }
558
559 shd, ok := msg.(*serverHelloDoneMsg)
560 if !ok {
561 c.sendAlert(alertUnexpectedMessage)
562 return unexpectedMessageError(shd, msg)
563 }
564 hs.writeServerHash(shd.marshal())
565
566 // If the server requested a certificate then we have to send a
567 // Certificate message in TLS, even if it's empty because we don't have
568 // a certificate to send. In SSL 3.0, skip the message and send a
569 // no_certificate warning alert.
570 if certRequested {
571 if c.vers == VersionSSL30 && chainToSend == nil {
572 c.sendAlert(alertNoCertficate)
573 } else if !c.config.Bugs.SkipClientCertificate {
574 certMsg := new(certificateMsg)
575 if chainToSend != nil {
576 certMsg.certificates = chainToSend.Certificate
577 }
578 hs.writeClientHash(certMsg.marshal())
579 c.writeRecord(recordTypeHandshake, certMsg.marshal())
580 }
581 }
582
583 preMasterSecret, ckx, err := keyAgreement.generateClientKeyExchange(c.config, hs.hello, leaf)
584 if err != nil {
585 c.sendAlert(alertInternalError)
586 return err
587 }
588 if ckx != nil {
589 if c.config.Bugs.EarlyChangeCipherSpec < 2 {
590 hs.writeClientHash(ckx.marshal())
591 }
592 c.writeRecord(recordTypeHandshake, ckx.marshal())
593 }
594
595 if hs.serverHello.extendedMasterSecret && c.vers >= VersionTLS10 {
596 hs.masterSecret = extendedMasterFromPreMasterSecret(c.vers, hs.suite, preMasterSecret, hs.finishedHash)
597 c.extendedMasterSecret = true
598 } else {
599 if c.config.Bugs.RequireExtendedMasterSecret {
600 return errors.New("tls: extended master secret required but not supported by peer")
601 }
602 hs.masterSecret = masterFromPreMasterSecret(c.vers, hs.suite, preMasterSecret, hs.hello.random, hs.serverHello.random)
603 }
604
605 if chainToSend != nil {
606 var signed []byte
607 certVerify := &certificateVerifyMsg{
608 hasSignatureAndHash: c.vers >= VersionTLS12,
609 }
610
611 // Determine the hash to sign.
612 var signatureType uint8
613 switch c.config.Certificates[0].PrivateKey.(type) {
614 case *ecdsa.PrivateKey:
615 signatureType = signatureECDSA
616 case *rsa.PrivateKey:
617 signatureType = signatureRSA
618 default:
619 c.sendAlert(alertInternalError)
620 return errors.New("unknown private key type")
621 }
622 if c.config.Bugs.IgnorePeerSignatureAlgorithmPreferences {
623 certReq.signatureAndHashes = c.config.signatureAndHashesForClient()
624 }
625 certVerify.signatureAndHash, err = hs.finishedHash.selectClientCertSignatureAlgorithm(certReq.signatureAndHashes, c.config.signatureAndHashesForClient(), signatureType)
626 if err != nil {
627 c.sendAlert(alertInternalError)
628 return err
629 }
630 digest, hashFunc, err := hs.finishedHash.hashForClientCertificate(certVerify.signatureAndHash, hs.masterSecret)
631 if err != nil {
632 c.sendAlert(alertInternalError)
633 return err
634 }
635 if c.config.Bugs.InvalidCertVerifySignature {
636 digest[0] ^= 0x80
637 }
638
639 switch key := c.config.Certificates[0].PrivateKey.(type) {
640 case *ecdsa.PrivateKey:
641 var r, s *big.Int
642 r, s, err = ecdsa.Sign(c.config.rand(), key, digest)
643 if err == nil {
644 signed, err = asn1.Marshal(ecdsaSignature{r, s})
645 }
646 case *rsa.PrivateKey:
647 signed, err = rsa.SignPKCS1v15(c.config.rand(), key, hashFunc, digest)
648 default:
649 err = errors.New("unknown private key type")
650 }
651 if err != nil {
652 c.sendAlert(alertInternalError)
653 return errors.New("tls: failed to sign handshake with client certificate: " + err.Error())
654 }
655 certVerify.signature = signed
656
657 hs.writeClientHash(certVerify.marshal())
658 c.writeRecord(recordTypeHandshake, certVerify.marshal())
659 }
660 c.dtlsFlushHandshake()
661
662 hs.finishedHash.discardHandshakeBuffer()
663
664 return nil
665 }
666
667 func (hs *clientHandshakeState) establishKeys() error {
668 c := hs.c
669
670 clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV :=
671 keysFromMasterSecret(c.vers, hs.suite, hs.masterSecret, hs.hello.random, hs.serverHello.random, hs.suite.macLen, hs.suite.keyLen, hs.suite.ivLen)
672 var clientCipher, serverCipher interface{}
673 var clientHash, serverHash macFunction
674 if hs.suite.cipher != nil {
675 clientCipher = hs.suite.cipher(clientKey, clientIV, false /* not for reading */)
676 clientHash = hs.suite.mac(c.vers, clientMAC)
677 serverCipher = hs.suite.cipher(serverKey, serverIV, true /* for reading */)
678 serverHash = hs.suite.mac(c.vers, serverMAC)
679 } else {
680 clientCipher = hs.suite.aead(clientKey, clientIV)
681 serverCipher = hs.suite.aead(serverKey, serverIV)
682 }
683
684 c.in.prepareCipherSpec(c.vers, serverCipher, serverHash)
685 c.out.prepareCipherSpec(c.vers, clientCipher, clientHash)
686 return nil
687 }
688
689 func (hs *clientHandshakeState) serverResumedSession() bool {
690 // If the server responded with the same sessionId then it means the
691 // sessionTicket is being used to resume a TLS session.
692 return hs.session != nil && hs.hello.sessionId != nil &&
693 bytes.Equal(hs.serverHello.sessionId, hs.hello.sessionId)
694 }
695
696 func (hs *clientHandshakeState) processServerHello() (bool, error) {
697 c := hs.c
698
699 if hs.serverHello.compressionMethod != compressionNone {
700 c.sendAlert(alertUnexpectedMessage)
701 return false, errors.New("tls: server selected unsupported compression format")
702 }
703
704 clientDidNPN := hs.hello.nextProtoNeg
705 clientDidALPN := len(hs.hello.alpnProtocols) > 0
706 serverHasNPN := hs.serverHello.nextProtoNeg
707 serverHasALPN := len(hs.serverHello.alpnProtocol) > 0
708
709 if !clientDidNPN && serverHasNPN {
710 c.sendAlert(alertHandshakeFailure)
711 return false, errors.New("server advertised unrequested NPN extension")
712 }
713
714 if !clientDidALPN && serverHasALPN {
715 c.sendAlert(alertHandshakeFailure)
716 return false, errors.New("server advertised unrequested ALPN extension")
717 }
718
719 if serverHasNPN && serverHasALPN {
720 c.sendAlert(alertHandshakeFailure)
721 return false, errors.New("server advertised both NPN and ALPN extensions")
722 }
723
724 if serverHasALPN {
725 c.clientProtocol = hs.serverHello.alpnProtocol
726 c.clientProtocolFallback = false
727 c.usedALPN = true
728 }
729
730 if !hs.hello.channelIDSupported && hs.serverHello.channelIDRequested {
731 c.sendAlert(alertHandshakeFailure)
732 return false, errors.New("server advertised unrequested Channel ID extension")
733 }
734
735 if hs.serverHello.srtpProtectionProfile != 0 {
736 if hs.serverHello.srtpMasterKeyIdentifier != "" {
737 return false, errors.New("tls: server selected SRTP MKI value")
738 }
739
740 found := false
741 for _, p := range c.config.SRTPProtectionProfiles {
742 if p == hs.serverHello.srtpProtectionProfile {
743 found = true
744 break
745 }
746 }
747 if !found {
748 return false, errors.New("tls: server advertised unsupported SRTP profile")
749 }
750
751 c.srtpProtectionProfile = hs.serverHello.srtpProtectionProfile
752 }
753
754 if hs.serverResumedSession() {
755 // For test purposes, assert that the server never accepts the
756 // resumption offer on renegotiation.
757 if c.cipherSuite != nil && c.config.Bugs.FailIfResumeOnRenego {
758 return false, errors.New("tls: server resumed session on renegotiation")
759 }
760
761 if hs.serverHello.sctList != nil {
762 return false, errors.New("tls: server sent SCT extension on session resumption")
763 }
764
765 if hs.serverHello.ocspStapling {
766 return false, errors.New("tls: server sent OCSP extension on session resumption")
767 }
768
769 // Restore masterSecret and peerCerts from previous state
770 hs.masterSecret = hs.session.masterSecret
771 c.peerCertificates = hs.session.serverCertificates
772 c.extendedMasterSecret = hs.session.extendedMasterSecret
773 c.sctList = hs.session.sctList
774 c.ocspResponse = hs.session.ocspResponse
775 hs.finishedHash.discardHandshakeBuffer()
776 return true, nil
777 }
778
779 if hs.serverHello.sctList != nil {
780 c.sctList = hs.serverHello.sctList
781 }
782
783 return false, nil
784 }
785
786 func (hs *clientHandshakeState) readFinished(out []byte) error {
787 c := hs.c
788
789 c.readRecord(recordTypeChangeCipherSpec)
790 if err := c.in.error(); err != nil {
791 return err
792 }
793
794 msg, err := c.readHandshake()
795 if err != nil {
796 return err
797 }
798 serverFinished, ok := msg.(*finishedMsg)
799 if !ok {
800 c.sendAlert(alertUnexpectedMessage)
801 return unexpectedMessageError(serverFinished, msg)
802 }
803
804 if c.config.Bugs.EarlyChangeCipherSpec == 0 {
805 verify := hs.finishedHash.serverSum(hs.masterSecret)
806 if len(verify) != len(serverFinished.verifyData) ||
807 subtle.ConstantTimeCompare(verify, serverFinished.verifyData) != 1 {
808 c.sendAlert(alertHandshakeFailure)
809 return errors.New("tls: server's Finished message was incorrect")
810 }
811 }
812 c.serverVerify = append(c.serverVerify[:0], serverFinished.verifyData...)
813 copy(out, serverFinished.verifyData)
814 hs.writeServerHash(serverFinished.marshal())
815 return nil
816 }
817
818 func (hs *clientHandshakeState) readSessionTicket() error {
819 c := hs.c
820
821 // Create a session with no server identifier. Either a
822 // session ID or session ticket will be attached.
823 session := &ClientSessionState{
824 vers: c.vers,
825 cipherSuite: hs.suite.id,
826 masterSecret: hs.masterSecret,
827 handshakeHash: hs.finishedHash.server.Sum(nil),
828 serverCertificates: c.peerCertificates,
829 sctList: c.sctList,
830 ocspResponse: c.ocspResponse,
831 }
832
833 if !hs.serverHello.ticketSupported {
834 if c.config.Bugs.ExpectNewTicket {
835 return errors.New("tls: expected new ticket")
836 }
837 if hs.session == nil && len(hs.serverHello.sessionId) > 0 {
838 session.sessionId = hs.serverHello.sessionId
839 hs.session = session
840 }
841 return nil
842 }
843
844 if c.vers == VersionSSL30 {
845 return errors.New("tls: negotiated session tickets in SSL 3.0")
846 }
847
848 msg, err := c.readHandshake()
849 if err != nil {
850 return err
851 }
852 sessionTicketMsg, ok := msg.(*newSessionTicketMsg)
853 if !ok {
854 c.sendAlert(alertUnexpectedMessage)
855 return unexpectedMessageError(sessionTicketMsg, msg)
856 }
857
858 session.sessionTicket = sessionTicketMsg.ticket
859 hs.session = session
860
861 hs.writeServerHash(sessionTicketMsg.marshal())
862
863 return nil
864 }
865
866 func (hs *clientHandshakeState) sendFinished(out []byte, isResume bool) error {
867 c := hs.c
868
869 var postCCSBytes []byte
870 seqno := hs.c.sendHandshakeSeq
871 if hs.serverHello.nextProtoNeg {
872 nextProto := new(nextProtoMsg)
873 proto, fallback := mutualProtocol(c.config.NextProtos, hs.serverHello.nextProtos)
874 nextProto.proto = proto
875 c.clientProtocol = proto
876 c.clientProtocolFallback = fallback
877
878 nextProtoBytes := nextProto.marshal()
879 hs.writeHash(nextProtoBytes, seqno)
880 seqno++
881 postCCSBytes = append(postCCSBytes, nextProtoBytes...)
882 }
883
884 if hs.serverHello.channelIDRequested {
885 encryptedExtensions := new(encryptedExtensionsMsg)
886 if c.config.ChannelID.Curve != elliptic.P256() {
887 return fmt.Errorf("tls: Channel ID is not on P-256.")
888 }
889 var resumeHash []byte
890 if isResume {
891 resumeHash = hs.session.handshakeHash
892 }
893 r, s, err := ecdsa.Sign(c.config.rand(), c.config.ChannelID, hs.finishedHash.hashForChannelID(resumeHash))
894 if err != nil {
895 return err
896 }
897 channelID := make([]byte, 128)
898 writeIntPadded(channelID[0:32], c.config.ChannelID.X)
899 writeIntPadded(channelID[32:64], c.config.ChannelID.Y)
900 writeIntPadded(channelID[64:96], r)
901 writeIntPadded(channelID[96:128], s)
902 encryptedExtensions.channelID = channelID
903
904 c.channelID = &c.config.ChannelID.PublicKey
905
906 encryptedExtensionsBytes := encryptedExtensions.marshal()
907 hs.writeHash(encryptedExtensionsBytes, seqno)
908 seqno++
909 postCCSBytes = append(postCCSBytes, encryptedExtensionsBytes...)
910 }
911
912 finished := new(finishedMsg)
913 if c.config.Bugs.EarlyChangeCipherSpec == 2 {
914 finished.verifyData = hs.finishedHash.clientSum(nil)
915 } else {
916 finished.verifyData = hs.finishedHash.clientSum(hs.masterSecret)
917 }
918 copy(out, finished.verifyData)
919 if c.config.Bugs.BadFinished {
920 finished.verifyData[0]++
921 }
922 c.clientVerify = append(c.clientVerify[:0], finished.verifyData...)
923 hs.finishedBytes = finished.marshal()
924 hs.writeHash(hs.finishedBytes, seqno)
925 postCCSBytes = append(postCCSBytes, hs.finishedBytes...)
926
927 if c.config.Bugs.FragmentAcrossChangeCipherSpec {
928 c.writeRecord(recordTypeHandshake, postCCSBytes[:5])
929 postCCSBytes = postCCSBytes[5:]
930 }
931 c.dtlsFlushHandshake()
932
933 if !c.config.Bugs.SkipChangeCipherSpec &&
934 c.config.Bugs.EarlyChangeCipherSpec == 0 {
935 ccs := []byte{1}
936 if c.config.Bugs.BadChangeCipherSpec != nil {
937 ccs = c.config.Bugs.BadChangeCipherSpec
938 }
939 c.writeRecord(recordTypeChangeCipherSpec, ccs)
940 }
941
942 if c.config.Bugs.AppDataAfterChangeCipherSpec != nil {
943 c.writeRecord(recordTypeApplicationData, c.config.Bugs.AppDataAfterChangeCipherSpec)
944 }
945 if c.config.Bugs.AlertAfterChangeCipherSpec != 0 {
946 c.sendAlert(c.config.Bugs.AlertAfterChangeCipherSpec)
947 return errors.New("tls: simulating post-CCS alert")
948 }
949
950 if !c.config.Bugs.SkipFinished {
951 c.writeRecord(recordTypeHandshake, postCCSBytes)
952 c.dtlsFlushHandshake()
953 }
954 return nil
955 }
956
957 func (hs *clientHandshakeState) writeClientHash(msg []byte) {
958 // writeClientHash is called before writeRecord.
959 hs.writeHash(msg, hs.c.sendHandshakeSeq)
960 }
961
962 func (hs *clientHandshakeState) writeServerHash(msg []byte) {
963 // writeServerHash is called after readHandshake.
964 hs.writeHash(msg, hs.c.recvHandshakeSeq-1)
965 }
966
967 func (hs *clientHandshakeState) writeHash(msg []byte, seqno uint16) {
968 if hs.c.isDTLS {
969 // This is somewhat hacky. DTLS hashes a slightly different format.
970 // First, the TLS header.
971 hs.finishedHash.Write(msg[:4])
972 // Then the sequence number and reassembled fragment offset (always 0).
973 hs.finishedHash.Write([]byte{byte(seqno >> 8), byte(seqno), 0, 0, 0})
974 // Then the reassembled fragment (always equal to the message length).
975 hs.finishedHash.Write(msg[1:4])
976 // And then the message body.
977 hs.finishedHash.Write(msg[4:])
978 } else {
979 hs.finishedHash.Write(msg)
980 }
981 }
982
983 // clientSessionCacheKey returns a key used to cache sessionTickets that could
984 // be used to resume previously negotiated TLS sessions with a server.
985 func clientSessionCacheKey(serverAddr net.Addr, config *Config) string {
986 if len(config.ServerName) > 0 {
987 return config.ServerName
988 }
989 return serverAddr.String()
990 }
991
992 // mutualProtocol finds the mutual Next Protocol Negotiation or ALPN protocol
993 // given list of possible protocols and a list of the preference order. The
994 // first list must not be empty. It returns the resulting protocol and flag
995 // indicating if the fallback case was reached.
996 func mutualProtocol(protos, preferenceProtos []string) (string, bool) {
997 for _, s := range preferenceProtos {
998 for _, c := range protos {
999 if s == c {
1000 return s, false
1001 }
1002 }
1003 }
1004
1005 return protos[0], true
1006 }
1007
1008 // writeIntPadded writes x into b, padded up with leading zeros as
1009 // needed.
1010 func writeIntPadded(b []byte, x *big.Int) {
1011 for i := range b {
1012 b[i] = 0
1013 }
1014 xb := x.Bytes()
1015 copy(b[len(b)-len(xb):], xb)
1016 }