← Back to branch summary

~cpick/mongrel2/release

« back to all changes in this revision

Viewing changes to src/polarssl/ssl_srv.c

  • Committer: Chris Pick
  • Date: 2013-06-30 16:39:57 UTC
  • mfrom: (1106.1.15)
  • Revision ID: git-v1:ec39967acb6bc9867ed9b9dc3774304ca6b9c294
Merge tag 'v1.8.1' into debian

Hotfix for github issue 148

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/polarssl/ssl_srv.c
30
30
#include "polarssl/debug.h"
31
31
#include "polarssl/ssl.h"
32
32
 
33
 
#include <string.h>
 
33
#if defined(POLARSSL_PKCS11_C)
 
34
#include "polarssl/pkcs11.h"
 
35
#endif /* defined(POLARSSL_PKCS11_C) */
 
36
 
34
37
#include <stdlib.h>
35
38
#include <stdio.h>
36
39
#include <time.h>
37
40
 
38
41
static int ssl_parse_client_hello( ssl_context *ssl )
39
42
{
40
 
    int ret, i, j, n;
41
 
    int ciph_len, sess_len;
42
 
    int chal_len, comp_len;
 
43
    int ret;
 
44
    unsigned int i, j;
 
45
    size_t n;
 
46
    unsigned int ciph_len, sess_len;
 
47
    unsigned int chal_len, comp_len;
43
48
    unsigned char *buf, *p;
44
49
 
45
50
    SSL_DEBUG_MSG( 2, ( "=> parse client hello" ) );
108
113
        n = ssl->in_left - 5;
109
114
 
110
115
        /*
111
 
         *    0  .   1   cipherlist length
 
116
         *    0  .   1   ciphersuitelist length
112
117
         *    2  .   3   session id length
113
118
         *    4  .   5   challenge length
114
 
         *    6  .  ..   cipherlist
 
119
         *    6  .  ..   ciphersuitelist
115
120
         *   ..  .  ..   session id
116
121
         *   ..  .  ..   challenge
117
122
         */
133
138
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
134
139
        }
135
140
 
136
 
        if( sess_len < 0 || sess_len > 32 )
 
141
        if( sess_len > 32 )
137
142
        {
138
143
            SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
139
144
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
151
156
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
152
157
        }
153
158
 
154
 
        SSL_DEBUG_BUF( 3, "client hello, cipherlist",
 
159
        SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
155
160
                       buf + 6,  ciph_len );
156
161
        SSL_DEBUG_BUF( 3, "client hello, session id",
157
162
                       buf + 6 + ciph_len,  sess_len );
167
172
        memset( ssl->randbytes, 0, 64 );
168
173
        memcpy( ssl->randbytes + 32 - chal_len, p, chal_len );
169
174
 
170
 
        for( i = 0; ssl->ciphers[i] != 0; i++ )
 
175
        for( i = 0; ssl->ciphersuites[i] != 0; i++ )
171
176
        {
172
177
            for( j = 0, p = buf + 6; j < ciph_len; j += 3, p += 3 )
173
178
            {
174
179
                if( p[0] == 0 &&
175
180
                    p[1] == 0 &&
176
 
                    p[2] == ssl->ciphers[i] )
177
 
                    goto have_cipher;
 
181
                    p[2] == ssl->ciphersuites[i] )
 
182
                    goto have_ciphersuite;
178
183
            }
179
184
        }
180
185
    }
233
238
         *    10  .  37   random bytes
234
239
         *    38  .  38   session id length
235
240
         *    39  . 38+x  session id
236
 
         *   39+x . 40+x  cipherlist length
237
 
         *   41+x .  ..   cipherlist
 
241
         *   39+x . 40+x  ciphersuitelist length
 
242
         *   41+x .  ..   ciphersuitelist
238
243
         *    ..  .  ..   compression alg.
239
244
         *    ..  .  ..   extensions
240
245
         */
269
274
        /*
270
275
         * Check the handshake message length
271
276
         */
272
 
        if( buf[1] != 0 || n != 4 + ( ( buf[2] << 8 ) | buf[3] ) )
 
277
        if( buf[1] != 0 || n != (unsigned int) 4 + ( ( buf[2] << 8 ) | buf[3] ) )
