TLS now working again.
[people/dverkamp/gpxe.git] / src / net / tls.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 /**
20  * @file
21  *
22  * Transport Layer Security Protocol
23  */
24
25 #include <stdint.h>
26 #include <stdlib.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <byteswap.h>
31 #include <gpxe/hmac.h>
32 #include <gpxe/md5.h>
33 #include <gpxe/sha1.h>
34 #include <gpxe/aes.h>
35 #include <gpxe/rsa.h>
36 #include <gpxe/xfer.h>
37 #include <gpxe/open.h>
38 #include <gpxe/filter.h>
39 #include <gpxe/tls.h>
40
41 static int tls_send_plaintext ( struct tls_session *tls, unsigned int type,
42                                 const void *data, size_t len );
43 static void tls_clear_cipher ( struct tls_session *tls,
44                                struct tls_cipherspec *cipherspec );
45
46 /**
47  * Free TLS session
48  *
49  * @v refcnt            Reference counter
50  */
51 static void free_tls ( struct refcnt *refcnt ) {
52         struct tls_session *tls =
53                 container_of ( refcnt, struct tls_session, refcnt );
54
55         /* Free dynamically-allocated resources */
56         tls_clear_cipher ( tls, &tls->tx_cipherspec );
57         tls_clear_cipher ( tls, &tls->tx_cipherspec_pending );
58         tls_clear_cipher ( tls, &tls->rx_cipherspec );
59         tls_clear_cipher ( tls, &tls->rx_cipherspec_pending );
60         free ( tls->rsa_mod );
61         free ( tls->rsa_pub_exp );
62         free ( tls->rx_data );
63
64         /* Free TLS structure itself */
65         free ( tls );   
66 }
67
68 /**
69  * Finish with TLS session
70  *
71  * @v tls               TLS session
72  * @v rc                Status code
73  */
74 static void tls_close ( struct tls_session *tls, int rc ) {
75
76         /* Remove process */
77         process_del ( &tls->process );
78         
79         /* Close ciphertext and plaintext streams */
80         xfer_nullify ( &tls->cipherstream.xfer );
81         xfer_close ( &tls->cipherstream.xfer, rc );
82         xfer_nullify ( &tls->plainstream.xfer );
83         xfer_close ( &tls->plainstream.xfer, rc );
84 }
85
86 /******************************************************************************
87  *
88  * Random number generation
89  *
90  ******************************************************************************
91  */
92
93 /**
94  * Generate random data
95  *
96  * @v data              Buffer to fill
97  * @v len               Length of buffer
98  */
99 static void tls_generate_random ( void *data, size_t len ) {
100 #warning "Placeholder"
101         memset ( data, 0x01, len );
102 }
103
104 /**
105  * Update HMAC with a list of ( data, len ) pairs
106  *
107  * @v digest            Hash function to use
108  * @v digest_ctx        Digest context
109  * @v args              ( data, len ) pairs of data, terminated by NULL
110  */
111 static void tls_hmac_update_va ( struct crypto_algorithm *digest,
112                                  void *digest_ctx, va_list args ) {
113         void *data;
114         size_t len;
115
116         while ( ( data = va_arg ( args, void * ) ) ) {
117                 len = va_arg ( args, size_t );
118                 hmac_update ( digest, digest_ctx, data, len );
119         }
120 }
121
122 /**
123  * Generate secure pseudo-random data using a single hash function
124  *
125  * @v tls               TLS session
126  * @v digest            Hash function to use
127  * @v secret            Secret
128  * @v secret_len        Length of secret
129  * @v out               Output buffer
130  * @v out_len           Length of output buffer
131  * @v seeds             ( data, len ) pairs of seed data, terminated by NULL
132  */
133 static void tls_p_hash_va ( struct tls_session *tls,
134                             struct crypto_algorithm *digest,
135                             void *secret, size_t secret_len,
136                             void *out, size_t out_len,
137                             va_list seeds ) {
138         uint8_t secret_copy[secret_len];
139         uint8_t digest_ctx[digest->ctxsize];
140         uint8_t digest_ctx_partial[digest->ctxsize];
141         uint8_t a[digest->digestsize];
142         uint8_t out_tmp[digest->digestsize];
143         size_t frag_len = digest->digestsize;
144         va_list tmp;
145
146         /* Copy the secret, in case HMAC modifies it */
147         memcpy ( secret_copy, secret, secret_len );
148         secret = secret_copy;
149         DBGC2 ( tls, "TLS %p %s secret:\n", tls, digest->name );
150         DBGC2_HD ( tls, secret, secret_len );
151
152         /* Calculate A(1) */
153         hmac_init ( digest, digest_ctx, secret, &secret_len );
154         va_copy ( tmp, seeds );
155         tls_hmac_update_va ( digest, digest_ctx, tmp );
156         va_end ( tmp );
157         hmac_final ( digest, digest_ctx, secret, &secret_len, a );
158         DBGC2 ( tls, "TLS %p %s A(1):\n", tls, digest->name );
159         DBGC2_HD ( tls, &a, sizeof ( a ) );
160
161         /* Generate as much data as required */
162         while ( out_len ) {
163                 /* Calculate output portion */
164                 hmac_init ( digest, digest_ctx, secret, &secret_len );
165                 hmac_update ( digest, digest_ctx, a, sizeof ( a ) );
166                 memcpy ( digest_ctx_partial, digest_ctx, digest->ctxsize );
167                 va_copy ( tmp, seeds );
168                 tls_hmac_update_va ( digest, digest_ctx, tmp );
169                 va_end ( tmp );
170                 hmac_final ( digest, digest_ctx,
171                              secret, &secret_len, out_tmp );
172
173                 /* Copy output */
174                 if ( frag_len > out_len )
175                         frag_len = out_len;
176                 memcpy ( out, out_tmp, frag_len );
177                 DBGC2 ( tls, "TLS %p %s output:\n", tls, digest->name );
178                 DBGC2_HD ( tls, out, frag_len );
179
180                 /* Calculate A(i) */
181                 hmac_final ( digest, digest_ctx_partial,
182                              secret, &secret_len, a );
183                 DBGC2 ( tls, "TLS %p %s A(n):\n", tls, digest->name );
184                 DBGC2_HD ( tls, &a, sizeof ( a ) );
185
186                 out += frag_len;
187                 out_len -= frag_len;
188         }
189 }
190
191 /**
192  * Generate secure pseudo-random data
193  *
194  * @v tls               TLS session
195  * @v secret            Secret
196  * @v secret_len        Length of secret
197  * @v out               Output buffer
198  * @v out_len           Length of output buffer
199  * @v ...               ( data, len ) pairs of seed data, terminated by NULL
200  */
201 static void tls_prf ( struct tls_session *tls, void *secret, size_t secret_len,
202                       void *out, size_t out_len, ... ) {
203         va_list seeds;
204         va_list tmp;
205         size_t subsecret_len;
206         void *md5_secret;
207         void *sha1_secret;
208         uint8_t out_md5[out_len];
209         uint8_t out_sha1[out_len];
210         unsigned int i;
211
212         va_start ( seeds, out_len );
213
214         /* Split secret into two, with an overlap of up to one byte */
215         subsecret_len = ( ( secret_len + 1 ) / 2 );
216         md5_secret = secret;
217         sha1_secret = ( secret + secret_len - subsecret_len );
218
219         /* Calculate MD5 portion */
220         va_copy ( tmp, seeds );
221         tls_p_hash_va ( tls, &md5_algorithm, md5_secret, subsecret_len,
222                         out_md5, out_len, seeds );
223         va_end ( tmp );
224
225         /* Calculate SHA1 portion */
226         va_copy ( tmp, seeds );
227         tls_p_hash_va ( tls, &sha1_algorithm, sha1_secret, subsecret_len,
228                         out_sha1, out_len, seeds );
229         va_end ( tmp );
230
231         /* XOR the two portions together into the final output buffer */
232         for ( i = 0 ; i < out_len ; i++ ) {
233                 *( ( uint8_t * ) out + i ) = ( out_md5[i] ^ out_sha1[i] );
234         }
235
236         va_end ( seeds );
237 }
238
239 /**
240  * Generate secure pseudo-random data
241  *
242  * @v secret            Secret
243  * @v secret_len        Length of secret
244  * @v out               Output buffer
245  * @v out_len           Length of output buffer
246  * @v label             String literal label
247  * @v ...               ( data, len ) pairs of seed data
248  */
249 #define tls_prf_label( tls, secret, secret_len, out, out_len, label, ... ) \
250         tls_prf ( (tls), (secret), (secret_len), (out), (out_len),         \
251                   label, ( sizeof ( label ) - 1 ), __VA_ARGS__, NULL )
252
253 /******************************************************************************
254  *
255  * Secret management
256  *
257  ******************************************************************************
258  */
259
260 /**
261  * Generate master secret
262  *
263  * @v tls               TLS session
264  *
265  * The pre-master secret and the client and server random values must
266  * already be known.
267  */
268 static void tls_generate_master_secret ( struct tls_session *tls ) {
269         DBGC ( tls, "TLS %p pre-master-secret:\n", tls );
270         DBGC_HD ( tls, &tls->pre_master_secret,
271                   sizeof ( tls->pre_master_secret ) );
272         DBGC ( tls, "TLS %p client random bytes:\n", tls );
273         DBGC_HD ( tls, &tls->client_random, sizeof ( tls->server_random ) );
274         DBGC ( tls, "TLS %p server random bytes:\n", tls );
275         DBGC_HD ( tls, &tls->server_random, sizeof ( tls->server_random ) );
276
277         tls_prf_label ( tls, tls->pre_master_secret,
278                         sizeof ( tls->pre_master_secret ),
279                         tls->master_secret, sizeof ( tls->master_secret ),
280                         "master secret",
281                         tls->client_random, sizeof ( tls->client_random ),
282                         tls->server_random, sizeof ( tls->server_random ) );
283
284         DBGC ( tls, "TLS %p generated master secret:\n", tls );
285         DBGC_HD ( tls, &tls->master_secret, sizeof ( tls->master_secret ) );
286 }
287
288 /**
289  * Generate key material
290  *
291  * @v tls               TLS session
292  *
293  * The master secret must already be known.
294  */
295 static int tls_generate_keys ( struct tls_session *tls ) {
296         struct tls_cipherspec *tx_cipherspec = &tls->tx_cipherspec_pending;
297         struct tls_cipherspec *rx_cipherspec = &tls->rx_cipherspec_pending;
298         size_t hash_size = tx_cipherspec->digest->digestsize;
299         size_t key_size = tx_cipherspec->key_len;
300         size_t iv_size = tx_cipherspec->cipher->blocksize;
301         size_t total = ( 2 * ( hash_size + key_size + iv_size ) );
302         uint8_t key_block[total];
303         uint8_t *key;
304         int rc;
305
306         /* Generate key block */
307         tls_prf_label ( tls, tls->master_secret, sizeof ( tls->master_secret ),
308                         key_block, sizeof ( key_block ), "key expansion",
309                         tls->server_random, sizeof ( tls->server_random ),
310                         tls->client_random, sizeof ( tls->client_random ) );
311
312         /* Split key block into portions */
313         key = key_block;
314
315         /* TX MAC secret */
316         memcpy ( tx_cipherspec->mac_secret, key, hash_size );
317         DBGC ( tls, "TLS %p TX MAC secret:\n", tls );
318         DBGC_HD ( tls, key, hash_size );
319         key += hash_size;
320
321         /* RX MAC secret */
322         memcpy ( rx_cipherspec->mac_secret, key, hash_size );
323         DBGC ( tls, "TLS %p RX MAC secret:\n", tls );
324         DBGC_HD ( tls, key, hash_size );
325         key += hash_size;
326
327         /* TX key */
328         if ( ( rc = cipher_setkey ( tx_cipherspec->cipher,
329                                     tx_cipherspec->cipher_ctx,
330                                     key, key_size ) ) != 0 ) {
331                 DBGC ( tls, "TLS %p could not set TX key: %s\n",
332                        tls, strerror ( rc ) );
333                 return rc;
334         }
335         DBGC ( tls, "TLS %p TX key:\n", tls );
336         DBGC_HD ( tls, key, key_size );
337         key += key_size;
338
339         /* RX key */
340         if ( ( rc = cipher_setkey ( rx_cipherspec->cipher,
341                                     rx_cipherspec->cipher_ctx,
342                                     key, key_size ) ) != 0 ) {
343                 DBGC ( tls, "TLS %p could not set TX key: %s\n",
344                        tls, strerror ( rc ) );
345                 return rc;
346         }
347
348 #warning "AES needs to be fixed to not require this"
349         AES_convert_key ( rx_cipherspec->cipher_ctx );
350
351         DBGC ( tls, "TLS %p RX key:\n", tls );
352         DBGC_HD ( tls, key, key_size );
353         key += key_size;
354
355         /* TX initialisation vector */
356         cipher_setiv ( tx_cipherspec->cipher, tx_cipherspec->cipher_ctx, key );
357         DBGC ( tls, "TLS %p TX IV:\n", tls );
358         DBGC_HD ( tls, key, iv_size );
359         key += iv_size;
360
361         /* RX initialisation vector */
362         cipher_setiv ( rx_cipherspec->cipher, rx_cipherspec->cipher_ctx, key );
363         DBGC ( tls, "TLS %p RX IV:\n", tls );
364         DBGC_HD ( tls, key, iv_size );
365         key += iv_size;
366
367         assert ( ( key_block + total ) == key );
368
369         return 0;
370 }
371
372 /******************************************************************************
373  *
374  * Cipher suite management
375  *
376  ******************************************************************************
377  */
378
379 /**
380  * Clear cipher suite
381  *
382  * @v cipherspec        TLS cipher specification
383  */
384 static void tls_clear_cipher ( struct tls_session *tls __unused,
385                                struct tls_cipherspec *cipherspec ) {
386         free ( cipherspec->dynamic );
387         memset ( cipherspec, 0, sizeof ( cipherspec ) );
388         cipherspec->pubkey = &crypto_null;
389         cipherspec->cipher = &crypto_null;
390         cipherspec->digest = &crypto_null;
391 }
392
393 /**
394  * Set cipher suite
395  *
396  * @v tls               TLS session
397  * @v cipherspec        TLS cipher specification
398  * @v pubkey            Public-key encryption elgorithm
399  * @v cipher            Bulk encryption cipher algorithm
400  * @v digest            MAC digest algorithm
401  * @v key_len           Key length
402  * @ret rc              Return status code
403  */
404 static int tls_set_cipher ( struct tls_session *tls,
405                             struct tls_cipherspec *cipherspec,
406                             struct crypto_algorithm *pubkey,
407                             struct crypto_algorithm *cipher,
408                             struct crypto_algorithm *digest,
409                             size_t key_len ) {
410         size_t total;
411         void *dynamic;
412
413         /* Clear out old cipher contents, if any */
414         tls_clear_cipher ( tls, cipherspec );
415         
416         /* Allocate dynamic storage */
417         total = ( pubkey->ctxsize + 2 * cipher->ctxsize + digest->digestsize );
418         dynamic = malloc ( total );
419         if ( ! dynamic ) {
420                 DBGC ( tls, "TLS %p could not allocate %zd bytes for crypto "
421                        "context\n", tls, total );
422                 return -ENOMEM;
423         }
424         memset ( dynamic, 0, total );
425
426         /* Assign storage */
427         cipherspec->dynamic = dynamic;
428         cipherspec->pubkey_ctx = dynamic;       dynamic += pubkey->ctxsize;
429         cipherspec->cipher_ctx = dynamic;       dynamic += cipher->ctxsize;
430         cipherspec->cipher_next_ctx = dynamic;  dynamic += cipher->ctxsize;
431         cipherspec->mac_secret = dynamic;       dynamic += digest->digestsize;
432         assert ( ( cipherspec->dynamic + total ) == dynamic );
433
434         /* Store parameters */
435         cipherspec->pubkey = pubkey;
436         cipherspec->cipher = cipher;
437         cipherspec->digest = digest;
438         cipherspec->key_len = key_len;
439
440         return 0;
441 }
442
443 /**
444  * Select next cipher suite
445  *
446  * @v tls               TLS session
447  * @v cipher_suite      Cipher suite specification
448  * @ret rc              Return status code
449  */
450 static int tls_select_cipher ( struct tls_session *tls,
451                                unsigned int cipher_suite ) {
452         struct crypto_algorithm *pubkey = &crypto_null;
453         struct crypto_algorithm *cipher = &crypto_null;
454         struct crypto_algorithm *digest = &crypto_null;
455         size_t key_len = 0;
456         int rc;
457
458         switch ( cipher_suite ) {
459         case htons ( TLS_RSA_WITH_AES_128_CBC_SHA ):
460                 key_len = ( 128 / 8 );
461                 cipher = &aes_algorithm;
462                 digest = &sha1_algorithm;
463                 break;
464         case htons ( TLS_RSA_WITH_AES_256_CBC_SHA ):
465                 key_len = ( 256 / 8 );
466                 cipher = &aes_algorithm;
467                 digest = &sha1_algorithm;
468                 break;
469         default:
470                 DBGC ( tls, "TLS %p does not support cipher %04x\n",
471                        tls, ntohs ( cipher_suite ) );
472                 return -ENOTSUP;
473         }
474
475         /* Set ciphers */
476         if ( ( rc = tls_set_cipher ( tls, &tls->tx_cipherspec_pending, pubkey,
477                                      cipher, digest, key_len ) ) != 0 )
478                 return rc;
479         if ( ( rc = tls_set_cipher ( tls, &tls->rx_cipherspec_pending, pubkey,
480                                      cipher, digest, key_len ) ) != 0 )
481                 return rc;
482
483         DBGC ( tls, "TLS %p selected %s-%s-%d-%s\n", tls,
484                pubkey->name, cipher->name, ( key_len * 8 ), digest->name );
485
486         return 0;
487 }
488
489 /**
490  * Activate next cipher suite
491  *
492  * @v tls               TLS session
493  * @v pending           Pending cipher specification
494  * @v active            Active cipher specification to replace
495  * @ret rc              Return status code
496  */
497 static int tls_change_cipher ( struct tls_session *tls,
498                                struct tls_cipherspec *pending,
499                                struct tls_cipherspec *active ) {
500
501 #warning "Why is this disabled?"
502 #if 0
503         /* Sanity check */
504         if ( ( pending->pubkey == &crypto_null ) ||
505              ( pending->cipher == &crypto_null ) ||
506              ( pending->digest == &crypto_null ) ) {
507                 DBGC ( tls, "TLS %p refusing to use null cipher\n", tls );
508                 return -ENOTSUP;
509         }
510 #endif
511
512         tls_clear_cipher ( tls, active );
513         memswap ( active, pending, sizeof ( *active ) );
514         return 0;
515 }
516
517 /******************************************************************************
518  *
519  * Handshake verification
520  *
521  ******************************************************************************
522  */
523
524 /**
525  * Add handshake record to verification hash
526  *
527  * @v tls               TLS session
528  * @v data              Handshake record
529  * @v len               Length of handshake record
530  */
531 static void tls_add_handshake ( struct tls_session *tls,
532                                 const void *data, size_t len ) {
533
534         digest_update ( &md5_algorithm, tls->handshake_md5_ctx, data, len );
535         digest_update ( &sha1_algorithm, tls->handshake_sha1_ctx, data, len );
536 }
537
538 /**
539  * Calculate handshake verification hash
540  *
541  * @v tls               TLS session
542  * @v out               Output buffer
543  *
544  * Calculates the MD5+SHA1 digest over all handshake messages seen so
545  * far.
546  */
547 static void tls_verify_handshake ( struct tls_session *tls, void *out ) {
548         struct crypto_algorithm *md5 = &md5_algorithm;
549         struct crypto_algorithm *sha1 = &sha1_algorithm;
550         uint8_t md5_ctx[md5->ctxsize];
551         uint8_t sha1_ctx[sha1->ctxsize];
552         void *md5_digest = out;
553         void *sha1_digest = ( out + md5->digestsize );
554
555         memcpy ( md5_ctx, tls->handshake_md5_ctx, sizeof ( md5_ctx ) );
556         memcpy ( sha1_ctx, tls->handshake_sha1_ctx, sizeof ( sha1_ctx ) );
557         digest_final ( md5, md5_ctx, md5_digest );
558         digest_final ( sha1, sha1_ctx, sha1_digest );
559 }
560
561 /******************************************************************************
562  *
563  * Record handling
564  *
565  ******************************************************************************
566  */
567
568 /**
569  * Transmit Handshake record
570  *
571  * @v tls               TLS session
572  * @v data              Plaintext record
573  * @v len               Length of plaintext record
574  * @ret rc              Return status code
575  */
576 static int tls_send_handshake ( struct tls_session *tls,
577                                 void *data, size_t len ) {
578
579         /* Add to handshake digest */
580         tls_add_handshake ( tls, data, len );
581
582         /* Send record */
583         return tls_send_plaintext ( tls, TLS_TYPE_HANDSHAKE, data, len );
584 }
585
586 /**
587  * Transmit Client Hello record
588  *
589  * @v tls               TLS session
590  * @ret rc              Return status code
591  */
592 static int tls_send_client_hello ( struct tls_session *tls ) {
593         struct {
594                 uint32_t type_length;
595                 uint16_t version;
596                 uint8_t random[32];
597                 uint8_t session_id_len;
598                 uint16_t cipher_suite_len;
599                 uint16_t cipher_suites[2];
600                 uint8_t compression_methods_len;
601                 uint8_t compression_methods[1];
602         } __attribute__ (( packed )) hello;
603
604         memset ( &hello, 0, sizeof ( hello ) );
605         hello.type_length = ( cpu_to_le32 ( TLS_CLIENT_HELLO ) |
606                               htonl ( sizeof ( hello ) -
607                                       sizeof ( hello.type_length ) ) );
608         hello.version = htons ( TLS_VERSION_TLS_1_0 );
609         memcpy ( &hello.random, tls->client_random, sizeof ( hello.random ) );
610         hello.cipher_suite_len = htons ( sizeof ( hello.cipher_suites ) );
611         hello.cipher_suites[0] = htons ( TLS_RSA_WITH_AES_128_CBC_SHA );
612         hello.cipher_suites[1] = htons ( TLS_RSA_WITH_AES_256_CBC_SHA );
613         hello.compression_methods_len = sizeof ( hello.compression_methods );
614
615         return tls_send_handshake ( tls, &hello, sizeof ( hello ) );
616 }
617
618 /**
619  * Transmit Client Key Exchange record
620  *
621  * @v tls               TLS session
622  * @ret rc              Return status code
623  */
624 static int tls_send_client_key_exchange ( struct tls_session *tls ) {
625 #warning "Hack alert"
626         RSA_CTX *rsa_ctx;
627         RSA_pub_key_new ( &rsa_ctx, tls->rsa_mod, tls->rsa_mod_len,
628                           tls->rsa_pub_exp, tls->rsa_pub_exp_len );
629         struct {
630                 uint32_t type_length;
631                 uint16_t encrypted_pre_master_secret_len;
632                 uint8_t encrypted_pre_master_secret[rsa_ctx->num_octets];
633         } __attribute__ (( packed )) key_xchg;
634
635         memset ( &key_xchg, 0, sizeof ( key_xchg ) );
636         key_xchg.type_length = ( cpu_to_le32 ( TLS_CLIENT_KEY_EXCHANGE ) |
637                                  htonl ( sizeof ( key_xchg ) -
638                                          sizeof ( key_xchg.type_length ) ) );
639         key_xchg.encrypted_pre_master_secret_len
640                 = htons ( sizeof ( key_xchg.encrypted_pre_master_secret ) );
641
642 #warning "Hack alert"
643         DBGC ( tls, "RSA encrypting plaintext, modulus, exponent:\n" );
644         DBGC_HD ( tls, &tls->pre_master_secret,
645                   sizeof ( tls->pre_master_secret ) );
646         DBGC_HD ( tls, tls->rsa_mod, tls->rsa_mod_len );
647         DBGC_HD ( tls, tls->rsa_pub_exp, tls->rsa_pub_exp_len );
648         RSA_encrypt ( rsa_ctx, tls->pre_master_secret,
649                       sizeof ( tls->pre_master_secret ),
650                       key_xchg.encrypted_pre_master_secret, 0 );
651         DBGC ( tls, "RSA encrypt done.  Ciphertext:\n" );
652         DBGC_HD ( tls, &key_xchg.encrypted_pre_master_secret,
653                   sizeof ( key_xchg.encrypted_pre_master_secret ) );
654         RSA_free ( rsa_ctx );
655
656
657         return tls_send_handshake ( tls, &key_xchg, sizeof ( key_xchg ) );
658 }
659
660 /**
661  * Transmit Change Cipher record
662  *
663  * @v tls               TLS session
664  * @ret rc              Return status code
665  */
666 static int tls_send_change_cipher ( struct tls_session *tls ) {
667         static const uint8_t change_cipher[1] = { 1 };
668         return tls_send_plaintext ( tls, TLS_TYPE_CHANGE_CIPHER,
669                                     change_cipher, sizeof ( change_cipher ) );
670 }
671
672 /**
673  * Transmit Finished record
674  *
675  * @v tls               TLS session
676  * @ret rc              Return status code
677  */
678 static int tls_send_finished ( struct tls_session *tls ) {
679         struct {
680                 uint32_t type_length;
681                 uint8_t verify_data[12];
682         } __attribute__ (( packed )) finished;
683         uint8_t digest[MD5_DIGEST_SIZE + SHA1_DIGEST_SIZE];
684
685         memset ( &finished, 0, sizeof ( finished ) );
686         finished.type_length = ( cpu_to_le32 ( TLS_FINISHED ) |
687                                  htonl ( sizeof ( finished ) -
688                                          sizeof ( finished.type_length ) ) );
689         tls_verify_handshake ( tls, digest );
690         tls_prf_label ( tls, tls->master_secret, sizeof ( tls->master_secret ),
691                         finished.verify_data, sizeof ( finished.verify_data ),
692                         "client finished", digest, sizeof ( digest ) );
693
694         return tls_send_handshake ( tls, &finished, sizeof ( finished ) );
695 }
696
697 /**
698  * Receive new Change Cipher record
699  *
700  * @v tls               TLS session
701  * @v data              Plaintext record
702  * @v len               Length of plaintext record
703  * @ret rc              Return status code
704  */
705 static int tls_new_change_cipher ( struct tls_session *tls,
706                                    void *data, size_t len ) {
707         int rc;
708
709         if ( ( len != 1 ) || ( *( ( uint8_t * ) data ) != 1 ) ) {
710                 DBGC ( tls, "TLS %p received invalid Change Cipher\n", tls );
711                 DBGC_HD ( tls, data, len );
712                 return -EINVAL;
713         }
714
715         if ( ( rc = tls_change_cipher ( tls, &tls->rx_cipherspec_pending,
716                                         &tls->rx_cipherspec ) ) != 0 ) {
717                 DBGC ( tls, "TLS %p could not activate RX cipher: %s\n",
718                        tls, strerror ( rc ) );
719                 return rc;
720         }
721         tls->rx_seq = ~( ( uint64_t ) 0 );
722
723         return 0;
724 }
725
726 /**
727  * Receive new Alert record
728  *
729  * @v tls               TLS session
730  * @v data              Plaintext record
731  * @v len               Length of plaintext record
732  * @ret rc              Return status code
733  */
734 static int tls_new_alert ( struct tls_session *tls, void *data, size_t len ) {
735         struct {
736                 uint8_t level;
737                 uint8_t description;
738                 char next[0];
739         } __attribute__ (( packed )) *alert = data;
740         void *end = alert->next;
741
742         /* Sanity check */
743         if ( end != ( data + len ) ) {
744                 DBGC ( tls, "TLS %p received overlength Alert\n", tls );
745                 DBGC_HD ( tls, data, len );
746                 return -EINVAL;
747         }
748
749         switch ( alert->level ) {
750         case TLS_ALERT_WARNING:
751                 DBGC ( tls, "TLS %p received warning alert %d\n",
752                        tls, alert->description );
753                 return 0;
754         case TLS_ALERT_FATAL:
755                 DBGC ( tls, "TLS %p received fatal alert %d\n",
756                        tls, alert->description );
757                 return -EPERM;
758         default:
759                 DBGC ( tls, "TLS %p received unknown alert level %d"
760                        "(alert %d)\n", tls, alert->level, alert->description );
761                 return -EIO;
762         }
763 }
764
765 /**
766  * Receive new Server Hello record
767  *
768  * @v tls               TLS session
769  * @v data              Plaintext record
770  * @v len               Length of plaintext record
771  * @ret rc              Return status code
772  */
773 static int tls_new_server_hello ( struct tls_session *tls,
774                                   void *data, size_t len ) {
775         struct {
776                 uint32_t type_length;
777                 uint16_t version;
778                 uint8_t random[32];
779                 uint8_t session_id_len;
780                 char next[0];
781         } __attribute__ (( packed )) *hello_a = data;
782         struct {
783                 uint8_t session_id[hello_a->session_id_len];
784                 uint16_t cipher_suite;
785                 uint8_t compression_method;
786                 char next[0];
787         } __attribute__ (( packed )) *hello_b = ( void * ) &hello_a->next;
788         void *end = hello_b->next;
789         int rc;
790
791         /* Sanity check */
792         if ( end != ( data + len ) ) {
793                 DBGC ( tls, "TLS %p received overlength Server Hello\n", tls );
794                 DBGC_HD ( tls, data, len );
795                 return -EINVAL;
796         }
797
798         /* Check protocol version */
799         if ( ntohs ( hello_a->version ) < TLS_VERSION_TLS_1_0 ) {
800                 DBGC ( tls, "TLS %p does not support protocol version %d.%d\n",
801                        tls, ( ntohs ( hello_a->version ) >> 8 ),
802                        ( ntohs ( hello_a->version ) & 0xff ) );
803                 return -ENOTSUP;
804         }
805
806         /* Copy out server random bytes */
807         memcpy ( tls->server_random, hello_a->random,
808                  sizeof ( tls->server_random ) );
809
810         /* Select cipher suite */
811         if ( ( rc = tls_select_cipher ( tls, hello_b->cipher_suite ) ) != 0 )
812                 return rc;
813
814         /* Generate secrets */
815         tls_generate_master_secret ( tls );
816         if ( ( rc = tls_generate_keys ( tls ) ) != 0 )
817                 return rc;
818
819         return 0;
820 }
821
822 /**
823  * Receive new Certificate record
824  *
825  * @v tls               TLS session
826  * @v data              Plaintext record
827  * @v len               Length of plaintext record
828  * @ret rc              Return status code
829  */
830 static int tls_new_certificate ( struct tls_session *tls,
831                                  void *data, size_t len ) {
832         struct {
833                 uint32_t type_length;
834                 uint8_t length[3];
835                 uint8_t first_cert_length[3];
836                 uint8_t asn1_start[0];
837         } __attribute__ (( packed )) *certificate = data;
838         uint8_t *cert = certificate->asn1_start;
839         int offset = 0;
840
841         if (asn1_next_obj(cert, &offset, ASN1_SEQUENCE) < 0 ||
842             asn1_next_obj(cert, &offset, ASN1_SEQUENCE) < 0 ||
843             asn1_skip_obj(cert, &offset, ASN1_EXPLICIT_TAG) ||
844             asn1_skip_obj(cert, &offset, ASN1_INTEGER) ||
845             asn1_skip_obj(cert, &offset, ASN1_SEQUENCE) ||
846             asn1_skip_obj(cert, &offset, ASN1_SEQUENCE) ||
847             asn1_skip_obj(cert, &offset, ASN1_SEQUENCE) ||
848             asn1_skip_obj(cert, &offset, ASN1_SEQUENCE) ||
849             asn1_next_obj(cert, &offset, ASN1_SEQUENCE) < 0 ||
850             asn1_skip_obj(cert, &offset, ASN1_SEQUENCE) ||
851             asn1_next_obj(cert, &offset, ASN1_BIT_STRING) < 0) {
852                 DBGC ( tls, "TLS %p invalid certificate\n", tls );
853                 DBGC_HD ( tls, cert + offset, 64 );
854                 return -EPERM;
855         }
856         
857         offset++;
858         
859         if (asn1_next_obj(cert, &offset, ASN1_SEQUENCE) < 0) {
860                 DBGC ( tls, "TLS %p invalid certificate\n", tls );
861                 DBGC_HD ( tls, cert + offset, 64 );
862                 return -EPERM;
863         }
864         
865         tls->rsa_mod_len = asn1_get_int(cert, &offset, &tls->rsa_mod);
866         tls->rsa_pub_exp_len = asn1_get_int(cert, &offset, &tls->rsa_pub_exp);
867         
868         DBGC_HD ( tls, tls->rsa_mod, tls->rsa_mod_len );
869         DBGC_HD ( tls, tls->rsa_pub_exp, tls->rsa_pub_exp_len );
870
871         return 0;
872 }
873
874 /**
875  * Receive new Server Hello Done record
876  *
877  * @v tls               TLS session
878  * @v data              Plaintext record
879  * @v len               Length of plaintext record
880  * @ret rc              Return status code
881  */
882 static int tls_new_server_hello_done ( struct tls_session *tls,
883                                        void *data, size_t len ) {
884         struct {
885                 uint32_t type_length;
886                 char next[0];
887         } __attribute__ (( packed )) *hello_done = data;
888         void *end = hello_done->next;
889
890         /* Sanity check */
891         if ( end != ( data + len ) ) {
892                 DBGC ( tls, "TLS %p received overlength Server Hello Done\n",
893                        tls );
894                 DBGC_HD ( tls, data, len );
895                 return -EINVAL;
896         }
897
898         /* Check that we are ready to send the Client Key Exchange */
899         if ( tls->tx_state != TLS_TX_NONE ) {
900                 DBGC ( tls, "TLS %p received Server Hello Done while in "
901                        "TX state %d\n", tls, tls->tx_state );
902                 return -EIO;
903         }
904
905         /* Start sending the Client Key Exchange */
906         tls->tx_state = TLS_TX_CLIENT_KEY_EXCHANGE;
907
908         return 0;
909 }
910
911 /**
912  * Receive new Finished record
913  *
914  * @v tls               TLS session
915  * @v data              Plaintext record
916  * @v len               Length of plaintext record
917  * @ret rc              Return status code
918  */
919 static int tls_new_finished ( struct tls_session *tls,
920                               void *data, size_t len ) {
921
922 #warning "Handle this properly"
923         tls->tx_state = TLS_TX_DATA;
924         ( void ) data;
925         ( void ) len;
926         return 0;
927 }
928
929 /**
930  * Receive new Handshake record
931  *
932  * @v tls               TLS session
933  * @v data              Plaintext record
934  * @v len               Length of plaintext record
935  * @ret rc              Return status code
936  */
937 static int tls_new_handshake ( struct tls_session *tls,
938                                void *data, size_t len ) {
939         uint8_t *type = data;
940         int rc;
941
942         switch ( *type ) {
943         case TLS_SERVER_HELLO:
944                 rc = tls_new_server_hello ( tls, data, len );
945                 break;
946         case TLS_CERTIFICATE:
947                 rc = tls_new_certificate ( tls, data, len );
948                 break;
949         case TLS_SERVER_HELLO_DONE:
950                 rc = tls_new_server_hello_done ( tls, data, len );
951                 break;
952         case TLS_FINISHED:
953                 rc = tls_new_finished ( tls, data, len );
954                 break;
955         default:
956                 DBGC ( tls, "TLS %p ignoring handshake type %d\n",
957                        tls, *type );
958                 rc = 0;
959                 break;
960         }
961
962         /* Add to handshake digest (except for Hello Requests, which
963          * are explicitly excludede).
964          */
965         if ( *type != TLS_HELLO_REQUEST )
966                 tls_add_handshake ( tls, data, len );
967
968         return rc;
969 }
970
971 /**
972  * Receive new record
973  *
974  * @v tls               TLS session
975  * @v type              Record type
976  * @v data              Plaintext record
977  * @v len               Length of plaintext record
978  * @ret rc              Return status code
979  */
980 static int tls_new_record ( struct tls_session *tls,
981                             unsigned int type, void *data, size_t len ) {
982
983         switch ( type ) {
984         case TLS_TYPE_CHANGE_CIPHER:
985                 return tls_new_change_cipher ( tls, data, len );
986         case TLS_TYPE_ALERT:
987                 return tls_new_alert ( tls, data, len );
988         case TLS_TYPE_HANDSHAKE:
989                 return tls_new_handshake ( tls, data, len );
990         case TLS_TYPE_DATA:
991                 return xfer_deliver_raw ( &tls->plainstream.xfer, data, len );
992         default:
993                 /* RFC4346 says that we should just ignore unknown
994                  * record types.
995                  */
996                 DBGC ( tls, "TLS %p ignoring record type %d\n", tls, type );
997                 return 0;
998         }
999 }
1000
1001 /******************************************************************************
1002  *
1003  * Record encryption/decryption
1004  *
1005  ******************************************************************************
1006  */
1007
1008 /**
1009  * Calculate HMAC
1010  *
1011  * @v tls               TLS session
1012  * @v cipherspec        Cipher specification
1013  * @v seq               Sequence number
1014  * @v tlshdr            TLS header
1015  * @v data              Data
1016  * @v len               Length of data
1017  * @v mac               HMAC to fill in
1018  */
1019 static void tls_hmac ( struct tls_session *tls __unused,
1020                        struct tls_cipherspec *cipherspec,
1021                        uint64_t seq, struct tls_header *tlshdr,
1022                        const void *data, size_t len, void *hmac ) {
1023         struct crypto_algorithm *digest = cipherspec->digest;
1024         uint8_t digest_ctx[digest->ctxsize];
1025
1026         hmac_init ( digest, digest_ctx, cipherspec->mac_secret,
1027                     &digest->digestsize );
1028         seq = cpu_to_be64 ( seq );
1029         hmac_update ( digest, digest_ctx, &seq, sizeof ( seq ) );
1030         hmac_update ( digest, digest_ctx, tlshdr, sizeof ( *tlshdr ) );
1031         hmac_update ( digest, digest_ctx, data, len );
1032         hmac_final ( digest, digest_ctx, cipherspec->mac_secret,
1033                      &digest->digestsize, hmac );
1034 }
1035
1036 /**
1037  * Allocate and assemble stream-ciphered record from data and MAC portions
1038  *
1039  * @v tls               TLS session
1040  * @ret data            Data
1041  * @ret len             Length of data
1042  * @ret digest          MAC digest
1043  * @ret plaintext_len   Length of plaintext record
1044  * @ret plaintext       Allocated plaintext record
1045  */
1046 static void * tls_assemble_stream ( struct tls_session *tls,
1047                                     const void *data, size_t len,
1048                                     void *digest, size_t *plaintext_len ) {
1049         size_t mac_len = tls->tx_cipherspec.digest->digestsize;
1050         void *plaintext;
1051         void *content;
1052         void *mac;
1053
1054         /* Calculate stream-ciphered struct length */
1055         *plaintext_len = ( len + mac_len );
1056
1057         /* Allocate stream-ciphered struct */
1058         plaintext = malloc ( *plaintext_len );
1059         if ( ! plaintext )
1060                 return NULL;
1061         content = plaintext;
1062         mac = ( content + len );
1063
1064         /* Fill in stream-ciphered struct */
1065         memcpy ( content, data, len );
1066         memcpy ( mac, digest, mac_len );
1067
1068         return plaintext;
1069 }
1070
1071 /**
1072  * Allocate and assemble block-ciphered record from data and MAC portions
1073  *
1074  * @v tls               TLS session
1075  * @ret data            Data
1076  * @ret len             Length of data
1077  * @ret digest          MAC digest
1078  * @ret plaintext_len   Length of plaintext record
1079  * @ret plaintext       Allocated plaintext record
1080  */
1081 static void * tls_assemble_block ( struct tls_session *tls,
1082                                    const void *data, size_t len,
1083                                    void *digest, size_t *plaintext_len ) {
1084         size_t blocksize = tls->tx_cipherspec.cipher->blocksize;
1085         size_t iv_len = blocksize;
1086         size_t mac_len = tls->tx_cipherspec.digest->digestsize;
1087         size_t padding_len;
1088         void *plaintext;
1089         void *iv;
1090         void *content;
1091         void *mac;
1092         void *padding;
1093
1094 #warning "TLSv1.1 has an explicit IV"
1095         iv_len = 0;
1096
1097         /* Calculate block-ciphered struct length */
1098         padding_len = ( ( blocksize - 1 ) & -( iv_len + len + mac_len + 1 ) );
1099         *plaintext_len = ( iv_len + len + mac_len + padding_len + 1 );
1100
1101         /* Allocate block-ciphered struct */
1102         plaintext = malloc ( *plaintext_len );
1103         if ( ! plaintext )
1104                 return NULL;
1105         iv = plaintext;
1106         content = ( iv + iv_len );
1107         mac = ( content + len );
1108         padding = ( mac + mac_len );
1109
1110         /* Fill in block-ciphered struct */
1111         memset ( iv, 0, iv_len );
1112         memcpy ( content, data, len );
1113         memcpy ( mac, digest, mac_len );
1114         memset ( padding, padding_len, ( padding_len + 1 ) );
1115
1116         return plaintext;
1117 }
1118
1119 /**
1120  * Send plaintext record
1121  *
1122  * @v tls               TLS session
1123  * @v type              Record type
1124  * @v data              Plaintext record
1125  * @v len               Length of plaintext record
1126  * @ret rc              Return status code
1127  */
1128 static int tls_send_plaintext ( struct tls_session *tls, unsigned int type,
1129                                 const void *data, size_t len ) {
1130         struct tls_header plaintext_tlshdr;
1131         struct tls_header *tlshdr;
1132         struct tls_cipherspec *cipherspec = &tls->tx_cipherspec;
1133         void *plaintext = NULL;
1134         size_t plaintext_len;
1135         struct io_buffer *ciphertext = NULL;
1136         size_t ciphertext_len;
1137         size_t mac_len = cipherspec->digest->digestsize;
1138         uint8_t mac[mac_len];
1139         int rc;
1140
1141         /* Construct header */
1142         plaintext_tlshdr.type = type;
1143         plaintext_tlshdr.version = htons ( TLS_VERSION_TLS_1_0 );
1144         plaintext_tlshdr.length = htons ( len );
1145
1146         /* Calculate MAC */
1147         tls_hmac ( tls, cipherspec, tls->tx_seq, &plaintext_tlshdr,
1148                    data, len, mac );
1149
1150         /* Allocate and assemble plaintext struct */
1151         if ( is_stream_cipher ( cipherspec->cipher ) ) {
1152                 plaintext = tls_assemble_stream ( tls, data, len, mac,
1153                                                   &plaintext_len );
1154         } else {
1155                 plaintext = tls_assemble_block ( tls, data, len, mac,
1156                                                  &plaintext_len );
1157         }
1158         if ( ! plaintext ) {
1159                 DBGC ( tls, "TLS %p could not allocate %zd bytes for "
1160                        "plaintext\n", tls, plaintext_len );
1161                 rc = -ENOMEM;
1162                 goto done;
1163         }
1164
1165         DBGC2 ( tls, "Sending plaintext data:\n" );
1166         DBGC2_HD ( tls, plaintext, plaintext_len );
1167
1168         /* Allocate ciphertext */
1169         ciphertext_len = ( sizeof ( *tlshdr ) + plaintext_len );
1170         ciphertext = xfer_alloc_iob ( &tls->cipherstream.xfer,
1171                                       ciphertext_len );
1172         if ( ! ciphertext ) {
1173                 DBGC ( tls, "TLS %p could not allocate %zd bytes for "
1174                        "ciphertext\n", tls, ciphertext_len );
1175                 rc = -ENOMEM;
1176                 goto done;
1177         }
1178
1179         /* Assemble ciphertext */
1180         tlshdr = iob_put ( ciphertext, sizeof ( *tlshdr ) );
1181         tlshdr->type = type;
1182         tlshdr->version = htons ( TLS_VERSION_TLS_1_0 );
1183         tlshdr->length = htons ( plaintext_len );
1184         memcpy ( cipherspec->cipher_next_ctx, cipherspec->cipher_ctx,
1185                  cipherspec->cipher->ctxsize );
1186         if ( ( rc = cipher_encrypt ( cipherspec->cipher,
1187                                      cipherspec->cipher_next_ctx, plaintext,
1188                                      iob_put ( ciphertext, plaintext_len ),
1189                                      plaintext_len ) ) != 0 ) {
1190                 DBGC ( tls, "TLS %p could not encrypt: %s\n",
1191                        tls, strerror ( rc ) );
1192                 DBGC_HD ( tls, plaintext, plaintext_len );
1193                 goto done;
1194         }
1195
1196         /* Free plaintext as soon as possible to conserve memory */
1197         free ( plaintext );
1198         plaintext = NULL;
1199
1200         /* Send ciphertext */
1201         rc = xfer_deliver_iob ( &tls->cipherstream.xfer, ciphertext );
1202         ciphertext = NULL;
1203         if ( rc != 0 ) {
1204                 DBGC ( tls, "TLS %p could not deliver ciphertext: %s\n",
1205                        tls, strerror ( rc ) );
1206                 goto done;
1207         }
1208
1209         /* Update TX state machine to next record */
1210         tls->tx_seq += 1;
1211         memcpy ( tls->tx_cipherspec.cipher_ctx,
1212                  tls->tx_cipherspec.cipher_next_ctx,
1213                  tls->tx_cipherspec.cipher->ctxsize );
1214
1215  done:
1216         free ( plaintext );
1217         free_iob ( ciphertext );
1218         return rc;
1219 }
1220
1221 /**
1222  * Split stream-ciphered record into data and MAC portions
1223  *
1224  * @v tls               TLS session
1225  * @v plaintext         Plaintext record
1226  * @v plaintext_len     Length of record
1227  * @ret data            Data
1228  * @ret len             Length of data
1229  * @ret digest          MAC digest
1230  * @ret rc              Return status code
1231  */
1232 static int tls_split_stream ( struct tls_session *tls,
1233                               void *plaintext, size_t plaintext_len,
1234                               void **data, size_t *len, void **digest ) {
1235         void *content;
1236         size_t content_len;
1237         void *mac;
1238         size_t mac_len;
1239
1240         /* Decompose stream-ciphered data */
1241         mac_len = tls->rx_cipherspec.digest->digestsize;
1242         if ( plaintext_len < mac_len ) {
1243                 DBGC ( tls, "TLS %p received underlength record\n", tls );
1244                 DBGC_HD ( tls, plaintext, plaintext_len );
1245                 return -EINVAL;
1246         }
1247         content_len = ( plaintext_len - mac_len );
1248         content = plaintext;
1249         mac = ( content + content_len );
1250
1251         /* Fill in return values */
1252         *data = content;
1253         *len = content_len;
1254         *digest = mac;
1255
1256         return 0;
1257 }
1258
1259 /**
1260  * Split block-ciphered record into data and MAC portions
1261  *
1262  * @v tls               TLS session
1263  * @v plaintext         Plaintext record
1264  * @v plaintext_len     Length of record
1265  * @ret data            Data
1266  * @ret len             Length of data
1267  * @ret digest          MAC digest
1268  * @ret rc              Return status code
1269  */
1270 static int tls_split_block ( struct tls_session *tls,
1271                              void *plaintext, size_t plaintext_len,
1272                              void **data, size_t *len,
1273                              void **digest ) {
1274         void *iv;
1275         size_t iv_len;
1276         void *content;
1277         size_t content_len;
1278         void *mac;
1279         size_t mac_len;
1280         void *padding;
1281         size_t padding_len;
1282         unsigned int i;
1283
1284         /* Decompose block-ciphered data */
1285         if ( plaintext_len < 1 ) {
1286                 DBGC ( tls, "TLS %p received underlength record\n", tls );
1287                 DBGC_HD ( tls, plaintext, plaintext_len );
1288                 return -EINVAL;
1289         }
1290         iv_len = tls->rx_cipherspec.cipher->blocksize;
1291
1292 #warning "TLSv1.1 uses an explicit IV"
1293         iv_len = 0;
1294
1295         mac_len = tls->rx_cipherspec.digest->digestsize;
1296         padding_len = *( ( uint8_t * ) ( plaintext + plaintext_len - 1 ) );
1297         if ( plaintext_len < ( iv_len + mac_len + padding_len + 1 ) ) {
1298                 DBGC ( tls, "TLS %p received underlength record\n", tls );
1299                 DBGC_HD ( tls, plaintext, plaintext_len );
1300                 return -EINVAL;
1301         }
1302         content_len = ( plaintext_len - iv_len - mac_len - padding_len - 1 );
1303         iv = plaintext;
1304         content = ( iv + iv_len );
1305         mac = ( content + content_len );
1306         padding = ( mac + mac_len );
1307
1308         /* Verify padding bytes */
1309         for ( i = 0 ; i < padding_len ; i++ ) {
1310                 if ( *( ( uint8_t * ) ( padding + i ) ) != padding_len ) {
1311                         DBGC ( tls, "TLS %p received bad padding\n", tls );
1312                         DBGC_HD ( tls, plaintext, plaintext_len );
1313                         return -EINVAL;
1314                 }
1315         }
1316
1317         /* Fill in return values */
1318         *data = content;
1319         *len = content_len;
1320         *digest = mac;
1321
1322         return 0;
1323 }
1324
1325 /**
1326  * Receive new ciphertext record
1327  *
1328  * @v tls               TLS session
1329  * @v tlshdr            Record header
1330  * @v ciphertext        Ciphertext record
1331  * @ret rc              Return status code
1332  */
1333 static int tls_new_ciphertext ( struct tls_session *tls,
1334                                 struct tls_header *tlshdr, void *ciphertext ) {
1335         struct tls_header plaintext_tlshdr;
1336         struct tls_cipherspec *cipherspec = &tls->rx_cipherspec;
1337         size_t record_len = ntohs ( tlshdr->length );
1338         void *plaintext = NULL;
1339         void *data;
1340         size_t len;
1341         void *mac;
1342         size_t mac_len = cipherspec->digest->digestsize;
1343         uint8_t verify_mac[mac_len];
1344         int rc;
1345
1346         /* Allocate buffer for plaintext */
1347         plaintext = malloc ( record_len );
1348         if ( ! plaintext ) {
1349                 DBGC ( tls, "TLS %p could not allocate %zd bytes for "
1350                        "decryption buffer\n", tls, record_len );
1351                 rc = -ENOMEM;
1352                 goto done;
1353         }
1354
1355         /* Decrypt the record */
1356         if ( ( rc = cipher_decrypt ( cipherspec->cipher,
1357                                      cipherspec->cipher_ctx, ciphertext,
1358                                      plaintext, record_len ) ) != 0 ) {
1359                 DBGC ( tls, "TLS %p could not decrypt: %s\n",
1360                        tls, strerror ( rc ) );
1361                 DBGC_HD ( tls, ciphertext, record_len );
1362                 goto done;
1363         }
1364
1365         /* Split record into content and MAC */
1366         if ( is_stream_cipher ( cipherspec->cipher ) ) {
1367                 if ( ( rc = tls_split_stream ( tls, plaintext, record_len,
1368                                                &data, &len, &mac ) ) != 0 )
1369                         goto done;
1370         } else {
1371                 if ( ( rc = tls_split_block ( tls, plaintext, record_len,
1372                                               &data, &len, &mac ) ) != 0 )
1373                         goto done;
1374         }
1375
1376         /* Verify MAC */
1377         plaintext_tlshdr.type = tlshdr->type;
1378         plaintext_tlshdr.version = tlshdr->version;
1379         plaintext_tlshdr.length = htons ( len );
1380         tls_hmac ( tls, cipherspec, tls->rx_seq, &plaintext_tlshdr,
1381                    data, len, verify_mac);
1382         if ( memcmp ( mac, verify_mac, mac_len ) != 0 ) {
1383                 DBGC ( tls, "TLS %p failed MAC verification\n", tls );
1384                 DBGC_HD ( tls, plaintext, record_len );
1385                 goto done;
1386         }
1387
1388         DBGC2 ( tls, "Received plaintext data:\n" );
1389         DBGC2_HD ( tls, data, len );
1390
1391         /* Process plaintext record */
1392         if ( ( rc = tls_new_record ( tls, tlshdr->type, data, len ) ) != 0 )
1393                 goto done;
1394
1395         rc = 0;
1396  done:
1397         free ( plaintext );
1398         return rc;
1399 }
1400
1401 /******************************************************************************
1402  *
1403  * Plaintext stream operations
1404  *
1405  ******************************************************************************
1406  */
1407
1408 /**
1409  * Close interface
1410  *
1411  * @v xfer              Plainstream data transfer interface
1412  * @v rc                Reason for close
1413  */
1414 static void tls_plainstream_close ( struct xfer_interface *xfer, int rc ) {
1415         struct tls_session *tls =
1416                 container_of ( xfer, struct tls_session, plainstream.xfer );
1417
1418         tls_close ( tls, rc );
1419 }
1420
1421 /**
1422  * Check flow control window
1423  *
1424  * @v xfer              Plainstream data transfer interface
1425  * @ret len             Length of window
1426  */
1427 static size_t tls_plainstream_window ( struct xfer_interface *xfer ) {
1428         struct tls_session *tls =
1429                 container_of ( xfer, struct tls_session, plainstream.xfer );
1430
1431         /* Block window unless we are ready to accept data */
1432         if ( tls->tx_state != TLS_TX_DATA )
1433                 return 0;
1434
1435         return filter_window ( xfer );
1436 }
1437
1438 /**
1439  * Deliver datagram as raw data
1440  *
1441  * @v xfer              Plainstream data transfer interface
1442  * @v data              Data buffer
1443  * @v len               Length of data buffer
1444  * @ret rc              Return status code
1445  */
1446 static int tls_plainstream_deliver_raw ( struct xfer_interface *xfer,
1447                                          const void *data, size_t len ) {
1448         struct tls_session *tls =
1449                 container_of ( xfer, struct tls_session, plainstream.xfer );
1450         
1451         /* Refuse unless we are ready to accept data */
1452         if ( tls->tx_state != TLS_TX_DATA )
1453                 return -ENOTCONN;
1454
1455         return tls_send_plaintext ( tls, TLS_TYPE_DATA, data, len );
1456 }
1457
1458 /** TLS plaintext stream operations */
1459 static struct xfer_interface_operations tls_plainstream_operations = {
1460         .close          = tls_plainstream_close,
1461         .vredirect      = ignore_xfer_vredirect,
1462         .seek           = filter_seek,
1463         .window         = tls_plainstream_window,
1464         .alloc_iob      = default_xfer_alloc_iob,
1465         .deliver_iob    = xfer_deliver_as_raw,
1466         .deliver_raw    = tls_plainstream_deliver_raw,
1467 };
1468
1469 /******************************************************************************
1470  *
1471  * Ciphertext stream operations
1472  *
1473  ******************************************************************************
1474  */
1475
1476 /**
1477  * Close interface
1478  *
1479  * @v xfer              Plainstream data transfer interface
1480  * @v rc                Reason for close
1481  */
1482 static void tls_cipherstream_close ( struct xfer_interface *xfer, int rc ) {
1483         struct tls_session *tls =
1484                 container_of ( xfer, struct tls_session, cipherstream.xfer );
1485
1486         tls_close ( tls, rc );
1487 }
1488
1489 /**
1490  * Handle received TLS header
1491  *
1492  * @v tls               TLS session
1493  * @ret rc              Returned status code
1494  */
1495 static int tls_newdata_process_header ( struct tls_session *tls ) {
1496         size_t data_len = ntohs ( tls->rx_header.length );
1497
1498         /* Allocate data buffer now that we know the length */
1499         assert ( tls->rx_data == NULL );
1500         tls->rx_data = malloc ( data_len );
1501         if ( ! tls->rx_data ) {
1502                 DBGC ( tls, "TLS %p could not allocate %zd bytes "
1503                        "for receive buffer\n", tls, data_len );
1504                 return -ENOMEM;
1505         }
1506
1507         /* Move to data state */
1508         tls->rx_state = TLS_RX_DATA;
1509
1510         return 0;
1511 }
1512
1513 /**
1514  * Handle received TLS data payload
1515  *
1516  * @v tls               TLS session
1517  * @ret rc              Returned status code
1518  */
1519 static int tls_newdata_process_data ( struct tls_session *tls ) {
1520         int rc;
1521
1522         /* Process record */
1523         if ( ( rc = tls_new_ciphertext ( tls, &tls->rx_header,
1524                                          tls->rx_data ) ) != 0 )
1525                 return rc;
1526
1527         /* Increment RX sequence number */
1528         tls->rx_seq += 1;
1529
1530         /* Free data buffer */
1531         free ( tls->rx_data );
1532         tls->rx_data = NULL;
1533
1534         /* Return to header state */
1535         tls->rx_state = TLS_RX_HEADER;
1536
1537         return 0;
1538 }
1539
1540 /**
1541  * Receive new ciphertext
1542  *
1543  * @v app               Stream application
1544  * @v data              Data received
1545  * @v len               Length of received data
1546  * @ret rc              Return status code
1547  */
1548 static int tls_cipherstream_deliver_raw ( struct xfer_interface *xfer,
1549                                           const void *data, size_t len ) {
1550         struct tls_session *tls = 
1551                 container_of ( xfer, struct tls_session, cipherstream.xfer );
1552         size_t frag_len;
1553         void *buf;
1554         size_t buf_len;
1555         int ( * process ) ( struct tls_session *tls );
1556         int rc;
1557
1558         while ( len ) {
1559                 /* Select buffer according to current state */
1560                 switch ( tls->rx_state ) {
1561                 case TLS_RX_HEADER:
1562                         buf = &tls->rx_header;
1563                         buf_len = sizeof ( tls->rx_header );
1564                         process = tls_newdata_process_header;
1565                         break;
1566                 case TLS_RX_DATA:
1567                         buf = tls->rx_data;
1568                         buf_len = ntohs ( tls->rx_header.length );
1569                         process = tls_newdata_process_data;
1570                         break;
1571                 default:
1572                         assert ( 0 );
1573                         return -EINVAL;
1574                 }
1575
1576                 /* Copy data portion to buffer */
1577                 frag_len = ( buf_len - tls->rx_rcvd );
1578                 if ( frag_len > len )
1579                         frag_len = len;
1580                 memcpy ( ( buf + tls->rx_rcvd ), data, frag_len );
1581                 tls->rx_rcvd += frag_len;
1582                 data += frag_len;
1583                 len -= frag_len;
1584
1585                 /* Process data if buffer is now full */
1586                 if ( tls->rx_rcvd == buf_len ) {
1587                         if ( ( rc = process ( tls ) ) != 0 ) {
1588                                 tls_close ( tls, rc );
1589                                 return rc;
1590                         }
1591                         tls->rx_rcvd = 0;
1592                 }
1593         }
1594
1595         return 0;
1596 }
1597
1598 /** TLS ciphertext stream operations */
1599 static struct xfer_interface_operations tls_cipherstream_operations = {
1600         .close          = tls_cipherstream_close,
1601         .vredirect      = xfer_vopen,
1602         .seek           = filter_seek,
1603         .window         = filter_window,
1604         .alloc_iob      = default_xfer_alloc_iob,
1605         .deliver_iob    = xfer_deliver_as_raw,
1606         .deliver_raw    = tls_cipherstream_deliver_raw,
1607 };
1608
1609 /******************************************************************************
1610  *
1611  * Controlling process
1612  *
1613  ******************************************************************************
1614  */
1615
1616 /**
1617  * TLS TX state machine
1618  *
1619  * @v process           TLS process
1620  */
1621 static void tls_step ( struct process *process ) {
1622         struct tls_session *tls =
1623                 container_of ( process, struct tls_session, process );
1624         int rc;
1625
1626         /* Wait for cipherstream to become ready */
1627         if ( ! xfer_window ( &tls->cipherstream.xfer ) )
1628                 return;
1629
1630         switch ( tls->tx_state ) {
1631         case TLS_TX_NONE:
1632                 /* Nothing to do */
1633                 break;
1634         case TLS_TX_CLIENT_HELLO:
1635                 /* Send Client Hello */
1636                 if ( ( rc = tls_send_client_hello ( tls ) ) != 0 ) {
1637                         DBGC ( tls, "TLS %p could not send Client Hello: %s\n",
1638                                tls, strerror ( rc ) );
1639                         goto err;
1640                 }
1641                 tls->tx_state = TLS_TX_NONE;
1642                 break;
1643         case TLS_TX_CLIENT_KEY_EXCHANGE:
1644                 /* Send Client Key Exchange */
1645                 if ( ( rc = tls_send_client_key_exchange ( tls ) ) != 0 ) {
1646                         DBGC ( tls, "TLS %p could send Client Key Exchange: "
1647                                "%s\n", tls, strerror ( rc ) );
1648                         goto err;
1649                 }
1650                 tls->tx_state = TLS_TX_CHANGE_CIPHER;
1651                 break;
1652         case TLS_TX_CHANGE_CIPHER:
1653                 /* Send Change Cipher, and then change the cipher in use */
1654                 if ( ( rc = tls_send_change_cipher ( tls ) ) != 0 ) {
1655                         DBGC ( tls, "TLS %p could not send Change Cipher: "
1656                                "%s\n", tls, strerror ( rc ) );
1657                         goto err;
1658                 }
1659                 if ( ( rc = tls_change_cipher ( tls,
1660                                                 &tls->tx_cipherspec_pending,
1661                                                 &tls->tx_cipherspec )) != 0 ){
1662                         DBGC ( tls, "TLS %p could not activate TX cipher: "
1663                                "%s\n", tls, strerror ( rc ) );
1664                         goto err;
1665                 }
1666                 tls->tx_seq = 0;
1667                 tls->tx_state = TLS_TX_FINISHED;
1668                 break;
1669         case TLS_TX_FINISHED:
1670                 /* Send Finished */
1671                 if ( ( rc = tls_send_finished ( tls ) ) != 0 ) {
1672                         DBGC ( tls, "TLS %p could not send Finished: %s\n",
1673                                tls, strerror ( rc ) );
1674                         goto err;
1675                 }
1676                 tls->tx_state = TLS_TX_NONE;
1677                 break;
1678         case TLS_TX_DATA:
1679                 /* Nothing to do */
1680                 break;
1681         default:
1682                 assert ( 0 );
1683         }
1684
1685         return;
1686
1687  err:
1688         tls_close ( tls, rc );
1689 }
1690
1691 /******************************************************************************
1692  *
1693  * Instantiator
1694  *
1695  ******************************************************************************
1696  */
1697
1698 int add_tls ( struct xfer_interface *xfer, struct xfer_interface **next ) {
1699         struct tls_session *tls;
1700
1701         /* Allocate and initialise TLS structure */
1702         tls = malloc ( sizeof ( *tls ) );
1703         if ( ! tls )
1704                 return -ENOMEM;
1705         memset ( tls, 0, sizeof ( *tls ) );
1706         tls->refcnt.free = free_tls;
1707         filter_init ( &tls->plainstream, &tls_plainstream_operations,
1708                       &tls->cipherstream, &tls_cipherstream_operations,
1709                       &tls->refcnt );
1710         tls_clear_cipher ( tls, &tls->tx_cipherspec );
1711         tls_clear_cipher ( tls, &tls->tx_cipherspec_pending );
1712         tls_clear_cipher ( tls, &tls->rx_cipherspec );
1713         tls_clear_cipher ( tls, &tls->rx_cipherspec_pending );
1714         *( ( uint32_t * ) tls->client_random ) = 0; /* GMT Unix time */
1715         tls_generate_random ( ( tls->client_random + 4 ),
1716                               ( sizeof ( tls->client_random ) - 4 ) );
1717         *( ( uint16_t * ) tls->pre_master_secret )
1718                 = htons ( TLS_VERSION_TLS_1_0 );
1719         tls_generate_random ( ( tls->pre_master_secret + 2 ),
1720                               ( sizeof ( tls->pre_master_secret ) - 2 ) );
1721         digest_init ( &md5_algorithm, tls->handshake_md5_ctx );
1722         digest_init ( &sha1_algorithm, tls->handshake_sha1_ctx );
1723         tls->tx_state = TLS_TX_CLIENT_HELLO;
1724         process_init ( &tls->process, tls_step, &tls->refcnt );
1725
1726         /* Attach to parent interface, mortalise self, and return */
1727         xfer_plug_plug ( &tls->plainstream.xfer, xfer );
1728         *next = &tls->cipherstream.xfer;
1729         ref_put ( &tls->refcnt );
1730         return 0;
1731 }
1732