← Back to branch summary

~ubuntu-branches/ubuntu/maverick/gnutls26/maverick-updates

« back to all changes in this revision

Viewing changes to lib/gnutls_dh_primes.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Metzler
  • Date: 2009-04-14 14:23:19 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20090414142319-ok7xejzbqkofno1q
Tags: 2.6.5-1
* Sync sections in debian/control with override file. libgnutls26-dbg is
  section debug, guile-gnutls is section lisp.
* New upstream version. (Needed for Libtasn1-3 2.0)
* New patch 15_tasn1inpc.diff. Make sure libtasn1 is listed in Libs.private.
* Standards-Version: 3.8.1, no changes required.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/gnutls_dh_primes.c
28
28
#include <x509_b64.h>           /* for PKCS3 PEM decoding */
29
29
#include <gnutls_global.h>
30
30
#include <gnutls_dh.h>
 
31
#include <gnutls_pk.h>
 
32
#include <gnutls/crypto.h>
31
33
#include "x509/x509_int.h"
32
34
#include "debug.h"
33
35
 
34
36
 
35
37
/* returns the prime and the generator of DH params.
36
38
 */
37
 
const mpi_t *
 
39
const bigint_t *
38
40
_gnutls_dh_params_to_mpi (gnutls_dh_params_t dh_primes)
39
41
{
40
42
  if (dh_primes == NULL || dh_primes->params[1] == NULL ||
46
48
  return dh_primes->params;
47
49
}
48
50
 
49
 
int
50
 
_gnutls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
51
 
{
52
 
  mpi_t g = NULL, prime = NULL;
53
 
  gcry_error_t err;
54
 
  int result, times = 0, qbits;
55
 
  mpi_t *factors = NULL;
56
 
 
57
 
  /* Calculate the size of a prime factor of (prime-1)/2.
58
 
   * This is an emulation of the values in "Selecting Cryptographic Key Sizes" paper.
59
 
   */
60
 
  if (bits < 256)
61
 
    qbits = bits / 2;
62
 
  else
63
 
    {
64
 
      qbits = (bits/40) + 105;
65
 
    }
66
 
 
67
 
  if (qbits & 1)                /* better have an even number */
68
 
    qbits++;
69
 
 
70
 
  /* find a prime number of size bits.
71
 
   */
72
 
  do
73
 
    {
74
 
 
75
 
      if (times)
76
 
        {
77
 
          _gnutls_mpi_release (&prime);
78
 
          gcry_prime_release_factors (factors);
79
 
        }
80
 
 
81
 
      err = gcry_prime_generate (&prime, bits, qbits,
82
 
                                 &factors, NULL, NULL, GCRY_STRONG_RANDOM,
83
 
                                 GCRY_PRIME_FLAG_SPECIAL_FACTOR);
84
 
 
85
 
      if (err != 0)
86
 
        {
87
 
          gnutls_assert ();
88
 
          result = GNUTLS_E_INTERNAL_ERROR;
89
 
          goto cleanup;
90
 
        }
91
 
 
92
 
      err = gcry_prime_check (prime, 0);
93
 
 
94
 
      times++;
95
 
    }
96
 
  while (err != 0 && times < 10);
97
 
 
98
 
  if (err != 0)
99
 
    {
100
 
      gnutls_assert ();
101
 
      result = GNUTLS_E_INTERNAL_ERROR;
102
 
      goto cleanup;
103
 
    }
104
 
 
105
 
  /* generate the group generator.
106
 
   */
107
 
  err = gcry_prime_group_generator (&g, prime, factors, NULL);
108
 
  if (err != 0)
109
 
    {
110
 
      gnutls_assert ();
111
 
      result = GNUTLS_E_INTERNAL_ERROR;
112
 
      goto cleanup;
113
 
    }
114
 
 
115
 
  gcry_prime_release_factors (factors);
116
 
  factors = NULL;
117
 
 
118
 
  if (ret_g)
119
 
    *ret_g = g;
120
 
  else
121
 
    _gnutls_mpi_release (&g);
122
 
  if (ret_n)
123
 
    *ret_n = prime;
124
 
  else
125
 
    _gnutls_mpi_release (&prime);
126
 
 
127
 
  return 0;
128
 
 
129
 
cleanup:
130
 
  gcry_prime_release_factors (factors);
131
 
  _gnutls_mpi_release (&g);
132
 
  _gnutls_mpi_release (&prime);
133
 
 
134
 
  return result;
135
 
 
136
 
}
137
51
 
138
52
/* Replaces the prime in the static DH parameters, with a randomly
139
53
 * generated one.
154
68
                             const gnutls_datum_t * prime,
155
69
                             const gnutls_datum_t * generator)
156
70
{
157
 
  mpi_t tmp_prime, tmp_g;
 
71
  bigint_t tmp_prime, tmp_g;
158
72
  size_t siz;
159
73
 
160
74
  siz = prime->size;
161
 
  if (_gnutls_mpi_scan_nz (&tmp_prime, prime->data, &siz))
 
75
  if (_gnutls_mpi_scan_nz (&tmp_prime, prime->data, siz))
162
76
    {
163
77
      gnutls_assert ();
164
78
      return GNUTLS_E_MPI_SCAN_FAILED;
165
79
    }
166
80
 
167
81
  siz = generator->size;
168
 
  if (_gnutls_mpi_scan_nz (&tmp_g, generator->data, &siz))
 
82
  if (_gnutls_mpi_scan_nz (&tmp_g, generator->data, siz))
169
83
    {
170
84
      _gnutls_mpi_release (&tmp_prime);
171
85
      gnutls_assert ();
268
182
gnutls_dh_params_generate2 (gnutls_dh_params_t params, unsigned int bits)
269
183
{
270
184
  int ret;
 
185
  gnutls_group_st group;
271
186
 
272
 
  ret = _gnutls_dh_generate_prime (&params->params[1],
273
 
                                   &params->params[0], bits);
 
187
  ret = _gnutls_mpi_generate_group (&group, bits);
274
188
  if (ret < 0)
275
189
    {
276
190
      gnutls_assert ();
277
191
      return ret;
278
192
    }
279
193
 
 
194
  params->params[0] = group.p;
 
195
  params->params[1] = group.g;
 
196
 
280
197
  return 0;
281
198
}
282
199
 
421
338
  opaque *p_data, *g_data;
422
339
  opaque *all_data;
423
340
 
424
 
  _gnutls_mpi_print_lz (NULL, &g_size, params->params[1]);
425
 
  _gnutls_mpi_print_lz (NULL, &p_size, params->params[0]);
 
341
  _gnutls_mpi_print_lz (params->params[1], NULL, &g_size);
 
342
  _gnutls_mpi_print_lz (params->params[0], NULL, &p_size);
426
343
 
427
344
  all_data = gnutls_malloc (g_size + p_size);
428
345
  if (all_data == NULL)
434
351
  p_data = &all_data[0];
435
352
  g_data = &all_data[p_size];
436
353
 
437
 
  _gnutls_mpi_print_lz (p_data, &p_size, params->params[0]);
438
 
  _gnutls_mpi_print_lz (g_data, &g_size, params->params[1]);
 
354
  _gnutls_mpi_print_lz (params->params[0], p_data, &p_size);
 
355
  _gnutls_mpi_print_lz (params->params[1], g_data, &g_size);
439
356
 
440
357
  /* Ok. Now we have the data. Create the asn1 structures
441
358
   */
547
464
          return GNUTLS_E_INTERNAL_ERROR;
548
465
        }