273
278
        {
274
279
            SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
275
280
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
280
285
         */
281
286
        sess_len = buf[38];
282
287
 
283
 
        if( sess_len < 0 || sess_len > 32 )
 
288
        if( sess_len > 32 )
284
289
        {
285
290
            SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
286
291
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO );
291
296
        memcpy( ssl->session->id, buf + 39 , ssl->session->length );
292
297
 
293
298
        /*
294
 
         * Check the cipherlist length
 
299
         * Check the ciphersuitelist length
295
300
         */
296
301
        ciph_len = ( buf[39 + sess_len] << 8 )
297
302
                 | ( buf[40 + sess_len]      );
317
322
                       buf +  6,  32 );
318
323
        SSL_DEBUG_BUF( 3, "client hello, session id",
319
324
                       buf + 38,  sess_len );
320
 
        SSL_DEBUG_BUF( 3, "client hello, cipherlist",
 
325
        SSL_DEBUG_BUF( 3, "client hello, ciphersuitelist",
321
326
                       buf + 41 + sess_len,  ciph_len );
322
327
        SSL_DEBUG_BUF( 3, "client hello, compression",
323
328
                       buf + 42 + sess_len + ciph_len, comp_len );
324
329
 
325
330
        /*
326
 
         * Search for a matching cipher
 
331
         * Search for a matching ciphersuite
327
332
         */
328
 
        for( i = 0; ssl->ciphers[i] != 0; i++ )
 
333
        for( i = 0; ssl->ciphersuites[i] != 0; i++ )
329
334
        {
330
335
            for( j = 0, p = buf + 41 + sess_len; j < ciph_len;
331
336
                j += 2, p += 2 )
332
337
            {
333
 
                if( p[0] == 0 && p[1] == ssl->ciphers[i] )
334
 
                    goto have_cipher;
 
338
                if( p[0] == 0 && p[1] == ssl->ciphersuites[i] )
 
339
                    goto have_ciphersuite;
335
340
            }
336
341
        }
337
342
    }
338
343
 
339
 
    SSL_DEBUG_MSG( 1, ( "got no ciphers in common" ) );
 
344
    SSL_DEBUG_MSG( 1, ( "got no ciphersuites in common" ) );
340
345
 
341
346
    return( POLARSSL_ERR_SSL_NO_CIPHER_CHOSEN );
342
347
 
343
 
have_cipher:
 
348
have_ciphersuite:
344
349
 
345
 
    ssl->session->cipher = ssl->ciphers[i];
 
350
    ssl->session->ciphersuite = ssl->ciphersuites[i];
346
351
    ssl->in_left = 0;
347
352
    ssl->state++;
348
353
 
354
359
static int ssl_write_server_hello( ssl_context *ssl )
355
360
{
356
361
    time_t t;
357
 
    int ret, i, n;
 
362
    int ret, n;
358
363
    unsigned char *buf, *p;
359
364
 
360
365
    SSL_DEBUG_MSG( 2, ( "=> write server hello" ) );
383
388
 
384
389
    SSL_DEBUG_MSG( 3, ( "server hello, current time: %lu", t ) );
385
390
 
386
 
    for( i = 28; i > 0; i-- )
387
 
        *p++ = (unsigned char) ssl->f_rng( ssl->p_rng );
 
391
    if( ( ret = ssl->f_rng( ssl->p_rng, p, 28 ) ) != 0 )
 
392
        return( ret );
 
393
 
 
394
    p += 28;
388
395
 
389
396
    memcpy( ssl->randbytes + 32, buf + 6, 32 );
390
397
 
393
400
    /*
394
401
     *    38  .  38   session id length
395
402
     *    39  . 38+n  session id
396
 
     *   39+n . 40+n  chosen cipher
 
403
     *   39+n . 40+n  chosen ciphersuite
397
404
     *   41+n . 41+n  chosen compression alg.
398
405
     */
399
406
    ssl->session->length = n = 32;
408
415
        ssl->resume = 0;
409
416
        ssl->state++;
410
417
 
411
 
        for( i = 0; i < n; i++ )
412
 
            ssl->session->id[i] =
413
 
                (unsigned char) ssl->f_rng( ssl->p_rng );
 
418
        if( ssl->session == NULL )
 
419
        {
 
420
            SSL_DEBUG_MSG( 1, ( "No session struct set" ) );
 
421
            return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
 
422
        }
 
423
 
 
424
        if( ( ret = ssl->f_rng( ssl->p_rng, ssl->session->id, n ) ) != 0 )
 
425
            return( ret );
414
426
    }
