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