← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnutls26/trusty

« back to all changes in this revision

Viewing changes to lib/gnutls_pk.c

  • Committer: Package Import Robot
  • Author(s): Andreas Metzler
  • Date: 2011-10-01 15:28:13 UTC
  • mfrom: (12.1.20 sid)
  • Revision ID: package-import@ubuntu.com-20111001152813-yygm1c4cxonfxhzy
http://bugs.debian.org/640639
* New upstream version.
  + Allow CA importing of 0 certificates to succeed. Closes: #640639
* Add libp11-kit-dev to libgnutls-dev dependencies. (see #643811)
* [20_guiledocstring.diff] guile: Fix docstring extraction with CPP 4.5+.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/gnutls_pk.c
44
44
 */
45
45
int
46
46
_gnutls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
47
 
                           const gnutls_datum_t * plaintext,
48
 
                           bigint_t * params, unsigned params_len,
49
 
                           unsigned btype)
 
47
                           const gnutls_datum_t * plaintext,
 
48
                           bigint_t * params, unsigned params_len,
 
49
                           unsigned btype)
50
50
{
51
51
  unsigned int i, pad;
52
52
  int ret;
92
92
    case 2:
93
93
      /* using public key */
94
94
      if (params_len < RSA_PUBLIC_PARAMS)
95
 
        {
96
 
          gnutls_assert ();
97
 
          gnutls_free (edata);
98
 
          return GNUTLS_E_INTERNAL_ERROR;
99
 
        }
 
95
        {
 
96
          gnutls_assert ();
 
97
          gnutls_free (edata);
 
98
          return GNUTLS_E_INTERNAL_ERROR;
 
99
        }
100
100
 
101
101
      ret = _gnutls_rnd (GNUTLS_RND_RANDOM, ps, psize);
102
102
      if (ret < 0)
103
 
        {
104
 
          gnutls_assert ();
105
 
          gnutls_free (edata);
106
 
          return ret;
107
 
        }
 
103
        {
 
104
          gnutls_assert ();
 
105
          gnutls_free (edata);
 
106
          return ret;
 
107
        }
108
108
      for (i = 0; i < psize; i++)
109
 
        while (ps[i] == 0)
110
 
          {
111
 
            ret = _gnutls_rnd (GNUTLS_RND_RANDOM, &ps[i], 1);
112
 
            if (ret < 0)
113
 
              {
114
 
                gnutls_assert ();
115
 
                gnutls_free (edata);
116
 
                return ret;
117
 
              }
118
 
          }
 
109
        while (ps[i] == 0)
 
110
          {
 
111
            ret = _gnutls_rnd (GNUTLS_RND_RANDOM, &ps[i], 1);
 
112
            if (ret < 0)
 
113
              {
 
114
                gnutls_assert ();
 
115
                gnutls_free (edata);
 
116
                return ret;
 
117
              }
 
118
          }
119
119
      break;
120
120
    case 1:
121
121
      /* using private key */
122
122
 
123
123
      if (params_len < RSA_PRIVATE_PARAMS)
124
 
        {
125
 
          gnutls_assert ();
126
 
          gnutls_free (edata);
127
 
          return GNUTLS_E_INTERNAL_ERROR;
128
 
        }
 
124
        {
 
125
          gnutls_assert ();
 
126
          gnutls_free (edata);
 
127
          return GNUTLS_E_INTERNAL_ERROR;
 
128
        }
129
129
 
130
130
      for (i = 0; i < psize; i++)
131
 
        ps[i] = 0xff;
 
131
        ps[i] = 0xff;
132
132
      break;
133
133
    default:
134
134
      gnutls_assert ();
142
142
  to_encrypt.data = edata;
143
143
  to_encrypt.size = k;
144
144
 
145
 
  if (btype == 2)               /* encrypt */
 
145
  if (btype == 2)               /* encrypt */
146
146
    ret =
147
147
      _gnutls_pk_encrypt (GNUTLS_PK_RSA, &encrypted, &to_encrypt, &pk_params);
148
 
  else                          /* sign */
 
148
  else                          /* sign */
149
149
    ret =
150
150
      _gnutls_pk_sign (GNUTLS_PK_RSA, &encrypted, &to_encrypt, &pk_params);
151
151
 
174
174
      return 0;
175
175
    }
