pk: Move s-expr creation for genkey 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
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         log_printmpi ("  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         log_printmpi ("  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_has_sign ( 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 (int algo, unsigned int nbits, unsigned long evalue,
787               const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
788 {
789   RSA_secret_key sk;
790   gpg_err_code_t ec;
791   gcry_sexp_t deriveparms;
792   int transient_key = 0;
793   int use_x931 = 0;
794   gcry_sexp_t l1;
795   gcry_sexp_t swap_info = NULL;
796
797   (void)algo;
798
799   memset (&sk, 0, sizeof sk);
800
801   deriveparms = (genparms?
802                  gcry_sexp_find_token (genparms, "derive-parms", 0) : NULL);
803   if (!deriveparms)
804     {
805       /* Parse the optional "use-x931" flag. */
806       l1 = gcry_sexp_find_token (genparms, "use-x931", 0);
807       if (l1)
808         {
809           use_x931 = 1;
810           gcry_sexp_release (l1);
811         }
812     }
813
814   if (deriveparms || use_x931 || fips_mode ())
815     {
816       int swapped;
817       ec = generate_x931 (&sk, nbits, evalue, deriveparms, &swapped);
818       gcry_sexp_release (deriveparms);
819       if (!ec && swapped)
820         ec = gcry_sexp_new (&swap_info, "(misc-key-info(p-q-swapped))", 0, 1);
821     }
822   else
823     {
824       /* Parse the optional "transient-key" flag. */
825       l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
826       if (l1)
827         {
828           transient_key = 1;
829           gcry_sexp_release (l1);
830         }
831       /* Generate.  */
832       ec = generate_std (&sk, nbits, evalue, transient_key);
833     }
834
835   if (!ec)
836     {
837       ec = gcry_err_code (gcry_sexp_build
838                           (r_skey, NULL,
839                            "(key-data"
840                            " (public-key"
841                            "  (rsa(n%m)(e%m)))"
842                            " (private-key"
843                            "  (rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))"
844                            " %S)",
845                            sk.n, sk.e,
846                            sk.n, sk.e, sk.d, sk.p, sk.q, sk.u,
847                            swap_info));
848     }
849
850   mpi_free (sk.n);
851   mpi_free (sk.e);
852   mpi_free (sk.p);
853   mpi_free (sk.q);
854   mpi_free (sk.d);
855   mpi_free (sk.u);
856   gcry_sexp_release (swap_info);
857
858   return ec;
859 }
860
861
862 static gcry_err_code_t
863 rsa_check_secret_key (int algo, gcry_mpi_t *skey)
864 {
865   gcry_err_code_t err = GPG_ERR_NO_ERROR;
866   RSA_secret_key sk;
867
868   (void)algo;
869
870   sk.n = skey[0];
871   sk.e = skey[1];
872   sk.d = skey[2];
873   sk.p = skey[3];
874   sk.q = skey[4];
875   sk.u = skey[5];
876
877   if (!sk.p || !sk.q || !sk.u)
878     err = GPG_ERR_NO_OBJ;  /* To check the key we need the optional
879                               parameters. */
880   else if (!check_secret_key (&sk))
881     err = GPG_ERR_BAD_SECKEY;
882
883   return err;
884 }
885
886
887 static gcry_err_code_t
888 rsa_encrypt (int algo, gcry_sexp_t *r_result, gcry_mpi_t data,
889              gcry_mpi_t *pkey, int flags)
890 {
891   gpg_err_code_t rc;
892   RSA_public_key pk;
893   gcry_mpi_t result;
894
895   (void)algo;
896   (void)flags;
897
898   pk.n = pkey[0];
899   pk.e = pkey[1];
900   result = mpi_alloc (mpi_get_nlimbs (pk.n));
901   public (result, data, &pk);
902   if ((flags & PUBKEY_FLAG_FIXEDLEN))
903     {
904       /* We need to make sure to return the correct length to avoid
905          problems with missing leading zeroes.  */
906       unsigned char *em;
907       size_t emlen = (mpi_get_nbits (pk.n)+7)/8;
908
909       rc = _gcry_mpi_to_octet_string (&em, NULL, result, emlen);
910       if (!rc)
911         {
912           rc = gcry_err_code (gcry_sexp_build (r_result, NULL,
913                                                "(enc-val(rsa(a%b)))",
914                                                (int)emlen, em));
915           gcry_free (em);
916         }
917     }
918   else
919     rc = gcry_err_code (gcry_sexp_build (r_result, NULL,
920                                          "(enc-val(rsa(a%m)))",
921                                          result));
922
923   mpi_free (result);
924   return rc;
925 }
926
927
928 static gcry_err_code_t
929 rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data,
930              gcry_mpi_t *skey, int flags)
931 {
932   RSA_secret_key sk;
933   gcry_mpi_t r = MPI_NULL;      /* Random number needed for blinding.  */
934   gcry_mpi_t ri = MPI_NULL;     /* Modular multiplicative inverse of
935                                    r.  */
936   gcry_mpi_t x = MPI_NULL;      /* Data to decrypt.  */
937   gcry_mpi_t y;                 /* Result.  */
938
939   (void)algo;
940
941   /* Extract private key.  */
942   sk.n = skey[0];
943   sk.e = skey[1];
944   sk.d = skey[2];
945   sk.p = skey[3]; /* Optional. */
946   sk.q = skey[4]; /* Optional. */
947   sk.u = skey[5]; /* Optional. */
948
949   y = gcry_mpi_snew (gcry_mpi_get_nbits (sk.n));
950
951   /* We use blinding by default to mitigate timing attacks which can
952      be practically mounted over the network as shown by Brumley and
953      Boney in 2003.  */
954   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
955     {
956       /* Initialize blinding.  */
957
958       /* First, we need a random number r between 0 and n - 1, which
959          is relatively prime to n (i.e. it is neither p nor q).  The
960          random number needs to be only unpredictable, thus we employ
961          the gcry_create_nonce function by using GCRY_WEAK_RANDOM with
962          gcry_mpi_randomize.  */
963       r = gcry_mpi_snew (gcry_mpi_get_nbits (sk.n));
964       ri = gcry_mpi_snew (gcry_mpi_get_nbits (sk.n));
965
966       gcry_mpi_randomize (r, gcry_mpi_get_nbits (sk.n), GCRY_WEAK_RANDOM);
967       gcry_mpi_mod (r, r, sk.n);
968
969       /* Calculate inverse of r.  It practically impossible that the
970          following test fails, thus we do not add code to release
971          allocated resources.  */
972       if (!gcry_mpi_invm (ri, r, sk.n))
973         return GPG_ERR_INTERNAL;
974     }
975
976   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
977     x = rsa_blind (data[0], r, sk.e, sk.n);
978   else
979     x = data[0];
980
981   /* Do the encryption.  */
982   secret (y, x, &sk);
983
984   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
985     {
986       /* Undo blinding.  */
987       gcry_mpi_t a = gcry_mpi_copy (y);
988
989       gcry_mpi_release (y);
990       y = rsa_unblind (a, ri, sk.n);
991
992       gcry_mpi_release (a);
993     }
994
995   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
996     {
997       /* Deallocate resources needed for blinding.  */
998       gcry_mpi_release (x);
999       gcry_mpi_release (r);
1000       gcry_mpi_release (ri);
1001     }
1002
1003   /* Copy out result.  */
1004   *result = y;
1005
1006   return GPG_ERR_NO_ERROR;
1007 }
1008
1009
1010 static gcry_err_code_t
1011 rsa_sign (int algo, gcry_sexp_t *r_result, gcry_mpi_t data, gcry_mpi_t *skey,
1012           int flags, int hashalgo)
1013 {
1014   gpg_err_code_t rc;
1015   RSA_secret_key sk;
1016   gcry_mpi_t result;
1017
1018   (void)algo;
1019   (void)flags;
1020   (void)hashalgo;
1021
1022   if (mpi_is_opaque (data))
1023     return GPG_ERR_INV_DATA;
1024
1025   sk.n = skey[0];
1026   sk.e = skey[1];
1027   sk.d = skey[2];
1028   sk.p = skey[3];
1029   sk.q = skey[4];
1030   sk.u = skey[5];
1031   result = mpi_alloc (mpi_get_nlimbs (sk.n));
1032   secret (result, data, &sk);
1033   if ((flags & PUBKEY_FLAG_FIXEDLEN))
1034     {
1035       /* We need to make sure to return the correct length to avoid
1036          problems with missing leading zeroes.  */
1037       unsigned char *em;
1038       size_t emlen = (mpi_get_nbits (sk.n)+7)/8;
1039
1040       rc = _gcry_mpi_to_octet_string (&em, NULL, result, emlen);
1041       if (!rc)
1042         {
1043           rc = gcry_err_code (gcry_sexp_build (r_result, NULL,
1044                                                "(sig-val(rsa(s%b)))",
1045                                                (int)emlen, em));
1046           gcry_free (em);
1047         }
1048     }
1049   else
1050     rc = gcry_err_code (gcry_sexp_build (r_result, NULL,
1051                                          "(sig-val(rsa(s%M)))",
1052                                          result));
1053   mpi_free (result);
1054
1055   return rc;
1056 }
1057
1058
1059 static gcry_err_code_t
1060 rsa_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
1061             int (*cmp) (void *opaque, gcry_mpi_t tmp), void *opaquev,
1062             int flags, int hashalgo)
1063 {
1064   RSA_public_key pk;
1065   gcry_mpi_t result;
1066   gcry_err_code_t rc;
1067
1068   (void)algo;
1069   (void)cmp;
1070   (void)opaquev;
1071   (void)flags;
1072   (void)hashalgo;
1073
1074   if (mpi_is_opaque (hash))
1075     return GPG_ERR_INV_DATA;
1076
1077   pk.n = pkey[0];
1078   pk.e = pkey[1];
1079   result = gcry_mpi_new ( 160 );
1080   public( result, data[0], &pk );
1081 #ifdef IS_DEVELOPMENT_VERSION
1082   if (DBG_CIPHER)
1083     {
1084       log_mpidump ("rsa verify result", result );
1085       log_mpidump ("             hash", hash );
1086     }
1087 #endif /*IS_DEVELOPMENT_VERSION*/
1088   if (cmp)
1089     rc = (*cmp) (opaquev, result);
1090   else
1091     rc = mpi_cmp (result, hash) ? GPG_ERR_BAD_SIGNATURE : GPG_ERR_NO_ERROR;
1092   gcry_mpi_release (result);
1093
1094   return rc;
1095 }
1096
1097
1098 static unsigned int
1099 rsa_get_nbits (int algo, gcry_mpi_t *pkey)
1100 {
1101   (void)algo;
1102
1103   return mpi_get_nbits (pkey[0]);
1104 }
1105
1106
1107 /* Compute a keygrip.  MD is the hash context which we are going to
1108    update.  KEYPARAM is an S-expression with the key parameters, this
1109    is usually a public key but may also be a secret key.  An example
1110    of such an S-expression is:
1111
1112       (rsa
1113         (n #00B...#)
1114         (e #010001#))
1115
1116    PKCS-15 says that for RSA only the modulus should be hashed -
1117    however, it is not clear whether this is meant to use the raw bytes
1118    (assuming this is an unsigned integer) or whether the DER required
1119    0 should be prefixed.  We hash the raw bytes.  */
1120 static gpg_err_code_t
1121 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
1122 {
1123   gcry_sexp_t l1;
1124   const char *data;
1125   size_t datalen;
1126
1127   l1 = gcry_sexp_find_token (keyparam, "n", 1);
1128   if (!l1)
1129     return GPG_ERR_NO_OBJ;
1130
1131   data = gcry_sexp_nth_data (l1, 1, &datalen);
1132   if (!data)
1133     {
1134       gcry_sexp_release (l1);
1135       return GPG_ERR_NO_OBJ;
1136     }
1137
1138   gcry_md_write (md, data, datalen);
1139   gcry_sexp_release (l1);
1140
1141   return 0;
1142 }
1143
1144
1145
1146 \f
1147 /*
1148      Self-test section.
1149  */
1150
1151 static const char *
1152 selftest_sign_1024 (gcry_sexp_t pkey, gcry_sexp_t skey)
1153 {
1154   static const char sample_data[] =
1155     "(data (flags pkcs1)"
1156     " (hash sha1 #11223344556677889900aabbccddeeff10203040#))";
1157   static const char sample_data_bad[] =
1158     "(data (flags pkcs1)"
1159     " (hash sha1 #11223344556677889900aabbccddeeff80203040#))";
1160
1161   const char *errtxt = NULL;
1162   gcry_error_t err;
1163   gcry_sexp_t data = NULL;
1164   gcry_sexp_t data_bad = NULL;
1165   gcry_sexp_t sig = NULL;
1166
1167   err = gcry_sexp_sscan (&data, NULL,
1168                          sample_data, strlen (sample_data));
1169   if (!err)
1170     err = gcry_sexp_sscan (&data_bad, NULL,
1171                            sample_data_bad, strlen (sample_data_bad));
1172   if (err)
1173     {
1174       errtxt = "converting data failed";
1175       goto leave;
1176     }
1177
1178   err = gcry_pk_sign (&sig, data, skey);
1179   if (err)
1180     {
1181       errtxt = "signing failed";
1182       goto leave;
1183     }
1184   err = gcry_pk_verify (sig, data, pkey);
1185   if (err)
1186     {
1187       errtxt = "verify failed";
1188       goto leave;
1189     }
1190   err = gcry_pk_verify (sig, data_bad, pkey);
1191   if (gcry_err_code (err) != GPG_ERR_BAD_SIGNATURE)
1192     {
1193       errtxt = "bad signature not detected";
1194       goto leave;
1195     }
1196
1197
1198  leave:
1199   gcry_sexp_release (sig);
1200   gcry_sexp_release (data_bad);
1201   gcry_sexp_release (data);
1202   return errtxt;
1203 }
1204
1205
1206
1207 /* Given an S-expression ENCR_DATA of the form:
1208
1209    (enc-val
1210     (rsa
1211      (a a-value)))
1212
1213    as returned by gcry_pk_decrypt, return the the A-VALUE.  On error,
1214    return NULL.  */
1215 static gcry_mpi_t
1216 extract_a_from_sexp (gcry_sexp_t encr_data)
1217 {
1218   gcry_sexp_t l1, l2, l3;
1219   gcry_mpi_t a_value;
1220
1221   l1 = gcry_sexp_find_token (encr_data, "enc-val", 0);
1222   if (!l1)
1223     return NULL;
1224   l2 = gcry_sexp_find_token (l1, "rsa", 0);
1225   gcry_sexp_release (l1);
1226   if (!l2)
1227     return NULL;
1228   l3 = gcry_sexp_find_token (l2, "a", 0);
1229   gcry_sexp_release (l2);
1230   if (!l3)
1231     return NULL;
1232   a_value = gcry_sexp_nth_mpi (l3, 1, 0);
1233   gcry_sexp_release (l3);
1234
1235   return a_value;
1236 }
1237
1238
1239 static const char *
1240 selftest_encr_1024 (gcry_sexp_t pkey, gcry_sexp_t skey)
1241 {
1242   const char *errtxt = NULL;
1243   gcry_error_t err;
1244   const unsigned int nbits = 1000; /* Encrypt 1000 random bits.  */
1245   gcry_mpi_t plaintext = NULL;
1246   gcry_sexp_t plain = NULL;
1247   gcry_sexp_t encr  = NULL;
1248   gcry_mpi_t  ciphertext = NULL;
1249   gcry_sexp_t decr  = NULL;
1250   gcry_mpi_t  decr_plaintext = NULL;
1251   gcry_sexp_t tmplist = NULL;
1252
1253   /* Create plaintext.  The plaintext is actually a big integer number.  */
1254   plaintext = gcry_mpi_new (nbits);
1255   gcry_mpi_randomize (plaintext, nbits, GCRY_WEAK_RANDOM);
1256
1257   /* Put the plaintext into an S-expression.  */
1258   err = gcry_sexp_build (&plain, NULL,
1259                          "(data (flags raw) (value %m))", plaintext);
1260   if (err)
1261     {
1262       errtxt = "converting data failed";
1263       goto leave;
1264     }
1265
1266   /* Encrypt.  */
1267   err = gcry_pk_encrypt (&encr, plain, pkey);
1268   if (err)
1269     {
1270       errtxt = "encrypt failed";
1271       goto leave;
1272     }
1273
1274   /* Extraxt the ciphertext from the returned S-expression.  */
1275   /*gcry_sexp_dump (encr);*/
1276   ciphertext = extract_a_from_sexp (encr);
1277   if (!ciphertext)
1278     {
1279       errtxt = "gcry_pk_decrypt returned garbage";
1280       goto leave;
1281     }
1282
1283   /* Check that the ciphertext does no match the plaintext.  */
1284   /* _gcry_log_mpidump ("plaintext", plaintext); */
1285   /* _gcry_log_mpidump ("ciphertxt", ciphertext); */
1286   if (!gcry_mpi_cmp (plaintext, ciphertext))
1287     {
1288       errtxt = "ciphertext matches plaintext";
1289       goto leave;
1290     }
1291
1292   /* Decrypt.  */
1293   err = gcry_pk_decrypt (&decr, encr, skey);
1294   if (err)
1295     {
1296       errtxt = "decrypt failed";
1297       goto leave;
1298     }
1299
1300   /* Extract the decrypted data from the S-expression.  Note that the
1301      output of gcry_pk_decrypt depends on whether a flags lists occurs
1302      in its input data.  Because we passed the output of
1303      gcry_pk_encrypt directly to gcry_pk_decrypt, such a flag value
1304      won't be there as of today.  To be prepared for future changes we
1305      take care of it anyway.  */
1306   tmplist = gcry_sexp_find_token (decr, "value", 0);
1307   if (tmplist)
1308     decr_plaintext = gcry_sexp_nth_mpi (tmplist, 1, GCRYMPI_FMT_USG);
1309   else
1310     decr_plaintext = gcry_sexp_nth_mpi (decr, 0, GCRYMPI_FMT_USG);
1311   if (!decr_plaintext)
1312     {
1313       errtxt = "decrypt returned no plaintext";
1314       goto leave;
1315     }
1316
1317   /* Check that the decrypted plaintext matches the original  plaintext.  */
1318   if (gcry_mpi_cmp (plaintext, decr_plaintext))
1319     {
1320       errtxt = "mismatch";
1321       goto leave;
1322     }
1323
1324  leave:
1325   gcry_sexp_release (tmplist);
1326   gcry_mpi_release (decr_plaintext);
1327   gcry_sexp_release (decr);
1328   gcry_mpi_release (ciphertext);
1329   gcry_sexp_release (encr);
1330   gcry_sexp_release (plain);
1331   gcry_mpi_release (plaintext);
1332   return errtxt;
1333 }
1334
1335
1336 static gpg_err_code_t
1337 selftests_rsa (selftest_report_func_t report)
1338 {
1339   const char *what;
1340   const char *errtxt;
1341   gcry_error_t err;
1342   gcry_sexp_t skey = NULL;
1343   gcry_sexp_t pkey = NULL;
1344
1345   /* Convert the S-expressions into the internal representation.  */
1346   what = "convert";
1347   err = gcry_sexp_sscan (&skey, NULL,
1348                          sample_secret_key, strlen (sample_secret_key));
1349   if (!err)
1350     err = gcry_sexp_sscan (&pkey, NULL,
1351                            sample_public_key, strlen (sample_public_key));
1352   if (err)
1353     {
1354       errtxt = gcry_strerror (err);
1355       goto failed;
1356     }
1357
1358   what = "key consistency";
1359   err = gcry_pk_testkey (skey);
1360   if (err)
1361     {
1362       errtxt = gcry_strerror (err);
1363       goto failed;
1364     }
1365
1366   what = "sign";
1367   errtxt = selftest_sign_1024 (pkey, skey);
1368   if (errtxt)
1369     goto failed;
1370
1371   what = "encrypt";
1372   errtxt = selftest_encr_1024 (pkey, skey);
1373   if (errtxt)
1374     goto failed;
1375
1376   gcry_sexp_release (pkey);
1377   gcry_sexp_release (skey);
1378   return 0; /* Succeeded. */
1379
1380  failed:
1381   gcry_sexp_release (pkey);
1382   gcry_sexp_release (skey);
1383   if (report)
1384     report ("pubkey", GCRY_PK_RSA, what, errtxt);
1385   return GPG_ERR_SELFTEST_FAILED;
1386 }
1387
1388
1389 /* Run a full self-test for ALGO and return 0 on success.  */
1390 static gpg_err_code_t
1391 run_selftests (int algo, int extended, selftest_report_func_t report)
1392 {
1393   gpg_err_code_t ec;
1394
1395   (void)extended;
1396
1397   switch (algo)
1398     {
1399     case GCRY_PK_RSA:
1400       ec = selftests_rsa (report);
1401       break;
1402     default:
1403       ec = GPG_ERR_PUBKEY_ALGO;
1404       break;
1405
1406     }
1407   return ec;
1408 }
1409
1410
1411
1412 \f
1413 static const char *rsa_names[] =
1414   {
1415     "rsa",
1416     "openpgp-rsa",
1417     "oid.1.2.840.113549.1.1.1",
1418     NULL,
1419   };
1420
1421 gcry_pk_spec_t _gcry_pubkey_spec_rsa =
1422   {
1423     GCRY_PK_RSA, { 0, 1 },
1424     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
1425     "RSA", rsa_names,
1426     "ne", "nedpqu", "a", "s", "n",
1427     rsa_generate,
1428     rsa_check_secret_key,
1429     rsa_encrypt,
1430     rsa_decrypt,
1431     rsa_sign,
1432     rsa_verify,
1433     rsa_get_nbits,
1434     run_selftests,
1435     compute_keygrip
1436   };