Remove most non-TLS-1.2 stuff and most configure options.
[ntbtls.git] / src / ssl_cli.c
1 /*
2  *  SSLv3/TLSv1 client-side functions
3  *
4  *  Copyright (C) 2006-2014, Brainspark B.V.
5  *
6  *  This file is part of PolarSSL (http://www.polarssl.org)
7  *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
8  *
9  *  All rights reserved.
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This program is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License along
22  *  with this program; if not, write to the Free Software Foundation, Inc.,
23  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24  */
25
26 #if !defined(POLARSSL_CONFIG_FILE)
27 #include "polarssl/config.h"
28 #else
29 #include POLARSSL_CONFIG_FILE
30 #endif
31
32 #if defined(POLARSSL_SSL_CLI_C)
33
34 #include "polarssl/debug.h"
35 #include "polarssl/ssl.h"
36
37 #if defined(POLARSSL_PLATFORM_C)
38 #include "polarssl/platform.h"
39 #else
40 #define polarssl_malloc     malloc
41 #define polarssl_free       free
42 #endif
43
44 #include <stdlib.h>
45 #include <stdio.h>
46
47 #if defined(_MSC_VER) && !defined(EFIX64) && !defined(EFI32)
48 #include <basetsd.h>
49 typedef UINT32 uint32_t;
50 #else
51 #include <inttypes.h>
52 #endif
53
54 #if defined(POLARSSL_HAVE_TIME)
55 #include <time.h>
56 #endif
57
58 #if defined(POLARSSL_SSL_SESSION_TICKETS)
59 /* Implementation that should never be optimized out by the compiler */
60 static void
61 polarssl_zeroize (void *v, size_t n)
62 {
63   volatile unsigned char *p = v;
64   while (n--)
65     *p++ = 0;
66 }
67 #endif
68
69 #if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
70 static void
71 ssl_write_hostname_ext (ssl_context * ssl, unsigned char *buf, size_t * olen)
72 {
73   unsigned char *p = buf;
74
75   *olen = 0;
76
77   if (ssl->hostname == NULL)
78     return;
79
80   SSL_DEBUG_MSG (3, ("client hello, adding server name extension: %s",
81                      ssl->hostname));
82
83   /*
84    * struct {
85    *     NameType name_type;
86    *     select (name_type) {
87    *         case host_name: HostName;
88    *     } name;
89    * } ServerName;
90    *
91    * enum {
92    *     host_name(0), (255)
93    * } NameType;
94    *
95    * opaque HostName<1..2^16-1>;
96    *
97    * struct {
98    *     ServerName server_name_list<1..2^16-1>
99    * } ServerNameList;
100    */
101   *p++ = (unsigned char) ((TLS_EXT_SERVERNAME >> 8) & 0xFF);
102   *p++ = (unsigned char) ((TLS_EXT_SERVERNAME) & 0xFF);
103
104   *p++ = (unsigned char) (((ssl->hostname_len + 5) >> 8) & 0xFF);
105   *p++ = (unsigned char) (((ssl->hostname_len + 5)) & 0xFF);
106
107   *p++ = (unsigned char) (((ssl->hostname_len + 3) >> 8) & 0xFF);
108   *p++ = (unsigned char) (((ssl->hostname_len + 3)) & 0xFF);
109
110   *p++ = (unsigned char) ((TLS_EXT_SERVERNAME_HOSTNAME) & 0xFF);
111   *p++ = (unsigned char) ((ssl->hostname_len >> 8) & 0xFF);
112   *p++ = (unsigned char) ((ssl->hostname_len) & 0xFF);
113
114   memcpy (p, ssl->hostname, ssl->hostname_len);
115
116   *olen = ssl->hostname_len + 9;
117 }
118 #endif /* POLARSSL_SSL_SERVER_NAME_INDICATION */
119
120 static void
121 ssl_write_renegotiation_ext (ssl_context * ssl,
122                              unsigned char *buf, size_t * olen)
123 {
124   unsigned char *p = buf;
125
126   *olen = 0;
127
128   if (ssl->renegotiation != SSL_RENEGOTIATION)
129     return;
130
131   SSL_DEBUG_MSG (3, ("client hello, adding renegotiation extension"));
132
133   /*
134    * Secure renegotiation
135    */
136   *p++ = (unsigned char) ((TLS_EXT_RENEGOTIATION_INFO >> 8) & 0xFF);
137   *p++ = (unsigned char) ((TLS_EXT_RENEGOTIATION_INFO) & 0xFF);
138
139   *p++ = 0x00;
140   *p++ = (ssl->verify_data_len + 1) & 0xFF;
141   *p++ = ssl->verify_data_len & 0xFF;
142
143   memcpy (p, ssl->own_verify_data, ssl->verify_data_len);
144
145   *olen = 5 + ssl->verify_data_len;
146 }
147
148 #if defined(POLARSSL_SSL_PROTO_TLS1_2)
149 static void
150 ssl_write_signature_algorithms_ext (ssl_context * ssl,
151                                     unsigned char *buf, size_t * olen)
152 {
153   unsigned char *p = buf;
154   size_t sig_alg_len = 0;
155 #if defined(POLARSSL_RSA_C) || defined(POLARSSL_ECDSA_C)
156   unsigned char *sig_alg_list = buf + 6;
157 #endif
158
159   *olen = 0;
160
161   if (ssl->max_minor_ver != SSL_MINOR_VERSION_3)
162     return;
163
164   SSL_DEBUG_MSG (3, ("client hello, adding signature_algorithms extension"));
165
166   /*
167    * Prepare signature_algorithms extension (TLS 1.2)
168    */
169 #if defined(POLARSSL_RSA_C)
170 #if defined(POLARSSL_SHA512_C)
171   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA512;
172   sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
173   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA384;
174   sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
175 #endif
176 #if defined(POLARSSL_SHA256_C)
177   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA256;
178   sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
179   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA224;
180   sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
181 #endif
182 #if defined(POLARSSL_SHA1_C)
183   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA1;
184   sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
185 #endif
186 #if defined(POLARSSL_MD5_C)
187   sig_alg_list[sig_alg_len++] = SSL_HASH_MD5;
188   sig_alg_list[sig_alg_len++] = SSL_SIG_RSA;
189 #endif
190 #endif /* POLARSSL_RSA_C */
191 #if defined(POLARSSL_ECDSA_C)
192 #if defined(POLARSSL_SHA512_C)
193   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA512;
194   sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
195   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA384;
196   sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
197 #endif
198 #if defined(POLARSSL_SHA256_C)
199   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA256;
200   sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
201   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA224;
202   sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
203 #endif
204 #if defined(POLARSSL_SHA1_C)
205   sig_alg_list[sig_alg_len++] = SSL_HASH_SHA1;
206   sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
207 #endif
208 #if defined(POLARSSL_MD5_C)
209   sig_alg_list[sig_alg_len++] = SSL_HASH_MD5;
210   sig_alg_list[sig_alg_len++] = SSL_SIG_ECDSA;
211 #endif
212 #endif /* POLARSSL_ECDSA_C */
213
214   /*
215    * enum {
216    *     none(0), md5(1), sha1(2), sha224(3), sha256(4), sha384(5),
217    *     sha512(6), (255)
218    * } HashAlgorithm;
219    *
220    * enum { anonymous(0), rsa(1), dsa(2), ecdsa(3), (255) }
221    *   SignatureAlgorithm;
222    *
223    * struct {
224    *     HashAlgorithm hash;
225    *     SignatureAlgorithm signature;
226    * } SignatureAndHashAlgorithm;
227    *
228    * SignatureAndHashAlgorithm
229    *   supported_signature_algorithms<2..2^16-2>;
230    */
231   *p++ = (unsigned char) ((TLS_EXT_SIG_ALG >> 8) & 0xFF);
232   *p++ = (unsigned char) ((TLS_EXT_SIG_ALG) & 0xFF);
233
234   *p++ = (unsigned char) (((sig_alg_len + 2) >> 8) & 0xFF);
235   *p++ = (unsigned char) (((sig_alg_len + 2)) & 0xFF);
236
237   *p++ = (unsigned char) ((sig_alg_len >> 8) & 0xFF);
238   *p++ = (unsigned char) ((sig_alg_len) & 0xFF);
239
240   *olen = 6 + sig_alg_len;
241 }
242 #endif /* POLARSSL_SSL_PROTO_TLS1_2 */
243
244 #if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
245 static void
246 ssl_write_supported_elliptic_curves_ext (ssl_context * ssl,
247                                          unsigned char *buf, size_t * olen)
248 {
249   unsigned char *p = buf;
250   unsigned char *elliptic_curve_list = p + 6;
251   size_t elliptic_curve_len = 0;
252   const ecp_curve_info *info;
253 #if defined(POLARSSL_SSL_SET_CURVES)
254   const ecp_group_id *grp_id;
255 #else
256   ((void) ssl);
257 #endif
258
259   *olen = 0;
260
261   SSL_DEBUG_MSG (3,
262                  ("client hello, adding supported_elliptic_curves extension"));
263
264 #if defined(POLARSSL_SSL_SET_CURVES)
265   for (grp_id = ssl->curve_list; *grp_id != POLARSSL_ECP_DP_NONE; grp_id++)
266     {
267       info = ecp_curve_info_from_grp_id (*grp_id);
268 #else
269   for (info = ecp_curve_list (); info->grp_id != POLARSSL_ECP_DP_NONE; info++)
270     {
271 #endif
272
273       elliptic_curve_list[elliptic_curve_len++] = info->tls_id >> 8;
274       elliptic_curve_list[elliptic_curve_len++] = info->tls_id & 0xFF;
275     }
276
277   if (elliptic_curve_len == 0)
278     return;
279
280   *p++ = (unsigned char) ((TLS_EXT_SUPPORTED_ELLIPTIC_CURVES >> 8) & 0xFF);
281   *p++ = (unsigned char) ((TLS_EXT_SUPPORTED_ELLIPTIC_CURVES) & 0xFF);
282
283   *p++ = (unsigned char) (((elliptic_curve_len + 2) >> 8) & 0xFF);
284   *p++ = (unsigned char) (((elliptic_curve_len + 2)) & 0xFF);
285
286   *p++ = (unsigned char) (((elliptic_curve_len) >> 8) & 0xFF);
287   *p++ = (unsigned char) (((elliptic_curve_len)) & 0xFF);
288
289   *olen = 6 + elliptic_curve_len;
290 }
291
292 static void
293 ssl_write_supported_point_formats_ext (ssl_context * ssl,
294                                        unsigned char *buf, size_t * olen)
295 {
296   unsigned char *p = buf;
297   ((void) ssl);
298
299   *olen = 0;
300
301   SSL_DEBUG_MSG (3,
302                  ("client hello, adding supported_point_formats extension"));
303
304   *p++ = (unsigned char) ((TLS_EXT_SUPPORTED_POINT_FORMATS >> 8) & 0xFF);
305   *p++ = (unsigned char) ((TLS_EXT_SUPPORTED_POINT_FORMATS) & 0xFF);
306
307   *p++ = 0x00;
308   *p++ = 2;
309
310   *p++ = 1;
311   *p++ = POLARSSL_ECP_PF_UNCOMPRESSED;
312
313   *olen = 6;
314 }
315 #endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
316
317 #if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
318 static void
319 ssl_write_max_fragment_length_ext (ssl_context * ssl,
320                                    unsigned char *buf, size_t * olen)
321 {
322   unsigned char *p = buf;
323
324   if (ssl->mfl_code == SSL_MAX_FRAG_LEN_NONE)
325     {
326       *olen = 0;
327       return;
328     }
329
330   SSL_DEBUG_MSG (3, ("client hello, adding max_fragment_length extension"));
331
332   *p++ = (unsigned char) ((TLS_EXT_MAX_FRAGMENT_LENGTH >> 8) & 0xFF);
333   *p++ = (unsigned char) ((TLS_EXT_MAX_FRAGMENT_LENGTH) & 0xFF);
334
335   *p++ = 0x00;
336   *p++ = 1;
337
338   *p++ = ssl->mfl_code;
339
340   *olen = 5;
341 }
342 #endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
343
344 #if defined(POLARSSL_SSL_TRUNCATED_HMAC)
345 static void
346 ssl_write_truncated_hmac_ext (ssl_context * ssl,
347                               unsigned char *buf, size_t * olen)
348 {
349   unsigned char *p = buf;
350
351   if (ssl->trunc_hmac == SSL_TRUNC_HMAC_DISABLED)
352     {
353       *olen = 0;
354       return;
355     }
356
357   SSL_DEBUG_MSG (3, ("client hello, adding truncated_hmac extension"));
358
359   *p++ = (unsigned char) ((TLS_EXT_TRUNCATED_HMAC >> 8) & 0xFF);
360   *p++ = (unsigned char) ((TLS_EXT_TRUNCATED_HMAC) & 0xFF);
361
362   *p++ = 0x00;
363   *p++ = 0x00;
364
365   *olen = 4;
366 }
367 #endif /* POLARSSL_SSL_TRUNCATED_HMAC */
368
369 #if defined(POLARSSL_SSL_SESSION_TICKETS)
370 static void
371 ssl_write_session_ticket_ext (ssl_context * ssl,
372                               unsigned char *buf, size_t * olen)
373 {
374   unsigned char *p = buf;
375   size_t tlen = ssl->session_negotiate->ticket_len;
376
377   if (ssl->session_tickets == SSL_SESSION_TICKETS_DISABLED)
378     {
379       *olen = 0;
380       return;
381     }
382
383   SSL_DEBUG_MSG (3, ("client hello, adding session ticket extension"));
384
385   *p++ = (unsigned char) ((TLS_EXT_SESSION_TICKET >> 8) & 0xFF);
386   *p++ = (unsigned char) ((TLS_EXT_SESSION_TICKET) & 0xFF);
387
388   *p++ = (unsigned char) ((tlen >> 8) & 0xFF);
389   *p++ = (unsigned char) ((tlen) & 0xFF);
390
391   *olen = 4;
392
393   if (ssl->session_negotiate->ticket == NULL ||
394       ssl->session_negotiate->ticket_len == 0)
395     {
396       return;
397     }
398
399   SSL_DEBUG_MSG (3, ("sending session ticket of length %d", tlen));
400
401   memcpy (p, ssl->session_negotiate->ticket, tlen);
402
403   *olen += tlen;
404 }
405 #endif /* POLARSSL_SSL_SESSION_TICKETS */
406
407 #if defined(POLARSSL_SSL_ALPN)
408 static void
409 ssl_write_alpn_ext (ssl_context * ssl, unsigned char *buf, size_t * olen)
410 {
411   unsigned char *p = buf;
412   const char **cur;
413
414   if (ssl->alpn_list == NULL)
415     {
416       *olen = 0;
417       return;
418     }
419
420   SSL_DEBUG_MSG (3, ("client hello, adding alpn extension"));
421
422   *p++ = (unsigned char) ((TLS_EXT_ALPN >> 8) & 0xFF);
423   *p++ = (unsigned char) ((TLS_EXT_ALPN) & 0xFF);
424
425   /*
426    * opaque ProtocolName<1..2^8-1>;
427    *
428    * struct {
429    *     ProtocolName protocol_name_list<2..2^16-1>
430    * } ProtocolNameList;
431    */
432
433   /* Skip writing extension and list length for now */
434   p += 4;
435
436   for (cur = ssl->alpn_list; *cur != NULL; cur++)
437     {
438       *p = (unsigned char) (strlen (*cur) & 0xFF);
439       memcpy (p + 1, *cur, *p);
440       p += 1 + *p;
441     }
442
443   *olen = p - buf;
444
445   /* List length = olen - 2 (ext_type) - 2 (ext_len) - 2 (list_len) */
446   buf[4] = (unsigned char) (((*olen - 6) >> 8) & 0xFF);
447   buf[5] = (unsigned char) (((*olen - 6)) & 0xFF);
448
449   /* Extension length = olen - 2 (ext_type) - 2 (ext_len) */
450   buf[2] = (unsigned char) (((*olen - 4) >> 8) & 0xFF);
451   buf[3] = (unsigned char) (((*olen - 4)) & 0xFF);
452 }
453 #endif /* POLARSSL_SSL_ALPN */
454
455 static int
456 ssl_write_client_hello (ssl_context * ssl)
457 {
458   int ret;
459   size_t i, n, olen, ext_len = 0;
460   unsigned char *buf;
461   unsigned char *p, *q;
462 #if defined(POLARSSL_HAVE_TIME)
463   time_t t;
464 #endif
465   const int *ciphersuites;
466   const ssl_ciphersuite_t *ciphersuite_info;
467
468   SSL_DEBUG_MSG (2, ("=> write client hello"));
469
470   if (ssl->f_rng == NULL)
471     {
472       SSL_DEBUG_MSG (1, ("no RNG provided"));
473       return (POLARSSL_ERR_SSL_NO_RNG);
474     }
475
476   if (ssl->renegotiation == SSL_INITIAL_HANDSHAKE)
477     {
478       ssl->major_ver = ssl->min_major_ver;
479       ssl->minor_ver = ssl->min_minor_ver;
480     }
481
482   if (ssl->max_major_ver == 0 && ssl->max_minor_ver == 0)
483     {
484       ssl->max_major_ver = SSL_MAX_MAJOR_VERSION;
485       ssl->max_minor_ver = SSL_MAX_MINOR_VERSION;
486     }
487
488   /*
489    *     0  .   0   handshake type
490    *     1  .   3   handshake length
491    *     4  .   5   highest version supported
492    *     6  .   9   current UNIX time
493    *    10  .  37   random bytes
494    */
495   buf = ssl->out_msg;
496   p = buf + 4;
497
498   *p++ = (unsigned char) ssl->max_major_ver;
499   *p++ = (unsigned char) ssl->max_minor_ver;
500
501   SSL_DEBUG_MSG (3, ("client hello, max version: [%d:%d]", buf[4], buf[5]));
502
503 #if defined(POLARSSL_HAVE_TIME)
504   t = time (NULL);
505   *p++ = (unsigned char) (t >> 24);
506   *p++ = (unsigned char) (t >> 16);
507   *p++ = (unsigned char) (t >> 8);
508   *p++ = (unsigned char) (t);
509
510   SSL_DEBUG_MSG (3, ("client hello, current time: %lu", t));
511 #else
512   if ((ret = ssl->f_rng (ssl->p_rng, p, 4)) != 0)
513     return (ret);
514
515   p += 4;
516 #endif /* POLARSSL_HAVE_TIME */
517
518   if ((ret = ssl->f_rng (ssl->p_rng, p, 28)) != 0)
519     return (ret);
520
521   p += 28;
522
523   memcpy (ssl->handshake->randbytes, buf + 6, 32);
524
525   SSL_DEBUG_BUF (3, "client hello, random bytes", buf + 6, 32);
526
527   /*
528    *    38  .  38   session id length
529    *    39  . 39+n  session id
530    *   40+n . 41+n  ciphersuitelist length
531    *   42+n . ..    ciphersuitelist
532    *   ..   . ..    compression methods length
533    *   ..   . ..    compression methods
534    *   ..   . ..    extensions length
535    *   ..   . ..    extensions
536    */
537   n = ssl->session_negotiate->length;
538
539   if (ssl->renegotiation != SSL_INITIAL_HANDSHAKE || n < 16 || n > 32 ||
540       ssl->handshake->resume == 0)
541     {
542       n = 0;
543     }
544
545 #if defined(POLARSSL_SSL_SESSION_TICKETS)
546   /*
547    * RFC 5077 section 3.4: "When presenting a ticket, the client MAY
548    * generate and include a Session ID in the TLS ClientHello."
549    */
550   if (ssl->renegotiation == SSL_INITIAL_HANDSHAKE &&
551       ssl->session_negotiate->ticket != NULL &&
552       ssl->session_negotiate->ticket_len != 0)
553     {
554       ret = ssl->f_rng (ssl->p_rng, ssl->session_negotiate->id, 32);
555
556       if (ret != 0)
557         return (ret);
558
559       ssl->session_negotiate->length = n = 32;
560     }
561 #endif /* POLARSSL_SSL_SESSION_TICKETS */
562
563   *p++ = (unsigned char) n;
564
565   for (i = 0; i < n; i++)
566     *p++ = ssl->session_negotiate->id[i];
567
568   SSL_DEBUG_MSG (3, ("client hello, session id len.: %d", n));
569   SSL_DEBUG_BUF (3, "client hello, session id", buf + 39, n);
570
571   ciphersuites = ssl->ciphersuite_list[ssl->minor_ver];
572   n = 0;
573   q = p;
574
575   // Skip writing ciphersuite length for now
576   p += 2;
577
578   /*
579    * Add TLS_EMPTY_RENEGOTIATION_INFO_SCSV
580    */
581   if (ssl->renegotiation == SSL_INITIAL_HANDSHAKE)
582     {
583       *p++ = (unsigned char) (SSL_EMPTY_RENEGOTIATION_INFO >> 8);
584       *p++ = (unsigned char) (SSL_EMPTY_RENEGOTIATION_INFO);
585       n++;
586     }
587
588   for (i = 0; ciphersuites[i] != 0; i++)
589     {
590       ciphersuite_info = ssl_ciphersuite_from_id (ciphersuites[i]);
591
592       if (ciphersuite_info == NULL)
593         continue;
594
595       if (ciphersuite_info->min_minor_ver > ssl->max_minor_ver ||
596           ciphersuite_info->max_minor_ver < ssl->min_minor_ver)
597         continue;
598
599       SSL_DEBUG_MSG (3, ("client hello, add ciphersuite: %2d",
600                          ciphersuites[i]));
601
602       n++;
603       *p++ = (unsigned char) (ciphersuites[i] >> 8);
604       *p++ = (unsigned char) (ciphersuites[i]);
605     }
606
607   *q++ = (unsigned char) (n >> 7);
608   *q++ = (unsigned char) (n << 1);
609
610   SSL_DEBUG_MSG (3, ("client hello, got %d ciphersuites", n));
611
612
613 #if defined(POLARSSL_ZLIB_SUPPORT)
614   SSL_DEBUG_MSG (3, ("client hello, compress len.: %d", 2));
615   SSL_DEBUG_MSG (3, ("client hello, compress alg.: %d %d",
616                      SSL_COMPRESS_DEFLATE, SSL_COMPRESS_NULL));
617
618   *p++ = 2;
619   *p++ = SSL_COMPRESS_DEFLATE;
620   *p++ = SSL_COMPRESS_NULL;
621 #else
622   SSL_DEBUG_MSG (3, ("client hello, compress len.: %d", 1));
623   SSL_DEBUG_MSG (3, ("client hello, compress alg.: %d", SSL_COMPRESS_NULL));
624
625   *p++ = 1;
626   *p++ = SSL_COMPRESS_NULL;
627 #endif /* POLARSSL_ZLIB_SUPPORT */
628
629   // First write extensions, then the total length
630   //
631 #if defined(POLARSSL_SSL_SERVER_NAME_INDICATION)
632   ssl_write_hostname_ext (ssl, p + 2 + ext_len, &olen);
633   ext_len += olen;
634 #endif
635
636   ssl_write_renegotiation_ext (ssl, p + 2 + ext_len, &olen);
637   ext_len += olen;
638
639 #if defined(POLARSSL_SSL_PROTO_TLS1_2)
640   ssl_write_signature_algorithms_ext (ssl, p + 2 + ext_len, &olen);
641   ext_len += olen;
642 #endif
643
644 #if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
645   ssl_write_supported_elliptic_curves_ext (ssl, p + 2 + ext_len, &olen);
646   ext_len += olen;
647
648   ssl_write_supported_point_formats_ext (ssl, p + 2 + ext_len, &olen);
649   ext_len += olen;
650 #endif
651
652 #if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
653   ssl_write_max_fragment_length_ext (ssl, p + 2 + ext_len, &olen);
654   ext_len += olen;
655 #endif
656
657 #if defined(POLARSSL_SSL_TRUNCATED_HMAC)
658   ssl_write_truncated_hmac_ext (ssl, p + 2 + ext_len, &olen);
659   ext_len += olen;
660 #endif
661
662 #if defined(POLARSSL_SSL_SESSION_TICKETS)
663   ssl_write_session_ticket_ext (ssl, p + 2 + ext_len, &olen);
664   ext_len += olen;
665 #endif
666
667 #if defined(POLARSSL_SSL_ALPN)
668   ssl_write_alpn_ext (ssl, p + 2 + ext_len, &olen);
669   ext_len += olen;
670 #endif
671
672   SSL_DEBUG_MSG (3, ("client hello, total extension length: %d", ext_len));
673
674   if (ext_len > 0)
675     {
676       *p++ = (unsigned char) ((ext_len >> 8) & 0xFF);
677       *p++ = (unsigned char) ((ext_len) & 0xFF);
678       p += ext_len;
679     }
680
681   ssl->out_msglen = p - buf;
682   ssl->out_msgtype = SSL_MSG_HANDSHAKE;
683   ssl->out_msg[0] = SSL_HS_CLIENT_HELLO;
684
685   ssl->state++;
686
687   if ((ret = ssl_write_record (ssl)) != 0)
688     {
689       SSL_DEBUG_RET (1, "ssl_write_record", ret);
690       return (ret);
691     }
692
693   SSL_DEBUG_MSG (2, ("<= write client hello"));
694
695   return (0);
696 }
697
698 static int
699 ssl_parse_renegotiation_info (ssl_context * ssl,
700                               const unsigned char *buf, size_t len)
701 {
702   int ret;
703
704   if (ssl->renegotiation == SSL_INITIAL_HANDSHAKE)
705     {
706       if (len != 1 || buf[0] != 0x0)
707         {
708           SSL_DEBUG_MSG (1,
709                          ("non-zero length renegotiated connection field"));
710
711           if ((ret = ssl_send_fatal_handshake_failure (ssl)) != 0)
712             return (ret);
713
714           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
715         }
716
717       ssl->secure_renegotiation = SSL_SECURE_RENEGOTIATION;
718     }
719   else
720     {
721       /* Check verify-data in constant-time. The length OTOH is no secret */
722       if (len != 1 + ssl->verify_data_len * 2 ||
723           buf[0] != ssl->verify_data_len * 2 ||
724           safer_memcmp (buf + 1,
725                         ssl->own_verify_data, ssl->verify_data_len) != 0 ||
726           safer_memcmp (buf + 1 + ssl->verify_data_len,
727                         ssl->peer_verify_data, ssl->verify_data_len) != 0)
728         {
729           SSL_DEBUG_MSG (1, ("non-matching renegotiated connection field"));
730
731           if ((ret = ssl_send_fatal_handshake_failure (ssl)) != 0)
732             return (ret);
733
734           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
735         }
736     }
737
738   return (0);
739 }
740
741 #if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
742 static int
743 ssl_parse_max_fragment_length_ext (ssl_context * ssl,
744                                    const unsigned char *buf, size_t len)
745 {
746   /*
747    * server should use the extension only if we did,
748    * and if so the server's value should match ours (and len is always 1)
749    */
750   if (ssl->mfl_code == SSL_MAX_FRAG_LEN_NONE ||
751       len != 1 || buf[0] != ssl->mfl_code)
752     {
753       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
754     }
755
756   return (0);
757 }
758 #endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
759
760 #if defined(POLARSSL_SSL_TRUNCATED_HMAC)
761 static int
762 ssl_parse_truncated_hmac_ext (ssl_context * ssl,
763                               const unsigned char *buf, size_t len)
764 {
765   if (ssl->trunc_hmac == SSL_TRUNC_HMAC_DISABLED || len != 0)
766     {
767       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
768     }
769
770   ((void) buf);
771
772   ssl->session_negotiate->trunc_hmac = SSL_TRUNC_HMAC_ENABLED;
773
774   return (0);
775 }
776 #endif /* POLARSSL_SSL_TRUNCATED_HMAC */
777
778 #if defined(POLARSSL_SSL_SESSION_TICKETS)
779 static int
780 ssl_parse_session_ticket_ext (ssl_context * ssl,
781                               const unsigned char *buf, size_t len)
782 {
783   if (ssl->session_tickets == SSL_SESSION_TICKETS_DISABLED || len != 0)
784     {
785       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
786     }
787
788   ((void) buf);
789
790   ssl->handshake->new_session_ticket = 1;
791
792   return (0);
793 }
794 #endif /* POLARSSL_SSL_SESSION_TICKETS */
795
796 #if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
797 static int
798 ssl_parse_supported_point_formats_ext (ssl_context * ssl,
799                                        const unsigned char *buf, size_t len)
800 {
801   size_t list_size;
802   const unsigned char *p;
803
804   list_size = buf[0];
805   if (list_size + 1 != len)
806     {
807       SSL_DEBUG_MSG (1, ("bad server hello message"));
808       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
809     }
810
811   p = buf + 1;
812   while (list_size > 0)
813     {
814       if (p[0] == POLARSSL_ECP_PF_UNCOMPRESSED ||
815           p[0] == POLARSSL_ECP_PF_COMPRESSED)
816         {
817           ssl->handshake->ecdh_ctx.point_format = p[0];
818           SSL_DEBUG_MSG (4, ("point format selected: %d", p[0]));
819           return (0);
820         }
821
822       list_size--;
823       p++;
824     }
825
826   SSL_DEBUG_MSG (1, ("no point format in common"));
827   return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
828 }
829 #endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
830
831 #if defined(POLARSSL_SSL_ALPN)
832 static int
833 ssl_parse_alpn_ext (ssl_context * ssl, const unsigned char *buf, size_t len)
834 {
835   size_t list_len, name_len;
836   const char **p;
837
838   /* If we didn't send it, the server shouldn't send it */
839   if (ssl->alpn_list == NULL)
840     return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
841
842   /*
843    * opaque ProtocolName<1..2^8-1>;
844    *
845    * struct {
846    *     ProtocolName protocol_name_list<2..2^16-1>
847    * } ProtocolNameList;
848    *
849    * the "ProtocolNameList" MUST contain exactly one "ProtocolName"
850    */
851
852   /* Min length is 2 (list_len) + 1 (name_len) + 1 (name) */
853   if (len < 4)
854     return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
855
856   list_len = (buf[0] << 8) | buf[1];
857   if (list_len != len - 2)
858     return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
859
860   name_len = buf[2];
861   if (name_len != list_len - 1)
862     return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
863
864   /* Check that the server chosen protocol was in our list and save it */
865   for (p = ssl->alpn_list; *p != NULL; p++)
866     {
867       if (name_len == strlen (*p) && memcmp (buf + 3, *p, name_len) == 0)
868         {
869           ssl->alpn_chosen = *p;
870           return (0);
871         }
872     }
873
874   return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
875 }
876 #endif /* POLARSSL_SSL_ALPN */
877
878 static int
879 ssl_parse_server_hello (ssl_context * ssl)
880 {
881   int ret, i, comp;
882   size_t n;
883   size_t ext_len = 0;
884   unsigned char *buf, *ext;
885   int renegotiation_info_seen = 0;
886   int handshake_failure = 0;
887 #if defined(POLARSSL_DEBUG_C)
888   uint32_t t;
889 #endif
890
891   SSL_DEBUG_MSG (2, ("=> parse server hello"));
892
893   /*
894    *     0  .   0   handshake type
895    *     1  .   3   handshake length
896    *     4  .   5   protocol version
897    *     6  .   9   UNIX time()
898    *    10  .  37   random bytes
899    */
900   buf = ssl->in_msg;
901
902   if ((ret = ssl_read_record (ssl)) != 0)
903     {
904       SSL_DEBUG_RET (1, "ssl_read_record", ret);
905       return (ret);
906     }
907
908   if (ssl->in_msgtype != SSL_MSG_HANDSHAKE)
909     {
910       SSL_DEBUG_MSG (1, ("bad server hello message"));
911       return (POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE);
912     }
913
914   SSL_DEBUG_MSG (3, ("server hello, chosen version: [%d:%d]",
915                      buf[4], buf[5]));
916
917   if (ssl->in_hslen < 42 ||
918       buf[0] != SSL_HS_SERVER_HELLO || buf[4] != SSL_MAJOR_VERSION_3)
919     {
920       SSL_DEBUG_MSG (1, ("bad server hello message"));
921       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
922     }
923
924   if (buf[5] > ssl->max_minor_ver)
925     {
926       SSL_DEBUG_MSG (1, ("bad server hello message"));
927       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
928     }
929
930   ssl->minor_ver = buf[5];
931
932   if (ssl->minor_ver < ssl->min_minor_ver)
933     {
934       SSL_DEBUG_MSG (1, ("server only supports ssl smaller than minimum"
935                          " [%d:%d] < [%d:%d]", ssl->major_ver,
936                          ssl->minor_ver, buf[4], buf[5]));
937
938       ssl_send_alert_message (ssl, SSL_ALERT_LEVEL_FATAL,
939                               SSL_ALERT_MSG_PROTOCOL_VERSION);
940
941       return (POLARSSL_ERR_SSL_BAD_HS_PROTOCOL_VERSION);
942     }
943
944 #if defined(POLARSSL_DEBUG_C)
945   t = ((uint32_t) buf[6] << 24)
946     | ((uint32_t) buf[7] << 16)
947     | ((uint32_t) buf[8] << 8) | ((uint32_t) buf[9]);
948   SSL_DEBUG_MSG (3, ("server hello, current time: %lu", t));
949 #endif
950
951   memcpy (ssl->handshake->randbytes + 32, buf + 6, 32);
952
953   n = buf[38];
954
955   SSL_DEBUG_BUF (3, "server hello, random bytes", buf + 6, 32);
956
957   if (n > 32)
958     {
959       SSL_DEBUG_MSG (1, ("bad server hello message"));
960       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
961     }
962
963   /*
964    *    38  .  38   session id length
965    *    39  . 38+n  session id
966    *   39+n . 40+n  chosen ciphersuite
967    *   41+n . 41+n  chosen compression alg.
968    *   42+n . 43+n  extensions length
969    *   44+n . 44+n+m extensions
970    */
971   if (ssl->in_hslen > 42 + n)
972     {
973       ext_len = ((buf[42 + n] << 8) | (buf[43 + n]));
974
975       if ((ext_len > 0 && ext_len < 4) || ssl->in_hslen != 44 + n + ext_len)
976         {
977           SSL_DEBUG_MSG (1, ("bad server hello message"));
978           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
979         }
980     }
981
982   i = (buf[39 + n] << 8) | buf[40 + n];
983   comp = buf[41 + n];
984
985   /*
986    * Initialize update checksum functions
987    */
988   ssl->transform_negotiate->ciphersuite_info = ssl_ciphersuite_from_id (i);
989
990   if (ssl->transform_negotiate->ciphersuite_info == NULL)
991     {
992       SSL_DEBUG_MSG (1, ("ciphersuite info for %04x not found", i));
993       return (POLARSSL_ERR_SSL_BAD_INPUT_DATA);
994     }
995
996   ssl_optimize_checksum (ssl, ssl->transform_negotiate->ciphersuite_info);
997
998   SSL_DEBUG_MSG (3, ("server hello, session id len.: %d", n));
999   SSL_DEBUG_BUF (3, "server hello, session id", buf + 39, n);
1000
1001   /*
1002    * Check if the session can be resumed
1003    */
1004   if (ssl->renegotiation != SSL_INITIAL_HANDSHAKE ||
1005       ssl->handshake->resume == 0 || n == 0 ||
1006       ssl->session_negotiate->ciphersuite != i ||
1007       ssl->session_negotiate->compression != comp ||
1008       ssl->session_negotiate->length != n ||
1009       memcmp (ssl->session_negotiate->id, buf + 39, n) != 0)
1010     {
1011       ssl->state++;
1012       ssl->handshake->resume = 0;
1013 #if defined(POLARSSL_HAVE_TIME)
1014       ssl->session_negotiate->start = time (NULL);
1015 #endif
1016       ssl->session_negotiate->ciphersuite = i;
1017       ssl->session_negotiate->compression = comp;
1018       ssl->session_negotiate->length = n;
1019       memcpy (ssl->session_negotiate->id, buf + 39, n);
1020     }
1021   else
1022     {
1023       ssl->state = SSL_SERVER_CHANGE_CIPHER_SPEC;
1024
1025       if ((ret = ssl_derive_keys (ssl)) != 0)
1026         {
1027           SSL_DEBUG_RET (1, "ssl_derive_keys", ret);
1028           return (ret);
1029         }
1030     }
1031
1032   SSL_DEBUG_MSG (3, ("%s session has been resumed",
1033                      ssl->handshake->resume ? "a" : "no"));
1034
1035   SSL_DEBUG_MSG (3, ("server hello, chosen ciphersuite: %d", i));
1036   SSL_DEBUG_MSG (3, ("server hello, compress alg.: %d", buf[41 + n]));
1037
1038   i = 0;
1039   while (1)
1040     {
1041       if (ssl->ciphersuite_list[ssl->minor_ver][i] == 0)
1042         {
1043           SSL_DEBUG_MSG (1, ("bad server hello message"));
1044           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
1045         }
1046
1047       if (ssl->ciphersuite_list[ssl->minor_ver][i++] ==
1048           ssl->session_negotiate->ciphersuite)
1049         {
1050           break;
1051         }
1052     }
1053
1054   if (comp != SSL_COMPRESS_NULL
1055 #if defined(POLARSSL_ZLIB_SUPPORT)
1056       && comp != SSL_COMPRESS_DEFLATE
1057 #endif
1058     )
1059     {
1060       SSL_DEBUG_MSG (1, ("bad server hello message"));
1061       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
1062     }
1063   ssl->session_negotiate->compression = comp;
1064
1065   ext = buf + 44 + n;
1066
1067   SSL_DEBUG_MSG (2, ("server hello, total extension length: %d", ext_len));
1068
1069   while (ext_len)
1070     {
1071       unsigned int ext_id = ((ext[0] << 8) | (ext[1]));
1072       unsigned int ext_size = ((ext[2] << 8) | (ext[3]));
1073
1074       if (ext_size + 4 > ext_len)
1075         {
1076           SSL_DEBUG_MSG (1, ("bad server hello message"));
1077           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
1078         }
1079
1080       switch (ext_id)
1081         {
1082         case TLS_EXT_RENEGOTIATION_INFO:
1083           SSL_DEBUG_MSG (3, ("found renegotiation extension"));
1084           renegotiation_info_seen = 1;
1085
1086           if ((ret = ssl_parse_renegotiation_info (ssl, ext + 4,
1087                                                    ext_size)) != 0)
1088             return (ret);
1089
1090           break;
1091
1092 #if defined(POLARSSL_SSL_MAX_FRAGMENT_LENGTH)
1093         case TLS_EXT_MAX_FRAGMENT_LENGTH:
1094           SSL_DEBUG_MSG (3, ("found max_fragment_length extension"));
1095
1096           if ((ret = ssl_parse_max_fragment_length_ext (ssl,
1097                                                         ext + 4,
1098                                                         ext_size)) != 0)
1099             {
1100               return (ret);
1101             }
1102
1103           break;
1104 #endif /* POLARSSL_SSL_MAX_FRAGMENT_LENGTH */
1105
1106 #if defined(POLARSSL_SSL_TRUNCATED_HMAC)
1107         case TLS_EXT_TRUNCATED_HMAC:
1108           SSL_DEBUG_MSG (3, ("found truncated_hmac extension"));
1109
1110           if ((ret = ssl_parse_truncated_hmac_ext (ssl,
1111                                                    ext + 4, ext_size)) != 0)
1112             {
1113               return (ret);
1114             }
1115
1116           break;
1117 #endif /* POLARSSL_SSL_TRUNCATED_HMAC */
1118
1119 #if defined(POLARSSL_SSL_SESSION_TICKETS)
1120         case TLS_EXT_SESSION_TICKET:
1121           SSL_DEBUG_MSG (3, ("found session_ticket extension"));
1122
1123           if ((ret = ssl_parse_session_ticket_ext (ssl,
1124                                                    ext + 4, ext_size)) != 0)
1125             {
1126               return (ret);
1127             }
1128
1129           break;
1130 #endif /* POLARSSL_SSL_SESSION_TICKETS */
1131
1132 #if defined(POLARSSL_ECDH_C) || defined(POLARSSL_ECDSA_C)
1133         case TLS_EXT_SUPPORTED_POINT_FORMATS:
1134           SSL_DEBUG_MSG (3, ("found supported_point_formats extension"));
1135
1136           if ((ret = ssl_parse_supported_point_formats_ext (ssl,
1137                                                             ext + 4,
1138                                                             ext_size)) != 0)
1139             {
1140               return (ret);
1141             }
1142
1143           break;
1144 #endif /* POLARSSL_ECDH_C || POLARSSL_ECDSA_C */
1145
1146 #if defined(POLARSSL_SSL_ALPN)
1147         case TLS_EXT_ALPN:
1148           SSL_DEBUG_MSG (3, ("found alpn extension"));
1149
1150           if ((ret = ssl_parse_alpn_ext (ssl, ext + 4, ext_size)) != 0)
1151             return (ret);
1152
1153           break;
1154 #endif /* POLARSSL_SSL_ALPN */
1155
1156         default:
1157           SSL_DEBUG_MSG (3, ("unknown extension found: %d (ignoring)",
1158                              ext_id));
1159         }
1160
1161       ext_len -= 4 + ext_size;
1162       ext += 4 + ext_size;
1163
1164       if (ext_len > 0 && ext_len < 4)
1165         {
1166           SSL_DEBUG_MSG (1, ("bad server hello message"));
1167           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
1168         }
1169     }
1170
1171   /*
1172    * Renegotiation security checks
1173    */
1174   if (ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
1175       ssl->allow_legacy_renegotiation == SSL_LEGACY_BREAK_HANDSHAKE)
1176     {
1177       SSL_DEBUG_MSG (1, ("legacy renegotiation, breaking off handshake"));
1178       handshake_failure = 1;
1179     }
1180   else if (ssl->renegotiation == SSL_RENEGOTIATION &&
1181            ssl->secure_renegotiation == SSL_SECURE_RENEGOTIATION &&
1182            renegotiation_info_seen == 0)
1183     {
1184       SSL_DEBUG_MSG (1, ("renegotiation_info extension missing (secure)"));
1185       handshake_failure = 1;
1186     }
1187   else if (ssl->renegotiation == SSL_RENEGOTIATION &&
1188            ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
1189            ssl->allow_legacy_renegotiation == SSL_LEGACY_NO_RENEGOTIATION)
1190     {
1191       SSL_DEBUG_MSG (1, ("legacy renegotiation not allowed"));
1192       handshake_failure = 1;
1193     }
1194   else if (ssl->renegotiation == SSL_RENEGOTIATION &&
1195            ssl->secure_renegotiation == SSL_LEGACY_RENEGOTIATION &&
1196            renegotiation_info_seen == 1)
1197     {
1198       SSL_DEBUG_MSG (1, ("renegotiation_info extension present (legacy)"));
1199       handshake_failure = 1;
1200     }
1201
1202   if (handshake_failure == 1)
1203     {
1204       if ((ret = ssl_send_fatal_handshake_failure (ssl)) != 0)
1205         return (ret);
1206
1207       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO);
1208     }
1209
1210   SSL_DEBUG_MSG (2, ("<= parse server hello"));
1211
1212   return (0);
1213 }
1214
1215 #if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) ||   \
1216   defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
1217 static int
1218 ssl_parse_server_dh_params (ssl_context * ssl, unsigned char **p,
1219                             unsigned char *end)
1220 {
1221   int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
1222
1223   /*
1224    * Ephemeral DH parameters:
1225    *
1226    * struct {
1227    *     opaque dh_p<1..2^16-1>;
1228    *     opaque dh_g<1..2^16-1>;
1229    *     opaque dh_Ys<1..2^16-1>;
1230    * } ServerDHParams;
1231    */
1232   if ((ret = dhm_read_params (&ssl->handshake->dhm_ctx, p, end)) != 0)
1233     {
1234       SSL_DEBUG_RET (2, ("dhm_read_params"), ret);
1235       return (ret);
1236     }
1237
1238   if (ssl->handshake->dhm_ctx.len < 64 || ssl->handshake->dhm_ctx.len > 512)
1239     {
1240       SSL_DEBUG_MSG (1, ("bad server key exchange message (DHM length)"));
1241       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1242     }
1243
1244   SSL_DEBUG_MPI (3, "DHM: P ", &ssl->handshake->dhm_ctx.P);
1245   SSL_DEBUG_MPI (3, "DHM: G ", &ssl->handshake->dhm_ctx.G);
1246   SSL_DEBUG_MPI (3, "DHM: GY", &ssl->handshake->dhm_ctx.GY);
1247
1248   return (ret);
1249 }
1250 #endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
1251           POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
1252
1253 #if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
1254   defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
1255   defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED) ||   \
1256   defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||    \
1257   defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
1258 static int
1259 ssl_check_server_ecdh_params (const ssl_context * ssl)
1260 {
1261   const ecp_curve_info *curve_info;
1262
1263   curve_info = ecp_curve_info_from_grp_id (ssl->handshake->ecdh_ctx.grp.id);
1264   if (curve_info == NULL)
1265     {
1266       SSL_DEBUG_MSG (1, ("should never happen"));
1267       return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
1268     }
1269
1270   SSL_DEBUG_MSG (2, ("ECDH curve: %s", curve_info->name));
1271
1272 #if defined(POLARSSL_SSL_ECP_SET_CURVES)
1273   if (!ssl_curve_is_acceptable (ssl, ssl->handshake->ecdh_ctx.grp.id))
1274 #else
1275   if (ssl->handshake->ecdh_ctx.grp.nbits < 163 ||
1276       ssl->handshake->ecdh_ctx.grp.nbits > 521)
1277 #endif
1278     return (-1);
1279
1280   SSL_DEBUG_ECP (3, "ECDH: Qp", &ssl->handshake->ecdh_ctx.Qp);
1281
1282   return (0);
1283 }
1284 #endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
1285           POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
1286           POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
1287           POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
1288           POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
1289
1290 #if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
1291   defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
1292   defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
1293 static int
1294 ssl_parse_server_ecdh_params (ssl_context * ssl,
1295                               unsigned char **p, unsigned char *end)
1296 {
1297   int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
1298
1299   /*
1300    * Ephemeral ECDH parameters:
1301    *
1302    * struct {
1303    *     ECParameters curve_params;
1304    *     ECPoint      public;
1305    * } ServerECDHParams;
1306    */
1307   if ((ret = ecdh_read_params (&ssl->handshake->ecdh_ctx,
1308                                (const unsigned char **) p, end)) != 0)
1309     {
1310       SSL_DEBUG_RET (1, ("ecdh_read_params"), ret);
1311       return (ret);
1312     }
1313
1314   if (ssl_check_server_ecdh_params (ssl) != 0)
1315     {
1316       SSL_DEBUG_MSG (1, ("bad server key exchange message (ECDHE curve)"));
1317       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1318     }
1319
1320   return (ret);
1321 }
1322 #endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
1323           POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
1324           POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
1325
1326 #if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
1327 static int
1328 ssl_parse_server_psk_hint (ssl_context * ssl,
1329                            unsigned char **p, unsigned char *end)
1330 {
1331   int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
1332   size_t len;
1333   ((void) ssl);
1334
1335   /*
1336    * PSK parameters:
1337    *
1338    * opaque psk_identity_hint<0..2^16-1>;
1339    */
1340   len = (*p)[0] << 8 | (*p)[1];
1341   *p += 2;
1342
1343   if ((*p) + len > end)
1344     {
1345       SSL_DEBUG_MSG (1,
1346                      ("bad server key exchange message (psk_identity_hint length)"));
1347       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1348     }
1349
1350   // TODO: Retrieve PSK identity hint and callback to app
1351   //
1352   *p += len;
1353   ret = 0;
1354
1355   return (ret);
1356 }
1357 #endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
1358
1359 #if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED) ||       \
1360   defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
1361   /*
1362    * Generate a pre-master secret and encrypt it with the server's RSA key
1363    */
1364 static int
1365 ssl_write_encrypted_pms (ssl_context * ssl,
1366                          size_t offset, size_t * olen, size_t pms_offset)
1367 {
1368   int ret;
1369   size_t len_bytes = ssl->minor_ver == SSL_MINOR_VERSION_0 ? 0 : 2;
1370   unsigned char *p = ssl->handshake->premaster + pms_offset;
1371
1372   /*
1373    * Generate (part of) the pre-master as
1374    *  struct {
1375    *      ProtocolVersion client_version;
1376    *      opaque random[46];
1377    *  } PreMasterSecret;
1378    */
1379   p[0] = (unsigned char) ssl->max_major_ver;
1380   p[1] = (unsigned char) ssl->max_minor_ver;
1381
1382   if ((ret = ssl->f_rng (ssl->p_rng, p + 2, 46)) != 0)
1383     {
1384       SSL_DEBUG_RET (1, "f_rng", ret);
1385       return (ret);
1386     }
1387
1388   ssl->handshake->pmslen = 48;
1389
1390   /*
1391    * Now write it out, encrypted
1392    */
1393   if (!pk_can_do (&ssl->session_negotiate->peer_cert->pk, POLARSSL_PK_RSA))
1394     {
1395       SSL_DEBUG_MSG (1, ("certificate key type mismatch"));
1396       return (POLARSSL_ERR_SSL_PK_TYPE_MISMATCH);
1397     }
1398
1399   if ((ret = pk_encrypt (&ssl->session_negotiate->peer_cert->pk,
1400                          p, ssl->handshake->pmslen,
1401                          ssl->out_msg + offset + len_bytes, olen,
1402                          SSL_MAX_CONTENT_LEN - offset - len_bytes,
1403                          ssl->f_rng, ssl->p_rng)) != 0)
1404     {
1405       SSL_DEBUG_RET (1, "rsa_pkcs1_encrypt", ret);
1406       return (ret);
1407     }
1408
1409 #if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
1410   defined(POLARSSL_SSL_PROTO_TLS1_2)
1411   if (len_bytes == 2)
1412     {
1413       ssl->out_msg[offset + 0] = (unsigned char) (*olen >> 8);
1414       ssl->out_msg[offset + 1] = (unsigned char) (*olen);
1415       *olen += 2;
1416     }
1417 #endif
1418
1419   return (0);
1420 }
1421 #endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED ||
1422           POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
1423
1424 #if defined(POLARSSL_SSL_PROTO_TLS1_2)
1425 #if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) ||   \
1426   defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) ||   \
1427   defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
1428 static int
1429 ssl_parse_signature_algorithm (ssl_context * ssl,
1430                                unsigned char **p,
1431                                unsigned char *end,
1432                                md_type_t * md_alg, pk_type_t * pk_alg)
1433 {
1434   ((void) ssl);
1435   *md_alg = POLARSSL_MD_NONE;
1436   *pk_alg = POLARSSL_PK_NONE;
1437
1438   /* Only in TLS 1.2 */
1439   if (ssl->minor_ver != SSL_MINOR_VERSION_3)
1440     {
1441       return (0);
1442     }
1443
1444   if ((*p) + 2 > end)
1445     return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1446
1447   /*
1448    * Get hash algorithm
1449    */
1450   if ((*md_alg = ssl_md_alg_from_hash ((*p)[0])) == POLARSSL_MD_NONE)
1451     {
1452       SSL_DEBUG_MSG (2, ("Server used unsupported "
1453                          "HashAlgorithm %d", *(p)[0]));
1454       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1455     }
1456
1457   /*
1458    * Get signature algorithm
1459    */
1460   if ((*pk_alg = ssl_pk_alg_from_sig ((*p)[1])) == POLARSSL_PK_NONE)
1461     {
1462       SSL_DEBUG_MSG (2, ("server used unsupported "
1463                          "SignatureAlgorithm %d", (*p)[1]));
1464       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1465     }
1466
1467   SSL_DEBUG_MSG (2, ("Server used SignatureAlgorithm %d", (*p)[1]));
1468   SSL_DEBUG_MSG (2, ("Server used HashAlgorithm %d", (*p)[0]));
1469   *p += 2;
1470
1471   return (0);
1472 }
1473 #endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
1474           POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
1475           POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
1476 #endif /* POLARSSL_SSL_PROTO_TLS1_2 */
1477
1478
1479 #if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||  \
1480   defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
1481 static int
1482 ssl_get_ecdh_params_from_cert (ssl_context * ssl)
1483 {
1484   int ret;
1485   const ecp_keypair *peer_key;
1486
1487   if (!pk_can_do (&ssl->session_negotiate->peer_cert->pk, POLARSSL_PK_ECKEY))
1488     {
1489       SSL_DEBUG_MSG (1, ("server key not ECDH capable"));
1490       return (POLARSSL_ERR_SSL_PK_TYPE_MISMATCH);
1491     }
1492
1493   peer_key = pk_ec (ssl->session_negotiate->peer_cert->pk);
1494
1495   if ((ret = ecdh_get_params (&ssl->handshake->ecdh_ctx, peer_key,
1496                               POLARSSL_ECDH_THEIRS)) != 0)
1497     {
1498       SSL_DEBUG_RET (1, ("ecdh_get_params"), ret);
1499       return (ret);
1500     }
1501
1502   if (ssl_check_server_ecdh_params (ssl) != 0)
1503     {
1504       SSL_DEBUG_MSG (1, ("bad server certificate (ECDH curve)"));
1505       return (POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE);
1506     }
1507
1508   return (ret);
1509 }
1510 #endif /* POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||
1511           POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
1512
1513 static int
1514 ssl_parse_server_key_exchange (ssl_context * ssl)
1515 {
1516   int ret;
1517   const ssl_ciphersuite_t *ciphersuite_info =
1518     ssl->transform_negotiate->ciphersuite_info;
1519   unsigned char *p, *end;
1520 #if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) ||   \
1521   defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) ||   \
1522   defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
1523   size_t sig_len, params_len;
1524   unsigned char hash[64];
1525   md_type_t md_alg = POLARSSL_MD_NONE;
1526   size_t hashlen;
1527   pk_type_t pk_alg = POLARSSL_PK_NONE;
1528 #endif
1529
1530   SSL_DEBUG_MSG (2, ("=> parse server key exchange"));
1531
1532 #if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
1533   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA)
1534     {
1535       SSL_DEBUG_MSG (2, ("<= skip parse server key exchange"));
1536       ssl->state++;
1537       return (0);
1538     }
1539   ((void) p);
1540   ((void) end);
1541 #endif
1542
1543 #if defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||  \
1544   defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
1545   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_RSA ||
1546       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_ECDSA)
1547     {
1548       if ((ret = ssl_get_ecdh_params_from_cert (ssl)) != 0)
1549         {
1550           SSL_DEBUG_RET (1, "ssl_get_ecdh_params_from_cert", ret);
1551           return (ret);
1552         }
1553
1554       SSL_DEBUG_MSG (2, ("<= skip parse server key exchange"));
1555       ssl->state++;
1556       return (0);
1557     }
1558   ((void) p);
1559   ((void) end);
1560 #endif /* POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
1561           POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
1562
1563   if ((ret = ssl_read_record (ssl)) != 0)
1564     {
1565       SSL_DEBUG_RET (1, "ssl_read_record", ret);
1566       return (ret);
1567     }
1568
1569   if (ssl->in_msgtype != SSL_MSG_HANDSHAKE)
1570     {
1571       SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1572       return (POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE);
1573     }
1574
1575   /*
1576    * ServerKeyExchange may be skipped with PSK and RSA-PSK when the server
1577    * doesn't use a psk_identity_hint
1578    */
1579   if (ssl->in_msg[0] != SSL_HS_SERVER_KEY_EXCHANGE)
1580     {
1581       if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
1582           ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK)
1583         {
1584           ssl->record_read = 1;
1585           goto exit;
1586         }
1587
1588       SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1589       return (POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE);
1590     }
1591
1592   p = ssl->in_msg + 4;
1593   end = ssl->in_msg + ssl->in_hslen;
1594   SSL_DEBUG_BUF (3, "server key exchange", p, ssl->in_hslen - 4);
1595
1596 #if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
1597   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
1598       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
1599       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
1600       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK)
1601     {
1602       if (ssl_parse_server_psk_hint (ssl, &p, end) != 0)
1603         {
1604           SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1605           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1606         }
1607     }                           /* FALLTROUGH */
1608 #endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
1609
1610 #if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED) ||       \
1611   defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
1612   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
1613       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK)
1614     ;                           /* nothing more to do */
1615   else
1616 #endif /* POLARSSL_KEY_EXCHANGE_PSK_ENABLED ||
1617           POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED */
1618 #if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) ||   \
1619   defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
1620   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA ||
1621         ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK)
1622     {
1623       if (ssl_parse_server_dh_params (ssl, &p, end) != 0)
1624         {
1625           SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1626           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1627         }
1628     }
1629   else
1630 #endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
1631           POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
1632 #if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
1633   defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED) ||   \
1634   defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
1635   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
1636         ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
1637         ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA)
1638     {
1639       if (ssl_parse_server_ecdh_params (ssl, &p, end) != 0)
1640         {
1641           SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1642           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1643         }
1644     }
1645   else
1646 #endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
1647           POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED ||
1648           POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
1649     {
1650       SSL_DEBUG_MSG (1, ("should never happen"));
1651       return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
1652     }
1653
1654 #if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED) ||   \
1655   defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) ||   \
1656   defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
1657   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA ||
1658       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
1659       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA)
1660     {
1661       params_len = p - (ssl->in_msg + 4);
1662
1663       /*
1664        * Handle the digitally-signed structure
1665        */
1666 #if defined(POLARSSL_SSL_PROTO_TLS1_2)
1667       if (ssl->minor_ver == SSL_MINOR_VERSION_3)
1668         {
1669           if (ssl_parse_signature_algorithm (ssl, &p, end,
1670                                              &md_alg, &pk_alg) != 0)
1671             {
1672               SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1673               return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1674             }
1675
1676           if (pk_alg != ssl_get_ciphersuite_sig_pk_alg (ciphersuite_info))
1677             {
1678               SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1679               return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1680             }
1681         }
1682       else
1683 #endif /* POLARSSL_SSL_PROTO_TLS1_2 */
1684 #if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
1685   defined(POLARSSL_SSL_PROTO_TLS1_1)
1686       if (ssl->minor_ver < SSL_MINOR_VERSION_3)
1687         {
1688           pk_alg = ssl_get_ciphersuite_sig_pk_alg (ciphersuite_info);
1689
1690           /* Default hash for ECDSA is SHA-1 */
1691           if (pk_alg == POLARSSL_PK_ECDSA && md_alg == POLARSSL_MD_NONE)
1692             md_alg = POLARSSL_MD_SHA1;
1693         }
1694       else
1695 #endif
1696         {
1697           SSL_DEBUG_MSG (1, ("should never happen"));
1698           return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
1699         }
1700
1701       /*
1702        * Read signature
1703        */
1704       sig_len = (p[0] << 8) | p[1];
1705       p += 2;
1706
1707       if (end != p + sig_len)
1708         {
1709           SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1710           return (POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE);
1711         }
1712
1713       SSL_DEBUG_BUF (3, "signature", p, sig_len);
1714
1715       /*
1716        * Compute the hash that has been signed
1717        */
1718 #if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
1719   defined(POLARSSL_SSL_PROTO_TLS1_1)
1720       if (md_alg == POLARSSL_MD_NONE)
1721         {
1722           md5_context md5;
1723           sha1_context sha1;
1724
1725           md5_init (&md5);
1726           sha1_init (&sha1);
1727
1728           hashlen = 36;
1729
1730           /*
1731            * digitally-signed struct {
1732            *     opaque md5_hash[16];
1733            *     opaque sha_hash[20];
1734            * };
1735            *
1736            * md5_hash
1737            *     MD5(ClientHello.random + ServerHello.random
1738            *                            + ServerParams);
1739            * sha_hash
1740            *     SHA(ClientHello.random + ServerHello.random
1741            *                            + ServerParams);
1742            */
1743           md5_starts (&md5);
1744           md5_update (&md5, ssl->handshake->randbytes, 64);
1745           md5_update (&md5, ssl->in_msg + 4, params_len);
1746           md5_finish (&md5, hash);
1747
1748           sha1_starts (&sha1);
1749           sha1_update (&sha1, ssl->handshake->randbytes, 64);
1750           sha1_update (&sha1, ssl->in_msg + 4, params_len);
1751           sha1_finish (&sha1, hash + 16);
1752
1753           md5_free (&md5);
1754           sha1_free (&sha1);
1755         }
1756       else
1757 #endif /* POLARSSL_SSL_PROTO_SSL3 || POLARSSL_SSL_PROTO_TLS1 || \
1758           POLARSSL_SSL_PROTO_TLS1_1 */
1759 #if defined(POLARSSL_SSL_PROTO_TLS1) || defined(POLARSSL_SSL_PROTO_TLS1_1) || \
1760   defined(POLARSSL_SSL_PROTO_TLS1_2)
1761       if (md_alg != POLARSSL_MD_NONE)
1762         {
1763           md_context_t ctx;
1764
1765           md_init (&ctx);
1766
1767           /* Info from md_alg will be used instead */
1768           hashlen = 0;
1769
1770           /*
1771            * digitally-signed struct {
1772            *     opaque client_random[32];
1773            *     opaque server_random[32];
1774            *     ServerDHParams params;
1775            * };
1776            */
1777           if ((ret = md_init_ctx (&ctx, md_info_from_type (md_alg))) != 0)
1778             {
1779               SSL_DEBUG_RET (1, "md_init_ctx", ret);
1780               return (ret);
1781             }
1782
1783           md_starts (&ctx);
1784           md_update (&ctx, ssl->handshake->randbytes, 64);
1785           md_update (&ctx, ssl->in_msg + 4, params_len);
1786           md_finish (&ctx, hash);
1787           md_free (&ctx);
1788         }
1789       else
1790 #endif /* POLARSSL_SSL_PROTO_TLS1 || POLARSSL_SSL_PROTO_TLS1_1 ||       \
1791           POLARSSL_SSL_PROTO_TLS1_2 */
1792         {
1793           SSL_DEBUG_MSG (1, ("should never happen"));
1794           return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
1795         }
1796
1797       SSL_DEBUG_BUF (3, "parameters hash", hash, hashlen != 0 ? hashlen :
1798                      (unsigned int) (md_info_from_type (md_alg))->size);
1799
1800       /*
1801        * Verify signature
1802        */
1803       if (!pk_can_do (&ssl->session_negotiate->peer_cert->pk, pk_alg))
1804         {
1805           SSL_DEBUG_MSG (1, ("bad server key exchange message"));
1806           return (POLARSSL_ERR_SSL_PK_TYPE_MISMATCH);
1807         }
1808
1809       if ((ret = pk_verify (&ssl->session_negotiate->peer_cert->pk,
1810                             md_alg, hash, hashlen, p, sig_len)) != 0)
1811         {
1812           SSL_DEBUG_RET (1, "pk_verify", ret);
1813           return (ret);
1814         }
1815     }
1816 #endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED ||
1817           POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
1818           POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
1819
1820 exit:
1821   ssl->state++;
1822
1823   SSL_DEBUG_MSG (2, ("<= parse server key exchange"));
1824
1825   return (0);
1826 }
1827
1828 #if !defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)       &&        \
1829   !defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)   &&          \
1830   !defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) &&          \
1831   !defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
1832 static int
1833 ssl_parse_certificate_request (ssl_context * ssl)
1834 {
1835   const ssl_ciphersuite_t *ciphersuite_info =
1836     ssl->transform_negotiate->ciphersuite_info;
1837
1838   SSL_DEBUG_MSG (2, ("=> parse certificate request"));
1839
1840   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
1841       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
1842       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
1843       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK)
1844     {
1845       SSL_DEBUG_MSG (2, ("<= skip parse certificate request"));
1846       ssl->state++;
1847       return (0);
1848     }
1849
1850   SSL_DEBUG_MSG (1, ("should never happen"));
1851   return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
1852 }
1853 #else
1854 static int
1855 ssl_parse_certificate_request (ssl_context * ssl)
1856 {
1857   int ret;
1858   unsigned char *buf, *p;
1859   size_t n = 0, m = 0;
1860   size_t cert_type_len = 0, dn_len = 0;
1861   const ssl_ciphersuite_t *ciphersuite_info =
1862     ssl->transform_negotiate->ciphersuite_info;
1863
1864   SSL_DEBUG_MSG (2, ("=> parse certificate request"));
1865
1866   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
1867       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
1868       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
1869       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK)
1870     {
1871       SSL_DEBUG_MSG (2, ("<= skip parse certificate request"));
1872       ssl->state++;
1873       return (0);
1874     }
1875
1876   /*
1877    *     0  .   0   handshake type
1878    *     1  .   3   handshake length
1879    *     4  .   4   cert type count
1880    *     5  .. m-1  cert types
1881    *     m  .. m+1  sig alg length (TLS 1.2 only)
1882    *    m+1 .. n-1  SignatureAndHashAlgorithms (TLS 1.2 only)
1883    *     n  .. n+1  length of all DNs
1884    *    n+2 .. n+3  length of DN 1
1885    *    n+4 .. ...  Distinguished Name #1
1886    *    ... .. ...  length of DN 2, etc.
1887    */
1888   if (ssl->record_read == 0)
1889     {
1890       if ((ret = ssl_read_record (ssl)) != 0)
1891         {
1892           SSL_DEBUG_RET (1, "ssl_read_record", ret);
1893           return (ret);
1894         }
1895
1896       if (ssl->in_msgtype != SSL_MSG_HANDSHAKE)
1897         {
1898           SSL_DEBUG_MSG (1, ("bad certificate request message"));
1899           return (POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE);
1900         }
1901
1902       ssl->record_read = 1;
1903     }
1904
1905   ssl->client_auth = 0;
1906   ssl->state++;
1907
1908   if (ssl->in_msg[0] == SSL_HS_CERTIFICATE_REQUEST)
1909     ssl->client_auth++;
1910
1911   SSL_DEBUG_MSG (3, ("got %s certificate request",
1912                      ssl->client_auth ? "a" : "no"));
1913
1914   if (ssl->client_auth == 0)
1915     goto exit;
1916
1917   ssl->record_read = 0;
1918
1919   // TODO: handshake_failure alert for an anonymous server to request
1920   // client authentication
1921
1922   buf = ssl->in_msg;
1923
1924   // Retrieve cert types
1925   //
1926   cert_type_len = buf[4];
1927   n = cert_type_len;
1928
1929   if (ssl->in_hslen < 6 + n)
1930     {
1931       SSL_DEBUG_MSG (1, ("bad certificate request message"));
1932       return (POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST);
1933     }
1934
1935   p = buf + 5;
1936   while (cert_type_len > 0)
1937     {
1938 #if defined(POLARSSL_RSA_C)
1939       if (*p == SSL_CERT_TYPE_RSA_SIGN &&
1940           pk_can_do (ssl_own_key (ssl), POLARSSL_PK_RSA))
1941         {
1942           ssl->handshake->cert_type = SSL_CERT_TYPE_RSA_SIGN;
1943           break;
1944         }
1945       else
1946 #endif
1947 #if defined(POLARSSL_ECDSA_C)
1948       if (*p == SSL_CERT_TYPE_ECDSA_SIGN &&
1949             pk_can_do (ssl_own_key (ssl), POLARSSL_PK_ECDSA))
1950         {
1951           ssl->handshake->cert_type = SSL_CERT_TYPE_ECDSA_SIGN;
1952           break;
1953         }
1954       else
1955 #endif
1956         {
1957           ;                     /* Unsupported cert type, ignore */
1958         }
1959
1960       cert_type_len--;
1961       p++;
1962     }
1963
1964 #if defined(POLARSSL_SSL_PROTO_TLS1_2)
1965   if (ssl->minor_ver == SSL_MINOR_VERSION_3)
1966     {
1967       /* Ignored, see comments about hash in write_certificate_verify */
1968       // TODO: should check the signature part against our pk_key though
1969       size_t sig_alg_len = ((buf[5 + n] << 8) | (buf[6 + n]));
1970
1971       p = buf + 7 + n;
1972       m += 2;
1973       n += sig_alg_len;
1974
1975       if (ssl->in_hslen < 6 + n)
1976         {
1977           SSL_DEBUG_MSG (1, ("bad certificate request message"));
1978           return (POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST);
1979         }
1980     }
1981 #endif /* POLARSSL_SSL_PROTO_TLS1_2 */
1982
1983   /* Ignore certificate_authorities, we only have one cert anyway */
1984   // TODO: should not send cert if no CA matches
1985   dn_len = ((buf[5 + m + n] << 8) | (buf[6 + m + n]));
1986
1987   n += dn_len;
1988   if (ssl->in_hslen != 7 + m + n)
1989     {
1990       SSL_DEBUG_MSG (1, ("bad certificate request message"));
1991       return (POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST);
1992     }
1993
1994 exit:
1995   SSL_DEBUG_MSG (2, ("<= parse certificate request"));
1996
1997   return (0);
1998 }
1999 #endif /* !POLARSSL_KEY_EXCHANGE_RSA_ENABLED &&
2000           !POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED &&
2001           !POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED &&
2002           !POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED */
2003
2004 static int
2005 ssl_parse_server_hello_done (ssl_context * ssl)
2006 {
2007   int ret;
2008
2009   SSL_DEBUG_MSG (2, ("=> parse server hello done"));
2010
2011   if (ssl->record_read == 0)
2012     {
2013       if ((ret = ssl_read_record (ssl)) != 0)
2014         {
2015           SSL_DEBUG_RET (1, "ssl_read_record", ret);
2016           return (ret);
2017         }
2018
2019       if (ssl->in_msgtype != SSL_MSG_HANDSHAKE)
2020         {
2021           SSL_DEBUG_MSG (1, ("bad server hello done message"));
2022           return (POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE);
2023         }
2024     }
2025   ssl->record_read = 0;
2026
2027   if (ssl->in_hslen != 4 || ssl->in_msg[0] != SSL_HS_SERVER_HELLO_DONE)
2028     {
2029       SSL_DEBUG_MSG (1, ("bad server hello done message"));
2030       return (POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO_DONE);
2031     }
2032
2033   ssl->state++;
2034
2035   SSL_DEBUG_MSG (2, ("<= parse server hello done"));
2036
2037   return (0);
2038 }
2039
2040 static int
2041 ssl_write_client_key_exchange (ssl_context * ssl)
2042 {
2043   int ret;
2044   size_t i, n;
2045   const ssl_ciphersuite_t *ciphersuite_info =
2046     ssl->transform_negotiate->ciphersuite_info;
2047
2048   SSL_DEBUG_MSG (2, ("=> write client key exchange"));
2049
2050 #if defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)
2051   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_RSA)
2052     {
2053       /*
2054        * DHM key exchange -- send G^X mod P
2055        */
2056       n = ssl->handshake->dhm_ctx.len;
2057
2058       ssl->out_msg[4] = (unsigned char) (n >> 8);
2059       ssl->out_msg[5] = (unsigned char) (n);
2060       i = 6;
2061
2062       ret = dhm_make_public (&ssl->handshake->dhm_ctx,
2063                              (int) mpi_size (&ssl->handshake->dhm_ctx.P),
2064                              &ssl->out_msg[i], n, ssl->f_rng, ssl->p_rng);
2065       if (ret != 0)
2066         {
2067           SSL_DEBUG_RET (1, "dhm_make_public", ret);
2068           return (ret);
2069         }
2070
2071       SSL_DEBUG_MPI (3, "DHM: X ", &ssl->handshake->dhm_ctx.X);
2072       SSL_DEBUG_MPI (3, "DHM: GX", &ssl->handshake->dhm_ctx.GX);
2073
2074       ssl->handshake->pmslen = POLARSSL_PREMASTER_SIZE;
2075
2076       if ((ret = dhm_calc_secret (&ssl->handshake->dhm_ctx,
2077                                   ssl->handshake->premaster,
2078                                   &ssl->handshake->pmslen,
2079                                   ssl->f_rng, ssl->p_rng)) != 0)
2080         {
2081           SSL_DEBUG_RET (1, "dhm_calc_secret", ret);
2082           return (ret);
2083         }
2084
2085       SSL_DEBUG_MPI (3, "DHM: K ", &ssl->handshake->dhm_ctx.K);
2086     }
2087   else
2088 #endif /* POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED */
2089 #if defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) || \
2090   defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) || \
2091   defined(POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED) ||    \
2092   defined(POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED)
2093   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_RSA ||
2094         ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA
2095         || ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_RSA
2096         || ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDH_ECDSA)
2097     {
2098       /*
2099        * ECDH key exchange -- send client public value
2100        */
2101       i = 4;
2102
2103       ret = ecdh_make_public (&ssl->handshake->ecdh_ctx,
2104                               &n,
2105                               &ssl->out_msg[i], 1000, ssl->f_rng, ssl->p_rng);
2106       if (ret != 0)
2107         {
2108           SSL_DEBUG_RET (1, "ecdh_make_public", ret);
2109           return (ret);
2110         }
2111
2112       SSL_DEBUG_ECP (3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q);
2113
2114       if ((ret = ecdh_calc_secret (&ssl->handshake->ecdh_ctx,
2115                                    &ssl->handshake->pmslen,
2116                                    ssl->handshake->premaster,
2117                                    POLARSSL_MPI_MAX_SIZE,
2118                                    ssl->f_rng, ssl->p_rng)) != 0)
2119         {
2120           SSL_DEBUG_RET (1, "ecdh_calc_secret", ret);
2121           return (ret);
2122         }
2123
2124       SSL_DEBUG_MPI (3, "ECDH: z", &ssl->handshake->ecdh_ctx.z);
2125     }
2126   else
2127 #endif /* POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED ||
2128           POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED ||
2129           POLARSSL_KEY_EXCHANGE_ECDH_RSA_ENABLED ||
2130           POLARSSL_KEY_EXCHANGE_ECDH_ECDSA_ENABLED */
2131 #if defined(POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED)
2132   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
2133         ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
2134         ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK ||
2135         ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK)
2136     {
2137       /*
2138        * opaque psk_identity<0..2^16-1>;
2139        */
2140       if (ssl->psk == NULL || ssl->psk_identity == NULL)
2141         return (POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED);
2142
2143       i = 4;
2144       n = ssl->psk_identity_len;
2145       ssl->out_msg[i++] = (unsigned char) (n >> 8);
2146       ssl->out_msg[i++] = (unsigned char) (n);
2147
2148       memcpy (ssl->out_msg + i, ssl->psk_identity, ssl->psk_identity_len);
2149       i += ssl->psk_identity_len;
2150
2151 #if defined(POLARSSL_KEY_EXCHANGE_PSK_ENABLED)
2152       if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK)
2153         {
2154           n = 0;
2155         }
2156       else
2157 #endif
2158 #if defined(POLARSSL_KEY_EXCHANGE_RSA_PSK_ENABLED)
2159       if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK)
2160         {
2161           if ((ret = ssl_write_encrypted_pms (ssl, i, &n, 2)) != 0)
2162             return (ret);
2163         }
2164       else
2165 #endif
2166 #if defined(POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED)
2167       if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK)
2168         {
2169           /*
2170            * ClientDiffieHellmanPublic public (DHM send G^X mod P)
2171            */
2172           n = ssl->handshake->dhm_ctx.len;
2173           ssl->out_msg[i++] = (unsigned char) (n >> 8);
2174           ssl->out_msg[i++] = (unsigned char) (n);
2175
2176           ret = dhm_make_public (&ssl->handshake->dhm_ctx,
2177                                  (int) mpi_size (&ssl->handshake->dhm_ctx.P),
2178                                  &ssl->out_msg[i], n, ssl->f_rng, ssl->p_rng);
2179           if (ret != 0)
2180             {
2181               SSL_DEBUG_RET (1, "dhm_make_public", ret);
2182               return (ret);
2183             }
2184         }
2185       else
2186 #endif /* POLARSSL_KEY_EXCHANGE_DHE_PSK_ENABLED */
2187 #if defined(POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED)
2188       if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK)
2189         {
2190           /*
2191            * ClientECDiffieHellmanPublic public;
2192            */
2193           ret = ecdh_make_public (&ssl->handshake->ecdh_ctx, &n,
2194                                   &ssl->out_msg[i], SSL_MAX_CONTENT_LEN - i,
2195                                   ssl->f_rng, ssl->p_rng);
2196           if (ret != 0)
2197             {
2198               SSL_DEBUG_RET (1, "ecdh_make_public", ret);
2199               return (ret);
2200             }
2201
2202           SSL_DEBUG_ECP (3, "ECDH: Q", &ssl->handshake->ecdh_ctx.Q);
2203         }
2204       else
2205 #endif /* POLARSSL_KEY_EXCHANGE_ECDHE_PSK_ENABLED */
2206         {
2207           SSL_DEBUG_MSG (1, ("should never happen"));
2208           return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
2209         }
2210
2211       if ((ret = ssl_psk_derive_premaster (ssl,
2212                                            ciphersuite_info->key_exchange)) !=
2213           0)
2214         {
2215           SSL_DEBUG_RET (1, "ssl_psk_derive_premaster", ret);
2216           return (ret);
2217         }
2218     }
2219   else
2220 #endif /* POLARSSL_KEY_EXCHANGE__SOME__PSK_ENABLED */
2221 #if defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)
2222   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA)
2223     {
2224       i = 4;
2225       if ((ret = ssl_write_encrypted_pms (ssl, i, &n, 0)) != 0)
2226         return (ret);
2227     }
2228   else
2229 #endif /* POLARSSL_KEY_EXCHANGE_RSA_ENABLED */
2230     {
2231       ((void) ciphersuite_info);
2232       SSL_DEBUG_MSG (1, ("should never happen"));
2233       return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
2234     }
2235
2236   if ((ret = ssl_derive_keys (ssl)) != 0)
2237     {
2238       SSL_DEBUG_RET (1, "ssl_derive_keys", ret);
2239       return (ret);
2240     }
2241
2242   ssl->out_msglen = i + n;
2243   ssl->out_msgtype = SSL_MSG_HANDSHAKE;
2244   ssl->out_msg[0] = SSL_HS_CLIENT_KEY_EXCHANGE;
2245
2246   ssl->state++;
2247
2248   if ((ret = ssl_write_record (ssl)) != 0)
2249     {
2250       SSL_DEBUG_RET (1, "ssl_write_record", ret);
2251       return (ret);
2252     }
2253
2254   SSL_DEBUG_MSG (2, ("<= write client key exchange"));
2255
2256   return (0);
2257 }
2258
2259 #if !defined(POLARSSL_KEY_EXCHANGE_RSA_ENABLED)       &&        \
2260   !defined(POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED)   &&          \
2261   !defined(POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED) &&          \
2262   !defined(POLARSSL_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED)
2263 static int
2264 ssl_write_certificate_verify (ssl_context * ssl)
2265 {
2266   const ssl_ciphersuite_t *ciphersuite_info =
2267     ssl->transform_negotiate->ciphersuite_info;
2268
2269   SSL_DEBUG_MSG (2, ("=> write certificate verify"));
2270
2271   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
2272       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
2273       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
2274       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK)
2275     {
2276       SSL_DEBUG_MSG (2, ("<= skip write certificate verify"));
2277       ssl->state++;
2278       return (0);
2279     }
2280
2281   SSL_DEBUG_MSG (1, ("should never happen"));
2282   return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
2283 }
2284 #else
2285 static int
2286 ssl_write_certificate_verify (ssl_context * ssl)
2287 {
2288   int ret = POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE;
2289   const ssl_ciphersuite_t *ciphersuite_info =
2290     ssl->transform_negotiate->ciphersuite_info;
2291   size_t n = 0, offset = 0;
2292   unsigned char hash[48];
2293   unsigned char *hash_start = hash;
2294   md_type_t md_alg = POLARSSL_MD_NONE;
2295   unsigned int hashlen;
2296
2297   SSL_DEBUG_MSG (2, ("=> write certificate verify"));
2298
2299   if (ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_PSK ||
2300       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_RSA_PSK ||
2301       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_ECDHE_PSK ||
2302       ciphersuite_info->key_exchange == POLARSSL_KEY_EXCHANGE_DHE_PSK)
2303     {
2304       SSL_DEBUG_MSG (2, ("<= skip write certificate verify"));
2305       ssl->state++;
2306       return (0);
2307     }
2308
2309   if (ssl->client_auth == 0 || ssl_own_cert (ssl) == NULL)
2310     {
2311       SSL_DEBUG_MSG (2, ("<= skip write certificate verify"));
2312       ssl->state++;
2313       return (0);
2314     }
2315
2316   if (ssl_own_key (ssl) == NULL)
2317     {
2318       SSL_DEBUG_MSG (1, ("got no private key"));
2319       return (POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED);
2320     }
2321
2322   /*
2323    * Make an RSA signature of the handshake digests
2324    */
2325   ssl->handshake->calc_verify (ssl, hash);
2326
2327 #if defined(POLARSSL_SSL_PROTO_SSL3) || defined(POLARSSL_SSL_PROTO_TLS1) || \
2328   defined(POLARSSL_SSL_PROTO_TLS1_1)
2329   if (ssl->minor_ver != SSL_MINOR_VERSION_3)
2330     {
2331       /*
2332        * digitally-signed struct {
2333        *     opaque md5_hash[16];
2334        *     opaque sha_hash[20];
2335        * };
2336        *
2337        * md5_hash
2338        *     MD5(handshake_messages);
2339        *
2340        * sha_hash
2341        *     SHA(handshake_messages);
2342        */
2343       hashlen = 36;
2344       md_alg = POLARSSL_MD_NONE;
2345
2346       /*
2347        * For ECDSA, default hash is SHA-1 only
2348        */
2349       if (pk_can_do (ssl_own_key (ssl), POLARSSL_PK_ECDSA))
2350         {
2351           hash_start += 16;
2352           hashlen -= 16;
2353           md_alg = POLARSSL_MD_SHA1;
2354         }
2355     }
2356   else
2357 #endif /* POLARSSL_SSL_PROTO_SSL3 || POLARSSL_SSL_PROTO_TLS1 || \
2358           POLARSSL_SSL_PROTO_TLS1_1 */
2359 #if defined(POLARSSL_SSL_PROTO_TLS1_2)
2360   if (ssl->minor_ver == SSL_MINOR_VERSION_3)
2361     {
2362       /*
2363        * digitally-signed struct {
2364        *     opaque handshake_messages[handshake_messages_length];
2365        * };
2366        *
2367        * Taking shortcut here. We assume that the server always allows the
2368        * PRF Hash function and has sent it in the allowed signature
2369        * algorithms list received in the Certificate Request message.
2370        *
2371        * Until we encounter a server that does not, we will take this
2372        * shortcut.
2373        *
2374        * Reason: Otherwise we should have running hashes for SHA512 and SHA224
2375        *         in order to satisfy 'weird' needs from the server side.
2376        */
2377       if (ssl->transform_negotiate->ciphersuite_info->mac ==
2378           POLARSSL_MD_SHA384)
2379         {
2380           md_alg = POLARSSL_MD_SHA384;
2381           ssl->out_msg[4] = SSL_HASH_SHA384;
2382         }
2383       else
2384         {
2385           md_alg = POLARSSL_MD_SHA256;
2386           ssl->out_msg[4] = SSL_HASH_SHA256;
2387         }
2388       ssl->out_msg[5] = ssl_sig_from_pk (ssl_own_key (ssl));
2389
2390       /* Info from md_alg will be used instead */
2391       hashlen = 0;
2392       offset = 2;
2393     }
2394   else
2395 #endif /* POLARSSL_SSL_PROTO_TLS1_2 */
2396     {
2397       SSL_DEBUG_MSG (1, ("should never happen"));
2398       return (POLARSSL_ERR_SSL_INTERNAL_ERROR);
2399     }
2400
2401   if ((ret = pk_sign (ssl_own_key (ssl), md_alg, hash_start, hashlen,
2402                       ssl->out_msg + 6 + offset, &n,
2403                       ssl->f_rng, ssl->p_rng)) != 0)
2404     {
2405       SSL_DEBUG_RET (1, "pk_sign", ret);
2406       return (ret);
2407     }
2408
2409   ssl->out_msg[4 + offset] = (unsigned char) (n >> 8);
2410   ssl->out_msg[5 + offset] = (unsigned char) (n);
2411
2412   ssl->out_msglen = 6 + n + offset;
2413   ssl->out_msgtype = SSL_MSG_HANDSHAKE;
2414   ssl->out_msg[0] = SSL_HS_CERTIFICATE_VERIFY;
2415
2416   ssl->state++;
2417
2418   if ((ret = ssl_write_record (ssl)) != 0)
2419     {
2420       SSL_DEBUG_RET (1, "ssl_write_record", ret);
2421       return (ret);
2422     }
2423
2424   SSL_DEBUG_MSG (2, ("<= write certificate verify"));
2425
2426   return (ret);
2427 }
2428 #endif /* !POLARSSL_KEY_EXCHANGE_RSA_ENABLED &&
2429           !POLARSSL_KEY_EXCHANGE_DHE_RSA_ENABLED &&
2430           !POLARSSL_KEY_EXCHANGE_ECDHE_RSA_ENABLED */
2431
2432 #if defined(POLARSSL_SSL_SESSION_TICKETS)
2433 static int
2434 ssl_parse_new_session_ticket (ssl_context * ssl)
2435 {
2436   int ret;
2437   uint32_t lifetime;
2438   size_t ticket_len;
2439   unsigned char *ticket;
2440
2441   SSL_DEBUG_MSG (2, ("=> parse new session ticket"));
2442
2443   if ((ret = ssl_read_record (ssl)) != 0)
2444     {
2445       SSL_DEBUG_RET (1, "ssl_read_record", ret);
2446       return (ret);
2447     }
2448
2449   if (ssl->in_msgtype != SSL_MSG_HANDSHAKE)
2450     {
2451       SSL_DEBUG_MSG (1, ("bad new session ticket message"));
2452       return (POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE);
2453     }
2454
2455   /*
2456    * struct {
2457    *     uint32 ticket_lifetime_hint;
2458    *     opaque ticket<0..2^16-1>;
2459    * } NewSessionTicket;
2460    *
2461    * 0  .  0   handshake message type
2462    * 1  .  3   handshake message length
2463    * 4  .  7   ticket_lifetime_hint
2464    * 8  .  9   ticket_len (n)
2465    * 10 .  9+n ticket content
2466    */
2467   if (ssl->in_msg[0] != SSL_HS_NEW_SESSION_TICKET || ssl->in_hslen < 10)
2468     {
2469       SSL_DEBUG_MSG (1, ("bad new session ticket message"));
2470       return (POLARSSL_ERR_SSL_BAD_HS_NEW_SESSION_TICKET);
2471     }
2472
2473   lifetime = (ssl->in_msg[4] << 24) | (ssl->in_msg[5] << 16) |
2474     (ssl->in_msg[6] << 8) | (ssl->in_msg[7]);
2475
2476   ticket_len = (ssl->in_msg[8] << 8) | (ssl->in_msg[9]);
2477
2478   if (ticket_len + 10 != ssl->in_hslen)
2479     {
2480       SSL_DEBUG_MSG (1, ("bad new session ticket message"));
2481       return (POLARSSL_ERR_SSL_BAD_HS_NEW_SESSION_TICKET);
2482     }
2483
2484   SSL_DEBUG_MSG (3, ("ticket length: %d", ticket_len));
2485
2486   /* We're not waiting for a NewSessionTicket message any more */
2487   ssl->handshake->new_session_ticket = 0;
2488
2489   /*
2490    * Zero-length ticket means the server changed his mind and doesn't want
2491    * to send a ticket after all, so just forget it
2492    */
2493   if (ticket_len == 0)
2494     return (0);
2495
2496   polarssl_zeroize (ssl->session_negotiate->ticket,
2497                     ssl->session_negotiate->ticket_len);
2498   polarssl_free (ssl->session_negotiate->ticket);
2499   ssl->session_negotiate->ticket = NULL;
2500   ssl->session_negotiate->ticket_len = 0;
2501
2502   if ((ticket = polarssl_malloc (ticket_len)) == NULL)
2503     {
2504       SSL_DEBUG_MSG (1, ("ticket malloc failed"));
2505       return (POLARSSL_ERR_SSL_MALLOC_FAILED);
2506     }
2507
2508   memcpy (ticket, ssl->in_msg + 10, ticket_len);
2509
2510   ssl->session_negotiate->ticket = ticket;
2511   ssl->session_negotiate->ticket_len = ticket_len;
2512   ssl->session_negotiate->ticket_lifetime = lifetime;
2513
2514   /*
2515    * RFC 5077 section 3.4:
2516    * "If the client receives a session ticket from the server, then it
2517    * discards any Session ID that was sent in the ServerHello."
2518    */
2519   SSL_DEBUG_MSG (3, ("ticket in use, discarding session id"));
2520   ssl->session_negotiate->length = 0;
2521
2522   SSL_DEBUG_MSG (2, ("<= parse new session ticket"));
2523
2524   return (0);
2525 }
2526 #endif /* POLARSSL_SSL_SESSION_TICKETS */
2527
2528   /*
2529    * SSL handshake -- client side -- single step
2530    */
2531 int
2532 ssl_handshake_client_step (ssl_context * ssl)
2533 {
2534   int ret = 0;
2535
2536   if (ssl->state == SSL_HANDSHAKE_OVER)
2537     return (POLARSSL_ERR_SSL_BAD_INPUT_DATA);
2538
2539   SSL_DEBUG_MSG (2, ("client state: %d", ssl->state));
2540
2541   if ((ret = ssl_flush_output (ssl)) != 0)
2542     return (ret);
2543
2544   switch (ssl->state)
2545     {
2546     case SSL_HELLO_REQUEST:
2547       ssl->state = SSL_CLIENT_HELLO;
2548       break;
2549
2550       /*
2551        *  ==>   ClientHello
2552        */
2553     case SSL_CLIENT_HELLO:
2554       ret = ssl_write_client_hello (ssl);
2555       break;
2556
2557       /*
2558        *  <==   ServerHello
2559        *        Certificate
2560        *      ( ServerKeyExchange  )
2561        *      ( CertificateRequest )
2562        *        ServerHelloDone
2563        */
2564     case SSL_SERVER_HELLO:
2565       ret = ssl_parse_server_hello (ssl);
2566       break;
2567
2568     case SSL_SERVER_CERTIFICATE:
2569       ret = ssl_parse_certificate (ssl);
2570       break;
2571
2572     case SSL_SERVER_KEY_EXCHANGE:
2573       ret = ssl_parse_server_key_exchange (ssl);
2574       break;
2575
2576     case SSL_CERTIFICATE_REQUEST:
2577       ret = ssl_parse_certificate_request (ssl);
2578       break;
2579
2580     case SSL_SERVER_HELLO_DONE:
2581       ret = ssl_parse_server_hello_done (ssl);
2582       break;
2583
2584       /*
2585        *  ==> ( Certificate/Alert  )
2586        *        ClientKeyExchange
2587        *      ( CertificateVerify  )
2588        *        ChangeCipherSpec
2589        *        Finished
2590        */
2591     case SSL_CLIENT_CERTIFICATE:
2592       ret = ssl_write_certificate (ssl);
2593       break;
2594
2595     case SSL_CLIENT_KEY_EXCHANGE:
2596       ret = ssl_write_client_key_exchange (ssl);
2597       break;
2598
2599     case SSL_CERTIFICATE_VERIFY:
2600       ret = ssl_write_certificate_verify (ssl);
2601       break;
2602
2603     case SSL_CLIENT_CHANGE_CIPHER_SPEC:
2604       ret = ssl_write_change_cipher_spec (ssl);
2605       break;
2606
2607     case SSL_CLIENT_FINISHED:
2608       ret = ssl_write_finished (ssl);
2609       break;
2610
2611       /*
2612        *  <==   ( NewSessionTicket )
2613        *        ChangeCipherSpec
2614        *        Finished
2615        */
2616     case SSL_SERVER_CHANGE_CIPHER_SPEC:
2617 #if defined(POLARSSL_SSL_SESSION_TICKETS)
2618       if (ssl->handshake->new_session_ticket != 0)
2619         ret = ssl_parse_new_session_ticket (ssl);
2620       else
2621 #endif
2622         ret = ssl_parse_change_cipher_spec (ssl);
2623       break;
2624
2625     case SSL_SERVER_FINISHED:
2626       ret = ssl_parse_finished (ssl);
2627       break;
2628
2629     case SSL_FLUSH_BUFFERS:
2630       SSL_DEBUG_MSG (2, ("handshake: done"));
2631       ssl->state = SSL_HANDSHAKE_WRAPUP;
2632       break;
2633
2634     case SSL_HANDSHAKE_WRAPUP:
2635       ssl_handshake_wrapup (ssl);
2636       break;
2637
2638     default:
2639       SSL_DEBUG_MSG (1, ("invalid state %d", ssl->state));
2640       return (POLARSSL_ERR_SSL_BAD_INPUT_DATA);
2641     }
2642
2643   return (ret);
2644 }
2645 #endif /* POLARSSL_SSL_CLI_C */