415
427
    else
416
428
    {
435
447
    SSL_DEBUG_MSG( 3, ( "%s session has been resumed",
436
448
                   ssl->resume ? "a" : "no" ) );
437
449
 
438
 
    *p++ = (unsigned char)( ssl->session->cipher >> 8 );
439
 
    *p++ = (unsigned char)( ssl->session->cipher      );
 
450
    *p++ = (unsigned char)( ssl->session->ciphersuite >> 8 );
 
451
    *p++ = (unsigned char)( ssl->session->ciphersuite      );
440
452
    *p++ = SSL_COMPRESS_NULL;
441
453
 
442
 
    SSL_DEBUG_MSG( 3, ( "server hello, chosen cipher: %d",
443
 
                   ssl->session->cipher ) );
 
454
    SSL_DEBUG_MSG( 3, ( "server hello, chosen ciphersuite: %d",
 
455
                   ssl->session->ciphersuite ) );
444
456
    SSL_DEBUG_MSG( 3, ( "server hello, compress alg.: %d", 0 ) );
445
457
 
446
458
    ssl->out_msglen  = p - buf;
456
468
 
457
469
static int ssl_write_certificate_request( ssl_context *ssl )
458
470
{
459
 
    int ret, n;
 
471
    int ret;
 
472
    size_t n;
460
473
    unsigned char *buf, *p;
461
474
    const x509_cert *crt;
462
475
 
521
534
 
522
535
static int ssl_write_server_key_exchange( ssl_context *ssl )
523
536
{
524
 
    int ret, n;
 
537
#if defined(POLARSSL_DHM_C)
 
538
    int ret;
 
539
    size_t n, rsa_key_len = 0;
525
540
    unsigned char hash[36];
526
541
    md5_context md5;
527
542
    sha1_context sha1;
 
543
#endif
528
544
 
529
545
    SSL_DEBUG_MSG( 2, ( "=> write server key exchange" ) );
530
546
 
531
 
    if( ssl->session->cipher != SSL_EDH_RSA_DES_168_SHA &&
532
 
        ssl->session->cipher != SSL_EDH_RSA_AES_128_SHA &&
533
 
        ssl->session->cipher != SSL_EDH_RSA_AES_256_SHA &&
534
 
        ssl->session->cipher != SSL_EDH_RSA_CAMELLIA_128_SHA &&
535
 
            ssl->session->cipher != SSL_EDH_RSA_CAMELLIA_256_SHA)
 
547
    if( ssl->session->ciphersuite != SSL_EDH_RSA_DES_168_SHA &&
 
548
        ssl->session->ciphersuite != SSL_EDH_RSA_AES_128_SHA &&
 
549
        ssl->session->ciphersuite != SSL_EDH_RSA_AES_256_SHA &&
 
550
        ssl->session->ciphersuite != SSL_EDH_RSA_CAMELLIA_128_SHA &&
 
551
        ssl->session->ciphersuite != SSL_EDH_RSA_CAMELLIA_256_SHA)
536
552
    {
537
553
        SSL_DEBUG_MSG( 2, ( "<= skip write server key exchange" ) );
538
554
        ssl->state++;
543
559
    SSL_DEBUG_MSG( 1, ( "support for dhm is not available" ) );
544
560
    return( POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE );
545
561
#else
 
562
 
 
563
    if( ssl->rsa_key == NULL )
 
564
    {
 
565
#if defined(POLARSSL_PKCS11_C)
 
566
        if( ssl->pkcs11_key == NULL )
 
567
        {
 
568
#endif /* defined(POLARSSL_PKCS11_C) */
 
569
            SSL_DEBUG_MSG( 1, ( "got no private key" ) );
 
570
            return( POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
 
571
#if defined(POLARSSL_PKCS11_C)
 
572
        }
 
573
#endif /* defined(POLARSSL_PKCS11_C) */
 
574
    }
 
575
 
546
576
    /*
547
577
     * Ephemeral DH parameters:
548
578
     *
589
619
 
590
620
    SSL_DEBUG_BUF( 3, "parameters hash", hash, 36 );
591
621
 
592
 
    ssl->out_msg[4 + n] = (unsigned char)( ssl->rsa_key->len >> 8 );
593
 
    ssl->out_msg[5 + n] = (unsigned char)( ssl->rsa_key->len      );
594
 
 
595
 
    ret = rsa_pkcs1_sign( ssl->rsa_key, RSA_PRIVATE,
596
 
                          SIG_RSA_RAW, 36, hash, ssl->out_msg + 6 + n );
 
622
    if ( ssl->rsa_key )
 
623
        rsa_key_len = ssl->rsa_key->len;
 
624
#if defined(POLARSSL_PKCS11_C)
 
625
    else
 
626
        rsa_key_len = ssl->pkcs11_key->len;
 
627
#endif /* defined(POLARSSL_PKCS11_C) */
 
628
 
 
629
    ssl->out_msg[4 + n] = (unsigned char)( rsa_key_len >> 8 );
 
630
    ssl->out_msg[5 + n] = (unsigned char)( rsa_key_len      );
 
631
 
 
632
    if ( ssl->rsa_key )
 
633
    {
 
634
        ret = rsa_pkcs1_sign( ssl->rsa_key, ssl->f_rng, ssl->p_rng,
 
635
                              RSA_PRIVATE,
 
636
                              SIG_RSA_RAW, 36, hash, ssl->out_msg + 6 + n );
 
637
    }
 
638
#if defined(POLARSSL_PKCS11_C)
 
639
    else {
 
640
        ret = pkcs11_sign( ssl->pkcs11_key, RSA_PRIVATE,
 
641
                              SIG_RSA_RAW, 36, hash, ssl->out_msg + 6 + n );
 
642
    }
 
643
#endif  /* defined(POLARSSL_PKCS11_C) */
 
644
 
597
645
    if( ret != 0 )
598
646
    {
599
 
        SSL_DEBUG_RET( 1, "rsa_pkcs1_sign", ret );
 
647
        SSL_DEBUG_RET( 1, "pkcs1_sign", ret );
600
648
        return( ret );
601
649
    }
602
650
 
603
 
    SSL_DEBUG_BUF( 3, "my RSA sig", ssl->out_msg + 6 + n,
604
 
                                    ssl->rsa_key->len );
 
651
    SSL_DEBUG_BUF( 3, "my RSA sig", ssl->out_msg + 6 + n, rsa_key_len );
605
652
 
606
 
    ssl->out_msglen  = 6 + n + ssl->rsa_key->len;
 
653
    ssl->out_msglen  = 6 + n + rsa_key_len;
607
654
    ssl->out_msgtype = SSL_MSG_HANDSHAKE;
608
655
    ssl->out_msg[0]  = SSL_HS_SERVER_KEY_EXCHANGE;
609
656
 
646
693
 
647
694
static int ssl_parse_client_key_exchange( ssl_context *ssl )
648
695
{
649
 
    int ret, i, n;
 
696
    int ret;
 
697
    size_t i, n = 0;
650
698
 
651
699
    SSL_DEBUG_MSG( 2, ( "=> parse client key exchange" ) );
652
700
 
668
716
        return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
669
717
    }
670
718
 
671
 
    if( ssl->session->cipher == SSL_EDH_RSA_DES_168_SHA ||
672
 
        ssl->session->cipher == SSL_EDH_RSA_AES_128_SHA ||
673
 
        ssl->session->cipher == SSL_EDH_RSA_AES_256_SHA ||
674
 
        ssl->session->cipher == SSL_EDH_RSA_CAMELLIA_128_SHA ||
675
 
            ssl->session->cipher == SSL_EDH_RSA_CAMELLIA_256_SHA)
 
719
    if( ssl->session->ciphersuite == SSL_EDH_RSA_DES_168_SHA ||
 
720
        ssl->session->ciphersuite == SSL_EDH_RSA_AES_128_SHA ||
 
721
        ssl->session->ciphersuite == SSL_EDH_RSA_AES_256_SHA ||
 
722
        ssl->session->ciphersuite == SSL_EDH_RSA_CAMELLIA_128_SHA ||
 
723
        ssl->session->ciphersuite == SSL_EDH_RSA_CAMELLIA_256_SHA)
676
724
    {
677
725
#if !defined(POLARSSL_DHM_C)
678
726
        SSL_DEBUG_MSG( 1, ( "support for dhm is not available" ) );
694
742
                                      ssl->in_msg + 6, n ) ) != 0 )
695
743
        {
696
744
            SSL_DEBUG_RET( 1, "dhm_read_public", ret );
697
 
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE | ret );
 
745
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_DHM_RP );
698
746
        }
699
747
 
700
748
        SSL_DEBUG_MPI( 3, "DHM: GY", &ssl->dhm_ctx.GY );
705
753
                     ssl->premaster, &ssl->pmslen ) ) != 0 )
