← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gnutls26/quantal

« back to all changes in this revision

Viewing changes to lib/gnutls_kx.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2011-05-20 13:07:18 UTC
  • mfrom: (12.1.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110520130718-db41dybbanzfvlji
Tags: 2.10.5-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Fix build failure with --no-add-needed.
  - Build for multiarch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/gnutls_kx.c
1
1
/*
2
 
 * Copyright (C) 2000, 2001, 2004, 2005, 2006, 2008  Free Software Foundation
 
2
 * Copyright (C) 2000, 2001, 2004, 2005, 2006, 2008, 2010 Free Software
 
3
 * Foundation, Inc.
3
4
 *
4
5
 * Author: Nikos Mavrogiannopoulos
5
6
 *
6
 
 * This file is part of GNUTLS.
 
7
 * This file is part of GnuTLS.
7
8
 *
8
 
 * The GNUTLS library is free software; you can redistribute it and/or
 
9
 * The GnuTLS is free software; you can redistribute it and/or
9
10
 * modify it under the terms of the GNU Lesser General Public License
10
11
 * as published by the Free Software Foundation; either version 2.1 of
11
12
 * the License, or (at your option) any later version.
65
66
                    _gnutls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
66
67
                                     sizeof (buf)));
67
68
  _gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
68
 
                    _gnutls_bin2hex (session->security_parameters.
69
 
                                     client_random, 32, buf, sizeof (buf)));
 
69
                    _gnutls_bin2hex (session->
 
70
                                     security_parameters.client_random, 32,
 
71
                                     buf, sizeof (buf)));
70
72
  _gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
71
 
                    _gnutls_bin2hex (session->security_parameters.
72
 
                                     server_random, 32, buf, sizeof (buf)));
 
73
                    _gnutls_bin2hex (session->
 
74
                                     security_parameters.server_random, 32,
 
75
                                     buf, sizeof (buf)));
73
76
 
74
77
  if (gnutls_protocol_get_version (session) == GNUTLS_SSL3)
75
78
    {
84
87
        _gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
85
88
                                      rnd, 2 * GNUTLS_RANDOM_SIZE,
86
89
                                      GNUTLS_MASTER_SIZE,
87
 
                                      session->security_parameters.
88
 
                                      master_secret);
 
90
                                      session->
 
91
                                      security_parameters.master_secret);
89
92
 
90
93
    }
91
94
  else if (session->security_parameters.extensions.oprfi_client_len > 0 &&
105
108
        }
106
109
 
107
110
      _gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
108
 
                        session->security_parameters.
109
 
                        extensions.oprfi_server_len,
110
 
                        _gnutls_bin2hex (session->security_parameters.
111
 
                                         extensions.oprfi_client,
112
 
                                         session->security_parameters.
113
 
                                         extensions.oprfi_client_len, buf,
 
111
                        session->security_parameters.extensions.
 
112
                        oprfi_server_len,
 
113
                        _gnutls_bin2hex (session->
 
114
                                         security_parameters.extensions.
 
115
                                         oprfi_client,
 
116
                                         session->
 
117
                                         security_parameters.extensions.
 
118
                                         oprfi_client_len, buf,
114
119
                                         sizeof (buf)));
115
120
      _gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
116
 
                        session->security_parameters.
117
 
                        extensions.oprfi_server_len,
118
 
                        _gnutls_bin2hex (session->security_parameters.
119
 
                                         extensions.oprfi_server,
120
 
                                         session->security_parameters.
121
 
                                         extensions.oprfi_server_len, buf,
 
121
                        session->security_parameters.extensions.
 
122
                        oprfi_server_len,
 
123
                        _gnutls_bin2hex (session->
 
124
                                         security_parameters.extensions.
 
125
                                         oprfi_server,
 
126
                                         session->
 
127
                                         security_parameters.extensions.
 
128
                                         oprfi_server_len, buf,
122
129
                                         sizeof (buf)));
123
130
 
124
131
      memcpy (rnd, session->security_parameters.client_random,
169
176
    return ret;
170
177
 
171
178
  _gnutls_hard_log ("INT: MASTER SECRET: %s\n",
172
 
                    _gnutls_bin2hex (session->security_parameters.
173
 
                                     master_secret, GNUTLS_MASTER_SIZE, buf,
174
 
                                     sizeof (buf)));
 
179
                    _gnutls_bin2hex (session->
 
180
                                     security_parameters.master_secret,
 
181
                                     GNUTLS_MASTER_SIZE, buf, sizeof (buf)));
175
182
 
176
183
  return ret;
177
184
}
236
243
  int data_size = 0;
237
244
  int ret = 0;
238
245
 
239
 
  if (session->internals.auth_struct->
240
 
      gnutls_generate_server_certificate_request == NULL)
 
246
  if (session->internals.
 
247
      auth_struct->gnutls_generate_server_certificate_request == NULL)
241
248
    return 0;
242
249
 
243
250
  if (session->internals.send_cert_req <= 0)
249
256
  if (again == 0)
250
257
    {
251
258
      data_size =
252
 
        session->internals.auth_struct->
253
 
        gnutls_generate_server_certificate_request (session, &data);
 
259
        session->internals.
 
260
        auth_struct->gnutls_generate_server_certificate_request (session,
 
261
                                                                 &data);
254
262
 
255
263
      if (data_size < 0)
256
264
        {
349
357
  if (again == 0)
350
358
    {
351
359
      data_size =
352
 
        session->internals.auth_struct->
353
 
        gnutls_generate_client_cert_vrfy (session, &data);
 
360
        session->internals.
 
361
        auth_struct->gnutls_generate_client_cert_vrfy (session, &data);
354
362
      if (data_size < 0)
355
363
        {
356
364
          gnutls_assert ();
427
435
  int datasize;
428
436
  int ret = 0;
429
437
 
430
 
  if (session->internals.auth_struct->
431
 
      gnutls_process_server_certificate_request != NULL)
 
438
  if (session->internals.
 
439
      auth_struct->gnutls_process_server_certificate_request != NULL)
432
440
    {
433
441
 
434
442
      ret =
443
451
        return 0;               /* ignored */
444
452
 
445
453
      ret =
446
 
        session->internals.auth_struct->
447
 
        gnutls_process_server_certificate_request (session, data, datasize);
 
454
        session->internals.
 
455
        auth_struct->gnutls_process_server_certificate_request (session, data,
 
456
                                                                datasize);
448
457
      gnutls_free (data);
449
458
      if (ret < 0)
450
459
        return ret;
515
524
          /* TLS 1.0 or SSL 3.0 with a valid certificate 
516
525
           */
517
526
          data_size =
518
 
            session->internals.auth_struct->
519
 
            gnutls_generate_client_certificate (session, &data);
 
527
            session->internals.
 
528
            auth_struct->gnutls_generate_client_certificate (session, &data);
520
529
 
521
530
          if (data_size < 0)
522
531
            {
577
586
  if (again == 0)
578
587
    {
579
588
      data_size =
580
 
        session->internals.auth_struct->
581
 
        gnutls_generate_server_certificate (session, &data);
 
589
        session->internals.
 
590
        auth_struct->gnutls_generate_server_certificate (session, &data);
582
591
 
583
592
      if (data_size < 0)
584
593
        {
672
681
          return 0;
673
682
        }
674
683
      ret =
675
 
        session->internals.auth_struct->
676
 
        gnutls_process_client_certificate (session, data, datasize);
 
684
        session->internals.
 
685
        auth_struct->gnutls_process_client_certificate (session, data,
 
686
                                                        datasize);
677
687
 
678
688
      gnutls_free (data);
679
689
      if (ret < 0 && ret != GNUTLS_E_NO_CERTIFICATE_FOUND)
717
727
        }
718
728
 
719
729
      ret =
720
 
        session->internals.auth_struct->
721
 
        gnutls_process_server_certificate (session, data, datasize);
 
730
        session->internals.
 
731
        auth_struct->gnutls_process_server_certificate (session, data,
 
732
                                                        datasize);
722
733
      gnutls_free (data);
723
734
      if (ret < 0)
724
735
        {
768
779
        }
769
780
 
770
781
      ret =
771
 
        session->internals.auth_struct->
772
 
        gnutls_process_client_cert_vrfy (session, data, datasize);
 
782
        session->internals.
 
783
        auth_struct->gnutls_process_client_cert_vrfy (session, data,
 
784
                                                      datasize);
773
785
      gnutls_free (data);
774
786
      if (ret < 0)
775
787
        return ret;