176
176
  else
177
 
    {                           /* psize > k !!! */
 
177
    {                           /* psize > k !!! */
178
178
      /* This is an impossible situation */
179
179
      gnutls_assert ();
180
180
      _gnutls_free_datum (&encrypted);
207
207
 */
208
208
int
209
209
_gnutls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
210
 
                           const gnutls_datum_t * ciphertext,
211
 
                           bigint_t * params, unsigned params_len,
212
 
                           unsigned btype)
 
210
                           const gnutls_datum_t * ciphertext,
 
211
                           bigint_t * params, unsigned params_len,
 
212
                           unsigned btype)
213
213
{
214
214
  unsigned int k, i;
215
215
  int ret;
239
239
  if (btype == 2)
240
240
    {
241
241
      ret =
242
 
        _gnutls_pk_decrypt (GNUTLS_PK_RSA, plaintext, ciphertext, &pk_params);
 
242
        _gnutls_pk_decrypt (GNUTLS_PK_RSA, plaintext, ciphertext, &pk_params);
243
243
    }
244
244
  else
245
245
    {
246
246
      ret =
247
 
        _gnutls_pk_encrypt (GNUTLS_PK_RSA, plaintext, ciphertext, &pk_params);
 
247
        _gnutls_pk_encrypt (GNUTLS_PK_RSA, plaintext, ciphertext, &pk_params);
248
248
    }
249
249
 
250
250
  if (ret < 0)
272
272
    {
273
273
    case 2:
274
274
      for (i = 2; i < plaintext->size; i++)
275
 
        {
276
 
          if (plaintext->data[i] == 0)
277
 
            {
278
 
              ret = 0;
279
 
              break;
280
 
            }
281
 
        }
 
275
        {
 
276
          if (plaintext->data[i] == 0)
 
277
            {
 
278
              ret = 0;
 
279
              break;
 
280
            }
 
281
        }
282
282
      break;
283
283
    case 1:
284
284
      for (i = 2; i < plaintext->size; i++)
285
 
        {
286
 
          if (plaintext->data[i] == 0 && i > 2)
287
 
            {
288
 
              ret = 0;
289
 
              break;
290
 
            }
291
 
          if (plaintext->data[i] != 0xff)
292
 
            {
293
 
              _gnutls_handshake_log ("PKCS #1 padding error");
294
 
              _gnutls_free_datum (plaintext);
295
 
              /* PKCS #1 padding error.  Don't use
296
 
                 GNUTLS_E_PKCS1_WRONG_PAD here.  */
297
 
              break;
298
 
            }
299
 
        }
 
285
        {
 
286
          if (plaintext->data[i] == 0 && i > 2)
 
287
            {
 
288
              ret = 0;
 
289
              break;
 
290
            }
 
291
          if (plaintext->data[i] != 0xff)
 
292
            {
 
293
              _gnutls_handshake_log ("PKCS #1 padding error");
 
294
              _gnutls_free_datum (plaintext);
 
295
              /* PKCS #1 padding error.  Don't use
 
296
                 GNUTLS_E_PKCS1_WRONG_PAD here.  */
 
297
              break;
 
298
            }
 
299
        }
300
300
      break;
301
301
    default:
302
302
      gnutls_assert ();
321
321
 
322
322
int
323
323
_gnutls_rsa_verify (const gnutls_datum_t * vdata,
324
 
                    const gnutls_datum_t * ciphertext, bigint_t * params,
325
 
                    int params_len, int btype)
 
324
                    const gnutls_datum_t * ciphertext, bigint_t * params,
 
325
                    int params_len, int btype)
326
326
{
327
327
 
328
328
  gnutls_datum_t plain;
331
331
  /* decrypt signature */
332
332
  if ((ret =
333
333
       _gnutls_pkcs1_rsa_decrypt (&plain, ciphertext, params, params_len,
334
 
                                  btype)) < 0)
 
334
                                  btype)) < 0)
