Debian Codegraph @

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

raw
1 // Copyright 2010 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 "crypto"
9 "crypto/ecdsa"
10 "crypto/elliptic"
11 "crypto/md5"
12 "crypto/rand"
13 "crypto/rsa"
14 "crypto/sha1"
15 "crypto/subtle"
16 "crypto/x509"
17 "encoding/asn1"
18 "errors"
19 "fmt"
20 "io"
21 "math/big"
22
23 "./curve25519"
24 "./newhope"
25 )
26
27 var errClientKeyExchange = errors.New("tls: invalid ClientKeyExchange message")
28 var errServerKeyExchange = errors.New("tls: invalid ServerKeyExchange message")
29
30 // rsaKeyAgreement implements the standard TLS key agreement where the client
31 // encrypts the pre-master secret to the server's public key.
32 type rsaKeyAgreement struct {
33 version uint16
34 clientVersion uint16
35 exportKey *rsa.PrivateKey
36 }
37
38 func (ka *rsaKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
39 // Save the client version for comparison later.
40 ka.clientVersion = versionToWire(clientHello.vers, clientHello.isDTLS)
41
42 if !config.Bugs.RSAEphemeralKey {
43 return nil, nil
44 }
45
46 // Generate an ephemeral RSA key to use instead of the real
47 // one, as in RSA_EXPORT.
48 key, err := rsa.GenerateKey(config.rand(), 512)
49 if err != nil {
50 return nil, err
51 }
52 ka.exportKey = key
53
54 modulus := key.N.Bytes()
55 exponent := big.NewInt(int64(key.E)).Bytes()
56 serverRSAParams := make([]byte, 0, 2+len(modulus)+2+len(exponent))
57 serverRSAParams = append(serverRSAParams, byte(len(modulus)>>8), byte(len(modulus)))
58 serverRSAParams = append(serverRSAParams, modulus...)
59 serverRSAParams = append(serverRSAParams, byte(len(exponent)>>8), byte(len(exponent)))
60 serverRSAParams = append(serverRSAParams, exponent...)
61
62 var tls12HashId uint8
63 if ka.version >= VersionTLS12 {
64 if tls12HashId, err = pickTLS12HashForSignature(signatureRSA, clientHello.signatureAndHashes, config.signatureAndHashesForServer()); err != nil {
65 return nil, err
66 }
67 }
68
69 digest, hashFunc, err := hashForServerKeyExchange(signatureRSA, tls12HashId, ka.version, clientHello.random, hello.random, serverRSAParams)
70 if err != nil {
71 return nil, err
72 }
73 privKey, ok := cert.PrivateKey.(*rsa.PrivateKey)
74 if !ok {
75 return nil, errors.New("RSA ephemeral key requires an RSA server private key")
76 }
77 sig, err := rsa.SignPKCS1v15(config.rand(), privKey, hashFunc, digest)
78 if err != nil {
79 return nil, errors.New("failed to sign RSA parameters: " + err.Error())
80 }
81
82 skx := new(serverKeyExchangeMsg)
83 sigAndHashLen := 0
84 if ka.version >= VersionTLS12 {
85 sigAndHashLen = 2
86 }
87 skx.key = make([]byte, len(serverRSAParams)+sigAndHashLen+2+len(sig))
88 copy(skx.key, serverRSAParams)
89 k := skx.key[len(serverRSAParams):]
90 if ka.version >= VersionTLS12 {
91 k[0] = tls12HashId
92 k[1] = signatureRSA
93 k = k[2:]
94 }
95 k[0] = byte(len(sig) >> 8)
96 k[1] = byte(len(sig))
97 copy(k[2:], sig)
98
99 return skx, nil
100 }
101
102 func (ka *rsaKeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
103 preMasterSecret := make([]byte, 48)
104 _, err := io.ReadFull(config.rand(), preMasterSecret[2:])
105 if err != nil {
106 return nil, err
107 }
108
109 if len(ckx.ciphertext) < 2 {
110 return nil, errClientKeyExchange
111 }
112
113 ciphertext := ckx.ciphertext
114 if version != VersionSSL30 {
115 ciphertextLen := int(ckx.ciphertext[0])<<8 | int(ckx.ciphertext[1])
116 if ciphertextLen != len(ckx.ciphertext)-2 {
117 return nil, errClientKeyExchange
118 }
119 ciphertext = ckx.ciphertext[2:]
120 }
121
122 key := cert.PrivateKey.(*rsa.PrivateKey)
123 if ka.exportKey != nil {
124 key = ka.exportKey
125 }
126 err = rsa.DecryptPKCS1v15SessionKey(config.rand(), key, ciphertext, preMasterSecret)
127 if err != nil {
128 return nil, err
129 }
130 // This check should be done in constant-time, but this is a testing
131 // implementation. See the discussion at the end of section 7.4.7.1 of
132 // RFC 4346.
133 vers := uint16(preMasterSecret[0])<<8 | uint16(preMasterSecret[1])
134 if ka.clientVersion != vers {
135 return nil, errors.New("tls: invalid version in RSA premaster")
136 }
137 return preMasterSecret, nil
138 }
139
140 func (ka *rsaKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
141 return errors.New("tls: unexpected ServerKeyExchange")
142 }
143
144 func (ka *rsaKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
145 bad := config.Bugs.BadRSAClientKeyExchange
146 preMasterSecret := make([]byte, 48)
147 vers := clientHello.vers
148 if bad == RSABadValueWrongVersion {
149 vers ^= 1
150 }
151 vers = versionToWire(vers, clientHello.isDTLS)
152 preMasterSecret[0] = byte(vers >> 8)
153 preMasterSecret[1] = byte(vers)
154 _, err := io.ReadFull(config.rand(), preMasterSecret[2:])
155 if err != nil {
156 return nil, nil, err
157 }
158
159 sentPreMasterSecret := preMasterSecret
160 if bad == RSABadValueTooLong {
161 sentPreMasterSecret = make([]byte, len(sentPreMasterSecret)+1)
162 copy(sentPreMasterSecret, preMasterSecret)
163 } else if bad == RSABadValueTooShort {
164 sentPreMasterSecret = sentPreMasterSecret[:len(sentPreMasterSecret)-1]
165 }
166
167 encrypted, err := rsa.EncryptPKCS1v15(config.rand(), cert.PublicKey.(*rsa.PublicKey), sentPreMasterSecret)
168 if err != nil {
169 return nil, nil, err
170 }
171 if bad == RSABadValueCorrupt {
172 encrypted[len(encrypted)-1] ^= 1
173 // Clear the high byte to ensure |encrypted| is still below the RSA modulus.
174 encrypted[0] = 0
175 }
176 ckx := new(clientKeyExchangeMsg)
177 if clientHello.vers != VersionSSL30 {
178 ckx.ciphertext = make([]byte, len(encrypted)+2)
179 ckx.ciphertext[0] = byte(len(encrypted) >> 8)
180 ckx.ciphertext[1] = byte(len(encrypted))
181 copy(ckx.ciphertext[2:], encrypted)
182 } else {
183 ckx.ciphertext = encrypted
184 }
185 return preMasterSecret, ckx, nil
186 }
187
188 // sha1Hash calculates a SHA1 hash over the given byte slices.
189 func sha1Hash(slices [][]byte) []byte {
190 hsha1 := sha1.New()
191 for _, slice := range slices {
192 hsha1.Write(slice)
193 }
194 return hsha1.Sum(nil)
195 }
196
197 // md5SHA1Hash implements TLS 1.0's hybrid hash function which consists of the
198 // concatenation of an MD5 and SHA1 hash.
199 func md5SHA1Hash(slices [][]byte) []byte {
200 md5sha1 := make([]byte, md5.Size+sha1.Size)
201 hmd5 := md5.New()
202 for _, slice := range slices {
203 hmd5.Write(slice)
204 }
205 copy(md5sha1, hmd5.Sum(nil))
206 copy(md5sha1[md5.Size:], sha1Hash(slices))
207 return md5sha1
208 }
209
210 // hashForServerKeyExchange hashes the given slices and returns their digest
211 // and the identifier of the hash function used. The hashFunc argument is only
212 // used for >= TLS 1.2 and precisely identifies the hash function to use.
213 func hashForServerKeyExchange(sigType, hashFunc uint8, version uint16, slices ...[]byte) ([]byte, crypto.Hash, error) {
214 if version >= VersionTLS12 {
215 hash, err := lookupTLSHash(hashFunc)
216 if err != nil {
217 return nil, 0, err
218 }
219 h := hash.New()
220 for _, slice := range slices {
221 h.Write(slice)
222 }
223 return h.Sum(nil), hash, nil
224 }
225 if sigType == signatureECDSA {
226 return sha1Hash(slices), crypto.SHA1, nil
227 }
228 return md5SHA1Hash(slices), crypto.MD5SHA1, nil
229 }
230
231 // pickTLS12HashForSignature returns a TLS 1.2 hash identifier for signing a
232 // ServerKeyExchange given the signature type being used and the client's
233 // advertized list of supported signature and hash combinations.
234 func pickTLS12HashForSignature(sigType uint8, clientList, serverList []signatureAndHash) (uint8, error) {
235 if len(clientList) == 0 {
236 // If the client didn't specify any signature_algorithms
237 // extension then we can assume that it supports SHA1. See
238 // http://tools.ietf.org/html/rfc5246#section-7.4.1.4.1
239 return hashSHA1, nil
240 }
241
242 for _, sigAndHash := range clientList {
243 if sigAndHash.signature != sigType {
244 continue
245 }
246 if isSupportedSignatureAndHash(sigAndHash, serverList) {
247 return sigAndHash.hash, nil
248 }
249 }
250
251 return 0, errors.New("tls: client doesn't support any common hash functions")
252 }
253
254 // A ecdhCurve is an instance of ECDH-style key agreement for TLS.
255 type ecdhCurve interface {
256 // offer generates a keypair using rand. It returns the encoded |publicKey|.
257 offer(rand io.Reader) (publicKey []byte, err error)
258
259 // accept responds to the |peerKey| generated by |offer| with the acceptor's
260 // |publicKey|, and returns agreed-upon |preMasterSecret| to the acceptor.
261 accept(rand io.Reader, peerKey []byte) (publicKey []byte, preMasterSecret []byte, err error)
262
263 // finish returns the computed |preMasterSecret|, given the |peerKey|
264 // generated by |accept|.
265 finish(peerKey []byte) (preMasterSecret []byte, err error)
266 }
267
268 // ellipticECDHCurve implements ecdhCurve with an elliptic.Curve.
269 type ellipticECDHCurve struct {
270 curve elliptic.Curve
271 privateKey []byte
272 }
273
274 func (e *ellipticECDHCurve) offer(rand io.Reader) (publicKey []byte, err error) {
275 var x, y *big.Int
276 e.privateKey, x, y, err = elliptic.GenerateKey(e.curve, rand)
277 if err != nil {
278 return nil, err
279 }
280 return elliptic.Marshal(e.curve, x, y), nil
281 }
282
283 func (e *ellipticECDHCurve) accept(rand io.Reader, peerKey []byte) (publicKey []byte, preMasterSecret []byte, err error) {
284 publicKey, err = e.offer(rand)
285 if err != nil {
286 return nil, nil, err
287 }
288 preMasterSecret, err = e.finish(peerKey)
289 if err != nil {
290 return nil, nil, err
291 }
292 return
293 }
294
295 func (e *ellipticECDHCurve) finish(peerKey []byte) (preMasterSecret []byte, err error) {
296 x, y := elliptic.Unmarshal(e.curve, peerKey)
297 if x == nil {
298 return nil, errors.New("tls: invalid peer key")
299 }
300 x, _ = e.curve.ScalarMult(x, y, e.privateKey)
301 preMasterSecret = make([]byte, (e.curve.Params().BitSize+7)>>3)
302 xBytes := x.Bytes()
303 copy(preMasterSecret[len(preMasterSecret)-len(xBytes):], xBytes)
304
305 return preMasterSecret, nil
306 }
307
308 // x25519ECDHCurve implements ecdhCurve with X25519.
309 type x25519ECDHCurve struct {
310 privateKey [32]byte
311 }
312
313 func (e *x25519ECDHCurve) offer(rand io.Reader) (publicKey []byte, err error) {
314 _, err = io.ReadFull(rand, e.privateKey[:])
315 if err != nil {
316 return
317 }
318 var out [32]byte
319 curve25519.ScalarBaseMult(&out, &e.privateKey)
320 return out[:], nil
321 }
322
323 func (e *x25519ECDHCurve) accept(rand io.Reader, peerKey []byte) (publicKey []byte, preMasterSecret []byte, err error) {
324 publicKey, err = e.offer(rand)
325 if err != nil {
326 return nil, nil, err
327 }
328 preMasterSecret, err = e.finish(peerKey)
329 if err != nil {
330 return nil, nil, err
331 }
332 return
333 }
334
335 func (e *x25519ECDHCurve) finish(peerKey []byte) (preMasterSecret []byte, err error) {
336 if len(peerKey) != 32 {
337 return nil, errors.New("tls: invalid peer key")
338 }
339 var out, peerKeyCopy [32]byte
340 copy(peerKeyCopy[:], peerKey)
341 curve25519.ScalarMult(&out, &e.privateKey, &peerKeyCopy)
342
343 // Per RFC 7748, reject the all-zero value in constant time.
344 var zeros [32]byte
345 if subtle.ConstantTimeCompare(zeros[:], out[:]) == 1 {
346 return nil, errors.New("tls: X25519 value with wrong order")
347 }
348
349 return out[:], nil
350 }
351
352 // cecpq1Curve is combined elliptic curve (X25519) and post-quantum (new hope) key
353 // agreement.
354 type cecpq1Curve struct {
355 x25519 *x25519ECDHCurve
356 newhope *newhope.Poly
357 }
358
359 func (e *cecpq1Curve) offer(rand io.Reader) (publicKey []byte, err error) {
360 var x25519OfferMsg, newhopeOfferMsg []byte
361
362 e.x25519 = new(x25519ECDHCurve)
363 if x25519OfferMsg, err = e.x25519.offer(rand); err != nil {
364 return nil, err
365 }
366
367 newhopeOfferMsg, e.newhope = newhope.Offer(rand)
368
369 return append(x25519OfferMsg, newhopeOfferMsg[:]...), nil
370 }
371
372 func (e *cecpq1Curve) accept(rand io.Reader, peerKey []byte) (publicKey []byte, preMasterSecret []byte, err error) {
373 if len(peerKey) != 32+newhope.OfferMsgLen {
374 return nil, nil, errors.New("cecpq1: invalid offer message")
375 }
376
377 var x25519AcceptMsg, newhopeAcceptMsg []byte
378 var x25519Secret []byte
379 var newhopeSecret newhope.Key
380
381 x25519 := new(x25519ECDHCurve)
382 if x25519AcceptMsg, x25519Secret, err = x25519.accept(rand, peerKey[:32]); err != nil {
383 return nil, nil, err
384 }
385
386 if newhopeSecret, newhopeAcceptMsg, err = newhope.Accept(rand, peerKey[32:]); err != nil {
387 return nil, nil, err
388 }
389
390 return append(x25519AcceptMsg, newhopeAcceptMsg[:]...), append(x25519Secret, newhopeSecret[:]...), nil
391 }
392
393 func (e *cecpq1Curve) finish(peerKey []byte) (preMasterSecret []byte, err error) {
394 if len(peerKey) != 32+newhope.AcceptMsgLen {
395 return nil, errors.New("cecpq1: invalid accept message")
396 }
397
398 var x25519Secret []byte
399 var newhopeSecret newhope.Key
400
401 if x25519Secret, err = e.x25519.finish(peerKey[:32]); err != nil {
402 return nil, err
403 }
404
405 if newhopeSecret, err = e.newhope.Finish(peerKey[32:]); err != nil {
406 return nil, err
407 }
408
409 return append(x25519Secret, newhopeSecret[:]...), nil
410 }
411
412 func curveForCurveID(id CurveID) (ecdhCurve, bool) {
413 switch id {
414 case CurveP224:
415 return &ellipticECDHCurve{curve: elliptic.P224()}, true
416 case CurveP256:
417 return &ellipticECDHCurve{curve: elliptic.P256()}, true
418 case CurveP384:
419 return &ellipticECDHCurve{curve: elliptic.P384()}, true
420 case CurveP521:
421 return &ellipticECDHCurve{curve: elliptic.P521()}, true
422 case CurveX25519:
423 return &x25519ECDHCurve{}, true
424 default:
425 return nil, false
426 }
427
428 }
429
430 // keyAgreementAuthentication is a helper interface that specifies how
431 // to authenticate the ServerKeyExchange parameters.
432 type keyAgreementAuthentication interface {
433 signParameters(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg, params []byte) (*serverKeyExchangeMsg, error)
434 verifyParameters(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, params []byte, sig []byte) error
435 }
436
437 // nilKeyAgreementAuthentication does not authenticate the key
438 // agreement parameters.
439 type nilKeyAgreementAuthentication struct{}
440
441 func (ka *nilKeyAgreementAuthentication) signParameters(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg, params []byte) (*serverKeyExchangeMsg, error) {
442 skx := new(serverKeyExchangeMsg)
443 skx.key = params
444 return skx, nil
445 }
446
447 func (ka *nilKeyAgreementAuthentication) verifyParameters(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, params []byte, sig []byte) error {
448 return nil
449 }
450
451 func maybeCorruptECDSAValue(n *big.Int, typeOfCorruption BadValue, limit *big.Int) *big.Int {
452 switch typeOfCorruption {
453 case BadValueNone:
454 return n
455 case BadValueNegative:
456 return new(big.Int).Neg(n)
457 case BadValueZero:
458 return big.NewInt(0)
459 case BadValueLimit:
460 return limit
461 case BadValueLarge:
462 bad := new(big.Int).Set(limit)
463 return bad.Lsh(bad, 20)
464 default:
465 panic("unknown BadValue type")
466 }
467 }
468
469 // signedKeyAgreement signs the ServerKeyExchange parameters with the
470 // server's private key.
471 type signedKeyAgreement struct {
472 version uint16
473 sigType uint8
474 }
475
476 func (ka *signedKeyAgreement) signParameters(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg, params []byte) (*serverKeyExchangeMsg, error) {
477 var tls12HashId uint8
478 var err error
479 if ka.version >= VersionTLS12 {
480 if tls12HashId, err = pickTLS12HashForSignature(ka.sigType, clientHello.signatureAndHashes, config.signatureAndHashesForServer()); err != nil {
481 return nil, err
482 }
483 }
484
485 digest, hashFunc, err := hashForServerKeyExchange(ka.sigType, tls12HashId, ka.version, clientHello.random, hello.random, params)
486 if err != nil {
487 return nil, err
488 }
489
490 if config.Bugs.InvalidSKXSignature {
491 digest[0] ^= 0x80
492 }
493
494 var sig []byte
495 switch ka.sigType {
496 case signatureECDSA:
497 privKey, ok := cert.PrivateKey.(*ecdsa.PrivateKey)
498 if !ok {
499 return nil, errors.New("ECDHE ECDSA requires an ECDSA server private key")
500 }
501 r, s, err := ecdsa.Sign(config.rand(), privKey, digest)
502 if err != nil {
503 return nil, errors.New("failed to sign ECDHE parameters: " + err.Error())
504 }
505 order := privKey.Curve.Params().N
506 r = maybeCorruptECDSAValue(r, config.Bugs.BadECDSAR, order)
507 s = maybeCorruptECDSAValue(s, config.Bugs.BadECDSAS, order)
508 sig, err = asn1.Marshal(ecdsaSignature{r, s})
509 case signatureRSA:
510 privKey, ok := cert.PrivateKey.(*rsa.PrivateKey)
511 if !ok {
512 return nil, errors.New("ECDHE RSA requires a RSA server private key")
513 }
514 sig, err = rsa.SignPKCS1v15(config.rand(), privKey, hashFunc, digest)
515 if err != nil {
516 return nil, errors.New("failed to sign ECDHE parameters: " + err.Error())
517 }
518 default:
519 return nil, errors.New("unknown ECDHE signature algorithm")
520 }
521
522 skx := new(serverKeyExchangeMsg)
523 if config.Bugs.UnauthenticatedECDH {
524 skx.key = params
525 } else {
526 sigAndHashLen := 0
527 if ka.version >= VersionTLS12 {
528 sigAndHashLen = 2
529 }
530 skx.key = make([]byte, len(params)+sigAndHashLen+2+len(sig))
531 copy(skx.key, params)
532 k := skx.key[len(params):]
533 if ka.version >= VersionTLS12 {
534 k[0] = tls12HashId
535 k[1] = ka.sigType
536 k = k[2:]
537 }
538 k[0] = byte(len(sig) >> 8)
539 k[1] = byte(len(sig))
540 copy(k[2:], sig)
541 }
542
543 return skx, nil
544 }
545
546 func (ka *signedKeyAgreement) verifyParameters(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, params []byte, sig []byte) error {
547 if len(sig) < 2 {
548 return errServerKeyExchange
549 }
550
551 var tls12HashId uint8
552 if ka.version >= VersionTLS12 {
553 // handle SignatureAndHashAlgorithm
554 var sigAndHash []uint8
555 sigAndHash, sig = sig[:2], sig[2:]
556 if sigAndHash[1] != ka.sigType {
557 return errServerKeyExchange
558 }
559 tls12HashId = sigAndHash[0]
560 if len(sig) < 2 {
561 return errServerKeyExchange
562 }
563
564 if !isSupportedSignatureAndHash(signatureAndHash{ka.sigType, tls12HashId}, config.signatureAndHashesForClient()) {
565 return errors.New("tls: unsupported hash function for ServerKeyExchange")
566 }
567 }
568 sigLen := int(sig[0])<<8 | int(sig[1])
569 if sigLen+2 != len(sig) {
570 return errServerKeyExchange
571 }
572 sig = sig[2:]
573
574 digest, hashFunc, err := hashForServerKeyExchange(ka.sigType, tls12HashId, ka.version, clientHello.random, serverHello.random, params)
575 if err != nil {
576 return err
577 }
578 switch ka.sigType {
579 case signatureECDSA:
580 pubKey, ok := cert.PublicKey.(*ecdsa.PublicKey)
581 if !ok {
582 return errors.New("ECDHE ECDSA requires a ECDSA server public key")
583 }
584 ecdsaSig := new(ecdsaSignature)
585 if _, err := asn1.Unmarshal(sig, ecdsaSig); err != nil {
586 return err
587 }
588 if ecdsaSig.R.Sign() <= 0 || ecdsaSig.S.Sign() <= 0 {
589 return errors.New("ECDSA signature contained zero or negative values")
590 }
591 if !ecdsa.Verify(pubKey, digest, ecdsaSig.R, ecdsaSig.S) {
592 return errors.New("ECDSA verification failure")
593 }
594 case signatureRSA:
595 pubKey, ok := cert.PublicKey.(*rsa.PublicKey)
596 if !ok {
597 return errors.New("ECDHE RSA requires a RSA server public key")
598 }
599 if err := rsa.VerifyPKCS1v15(pubKey, hashFunc, digest, sig); err != nil {
600 return err
601 }
602 default:
603 return errors.New("unknown ECDHE signature algorithm")
604 }
605
606 return nil
607 }
608
609 // ecdheRSAKeyAgreement implements a TLS key agreement where the server
610 // generates a ephemeral EC public/private key pair and signs it. The
611 // pre-master secret is then calculated using ECDH. The signature may
612 // either be ECDSA or RSA.
613 type ecdheKeyAgreement struct {
614 auth keyAgreementAuthentication
615 curve ecdhCurve
616 peerKey []byte
617 }
618
619 func (ka *ecdheKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
620 var curveid CurveID
621 preferredCurves := config.curvePreferences()
622
623 NextCandidate:
624 for _, candidate := range preferredCurves {
625 for _, c := range clientHello.supportedCurves {
626 if candidate == c {
627 curveid = c
628 break NextCandidate
629 }
630 }
631 }
632
633 if curveid == 0 {
634 return nil, errors.New("tls: no supported elliptic curves offered")
635 }
636
637 var ok bool
638 if ka.curve, ok = curveForCurveID(curveid); !ok {
639 return nil, errors.New("tls: preferredCurves includes unsupported curve")
640 }
641
642 publicKey, err := ka.curve.offer(config.rand())
643 if err != nil {
644 return nil, err
645 }
646
647 // http://tools.ietf.org/html/rfc4492#section-5.4
648 serverECDHParams := make([]byte, 1+2+1+len(publicKey))
649 serverECDHParams[0] = 3 // named curve
650 serverECDHParams[1] = byte(curveid >> 8)
651 serverECDHParams[2] = byte(curveid)
652 if config.Bugs.InvalidSKXCurve {
653 serverECDHParams[2] ^= 0xff
654 }
655 serverECDHParams[3] = byte(len(publicKey))
656 copy(serverECDHParams[4:], publicKey)
657 if config.Bugs.InvalidECDHPoint {
658 serverECDHParams[4] ^= 0xff
659 }
660
661 return ka.auth.signParameters(config, cert, clientHello, hello, serverECDHParams)
662 }
663
664 func (ka *ecdheKeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
665 if len(ckx.ciphertext) == 0 || int(ckx.ciphertext[0]) != len(ckx.ciphertext)-1 {
666 return nil, errClientKeyExchange
667 }
668 return ka.curve.finish(ckx.ciphertext[1:])
669 }
670
671 func (ka *ecdheKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
672 if len(skx.key) < 4 {
673 return errServerKeyExchange
674 }
675 if skx.key[0] != 3 { // named curve
676 return errors.New("tls: server selected unsupported curve")
677 }
678 curveid := CurveID(skx.key[1])<<8 | CurveID(skx.key[2])
679
680 var ok bool
681 if ka.curve, ok = curveForCurveID(curveid); !ok {
682 return errors.New("tls: server selected unsupported curve")
683 }
684
685 publicLen := int(skx.key[3])
686 if publicLen+4 > len(skx.key) {
687 return errServerKeyExchange
688 }
689 // Save the peer key for later.
690 ka.peerKey = skx.key[4 : 4+publicLen]
691
692 // Check the signature.
693 serverECDHParams := skx.key[:4+publicLen]
694 sig := skx.key[4+publicLen:]
695 return ka.auth.verifyParameters(config, clientHello, serverHello, cert, serverECDHParams, sig)
696 }
697
698 func (ka *ecdheKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
699 if ka.curve == nil {
700 return nil, nil, errors.New("missing ServerKeyExchange message")
701 }
702
703 publicKey, preMasterSecret, err := ka.curve.accept(config.rand(), ka.peerKey)
704 if err != nil {
705 return nil, nil, err
706 }
707
708 ckx := new(clientKeyExchangeMsg)
709 ckx.ciphertext = make([]byte, 1+len(publicKey))
710 ckx.ciphertext[0] = byte(len(publicKey))
711 copy(ckx.ciphertext[1:], publicKey)
712 if config.Bugs.InvalidECDHPoint {
713 ckx.ciphertext[1] ^= 0xff
714 }
715
716 return preMasterSecret, ckx, nil
717 }
718
719 // cecpq1RSAKeyAgreement is like an ecdheKeyAgreement, but using the cecpq1Curve
720 // pseudo-curve, and without any parameters (e.g. curve name) other than the
721 // keys being exchanged. The signature may either be ECDSA or RSA.
722 type cecpq1KeyAgreement struct {
723 auth keyAgreementAuthentication
724 curve ecdhCurve
725 peerKey []byte
726 }
727
728 func (ka *cecpq1KeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
729 ka.curve = &cecpq1Curve{}
730 publicKey, err := ka.curve.offer(config.rand())
731 if err != nil {
732 return nil, err
733 }
734
735 if config.Bugs.CECPQ1BadX25519Part {
736 publicKey[0] ^= 1
737 }
738 if config.Bugs.CECPQ1BadNewhopePart {
739 publicKey[32] ^= 1
740 publicKey[33] ^= 1
741 publicKey[34] ^= 1
742 publicKey[35] ^= 1
743 }
744
745 var params []byte
746 params = append(params, byte(len(publicKey)>>8))
747 params = append(params, byte(len(publicKey)&0xff))
748 params = append(params, publicKey[:]...)
749
750 return ka.auth.signParameters(config, cert, clientHello, hello, params)
751 }
752
753 func (ka *cecpq1KeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
754 if len(ckx.ciphertext) < 2 {
755 return nil, errClientKeyExchange
756 }
757 peerKeyLen := int(ckx.ciphertext[0])<<8 + int(ckx.ciphertext[1])
758 peerKey := ckx.ciphertext[2:]
759 if peerKeyLen != len(peerKey) {
760 return nil, errClientKeyExchange
761 }
762 return ka.curve.finish(peerKey)
763 }
764
765 func (ka *cecpq1KeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
766 if len(skx.key) < 2 {
767 return errServerKeyExchange
768 }
769 peerKeyLen := int(skx.key[0])<<8 + int(skx.key[1])
770 // Save the peer key for later.
771 if len(skx.key) < 2+peerKeyLen {
772 return errServerKeyExchange
773 }
774 ka.peerKey = skx.key[2 : 2+peerKeyLen]
775 if peerKeyLen != len(ka.peerKey) {
776 return errServerKeyExchange
777 }
778
779 // Check the signature.
780 params := skx.key[:2+peerKeyLen]
781 sig := skx.key[2+peerKeyLen:]
782 return ka.auth.verifyParameters(config, clientHello, serverHello, cert, params, sig)
783 }
784
785 func (ka *cecpq1KeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
786 curve := &cecpq1Curve{}
787 publicKey, preMasterSecret, err := curve.accept(config.rand(), ka.peerKey)
788 if err != nil {
789 return nil, nil, err
790 }
791
792 if config.Bugs.CECPQ1BadX25519Part {
793 publicKey[0] ^= 1
794 }
795 if config.Bugs.CECPQ1BadNewhopePart {
796 publicKey[32] ^= 1
797 publicKey[33] ^= 1
798 publicKey[34] ^= 1
799 publicKey[35] ^= 1
800 }
801
802 ckx := new(clientKeyExchangeMsg)
803 ckx.ciphertext = append(ckx.ciphertext, byte(len(publicKey)>>8))
804 ckx.ciphertext = append(ckx.ciphertext, byte(len(publicKey)&0xff))
805 ckx.ciphertext = append(ckx.ciphertext, publicKey[:]...)
806
807 return preMasterSecret, ckx, nil
808 }
809
810 // dheRSAKeyAgreement implements a TLS key agreement where the server generates
811 // an ephemeral Diffie-Hellman public/private key pair and signs it. The
812 // pre-master secret is then calculated using Diffie-Hellman.
813 type dheKeyAgreement struct {
814 auth keyAgreementAuthentication
815 p, g *big.Int
816 yTheirs *big.Int
817 xOurs *big.Int
818 }
819
820 func (ka *dheKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
821 var q *big.Int
822 if p := config.Bugs.DHGroupPrime; p != nil {
823 ka.p = p
824 ka.g = big.NewInt(2)
825 q = p
826 } else {
827 // 2048-bit MODP Group with 256-bit Prime Order Subgroup (RFC
828 // 5114, Section 2.3)
829 ka.p, _ = new(big.Int).SetString("87A8E61DB4B6663CFFBBD19C651959998CEEF608660DD0F25D2CEED4435E3B00E00DF8F1D61957D4FAF7DF4561B2AA3016C3D91134096FAA3BF4296D830E9A7C209E0C6497517ABD5A8A9D306BCF67ED91F9E6725B4758C022E0B1EF4275BF7B6C5BFC11D45F9088B941F54EB1E59BB8BC39A0BF12307F5C4FDB70C581B23F76B63ACAE1CAA6B7902D52526735488A0EF13C6D9A51BFA4AB3AD8347796524D8EF6A167B5A41825D967E144E5140564251CCACB83E6B486F6B3CA3F7971506026C0B857F689962856DED4010ABD0BE621C3A3960A54E710C375F26375D7014103A4B54330C198AF126116D2276E11715F693877FAD7EF09CADB094AE91E1A1597", 16)
830 ka.g, _ = new(big.Int).SetString("3FB32C9B73134D0B2E77506660EDBD484CA7B18F21EF205407F4793A1A0BA12510DBC15077BE463FFF4FED4AAC0BB555BE3A6C1B0C6B47B1BC3773BF7E8C6F62901228F8C28CBB18A55AE31341000A650196F931C77A57F2DDF463E5E9EC144B777DE62AAAB8A8628AC376D282D6ED3864E67982428EBC831D14348F6F2F9193B5045AF2767164E1DFC967C1FB3F2E55A4BD1BFFE83B9C80D052B985D182EA0ADB2A3B7313D3FE14C8484B1E052588B9B7D2BBD2DF016199ECD06E1557CD0915B3353BBB64E0EC377FD028370DF92B52C7891428CDC67EB6184B523D1DB246C32F63078490F00EF8D647D148D47954515E2327CFEF98C582664B4C0F6CC41659", 16)
831 q, _ = new(big.Int).SetString("8CF83642A709A097B447997640129DA299B1A47D1EB3750BA308B0FE64F5FBD3", 16)
832 }
833
834 var err error
835 ka.xOurs, err = rand.Int(config.rand(), q)
836 if err != nil {
837 return nil, err
838 }
839 yOurs := new(big.Int).Exp(ka.g, ka.xOurs, ka.p)
840
841 // http://tools.ietf.org/html/rfc5246#section-7.4.3
842 pBytes := ka.p.Bytes()
843 gBytes := ka.g.Bytes()
844 yBytes := yOurs.Bytes()
845 serverDHParams := make([]byte, 0, 2+len(pBytes)+2+len(gBytes)+2+len(yBytes))
846 serverDHParams = append(serverDHParams, byte(len(pBytes)>>8), byte(len(pBytes)))
847 serverDHParams = append(serverDHParams, pBytes...)
848 serverDHParams = append(serverDHParams, byte(len(gBytes)>>8), byte(len(gBytes)))
849 serverDHParams = append(serverDHParams, gBytes...)
850 serverDHParams = append(serverDHParams, byte(len(yBytes)>>8), byte(len(yBytes)))
851 serverDHParams = append(serverDHParams, yBytes...)
852
853 return ka.auth.signParameters(config, cert, clientHello, hello, serverDHParams)
854 }
855
856 func (ka *dheKeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
857 if len(ckx.ciphertext) < 2 {
858 return nil, errClientKeyExchange
859 }
860 yLen := (int(ckx.ciphertext[0]) << 8) | int(ckx.ciphertext[1])
861 if yLen != len(ckx.ciphertext)-2 {
862 return nil, errClientKeyExchange
863 }
864 yTheirs := new(big.Int).SetBytes(ckx.ciphertext[2:])
865 if yTheirs.Sign() <= 0 || yTheirs.Cmp(ka.p) >= 0 {
866 return nil, errClientKeyExchange
867 }
868 return new(big.Int).Exp(yTheirs, ka.xOurs, ka.p).Bytes(), nil
869 }
870
871 func (ka *dheKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
872 // Read dh_p
873 k := skx.key
874 if len(k) < 2 {
875 return errServerKeyExchange
876 }
877 pLen := (int(k[0]) << 8) | int(k[1])
878 k = k[2:]
879 if len(k) < pLen {
880 return errServerKeyExchange
881 }
882 ka.p = new(big.Int).SetBytes(k[:pLen])
883 k = k[pLen:]
884
885 // Read dh_g
886 if len(k) < 2 {
887 return errServerKeyExchange
888 }
889 gLen := (int(k[0]) << 8) | int(k[1])
890 k = k[2:]
891 if len(k) < gLen {
892 return errServerKeyExchange
893 }
894 ka.g = new(big.Int).SetBytes(k[:gLen])
895 k = k[gLen:]
896
897 // Read dh_Ys
898 if len(k) < 2 {
899 return errServerKeyExchange
900 }
901 yLen := (int(k[0]) << 8) | int(k[1])
902 k = k[2:]
903 if len(k) < yLen {
904 return errServerKeyExchange
905 }
906 ka.yTheirs = new(big.Int).SetBytes(k[:yLen])
907 k = k[yLen:]
908 if ka.yTheirs.Sign() <= 0 || ka.yTheirs.Cmp(ka.p) >= 0 {
909 return errServerKeyExchange
910 }
911
912 if l := config.Bugs.RequireDHPublicValueLen; l != 0 && l != yLen {
913 return fmt.Errorf("RequireDHPublicValueLen set to %d, but server's public value was %d bytes on the wire and %d bytes if minimal", l, yLen, (ka.yTheirs.BitLen()+7)/8)
914 }
915
916 sig := k
917 serverDHParams := skx.key[:len(skx.key)-len(sig)]
918
919 return ka.auth.verifyParameters(config, clientHello, serverHello, cert, serverDHParams, sig)
920 }
921
922 func (ka *dheKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
923 if ka.p == nil || ka.g == nil || ka.yTheirs == nil {
924 return nil, nil, errors.New("missing ServerKeyExchange message")
925 }
926
927 xOurs, err := rand.Int(config.rand(), ka.p)
928 if err != nil {
929 return nil, nil, err
930 }
931 preMasterSecret := new(big.Int).Exp(ka.yTheirs, xOurs, ka.p).Bytes()
932
933 yOurs := new(big.Int).Exp(ka.g, xOurs, ka.p)
934 yBytes := yOurs.Bytes()
935 ckx := new(clientKeyExchangeMsg)
936 ckx.ciphertext = make([]byte, 2+len(yBytes))
937 ckx.ciphertext[0] = byte(len(yBytes) >> 8)
938 ckx.ciphertext[1] = byte(len(yBytes))
939 copy(ckx.ciphertext[2:], yBytes)
940
941 return preMasterSecret, ckx, nil
942 }
943
944 // nilKeyAgreement is a fake key agreement used to implement the plain PSK key
945 // exchange.
946 type nilKeyAgreement struct{}
947
948 func (ka *nilKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
949 return nil, nil
950 }
951
952 func (ka *nilKeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
953 if len(ckx.ciphertext) != 0 {
954 return nil, errClientKeyExchange
955 }
956
957 // Although in plain PSK, otherSecret is all zeros, the base key
958 // agreement does not access to the length of the pre-shared
959 // key. pskKeyAgreement instead interprets nil to mean to use all zeros
960 // of the appropriate length.
961 return nil, nil
962 }
963
964 func (ka *nilKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
965 if len(skx.key) != 0 {
966 return errServerKeyExchange
967 }
968 return nil
969 }
970
971 func (ka *nilKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
972 // Although in plain PSK, otherSecret is all zeros, the base key
973 // agreement does not access to the length of the pre-shared
974 // key. pskKeyAgreement instead interprets nil to mean to use all zeros
975 // of the appropriate length.
976 return nil, &clientKeyExchangeMsg{}, nil
977 }
978
979 // makePSKPremaster formats a PSK pre-master secret based on otherSecret from
980 // the base key exchange and psk.
981 func makePSKPremaster(otherSecret, psk []byte) []byte {
982 out := make([]byte, 0, 2+len(otherSecret)+2+len(psk))
983 out = append(out, byte(len(otherSecret)>>8), byte(len(otherSecret)))
984 out = append(out, otherSecret...)
985 out = append(out, byte(len(psk)>>8), byte(len(psk)))
986 out = append(out, psk...)
987 return out
988 }
989
990 // pskKeyAgreement implements the PSK key agreement.
991 type pskKeyAgreement struct {
992 base keyAgreement
993 identityHint string
994 }
995
996 func (ka *pskKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
997 // Assemble the identity hint.
998 bytes := make([]byte, 2+len(config.PreSharedKeyIdentity))
999 bytes[0] = byte(len(config.PreSharedKeyIdentity) >> 8)
1000 bytes[1] = byte(len(config.PreSharedKeyIdentity))
1001 copy(bytes[2:], []byte(config.PreSharedKeyIdentity))
1002
1003 // If there is one, append the base key agreement's
1004 // ServerKeyExchange.
1005 baseSkx, err := ka.base.generateServerKeyExchange(config, cert, clientHello, hello)
1006 if err != nil {
1007 return nil, err
1008 }
1009
1010 if baseSkx != nil {
1011 bytes = append(bytes, baseSkx.key...)
1012 } else if config.PreSharedKeyIdentity == "" {
1013 // ServerKeyExchange is optional if the identity hint is empty
1014 // and there would otherwise be no ServerKeyExchange.
1015 return nil, nil
1016 }
1017
1018 skx := new(serverKeyExchangeMsg)
1019 skx.key = bytes
1020 return skx, nil
1021 }
1022
1023 func (ka *pskKeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
1024 // First, process the PSK identity.
1025 if len(ckx.ciphertext) < 2 {
1026 return nil, errClientKeyExchange
1027 }
1028 identityLen := (int(ckx.ciphertext[0]) << 8) | int(ckx.ciphertext[1])
1029 if 2+identityLen > len(ckx.ciphertext) {
1030 return nil, errClientKeyExchange
1031 }
1032 identity := string(ckx.ciphertext[2 : 2+identityLen])
1033
1034 if identity != config.PreSharedKeyIdentity {
1035 return nil, errors.New("tls: unexpected identity")
1036 }
1037
1038 if config.PreSharedKey == nil {
1039 return nil, errors.New("tls: pre-shared key not configured")
1040 }
1041
1042 // Process the remainder of the ClientKeyExchange to compute the base
1043 // pre-master secret.
1044 newCkx := new(clientKeyExchangeMsg)
1045 newCkx.ciphertext = ckx.ciphertext[2+identityLen:]
1046 otherSecret, err := ka.base.processClientKeyExchange(config, cert, newCkx, version)
1047 if err != nil {
1048 return nil, err
1049 }
1050
1051 if otherSecret == nil {
1052 // Special-case for the plain PSK key exchanges.
1053 otherSecret = make([]byte, len(config.PreSharedKey))
1054 }
1055 return makePSKPremaster(otherSecret, config.PreSharedKey), nil
1056 }
1057
1058 func (ka *pskKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
1059 if len(skx.key) < 2 {
1060 return errServerKeyExchange
1061 }
1062 identityLen := (int(skx.key[0]) << 8) | int(skx.key[1])
1063 if 2+identityLen > len(skx.key) {
1064 return errServerKeyExchange
1065 }
1066 ka.identityHint = string(skx.key[2 : 2+identityLen])
1067
1068 // Process the remainder of the ServerKeyExchange.
1069 newSkx := new(serverKeyExchangeMsg)
1070 newSkx.key = skx.key[2+identityLen:]
1071 return ka.base.processServerKeyExchange(config, clientHello, serverHello, cert, newSkx)
1072 }
1073
1074 func (ka *pskKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
1075 // The server only sends an identity hint but, for purposes of
1076 // test code, the server always sends the hint and it is
1077 // required to match.
1078 if ka.identityHint != config.PreSharedKeyIdentity {
1079 return nil, nil, errors.New("tls: unexpected identity")
1080 }
1081
1082 // Serialize the identity.
1083 bytes := make([]byte, 2+len(config.PreSharedKeyIdentity))
1084 bytes[0] = byte(len(config.PreSharedKeyIdentity) >> 8)
1085 bytes[1] = byte(len(config.PreSharedKeyIdentity))
1086 copy(bytes[2:], []byte(config.PreSharedKeyIdentity))
1087
1088 // Append the base key exchange's ClientKeyExchange.
1089 otherSecret, baseCkx, err := ka.base.generateClientKeyExchange(config, clientHello, cert)
1090 if err != nil {
1091 return nil, nil, err
1092 }
1093 ckx := new(clientKeyExchangeMsg)
1094 ckx.ciphertext = append(bytes, baseCkx.ciphertext...)
1095
1096 if config.PreSharedKey == nil {
1097 return nil, nil, errors.New("tls: pre-shared key not configured")
1098 }
1099 if otherSecret == nil {
1100 otherSecret = make([]byte, len(config.PreSharedKey))
1101 }
1102 return makePSKPremaster(otherSecret, config.PreSharedKey), ckx, nil
1103 }