pk: Allow the use of a hash element for DSA sign and verify.
[libgcrypt.git] / cipher / rsa.c
1 /* rsa.c - RSA implementation
2  * Copyright (C) 1997, 1998, 1999 by Werner Koch (dd9jn)
3  * Copyright (C) 2000, 2001, 2002, 2003, 2008 Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* This code uses an algorithm protected by U.S. Patent #4,405,829
22    which expired on September 20, 2000.  The patent holder placed that
23    patent into the public domain on Sep 6th, 2000.
24 */
25
26 #include <config.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <errno.h>
31
32 #include "g10lib.h"
33 #include "mpi.h"
34 #include "cipher.h"
35
36
37 typedef struct
38 {
39   gcry_mpi_t n;     /* modulus */
40   gcry_mpi_t e;     /* exponent */
41 } RSA_public_key;
42
43
44 typedef struct
45 {
46   gcry_mpi_t n;     /* public modulus */
47   gcry_mpi_t e;     /* public exponent */
48   gcry_mpi_t d;     /* exponent */
49   gcry_mpi_t p;     /* prime  p. */
50   gcry_mpi_t q;     /* prime  q. */
51   gcry_mpi_t u;     /* inverse of p mod q. */
52 } RSA_secret_key;
53
54
55 /* A sample 1024 bit RSA key used for the selftests.  */
56 static const char sample_secret_key[] =
57 "(private-key"
58 " (rsa"
59 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
60 "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
61 "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
62 "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)"
63 "  (e #010001#)"
64 "  (d #046129f2489d71579be0a75fe029bd6cdb574ebf57ea8a5b0fda942cab943b11"
65 "      7d7bb95e5d28875e0f9fc5fcc06a72f6d502464dabded78ef6b716177b83d5bd"
66 "      c543dc5d3fed932e59f5897e92e6f58a0f33424106a3b6fa2cbf877510e4ac21"
67 "      c3ee47851e97d12996222ac3566d4ccb0b83d164074abf7de655fc2446da1781#)"
68 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
69 "      fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)"
70 "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
71 "      35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361#)"
72 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
73 "      ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)))";
74 /* A sample 1024 bit RSA key used for the selftests (public only).  */
75 static const char sample_public_key[] =
76 "(public-key"
77 " (rsa"
78 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
79 "      2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
80 "      ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
81 "      891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)"
82 "  (e #010001#)))";
83
84
85
86 \f
87 static int test_keys (RSA_secret_key *sk, unsigned nbits);
88 static int  check_secret_key (RSA_secret_key *sk);
89 static void public (gcry_mpi_t output, gcry_mpi_t input, RSA_public_key *skey);
90 static void secret (gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey);
91
92
93 /* Check that a freshly generated key actually works.  Returns 0 on success. */
94 static int
95 test_keys (RSA_secret_key *sk, unsigned int nbits)
96 {
97   int result = -1; /* Default to failure.  */
98   RSA_public_key pk;
99   gcry_mpi_t plaintext = gcry_mpi_new (nbits);
100   gcry_mpi_t ciphertext = gcry_mpi_new (nbits);
101   gcry_mpi_t decr_plaintext = gcry_mpi_new (nbits);
102   gcry_mpi_t signature = gcry_mpi_new (nbits);
103
104   /* Put the relevant parameters into a public key structure.  */
105   pk.n = sk->n;
106   pk.e = sk->e;
107
108   /* Create a random plaintext.  */
109   gcry_mpi_randomize (plaintext, nbits, GCRY_WEAK_RANDOM);
110
111   /* Encrypt using the public key.  */
112   public (ciphertext, plaintext, &pk);
113
114   /* Check that the cipher text does not match the plaintext.  */
115   if (!gcry_mpi_cmp (ciphertext, plaintext))
116     goto leave; /* Ciphertext is identical to the plaintext.  */
117
118   /* Decrypt using the secret key.  */
119   secret (decr_plaintext, ciphertext, sk);
120
121   /* Check that the decrypted plaintext matches the original plaintext.  */
122   if (gcry_mpi_cmp (decr_plaintext, plaintext))
123     goto leave; /* Plaintext does not match.  */
124
125   /* Create another random plaintext as data for signature checking.  */
126   gcry_mpi_randomize (plaintext, nbits, GCRY_WEAK_RANDOM);
127
128   /* Use the RSA secret function to create a signature of the plaintext.  */
129   secret (signature, plaintext, sk);
130
131   /* Use the RSA public function to verify this signature.  */
132   public (decr_plaintext, signature, &pk);
133   if (gcry_mpi_cmp (decr_plaintext, plaintext))
134     goto leave; /* Signature does not match.  */
135
136   /* Modify the signature and check that the signing fails.  */
137   gcry_mpi_add_ui (signature, signature, 1);
138   public (decr_plaintext, signature, &pk);
139   if (!gcry_mpi_cmp (decr_plaintext, plaintext))
140     goto leave; /* Signature matches but should not.  */
141
142   result = 0; /* All tests succeeded.  */
143
144  leave:
145   gcry_mpi_release (signature);
146   gcry_mpi_release (decr_plaintext);
147   gcry_mpi_release (ciphertext);
148   gcry_mpi_release (plaintext);
149   return result;
150 }
151
152
153 /* Callback used by the prime generation to test whether the exponent
154    is suitable. Returns 0 if the test has been passed. */
155 static int
156 check_exponent (void *arg, gcry_mpi_t a)
157 {
158   gcry_mpi_t e = arg;
159   gcry_mpi_t tmp;
160   int result;
161
162   mpi_sub_ui (a, a, 1);
163   tmp = _gcry_mpi_alloc_like (a);
164   result = !gcry_mpi_gcd(tmp, e, a); /* GCD is not 1. */
165   gcry_mpi_release (tmp);
166   mpi_add_ui (a, a, 1);
167   return result;
168 }
169
170 /****************
171  * Generate a key pair with a key of size NBITS.
172  * USE_E = 0 let Libcgrypt decide what exponent to use.
173  *       = 1 request the use of a "secure" exponent; this is required by some
174  *           specification to be 65537.
175  *       > 2 Use this public exponent.  If the given exponent
176  *           is not odd one is internally added to it.
177  * TRANSIENT_KEY:  If true, generate the primes using the standard RNG.
178  * Returns: 2 structures filled with all needed values
179  */
180 static gpg_err_code_t
181 generate_std (RSA_secret_key *sk, unsigned int nbits, unsigned long use_e,
182               int transient_key)
183 {
184   gcry_mpi_t p, q; /* the two primes */
185   gcry_mpi_t d;    /* the private key */
186   gcry_mpi_t u;
187   gcry_mpi_t t1, t2;
188   gcry_mpi_t n;    /* the public key */
189   gcry_mpi_t e;    /* the exponent */
190   gcry_mpi_t phi;  /* helper: (p-1)(q-1) */
191   gcry_mpi_t g;
192   gcry_mpi_t f;
193   gcry_random_level_t random_level;
194
195   if (fips_mode ())
196     {
197       if (nbits < 1024)
198         return GPG_ERR_INV_VALUE;
199       if (transient_key)
200         return GPG_ERR_INV_VALUE;
201     }
202
203   /* The random quality depends on the transient_key flag.  */
204   random_level = transient_key ? GCRY_STRONG_RANDOM : GCRY_VERY_STRONG_RANDOM;
205
206   /* Make sure that nbits is even so that we generate p, q of equal size. */
207   if ( (nbits&1) )
208     nbits++;
209
210   if (use_e == 1)   /* Alias for a secure value */
211     use_e = 65537;  /* as demanded by Sphinx. */
212
213   /* Public exponent:
214      In general we use 41 as this is quite fast and more secure than the
215      commonly used 17.  Benchmarking the RSA verify function
216      with a 1024 bit key yields (2001-11-08):
217      e=17    0.54 ms
218      e=41    0.75 ms
219      e=257   0.95 ms
220      e=65537 1.80 ms
221   */
222   e = mpi_alloc( (32+BITS_PER_MPI_LIMB-1)/BITS_PER_MPI_LIMB );
223   if (!use_e)
224     mpi_set_ui (e, 41);     /* This is a reasonable secure and fast value */
225   else
226     {
227       use_e |= 1; /* make sure this is odd */
228       mpi_set_ui (e, use_e);
229     }
230
231   n = gcry_mpi_new (nbits);
232
233   p = q = NULL;
234   do
235     {
236       /* select two (very secret) primes */
237       if (p)
238         gcry_mpi_release (p);
239       if (q)
240         gcry_mpi_release (q);
241       if (use_e)
242         { /* Do an extra test to ensure that the given exponent is
243              suitable. */
244           p = _gcry_generate_secret_prime (nbits/2, random_level,
245                                            check_exponent, e);
246           q = _gcry_generate_secret_prime (nbits/2, random_level,
247                                            check_exponent, e);
248         }
249       else
250         { /* We check the exponent later. */
251           p = _gcry_generate_secret_prime (nbits/2, random_level, NULL, NULL);
252           q = _gcry_generate_secret_prime (nbits/2, random_level, NULL, NULL);
253         }
254       if (mpi_cmp (p, q) > 0 ) /* p shall be smaller than q (for calc of u)*/
255         mpi_swap(p,q);
256       /* calculate the modulus */
257       mpi_mul( n, p, q );
258     }
259   while ( mpi_get_nbits(n) != nbits );
260
261   /* calculate Euler totient: phi = (p-1)(q-1) */
262   t1 = mpi_alloc_secure( mpi_get_nlimbs(p) );
263   t2 = mpi_alloc_secure( mpi_get_nlimbs(p) );
264   phi = gcry_mpi_snew ( nbits );
265   g     = gcry_mpi_snew ( nbits );
266   f     = gcry_mpi_snew ( nbits );
267   mpi_sub_ui( t1, p, 1 );
268   mpi_sub_ui( t2, q, 1 );
269   mpi_mul( phi, t1, t2 );
270   gcry_mpi_gcd(g, t1, t2);
271   mpi_fdiv_q(f, phi, g);
272
273   while (!gcry_mpi_gcd(t1, e, phi)) /* (while gcd is not 1) */
274     {
275       if (use_e)
276         BUG (); /* The prime generator already made sure that we
277                    never can get to here. */
278       mpi_add_ui (e, e, 2);
279     }
280
281   /* calculate the secret key d = e^1 mod phi */
282   d = gcry_mpi_snew ( nbits );
283   mpi_invm(d, e, f );
284   /* calculate the inverse of p and q (used for chinese remainder theorem)*/
285   u = gcry_mpi_snew ( nbits );
286   mpi_invm(u, p, q );
287
288   if( DBG_CIPHER )
289     {
290       log_mpidump("  p= ", p );
291       log_mpidump("  q= ", q );
292       log_mpidump("phi= ", phi );
293       log_mpidump("  g= ", g );
294       log_mpidump("  f= ", f );
295       log_mpidump("  n= ", n );
296       log_mpidump("  e= ", e );
297       log_mpidump("  d= ", d );
298       log_mpidump("  u= ", u );
299     }
300
301   gcry_mpi_release (t1);
302   gcry_mpi_release (t2);
303   gcry_mpi_release (phi);
304   gcry_mpi_release (f);
305   gcry_mpi_release (g);
306
307   sk->n = n;
308   sk->e = e;
309   sk->p = p;
310   sk->q = q;
311   sk->d = d;
312   sk->u = u;
313
314   /* Now we can test our keys. */
315   if (test_keys (sk, nbits - 64))
316     {
317       gcry_mpi_release (sk->n); sk->n = NULL;
318       gcry_mpi_release (sk->e); sk->e = NULL;
319       gcry_mpi_release (sk->p); sk->p = NULL;
320       gcry_mpi_release (sk->q); sk->q = NULL;
321       gcry_mpi_release (sk->d); sk->d = NULL;
322       gcry_mpi_release (sk->u); sk->u = NULL;
323       fips_signal_error ("self-test after key generation failed");
324       return GPG_ERR_SELFTEST_FAILED;
325     }
326
327   return 0;
328 }
329
330
331 /* Helper for generate_x931.  */
332 static gcry_mpi_t
333 gen_x931_parm_xp (unsigned int nbits)
334 {
335   gcry_mpi_t xp;
336
337   xp = gcry_mpi_snew (nbits);
338   gcry_mpi_randomize (xp, nbits, GCRY_VERY_STRONG_RANDOM);
339
340   /* The requirement for Xp is:
341
342        sqrt{2}*2^{nbits-1} <= xp <= 2^{nbits} - 1
343
344      We set the two high order bits to 1 to satisfy the lower bound.
345      By using mpi_set_highbit we make sure that the upper bound is
346      satisfied as well.  */
347   mpi_set_highbit (xp, nbits-1);
348   mpi_set_bit (xp, nbits-2);
349   gcry_assert ( mpi_get_nbits (xp) == nbits );
350
351   return xp;
352 }
353
354
355 /* Helper for generate_x931.  */
356 static gcry_mpi_t
357 gen_x931_parm_xi (void)
358 {
359   gcry_mpi_t xi;
360
361   xi = gcry_mpi_snew (101);
362   gcry_mpi_randomize (xi, 101, GCRY_VERY_STRONG_RANDOM);
363   mpi_set_highbit (xi, 100);
364   gcry_assert ( mpi_get_nbits (xi) == 101 );
365
366   return xi;
367 }
368
369
370
371 /* Variant of the standard key generation code using the algorithm
372    from X9.31.  Using this algorithm has the advantage that the
373    generation can be made deterministic which is required for CAVS
374    testing.  */
375 static gpg_err_code_t
376 generate_x931 (RSA_secret_key *sk, unsigned int nbits, unsigned long e_value,
377                gcry_sexp_t deriveparms, int *swapped)
378 {
379   gcry_mpi_t p, q; /* The two primes.  */
380   gcry_mpi_t e;    /* The public exponent.  */
381   gcry_mpi_t n;    /* The public key.  */
382   gcry_mpi_t d;    /* The private key */
383   gcry_mpi_t u;    /* The inverse of p and q.  */
384   gcry_mpi_t pm1;  /* p - 1  */
385   gcry_mpi_t qm1;  /* q - 1  */
386   gcry_mpi_t phi;  /* Euler totient.  */
387   gcry_mpi_t f, g; /* Helper.  */
388
389   *swapped = 0;
390
391   if (e_value == 1)   /* Alias for a secure value. */
392     e_value = 65537;
393
394   /* Point 1 of section 4.1:  k = 1024 + 256s with S >= 0  */
395   if (nbits < 1024 || (nbits % 256))
396     return GPG_ERR_INV_VALUE;
397
398   /* Point 2:  2 <= bitlength(e) < 2^{k-2}
399      Note that we do not need to check the upper bound because we use
400      an unsigned long for E and thus there is no way for E to reach
401      that limit.  */
402   if (e_value < 3)
403     return GPG_ERR_INV_VALUE;
404
405   /* Our implementaion requires E to be odd.  */
406   if (!(e_value & 1))
407     return GPG_ERR_INV_VALUE;
408
409   /* Point 3:  e > 0 or e 0 if it is to be randomly generated.
410      We support only a fixed E and thus there is no need for an extra test.  */
411
412
413   /* Compute or extract the derive parameters.  */
414   {
415     gcry_mpi_t xp1 = NULL;
416     gcry_mpi_t xp2 = NULL;
417     gcry_mpi_t xp  = NULL;
418     gcry_mpi_t xq1 = NULL;
419     gcry_mpi_t xq2 = NULL;
420     gcry_mpi_t xq  = NULL;
421     gcry_mpi_t tmpval;
422
423     if (!deriveparms)
424       {
425         /* Not given: Generate them.  */
426         xp = gen_x931_parm_xp (nbits/2);
427         /* Make sure that |xp - xq| > 2^{nbits - 100} holds.  */
428         tmpval = gcry_mpi_snew (nbits/2);
429         do
430           {
431             gcry_mpi_release (xq);
432             xq = gen_x931_parm_xp (nbits/2);
433             mpi_sub (tmpval, xp, xq);
434           }
435         while (mpi_get_nbits (tmpval) <= (nbits/2 - 100));
436         gcry_mpi_release (tmpval);
437
438         xp1 = gen_x931_parm_xi ();
439         xp2 = gen_x931_parm_xi ();
440         xq1 = gen_x931_parm_xi ();
441         xq2 = gen_x931_parm_xi ();
442
443       }
444     else
445       {
446         /* Parameters to derive the key are given.  */
447         /* Note that we explicitly need to setup the values of tbl
448            because some compilers (e.g. OpenWatcom, IRIX) don't allow
449            to initialize a structure with automatic variables.  */
450         struct { const char *name; gcry_mpi_t *value; } tbl[] = {
451           { "Xp1" },
452           { "Xp2" },
453           { "Xp"  },
454           { "Xq1" },
455           { "Xq2" },
456           { "Xq"  },
457           { NULL }
458         };
459         int idx;
460         gcry_sexp_t oneparm;
461
462         tbl[0].value = &xp1;
463         tbl[1].value = &xp2;
464         tbl[2].value = &xp;
465         tbl[3].value = &xq1;
466         tbl[4].value = &xq2;
467         tbl[5].value = &xq;
468
469         for (idx=0; tbl[idx].name; idx++)
470           {
471             oneparm = gcry_sexp_find_token (deriveparms, tbl[idx].name, 0);
472             if (oneparm)
473               {
474                 *tbl[idx].value = gcry_sexp_nth_mpi (oneparm, 1,
475                                                      GCRYMPI_FMT_USG);
476                 gcry_sexp_release (oneparm);
477               }
478           }
479         for (idx=0; tbl[idx].name; idx++)
480           if (!*tbl[idx].value)
481             break;
482         if (tbl[idx].name)
483           {
484             /* At least one parameter is missing.  */
485             for (idx=0; tbl[idx].name; idx++)
486               gcry_mpi_release (*tbl[idx].value);
487             return GPG_ERR_MISSING_VALUE;
488           }
489       }
490
491     e = mpi_alloc_set_ui (e_value);
492
493     /* Find two prime numbers.  */
494     p = _gcry_derive_x931_prime (xp, xp1, xp2, e, NULL, NULL);
495     q = _gcry_derive_x931_prime (xq, xq1, xq2, e, NULL, NULL);
496     gcry_mpi_release (xp);  xp  = NULL;
497     gcry_mpi_release (xp1); xp1 = NULL;
498     gcry_mpi_release (xp2); xp2 = NULL;
499     gcry_mpi_release (xq);  xq  = NULL;
500     gcry_mpi_release (xq1); xq1 = NULL;
501     gcry_mpi_release (xq2); xq2 = NULL;
502     if (!p || !q)
503       {
504         gcry_mpi_release (p);
505         gcry_mpi_release (q);
506         gcry_mpi_release (e);
507         return GPG_ERR_NO_PRIME;
508       }
509   }
510
511
512   /* Compute the public modulus.  We make sure that p is smaller than
513      q to allow the use of the CRT.  */
514   if (mpi_cmp (p, q) > 0 )
515     {
516       mpi_swap (p, q);
517       *swapped = 1;
518     }
519   n = gcry_mpi_new (nbits);
520   mpi_mul (n, p, q);
521
522   /* Compute the Euler totient:  phi = (p-1)(q-1)  */
523   pm1 = gcry_mpi_snew (nbits/2);
524   qm1 = gcry_mpi_snew (nbits/2);
525   phi = gcry_mpi_snew (nbits);
526   mpi_sub_ui (pm1, p, 1);
527   mpi_sub_ui (qm1, q, 1);
528   mpi_mul (phi, pm1, qm1);
529
530   g = gcry_mpi_snew (nbits);
531   gcry_assert (gcry_mpi_gcd (g, e, phi));
532
533   /* Compute: f = lcm(p-1,q-1) = phi / gcd(p-1,q-1) */
534   gcry_mpi_gcd (g, pm1, qm1);
535   f = pm1; pm1 = NULL;
536   gcry_mpi_release (qm1); qm1 = NULL;
537   mpi_fdiv_q (f, phi, g);
538   gcry_mpi_release (phi); phi = NULL;
539   d = g; g = NULL;
540   /* Compute the secret key:  d = e^{-1} mod lcm(p-1,q-1) */
541   mpi_invm (d, e, f);
542
543   /* Compute the inverse of p and q.  */
544   u = f; f = NULL;
545   mpi_invm (u, p, q );
546
547   if( DBG_CIPHER )
548     {
549       if (*swapped)
550         log_debug ("p and q are swapped\n");
551       log_mpidump("  p", p );
552       log_mpidump("  q", q );
553       log_mpidump("  n", n );
554       log_mpidump("  e", e );
555       log_mpidump("  d", d );
556       log_mpidump("  u", u );
557     }
558
559
560   sk->n = n;
561   sk->e = e;
562   sk->p = p;
563   sk->q = q;
564   sk->d = d;
565   sk->u = u;
566
567   /* Now we can test our keys. */
568   if (test_keys (sk, nbits - 64))
569     {
570       gcry_mpi_release (sk->n); sk->n = NULL;
571       gcry_mpi_release (sk->e); sk->e = NULL;
572       gcry_mpi_release (sk->p); sk->p = NULL;
573       gcry_mpi_release (sk->q); sk->q = NULL;
574       gcry_mpi_release (sk->d); sk->d = NULL;
575       gcry_mpi_release (sk->u); sk->u = NULL;
576       fips_signal_error ("self-test after key generation failed");
577       return GPG_ERR_SELFTEST_FAILED;
578     }
579
580   return 0;
581 }
582
583
584 /****************
585  * Test whether the secret key is valid.
586  * Returns: true if this is a valid key.
587  */
588 static int
589 check_secret_key( RSA_secret_key *sk )
590 {
591   int rc;
592   gcry_mpi_t temp = mpi_alloc( mpi_get_nlimbs(sk->p)*2 );
593
594   mpi_mul(temp, sk->p, sk->q );
595   rc = mpi_cmp( temp, sk->n );
596   mpi_free(temp);
597   return !rc;
598 }
599
600
601
602 /****************
603  * Public key operation. Encrypt INPUT with PKEY and put result into OUTPUT.
604  *
605  *      c = m^e mod n
606  *
607  * Where c is OUTPUT, m is INPUT and e,n are elements of PKEY.
608  */
609 static void
610 public(gcry_mpi_t output, gcry_mpi_t input, RSA_public_key *pkey )
611 {
612   if( output == input )  /* powm doesn't like output and input the same */
613     {
614       gcry_mpi_t x = mpi_alloc( mpi_get_nlimbs(input)*2 );
615       mpi_powm( x, input, pkey->e, pkey->n );
616       mpi_set(output, x);
617       mpi_free(x);
618     }
619   else
620     mpi_powm( output, input, pkey->e, pkey->n );
621 }
622
623 #if 0
624 static void
625 stronger_key_check ( RSA_secret_key *skey )
626 {
627   gcry_mpi_t t = mpi_alloc_secure ( 0 );
628   gcry_mpi_t t1 = mpi_alloc_secure ( 0 );
629   gcry_mpi_t t2 = mpi_alloc_secure ( 0 );
630   gcry_mpi_t phi = mpi_alloc_secure ( 0 );
631
632   /* check that n == p * q */
633   mpi_mul( t, skey->p, skey->q);
634   if (mpi_cmp( t, skey->n) )
635     log_info ( "RSA Oops: n != p * q\n" );
636
637   /* check that p is less than q */
638   if( mpi_cmp( skey->p, skey->q ) > 0 )
639     {
640       log_info ("RSA Oops: p >= q - fixed\n");
641       _gcry_mpi_swap ( skey->p, skey->q);
642     }
643
644     /* check that e divides neither p-1 nor q-1 */
645     mpi_sub_ui(t, skey->p, 1 );
646     mpi_fdiv_r(t, t, skey->e );
647     if ( !mpi_cmp_ui( t, 0) )
648         log_info ( "RSA Oops: e divides p-1\n" );
649     mpi_sub_ui(t, skey->q, 1 );
650     mpi_fdiv_r(t, t, skey->e );
651     if ( !mpi_cmp_ui( t, 0) )
652         log_info ( "RSA Oops: e divides q-1\n" );
653
654     /* check that d is correct */
655     mpi_sub_ui( t1, skey->p, 1 );
656     mpi_sub_ui( t2, skey->q, 1 );
657     mpi_mul( phi, t1, t2 );
658     gcry_mpi_gcd(t, t1, t2);
659     mpi_fdiv_q(t, phi, t);
660     mpi_invm(t, skey->e, t );
661     if ( mpi_cmp(t, skey->d ) )
662       {
663         log_info ( "RSA Oops: d is wrong - fixed\n");
664         mpi_set (skey->d, t);
665         _gcry_log_mpidump ("  fixed d", skey->d);
666       }
667
668     /* check for correctness of u */
669     mpi_invm(t, skey->p, skey->q );
670     if ( mpi_cmp(t, skey->u ) )
671       {
672         log_info ( "RSA Oops: u is wrong - fixed\n");
673         mpi_set (skey->u, t);
674         _gcry_log_mpidump ("  fixed u", skey->u);
675       }
676
677     log_info ( "RSA secret key check finished\n");
678
679     mpi_free (t);
680     mpi_free (t1);
681     mpi_free (t2);
682     mpi_free (phi);
683 }
684 #endif
685
686
687
688 /****************
689  * Secret key operation. Encrypt INPUT with SKEY and put result into OUTPUT.
690  *
691  *      m = c^d mod n
692  *
693  * Or faster:
694  *
695  *      m1 = c ^ (d mod (p-1)) mod p
696  *      m2 = c ^ (d mod (q-1)) mod q
697  *      h = u * (m2 - m1) mod q
698  *      m = m1 + h * p
699  *
700  * Where m is OUTPUT, c is INPUT and d,n,p,q,u are elements of SKEY.
701  */
702 static void
703 secret (gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey )
704 {
705   if (!skey->p || !skey->q || !skey->u)
706     {
707       mpi_powm (output, input, skey->d, skey->n);
708     }
709   else
710     {
711       gcry_mpi_t m1 = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
712       gcry_mpi_t m2 = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
713       gcry_mpi_t h  = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
714
715       /* m1 = c ^ (d mod (p-1)) mod p */
716       mpi_sub_ui( h, skey->p, 1  );
717       mpi_fdiv_r( h, skey->d, h );
718       mpi_powm( m1, input, h, skey->p );
719       /* m2 = c ^ (d mod (q-1)) mod q */
720       mpi_sub_ui( h, skey->q, 1  );
721       mpi_fdiv_r( h, skey->d, h );
722       mpi_powm( m2, input, h, skey->q );
723       /* h = u * ( m2 - m1 ) mod q */
724       mpi_sub( h, m2, m1 );
725       if ( mpi_is_neg( h ) )
726         mpi_add ( h, h, skey->q );
727       mpi_mulm( h, skey->u, h, skey->q );
728       /* m = m2 + h * p */
729       mpi_mul ( h, h, skey->p );
730       mpi_add ( output, m1, h );
731
732       mpi_free ( h );
733       mpi_free ( m1 );
734       mpi_free ( m2 );
735     }
736 }
737
738
739
740 /* Perform RSA blinding.  */
741 static gcry_mpi_t
742 rsa_blind (gcry_mpi_t x, gcry_mpi_t r, gcry_mpi_t e, gcry_mpi_t n)
743 {
744   /* A helper.  */
745   gcry_mpi_t a;
746
747   /* Result.  */
748   gcry_mpi_t y;
749
750   a = gcry_mpi_snew (gcry_mpi_get_nbits (n));
751   y = gcry_mpi_snew (gcry_mpi_get_nbits (n));
752
753   /* Now we calculate: y = (x * r^e) mod n, where r is the random
754      number, e is the public exponent, x is the non-blinded data and n
755      is the RSA modulus.  */
756   gcry_mpi_powm (a, r, e, n);
757   gcry_mpi_mulm (y, a, x, n);
758
759   gcry_mpi_release (a);
760
761   return y;
762 }
763
764 /* Undo RSA blinding.  */
765 static gcry_mpi_t
766 rsa_unblind (gcry_mpi_t x, gcry_mpi_t ri, gcry_mpi_t n)
767 {
768   gcry_mpi_t y;
769
770   y = gcry_mpi_snew (gcry_mpi_get_nbits (n));
771
772   /* Here we calculate: y = (x * r^-1) mod n, where x is the blinded
773      decrypted data, ri is the modular multiplicative inverse of r and
774      n is the RSA modulus.  */
775
776   gcry_mpi_mulm (y, ri, x, n);
777
778   return y;
779 }
780
781 /*********************************************
782  **************  interface  ******************
783  *********************************************/
784
785 static gcry_err_code_t
786 rsa_generate_ext (int algo, unsigned int nbits, unsigned long evalue,
787                   const gcry_sexp_t genparms,
788                   gcry_mpi_t *skey, gcry_mpi_t **retfactors,
789                   gcry_sexp_t *r_extrainfo)
790 {
791   RSA_secret_key sk;
792   gpg_err_code_t ec;
793   gcry_sexp_t deriveparms;
794   int transient_key = 0;
795   int use_x931 = 0;
796   gcry_sexp_t l1;
797
798   (void)algo;
799
800   *retfactors = NULL; /* We don't return them.  */
801
802   deriveparms = (genparms?
803                  gcry_sexp_find_token (genparms, "derive-parms", 0) : NULL);
804   if (!deriveparms)
805     {
806       /* Parse the optional "use-x931" flag. */
807       l1 = gcry_sexp_find_token (genparms, "use-x931", 0);
808       if (l1)
809         {
810           use_x931 = 1;
811           gcry_sexp_release (l1);
812         }
813     }
814
815   if (deriveparms || use_x931 || fips_mode ())
816     {
817       int swapped;
818       ec = generate_x931 (&sk, nbits, evalue, deriveparms, &swapped);
819       gcry_sexp_release (deriveparms);
820       if (!ec && r_extrainfo && swapped)
821         {
822           ec = gcry_sexp_new (r_extrainfo,
823                               "(misc-key-info(p-q-swapped))", 0, 1);
824           if (ec)
825             {
826               gcry_mpi_release (sk.n); sk.n = NULL;
827               gcry_mpi_release (sk.e); sk.e = NULL;
828               gcry_mpi_release (sk.p); sk.p = NULL;
829               gcry_mpi_release (sk.q); sk.q = NULL;
830               gcry_mpi_release (sk.d); sk.d = NULL;
831               gcry_mpi_release (sk.u); sk.u = NULL;
832             }
833         }
834     }
835   else
836     {
837       /* Parse the optional "transient-key" flag. */
838       l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
839       if (l1)
840         {
841           transient_key = 1;
842           gcry_sexp_release (l1);
843         }
844       /* Generate.  */
845       ec = generate_std (&sk, nbits, evalue, transient_key);
846     }
847
848   if (!ec)
849     {
850       skey[0] = sk.n;
851       skey[1] = sk.e;
852       skey[2] = sk.d;
853       skey[3] = sk.p;
854       skey[4] = sk.q;
855       skey[5] = sk.u;
856     }
857
858   return ec;
859 }
860
861
862 static gcry_err_code_t
863 rsa_generate (int algo, unsigned int nbits, unsigned long evalue,
864               gcry_mpi_t *skey, gcry_mpi_t **retfactors)
865 {
866   return rsa_generate_ext (algo, nbits, evalue, NULL, skey, retfactors, NULL);
867 }
868
869
870 static gcry_err_code_t
871 rsa_check_secret_key (int algo, gcry_mpi_t *skey)
872 {
873   gcry_err_code_t err = GPG_ERR_NO_ERROR;
874   RSA_secret_key sk;
875
876   (void)algo;
877
878   sk.n = skey[0];
879   sk.e = skey[1];
880   sk.d = skey[2];
881   sk.p = skey[3];
882   sk.q = skey[4];
883   sk.u = skey[5];
884
885   if (!sk.p || !sk.q || !sk.u)
886     err = GPG_ERR_NO_OBJ;  /* To check the key we need the optional
887                               parameters. */
888   else if (!check_secret_key (&sk))
889     err = GPG_ERR_BAD_SECKEY;
890
891   return err;
892 }
893
894
895 static gcry_err_code_t
896 rsa_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data,
897              gcry_mpi_t *pkey, int flags)
898 {
899   RSA_public_key pk;
900
901   (void)algo;
902   (void)flags;
903
904   pk.n = pkey[0];
905   pk.e = pkey[1];
906   resarr[0] = mpi_alloc (mpi_get_nlimbs (pk.n));
907   public (resarr[0], data, &pk);
908
909   return GPG_ERR_NO_ERROR;
910 }
911
912
913 static gcry_err_code_t
914 rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data,
915              gcry_mpi_t *skey, int flags)
916 {
917   RSA_secret_key sk;
918   gcry_mpi_t r = MPI_NULL;      /* Random number needed for blinding.  */
919   gcry_mpi_t ri = MPI_NULL;     /* Modular multiplicative inverse of
920                                    r.  */
921   gcry_mpi_t x = MPI_NULL;      /* Data to decrypt.  */
922   gcry_mpi_t y;                 /* Result.  */
923
924   (void)algo;
925
926   /* Extract private key.  */
927   sk.n = skey[0];
928   sk.e = skey[1];
929   sk.d = skey[2];
930   sk.p = skey[3]; /* Optional. */
931   sk.q = skey[4]; /* Optional. */
932   sk.u = skey[5]; /* Optional. */
933
934   y = gcry_mpi_snew (gcry_mpi_get_nbits (sk.n));
935
936   /* We use blinding by default to mitigate timing attacks which can
937      be practically mounted over the network as shown by Brumley and
938      Boney in 2003.  */
939   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
940     {
941       /* Initialize blinding.  */
942
943       /* First, we need a random number r between 0 and n - 1, which
944          is relatively prime to n (i.e. it is neither p nor q).  The
945          random number needs to be only unpredictable, thus we employ
946          the gcry_create_nonce function by using GCRY_WEAK_RANDOM with
947          gcry_mpi_randomize.  */
948       r = gcry_mpi_snew (gcry_mpi_get_nbits (sk.n));
949       ri = gcry_mpi_snew (gcry_mpi_get_nbits (sk.n));
950
951       gcry_mpi_randomize (r, gcry_mpi_get_nbits (sk.n), GCRY_WEAK_RANDOM);
952       gcry_mpi_mod (r, r, sk.n);
953
954       /* Calculate inverse of r.  It practically impossible that the
955          following test fails, thus we do not add code to release
956          allocated resources.  */
957       if (!gcry_mpi_invm (ri, r, sk.n))
958         return GPG_ERR_INTERNAL;
959     }
960
961   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
962     x = rsa_blind (data[0], r, sk.e, sk.n);
963   else
964     x = data[0];
965
966   /* Do the encryption.  */
967   secret (y, x, &sk);
968
969   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
970     {
971       /* Undo blinding.  */
972       gcry_mpi_t a = gcry_mpi_copy (y);
973
974       gcry_mpi_release (y);
975       y = rsa_unblind (a, ri, sk.n);
976
977       gcry_mpi_release (a);
978     }
979
980   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
981     {
982       /* Deallocate resources needed for blinding.  */
983       gcry_mpi_release (x);
984       gcry_mpi_release (r);
985       gcry_mpi_release (ri);
986     }
987
988   /* Copy out result.  */
989   *result = y;
990
991   return GPG_ERR_NO_ERROR;
992 }
993
994
995 static gcry_err_code_t
996 rsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey,
997           int flags, int hashalgo)
998 {
999   RSA_secret_key sk;
1000
1001   (void)algo;
1002   (void)flags;
1003   (void)hashalgo;
1004
1005   if (mpi_is_opaque (data))
1006     return GPG_ERR_INV_DATA;
1007
1008   sk.n = skey[0];
1009   sk.e = skey[1];
1010   sk.d = skey[2];
1011   sk.p = skey[3];
1012   sk.q = skey[4];
1013   sk.u = skey[5];
1014   resarr[0] = mpi_alloc( mpi_get_nlimbs (sk.n));
1015   secret (resarr[0], data, &sk);
1016
1017   return GPG_ERR_NO_ERROR;
1018 }
1019
1020
1021 static gcry_err_code_t
1022 rsa_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
1023                   int (*cmp) (void *opaque, gcry_mpi_t tmp),
1024                   void *opaquev)
1025 {
1026   RSA_public_key pk;
1027   gcry_mpi_t result;
1028   gcry_err_code_t rc;
1029
1030   (void)algo;
1031   (void)cmp;
1032   (void)opaquev;
1033
1034   if (mpi_is_opaque (hash))
1035     return GPG_ERR_INV_DATA;
1036
1037   pk.n = pkey[0];
1038   pk.e = pkey[1];
1039   result = gcry_mpi_new ( 160 );
1040   public( result, data[0], &pk );
1041 #ifdef IS_DEVELOPMENT_VERSION
1042   if (DBG_CIPHER)
1043     {
1044       log_mpidump ("rsa verify result:", result );
1045       log_mpidump ("             hash:", hash );
1046     }
1047 #endif /*IS_DEVELOPMENT_VERSION*/
1048   if (cmp)
1049     rc = (*cmp) (opaquev, result);
1050   else
1051     rc = mpi_cmp (result, hash) ? GPG_ERR_BAD_SIGNATURE : GPG_ERR_NO_ERROR;
1052   gcry_mpi_release (result);
1053
1054   return rc;
1055 }
1056
1057
1058 static unsigned int
1059 rsa_get_nbits (int algo, gcry_mpi_t *pkey)
1060 {
1061   (void)algo;
1062
1063   return mpi_get_nbits (pkey[0]);
1064 }
1065
1066
1067 /* Compute a keygrip.  MD is the hash context which we are going to
1068    update.  KEYPARAM is an S-expression with the key parameters, this
1069    is usually a public key but may also be a secret key.  An example
1070    of such an S-expression is:
1071
1072       (rsa
1073         (n #00B...#)
1074         (e #010001#))
1075
1076    PKCS-15 says that for RSA only the modulus should be hashed -
1077    however, it is not clear whether this is meant to use the raw bytes
1078    (assuming this is an unsigned integer) or whether the DER required
1079    0 should be prefixed.  We hash the raw bytes.  */
1080 static gpg_err_code_t
1081 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
1082 {
1083   gcry_sexp_t l1;
1084   const char *data;
1085   size_t datalen;
1086
1087   l1 = gcry_sexp_find_token (keyparam, "n", 1);
1088   if (!l1)
1089     return GPG_ERR_NO_OBJ;
1090
1091   data = gcry_sexp_nth_data (l1, 1, &datalen);
1092   if (!data)
1093     {
1094       gcry_sexp_release (l1);
1095       return GPG_ERR_NO_OBJ;
1096     }
1097
1098   gcry_md_write (md, data, datalen);
1099   gcry_sexp_release (l1);
1100
1101   return 0;
1102 }
1103
1104
1105
1106 \f
1107 /*
1108      Self-test section.
1109  */
1110
1111 static const char *
1112 selftest_sign_1024 (gcry_sexp_t pkey, gcry_sexp_t skey)
1113 {
1114   static const char sample_data[] =
1115     "(data (flags pkcs1)"
1116     " (hash sha1 #11223344556677889900aabbccddeeff10203040#))";
1117   static const char sample_data_bad[] =
1118     "(data (flags pkcs1)"
1119     " (hash sha1 #11223344556677889900aabbccddeeff80203040#))";
1120
1121   const char *errtxt = NULL;
1122   gcry_error_t err;
1123   gcry_sexp_t data = NULL;
1124   gcry_sexp_t data_bad = NULL;
1125   gcry_sexp_t sig = NULL;
1126
1127   err = gcry_sexp_sscan (&data, NULL,
1128                          sample_data, strlen (sample_data));
1129   if (!err)
1130     err = gcry_sexp_sscan (&data_bad, NULL,
1131                            sample_data_bad, strlen (sample_data_bad));
1132   if (err)
1133     {
1134       errtxt = "converting data failed";
1135       goto leave;
1136     }
1137
1138   err = gcry_pk_sign (&sig, data, skey);
1139   if (err)
1140     {
1141       errtxt = "signing failed";
1142       goto leave;
1143     }
1144   err = gcry_pk_verify (sig, data, pkey);
1145   if (err)
1146     {
1147       errtxt = "verify failed";
1148       goto leave;
1149     }
1150   err = gcry_pk_verify (sig, data_bad, pkey);
1151   if (gcry_err_code (err) != GPG_ERR_BAD_SIGNATURE)
1152     {
1153       errtxt = "bad signature not detected";
1154       goto leave;
1155     }
1156
1157
1158  leave:
1159   gcry_sexp_release (sig);
1160   gcry_sexp_release (data_bad);
1161   gcry_sexp_release (data);
1162   return errtxt;
1163 }
1164
1165
1166
1167 /* Given an S-expression ENCR_DATA of the form:
1168
1169    (enc-val
1170     (rsa
1171      (a a-value)))
1172
1173    as returned by gcry_pk_decrypt, return the the A-VALUE.  On error,
1174    return NULL.  */
1175 static gcry_mpi_t
1176 extract_a_from_sexp (gcry_sexp_t encr_data)
1177 {
1178   gcry_sexp_t l1, l2, l3;
1179   gcry_mpi_t a_value;
1180
1181   l1 = gcry_sexp_find_token (encr_data, "enc-val", 0);
1182   if (!l1)
1183     return NULL;
1184   l2 = gcry_sexp_find_token (l1, "rsa", 0);
1185   gcry_sexp_release (l1);
1186   if (!l2)
1187     return NULL;
1188   l3 = gcry_sexp_find_token (l2, "a", 0);
1189   gcry_sexp_release (l2);
1190   if (!l3)
1191     return NULL;
1192   a_value = gcry_sexp_nth_mpi (l3, 1, 0);
1193   gcry_sexp_release (l3);
1194
1195   return a_value;
1196 }
1197
1198
1199 static const char *
1200 selftest_encr_1024 (gcry_sexp_t pkey, gcry_sexp_t skey)
1201 {
1202   const char *errtxt = NULL;
1203   gcry_error_t err;
1204   const unsigned int nbits = 1000; /* Encrypt 1000 random bits.  */
1205   gcry_mpi_t plaintext = NULL;
1206   gcry_sexp_t plain = NULL;
1207   gcry_sexp_t encr  = NULL;
1208   gcry_mpi_t  ciphertext = NULL;
1209   gcry_sexp_t decr  = NULL;
1210   gcry_mpi_t  decr_plaintext = NULL;
1211   gcry_sexp_t tmplist = NULL;
1212
1213   /* Create plaintext.  The plaintext is actually a big integer number.  */
1214   plaintext = gcry_mpi_new (nbits);
1215   gcry_mpi_randomize (plaintext, nbits, GCRY_WEAK_RANDOM);
1216
1217   /* Put the plaintext into an S-expression.  */
1218   err = gcry_sexp_build (&plain, NULL,
1219                          "(data (flags raw) (value %m))", plaintext);
1220   if (err)
1221     {
1222       errtxt = "converting data failed";
1223       goto leave;
1224     }
1225
1226   /* Encrypt.  */
1227   err = gcry_pk_encrypt (&encr, plain, pkey);
1228   if (err)
1229     {
1230       errtxt = "encrypt failed";
1231       goto leave;
1232     }
1233
1234   /* Extraxt the ciphertext from the returned S-expression.  */
1235   /*gcry_sexp_dump (encr);*/
1236   ciphertext = extract_a_from_sexp (encr);
1237   if (!ciphertext)
1238     {
1239       errtxt = "gcry_pk_decrypt returned garbage";
1240       goto leave;
1241     }
1242
1243   /* Check that the ciphertext does no match the plaintext.  */
1244   /* _gcry_log_mpidump ("plaintext", plaintext); */
1245   /* _gcry_log_mpidump ("ciphertxt", ciphertext); */
1246   if (!gcry_mpi_cmp (plaintext, ciphertext))
1247     {
1248       errtxt = "ciphertext matches plaintext";
1249       goto leave;
1250     }
1251
1252   /* Decrypt.  */
1253   err = gcry_pk_decrypt (&decr, encr, skey);
1254   if (err)
1255     {
1256       errtxt = "decrypt failed";
1257       goto leave;
1258     }
1259
1260   /* Extract the decrypted data from the S-expression.  Note that the
1261      output of gcry_pk_decrypt depends on whether a flags lists occurs
1262      in its input data.  Because we passed the output of
1263      gcry_pk_encrypt directly to gcry_pk_decrypt, such a flag value
1264      won't be there as of today.  To be prepared for future changes we
1265      take care of it anyway.  */
1266   tmplist = gcry_sexp_find_token (decr, "value", 0);
1267   if (tmplist)
1268     decr_plaintext = gcry_sexp_nth_mpi (tmplist, 1, GCRYMPI_FMT_USG);
1269   else
1270     decr_plaintext = gcry_sexp_nth_mpi (decr, 0, GCRYMPI_FMT_USG);
1271   if (!decr_plaintext)
1272     {
1273       errtxt = "decrypt returned no plaintext";
1274       goto leave;
1275     }
1276
1277   /* Check that the decrypted plaintext matches the original  plaintext.  */
1278   if (gcry_mpi_cmp (plaintext, decr_plaintext))
1279     {
1280       errtxt = "mismatch";
1281       goto leave;
1282     }
1283
1284  leave:
1285   gcry_sexp_release (tmplist);
1286   gcry_mpi_release (decr_plaintext);
1287   gcry_sexp_release (decr);
1288   gcry_mpi_release (ciphertext);
1289   gcry_sexp_release (encr);
1290   gcry_sexp_release (plain);
1291   gcry_mpi_release (plaintext);
1292   return errtxt;
1293 }
1294
1295
1296 static gpg_err_code_t
1297 selftests_rsa (selftest_report_func_t report)
1298 {
1299   const char *what;
1300   const char *errtxt;
1301   gcry_error_t err;
1302   gcry_sexp_t skey = NULL;
1303   gcry_sexp_t pkey = NULL;
1304
1305   /* Convert the S-expressions into the internal representation.  */
1306   what = "convert";
1307   err = gcry_sexp_sscan (&skey, NULL,
1308                          sample_secret_key, strlen (sample_secret_key));
1309   if (!err)
1310     err = gcry_sexp_sscan (&pkey, NULL,
1311                            sample_public_key, strlen (sample_public_key));
1312   if (err)
1313     {
1314       errtxt = gcry_strerror (err);
1315       goto failed;
1316     }
1317
1318   what = "key consistency";
1319   err = gcry_pk_testkey (skey);
1320   if (err)
1321     {
1322       errtxt = gcry_strerror (err);
1323       goto failed;
1324     }
1325
1326   what = "sign";
1327   errtxt = selftest_sign_1024 (pkey, skey);
1328   if (errtxt)
1329     goto failed;
1330
1331   what = "encrypt";
1332   errtxt = selftest_encr_1024 (pkey, skey);
1333   if (errtxt)
1334     goto failed;
1335
1336   gcry_sexp_release (pkey);
1337   gcry_sexp_release (skey);
1338   return 0; /* Succeeded. */
1339
1340  failed:
1341   gcry_sexp_release (pkey);
1342   gcry_sexp_release (skey);
1343   if (report)
1344     report ("pubkey", GCRY_PK_RSA, what, errtxt);
1345   return GPG_ERR_SELFTEST_FAILED;
1346 }
1347
1348
1349 /* Run a full self-test for ALGO and return 0 on success.  */
1350 static gpg_err_code_t
1351 run_selftests (int algo, int extended, selftest_report_func_t report)
1352 {
1353   gpg_err_code_t ec;
1354
1355   (void)extended;
1356
1357   switch (algo)
1358     {
1359     case GCRY_PK_RSA:
1360       ec = selftests_rsa (report);
1361       break;
1362     default:
1363       ec = GPG_ERR_PUBKEY_ALGO;
1364       break;
1365
1366     }
1367   return ec;
1368 }
1369
1370
1371
1372 \f
1373 static const char *rsa_names[] =
1374   {
1375     "rsa",
1376     "openpgp-rsa",
1377     "oid.1.2.840.113549.1.1.1",
1378     NULL,
1379   };
1380
1381 gcry_pk_spec_t _gcry_pubkey_spec_rsa =
1382   {
1383     "RSA", rsa_names,
1384     "ne", "nedpqu", "a", "s", "n",
1385     GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR,
1386     rsa_generate,
1387     rsa_check_secret_key,
1388     rsa_encrypt,
1389     rsa_decrypt,
1390     rsa_sign,
1391     rsa_verify,
1392     rsa_get_nbits,
1393   };
1394 pk_extra_spec_t _gcry_pubkey_extraspec_rsa =
1395   {
1396     run_selftests,
1397     rsa_generate_ext,
1398     compute_keygrip
1399   };