706
754
        {
707
755
            SSL_DEBUG_RET( 1, "dhm_calc_secret", ret );
708
 
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE | ret );
 
756
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_DHM_CS );
709
757
        }
710
758
 
711
759
        SSL_DEBUG_MPI( 3, "DHM: K ", &ssl->dhm_ctx.K  );
713
761
    }
714
762
    else
715
763
    {
 
764
        if( ssl->rsa_key == NULL )
 
765
        {
 
766
#if defined(POLARSSL_PKCS11_C)
 
767
                if( ssl->pkcs11_key == NULL )
 
768
                {
 
769
#endif
 
770
                    SSL_DEBUG_MSG( 1, ( "got no private key" ) );
 
771
                    return( POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED );
 
772
#if defined(POLARSSL_PKCS11_C)
 
773
                }
 
774
#endif
 
775
        }
 
776
 
716
777
        /*
717
778
         * Decrypt the premaster using own private RSA key
718
779
         */
719
780
        i = 4;
720
 
        n = ssl->rsa_key->len;
 
781
        if( ssl->rsa_key )
 
782
            n = ssl->rsa_key->len;
 
783
#if defined(POLARSSL_PKCS11_C)
 
784
        else
 
785
            n = ssl->pkcs11_key->len;
 
786
#endif
721
787
        ssl->pmslen = 48;
722
788
 
723
789
        if( ssl->minor_ver != SSL_MINOR_VERSION_0 )
737
803
            return( POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE );
738
804
        }