335
335
    {
336
336
      gnutls_assert ();
337
337
      return ret;
353
353
 
354
354
  _gnutls_free_datum (&plain);
355
355
 
356
 
  return 0;                     /* ok */
 
356
  return 0;                     /* ok */
357
357
}
358
358
 
359
359
/* encodes the Dss-Sig-Value structure
366
366
 
367
367
  if ((result =
368
368
       asn1_create_element (_gnutls_get_gnutls_asn (),
369
 
                            "GNUTLS.DSASignatureValue",
370
 
                            &sig)) != ASN1_SUCCESS)
 
369
                            "GNUTLS.DSASignatureValue",
 
370
                            &sig)) != ASN1_SUCCESS)
371
371
    {
372
372
      gnutls_assert ();
373
373
      return _gnutls_asn2err (result);
407
407
 */
408
408
int
409
409
_gnutls_dsa_sign (gnutls_datum_t * signature,
410
 
                  const gnutls_datum_t * hash, bigint_t * params,
411
 
                  unsigned int params_len)
 
410
                  const gnutls_datum_t * hash, bigint_t * params,
 
411
                  unsigned int params_len)
412
412
{
413
413
  int ret;
414
414
  size_t i;
421
421
 
422
422
  k = hash->size;
423
423
  if (k < 20)
424
 
    {                           /* SHA1 or better only */
 
424
    {                           /* SHA1 or better only */
425
425
      gnutls_assert ();
426
426
      return GNUTLS_E_PK_SIGN_FAILED;
427
427
    }
442
442
 */
443
443
int
444
444
_gnutls_decode_ber_rs (const gnutls_datum_t * sig_value, bigint_t * r,
445
 
                       bigint_t * s)
 
445
                       bigint_t * s)
446
446
{
447
447
  ASN1_TYPE sig;
448
448
  int result;
449
449
 
450
450
  if ((result =
451
451
       asn1_create_element (_gnutls_get_gnutls_asn (),
452
 
                            "GNUTLS.DSASignatureValue",
453
 
                            &sig)) != ASN1_SUCCESS)
 
452
                            "GNUTLS.DSASignatureValue",
 
453
                            &sig)) != ASN1_SUCCESS)
454
454
    {
455
455
      gnutls_assert ();
456
456
      return _gnutls_asn2err (result);
490
490
 */
491
491
int
492
492
_gnutls_dsa_verify (const gnutls_datum_t * vdata,
493
 
                    const gnutls_datum_t * sig_value, bigint_t * params,
494
 
                    int params_len)
 
493
                    const gnutls_datum_t * sig_value, bigint_t * params,
 
494
                    int params_len)
495
495
{
496
496
 
497
497
  int ret, i;
502
502
  pk_params.params_nr = params_len;
503
503
 
504
504
  if (vdata->size < 20)
505
 
    {                           /* SHA1 or better only */
 
505
    { /* SHA1 or better only */
506
506
      gnutls_assert ();
507
507
      return GNUTLS_E_PK_SIG_VERIFY_FAILED;
508
508
    }
516
516
      return ret;
517
517
    }
518
518
 
519
 
  return 0;                     /* ok */
 
519
  return 0;                     /* ok */
520
520
}
521
521
 
522
522
/* some generic pk functions */
523
523
static int
524
524
_generate_params (int algo, bigint_t * resarr, unsigned int *resarr_len,
525
 
                  int bits)
 
525
                  int bits)