549
466
 
550
 
      if ((unsigned) result + 1 > *params_data_size)
 
467
      if ((unsigned) result > *params_data_size)
551
468
        {
552
469
          gnutls_assert ();
553
470
          gnutls_free (out);
554
 
          *params_data_size = result + 1;
 
471
          *params_data_size = result;
555
472
          return GNUTLS_E_SHORT_MEMORY_BUFFER;
556
473
        }
557
474
 
558
 
      *params_data_size = result;
 
475
      *params_data_size = result - 1;
559
476
 
560
477
      if (params_data)
561
 
        {
562
 
          memcpy (params_data, out, result);
563
 
          params_data[result] = 0;
564
 
        }
 
478
        memcpy (params_data, out, result);
 
479
 
565
480
      gnutls_free (out);
566
481
 
567
482
    }
586
501
                             gnutls_datum_t * prime,
587
502
                             gnutls_datum_t * generator, unsigned int *bits)
588
503
{
589
 
 
590
 
  size_t size;
 
504
  int ret;
591
505
 
592
506
  if (params->params[1] == NULL || params->params[0] == NULL)
593
507
    {
595
509
      return GNUTLS_E_INVALID_REQUEST;
596
510
    }
597
511
 
598
 
  size = 0;
599
 
  _gnutls_mpi_print (NULL, &size, params->params[1]);
600
 
 
601
 
  generator->data = gnutls_malloc (size);
602
 
  if (generator->data == NULL)
603
 
    {
604
 
      return GNUTLS_E_MEMORY_ERROR;
605
 
    }
606
 
 
607
 
  generator->size = size;
608
 
  _gnutls_mpi_print (generator->data, &size, params->params[1]);
609
 
 
610
 
 
611
 
  size = 0;
612
 
  _gnutls_mpi_print (NULL, &size, params->params[0]);
613
 
 
614
 
  prime->data = gnutls_malloc (size);
615
 
  if (prime->data == NULL)
616
 
    {
617
 
      gnutls_free (generator->data);
618
 
      generator->data = NULL;
619
 
      return GNUTLS_E_MEMORY_ERROR;
620
 
    }
621
 
  prime->size = size;
622
 
  _gnutls_mpi_print (prime->data, &size, params->params[0]);
 
512
  ret = _gnutls_mpi_dprint (params->params[1], generator);
 
513
  if (ret < 0)
 
514
    {
 
515
      gnutls_assert ();
 
516
      return ret;
 
517
    }
 
518
 
 
519
  ret = _gnutls_mpi_dprint (params->params[0], prime);
 
520
  if (ret < 0)
 
521
    {
 
522
      gnutls_assert ();
 
523
      _gnutls_free_datum (generator);
 
524
      return ret;
 
525
    }
623
526
 
624
527
  if (bits)
625
528
    *bits = _gnutls_mpi_get_nbits (params->params[0]);