739
805
 
740
 
        ret = rsa_pkcs1_decrypt( ssl->rsa_key, RSA_PRIVATE, &ssl->pmslen,
741
 
                                 ssl->in_msg + i, ssl->premaster,
742
 
                                 sizeof(ssl->premaster) );
 
806
        if( ssl->rsa_key ) {
 
807
            ret = rsa_pkcs1_decrypt( ssl->rsa_key, RSA_PRIVATE, &ssl->pmslen,
 
808
                                 ssl->in_msg + i, ssl->premaster,
 
809
                                 sizeof(ssl->premaster) );
 
810
        }
 
811
#if defined(POLARSSL_PKCS11_C)
 
812
        else {
 
813
            ret = pkcs11_decrypt( ssl->pkcs11_key, RSA_PRIVATE, &ssl->pmslen,
 
814
                                 ssl->in_msg + i, ssl->premaster,
 
815
                                 sizeof(ssl->premaster) );
 
816
        }
 
817
#endif  /* defined(POLARSSL_PKCS11_C) */
743
818
 
744
819
        if( ret != 0 || ssl->pmslen != 48 ||
745
820
            ssl->premaster[0] != ssl->max_major_ver ||
755
830
             */
756
831
            ssl->pmslen = 48;
757
832
 
758
 
            for( i = 0; i < ssl->pmslen; i++ )
759
 
                ssl->premaster[i] = (unsigned char) ssl->f_rng( ssl->p_rng );
 
833
            ret = ssl->f_rng( ssl->p_rng, ssl->premaster, ssl->pmslen );
 
834
            if( ret != 0 )
 
835
                return( ret );
760
836
        }
761
837
    }
762
838
 
778
854
 
779
855
static int ssl_parse_certificate_verify( ssl_context *ssl )
780
856
{
781
 
    int n1, n2, ret;
 
857
    int ret;
 
858
    size_t n1, n2;
782
859
    unsigned char hash[36];
783
860
 
784
861
    SSL_DEBUG_MSG( 2, ( "=> parse certificate verify" ) );