526
526
{
527
527
  gnutls_pk_params_st params;
528
528
  int ret;
540
540
    {
541
541
      *resarr_len = params.params_nr;
542
542
      for (i = 0; i < params.params_nr; i++)
543
 
        resarr[i] = params.params[i];
 
543
        resarr[i] = params.params[i];
544
544
    }
545
545
  else
546
546
    {
554
554
 
555
555
int
556
556
_gnutls_rsa_generate_params (bigint_t * resarr, unsigned int *resarr_len,
557
 
                             int bits)
 
557
                             int bits)
558
558
{
559
559
  return _generate_params (GNUTLS_PK_RSA, resarr, resarr_len, bits);
560
560
}
561
561
 
562
562
int
563
563
_gnutls_dsa_generate_params (bigint_t * resarr, unsigned int *resarr_len,
564
 
                             int bits)
 
564
                             int bits)
565
565
{
566
566
  return _generate_params (GNUTLS_PK_DSA, resarr, resarr_len, bits);
567
567
}
568
568
 
569
569
int
570
570
_gnutls_pk_params_copy (gnutls_pk_params_st * dst, bigint_t * params,
571
 
                        int params_len)
 
571
                        int params_len)
572
572
{
573
573
  int i, j;
574
574
  dst->params_nr = 0;
583
583
    {
584
584
      dst->params[i] = _gnutls_mpi_set (NULL, params[i]);
585
585
      if (dst->params[i] == NULL)
586
 
        {
587
 
          for (j = 0; j < i; j++)
588
 
            _gnutls_mpi_release (&dst->params[j]);
589
 
          return GNUTLS_E_MEMORY_ERROR;
590
 
        }
 
586
        {
 
587
          for (j = 0; j < i; j++)
 
588
            _gnutls_mpi_release (&dst->params[j]);
 
589
          return GNUTLS_E_MEMORY_ERROR;
 
590
        }
591
591
      dst->params_nr++;
592
592
    }
593
593
 
609
609
      _gnutls_mpi_release (&p->params[i]);
610
610
    }
611
611
}
 
612
 
 
613
int
 
614
_gnutls_calc_rsa_exp (bigint_t * params, unsigned int params_size)
 
615
{
 
616
  bigint_t tmp = _gnutls_mpi_alloc_like (params[0]);
 
617
 
 
618
  if (params_size < RSA_PRIVATE_PARAMS - 2)
 
619
    {
 
620
      gnutls_assert ();
 
621
      return GNUTLS_E_INTERNAL_ERROR;
 
622
    }
 
623
 
 
624
  if (tmp == NULL)
 
625
    {
 
626
      gnutls_assert ();
 
627
      return GNUTLS_E_MEMORY_ERROR;
 
628
    }
 
629
 
 
630
  /* [6] = d % p-1, [7] = d % q-1 */
 
631
  _gnutls_mpi_sub_ui (tmp, params[3], 1);
 
632
  params[6] = _gnutls_mpi_mod (params[2] /*d */ , tmp);
 
633
 
 
634
  _gnutls_mpi_sub_ui (tmp, params[4], 1);
 
635
  params[7] = _gnutls_mpi_mod (params[2] /*d */ , tmp);
 
636
 
 
637
  _gnutls_mpi_release (&tmp);
 
638
 
 
639
  if (params[7] == NULL || params[6] == NULL)
 
640
    {
 
641
      gnutls_assert ();
 
642
      return GNUTLS_E_MEMORY_ERROR;
 
643
    }
 
644
 
 
645
  return 0;
 
646
}
 
647
 
 
648
int
 
649
_gnutls_pk_get_hash_algorithm (gnutls_pk_algorithm_t pk, bigint_t * params,
 
650
                               int params_size,
 
651
                               gnutls_digest_algorithm_t * dig,
 
652
                               unsigned int *mand)
 
653
{
 
654
  if (mand)
 
655
    {
 
656
      if (pk == GNUTLS_PK_DSA)
 
657
        *mand = 1;
 
658
      else
 
659
        *mand = 0;
 
660
    }
 
661
 
 
662
  return _gnutls_x509_verify_algorithm ((gnutls_mac_algorithm_t *) dig,
 
663
                                        NULL, pk, params, params_size);
 
664
 
 
665
}