More changes - first successful handshake.
[ntbtls.git] / src / protocol.c
1 /* protocol.c - TLS 1.2 protocol implementation
2  * Copyright (C) 2006-2014, Brainspark B.V.
3  * Copyright (C) 2014 g10 code GmbH
4  *
5  * This file is part of NTBTLS
6  *
7  * NTBTLS is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * NTBTLS is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  *
20  * This file was part of PolarSSL (http://www.polarssl.org).  Former
21  * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>.
22  * Please do not file bug reports to them but to the address given in
23  * the file AUTHORS in the top directory of NTBTLS.
24  */
25
26 #include <config.h>
27 #include <stdlib.h>
28
29 #include "ntbtls-int.h"
30 #include "ciphersuites.h"
31
32
33
34 static void transform_deinit (transform_t transform);
35 static void session_deinit (session_t session);
36 static void handshake_params_deinit (handshake_params_t handshake);
37 static void ticket_keys_deinit (ticket_keys_t tkeys);
38
39 static void update_checksum_sha256 (ntbtls_t, const unsigned char *, size_t);
40 static void calc_verify_tls_sha256 (ntbtls_t, unsigned char *);
41 static void calc_finished_tls_sha256 (ntbtls_t, unsigned char *, int);
42 static void calc_verify_tls_sha384 (ntbtls_t, unsigned char *);
43 static void calc_finished_tls_sha384 (ntbtls_t, unsigned char *, int);
44
45
46
47
48 /*
49  * Convert max_fragment_length codes to length.
50  * RFC 6066 says:
51  *    enum{
52  *        2^9(1), 2^10(2), 2^11(3), 2^12(4), (255)
53  *    } MaxFragmentLength;
54  * and we add 0 -> extension unused
55  */
56 static unsigned int mfl_code_to_length[] =
57   {
58     TLS_MAX_CONTENT_LEN,          /* TLS_MAX_FRAG_LEN_NONE */
59     512,                          /* TLS_MAX_FRAG_LEN_512  */
60     1024,                         /* TLS_MAX_FRAG_LEN_1024 */
61     2048,                         /* TLS_MAX_FRAG_LEN_2048 */
62     4096                          /* TLS_MAX_FRAG_LEN_4096 */
63   };
64
65
66 static gpg_error_t
67 session_copy (session_t dst, const session_t src)
68 {
69   session_deinit (dst);
70   memcpy (dst, src, sizeof *src);
71
72   if (src->peer_chain)
73     {
74       /* int ret; */
75
76       //FIXME: Use libksba
77       /* dst->peer_cert = malloc (sizeof *dst->peer_cert); */
78       /* if (!dst->peer_cert) */
79       /*   return gpg_error_from_syserror (); */
80
81       /* x509_crt_init (dst->peer_cert); */
82
83       /* if ((ret = x509_crt_parse_der (dst->peer_cert, src->peer_cert->raw.p, */
84       /*                                src->peer_cert->raw.len)) != 0) */
85       /*   { */
86       /*     free (dst->peer_cert); */
87       /*     dst->peer_cert = NULL; */
88       /*     return (ret); */
89       /*   } */
90     }
91
92   if (src->ticket)
93     {
94       dst->ticket = malloc (src->ticket_len);
95       if (!dst->ticket)
96         return gpg_error_from_syserror ();
97
98       memcpy (dst->ticket, src->ticket, src->ticket_len);
99     }
100
101   return 0;
102 }
103
104
105 /*
106  * output = HMAC-SHA-NNN( hmac key, input buffer )
107  *
108  * The used algorithm depends on OUTPUTSIZE which is expected in bytes.
109  */
110 static gpg_error_t
111 sha_hmac (const unsigned char *key, size_t keylen,
112           const unsigned char *input, size_t inputlen,
113           unsigned char *output, int outputsize)
114 {
115   gpg_error_t err;
116   gcry_mac_hd_t hd;
117   size_t macoutlen;
118   int algo;
119
120   switch (outputsize)
121     {
122     case 32: algo = GCRY_MAC_HMAC_SHA256; break;
123     case 48: algo = GCRY_MAC_HMAC_SHA384; break;
124     case 64: algo = GCRY_MAC_HMAC_SHA512; break;
125     default: return gpg_error (GPG_ERR_MAC_ALGO);
126     }
127
128   err = gcry_mac_open (&hd, algo, 0, NULL);
129   if (!err)
130     {
131       err = gcry_mac_setkey (hd, key, keylen);
132       if (!err)
133         {
134           err = gcry_mac_write (hd, input, inputlen);
135           if (!err)
136             {
137               macoutlen = outputsize;
138               err = gcry_mac_read (hd, output, &macoutlen);
139             }
140         }
141       gcry_mac_close (hd);
142     }
143   return err;
144 }
145
146
147 /*
148  * Key material generation
149  */
150
151 static gpg_error_t
152 do_tls_prf (const unsigned char *secret, size_t slen,
153             const char *label,
154             const unsigned char *random, size_t rlen,
155             unsigned char *dstbuf, size_t dlen,
156             size_t hashlen)
157 {
158   gpg_error_t err;
159   size_t nb;
160   size_t i, j, k;
161   unsigned char tmp[128];
162   unsigned char h_i[64];
163
164   if (sizeof (tmp) < hashlen + strlen (label) + rlen)
165     return gpg_error (GPG_ERR_INV_ARG);
166
167   nb = strlen (label);
168   memcpy (tmp + hashlen, label, nb);
169   memcpy (tmp + hashlen + nb, random, rlen);
170   nb += rlen;
171
172   /*
173    * Compute P_<hash>(secret, label + random)[0..dlen]
174    */
175   err = sha_hmac (secret, slen, tmp + hashlen, nb, tmp, hashlen);
176   if (err)
177     return err;
178
179   for (i = 0; i < dlen; i += hashlen)
180     {
181       err = sha_hmac (secret, slen, tmp, hashlen + nb, h_i, hashlen);
182       if (err)
183         return err;
184       err = sha_hmac (secret, slen, tmp, hashlen, tmp, hashlen);
185       if (err)
186         return err;
187
188       k = (i + hashlen > dlen) ? dlen % hashlen : hashlen;
189
190       for (j = 0; j < k; j++)
191         dstbuf[i + j] = h_i[j];
192     }
193
194   wipememory (tmp, sizeof (tmp));
195   wipememory (h_i, hashlen);
196
197   return 0;
198 }
199
200
201 static gpg_error_t
202 tls_prf_sha256 (const unsigned char *secret, size_t slen,
203                 const char *label,
204                 const unsigned char *random, size_t rlen,
205                 unsigned char *dstbuf, size_t dlen)
206 {
207   return do_tls_prf (secret, slen, label, random, rlen, dstbuf, dlen, 32);
208 }
209
210
211 static gpg_error_t
212 tls_prf_sha384 (const unsigned char *secret, size_t slen,
213                 const char *label,
214                 const unsigned char *random, size_t rlen,
215                 unsigned char *dstbuf, size_t dlen)
216 {
217   return do_tls_prf (secret, slen, label, random, rlen, dstbuf, dlen, 48);
218 }
219
220
221 gpg_error_t
222 _ntbtls_derive_keys (ntbtls_t tls)
223 {
224   gpg_error_t err;
225   unsigned char tmp[64];
226   unsigned char keyblk[256];
227   unsigned char *key1;
228   unsigned char *key2;
229   unsigned char *mac_enc;
230   unsigned char *mac_dec;
231   size_t iv_copy_len;
232   cipher_algo_t cipher;
233   cipher_mode_t ciphermode;
234   mac_algo_t mac;
235   session_t session = tls->session_negotiate;
236   transform_t transform = tls->transform_negotiate;
237   handshake_params_t handshake = tls->handshake;
238
239   debug_msg (2, "=> derive keys");
240
241   if (tls->minor_ver != TLS_MINOR_VERSION_3)
242     {
243       debug_bug ();
244       return gpg_error (GPG_ERR_INTERNAL);
245     }
246
247   cipher = _ntbtls_ciphersuite_get_cipher (transform->ciphersuite,
248                                            &ciphermode);
249   if (!cipher || !ciphermode)
250     {
251       debug_msg (1, "cipher algo not found");
252       return gpg_error (GPG_ERR_INV_ARG);
253     }
254
255   mac = _ntbtls_ciphersuite_get_mac (transform->ciphersuite);
256   if (!mac)
257     {
258       debug_msg (1, "mac algo not found");
259       return gpg_error (GPG_ERR_INV_ARG);
260     }
261
262   /*
263    * Set appropriate PRF function and other TLS functions
264    */
265   if (mac == GCRY_MAC_HMAC_SHA384)
266     {
267       handshake->tls_prf = tls_prf_sha384;
268       handshake->calc_verify = calc_verify_tls_sha384;
269       handshake->calc_finished = calc_finished_tls_sha384;
270     }
271   else
272     {
273       handshake->tls_prf = tls_prf_sha256;
274       handshake->calc_verify = calc_verify_tls_sha256;
275       handshake->calc_finished = calc_finished_tls_sha256;
276     }
277
278   /*
279    * TLSv1+:
280    *   master = PRF( premaster, "master secret", randbytes )[0..47]
281    */
282   if (!handshake->resume)
283     {
284       debug_buf (3, "premaster secret",
285                  handshake->premaster, handshake->pmslen);
286
287       handshake->tls_prf (handshake->premaster, handshake->pmslen,
288                           "master secret",
289                           handshake->randbytes, 64, session->master, 48);
290
291       wipememory (handshake->premaster, sizeof (handshake->premaster));
292     }
293   else
294     debug_msg (3, "no premaster (session resumed)");
295
296   /*
297    * Swap the client and server random values.
298    */
299   memcpy (tmp, handshake->randbytes, 64);
300   memcpy (handshake->randbytes, tmp + 32, 32);
301   memcpy (handshake->randbytes + 32, tmp, 32);
302   wipememory (tmp, sizeof (tmp));
303
304   /*
305    *  TLSv1:
306    *    key block = PRF( master, "key expansion", randbytes )
307    */
308   handshake->tls_prf (session->master, 48,
309                       "key expansion",
310                       handshake->randbytes, 64, keyblk, 256);
311
312   debug_msg (3, "ciphersuite = %s",
313              _ntbtls_ciphersuite_get_name (session->ciphersuite));
314   debug_buf (3, "master secret", session->master, 48);
315   debug_buf (4, "random bytes", handshake->randbytes, 64);
316   debug_buf (4, "key block", keyblk, 256);
317
318   wipememory (handshake->randbytes, sizeof (handshake->randbytes));
319
320   /*
321    * Determine the appropriate key, IV and MAC length.
322    */
323
324   transform->keylen = gcry_cipher_get_algo_keylen (cipher);
325   /* FIXME: Check that KEYLEN has an upper bound.  */
326
327   if (ciphermode == GCRY_CIPHER_MODE_GCM || ciphermode == GCRY_CIPHER_MODE_CCM)
328     {
329       transform->maclen = 0;
330
331       transform->ivlen = 12;
332       transform->fixed_ivlen = 4;
333
334       /* Minimum length is expicit IV + tag */
335       transform->minlen =
336         (transform->ivlen
337          - transform->fixed_ivlen
338          + ((_ntbtls_ciphersuite_get_flags (transform->ciphersuite)
339              & CIPHERSUITE_FLAG_SHORT_TAG)? 8 : 16));
340     }
341   else
342     {
343       size_t blklen = gcry_cipher_get_algo_blklen (cipher);
344
345       /* Initialize HMAC contexts */
346       /* Fixme: Check whether the context may really be open.  */
347       gcry_mac_close (transform->mac_ctx_enc);
348       err = gcry_mac_open (&transform->mac_ctx_enc, mac, 0, NULL);
349       if (!err)
350         {
351           gcry_mac_close (transform->mac_ctx_dec);
352           err = gcry_mac_open (&transform->mac_ctx_dec, mac, 0, NULL);
353         }
354       if (err)
355         {
356           debug_ret (1, "gcry_mac_open", err);
357           return err;
358         }
359
360       /* Get MAC length */
361       transform->maclen = gcry_mac_get_algo_maclen (mac);
362       if (transform->maclen < TLS_TRUNCATED_HMAC_LEN)
363         {
364           debug_bug ();
365           return gpg_error (GPG_ERR_BUG);
366         }
367
368       /*
369        * If HMAC is to be truncated, we shall keep the leftmost bytes,
370        * (rfc 6066 page 13 or rfc 2104 section 4),
371        * so we only need to adjust the length here.
372        */
373       if (session->use_trunc_hmac)
374         transform->maclen = TLS_TRUNCATED_HMAC_LEN;
375
376       /* IV length.  According to RFC-5246, Appendix C, we shall use
377          the block length of the IV length.  */
378       transform->ivlen = blklen;
379
380       /* Minimum length */
381       if (ciphermode == GCRY_CIPHER_MODE_STREAM)
382         transform->minlen = transform->maclen;
383       else
384         {
385           /*
386            * GenericBlockCipher:
387            * First multiple of blocklen greater than maclen
388            * + IV.
389            */
390           transform->minlen = (transform->maclen
391                                + blklen
392                                - (transform->maclen % blklen)
393                                + transform->ivlen);
394         }
395     }
396
397   debug_msg (3, "keylen: %d, minlen: %d, ivlen: %d, maclen: %d",
398              transform->keylen, transform->minlen, transform->ivlen,
399              transform->maclen);
400
401   /*
402    * Finally setup the cipher contexts, IVs and MAC secrets.
403    */
404   if (tls->is_client)
405     {
406       key1 = keyblk + transform->maclen * 2;
407       key2 = keyblk + transform->maclen * 2 + transform->keylen;
408
409       mac_enc = keyblk;
410       mac_dec = keyblk + transform->maclen;
411
412       /*
413        * This is not used in TLS v1.1.  FIXME: Check and remove.
414        */
415       iv_copy_len = (transform->fixed_ivlen ?
416                      transform->fixed_ivlen : transform->ivlen);
417       memcpy (transform->iv_enc, key2 + transform->keylen, iv_copy_len);
418       memcpy (transform->iv_dec, key2 + transform->keylen + iv_copy_len,
419               iv_copy_len);
420     }
421   else
422     {
423       key1 = keyblk + transform->maclen * 2 + transform->keylen;
424       key2 = keyblk + transform->maclen * 2;
425
426       mac_enc = keyblk + transform->maclen;
427       mac_dec = keyblk;
428
429       /*
430        * This is not used in TLS v1.1.  FIXME: Check and remove
431        */
432       iv_copy_len = (transform->fixed_ivlen ?
433                      transform->fixed_ivlen : transform->ivlen);
434       memcpy (transform->iv_dec, key1 + transform->keylen, iv_copy_len);
435       memcpy (transform->iv_enc, key1 + transform->keylen + iv_copy_len,
436               iv_copy_len);
437     }
438
439
440   if (ciphermode != GCRY_CIPHER_MODE_GCM && ciphermode != GCRY_CIPHER_MODE_CCM)
441     {
442       err = gcry_mac_setkey (transform->mac_ctx_enc,
443                              mac_enc, transform->maclen);
444       if (!err)
445         err = gcry_mac_setkey (transform->mac_ctx_dec,
446                                mac_dec, transform->maclen);
447       if (err)
448         {
449           debug_ret (1, "gcry_mac_setkey", err);
450           return err;
451         }
452     }
453
454   gcry_cipher_close (transform->cipher_ctx_enc);
455   err = gcry_cipher_open (&transform->cipher_ctx_enc, cipher, ciphermode, 0);
456   if (!err)
457     {
458       gcry_cipher_close (transform->cipher_ctx_dec);
459       err = gcry_cipher_open (&transform->cipher_ctx_dec, cipher, ciphermode,0);
460     }
461   if (err)
462     {
463       debug_ret (1, "gcry_cipher_open", err);
464       return err;
465     }
466   transform->cipher_mode_enc = ciphermode;
467   transform->cipher_mode_dec = ciphermode;
468
469   err = gcry_cipher_setkey (transform->cipher_ctx_enc,
470                             key1, transform->keylen);
471   if (!err)
472     err = gcry_cipher_setkey (transform->cipher_ctx_dec,
473                               key2, transform->keylen);
474   if (err)
475     {
476       debug_ret (1, "cipher_setkey", err);
477       return err;
478     }
479
480   wipememory (keyblk, sizeof (keyblk));
481
482   /* Initialize compression.  */
483   if (session->compression == TLS_COMPRESS_DEFLATE)
484     {
485       /* if (tls->compress_buf == NULL) */
486       /*   { */
487       /*     deboug_msg (3, "Allocating compression buffer"); */
488       /*     ssl->compress_buf = malloc (SSL_BUFFER_LEN); */
489       /*     if (!ssl->compress_buf) */
490       /*       { */
491       /*         err = gpg_error_from_syserror (); */
492       /*         debug_msg (1, "malloc(%d bytes) failed", SSL_BUFFER_LEN); */
493       /*         return err; */
494       /*       } */
495       /*   } */
496
497       /* debug_msg (3, "Initializing zlib states"); */
498
499       /* memset (&transform->ctx_deflate, 0, sizeof (transform->ctx_deflate));*/
500       /* memset (&transform->ctx_inflate, 0, sizeof (transform->ctx_inflate));*/
501
502       /* if (deflateInit (&transform->ctx_deflate, */
503       /*                  Z_DEFAULT_COMPRESSION) != Z_OK || */
504       /*     inflateInit (&transform->ctx_inflate) != Z_OK) */
505         {
506           debug_msg (1, "Failed to initialize compression");
507           return gpg_error (GPG_ERR_COMPR_FAILED);
508         }
509     }
510
511   debug_msg (2, "<= derive keys");
512
513   return 0;
514 }
515
516
517 static void
518 calc_verify_tls (gcry_md_hd_t md_input, md_algo_t md_alg,
519                  unsigned char *hash, size_t hashlen)
520 {
521   gpg_error_t err;
522   gcry_md_hd_t md;
523   char *p;
524
525   debug_msg (2, "=> calc verify tls sha%d", hashlen*8);
526
527   err = gcry_md_copy (&md, md_input);
528   if (err)
529     {
530       debug_ret (1, "calc_verify_tls", err);
531       memset (hash, 0, hashlen);
532       return;
533     }
534   p = gcry_md_read (md, md_alg);
535   if (!p)
536     {
537       debug_bug ();
538       memset (hash, 0, hashlen);
539       gcry_md_close (md);
540       return;
541     }
542   memcpy (hash, p, hashlen);
543   gcry_md_close (md);
544
545   debug_buf (3, "calculated verify result", hash, hashlen);
546   debug_msg (2, "<= calc verify tls sha%d", hashlen*8);
547 }
548
549
550 static void
551 calc_verify_tls_sha256 (ntbtls_t tls, unsigned char hash[32])
552 {
553   calc_verify_tls (tls->handshake->fin_sha256, GCRY_MD_SHA256, hash, 32);
554 }
555
556 static void
557 calc_verify_tls_sha384 (ntbtls_t tls, unsigned char hash[48])
558 {
559   calc_verify_tls (tls->handshake->fin_sha512, GCRY_MD_SHA384, hash, 48);
560 }
561
562
563 gpg_error_t
564 _ntbtls_psk_derive_premaster (ntbtls_t tls, key_exchange_type_t kex)
565 {
566   gpg_error_t err;
567   unsigned char *p = tls->handshake->premaster;
568   unsigned char *end = p + sizeof (tls->handshake->premaster);
569
570   /*
571    * PMS = struct {
572    *     opaque other_secret<0..2^16-1>;
573    *     opaque psk<0..2^16-1>;
574    * };
575    * with "other_secret" depending on the particular key exchange
576    */
577   if (kex == KEY_EXCHANGE_PSK)
578     {
579       if (end - p < 2 + (int) tls->psk_len)
580         return gpg_error (GPG_ERR_INV_ARG);
581
582       *(p++) = (unsigned char) (tls->psk_len >> 8);
583       *(p++) = (unsigned char) (tls->psk_len);
584       p += tls->psk_len;
585     }
586   else if (kex == KEY_EXCHANGE_RSA_PSK)
587     {
588       /*
589        * other_secret already set by the ClientKeyExchange message,
590        * and is 48 bytes long
591        */
592       *p++ = 0;
593       *p++ = 48;
594       p += 48;
595     }
596   else if (kex == KEY_EXCHANGE_DHE_PSK)
597     {
598       size_t len = end - (p + 2);
599
600       /* Write length only when we know the actual value.  */
601       /* err = dhm_calc_secret (&tls->handshake->dhm_ctx, p + 2, &len); */
602       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
603       if (err)
604         {
605           debug_ret (1, "dhm_calc_secret", err);
606           return err;
607         }
608       *(p++) = (unsigned char) (len >> 8);
609       *(p++) = (unsigned char) (len);
610       p += len;
611
612       /* SSL_DEBUG_MPI (3, "DHM: K ", &tls->handshake->dhm_ctx.K); */
613     }
614   else if (kex == KEY_EXCHANGE_ECDHE_PSK)
615     {
616       size_t zlen;
617
618       /* err = ecdh_calc_secret (&tls->handshake->ecdh_ctx, &zlen, */
619       /*                         p + 2, end - (p + 2)); */
620       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
621       if (err)
622         {
623           debug_ret (1, "ecdh_calc_secret", err);
624           return err;
625         }
626
627       *(p++) = (unsigned char) (zlen >> 8);
628       *(p++) = (unsigned char) (zlen);
629       p += zlen;
630
631       /* SSL_DEBUG_MPI (3, "ECDH: z", &tls->handshake->ecdh_ctx.z); */
632     }
633   else
634     {
635       debug_bug ();
636       return gpg_error (GPG_ERR_INTERNAL);
637     }
638
639   /* opaque psk<0..2^16-1>; */
640   if (end - p < 2 + (int) tls->psk_len)
641     return gpg_error (GPG_ERR_INV_ARG);
642
643   *(p++) = (unsigned char) (tls->psk_len >> 8);
644   *(p++) = (unsigned char) (tls->psk_len);
645   memcpy (p, tls->psk, tls->psk_len);
646   p += tls->psk_len;
647
648   tls->handshake->pmslen = p - tls->handshake->premaster;
649
650   return 0;
651 }
652
653
654 /*
655  * Encryption/decryption functions
656  */
657 static gpg_error_t
658 encrypt_buf (ntbtls_t tls)
659 {
660   gpg_error_t err;
661   size_t tmplen, i;
662   cipher_mode_t mode = tls->transform_out->cipher_mode_enc;
663
664   debug_msg (2, "=> encrypt buf");
665
666   if (tls->minor_ver < TLS_MINOR_VERSION_3)
667     {
668       debug_bug ();
669       return gpg_error (GPG_ERR_BUG);
670     }
671
672
673   /*
674    * Add MAC before encrypt, except for AEAD modes
675    */
676   if (mode != GCRY_CIPHER_MODE_GCM && mode != GCRY_CIPHER_MODE_CCM)
677     {
678       /* fixme: Add error checking.  */
679       gcry_mac_write (tls->transform_out->mac_ctx_enc, tls->out_ctr, 13);
680       gcry_mac_write (tls->transform_out->mac_ctx_enc,
681                       tls->out_msg, tls->out_msglen);
682       tmplen = tls->transform_out->maclen;
683       gcry_mac_read (tls->transform_out->mac_ctx_enc,
684                      tls->out_msg + tls->out_msglen, &tmplen);
685       gcry_mac_reset (tls->transform_out->mac_ctx_enc);
686
687       debug_buf (4, "computed mac",
688                  tls->out_msg + tls->out_msglen,
689                  tls->transform_out->maclen);
690
691       tls->out_msglen += tls->transform_out->maclen;
692     }
693
694   /*
695    * Encrypt
696    */
697   if (mode == GCRY_CIPHER_MODE_STREAM)
698     {
699       size_t olen = 0;
700
701       debug_msg (3, "before encrypt: msglen = %d,"
702                  " including %d bytes of padding", tls->out_msglen, 0);
703       debug_buf (4, "before encrypt: output payload",
704                  tls->out_msg, tls->out_msglen);
705
706       /* err = cipher_crypt (&tls->transform_out->cipher_ctx_enc, */
707       /*                     tls->transform_out->iv_enc, */
708       /*                     tls->transform_out->ivlen, */
709       /*                     tls->out_msg, tls->out_msglen, */
710       /*                     tls->out_msg, &olen); */
711       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
712       if (err)
713         {
714           debug_ret (1, "cipher_crypt", err);
715           return err;
716         }
717
718       if (tls->out_msglen != olen)
719         {
720           debug_bug ();
721           return gpg_error (GPG_ERR_INTERNAL);
722         }
723     }
724   else if (mode == GCRY_CIPHER_MODE_GCM || mode == GCRY_CIPHER_MODE_CCM)
725     {
726       size_t enc_msglen, olen;
727       unsigned char *enc_msg;
728       unsigned char add_data[13];
729       unsigned char taglen;
730
731
732       taglen = (_ntbtls_ciphersuite_get_flags (tls->transform_out->ciphersuite)
733                 & CIPHERSUITE_FLAG_SHORT_TAG)? 8 : 16;
734
735       memcpy (add_data, tls->out_ctr, 8);
736       add_data[8] = tls->out_msgtype;
737       add_data[9] = tls->major_ver;
738       add_data[10] = tls->minor_ver;
739       add_data[11] = (tls->out_msglen >> 8) & 0xFF;
740       add_data[12] = tls->out_msglen & 0xFF;
741
742       debug_buf (4, "additional data used for AEAD", add_data, 13);
743
744       /*
745        * Generate IV
746        */
747       gcry_create_nonce (tls->transform_out->iv_enc
748                          + tls->transform_out->fixed_ivlen,
749                          tls->transform_out->ivlen
750                          - tls->transform_out->fixed_ivlen);
751
752       memcpy (tls->out_iv,
753               tls->transform_out->iv_enc + tls->transform_out->fixed_ivlen,
754               tls->transform_out->ivlen - tls->transform_out->fixed_ivlen);
755
756       debug_buf (4, "IV used", tls->out_iv,
757                  tls->transform_out->ivlen - tls->transform_out->fixed_ivlen);
758
759       /*
760        * Fix pointer positions and message length with added IV
761        */
762       enc_msg = tls->out_msg;
763       enc_msglen = tls->out_msglen;
764       tls->out_msglen += (tls->transform_out->ivlen
765                           - tls->transform_out->fixed_ivlen);
766
767       debug_msg (3, "before encrypt: msglen = %d, "
768                  "including %d bytes of padding", tls->out_msglen, 0);
769       debug_buf (4, "before encrypt: output payload",
770                  tls->out_msg, tls->out_msglen);
771
772       /*
773        * Encrypt and authenticate
774        */
775       /* err = cipher_auth_encrypt (&tls->transform_out->cipher_ctx_enc, */
776       /*                            tls->transform_out->iv_enc, */
777       /*                            tls->transform_out->ivlen, */
778       /*                            add_data, 13, */
779       /*                            enc_msg, enc_msglen, */
780       /*                            enc_msg, &olen, */
781       /*                            enc_msg + enc_msglen, taglen); */
782       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
783       if (err)
784         {
785           debug_ret (1, "cipher_auth_encrypt", err);
786           return err;
787         }
788
789       if (olen != enc_msglen)
790         {
791           debug_bug ();
792           return gpg_error (GPG_ERR_BUG);
793         }
794
795       tls->out_msglen += taglen;
796
797       debug_buf (4, "after encrypt: tag", enc_msg + enc_msglen, taglen);
798     }
799   else if (mode == GCRY_CIPHER_MODE_CBC)
800     {
801       unsigned char *enc_msg;
802       size_t enc_msglen, padlen;
803
804       padlen = (tls->transform_out->ivlen
805                 - ((tls->out_msglen + 1) % tls->transform_out->ivlen));
806       if (padlen == tls->transform_out->ivlen)
807         padlen = 0;
808
809       for (i = 0; i <= padlen; i++)
810         tls->out_msg[tls->out_msglen + i] = (unsigned char) padlen;
811
812       tls->out_msglen += padlen + 1;
813
814       enc_msglen = tls->out_msglen;
815       enc_msg = tls->out_msg;
816
817       /*
818        * Prepend per-record IV for block cipher in TLS v1.1 and up as per
819        * Method 1 (RFC-5246, 6.2.3.2)
820        */
821
822       /* Generate IV.  */
823       gcry_create_nonce (tls->transform_out->iv_enc, tls->transform_out->ivlen);
824
825       memcpy (tls->out_iv, tls->transform_out->iv_enc,
826               tls->transform_out->ivlen);
827
828       /* Fix pointer positions and message length with added IV.  */
829       enc_msg = tls->out_msg;
830       enc_msglen = tls->out_msglen;
831       tls->out_msglen += tls->transform_out->ivlen;
832
833       debug_msg (3, "before encrypt: msglen = %d, "
834                  "including %d bytes of IV and %d bytes of padding",
835                  tls->out_msglen, tls->transform_out->ivlen, padlen + 1);
836       debug_buf (4, "before encrypt: output payload",
837                  tls->out_iv, tls->out_msglen);
838
839       err = gcry_cipher_reset (tls->transform_out->cipher_ctx_enc);
840       if (err)
841         {
842           debug_ret (1, "cipher_reset", err);
843           return err;
844         }
845       err = gcry_cipher_setiv (tls->transform_out->cipher_ctx_enc,
846                                tls->transform_out->iv_enc,
847                                tls->transform_out->ivlen);
848       if (err)
849         {
850           debug_ret (1, "cipher_setiv", err);
851           return err;
852         }
853
854       err = gcry_cipher_encrypt (tls->transform_out->cipher_ctx_enc,
855                                  enc_msg, enc_msglen, NULL, 0);
856       if (err)
857         {
858           debug_ret (1, "cipher_encrypt", err);
859           return err;
860         }
861     }
862   else
863     {
864       debug_bug ();
865       return gpg_error (GPG_ERR_INTERNAL);
866     }
867
868   for (i = 8; i > 0; i--)
869     if (++tls->out_ctr[i - 1] != 0)
870       break;
871
872   /* The loops goes to its end iff the counter is wrapping */
873   if (!i)
874     {
875       debug_msg (1, "outgoing message counter would wrap");
876       return gpg_error (GPG_ERR_WOULD_WRAP);
877     }
878
879   debug_msg (2, "<= encrypt buf");
880
881   return 0;
882 }
883
884
885 static int
886 decrypt_buf (ntbtls_t tls)
887 {
888   gpg_error_t err;
889   cipher_mode_t mode = tls->transform_out->cipher_mode_dec;
890   size_t padlen = 0;
891   size_t correct = 1;
892   size_t tmplen, i;
893
894   debug_msg (2, "=> decrypt buf");
895
896   if (tls->minor_ver < TLS_MINOR_VERSION_3)
897     {
898       debug_bug ();
899       return gpg_error (GPG_ERR_BUG);
900     }
901
902   if (tls->in_msglen < tls->transform_in->minlen)
903     {
904       debug_msg (1, "in_msglen (%d) < minlen (%d)",
905                  tls->in_msglen, tls->transform_in->minlen);
906       return gpg_error (GPG_ERR_INV_MAC);
907     }
908
909   if (mode == GCRY_CIPHER_MODE_STREAM)
910     {
911       size_t olen = 0;
912
913       padlen = 0;
914
915       /* err = cipher_crypt (tls->transform_in->cipher_ctx_dec, */
916       /*                     tls->transform_in->iv_dec, */
917       /*                     tls->transform_in->ivlen, */
918       /*                     tls->in_msg, tls->in_msglen, */
919       /*                     tls->in_msg, &olen); */
920       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
921       if (err)
922         {
923           debug_ret (1, "cipher_crypt", err);
924           return err;
925         }
926
927       if (tls->in_msglen != olen)
928         {
929           debug_bug ();
930           return gpg_error (GPG_ERR_INTERNAL);
931         }
932     }
933   else if (mode == GCRY_CIPHER_MODE_GCM || mode == GCRY_CIPHER_MODE_CCM)
934     {
935       size_t dec_msglen, olen;
936       unsigned char *dec_msg;
937       unsigned char add_data[13];
938       unsigned char taglen, explicit_iv_len;
939
940       taglen = (_ntbtls_ciphersuite_get_flags (tls->transform_in->ciphersuite)
941                 & CIPHERSUITE_FLAG_SHORT_TAG)? 8 : 16;
942       explicit_iv_len = (tls->transform_in->ivlen
943                          - tls->transform_in->fixed_ivlen);
944
945       if (tls->in_msglen < explicit_iv_len + taglen)
946         {
947           debug_msg (1, "msglen (%d) < explicit_iv_len (%d) "
948                      "+ taglen (%d)", tls->in_msglen,
949                      explicit_iv_len, taglen);
950           return gpg_error (GPG_ERR_INV_MAC);
951          }
952       dec_msglen = tls->in_msglen - explicit_iv_len - taglen;
953
954       dec_msg = tls->in_msg;
955       tls->in_msglen = dec_msglen;
956
957       memcpy (add_data, tls->in_ctr, 8);
958       add_data[8] = tls->in_msgtype;
959       add_data[9] = tls->major_ver;
960       add_data[10] = tls->minor_ver;
961       add_data[11] = (tls->in_msglen >> 8) & 0xFF;
962       add_data[12] = tls->in_msglen & 0xFF;
963
964       debug_buf (4, "additional data used for AEAD", add_data, 13);
965
966       memcpy (tls->transform_in->iv_dec + tls->transform_in->fixed_ivlen,
967               tls->in_iv,
968               tls->transform_in->ivlen - tls->transform_in->fixed_ivlen);
969
970       debug_buf (4, "IV used",
971                  tls->transform_in->iv_dec, tls->transform_in->ivlen);
972       debug_buf (4, "TAG used", dec_msg + dec_msglen, taglen);
973
974       /*
975        * Decrypt and authenticate
976        */
977       /* err = cipher_auth_decrypt (tls->transform_in->cipher_ctx_dec, */
978       /*                            tls->transform_in->iv_dec, */
979       /*                            tls->transform_in->ivlen, */
980       /*                            add_data, 13, */
981       /*                            dec_msg, dec_msglen, */
982       /*                            dec_msg_result, &olen, */
983       /*                            dec_msg + dec_msglen, taglen); */
984       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
985       if (err)
986         {
987           debug_ret (1, "cipher_auth_decrypt", err);
988
989           /* if (gpg_err_code (err) == POLARSSL_ERR_CIPHER_AUTH_FAILED) */
990           /*   err = gpg_error (GPG_ERR_BAD_MAC); */
991
992           return err;
993         }
994
995       if (olen != dec_msglen)
996         {
997           debug_bug ();
998           return gpg_error (GPG_ERR_INTERNAL);
999         }
1000     }
1001   else if (mode == GCRY_CIPHER_MODE_CBC)
1002     {
1003       /*
1004        * Decrypt and check the padding
1005        */
1006       unsigned char *dec_msg;
1007       size_t pad_count, real_count, padding_idx;
1008       size_t dec_msglen;
1009       size_t minlen = 0;
1010       size_t olen = 0;
1011
1012       /*
1013        * Check immediate ciphertext sanity
1014        */
1015       if ((tls->in_msglen % tls->transform_in->ivlen))
1016         {
1017           debug_msg (1, "msglen (%d) %% ivlen (%d) != 0",
1018                      tls->in_msglen, tls->transform_in->ivlen);
1019           return gpg_error (GPG_ERR_INV_MAC);
1020         }
1021
1022       minlen += tls->transform_in->ivlen;
1023
1024       if (tls->in_msglen < minlen + tls->transform_in->ivlen
1025           || tls->in_msglen < minlen + tls->transform_in->maclen + 1)
1026         {
1027           debug_msg (1, "msglen (%d) < max( ivlen(%d), maclen (%d) "
1028                      "+ 1 ) ( + expl IV )",
1029                      tls->in_msglen,
1030                      tls->transform_in->ivlen,
1031                      tls->transform_in->maclen);
1032           return gpg_error (GPG_ERR_INV_MAC);
1033         }
1034
1035       dec_msglen = tls->in_msglen;
1036       dec_msg = tls->in_msg;
1037
1038       /*
1039        * Initialize for prepended IV.
1040        */
1041       dec_msglen -= tls->transform_in->ivlen;
1042       tls->in_msglen -= tls->transform_in->ivlen;
1043
1044       for (i = 0; i < tls->transform_in->ivlen; i++)
1045         tls->transform_in->iv_dec[i] = tls->in_iv[i];
1046
1047       err = gcry_cipher_reset (tls->transform_out->cipher_ctx_dec);
1048       if (err)
1049         {
1050           debug_ret (1, "cipher_reset", err);
1051           return err;
1052         }
1053       err = gcry_cipher_setiv (tls->transform_out->cipher_ctx_dec,
1054                                tls->transform_out->iv_dec,
1055                                tls->transform_out->ivlen);
1056       if (err)
1057         {
1058           debug_ret (1, "cipher_setiv", err);
1059           return err;
1060         }
1061
1062       err = gcry_cipher_decrypt (tls->transform_out->cipher_ctx_dec,
1063                                  dec_msg, dec_msglen, NULL, 0);
1064       if (err)
1065         {
1066           debug_ret (1, "cipher_decrypt", err);
1067           return err;
1068         }
1069
1070       padlen = 1 + tls->in_msg[tls->in_msglen - 1];
1071
1072       if (tls->in_msglen < tls->transform_in->maclen + padlen)
1073         {
1074           debug_msg (1, "msglen (%d) < maclen (%d) + padlen (%d)",
1075                      tls->in_msglen, tls->transform_in->maclen, padlen);
1076           padlen = 0;
1077           correct = 0;
1078         }
1079
1080       /*
1081        * Always check the padding up to the first failure and fake
1082        * check up to 256 bytes of padding
1083        */
1084       pad_count = 0;
1085       real_count = 1;
1086       padding_idx = tls->in_msglen - padlen - 1;
1087
1088       /*
1089        * Padding is guaranteed to be incorrect if:
1090        *   1. padlen >= tls->in_msglen
1091        *
1092        *   2. padding_idx >= TLS_MAX_CONTENT_LEN +
1093        *                     tls->transform_in->maclen
1094        *
1095        * In both cases we reset padding_idx to a safe value (0) to
1096        * prevent out-of-buffer reads.
1097        */
1098       correct &= (tls->in_msglen >= padlen + 1);
1099       correct &= (padding_idx < TLS_MAX_CONTENT_LEN
1100                   + tls->transform_in->maclen);
1101       padding_idx *= correct;
1102
1103       for (i = 1; i <= 256; i++)
1104         {
1105           real_count &= (i <= padlen);
1106           pad_count += real_count * (tls->in_msg[padding_idx + i] == padlen-1);
1107         }
1108
1109       correct &= (pad_count == padlen);     /* Only 1 on correct padding */
1110
1111       if (padlen > 0 && !correct)
1112         debug_msg (1, "bad padding byte detected");
1113
1114       padlen &= correct * 0x1FF;
1115     }
1116   else
1117     {
1118       debug_bug ();
1119       return gpg_error (GPG_ERR_INTERNAL);
1120     }
1121
1122   debug_buf (4, "raw buffer after decryption", tls->in_msg, tls->in_msglen);
1123
1124   /*
1125    * Always compute the MAC (RFC4346, CBCTIME), except for AEAD of course
1126    */
1127   if (mode != GCRY_CIPHER_MODE_GCM && mode != GCRY_CIPHER_MODE_CCM)
1128     {
1129       unsigned char tmp[TLS_MAX_MAC_SIZE];
1130       size_t j, extra_run;
1131
1132       tls->in_msglen -= (tls->transform_in->maclen + padlen);
1133
1134       tls->in_hdr[3] = (unsigned char) (tls->in_msglen >> 8);
1135       tls->in_hdr[4] = (unsigned char) (tls->in_msglen);
1136
1137       memcpy (tmp, tls->in_msg + tls->in_msglen, tls->transform_in->maclen);
1138
1139       /*
1140        * Process MAC and always update for padlen afterwards to make
1141        * total time independent of padlen
1142        *
1143        * extra_run compensates MAC check for padlen
1144        *
1145        * Known timing attacks:
1146        *  - Lucky Thirteen (http://www.isg.rhul.ac.uk/tls/TLStiming.pdf)
1147        *
1148        * We use ( ( Lx + 8 ) / 64 ) to handle 'negative Lx' values
1149        * correctly. (We round down instead of up, so -56 is the correct
1150        * value for our calculations instead of -55)
1151        */
1152       extra_run = ((13 + tls->in_msglen + padlen + 8) / 64
1153                    - (13 + tls->in_msglen + 8) / 64);
1154
1155       extra_run &= correct * 0xFF;
1156
1157       gcry_mac_write (tls->transform_in->mac_ctx_dec, tls->in_ctr, 13);
1158       gcry_mac_write (tls->transform_in->mac_ctx_dec, tls->in_msg,
1159                       tls->in_msglen);
1160       tmplen = tls->transform_in->maclen;
1161       gcry_mac_read (tls->transform_in->mac_ctx_dec,
1162                      tls->in_msg + tls->in_msglen, &tmplen);
1163       //FIXME:
1164       //FIXME:  We need to implement our own version of this
1165       //FIXME:  Maybe we can use gcry_mac_write after the read but that
1166       //        Needs to be checked and a comment must be added to
1167       //        Libgcrypt so that we do not accidently optimize this away.
1168       /* for (j = 0; j < extra_run; j++) */
1169       /*   md_process (&tls->transform_in->md_ctx_dec, tls->in_msg); */
1170
1171       gcry_mac_reset (tls->transform_in->mac_ctx_dec);
1172
1173       debug_buf (4, "message  mac", tmp, tls->transform_in->maclen);
1174       debug_buf (4, "computed mac",
1175                  tls->in_msg + tls->in_msglen, tls->transform_in->maclen);
1176
1177       if (memcmpct (tmp, tls->in_msg + tls->in_msglen,
1178                     tls->transform_in->maclen))
1179         {
1180           debug_msg (1, "message mac does not match");
1181           correct = 0;
1182         }
1183
1184       /*
1185        * Finally check the correct flag
1186        */
1187       if (!correct)
1188         return gpg_error (GPG_ERR_BAD_MAC);
1189     }
1190
1191   if (!tls->in_msglen)
1192     {
1193       tls->nb_zero++;
1194
1195       /*
1196        * Three or more empty messages may be a DoS attack
1197        * (excessive CPU consumption).
1198        */
1199       if (tls->nb_zero > 3)
1200         {
1201           debug_msg (1, "received four consecutive empty "
1202                      "messages, possible DoS attack");
1203           return gpg_error (GPG_ERR_INV_MAC);
1204         }
1205     }
1206   else
1207     tls->nb_zero = 0;
1208
1209   for (i = 8; i > 0; i--)
1210     if (++tls->in_ctr[i - 1] != 0)
1211       break;
1212
1213   /* The loops goes to its end iff the counter is wrapping */
1214   if (!i)
1215     {
1216       debug_msg (1, "incoming message counter would wrap");
1217       return gpg_error (GPG_ERR_WOULD_WRAP);
1218     }
1219
1220   debug_msg (2, "<= decrypt buf");
1221
1222   return 0;
1223 }
1224
1225
1226 /*
1227  * Compression/decompression functions
1228  */
1229 static int
1230 ssl_compress_buf (ntbtls_t ssl)
1231 {
1232   int ret;
1233   unsigned char *msg_post = ssl->out_msg;
1234   size_t len_pre = ssl->out_msglen;
1235   unsigned char *msg_pre = ssl->compress_buf;
1236
1237   debug_msg (2, "=> compress buf");
1238
1239   if (len_pre == 0)
1240     return (0);
1241
1242   memcpy (msg_pre, ssl->out_msg, len_pre);
1243
1244   debug_msg (3, "before compression: msglen = %d, ", ssl->out_msglen);
1245
1246   debug_buf (4, "before compression: output payload",
1247              ssl->out_msg, ssl->out_msglen);
1248
1249   ssl->transform_out->ctx_deflate.next_in = msg_pre;
1250   ssl->transform_out->ctx_deflate.avail_in = len_pre;
1251   ssl->transform_out->ctx_deflate.next_out = msg_post;
1252   ssl->transform_out->ctx_deflate.avail_out = TLS_BUFFER_LEN;
1253
1254   /* ret = deflate (&ssl->transform_out->ctx_deflate, Z_SYNC_FLUSH); */
1255   ret = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1256   if (ret != Z_OK)
1257     {
1258       debug_msg (1, "failed to perform compression (%d)", ret);
1259       return gpg_error (GPG_ERR_COMPR_FAILED);
1260     }
1261
1262   ssl->out_msglen = (TLS_BUFFER_LEN
1263                      - ssl->transform_out->ctx_deflate.avail_out);
1264
1265   debug_msg (3, "after compression: msglen = %d, ", ssl->out_msglen);
1266
1267   debug_buf (4, "after compression: output payload",
1268              ssl->out_msg, ssl->out_msglen);
1269
1270   debug_msg (2, "<= compress buf");
1271
1272   return (0);
1273 }
1274
1275 static int
1276 ssl_decompress_buf (ntbtls_t ssl)
1277 {
1278   int ret;
1279   unsigned char *msg_post = ssl->in_msg;
1280   size_t len_pre = ssl->in_msglen;
1281   unsigned char *msg_pre = ssl->compress_buf;
1282
1283   debug_msg (2, "=> decompress buf");
1284
1285   if (len_pre == 0)
1286     return (0);
1287
1288   memcpy (msg_pre, ssl->in_msg, len_pre);
1289
1290   debug_msg (3, "before decompression: msglen = %d, ", ssl->in_msglen);
1291
1292   debug_buf (4, "before decompression: input payload",
1293              ssl->in_msg, ssl->in_msglen);
1294
1295   ssl->transform_in->ctx_inflate.next_in = msg_pre;
1296   ssl->transform_in->ctx_inflate.avail_in = len_pre;
1297   ssl->transform_in->ctx_inflate.next_out = msg_post;
1298   ssl->transform_in->ctx_inflate.avail_out = TLS_MAX_CONTENT_LEN;
1299
1300   /* ret = inflate (&ssl->transform_in->ctx_inflate, Z_SYNC_FLUSH); */
1301   ret = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1302   if (ret != Z_OK)
1303     {
1304       debug_msg (1, "failed to perform decompression (%d)", ret);
1305       return gpg_error (GPG_ERR_COMPR_FAILED);
1306     }
1307
1308   ssl->in_msglen = (TLS_MAX_CONTENT_LEN
1309                     - ssl->transform_in->ctx_inflate.avail_out);
1310
1311   debug_msg (3, "after decompression: msglen = %d, ", ssl->in_msglen);
1312
1313   debug_buf (4, "after decompression: input payload",
1314              ssl->in_msg, ssl->in_msglen);
1315
1316   debug_msg (2, "<= decompress buf");
1317
1318   return (0);
1319 }
1320
1321
1322 /* Fill the input message buffer with NB_WANT bytes.  The function
1323  * returns an error if the numer of requested bytes do not fit into
1324  * the record buffer, there is a read problem, or on EOF.  */
1325 gpg_error_t
1326 _ntbtls_fetch_input (ntbtls_t tls, size_t nb_want)
1327 {
1328   gpg_error_t err;
1329   size_t len, nread;
1330
1331   debug_msg (2, "=> fetch input");
1332
1333   if (!tls->inbound)
1334     return gpg_error (GPG_ERR_NOT_INITIALIZED);
1335
1336   if (nb_want > TLS_BUFFER_LEN - 8)
1337     {
1338       debug_msg (1, "requesting more data than fits");
1339       // FIXME; New code for "request too long for buffer"?
1340       return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
1341     }
1342
1343   err = 0;
1344   while (tls->in_left < nb_want)
1345     {
1346       len = nb_want - tls->in_left;
1347       if (es_read (tls->inbound, tls->in_hdr + tls->in_left, len, &nread))
1348         err = gpg_error_from_syserror ();
1349
1350       debug_msg (2, "in_left: %d, nb_want: %d", tls->in_left, nb_want);
1351       debug_ret (2, "es_read", err);
1352
1353       if (err || !nread /*ie. EOF*/)
1354         break;
1355
1356       tls->in_left += nread;
1357     }
1358
1359   debug_msg (2, "<= fetch input");
1360
1361   return err;
1362 }
1363
1364
1365 /*
1366  * Flush any data not yet written
1367  */
1368 gpg_error_t
1369 _ntbtls_flush_output (ntbtls_t tls)
1370 {
1371   gpg_error_t err;
1372   unsigned char *buf;
1373   size_t nwritten;
1374
1375   debug_msg (2, "=> flush output");
1376
1377   if (!tls->outbound)
1378     return gpg_error (GPG_ERR_NOT_INITIALIZED);
1379
1380   err = 0;
1381   while (tls->out_left > 0)
1382     {
1383       debug_msg (2, "message length: %d, out_left: %d",
1384                  5 + tls->out_msglen, tls->out_left);
1385
1386       buf = tls->out_hdr + 5 + tls->out_msglen - tls->out_left;
1387       if (es_write (tls->outbound, buf, tls->out_left, &nwritten))
1388         err = gpg_error_from_syserror ();
1389
1390       debug_ret (2, "es_write", err);
1391
1392       if (err)
1393         break;
1394
1395       tls->out_left -= nwritten;
1396     }
1397
1398   debug_msg (2, "<= flush output");
1399
1400   return err;
1401 }
1402
1403
1404 /*
1405  * Record layer functions
1406  */
1407 gpg_error_t
1408 _ntbtls_write_record (ntbtls_t tls)
1409 {
1410   gpg_error_t err;
1411   int done = 0;
1412   size_t len = tls->out_msglen;
1413
1414   debug_msg (2, "=> write record");
1415
1416   if (tls->out_msgtype == TLS_MSG_HANDSHAKE)
1417     {
1418       tls->out_msg[1] = (unsigned char) ((len - 4) >> 16);
1419       tls->out_msg[2] = (unsigned char) ((len - 4) >> 8);
1420       tls->out_msg[3] = (unsigned char) ((len - 4));
1421
1422       if (tls->out_msg[0] != TLS_HS_HELLO_REQUEST)
1423         tls->handshake->update_checksum (tls, tls->out_msg, len);
1424     }
1425
1426   if (tls->transform_out
1427       && tls->session_out->compression == TLS_COMPRESS_DEFLATE)
1428     {
1429       err = ssl_compress_buf (tls);
1430       if (err)
1431         {
1432           debug_ret (1, "ssl_compress_buf", err);
1433           return err;
1434         }
1435
1436       len = tls->out_msglen;
1437     }
1438
1439   if (!done)
1440     {
1441       tls->out_hdr[0] = (unsigned char) tls->out_msgtype;
1442       tls->out_hdr[1] = (unsigned char) tls->major_ver;
1443       tls->out_hdr[2] = (unsigned char) tls->minor_ver;
1444       tls->out_hdr[3] = (unsigned char) (len >> 8);
1445       tls->out_hdr[4] = (unsigned char) (len);
1446
1447       if (tls->transform_out)
1448         {
1449           err = encrypt_buf (tls);
1450           if (err)
1451             {
1452               debug_ret (1, "encrypt_buf", err);
1453               return err;
1454             }
1455
1456           len = tls->out_msglen;
1457           tls->out_hdr[3] = (unsigned char) (len >> 8);
1458           tls->out_hdr[4] = (unsigned char) (len);
1459         }
1460
1461       tls->out_left = 5 + tls->out_msglen;
1462
1463       debug_msg (3, "output record: msgtype = %d, "
1464                  "version = [%d:%d], msglen = %d",
1465                  tls->out_hdr[0], tls->out_hdr[1], tls->out_hdr[2],
1466                  (tls->out_hdr[3] << 8) | tls->out_hdr[4]);
1467
1468       debug_buf (4, "output record sent to network",
1469                  tls->out_hdr, 5 + tls->out_msglen);
1470     }
1471
1472   err = _ntbtls_flush_output (tls);
1473   if (err)
1474     {
1475       debug_ret (1, "_ntbtls_flush_output", err);
1476       return err;
1477     }
1478
1479   debug_msg (2, "<= write record");
1480
1481   return err;
1482 }
1483
1484
1485 gpg_error_t
1486 _ntbtls_read_record (ntbtls_t tls)
1487 {
1488   gpg_error_t err;
1489   int done = 0;
1490
1491   debug_msg (2, "=> read record");
1492
1493   if (tls->in_hslen != 0 && tls->in_hslen < tls->in_msglen)
1494     {
1495       /*
1496        * Get next Handshake message in the current record
1497        */
1498       tls->in_msglen -= tls->in_hslen;
1499
1500       memmove (tls->in_msg, tls->in_msg + tls->in_hslen, tls->in_msglen);
1501
1502       tls->in_hslen = 4;
1503       tls->in_hslen += (tls->in_msg[2] << 8) | tls->in_msg[3];
1504
1505       debug_msg (3, "handshake message: msglen ="
1506                  " %d, type = %d, hslen = %d",
1507                  tls->in_msglen, tls->in_msg[0], tls->in_hslen);
1508
1509       if (tls->in_msglen < 4 || tls->in_msg[1] != 0)
1510         {
1511           debug_msg (1, "bad handshake length");
1512           return gpg_error (GPG_ERR_INV_RECORD);
1513         }
1514
1515       if (tls->in_msglen < tls->in_hslen)
1516         {
1517           debug_msg (1, "bad handshake length");
1518           return gpg_error (GPG_ERR_INV_RECORD);
1519         }
1520
1521       if (tls->state != TLS_HANDSHAKE_OVER)
1522         tls->handshake->update_checksum (tls, tls->in_msg, tls->in_hslen);
1523
1524       return 0;
1525     }
1526
1527   tls->in_hslen = 0;
1528
1529   /*
1530    * Read the record header and validate it
1531    */
1532   err = _ntbtls_fetch_input (tls, 5);
1533   if (err)
1534     {
1535       debug_ret (1, "fetch_input", err);
1536       return err;
1537     }
1538   //FIXME: Handle EOF
1539
1540   tls->in_msgtype = tls->in_hdr[0];
1541   tls->in_msglen = (tls->in_hdr[3] << 8) | tls->in_hdr[4];
1542
1543   debug_msg (3, "input record: msgtype = %d, "
1544              "version = [%d:%d], msglen = %d",
1545              tls->in_hdr[0], tls->in_hdr[1], tls->in_hdr[2],
1546              (tls->in_hdr[3] << 8) | tls->in_hdr[4]);
1547
1548   if (tls->in_hdr[1] != tls->major_ver)
1549     {
1550       debug_msg (1, "major version mismatch");
1551       return gpg_error (GPG_ERR_INV_RECORD);
1552     }
1553
1554   if (tls->in_hdr[2] > tls->max_minor_ver)
1555     {
1556       debug_msg (1, "minor version mismatch");
1557       return gpg_error (GPG_ERR_INV_RECORD);
1558     }
1559
1560   /* Sanity check (outer boundaries) */
1561   if (tls->in_msglen < 1 || tls->in_msglen > TLS_BUFFER_LEN - 13)
1562     {
1563       debug_msg (1, "bad message length");
1564       return gpg_error (GPG_ERR_INV_RECORD);
1565     }
1566
1567   /*
1568    * Make sure the message length is acceptable for the current transform
1569    * and protocol version.
1570    */
1571   if (!tls->transform_in)
1572     {
1573       if (tls->in_msglen > TLS_MAX_CONTENT_LEN)
1574         {
1575           debug_msg (1, "bad message length");
1576           return gpg_error (GPG_ERR_INV_RECORD);
1577         }
1578     }
1579   else
1580     {
1581       if (tls->in_msglen < tls->transform_in->minlen)
1582         {
1583           debug_msg (1, "bad message length");
1584           return gpg_error (GPG_ERR_INV_RECORD);
1585         }
1586
1587       /*
1588        * TLS encrypted messages can have up to 256 bytes of padding
1589        */
1590       if (tls->minor_ver >= TLS_MINOR_VERSION_1
1591           && tls->in_msglen > (tls->transform_in->minlen
1592                                + TLS_MAX_CONTENT_LEN + 256))
1593         {
1594           debug_msg (1, "bad message length");
1595           return gpg_error (GPG_ERR_INV_RECORD);
1596         }
1597     }
1598
1599   /*
1600    * Read and optionally decrypt the message contents
1601    */
1602   err = _ntbtls_fetch_input (tls, 5 + tls->in_msglen);
1603   if (err)
1604     {
1605       debug_ret (1, "fetch_input", err);
1606       return err;
1607     }
1608   //FIXME: Handle EOF
1609
1610   debug_buf (4, "input record from network", tls->in_hdr, 5 + tls->in_msglen);
1611
1612   if (!done && tls->transform_in)
1613     {
1614       err = decrypt_buf (tls);
1615       if (err)
1616         {
1617           if (gpg_err_code (err) == GPG_ERR_INV_MAC
1618               || gpg_err_code (err) == GPG_ERR_BAD_MAC)
1619             {
1620               _ntbtls_send_alert_message (tls,
1621                                           TLS_ALERT_LEVEL_FATAL,
1622                                           TLS_ALERT_MSG_BAD_RECORD_MAC);
1623             }
1624           debug_ret (1, "decrypt_buf", err);
1625           return err;
1626         }
1627
1628       debug_buf (4, "input payload after decrypt", tls->in_msg, tls->in_msglen);
1629
1630       if (tls->in_msglen > TLS_MAX_CONTENT_LEN)
1631         {
1632           debug_msg (1, "bad message length");
1633           return gpg_error (GPG_ERR_INV_RECORD);
1634         }
1635     }
1636
1637   if (tls->transform_in && tls->session_in->compression == TLS_COMPRESS_DEFLATE)
1638     {
1639       err = ssl_decompress_buf (tls);
1640       if (err)
1641         {
1642           debug_ret (1, "decompress_buf", err);
1643           return err;
1644         }
1645
1646       tls->in_hdr[3] = (unsigned char) (tls->in_msglen >> 8);
1647       tls->in_hdr[4] = (unsigned char) (tls->in_msglen);
1648     }
1649
1650   if (   tls->in_msgtype != TLS_MSG_HANDSHAKE
1651       && tls->in_msgtype != TLS_MSG_ALERT
1652       && tls->in_msgtype != TLS_MSG_CHANGE_CIPHER_SPEC
1653       && tls->in_msgtype != TLS_MSG_APPLICATION_DATA)
1654     {
1655       debug_msg (1, "unknown record type");
1656
1657       err = _ntbtls_send_alert_message (tls, TLS_ALERT_LEVEL_FATAL,
1658                                         TLS_ALERT_MSG_UNEXPECTED_MESSAGE);
1659       if (!err)
1660         err = gpg_error (GPG_ERR_INV_RECORD);
1661
1662       return err;
1663     }
1664
1665   if (tls->in_msgtype == TLS_MSG_HANDSHAKE)
1666     {
1667       tls->in_hslen = 4;
1668       tls->in_hslen += (tls->in_msg[2] << 8) | tls->in_msg[3];
1669
1670       debug_msg (3, "handshake message: msglen ="
1671                  " %d, type = %d, hslen = %d",
1672                  tls->in_msglen, tls->in_msg[0], tls->in_hslen);
1673
1674       /*
1675        * Additional checks to validate the handshake header
1676        */
1677       if (tls->in_msglen < 4 || tls->in_msg[1] != 0)
1678         {
1679           debug_msg (1, "bad handshake length");
1680           return gpg_error (GPG_ERR_INV_RECORD);
1681         }
1682
1683       if (tls->in_msglen < tls->in_hslen)
1684         {
1685           debug_msg (1, "bad handshake length");
1686           return gpg_error (GPG_ERR_INV_RECORD);
1687         }
1688
1689       if (tls->state != TLS_HANDSHAKE_OVER)
1690         tls->handshake->update_checksum (tls, tls->in_msg, tls->in_hslen);
1691     }
1692
1693   if (tls->in_msgtype == TLS_MSG_ALERT)
1694     {
1695       debug_msg (2, "got an alert message, type: [%d:%d]",
1696                  tls->in_msg[0], tls->in_msg[1]);
1697
1698       /*
1699        * Ignore non-fatal alerts, except close_notify
1700        */
1701       if (tls->in_msg[0] == TLS_ALERT_LEVEL_FATAL)
1702         {
1703           debug_msg (1, "is a fatal alert message (msg %d)",
1704                      tls->in_msg[1]);
1705           /**
1706            * Subtract from error code as tls->in_msg[1] is 7-bit positive
1707            * error identifier.
1708            */
1709           return gpg_error (GPG_ERR_FATAL_ALERT);
1710         }
1711
1712       if (tls->in_msg[0] == TLS_ALERT_LEVEL_WARNING &&
1713           tls->in_msg[1] == TLS_ALERT_MSG_CLOSE_NOTIFY)
1714         {
1715           debug_msg (2, "is a close notify message");
1716           return gpg_error (GPG_ERR_CLOSE_NOTIFY);
1717         }
1718     }
1719
1720   tls->in_left = 0;
1721
1722   debug_msg (2, "<= read record");
1723
1724   return (0);
1725 }
1726
1727
1728 gpg_error_t
1729 _ntbtls_send_fatal_handshake_failure (ntbtls_t tls)
1730 {
1731   return _ntbtls_send_alert_message (tls, TLS_ALERT_LEVEL_FATAL,
1732                                      TLS_ALERT_MSG_HANDSHAKE_FAILURE);
1733 }
1734
1735
1736 gpg_error_t
1737 _ntbtls_send_alert_message (ntbtls_t tls,
1738                             unsigned char level, unsigned char message)
1739 {
1740   gpg_error_t err;
1741
1742   debug_msg (2, "=> send alert message");
1743
1744   tls->out_msgtype = TLS_MSG_ALERT;
1745   tls->out_msglen = 2;
1746   tls->out_msg[0] = level;
1747   tls->out_msg[1] = message;
1748
1749   err = _ntbtls_write_record (tls);
1750   if (err)
1751     {
1752       debug_ret (1, "write_record", err);
1753       return err;
1754     }
1755
1756   debug_msg (2, "<= send alert message");
1757
1758   return 0;
1759 }
1760
1761
1762 /*
1763  * Handshake functions
1764  */
1765
1766
1767 gpg_error_t
1768 _ntbtls_write_certificate (ntbtls_t tls)
1769 {
1770   gpg_error_t err;
1771   const ciphersuite_t suite = tls->transform_negotiate->ciphersuite;
1772   key_exchange_type_t kex = _ntbtls_ciphersuite_get_kex (suite);
1773   x509_cert_t cert;
1774   int idx;
1775   const unsigned char *der;
1776   size_t derlen;
1777   size_t i;
1778
1779   debug_msg (2, "=> write certificate");
1780
1781   if (kex == KEY_EXCHANGE_PSK
1782       || kex == KEY_EXCHANGE_DHE_PSK
1783       || kex == KEY_EXCHANGE_ECDHE_PSK)
1784     {
1785       debug_msg (2, "<= skip write certificate");
1786       tls->state++;
1787       return 0;
1788     }
1789
1790   if (tls->is_client)
1791     {
1792       if (!tls->client_auth)
1793         {
1794           debug_msg (2, "<= skip write certificate");
1795           tls->state++;
1796           return 0;
1797         }
1798
1799     }
1800   else /* is_server */
1801     {
1802       if (!tls_own_cert (tls))
1803         {
1804           debug_msg (1, "got no certificate to send");
1805           return gpg_error (GPG_ERR_MISSING_CERT);
1806         }
1807     }
1808
1809   /* SSL_DEBUG_CRT (3, "own certificate", tls_own_cert (tls)); */
1810
1811   /*
1812    *     0  .  0    handshake type
1813    *     1  .  3    handshake length
1814    *     4  .  6    length of all certs
1815    *     7  .  9    length of cert. 1
1816    *    10  . n-1   peer certificate
1817    *     n  . n+2   length of cert. 2
1818    *    n+3 . ...   upper level cert, etc.
1819    */
1820   i = 7;
1821   cert = tls_own_cert (tls);
1822   for (idx = 0; (der = _ntbtls_x509_get_cert (cert, idx, &derlen)); idx++)
1823     {
1824       if (derlen > TLS_MAX_CONTENT_LEN - 3 - i)
1825         {
1826           debug_msg (1, "certificate too large, %d > %d",
1827                      i + 3 + derlen, TLS_MAX_CONTENT_LEN);
1828           return gpg_error (GPG_ERR_CERT_TOO_LARGE);
1829         }
1830
1831       tls->out_msg[i]     = (unsigned char) (derlen >> 16);
1832       tls->out_msg[i + 1] = (unsigned char) (derlen >> 8);
1833       tls->out_msg[i + 2] = (unsigned char) (derlen);
1834       i += 3;
1835       memcpy (tls->out_msg + i, der, derlen);
1836       i += derlen;
1837     }
1838
1839   tls->out_msg[4] = (unsigned char) ((i - 7) >> 16);
1840   tls->out_msg[5] = (unsigned char) ((i - 7) >> 8);
1841   tls->out_msg[6] = (unsigned char) ((i - 7));
1842
1843   tls->out_msglen = i;
1844   tls->out_msgtype = TLS_MSG_HANDSHAKE;
1845   tls->out_msg[0] = TLS_HS_CERTIFICATE;
1846
1847   tls->state++;
1848
1849   err = _ntbtls_write_record (tls);
1850   if (err)
1851     {
1852       debug_ret (1, "write_record", err);
1853       return err;
1854     }
1855
1856   debug_msg (2, "<= write certificate");
1857
1858   return err;
1859 }
1860
1861
1862 gpg_error_t
1863 _ntbtls_parse_certificate (ntbtls_t tls)
1864 {
1865   gpg_error_t err;
1866   size_t i, n;
1867   const ciphersuite_t suite = tls->transform_negotiate->ciphersuite;
1868   key_exchange_type_t kex = _ntbtls_ciphersuite_get_kex (suite);
1869
1870   debug_msg (2, "=> parse certificate");
1871
1872   if (kex == KEY_EXCHANGE_PSK
1873       || kex == KEY_EXCHANGE_DHE_PSK
1874       || kex == KEY_EXCHANGE_ECDHE_PSK)
1875     {
1876       debug_msg (2, "<= skip parse certificate");
1877       tls->state++;
1878       return 0;
1879     }
1880
1881   if (!tls->is_client
1882       && (tls->authmode == TLS_VERIFY_NONE || kex == KEY_EXCHANGE_RSA_PSK))
1883     {
1884       tls->session_negotiate->verify_result = BADCERT_SKIP_VERIFY;
1885       debug_msg (2, "<= skip parse certificate");
1886       tls->state++;
1887       return 0;
1888     }
1889
1890   err = _ntbtls_read_record (tls);
1891   if (err)
1892     {
1893       debug_ret (1, "read_record", err);
1894       return err;
1895     }
1896
1897   tls->state++;
1898
1899   if (!tls->is_client && tls->minor_ver != TLS_MINOR_VERSION_0)
1900     {
1901       if (tls->in_hslen == 7 &&
1902           tls->in_msgtype == TLS_MSG_HANDSHAKE &&
1903           tls->in_msg[0] == TLS_HS_CERTIFICATE &&
1904           !memcmp (tls->in_msg + 4, "\0\0\0", 3))
1905         {
1906           debug_msg (1, "TLSv1 client has no certificate");
1907
1908           tls->session_negotiate->verify_result = BADCERT_MISSING;
1909           if (tls->authmode == TLS_VERIFY_REQUIRED)
1910             return gpg_error (GPG_ERR_MISSING_CLIENT_CERT);
1911           else
1912             return 0;
1913         }
1914     }
1915
1916   if (tls->in_msgtype != TLS_MSG_HANDSHAKE)
1917     {
1918       debug_msg (1, "bad certificate message");
1919       return gpg_error (GPG_ERR_UNEXPECTED_MSG);
1920     }
1921
1922   if (tls->in_msg[0] != TLS_HS_CERTIFICATE || tls->in_hslen < 10)
1923     {
1924       debug_msg (1, "bad certificate message");
1925       return gpg_error (GPG_ERR_BAD_HS_CERT);
1926     }
1927
1928   /*
1929    * Same message structure as in _ntbtls_write_certificate()
1930    */
1931   n = (tls->in_msg[5] << 8) | tls->in_msg[6];
1932
1933   if (tls->in_msg[4] != 0 || tls->in_hslen != 7 + n)
1934     {
1935       debug_msg (1, "bad certificate message");
1936       return gpg_error (GPG_ERR_BAD_HS_CERT);
1937     }
1938
1939   /* In case we tried to reuse a session but it failed. */
1940   if (tls->session_negotiate->peer_chain)
1941     {
1942       _ntbtls_x509_release (tls->session_negotiate->peer_chain);
1943       tls->session_negotiate->peer_chain = NULL;
1944     }
1945
1946   err = _ntbtls_x509_new (&tls->session_negotiate->peer_chain);
1947   if (err)
1948     {
1949       debug_msg (1, "allocating X.509 cert object failed");
1950       return err;
1951     }
1952
1953   for (i = 7; i < tls->in_hslen; )
1954     {
1955       if (tls->in_msg[i] != 0)
1956         {
1957           debug_msg (1, "bad certificate message");
1958           return gpg_error (GPG_ERR_BAD_HS_CERT);
1959         }
1960
1961       n = (((unsigned int) tls->in_msg[i + 1] << 8)
1962            | (unsigned int) tls->in_msg[i + 2]);
1963       i += 3;
1964
1965       if (n < 128 || i + n > tls->in_hslen)
1966         {
1967           debug_msg (1, "bad certificate message");
1968           return gpg_error (GPG_ERR_BAD_HS_CERT);
1969         }
1970
1971       err = _ntbtls_x509_append_cert (tls->session_negotiate->peer_chain,
1972                                       tls->in_msg + i, n);
1973       if (err)
1974         {
1975           debug_ret (1, "x509_append_cert", err);
1976           return err;
1977         }
1978       i += n;
1979     }
1980
1981   //FIXME: debug_crt (3, "peer certificate", tls->session_negotiate->peer_chain);
1982
1983   /*
1984    * On client, make sure the server cert doesn't change during renego to
1985    * avoid "triple handshake" attack: https://secure-resumption.com/
1986    */
1987   if (tls->is_client && tls->renegotiation == TLS_RENEGOTIATION)
1988     {
1989       if (!tls->session->peer_chain)
1990         {
1991           debug_msg (1, "new server cert during renegotiation");
1992           return gpg_error (GPG_ERR_BAD_HS_CERT);
1993         }
1994
1995       //FIXME:  Need to implement this in x509.c  IMPORTANT!
1996       /* if (tls->session->peer_chain->raw.len != */
1997       /*     tls->session_negotiate->peer_chain->raw.len */
1998       /*     ||  memcmp (tls->session->peer_chain->raw.p, */
1999       /*                 tls->session_negotiate->peer_chain->raw.p, */
2000       /*                 tls->session->peer_chain->raw.len)) */
2001       /*   { */
2002       /*     debug_msg (1, "server cert changed during renegotiation"); */
2003       /*     return gpg_error (GPG_ERR_BAD_HS_CERT); */
2004       /*   } */
2005     }
2006
2007   if (tls->authmode != TLS_VERIFY_NONE)
2008     {
2009       if (!tls->ca_chain)
2010         {
2011           debug_msg (1, "got no CA chain");
2012           return gpg_error (GPG_ERR_NO_CERT_CHAIN);
2013         }
2014
2015       /*
2016        * Main check: verify certificate
2017        */
2018       err = _ntbtls_x509_verify (tls->session_negotiate->peer_chain,
2019                                  tls->ca_chain, tls->ca_crl,
2020                                  tls->peer_cn,
2021                                  &tls->session_negotiate->verify_result);
2022       if (err)
2023         {
2024           debug_ret (1, "x509_verify", err);
2025         }
2026
2027       /*
2028        * Secondary checks: always done, but change 'ret' only if it was 0
2029        */
2030       //FIXME:
2031       /* { */
2032       /*   pk_context *pk = &tls->session_negotiate->peer_chain->pk; */
2033
2034       /*   /\* If certificate uses an EC key, make sure the curve is OK *\/ */
2035       /*   if (pk_can_do (pk, POLARSSL_PK_ECKEY) && */
2036       /*       !ssl_curve_is_acceptable (tls, pk_ec (*pk)->grp.id)) */
2037       /*     { */
2038       /*       debug_msg (1, "bad certificate (EC key curve)"); */
2039       /*       if (ret == 0) */
2040       /*         ret = gpg_error (GPG_ERR_BAD_HS_CERT); */
2041       /*     } */
2042       /* } */
2043       /* */
2044       /* if (ssl_check_cert_usage (tls->session_negotiate->peer_chain, */
2045       /*                           suite, tls->is_client)) */
2046       /*   { */
2047       /*     debug_msg (1, "bad certificate (usage extensions)"); */
2048       /*     if (!err) */
2049       /*       err = gpg_error (GPG_ERR_BAD_HS_CERT); */
2050       /*   } */
2051
2052       if (tls->authmode != TLS_VERIFY_REQUIRED)
2053         err = 0;
2054     }
2055
2056   debug_msg (2, "<= parse certificate");
2057
2058   return err;
2059 }
2060
2061
2062 gpg_error_t
2063 _ntbtls_write_change_cipher_spec (ntbtls_t tls)
2064 {
2065   gpg_error_t err;
2066
2067   debug_msg (2, "=> write change cipher spec");
2068
2069   tls->out_msgtype = TLS_MSG_CHANGE_CIPHER_SPEC;
2070   tls->out_msglen = 1;
2071   tls->out_msg[0] = 1;
2072
2073   tls->state++;
2074
2075   err = _ntbtls_write_record (tls);
2076   if (err)
2077     {
2078       debug_ret (1, "write_record", err);
2079       return err;
2080     }
2081
2082   debug_msg (2, "<= write change cipher spec");
2083
2084   return 0;
2085 }
2086
2087
2088 gpg_error_t
2089 _ntbtls_parse_change_cipher_spec (ntbtls_t tls)
2090 {
2091   gpg_error_t err;
2092
2093   debug_msg (2, "=> parse change cipher spec");
2094
2095   err = _ntbtls_read_record (tls);
2096   if (err)
2097     {
2098       debug_ret (1, "read_record", err);
2099       return err;
2100     }
2101
2102   if (tls->in_msgtype != TLS_MSG_CHANGE_CIPHER_SPEC)
2103     {
2104       debug_msg (1, "bad change cipher spec message");
2105       return gpg_error (GPG_ERR_UNEXPECTED_MSG);
2106     }
2107
2108   if (tls->in_msglen != 1 || tls->in_msg[0] != 1)
2109     {
2110       debug_msg (1, "bad change cipher spec message");
2111       return gpg_error (GPG_ERR_BAD_HS_CHANGE_CIPHER);
2112     }
2113
2114   tls->state++;
2115
2116   debug_msg (2, "<= parse change cipher spec");
2117
2118   return 0;
2119 }
2120
2121
2122 static void
2123 update_checksum_sha256 (ntbtls_t tls, const unsigned char *buf, size_t len)
2124 {
2125   gcry_md_write (tls->handshake->fin_sha256, buf, len);
2126 }
2127
2128
2129 static void
2130 update_checksum_sha384 (ntbtls_t tls, const unsigned char *buf, size_t len)
2131 {
2132   gcry_md_write (tls->handshake->fin_sha512, buf, len);
2133 }
2134
2135
2136 void
2137 _ntbtls_optimize_checksum (ntbtls_t tls, const ciphersuite_t suite)
2138 {
2139   if (_ntbtls_ciphersuite_get_mac (suite) == GCRY_MAC_HMAC_SHA384)
2140     tls->handshake->update_checksum = update_checksum_sha384;
2141   else if (_ntbtls_ciphersuite_get_mac (suite) != GCRY_MAC_HMAC_SHA384)
2142     tls->handshake->update_checksum = update_checksum_sha256;
2143   else
2144     {
2145       debug_bug ();
2146       return;
2147     }
2148 }
2149
2150
2151 static void
2152 update_checksum_start (ntbtls_t tls, const unsigned char *buf, size_t len)
2153 {
2154   gcry_md_write (tls->handshake->fin_sha256, buf, len);
2155   gcry_md_write (tls->handshake->fin_sha512, buf, len);
2156 }
2157
2158
2159
2160 static void
2161 calc_finished_tls (ntbtls_t tls, int is_sha384,
2162                    unsigned char *buf, int is_client)
2163 {
2164   gpg_error_t err;
2165   gcry_md_hd_t md;
2166   int len = 12;
2167   const char *sender;
2168   unsigned char padbuf[48];
2169   size_t hashlen = is_sha384? 48 : 32;
2170   session_t session;
2171   char *p;
2172
2173   session = tls->session_negotiate;
2174   if (!session)
2175     session = tls->session;
2176
2177   debug_msg (2, "=> calc finished tls sha%d", is_sha384? 384 : 256);
2178
2179   err = gcry_md_copy (&md, (is_sha384 ? tls->handshake->fin_sha512
2180                             /*     */ : tls->handshake->fin_sha256));
2181   if (err)
2182     {
2183       debug_ret (1, "calc_finished_tls", err);
2184       memset (buf, 0, len);
2185       return;
2186     }
2187
2188   /*
2189    * TLSv1.2:
2190    *   hash = PRF( master, finished_label,
2191    *               Hash( handshake ) )[0.11]
2192    */
2193   sender = is_client ? "client finished" : "server finished";
2194
2195   p = gcry_md_read (md, is_sha384? GCRY_MD_SHA384 : GCRY_MD_SHA256);
2196   if (p)
2197     memcpy (padbuf, p, hashlen);
2198   gcry_md_close (md);
2199   if (!p)
2200     {
2201       debug_bug ();
2202       memset (buf, 0, len);
2203       return;
2204     }
2205
2206   tls->handshake->tls_prf (session->master, 48, sender,
2207                            padbuf, hashlen, buf, len);
2208
2209   debug_buf (3, "calc finished result", buf, len);
2210
2211   wipememory (padbuf, hashlen);
2212
2213   debug_msg (2, "<= calc finished tls sha%d", is_sha384? 384 : 256);
2214 }
2215
2216
2217 static void
2218 calc_finished_tls_sha256 (ntbtls_t tls, unsigned char *buf, int is_client)
2219 {
2220   calc_finished_tls (tls, 0, buf, is_client);
2221 }
2222
2223 static void
2224 calc_finished_tls_sha384 (ntbtls_t tls, unsigned char *buf, int is_client)
2225 {
2226   calc_finished_tls (tls, 1, buf, is_client);
2227 }
2228
2229
2230 void
2231 _ntbtls_handshake_wrapup (ntbtls_t tls)
2232 {
2233   int resume = tls->handshake->resume;
2234
2235   debug_msg (3, "=> handshake wrapup");
2236
2237   /*
2238    * Free our handshake params
2239    */
2240   handshake_params_deinit (tls->handshake);
2241   free (tls->handshake);
2242   tls->handshake = NULL;
2243
2244   if (tls->renegotiation == TLS_RENEGOTIATION)
2245     {
2246       tls->renegotiation = TLS_RENEGOTIATION_DONE;
2247       tls->renego_records_seen = 0;
2248     }
2249
2250   /*
2251    * Switch in our now active transform context
2252    */
2253   if (tls->transform)
2254     {
2255       transform_deinit (tls->transform);
2256       free (tls->transform);
2257     }
2258   tls->transform = tls->transform_negotiate;
2259   tls->transform_negotiate = NULL;
2260
2261   if (tls->session)
2262     {
2263       session_deinit (tls->session);
2264       free (tls->session);
2265     }
2266   tls->session = tls->session_negotiate;
2267   tls->session_negotiate = NULL;
2268
2269   /*
2270    * Add cache entry
2271    */
2272   if (tls->f_set_cache && tls->session->length && !resume)
2273     {
2274       if (tls->f_set_cache (tls->p_set_cache, tls->session))
2275         debug_msg (1, "cache did not store session");
2276     }
2277
2278   tls->state++;
2279
2280   debug_msg (3, "<= handshake wrapup");
2281 }
2282
2283
2284 gpg_error_t
2285 _ntbtls_write_finished (ntbtls_t tls)
2286 {
2287   gpg_error_t err;
2288   int hashlen;
2289
2290   debug_msg (2, "=> write finished");
2291
2292   /*
2293    * Set the out_msg pointer to the correct location based on IV length
2294    */
2295   if (tls->minor_ver >= TLS_MINOR_VERSION_2)
2296     {
2297       tls->out_msg = (tls->out_iv
2298                       + tls->transform_negotiate->ivlen
2299                       - tls->transform_negotiate->fixed_ivlen);
2300     }
2301   else
2302     tls->out_msg = tls->out_iv;
2303
2304   tls->handshake->calc_finished (tls, tls->out_msg + 4, tls->is_client);
2305
2306   /* TODO TLS/1.2 Hash length is determined by cipher suite (Page 63)
2307      but all currently defined cipher suite keep it at 12.  */
2308   hashlen = 12;
2309
2310   tls->verify_data_len = hashlen;
2311   memcpy (tls->own_verify_data, tls->out_msg + 4, hashlen);
2312
2313   tls->out_msglen = 4 + hashlen;
2314   tls->out_msgtype = TLS_MSG_HANDSHAKE;
2315   tls->out_msg[0] = TLS_HS_FINISHED;
2316
2317   /*
2318    * In case of session resuming, invert the client and server
2319    * ChangeCipherSpec messages order.
2320    */
2321   if (tls->handshake->resume)
2322     {
2323       if (tls->is_client)
2324         tls->state = TLS_HANDSHAKE_WRAPUP;
2325       else
2326         tls->state = TLS_CLIENT_CHANGE_CIPHER_SPEC;
2327     }
2328   else
2329     tls->state++;
2330
2331   /*
2332    * Switch to our negotiated transform and session parameters for outbound
2333    * data.
2334    */
2335   debug_msg (3, "switching to new transform spec for outbound data");
2336   tls->transform_out = tls->transform_negotiate;
2337   tls->session_out = tls->session_negotiate;
2338   memset (tls->out_ctr, 0, 8);
2339
2340   err = _ntbtls_write_record (tls);
2341   if (err)
2342     {
2343       debug_ret (1, "write_record", err);
2344       return err;
2345     }
2346
2347   debug_msg (2, "<= write finished");
2348
2349   return 0;
2350 }
2351
2352
2353 gpg_error_t
2354 _ntbtls_parse_finished (ntbtls_t tls)
2355 {
2356   gpg_error_t err;
2357   unsigned int hashlen;
2358   unsigned char buf[36];
2359
2360   debug_msg (2, "=> parse finished");
2361
2362   tls->handshake->calc_finished (tls, buf, !tls->is_client);
2363
2364   /*
2365    * Switch to our negotiated transform and session parameters for inbound
2366    * data.
2367    */
2368   debug_msg (3, "switching to new transform spec for inbound data");
2369   tls->transform_in = tls->transform_negotiate;
2370   tls->session_in = tls->session_negotiate;
2371   memset (tls->in_ctr, 0, 8);
2372
2373   /*
2374    * Set the in_msg pointer to the correct location based on IV length
2375    */
2376   if (tls->minor_ver >= TLS_MINOR_VERSION_2)
2377     {
2378       tls->in_msg = (tls->in_iv
2379                      + tls->transform_negotiate->ivlen
2380                      - tls->transform_negotiate->fixed_ivlen);
2381     }
2382   else
2383     tls->in_msg = tls->in_iv;
2384
2385   err = _ntbtls_read_record (tls);
2386   if (err)
2387     {
2388       debug_ret (1, "read_record", err);
2389       return err;
2390     }
2391
2392   if (tls->in_msgtype != TLS_MSG_HANDSHAKE)
2393     {
2394       debug_msg (1, "bad finished message");
2395       return gpg_error (GPG_ERR_UNEXPECTED_MSG);
2396     }
2397
2398   /* TODO TLS/1.2 Hash length is determined by cipher suite (Page 63).  */
2399   hashlen = 12;
2400
2401   if (tls->in_msg[0] != TLS_HS_FINISHED || tls->in_hslen != 4 + hashlen)
2402     {
2403       debug_msg (1, "bad finished message");
2404       return gpg_error (GPG_ERR_BAD_HS_FINISHED);
2405     }
2406
2407   if (memcmpct (tls->in_msg + 4, buf, hashlen))
2408     {
2409       debug_msg (1, "bad finished message");
2410       debug_buf (2, "want", buf, hashlen);
2411       debug_buf (2, " got", tls->in_msg+4, hashlen);
2412       return gpg_error (GPG_ERR_BAD_HS_FINISHED);
2413     }
2414
2415   tls->verify_data_len = hashlen;
2416   memcpy (tls->peer_verify_data, buf, hashlen);
2417
2418   if (tls->handshake->resume)
2419     {
2420       if (tls->is_client)
2421         tls->state = TLS_CLIENT_CHANGE_CIPHER_SPEC;
2422       else
2423         tls->state = TLS_HANDSHAKE_WRAPUP;
2424     }
2425   else
2426     tls->state++;
2427
2428   debug_msg (2, "<= parse finished");
2429
2430   return 0;
2431 }
2432
2433
2434 static gpg_error_t
2435 transform_init (transform_t transform)
2436 {
2437   gpg_error_t err = 0;
2438
2439   //FIXME:
2440   /* cipher_init (&transform->cipher_ctx_enc); */
2441   /* cipher_init (&transform->cipher_ctx_dec); */
2442
2443   /* md_init (&transform->mac_ctx_enc); */
2444   /* md_init (&transform->mac_ctx_dec); */
2445   return err;
2446 }
2447
2448
2449 static void
2450 transform_deinit (transform_t transform)
2451 {
2452   if (!transform)
2453     return;
2454
2455   //FIXME:
2456   /* deflateEnd (&transform->ctx_deflate); */
2457   /* inflateEnd (&transform->ctx_inflate); */
2458
2459   /* cipher_free (&transform->cipher_ctx_enc); */
2460   /* cipher_free (&transform->cipher_ctx_dec); */
2461
2462   /* md_free (&transform->mac_ctx_enc); */
2463   /* md_free (&transform->mac_ctx_dec); */
2464
2465   wipememory (transform, sizeof *transform);
2466 }
2467
2468
2469 static gpg_error_t
2470 session_init (session_t session)
2471 {
2472   return 0;
2473 }
2474
2475
2476 static void
2477 session_deinit (session_t session)
2478 {
2479   if (!session)
2480     return;
2481
2482   if (session->peer_chain)
2483     _ntbtls_x509_release (session->peer_chain);
2484
2485   free (session->ticket);
2486   wipememory (session, sizeof *session);
2487 }
2488
2489
2490 static gpg_error_t
2491 handshake_params_init (handshake_params_t handshake)
2492 {
2493   gpg_error_t err;
2494
2495   err = gcry_md_open (&handshake->fin_sha256, GCRY_MD_SHA256, 0);
2496   if (err)
2497     return err;
2498
2499   err = gcry_md_open (&handshake->fin_sha512, GCRY_MD_SHA384, 0);
2500   if (err)
2501     {
2502       gcry_md_close (handshake->fin_sha256);
2503       handshake->fin_sha256 = NULL;
2504       return err;
2505     }
2506
2507   err = _ntbtls_dhm_new (&handshake->dhm_ctx);
2508   if (err)
2509     {
2510       gcry_md_close (handshake->fin_sha256);
2511       handshake->fin_sha256 = NULL;
2512       gcry_md_close (handshake->fin_sha512);
2513       handshake->fin_sha512 = NULL;
2514       return err;
2515     }
2516
2517   handshake->update_checksum = update_checksum_start;
2518   handshake->sig_alg = TLS_HASH_SHA1;
2519
2520
2521   //*FIXME:
2522   /* ecdh_init (&handshake->ecdh_ctx); */
2523   return 0;
2524 }
2525
2526
2527 static void
2528 handshake_params_deinit (handshake_params_t handshake)
2529 {
2530   if (!handshake)
2531     return;
2532
2533   _ntbtls_dhm_release (handshake->dhm_ctx);
2534   handshake->dhm_ctx = NULL;
2535
2536   //FIXME:
2537   /* ecdh_free (&handshake->ecdh_ctx); */
2538
2539   free (handshake->curves);
2540
2541   /* Free only the linked list wrapper, not the keys themselves since
2542      the belong to the SNI callback. */
2543   if (handshake->sni_key_cert)
2544     {
2545       //FIXME:
2546       /* ssl_key_cert *cur, *next; */
2547
2548       /* cur = handshake->sni_key_cert; */
2549       /* while (cur) */
2550       /*   { */
2551       /*     next = cur->next; */
2552       /*     free (cur); */
2553       /*     cur = next; */
2554       /*   } */
2555     }
2556
2557   wipememory (handshake, sizeof *handshake);
2558 }
2559
2560
2561 static gpg_error_t
2562 handshake_init (ntbtls_t tls)
2563 {
2564   gpg_error_t err;
2565
2566   /* Clear old handshake information if present.  */
2567   transform_deinit (tls->transform_negotiate);
2568   session_deinit (tls->session_negotiate);
2569   handshake_params_deinit (tls->handshake);
2570
2571   /*
2572    * Either the pointers are now NULL or cleared properly and can be freed.
2573    * Now allocate missing structures.
2574    */
2575   if (!tls->transform_negotiate)
2576     {
2577       tls->transform_negotiate = calloc (1, sizeof *tls->transform_negotiate);
2578       if (!tls->transform_negotiate)
2579         {
2580           err = gpg_error_from_syserror ();
2581           goto leave;
2582         }
2583     }
2584   if (!tls->session_negotiate)
2585     {
2586       tls->session_negotiate = calloc (1, sizeof *tls->session_negotiate);
2587       if (!tls->session_negotiate)
2588         {
2589           err = gpg_error_from_syserror ();
2590           goto leave;
2591         }
2592     }
2593   if (!tls->handshake)
2594     {
2595       tls->handshake = calloc (1, sizeof *tls->handshake);
2596       if (!tls->handshake)
2597         {
2598           err = gpg_error_from_syserror ();
2599           goto leave;
2600         }
2601     }
2602
2603   /* Initialize structures */
2604   err = transform_init (tls->transform_negotiate);
2605   if (err)
2606     goto leave;
2607   err = session_init (tls->session_negotiate);
2608   if (err)
2609     goto leave;
2610   err = handshake_params_init (tls->handshake);
2611   if (err)
2612     goto leave;
2613
2614   /* Fixme: Document the owner of KEY_CERT or use a ref counter.  */
2615   tls->handshake->key_cert = tls->key_cert;
2616
2617  leave:
2618   if (err)
2619     {
2620       transform_deinit (tls->transform_negotiate);
2621       free (tls->transform_negotiate);
2622       tls->transform_negotiate = NULL;
2623
2624       session_deinit (tls->session_negotiate);
2625       free (tls->session_negotiate);
2626       tls->session_negotiate = NULL;
2627
2628       handshake_params_deinit (tls->handshake);
2629       free (tls->handshake);
2630       tls->handshake = NULL;
2631     }
2632   return err;
2633 }
2634
2635
2636 /*
2637  * Create a new TLS context.  Valid values for FLAGS are:
2638  *
2639  *   NTBTLS_SERVER  - This endpoint is a server (default).
2640  *   NTBTLS_CLIENT  - This endpoint is a client.
2641  *
2642  * On success a context object is returned at R_TLS.  One error NULL
2643  * is stored at R_TLS and an error code is returned.
2644  */
2645 gpg_error_t
2646 _ntbtls_new (ntbtls_t *r_tls, unsigned int flags)
2647 {
2648   gpg_error_t err;
2649   ntbtls_t tls;
2650   int buffer_len = TLS_BUFFER_LEN;
2651
2652   *r_tls = NULL;
2653
2654   /* Note: NTBTLS_SERVER has value 0, thus we can't check for it. */
2655   if ((flags & ~(NTBTLS_CLIENT)))
2656     return gpg_error (GPG_ERR_EINVAL);
2657
2658   tls = calloc (1, sizeof *tls);
2659   if (!tls)
2660     return gpg_error_from_syserror ();  /* Return immediately.  */
2661
2662   tls->min_major_ver = TLS_MIN_MAJOR_VERSION;
2663   tls->min_minor_ver = TLS_MIN_MINOR_VERSION;
2664   tls->max_major_ver = TLS_MAX_MAJOR_VERSION;
2665   tls->max_minor_ver = TLS_MAX_MINOR_VERSION;
2666
2667   if ((flags & NTBTLS_CLIENT))
2668     {
2669       tls->is_client = 1;
2670       tls->use_session_tickets = 1;
2671     }
2672
2673   /* We only support TLS 1.2 and thus we set the list for the other
2674      TLS versions to NULL.  */
2675   tls->ciphersuite_list[TLS_MINOR_VERSION_0] = NULL;
2676   tls->ciphersuite_list[TLS_MINOR_VERSION_1] = NULL;
2677   tls->ciphersuite_list[TLS_MINOR_VERSION_2] = NULL;
2678   tls->ciphersuite_list[TLS_MINOR_VERSION_3] = _ntbtls_ciphersuite_list ();
2679
2680
2681   tls->renego_max_records = TLS_RENEGO_MAX_RECORDS_DEFAULT;
2682
2683   /* FIXME */
2684   /* if ((ret = mpi_read_string (&tls->dhm_P, 16, */
2685   /*                             POLARSSL_DHM_RFC5114_MODP_1024_P)) != 0 || */
2686   /*     (ret = mpi_read_string (&tls->dhm_G, 16, */
2687   /*                             POLARSSL_DHM_RFC5114_MODP_1024_G)) != 0) */
2688   /*   { */
2689   /*     debug_ret (1, "mpi_read_string", ret); */
2690   /*     return (ret); */
2691   /*   } */
2692
2693   /*
2694    * Prepare base structures
2695    */
2696   tls->in_ctr = malloc (buffer_len);
2697   if (!tls->in_ctr)
2698     {
2699       err = gpg_error_from_syserror ();
2700       goto leave;
2701     }
2702   tls->in_hdr = tls->in_ctr + 8;
2703   tls->in_iv  = tls->in_ctr + 13;
2704   tls->in_msg = tls->in_ctr + 13;
2705
2706   tls->out_ctr = malloc (buffer_len);
2707   if (!tls->out_ctr)
2708     {
2709       err = gpg_error_from_syserror ();
2710       goto leave;
2711     }
2712   tls->out_hdr = tls->out_ctr + 8;
2713   tls->out_iv  = tls->out_ctr + 13;
2714   tls->out_msg = tls->out_ctr + 13;
2715
2716   memset (tls->in_ctr, 0, buffer_len);
2717   memset (tls->out_ctr, 0, buffer_len);
2718
2719   tls->ticket_lifetime = TLS_DEFAULT_TICKET_LIFETIME;
2720
2721   // FIXME: tls->curve_list = ecp_grp_id_list ();
2722
2723   err = handshake_init (tls);
2724   if (err)
2725     goto leave;
2726
2727   if (tls->is_client)
2728     tls->use_session_tickets = 1;
2729
2730
2731  leave:
2732   if (err)
2733     {
2734       free (tls->in_ctr);
2735       free (tls);
2736     }
2737   else
2738     *r_tls = tls;
2739   return err;
2740 }
2741
2742
2743 /*
2744  * Release an TLS context.
2745  */
2746 void
2747 _ntbtls_release (ntbtls_t tls)
2748 {
2749   if (!tls)
2750     return;
2751
2752   debug_msg (2, "=> release");
2753
2754   if (tls->out_ctr)
2755     {
2756       /* FIXME: At some points we are using a variable for the length.
2757          Either do that always or use always this constant. */
2758       wipememory (tls->out_ctr, TLS_BUFFER_LEN);
2759       free (tls->out_ctr);
2760     }
2761
2762   if (tls->in_ctr)
2763     {
2764       wipememory (tls->in_ctr, TLS_BUFFER_LEN);
2765       free (tls->in_ctr);
2766     }
2767
2768   if (tls->compress_buf)
2769     {
2770       wipememory (tls->compress_buf, TLS_BUFFER_LEN);
2771       free (tls->compress_buf);
2772     }
2773
2774   //FIXME:
2775   /* mpi_free (&tls->dhm_P); */
2776   /* mpi_free (&tls->dhm_G); */
2777
2778   if (tls->transform)
2779     {
2780       transform_deinit (tls->transform);
2781       free (tls->transform);
2782     }
2783
2784   if (tls->handshake)
2785     {
2786       handshake_params_deinit (tls->handshake);
2787       free (tls->handshake);
2788       transform_deinit (tls->transform_negotiate);
2789       free (tls->transform_negotiate);
2790       session_deinit (tls->session_negotiate);
2791       free (tls->session_negotiate);
2792     }
2793
2794   if (tls->session)
2795     {
2796       session_deinit (tls->session);
2797       free (tls->session);
2798     }
2799
2800   if (tls->ticket_keys)
2801     {
2802       ticket_keys_deinit (tls->ticket_keys);
2803       free (tls->ticket_keys);
2804     }
2805
2806   if (tls->hostname)
2807     {
2808       wipememory (tls->hostname, tls->hostname_len);
2809       free (tls->hostname);
2810       tls->hostname_len = 0;
2811     }
2812
2813   if (tls->psk)
2814     {
2815       wipememory (tls->psk, tls->psk_len);
2816       wipememory (tls->psk_identity, tls->psk_identity_len);
2817       free (tls->psk);
2818       free (tls->psk_identity);
2819       tls->psk_len = 0;
2820       tls->psk_identity_len = 0;
2821     }
2822
2823   //FIXME:
2824   /* ssl_key_cert_free (tls->key_cert); */
2825
2826   debug_msg (2, "<= release");
2827
2828   /* Actually clear after last debug message */
2829   wipememory (tls, sizeof *tls);
2830   free (tls);
2831 }
2832
2833
2834 /* Set the transport stream for the context TLS.  This needs to be
2835    called right after init and may not be changed later.  INBOUND and
2836    OUTBOIUND are usually connected to the same socket.  The caller
2837    must ensure that the streams are not closed as long as the context
2838    TLS is valid.  However, after destroying the context the streams
2839    may be closed.  This behavior allows to setup a TLS connection on
2840    an existing stream, shutdown the TLS and continue unencrypted.
2841    Whether the latter is of any real use in practice is a different
2842    question.  Using separate streams allow to run TLS over a pair of
2843    half-duplex connections.  */
2844 gpg_error_t
2845 _ntbtls_set_transport (ntbtls_t tls, estream_t inbound, estream_t outbound)
2846 {
2847   if (!tls || !inbound || !outbound)
2848     return gpg_error (GPG_ERR_INV_ARG);
2849   if (tls->inbound || tls->outbound)
2850     return gpg_error (GPG_ERR_CONFLICT);
2851
2852   /* fixme: Instead of calling a flush we set the stream to nowbug for
2853      now.  This makes debugging easier.  */
2854   if (es_setvbuf (inbound, NULL, _IONBF, 0))
2855     return gpg_error_from_syserror ();
2856   if (es_setvbuf (outbound, NULL, _IONBF, 0))
2857     return gpg_error_from_syserror ();
2858
2859   tls->inbound = inbound;
2860   tls->outbound = outbound;
2861   return 0;
2862 }
2863
2864
2865 /* Return the two streams used to read and write the plaintext.  the
2866    streams are valid as along as TLS is valid and may thus not be used
2867    after TLS has been destroyed.  */
2868 gpg_error_t
2869 _ntbtls_get_stream (ntbtls_t tls, estream_t *r_readfp, estream_t *r_writefp)
2870 {
2871   //FIXME
2872
2873 }
2874
2875
2876
2877 /*
2878  * Reset an initialized and used SSL context for re-use while retaining
2879  * all application-set variables, function pointers and data.
2880  */
2881 int
2882 ssl_session_reset (ntbtls_t ssl)
2883 {
2884   int ret;
2885
2886   ssl->state = TLS_HELLO_REQUEST;
2887   ssl->renegotiation = TLS_INITIAL_HANDSHAKE;
2888   ssl->secure_renegotiation = TLS_LEGACY_RENEGOTIATION;
2889
2890   ssl->verify_data_len = 0;
2891   memset (ssl->own_verify_data, 0, 36);
2892   memset (ssl->peer_verify_data, 0, 36);
2893
2894   ssl->in_offt = NULL;
2895
2896   ssl->in_msg = ssl->in_ctr + 13;
2897   ssl->in_msgtype = 0;
2898   ssl->in_msglen = 0;
2899   ssl->in_left = 0;
2900
2901   ssl->in_hslen = 0;
2902   ssl->nb_zero = 0;
2903   ssl->record_read = 0;
2904
2905   ssl->out_msg = ssl->out_ctr + 13;
2906   ssl->out_msgtype = 0;
2907   ssl->out_msglen = 0;
2908   ssl->out_left = 0;
2909
2910   ssl->transform_in = NULL;
2911   ssl->transform_out = NULL;
2912
2913   ssl->renego_records_seen = 0;
2914
2915   memset (ssl->out_ctr, 0, TLS_BUFFER_LEN);
2916   memset (ssl->in_ctr, 0, TLS_BUFFER_LEN);
2917
2918   if (ssl->transform)
2919     {
2920       transform_deinit (ssl->transform);
2921       free (ssl->transform);
2922       ssl->transform = NULL;
2923     }
2924
2925   if (ssl->session)
2926     {
2927       session_deinit (ssl->session);
2928       free (ssl->session);
2929       ssl->session = NULL;
2930     }
2931
2932   ssl->alpn_chosen = NULL;
2933
2934   if ((ret = handshake_init (ssl)) != 0)
2935     return (ret);
2936
2937   return (0);
2938 }
2939
2940
2941 static void
2942 ticket_keys_deinit (ticket_keys_t tkeys)
2943 {
2944   //FIXME:
2945   /* aes_free (&tkeys->enc); */
2946   /* aes_free (&tkeys->dec); */
2947
2948   wipememory (tkeys, sizeof *tkeys);
2949 }
2950
2951
2952 /*
2953  * Allocate and initialize ticket keys in TLS if not yet done.
2954  */
2955 static gpg_error_t
2956 ticket_keys_setup (ntbtls_t tls)
2957 {
2958   ticket_keys_t tkeys;
2959   unsigned char buf[16];
2960
2961   if (tls->ticket_keys)
2962     return 0;
2963
2964   tkeys = malloc (sizeof *tkeys);
2965   if (!tkeys)
2966     return gpg_error_from_syserror ();
2967
2968   //FIXME:
2969   /* aes_init (&tkeys->enc); */
2970   /* aes_init (&tkeys->dec); */
2971
2972   gcry_randomize (tkeys->key_name, 16, GCRY_STRONG_RANDOM);
2973   gcry_randomize (buf, 16, GCRY_STRONG_RANDOM);
2974
2975   //FIXME:
2976   /* if ((ret = aes_setkey_enc (&tkeys->enc, buf, 128)) != 0 || */
2977   /*     (ret = aes_setkey_dec (&tkeys->dec, buf, 128)) != 0) */
2978   /*   { */
2979   /*     ssl_ticket_keys_free (tkeys); */
2980   /*     polarssl_free (tkeys); */
2981   /*     return (ret); */
2982   /*   } */
2983
2984   gcry_randomize (tkeys->mac_key, 16, GCRY_STRONG_RANDOM);
2985
2986   tls->ticket_keys = tkeys;
2987
2988   return 0;
2989 }
2990
2991
2992 /*
2993  * SSL set accessors
2994  */
2995
2996 void
2997 ssl_set_authmode (ntbtls_t ssl, int authmode)
2998 {
2999   ssl->authmode = authmode;
3000 }
3001
3002 #if defined(POLARSSL_X509_CRT_PARSE_C)
3003 void
3004 ssl_set_verify (ntbtls_t ssl,
3005                 int (*f_vrfy) (void *, x509_crt *, int, int *), void *p_vrfy)
3006 {
3007   ssl->f_vrfy = f_vrfy;
3008   ssl->p_vrfy = p_vrfy;
3009 }
3010 #endif /* POLARSSL_X509_CRT_PARSE_C */
3011
3012
3013 void
3014 ssl_set_session_cache (ntbtls_t ssl,
3015                        int (*f_get_cache) (void *, session_t),
3016                        void *p_get_cache, int (*f_set_cache) (void *,
3017                                                               const
3018                                                               session_t),
3019                        void *p_set_cache)
3020 {
3021   ssl->f_get_cache = f_get_cache;
3022   ssl->p_get_cache = p_get_cache;
3023   ssl->f_set_cache = f_set_cache;
3024   ssl->p_set_cache = p_set_cache;
3025 }
3026
3027
3028 /* Request resumption of session (client-side only).
3029    Session data is copied from presented session structure. */
3030 gpg_error_t
3031 _ntbtls_set_session (ntbtls_t tls, const session_t session)
3032 {
3033   gpg_error_t err;
3034
3035   if (!tls || !session || !tls->session_negotiate || !tls->is_client)
3036     return gpg_error (GPG_ERR_INV_ARG);
3037
3038   err = session_copy (tls->session_negotiate, session);
3039   if (err)
3040     return err;
3041
3042   tls->handshake->resume = 1;
3043
3044   return 0;
3045 }
3046
3047
3048
3049 /* Add a new (empty) key_cert entry an return a pointer to it */
3050 /* static ssl_key_cert * */
3051 /* ssl_add_key_cert (ntbtls_t ssl) */
3052 /* { */
3053 /*   ssl_key_cert *key_cert, *last; */
3054
3055 /*   key_cert = calloc (1, sizeof *key_cert); */
3056 /*   if (!key_cert) */
3057 /*     return NULL; */
3058
3059 /*   /\* Append the new key_cert to the (possibly empty) current list *\/ */
3060 /*   if (ssl->key_cert == NULL) */
3061 /*     { */
3062 /*       ssl->key_cert = key_cert; */
3063 /*       if (ssl->handshake != NULL) */
3064 /*         ssl->handshake->key_cert = key_cert; */
3065 /*     } */
3066 /*   else */
3067 /*     { */
3068 /*       last = ssl->key_cert; */
3069 /*       while (last->next != NULL) */
3070 /*         last = last->next; */
3071 /*       last->next = key_cert; */
3072 /*     } */
3073
3074 /*   return (key_cert); */
3075 /* } */
3076
3077
3078 /* void */
3079 /* ssl_set_ca_chain (ntbtls_t ssl, x509_crt * ca_chain, */
3080 /*                   x509_crl_t ca_crl, const char *peer_cn) */
3081 /* { */
3082 /*   ssl->ca_chain = ca_chain; */
3083 /*   ssl->ca_crl = ca_crl; */
3084 /*   ssl->peer_cn = peer_cn; */
3085 /* } */
3086
3087
3088 /* int */
3089 /* ssl_set_own_cert (ntbtls_t ssl, x509_crt * own_cert, pk_context * pk_key) */
3090 /* { */
3091 /*   ssl_key_cert *key_cert; */
3092
3093 /*   key_cert = ssl_add_key_cert (ssl); */
3094 /*   if (!key_cert) */
3095 /*     return gpg_error_from_syserror (); */
3096
3097 /*   key_cert->cert = own_cert; */
3098 /*   key_cert->key = pk_key; */
3099
3100 /*   return 0; */
3101 /* } */
3102
3103
3104 /* int */
3105 /* ssl_set_own_cert_rsa (ntbtls_t ssl, x509_crt * own_cert, */
3106 /*                       rsa_context * rsa_key) */
3107 /* { */
3108 /*   int ret; */
3109 /*   ssl_key_cert *key_cert; */
3110
3111
3112 /*   key_cert = ssl_add_key_cert (ssl); */
3113 /*   if (!key_cert) */
3114 /*     return gpg_error_from_syserror (); */
3115
3116 /*   key_cert->key = malloc (sizeof (pk_context)); */
3117 /*   if (!key_cert->key) */
3118 /*     return gpg_error_from_syserror (); */
3119
3120 /*   pk_init (key_cert->key); */
3121
3122 /*   ret = pk_init_ctx (key_cert->key, pk_info_from_type (POLARSSL_PK_RSA)); */
3123 /*   if (ret != 0) */
3124 /*     return (ret); */
3125
3126 /*   if ((ret = rsa_copy (pk_rsa (*key_cert->key), rsa_key)) != 0) */
3127 /*     return (ret); */
3128
3129 /*   key_cert->cert = own_cert; */
3130 /*   key_cert->key_own_alloc = 1; */
3131
3132 /*   return (0); */
3133 /* } */
3134
3135
3136 /* int */
3137 /* ssl_set_own_cert_alt (ntbtls_t ssl, x509_crt * own_cert, */
3138 /*                       void *rsa_key, */
3139 /*                       rsa_decrypt_func rsa_decrypt, */
3140 /*                       rsa_sign_func rsa_sign, rsa_key_len_func rsa_key_len) */
3141 /* { */
3142 /*   int ret; */
3143 /*   ssl_key_cert *key_cert; */
3144
3145 /*   key_cert = ssl_add_key_cert (ssl); */
3146 /*   if (!key_cert) */
3147 /*     return gpg_error_from_syserror (); */
3148
3149 /*   key_cert->key = malloc (sizeof (pk_context)); */
3150 /*   if (!key_cert->key) */
3151 /*     { */
3152 /*       err = gpg_error_from_syserror (); */
3153 /*       free (key_cert); */
3154 /*       return err; */
3155 /*     } */
3156
3157 /*   pk_init (key_cert->key); */
3158
3159 /*   if ((ret = pk_init_ctx_rsa_alt (key_cert->key, rsa_key, */
3160 /*                                   rsa_decrypt, rsa_sign, rsa_key_len)) != 0) */
3161 /*     return (ret); */
3162
3163 /*   key_cert->cert = own_cert; */
3164 /*   key_cert->key_own_alloc = 1; */
3165
3166 /*   return 0; */
3167 /* } */
3168
3169
3170 /* int */
3171 /* ssl_set_psk (ntbtls_t ssl, const unsigned char *psk, size_t psk_len, */
3172 /*              const unsigned char *psk_identity, size_t psk_identity_len) */
3173 /* { */
3174 /*   if (psk == NULL || psk_identity == NULL) */
3175 /*     return gpg_error (GPG_ERR_INV_ARG); */
3176
3177 /*   if (psk_len > POLARSSL_PSK_MAX_LEN) */
3178 /*     return gpg_error (GPG_ERR_INV_ARG); */
3179
3180 /*   if (ssl->psk != NULL) */
3181 /*     { */
3182 /*       free (ssl->psk); */
3183 /*       ssl->psk = NULL; */
3184 /*       free (ssl->psk_identity); */
3185 /*       ssl->psk_identity = NULL; */
3186 /*     } */
3187
3188 /*   ssl->psk_len = psk_len; */
3189 /*   ssl->psk_identity_len = psk_identity_len; */
3190
3191 /*   ssl->psk = malloc (ssl->psk_len); */
3192 /*   if (!ssl->psk) */
3193 /*     return gpg_error_from_syserror (); */
3194
3195 /*   ssl->psk_identity = malloc (ssl->psk_identity_len); */
3196 /*   if (!ssl->psk_identity) */
3197 /*     { */
3198 /*       err = gpg_error_from_syserror (); */
3199 /*       free (ssl->psk); */
3200 /*       ssl->psk = NULL; */
3201 /*       return err; */
3202 /*     } */
3203
3204 /*   memcpy (ssl->psk, psk, ssl->psk_len); */
3205 /*   memcpy (ssl->psk_identity, psk_identity, ssl->psk_identity_len); */
3206
3207 /*   return (0); */
3208 /* } */
3209
3210 /* void */
3211 /* ssl_set_psk_cb (ntbtls_t ssl, */
3212 /*                 int (*f_psk) (void *, ssl_context *, const unsigned char *, */
3213 /*                               size_t), void *p_psk) */
3214 /* { */
3215 /*   ssl->f_psk = f_psk; */
3216 /*   ssl->p_psk = p_psk; */
3217 /* } */
3218
3219
3220 /* int */
3221 /* ssl_set_dh_param (ntbtls_t ssl, const char *dhm_P, const char *dhm_G) */
3222 /* { */
3223 /*   int ret; */
3224
3225 /*   if ((ret = mpi_read_string (&ssl->dhm_P, 16, dhm_P)) != 0) */
3226 /*     { */
3227 /*       debug_ret (1, "mpi_read_string", ret); */
3228 /*       return (ret); */
3229 /*     } */
3230
3231 /*   if ((ret = mpi_read_string (&ssl->dhm_G, 16, dhm_G)) != 0) */
3232 /*     { */
3233 /*       debug_ret (1, "mpi_read_string", ret); */
3234 /*       return (ret); */
3235 /*     } */
3236
3237 /*   return (0); */
3238 /* } */
3239
3240 /* int */
3241 /* ssl_set_dh_param_ctx (ntbtls_t ssl, dhm_context * dhm_ctx) */
3242 /* { */
3243 /*   int ret; */
3244
3245 /*   if ((ret = mpi_copy (&ssl->dhm_P, &dhm_ctx->P)) != 0) */
3246 /*     { */
3247 /*       debug_ret (1, "mpi_copy", ret); */
3248 /*       return (ret); */
3249 /*     } */
3250
3251 /*   if ((ret = mpi_copy (&ssl->dhm_G, &dhm_ctx->G)) != 0) */
3252 /*     { */
3253 /*       debug_ret (1, "mpi_copy", ret); */
3254 /*       return (ret); */
3255 /*     } */
3256
3257 /*   return (0); */
3258 /* } */
3259
3260
3261 /*
3262  * Set the allowed elliptic curves
3263  */
3264 /* void */
3265 /* ssl_set_curves (ntbtls_t ssl, const ecp_group_id * curve_list) */
3266 /* { */
3267 /*   ssl->curve_list = curve_list; */
3268 /* } */
3269
3270
3271 /* int */
3272 /* ssl_set_hostname (ntbtls_t ssl, const char *hostname) */
3273 /* { */
3274 /*   if (hostname == NULL) */
3275 /*     return gpg_error (GPG_ERR_INV_ARG); */
3276
3277 /*   ssl->hostname_len = strlen (hostname); */
3278
3279 /*   if (ssl->hostname_len + 1 == 0) */
3280 /*     return gpg_error (GPG_ERR_INV_ARG); */
3281
3282 /*   ssl->hostname = malloc (ssl->hostname_len + 1); */
3283 /*   if (!ssl->hostname) */
3284 /*     return gpg_error_from_syserror (); */
3285
3286 /*   memcpy (ssl->hostname, hostname, ssl->hostname_len); */
3287 /*   ssl->hostname[ssl->hostname_len] = '\0'; */
3288
3289 /*   return 0; */
3290 /* } */
3291
3292
3293 /* void */
3294 /* ssl_set_sni (ntbtls_t ssl, */
3295 /*              int (*f_sni) (void *, ntbtls_t, */
3296 /*                            const unsigned char *, size_t), void *p_sni) */
3297 /* { */
3298 /*   ssl->f_sni = f_sni; */
3299 /*   ssl->p_sni = p_sni; */
3300 /* } */
3301
3302
3303 /* int */
3304 /* ssl_set_alpn_protocols (ntbtls_t ssl, const char **protos) */
3305 /* { */
3306 /*   size_t cur_len, tot_len; */
3307 /*   const char **p; */
3308
3309 /*   /\* */
3310 /*    * "Empty strings MUST NOT be included and byte strings MUST NOT be */
3311 /*    * truncated". Check lengths now rather than later. */
3312 /*    *\/ */
3313 /*   tot_len = 0; */
3314 /*   for (p = protos; *p != NULL; p++) */
3315 /*     { */
3316 /*       cur_len = strlen (*p); */
3317 /*       tot_len += cur_len; */
3318
3319 /*       if (cur_len == 0 || cur_len > 255 || tot_len > 65535) */
3320 /*         return gpg_error (GPG_ERR_INV_ARG); */
3321 /*     } */
3322
3323 /*   ssl->alpn_list = protos; */
3324
3325 /*   return (0); */
3326 /* } */
3327
3328 /* const char * */
3329 /* ssl_get_alpn_protocol (const ntbtls_t ssl) */
3330 /* { */
3331 /*   return (ssl->alpn_chosen); */
3332 /* } */
3333
3334
3335 /* void */
3336 /* ssl_set_max_version (ntbtls_t ssl, int major, int minor) */
3337 /* { */
3338 /*   if (   major >= TLS_MIN_MAJOR_VERSION && major <= TLS_MAX_MAJOR_VERSION */
3339 /*       && minor >= TLS_MIN_MINOR_VERSION && minor <= TLS_MAX_MINOR_VERSION) */
3340 /*     { */
3341 /*       ssl->max_major_ver = major; */
3342 /*       ssl->max_minor_ver = minor; */
3343 /*     } */
3344 /* } */
3345
3346
3347 /* void */
3348 /* ssl_set_min_version (ntbtls_t ssl, int major, int minor) */
3349 /* { */
3350 /*   if (   major >= TLS_MIN_MAJOR_VERSION && major <= TLS_MAX_MAJOR_VERSION */
3351 /*       && minor >= TLS_MIN_MINOR_VERSION && minor <= TLS_MAX_MINOR_VERSION) */
3352 /*     { */
3353 /*       ssl->min_major_ver = major; */
3354 /*       ssl->min_minor_ver = minor; */
3355 /*     } */
3356 /* } */
3357
3358
3359 int
3360 ssl_set_max_frag_len (ntbtls_t ssl, unsigned char mfl_code)
3361 {
3362   if (mfl_code >= DIM(mfl_code_to_length)
3363       || mfl_code_to_length[mfl_code] > TLS_MAX_CONTENT_LEN)
3364     {
3365       return gpg_error (GPG_ERR_INV_ARG);
3366     }
3367
3368   ssl->mfl_code = mfl_code;
3369
3370   return (0);
3371 }
3372
3373
3374 int
3375 ssl_set_truncated_hmac (ntbtls_t ssl, int truncate)
3376 {
3377   if (!ssl->is_client)
3378     return gpg_error (GPG_ERR_INV_ARG);
3379
3380   ssl->use_trunc_hmac = !!truncate;
3381
3382   return 0;
3383 }
3384
3385
3386 void
3387 ssl_set_renegotiation (ntbtls_t ssl, int renegotiation)
3388 {
3389   ssl->disable_renegotiation = renegotiation;
3390 }
3391
3392 void
3393 ssl_legacy_renegotiation (ntbtls_t ssl, int allow_legacy)
3394 {
3395   ssl->allow_legacy_renegotiation = allow_legacy;
3396 }
3397
3398 void
3399 ssl_set_renegotiation_enforced (ntbtls_t ssl, int max_records)
3400 {
3401   ssl->renego_max_records = max_records;
3402 }
3403
3404
3405 int
3406 _ntbtls_set_session_tickets (ntbtls_t tls, int use_tickets)
3407 {
3408   tls->use_session_tickets = !!use_tickets;
3409
3410   if (tls->is_client)
3411     return 0;
3412
3413   return ticket_keys_setup (tls);
3414 }
3415
3416 void
3417 ssl_set_session_ticket_lifetime (ntbtls_t ssl, int lifetime)
3418 {
3419   ssl->ticket_lifetime = lifetime;
3420 }
3421
3422
3423 /*
3424  * SSL get accessors
3425  */
3426 size_t
3427 ssl_get_bytes_avail (const ntbtls_t ssl)
3428 {
3429   return (ssl->in_offt == NULL ? 0 : ssl->in_msglen);
3430 }
3431
3432 int
3433 ssl_get_verify_result (const ntbtls_t ssl)
3434 {
3435   return (ssl->session->verify_result);
3436 }
3437
3438
3439 /*
3440  * Return the name of the current ciphersuite
3441  */
3442 const char *
3443 _ntbtls_get_ciphersuite (const ntbtls_t tls)
3444 {
3445   if (!tls || !tls->session)
3446     return NULL;
3447
3448   return _ntbtls_ciphersuite_get_name (tls->session->ciphersuite);
3449 }
3450
3451
3452 /* const x509_crt * */
3453 /* ssl_get_peer_chain (const ntbtls_t ssl) */
3454 /* { */
3455 /*   if (ssl == NULL || ssl->session == NULL) */
3456 /*     return (NULL); */
3457
3458 /*   return (ssl->session->peer_chain); */
3459 /* } */
3460
3461
3462 /* Save session in order to resume it later (client-side only).
3463    Session data is copied to presented session structure.  */
3464 gpg_error_t
3465 _ntbtls_get_session (const ntbtls_t tls, session_t dst)
3466 {
3467   if (!tls || !dst || !tls->session || !tls->is_client)
3468     {
3469       return gpg_error (GPG_ERR_INV_ARG);
3470     }
3471
3472   return session_copy (dst, tls->session);
3473 }
3474
3475
3476 /*
3477  * Perform a single step of the SSL handshake
3478  */
3479 static gpg_error_t
3480 handshake_step (ntbtls_t tls)
3481 {
3482   gpg_error_t err;
3483
3484   if (tls->is_client)
3485     err = _ntbtls_handshake_client_step (tls);
3486   else
3487     err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3488           /*_ntbtls_handshake_server_step (tls);*/
3489
3490   return err;
3491 }
3492
3493
3494 /*
3495  * Perform the SSL handshake
3496  */
3497 gpg_error_t
3498 _ntbtls_handshake (ntbtls_t tls)
3499 {
3500   gpg_error_t err = 0;
3501
3502   debug_msg (2, "=> handshake");
3503
3504   while (tls->state != TLS_HANDSHAKE_OVER)
3505     {
3506       err = handshake_step (tls);
3507       if (err)
3508         break;
3509     }
3510
3511   debug_msg (2, "<= handshake");
3512
3513   return err;
3514 }
3515
3516
3517 /*
3518  * Write HelloRequest to request renegotiation on server
3519  */
3520 static int
3521 ssl_write_hello_request (ntbtls_t ssl)
3522 {
3523   int ret;
3524
3525   debug_msg (2, "=> write hello request");
3526
3527   ssl->out_msglen = 4;
3528   ssl->out_msgtype = TLS_MSG_HANDSHAKE;
3529   ssl->out_msg[0] = TLS_HS_HELLO_REQUEST;
3530
3531   ret = _ntbtls_write_record (ssl);
3532   if (ret)
3533     {
3534       debug_ret (1, "write_record", ret);
3535       return ret;
3536     }
3537
3538   ssl->renegotiation = TLS_RENEGOTIATION_PENDING;
3539
3540   debug_msg (2, "<= write hello request");
3541
3542   return (0);
3543 }
3544
3545
3546 /*
3547  * Actually renegotiate current connection, triggered by either:
3548  * - calling ssl_renegotiate() on client,
3549  * - receiving a HelloRequest on client during ssl_read(),
3550  * - receiving any handshake message on server during ssl_read() after the
3551  *   initial handshake is completed
3552  * If the handshake doesn't complete due to waiting for I/O, it will continue
3553  * during the next calls to ssl_renegotiate() or ssl_read() respectively.
3554  */
3555 static gpg_error_t
3556 start_renegotiation (ntbtls_t tls)
3557 {
3558   gpg_error_t err;
3559
3560   debug_msg (2, "=> renegotiate");
3561
3562   err = handshake_init (tls);
3563   if (err)
3564     return err;
3565
3566   tls->state = TLS_HELLO_REQUEST;
3567   tls->renegotiation = TLS_RENEGOTIATION;
3568
3569   err = _ntbtls_handshake (tls);
3570   if (err)
3571     {
3572       debug_ret (1, "handshake", err);
3573       return err;
3574     }
3575
3576   debug_msg (2, "<= renegotiate");
3577
3578   return 0;
3579 }
3580
3581
3582 /*
3583  * Renegotiate current connection on client,
3584  * or request renegotiation on server
3585  */
3586 int
3587 ssl_renegotiate (ntbtls_t ssl)
3588 {
3589   int ret = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3590
3591   /* On server, just send the request */
3592   if (!ssl->is_client)
3593     {
3594       if (ssl->state != TLS_HANDSHAKE_OVER)
3595         return gpg_error (GPG_ERR_INV_ARG);
3596
3597       return (ssl_write_hello_request (ssl));
3598     }
3599
3600   /*
3601    * On client, either start the renegotiation process or,
3602    * if already in progress, continue the handshake
3603    */
3604   if (ssl->renegotiation != TLS_RENEGOTIATION)
3605     {
3606       if (ssl->state != TLS_HANDSHAKE_OVER)
3607         return gpg_error (GPG_ERR_INV_ARG);
3608
3609       if ((ret = start_renegotiation (ssl)) != 0)
3610         {
3611           debug_ret (1, "start_renegotiation", ret);
3612           return (ret);
3613         }
3614     }
3615   else
3616     {
3617       if ((ret = _ntbtls_handshake (ssl)) != 0)
3618         {
3619           debug_ret (1, "handshake", ret);
3620           return (ret);
3621         }
3622     }
3623
3624   return (ret);
3625 }
3626
3627
3628 /*
3629  * Receive application data decrypted from the SSL layer
3630  */
3631 int
3632 ssl_read (ntbtls_t ssl, unsigned char *buf, size_t len)
3633 {
3634   int ret;
3635   size_t n;
3636
3637   debug_msg (2, "=> read");
3638
3639   if (ssl->state != TLS_HANDSHAKE_OVER)
3640     {
3641       if ((ret = _ntbtls_handshake (ssl)) != 0)
3642         {
3643           debug_ret (1, "handshake", ret);
3644           return (ret);
3645         }
3646     }
3647
3648   if (ssl->in_offt == NULL)
3649     {
3650       if ((ret = _ntbtls_read_record (ssl)) != 0)
3651         {
3652           if (gpg_err_code (ret) == GPG_ERR_EOF)
3653             return 0;
3654
3655           debug_ret (1, "read_record", ret);
3656           return ret;
3657         }
3658
3659       if (ssl->in_msglen == 0 && ssl->in_msgtype == TLS_MSG_APPLICATION_DATA)
3660         {
3661           /*
3662            * OpenSSL sends empty messages to randomize the IV
3663            */
3664           if ((ret = _ntbtls_read_record (ssl)) != 0)
3665             {
3666               if (gpg_err_code (ret) == GPG_ERR_EOF)
3667                 return (0);
3668
3669               debug_ret (1, "read_record", ret);
3670               return (ret);
3671             }
3672         }
3673
3674       if (ssl->in_msgtype == TLS_MSG_HANDSHAKE)
3675         {
3676           debug_msg (1, "received handshake message");
3677
3678           if (ssl->is_client &&
3679               (ssl->in_msg[0] != TLS_HS_HELLO_REQUEST || ssl->in_hslen != 4))
3680             {
3681               debug_msg (1, "handshake received (not HelloRequest)");
3682               return gpg_error (GPG_ERR_UNEXPECTED_MSG);
3683             }
3684
3685           if (ssl->disable_renegotiation == TLS_RENEGOTIATION_DISABLED ||
3686               (ssl->secure_renegotiation == TLS_LEGACY_RENEGOTIATION &&
3687                ssl->allow_legacy_renegotiation == TLS_LEGACY_NO_RENEGOTIATION))
3688             {
3689               debug_msg (3, "ignoring renegotiation, sending alert");
3690
3691               if (ssl->minor_ver >= TLS_MINOR_VERSION_1)
3692                 {
3693                   if ((ret = _ntbtls_send_alert_message (ssl,
3694                                                      TLS_ALERT_LEVEL_WARNING,
3695                                                      TLS_ALERT_MSG_NO_RENEGOTIATION))
3696                       != 0)
3697                     {
3698                       return (ret);
3699                     }
3700                 }
3701               else
3702                 {
3703                   debug_bug ();
3704                   return gpg_error (GPG_ERR_INTERNAL);
3705                 }
3706             }
3707           else
3708             {
3709               if ((ret = start_renegotiation (ssl)) != 0)
3710                 {
3711                   debug_ret (1, "start_renegotiation", ret);
3712                   return ret;
3713                 }
3714
3715               debug_msg (1, "used to be POLARSSL_ERR_NET_WANT_READ");
3716               return gpg_error (GPG_ERR_BUG);
3717             }
3718         }
3719       else if (ssl->renegotiation == TLS_RENEGOTIATION_PENDING)
3720         {
3721           ssl->renego_records_seen++;
3722
3723           if (ssl->renego_max_records >= 0 &&
3724               ssl->renego_records_seen > ssl->renego_max_records)
3725             {
3726               debug_msg (1, "renegotiation requested, "
3727                          "but not honored by client");
3728               return gpg_error (GPG_ERR_UNEXPECTED_MSG);
3729             }
3730         }
3731       else if (ssl->in_msgtype != TLS_MSG_APPLICATION_DATA)
3732         {
3733           debug_msg (1, "bad application data message");
3734           return gpg_error (GPG_ERR_UNEXPECTED_MSG);
3735         }
3736
3737       ssl->in_offt = ssl->in_msg;
3738     }
3739
3740   n = (len < ssl->in_msglen) ? len : ssl->in_msglen;
3741
3742   memcpy (buf, ssl->in_offt, n);
3743   ssl->in_msglen -= n;
3744
3745   if (ssl->in_msglen == 0)
3746     /* all bytes consumed  */
3747     ssl->in_offt = NULL;
3748   else
3749     /* more data available */
3750     ssl->in_offt += n;
3751
3752   debug_msg (2, "<= read");
3753
3754   return ((int) n);
3755 }
3756
3757
3758 /*
3759  * Send application data to be encrypted by the SSL layer
3760  */
3761 int
3762 ssl_write (ntbtls_t ssl, const unsigned char *buf, size_t len)
3763 {
3764   gpg_error_t err;
3765   int ret;
3766   size_t n;
3767   unsigned int max_len = TLS_MAX_CONTENT_LEN;
3768
3769   debug_msg (2, "=> write");
3770
3771   if (ssl->state != TLS_HANDSHAKE_OVER)
3772     {
3773       if ((ret = _ntbtls_handshake (ssl)) != 0)