pkgconfig: Fix libgcrypt.pc.
[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 static const char *rsa_names[] =
57   {
58     "rsa",
59     "openpgp-rsa",
60     "oid.1.2.840.113549.1.1.1",
61     NULL,
62   };
63
64
65 /* A sample 2048 bit RSA key used for the selftests.  */
66 static const char sample_secret_key[] =
67 " (private-key"
68 "  (rsa"
69 "  (n #009F56231A3D82E3E7D613D59D53E9AB921BEF9F08A782AED0B6E46ADBC853EC"
70 "      7C71C422435A3CD8FA0DB9EFD55CD3295BADC4E8E2E2B94E15AE82866AB8ADE8"
71 "      7E469FAE76DC3577DE87F1F419C4EB41123DFAF8D16922D5EDBAD6E9076D5A1C"
72 "      958106F0AE5E2E9193C6B49124C64C2A241C4075D4AF16299EB87A6585BAE917"
73 "      DEF27FCDD165764D069BC18D16527B29DAAB549F7BBED4A7C6A842D203ED6613"
74 "      6E2411744E432CD26D940132F25874483DCAEECDFD95744819CBCF1EA810681C"
75 "      42907EBCB1C7EAFBE75C87EC32C5413EA10476545D3FC7B2ADB1B66B7F200918"
76 "      664B0E5261C2895AA28B0DE321E921B3F877172CCCAB81F43EF98002916156F6CB#)"
77 "   (e #010001#)"
78 "   (d #07EF82500C403899934FE993AC5A36F14FF2DF38CF1EF315F205EE4C83EDAA19"
79 "       8890FC23DE9AA933CAFB37B6A8A8DBA675411958337287310D3FF2F1DDC0CB93"
80 "       7E70F57F75F833C021852B631D2B9A520E4431A03C5C3FCB5742DCD841D9FB12"
81 "       771AA1620DCEC3F1583426066ED9DC3F7028C5B59202C88FDF20396E2FA0EC4F"
82 "       5A22D9008F3043673931BC14A5046D6327398327900867E39CC61B2D1AFE2F48"
83 "       EC8E1E3861C68D257D7425F4E6F99ABD77D61F10CA100EFC14389071831B33DD"
84 "       69CC8EABEF860D1DC2AAA84ABEAE5DFC91BC124DAF0F4C8EF5BBEA436751DE84"
85 "       3A8063E827A024466F44C28614F93B0732A100D4A0D86D532FE1E22C7725E401#)"
86 "   (p #00C29D438F115825779631CD665A5739367F3E128ADC29766483A46CA80897E0"
87 "       79B32881860B8F9A6A04C2614A904F6F2578DAE13EA67CD60AE3D0AA00A1FF9B"
88 "       441485E44B2DC3D0B60260FBFE073B5AC72FAF67964DE15C8212C389D20DB9CF"
89 "       54AF6AEF5C4196EAA56495DD30CF709F499D5AB30CA35E086C2A1589D6283F1783#)"
90 "   (q #00D1984135231CB243FE959C0CBEF551EDD986AD7BEDF71EDF447BE3DA27AF46"
91 "       79C974A6FA69E4D52FE796650623DE70622862713932AA2FD9F2EC856EAEAA77"
92 "       88B4EA6084DC81C902F014829B18EA8B2666EC41586818E0589E18876065F97E"
93 "       8D22CE2DA53A05951EC132DCEF41E70A9C35F4ACC268FFAC2ADF54FA1DA110B919#)"
94 "   (u #67CF0FD7635205DD80FA814EE9E9C267C17376BF3209FB5D1BC42890D2822A04"
95 "       479DAF4D5B6ED69D0F8D1AF94164D07F8CD52ECEFE880641FA0F41DDAB1785E4"
96 "       A37A32F997A516480B4CD4F6482B9466A1765093ED95023CA32D5EDC1E34CEE9"
97 "       AF595BC51FE43C4BF810FA225AF697FB473B83815966188A4312C048B885E3F7#)))";
98
99 /* A sample 2048 bit RSA key used for the selftests (public only).  */
100 static const char sample_public_key[] =
101 " (public-key"
102 "  (rsa"
103 "   (n #009F56231A3D82E3E7D613D59D53E9AB921BEF9F08A782AED0B6E46ADBC853EC"
104 "       7C71C422435A3CD8FA0DB9EFD55CD3295BADC4E8E2E2B94E15AE82866AB8ADE8"
105 "       7E469FAE76DC3577DE87F1F419C4EB41123DFAF8D16922D5EDBAD6E9076D5A1C"
106 "       958106F0AE5E2E9193C6B49124C64C2A241C4075D4AF16299EB87A6585BAE917"
107 "       DEF27FCDD165764D069BC18D16527B29DAAB549F7BBED4A7C6A842D203ED6613"
108 "       6E2411744E432CD26D940132F25874483DCAEECDFD95744819CBCF1EA810681C"
109 "       42907EBCB1C7EAFBE75C87EC32C5413EA10476545D3FC7B2ADB1B66B7F200918"
110 "       664B0E5261C2895AA28B0DE321E921B3F877172CCCAB81F43EF98002916156F6CB#)"
111 "   (e #010001#)))";
112
113 \f
114 static int test_keys (RSA_secret_key *sk, unsigned nbits);
115 static int  check_secret_key (RSA_secret_key *sk);
116 static void public (gcry_mpi_t output, gcry_mpi_t input, RSA_public_key *skey);
117 static void secret (gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey);
118 static unsigned int rsa_get_nbits (gcry_sexp_t parms);
119
120
121 /* Check that a freshly generated key actually works.  Returns 0 on success. */
122 static int
123 test_keys (RSA_secret_key *sk, unsigned int nbits)
124 {
125   int result = -1; /* Default to failure.  */
126   RSA_public_key pk;
127   gcry_mpi_t plaintext = mpi_new (nbits);
128   gcry_mpi_t ciphertext = mpi_new (nbits);
129   gcry_mpi_t decr_plaintext = mpi_new (nbits);
130   gcry_mpi_t signature = mpi_new (nbits);
131
132   /* Put the relevant parameters into a public key structure.  */
133   pk.n = sk->n;
134   pk.e = sk->e;
135
136   /* Create a random plaintext.  */
137   _gcry_mpi_randomize (plaintext, nbits, GCRY_WEAK_RANDOM);
138
139   /* Encrypt using the public key.  */
140   public (ciphertext, plaintext, &pk);
141
142   /* Check that the cipher text does not match the plaintext.  */
143   if (!mpi_cmp (ciphertext, plaintext))
144     goto leave; /* Ciphertext is identical to the plaintext.  */
145
146   /* Decrypt using the secret key.  */
147   secret (decr_plaintext, ciphertext, sk);
148
149   /* Check that the decrypted plaintext matches the original plaintext.  */
150   if (mpi_cmp (decr_plaintext, plaintext))
151     goto leave; /* Plaintext does not match.  */
152
153   /* Create another random plaintext as data for signature checking.  */
154   _gcry_mpi_randomize (plaintext, nbits, GCRY_WEAK_RANDOM);
155
156   /* Use the RSA secret function to create a signature of the plaintext.  */
157   secret (signature, plaintext, sk);
158
159   /* Use the RSA public function to verify this signature.  */
160   public (decr_plaintext, signature, &pk);
161   if (mpi_cmp (decr_plaintext, plaintext))
162     goto leave; /* Signature does not match.  */
163
164   /* Modify the signature and check that the signing fails.  */
165   mpi_add_ui (signature, signature, 1);
166   public (decr_plaintext, signature, &pk);
167   if (!mpi_cmp (decr_plaintext, plaintext))
168     goto leave; /* Signature matches but should not.  */
169
170   result = 0; /* All tests succeeded.  */
171
172  leave:
173   _gcry_mpi_release (signature);
174   _gcry_mpi_release (decr_plaintext);
175   _gcry_mpi_release (ciphertext);
176   _gcry_mpi_release (plaintext);
177   return result;
178 }
179
180
181 /* Callback used by the prime generation to test whether the exponent
182    is suitable. Returns 0 if the test has been passed. */
183 static int
184 check_exponent (void *arg, gcry_mpi_t a)
185 {
186   gcry_mpi_t e = arg;
187   gcry_mpi_t tmp;
188   int result;
189
190   mpi_sub_ui (a, a, 1);
191   tmp = _gcry_mpi_alloc_like (a);
192   result = !mpi_gcd(tmp, e, a); /* GCD is not 1. */
193   _gcry_mpi_release (tmp);
194   mpi_add_ui (a, a, 1);
195   return result;
196 }
197
198 /****************
199  * Generate a key pair with a key of size NBITS.
200  * USE_E = 0 let Libcgrypt decide what exponent to use.
201  *       = 1 request the use of a "secure" exponent; this is required by some
202  *           specification to be 65537.
203  *       > 2 Use this public exponent.  If the given exponent
204  *           is not odd one is internally added to it.
205  * TRANSIENT_KEY:  If true, generate the primes using the standard RNG.
206  * Returns: 2 structures filled with all needed values
207  */
208 static gpg_err_code_t
209 generate_std (RSA_secret_key *sk, unsigned int nbits, unsigned long use_e,
210               int transient_key)
211 {
212   gcry_mpi_t p, q; /* the two primes */
213   gcry_mpi_t d;    /* the private key */
214   gcry_mpi_t u;
215   gcry_mpi_t t1, t2;
216   gcry_mpi_t n;    /* the public key */
217   gcry_mpi_t e;    /* the exponent */
218   gcry_mpi_t phi;  /* helper: (p-1)(q-1) */
219   gcry_mpi_t g;
220   gcry_mpi_t f;
221   gcry_random_level_t random_level;
222
223   if (fips_mode ())
224     {
225       if (nbits < 1024)
226         return GPG_ERR_INV_VALUE;
227       if (transient_key)
228         return GPG_ERR_INV_VALUE;
229     }
230
231   /* The random quality depends on the transient_key flag.  */
232   random_level = transient_key ? GCRY_STRONG_RANDOM : GCRY_VERY_STRONG_RANDOM;
233
234   /* Make sure that nbits is even so that we generate p, q of equal size. */
235   if ( (nbits&1) )
236     nbits++;
237
238   if (use_e == 1)   /* Alias for a secure value */
239     use_e = 65537;  /* as demanded by Sphinx. */
240
241   /* Public exponent:
242      In general we use 41 as this is quite fast and more secure than the
243      commonly used 17.  Benchmarking the RSA verify function
244      with a 1024 bit key yields (2001-11-08):
245      e=17    0.54 ms
246      e=41    0.75 ms
247      e=257   0.95 ms
248      e=65537 1.80 ms
249   */
250   e = mpi_alloc( (32+BITS_PER_MPI_LIMB-1)/BITS_PER_MPI_LIMB );
251   if (!use_e)
252     mpi_set_ui (e, 41);     /* This is a reasonable secure and fast value */
253   else
254     {
255       use_e |= 1; /* make sure this is odd */
256       mpi_set_ui (e, use_e);
257     }
258
259   n = mpi_new (nbits);
260
261   p = q = NULL;
262   do
263     {
264       /* select two (very secret) primes */
265       if (p)
266         _gcry_mpi_release (p);
267       if (q)
268         _gcry_mpi_release (q);
269       if (use_e)
270         { /* Do an extra test to ensure that the given exponent is
271              suitable. */
272           p = _gcry_generate_secret_prime (nbits/2, random_level,
273                                            check_exponent, e);
274           q = _gcry_generate_secret_prime (nbits/2, random_level,
275                                            check_exponent, e);
276         }
277       else
278         { /* We check the exponent later. */
279           p = _gcry_generate_secret_prime (nbits/2, random_level, NULL, NULL);
280           q = _gcry_generate_secret_prime (nbits/2, random_level, NULL, NULL);
281         }
282       if (mpi_cmp (p, q) > 0 ) /* p shall be smaller than q (for calc of u)*/
283         mpi_swap(p,q);
284       /* calculate the modulus */
285       mpi_mul( n, p, q );
286     }
287   while ( mpi_get_nbits(n) != nbits );
288
289   /* calculate Euler totient: phi = (p-1)(q-1) */
290   t1 = mpi_alloc_secure( mpi_get_nlimbs(p) );
291   t2 = mpi_alloc_secure( mpi_get_nlimbs(p) );
292   phi   = mpi_snew ( nbits );
293   g     = mpi_snew ( nbits );
294   f     = mpi_snew ( nbits );
295   mpi_sub_ui( t1, p, 1 );
296   mpi_sub_ui( t2, q, 1 );
297   mpi_mul( phi, t1, t2 );
298   mpi_gcd (g, t1, t2);
299   mpi_fdiv_q(f, phi, g);
300
301   while (!mpi_gcd(t1, e, phi)) /* (while gcd is not 1) */
302     {
303       if (use_e)
304         BUG (); /* The prime generator already made sure that we
305                    never can get to here. */
306       mpi_add_ui (e, e, 2);
307     }
308
309   /* calculate the secret key d = e^-1 mod phi */
310   d = mpi_snew ( nbits );
311   mpi_invm (d, e, f );
312   /* calculate the inverse of p and q (used for chinese remainder theorem)*/
313   u = mpi_snew ( nbits );
314   mpi_invm(u, p, q );
315
316   if( DBG_CIPHER )
317     {
318       log_mpidump("  p= ", p );
319       log_mpidump("  q= ", q );
320       log_mpidump("phi= ", phi );
321       log_mpidump("  g= ", g );
322       log_mpidump("  f= ", f );
323       log_mpidump("  n= ", n );
324       log_mpidump("  e= ", e );
325       log_mpidump("  d= ", d );
326       log_mpidump("  u= ", u );
327     }
328
329   _gcry_mpi_release (t1);
330   _gcry_mpi_release (t2);
331   _gcry_mpi_release (phi);
332   _gcry_mpi_release (f);
333   _gcry_mpi_release (g);
334
335   sk->n = n;
336   sk->e = e;
337   sk->p = p;
338   sk->q = q;
339   sk->d = d;
340   sk->u = u;
341
342   /* Now we can test our keys. */
343   if (test_keys (sk, nbits - 64))
344     {
345       _gcry_mpi_release (sk->n); sk->n = NULL;
346       _gcry_mpi_release (sk->e); sk->e = NULL;
347       _gcry_mpi_release (sk->p); sk->p = NULL;
348       _gcry_mpi_release (sk->q); sk->q = NULL;
349       _gcry_mpi_release (sk->d); sk->d = NULL;
350       _gcry_mpi_release (sk->u); sk->u = NULL;
351       fips_signal_error ("self-test after key generation failed");
352       return GPG_ERR_SELFTEST_FAILED;
353     }
354
355   return 0;
356 }
357
358
359 /****************
360  * Generate a key pair with a key of size NBITS.
361  * USE_E = 0 let Libcgrypt decide what exponent to use.
362  *       = 1 request the use of a "secure" exponent; this is required by some
363  *           specification to be 65537.
364  *       > 2 Use this public exponent.  If the given exponent
365  *           is not odd one is internally added to it.
366  * TESTPARMS: If set, do not generate but test whether the p,q is probably prime
367  *            Returns key with zeroes to not break code calling this function.
368  * TRANSIENT_KEY:  If true, generate the primes using the standard RNG.
369  * Returns: 2 structures filled with all needed values
370  */
371 static gpg_err_code_t
372 generate_fips (RSA_secret_key *sk, unsigned int nbits, unsigned long use_e,
373                gcry_sexp_t testparms, int transient_key)
374 {
375   gcry_mpi_t p, q; /* the two primes */
376   gcry_mpi_t d;    /* the private key */
377   gcry_mpi_t u;
378   gcry_mpi_t p1, q1;
379   gcry_mpi_t n;    /* the public key */
380   gcry_mpi_t e;    /* the exponent */
381   gcry_mpi_t g;
382   gcry_mpi_t minp;
383   gcry_mpi_t diff, mindiff;
384   gcry_random_level_t random_level;
385   unsigned int pbits = nbits/2;
386   unsigned int i;
387   int pqswitch;
388   gpg_err_code_t ec = GPG_ERR_NO_PRIME;
389
390   if (nbits < 1024 || (nbits & 0x1FF))
391     return GPG_ERR_INV_VALUE;
392   if (_gcry_enforced_fips_mode() && nbits != 2048 && nbits != 3072)
393       return GPG_ERR_INV_VALUE;
394
395   /* The random quality depends on the transient_key flag.  */
396   random_level = transient_key ? GCRY_STRONG_RANDOM : GCRY_VERY_STRONG_RANDOM;
397
398   if (testparms)
399     {
400       /* Parameters to derive the key are given.  */
401       /* Note that we explicitly need to setup the values of tbl
402          because some compilers (e.g. OpenWatcom, IRIX) don't allow to
403          initialize a structure with automatic variables.  */
404       struct { const char *name; gcry_mpi_t *value; } tbl[] = {
405         { "e" },
406         { "p" },
407         { "q" },
408         { NULL }
409       };
410       int idx;
411       gcry_sexp_t oneparm;
412
413       tbl[0].value = &e;
414       tbl[1].value = &p;
415       tbl[2].value = &q;
416
417       for (idx=0; tbl[idx].name; idx++)
418         {
419           oneparm = sexp_find_token (testparms, tbl[idx].name, 0);
420           if (oneparm)
421             {
422               *tbl[idx].value = sexp_nth_mpi (oneparm, 1, GCRYMPI_FMT_USG);
423               sexp_release (oneparm);
424             }
425         }
426       for (idx=0; tbl[idx].name; idx++)
427         if (!*tbl[idx].value)
428           break;
429       if (tbl[idx].name)
430         {
431           /* At least one parameter is missing.  */
432           for (idx=0; tbl[idx].name; idx++)
433             _gcry_mpi_release (*tbl[idx].value);
434           return GPG_ERR_MISSING_VALUE;
435         }
436     }
437   else
438     {
439       if (use_e < 65537)
440         use_e = 65537;  /* This is the smallest value allowed by FIPS */
441
442       e = mpi_alloc ((32+BITS_PER_MPI_LIMB-1)/BITS_PER_MPI_LIMB);
443
444       use_e |= 1; /* make sure this is odd */
445       mpi_set_ui (e, use_e);
446
447       p = mpi_snew (pbits);
448       q = mpi_snew (pbits);
449     }
450
451   n = mpi_new (nbits);
452   d = mpi_snew (nbits);
453   u = mpi_snew (nbits);
454
455   /* prepare approximate minimum p and q */
456   minp = mpi_new (pbits);
457   mpi_set_ui (minp, 0xB504F334);
458   mpi_lshift (minp, minp, pbits - 32);
459
460   /* prepare minimum p and q difference */
461   diff = mpi_new (pbits);
462   mindiff = mpi_new (pbits - 99);
463   mpi_set_ui (mindiff, 1);
464   mpi_lshift (mindiff, mindiff, pbits - 100);
465
466   p1 = mpi_snew (pbits);
467   q1 = mpi_snew (pbits);
468   g  = mpi_snew (pbits);
469
470  retry:
471   /* generate p and q */
472   for (i = 0; i < 5 * pbits; i++)
473     {
474     ploop:
475       if (!testparms)
476         {
477           _gcry_mpi_randomize (p, pbits, random_level);
478         }
479       if (mpi_cmp (p, minp) < 0)
480         {
481           if (testparms)
482             goto err;
483           goto ploop;
484         }
485
486       mpi_sub_ui (p1, p, 1);
487       if (mpi_gcd (g, p1, e))
488         {
489           if (_gcry_fips186_4_prime_check (p, pbits) != GPG_ERR_NO_ERROR)
490             {
491               /* not a prime */
492               if (testparms)
493                 goto err;
494             }
495           else
496             break;
497         }
498       else if (testparms)
499         goto err;
500     }
501   if (i >= 5 * pbits)
502     goto err;
503
504   for (i = 0; i < 5 * pbits; i++)
505     {
506     qloop:
507       if (!testparms)
508         {
509           _gcry_mpi_randomize (q, pbits, random_level);
510         }
511       if (mpi_cmp (q, minp) < 0)
512         {
513           if (testparms)
514             goto err;
515           goto qloop;
516         }
517       if (mpi_cmp (p, q) > 0)
518         {
519           pqswitch = 1;
520           mpi_sub (diff, p, q);
521         }
522       else
523         {
524           pqswitch = 0;
525           mpi_sub (diff, q, p);
526         }
527       if (mpi_cmp (diff, mindiff) < 0)
528         {
529           if (testparms)
530             goto err;
531           goto qloop;
532         }
533
534       mpi_sub_ui (q1, q, 1);
535       if (mpi_gcd (g, q1, e))
536         {
537           if (_gcry_fips186_4_prime_check (q, pbits) != GPG_ERR_NO_ERROR)
538             {
539               /* not a prime */
540               if (testparms)
541                 goto err;
542             }
543           else
544             break;
545         }
546       else if (testparms)
547         goto err;
548     }
549   if (i >= 5 * pbits)
550     goto err;
551
552   if (testparms)
553     {
554       mpi_clear (p);
555       mpi_clear (q);
556     }
557   else
558     {
559       gcry_mpi_t f;
560
561       if (pqswitch)
562         {
563           gcry_mpi_t tmp;
564
565           tmp = p;
566           p = q;
567           q = tmp;
568         }
569
570       f = mpi_snew (nbits);
571
572       /* calculate the modulus */
573       mpi_mul (n, p, q);
574
575       /* calculate the secret key d = e^1 mod phi */
576       mpi_gcd (g, p1, q1);
577       mpi_fdiv_q (f, p1, g);
578       mpi_mul (f, f, q1);
579
580       mpi_invm (d, e, f);
581
582       _gcry_mpi_release (f);
583
584       if (mpi_get_nbits (d) < pbits)
585         goto retry;
586
587       /* calculate the inverse of p and q (used for chinese remainder theorem)*/
588       mpi_invm (u, p, q );
589     }
590
591   ec = 0;
592
593   if (DBG_CIPHER)
594     {
595       log_mpidump("  p= ", p );
596       log_mpidump("  q= ", q );
597       log_mpidump("  n= ", n );
598       log_mpidump("  e= ", e );
599       log_mpidump("  d= ", d );
600       log_mpidump("  u= ", u );
601     }
602
603  err:
604
605   _gcry_mpi_release (p1);
606   _gcry_mpi_release (q1);
607   _gcry_mpi_release (g);
608   _gcry_mpi_release (minp);
609   _gcry_mpi_release (mindiff);
610   _gcry_mpi_release (diff);
611
612   sk->n = n;
613   sk->e = e;
614   sk->p = p;
615   sk->q = q;
616   sk->d = d;
617   sk->u = u;
618
619   /* Now we can test our keys. */
620   if (ec || (!testparms && test_keys (sk, nbits - 64)))
621     {
622       _gcry_mpi_release (sk->n); sk->n = NULL;
623       _gcry_mpi_release (sk->e); sk->e = NULL;
624       _gcry_mpi_release (sk->p); sk->p = NULL;
625       _gcry_mpi_release (sk->q); sk->q = NULL;
626       _gcry_mpi_release (sk->d); sk->d = NULL;
627       _gcry_mpi_release (sk->u); sk->u = NULL;
628       if (!ec)
629         {
630           fips_signal_error ("self-test after key generation failed");
631           return GPG_ERR_SELFTEST_FAILED;
632         }
633     }
634
635   return ec;
636 }
637
638
639 /* Helper for generate_x931.  */
640 static gcry_mpi_t
641 gen_x931_parm_xp (unsigned int nbits)
642 {
643   gcry_mpi_t xp;
644
645   xp = mpi_snew (nbits);
646   _gcry_mpi_randomize (xp, nbits, GCRY_VERY_STRONG_RANDOM);
647
648   /* The requirement for Xp is:
649
650        sqrt{2}*2^{nbits-1} <= xp <= 2^{nbits} - 1
651
652      We set the two high order bits to 1 to satisfy the lower bound.
653      By using mpi_set_highbit we make sure that the upper bound is
654      satisfied as well.  */
655   mpi_set_highbit (xp, nbits-1);
656   mpi_set_bit (xp, nbits-2);
657   gcry_assert ( mpi_get_nbits (xp) == nbits );
658
659   return xp;
660 }
661
662
663 /* Helper for generate_x931.  */
664 static gcry_mpi_t
665 gen_x931_parm_xi (void)
666 {
667   gcry_mpi_t xi;
668
669   xi = mpi_snew (101);
670   _gcry_mpi_randomize (xi, 101, GCRY_VERY_STRONG_RANDOM);
671   mpi_set_highbit (xi, 100);
672   gcry_assert ( mpi_get_nbits (xi) == 101 );
673
674   return xi;
675 }
676
677
678
679 /* Variant of the standard key generation code using the algorithm
680    from X9.31.  Using this algorithm has the advantage that the
681    generation can be made deterministic which is required for CAVS
682    testing.  */
683 static gpg_err_code_t
684 generate_x931 (RSA_secret_key *sk, unsigned int nbits, unsigned long e_value,
685                gcry_sexp_t deriveparms, int *swapped)
686 {
687   gcry_mpi_t p, q; /* The two primes.  */
688   gcry_mpi_t e;    /* The public exponent.  */
689   gcry_mpi_t n;    /* The public key.  */
690   gcry_mpi_t d;    /* The private key */
691   gcry_mpi_t u;    /* The inverse of p and q.  */
692   gcry_mpi_t pm1;  /* p - 1  */
693   gcry_mpi_t qm1;  /* q - 1  */
694   gcry_mpi_t phi;  /* Euler totient.  */
695   gcry_mpi_t f, g; /* Helper.  */
696
697   *swapped = 0;
698
699   if (e_value == 1)   /* Alias for a secure value. */
700     e_value = 65537;
701
702   /* Point 1 of section 4.1:  k = 1024 + 256s with S >= 0  */
703   if (nbits < 1024 || (nbits % 256))
704     return GPG_ERR_INV_VALUE;
705
706   /* Point 2:  2 <= bitlength(e) < 2^{k-2}
707      Note that we do not need to check the upper bound because we use
708      an unsigned long for E and thus there is no way for E to reach
709      that limit.  */
710   if (e_value < 3)
711     return GPG_ERR_INV_VALUE;
712
713   /* Our implementation requires E to be odd.  */
714   if (!(e_value & 1))
715     return GPG_ERR_INV_VALUE;
716
717   /* Point 3:  e > 0 or e 0 if it is to be randomly generated.
718      We support only a fixed E and thus there is no need for an extra test.  */
719
720
721   /* Compute or extract the derive parameters.  */
722   {
723     gcry_mpi_t xp1 = NULL;
724     gcry_mpi_t xp2 = NULL;
725     gcry_mpi_t xp  = NULL;
726     gcry_mpi_t xq1 = NULL;
727     gcry_mpi_t xq2 = NULL;
728     gcry_mpi_t xq  = NULL;
729     gcry_mpi_t tmpval;
730
731     if (!deriveparms)
732       {
733         /* Not given: Generate them.  */
734         xp = gen_x931_parm_xp (nbits/2);
735         /* Make sure that |xp - xq| > 2^{nbits - 100} holds.  */
736         tmpval = mpi_snew (nbits/2);
737         do
738           {
739             _gcry_mpi_release (xq);
740             xq = gen_x931_parm_xp (nbits/2);
741             mpi_sub (tmpval, xp, xq);
742           }
743         while (mpi_get_nbits (tmpval) <= (nbits/2 - 100));
744         _gcry_mpi_release (tmpval);
745
746         xp1 = gen_x931_parm_xi ();
747         xp2 = gen_x931_parm_xi ();
748         xq1 = gen_x931_parm_xi ();
749         xq2 = gen_x931_parm_xi ();
750
751       }
752     else
753       {
754         /* Parameters to derive the key are given.  */
755         /* Note that we explicitly need to setup the values of tbl
756            because some compilers (e.g. OpenWatcom, IRIX) don't allow
757            to initialize a structure with automatic variables.  */
758         struct { const char *name; gcry_mpi_t *value; } tbl[] = {
759           { "Xp1" },
760           { "Xp2" },
761           { "Xp"  },
762           { "Xq1" },
763           { "Xq2" },
764           { "Xq"  },
765           { NULL }
766         };
767         int idx;
768         gcry_sexp_t oneparm;
769
770         tbl[0].value = &xp1;
771         tbl[1].value = &xp2;
772         tbl[2].value = &xp;
773         tbl[3].value = &xq1;
774         tbl[4].value = &xq2;
775         tbl[5].value = &xq;
776
777         for (idx=0; tbl[idx].name; idx++)
778           {
779             oneparm = sexp_find_token (deriveparms, tbl[idx].name, 0);
780             if (oneparm)
781               {
782                 *tbl[idx].value = sexp_nth_mpi (oneparm, 1, GCRYMPI_FMT_USG);
783                 sexp_release (oneparm);
784               }
785           }
786         for (idx=0; tbl[idx].name; idx++)
787           if (!*tbl[idx].value)
788             break;
789         if (tbl[idx].name)
790           {
791             /* At least one parameter is missing.  */
792             for (idx=0; tbl[idx].name; idx++)
793               _gcry_mpi_release (*tbl[idx].value);
794             return GPG_ERR_MISSING_VALUE;
795           }
796       }
797
798     e = mpi_alloc_set_ui (e_value);
799
800     /* Find two prime numbers.  */
801     p = _gcry_derive_x931_prime (xp, xp1, xp2, e, NULL, NULL);
802     q = _gcry_derive_x931_prime (xq, xq1, xq2, e, NULL, NULL);
803     _gcry_mpi_release (xp);  xp  = NULL;
804     _gcry_mpi_release (xp1); xp1 = NULL;
805     _gcry_mpi_release (xp2); xp2 = NULL;
806     _gcry_mpi_release (xq);  xq  = NULL;
807     _gcry_mpi_release (xq1); xq1 = NULL;
808     _gcry_mpi_release (xq2); xq2 = NULL;
809     if (!p || !q)
810       {
811         _gcry_mpi_release (p);
812         _gcry_mpi_release (q);
813         _gcry_mpi_release (e);
814         return GPG_ERR_NO_PRIME;
815       }
816   }
817
818
819   /* Compute the public modulus.  We make sure that p is smaller than
820      q to allow the use of the CRT.  */
821   if (mpi_cmp (p, q) > 0 )
822     {
823       mpi_swap (p, q);
824       *swapped = 1;
825     }
826   n = mpi_new (nbits);
827   mpi_mul (n, p, q);
828
829   /* Compute the Euler totient:  phi = (p-1)(q-1)  */
830   pm1 = mpi_snew (nbits/2);
831   qm1 = mpi_snew (nbits/2);
832   phi = mpi_snew (nbits);
833   mpi_sub_ui (pm1, p, 1);
834   mpi_sub_ui (qm1, q, 1);
835   mpi_mul (phi, pm1, qm1);
836
837   g = mpi_snew (nbits);
838   gcry_assert (mpi_gcd (g, e, phi));
839
840   /* Compute: f = lcm(p-1,q-1) = phi / gcd(p-1,q-1) */
841   mpi_gcd (g, pm1, qm1);
842   f = pm1; pm1 = NULL;
843   _gcry_mpi_release (qm1); qm1 = NULL;
844   mpi_fdiv_q (f, phi, g);
845   _gcry_mpi_release (phi); phi = NULL;
846   d = g; g = NULL;
847   /* Compute the secret key:  d = e^{-1} mod lcm(p-1,q-1) */
848   mpi_invm (d, e, f);
849
850   /* Compute the inverse of p and q.  */
851   u = f; f = NULL;
852   mpi_invm (u, p, q );
853
854   if( DBG_CIPHER )
855     {
856       if (*swapped)
857         log_debug ("p and q are swapped\n");
858       log_mpidump("  p", p );
859       log_mpidump("  q", q );
860       log_mpidump("  n", n );
861       log_mpidump("  e", e );
862       log_mpidump("  d", d );
863       log_mpidump("  u", u );
864     }
865
866
867   sk->n = n;
868   sk->e = e;
869   sk->p = p;
870   sk->q = q;
871   sk->d = d;
872   sk->u = u;
873
874   /* Now we can test our keys. */
875   if (test_keys (sk, nbits - 64))
876     {
877       _gcry_mpi_release (sk->n); sk->n = NULL;
878       _gcry_mpi_release (sk->e); sk->e = NULL;
879       _gcry_mpi_release (sk->p); sk->p = NULL;
880       _gcry_mpi_release (sk->q); sk->q = NULL;
881       _gcry_mpi_release (sk->d); sk->d = NULL;
882       _gcry_mpi_release (sk->u); sk->u = NULL;
883       fips_signal_error ("self-test after key generation failed");
884       return GPG_ERR_SELFTEST_FAILED;
885     }
886
887   return 0;
888 }
889
890
891 /****************
892  * Test whether the secret key is valid.
893  * Returns: true if this is a valid key.
894  */
895 static int
896 check_secret_key( RSA_secret_key *sk )
897 {
898   int rc;
899   gcry_mpi_t temp = mpi_alloc( mpi_get_nlimbs(sk->p)*2 );
900
901   mpi_mul(temp, sk->p, sk->q );
902   rc = mpi_cmp( temp, sk->n );
903   mpi_free(temp);
904   return !rc;
905 }
906
907
908
909 /****************
910  * Public key operation. Encrypt INPUT with PKEY and put result into OUTPUT.
911  *
912  *      c = m^e mod n
913  *
914  * Where c is OUTPUT, m is INPUT and e,n are elements of PKEY.
915  */
916 static void
917 public(gcry_mpi_t output, gcry_mpi_t input, RSA_public_key *pkey )
918 {
919   if( output == input )  /* powm doesn't like output and input the same */
920     {
921       gcry_mpi_t x = mpi_alloc( mpi_get_nlimbs(input)*2 );
922       mpi_powm( x, input, pkey->e, pkey->n );
923       mpi_set(output, x);
924       mpi_free(x);
925     }
926   else
927     mpi_powm( output, input, pkey->e, pkey->n );
928 }
929
930 #if 0
931 static void
932 stronger_key_check ( RSA_secret_key *skey )
933 {
934   gcry_mpi_t t = mpi_alloc_secure ( 0 );
935   gcry_mpi_t t1 = mpi_alloc_secure ( 0 );
936   gcry_mpi_t t2 = mpi_alloc_secure ( 0 );
937   gcry_mpi_t phi = mpi_alloc_secure ( 0 );
938
939   /* check that n == p * q */
940   mpi_mul( t, skey->p, skey->q);
941   if (mpi_cmp( t, skey->n) )
942     log_info ( "RSA Oops: n != p * q\n" );
943
944   /* check that p is less than q */
945   if( mpi_cmp( skey->p, skey->q ) > 0 )
946     {
947       log_info ("RSA Oops: p >= q - fixed\n");
948       _gcry_mpi_swap ( skey->p, skey->q);
949     }
950
951     /* check that e divides neither p-1 nor q-1 */
952     mpi_sub_ui(t, skey->p, 1 );
953     mpi_fdiv_r(t, t, skey->e );
954     if ( !mpi_cmp_ui( t, 0) )
955         log_info ( "RSA Oops: e divides p-1\n" );
956     mpi_sub_ui(t, skey->q, 1 );
957     mpi_fdiv_r(t, t, skey->e );
958     if ( !mpi_cmp_ui( t, 0) )
959         log_info ( "RSA Oops: e divides q-1\n" );
960
961     /* check that d is correct */
962     mpi_sub_ui( t1, skey->p, 1 );
963     mpi_sub_ui( t2, skey->q, 1 );
964     mpi_mul( phi, t1, t2 );
965     gcry_mpi_gcd(t, t1, t2);
966     mpi_fdiv_q(t, phi, t);
967     mpi_invm(t, skey->e, t );
968     if ( mpi_cmp(t, skey->d ) )
969       {
970         log_info ( "RSA Oops: d is wrong - fixed\n");
971         mpi_set (skey->d, t);
972         log_printmpi ("  fixed d", skey->d);
973       }
974
975     /* check for correctness of u */
976     mpi_invm(t, skey->p, skey->q );
977     if ( mpi_cmp(t, skey->u ) )
978       {
979         log_info ( "RSA Oops: u is wrong - fixed\n");
980         mpi_set (skey->u, t);
981         log_printmpi ("  fixed u", skey->u);
982       }
983
984     log_info ( "RSA secret key check finished\n");
985
986     mpi_free (t);
987     mpi_free (t1);
988     mpi_free (t2);
989     mpi_free (phi);
990 }
991 #endif
992
993
994 \f
995 /* Secret key operation - standard version.
996  *
997  *      m = c^d mod n
998  */
999 static void
1000 secret_core_std (gcry_mpi_t M, gcry_mpi_t C,
1001                  gcry_mpi_t D, gcry_mpi_t N)
1002 {
1003   mpi_powm (M, C, D, N);
1004 }
1005
1006
1007 /* Secret key operation - using the CRT.
1008  *
1009  *      m1 = c ^ (d mod (p-1)) mod p
1010  *      m2 = c ^ (d mod (q-1)) mod q
1011  *      h = u * (m2 - m1) mod q
1012  *      m = m1 + h * p
1013  */
1014 static void
1015 secret_core_crt (gcry_mpi_t M, gcry_mpi_t C,
1016                  gcry_mpi_t D, unsigned int Nlimbs,
1017                  gcry_mpi_t P, gcry_mpi_t Q, gcry_mpi_t U)
1018 {
1019   gcry_mpi_t m1 = mpi_alloc_secure ( Nlimbs + 1 );
1020   gcry_mpi_t m2 = mpi_alloc_secure ( Nlimbs + 1 );
1021   gcry_mpi_t h  = mpi_alloc_secure ( Nlimbs + 1 );
1022   gcry_mpi_t D_blind = mpi_alloc_secure ( Nlimbs + 1 );
1023   gcry_mpi_t r;
1024   unsigned int r_nbits;
1025
1026   r_nbits = mpi_get_nbits (P) / 4;
1027   if (r_nbits < 96)
1028     r_nbits = 96;
1029   r = mpi_secure_new (r_nbits);
1030
1031   /* d_blind = (d mod (p-1)) + (p-1) * r            */
1032   /* m1 = c ^ d_blind mod p */
1033   _gcry_mpi_randomize (r, r_nbits, GCRY_WEAK_RANDOM);
1034   mpi_set_highbit (r, r_nbits - 1);
1035   mpi_sub_ui ( h, P, 1 );
1036   mpi_mul ( D_blind, h, r );
1037   mpi_fdiv_r ( h, D, h );
1038   mpi_add ( D_blind, D_blind, h );
1039   mpi_powm ( m1, C, D_blind, P );
1040
1041   /* d_blind = (d mod (q-1)) + (q-1) * r            */
1042   /* m2 = c ^ d_blind mod q */
1043   _gcry_mpi_randomize (r, r_nbits, GCRY_WEAK_RANDOM);
1044   mpi_set_highbit (r, r_nbits - 1);
1045   mpi_sub_ui ( h, Q, 1  );
1046   mpi_mul ( D_blind, h, r );
1047   mpi_fdiv_r ( h, D, h );
1048   mpi_add ( D_blind, D_blind, h );
1049   mpi_powm ( m2, C, D_blind, Q );
1050
1051   mpi_free ( r );
1052   mpi_free ( D_blind );
1053
1054   /* h = u * ( m2 - m1 ) mod q */
1055   mpi_sub ( h, m2, m1 );
1056   if ( mpi_has_sign ( h ) )
1057     mpi_add ( h, h, Q );
1058   mpi_mulm ( h, U, h, Q );
1059
1060   /* m = m1 + h * p */
1061   mpi_mul ( h, h, P );
1062   mpi_add ( M, m1, h );
1063
1064   mpi_free ( h );
1065   mpi_free ( m1 );
1066   mpi_free ( m2 );
1067 }
1068
1069
1070 /* Secret key operation.
1071  * Encrypt INPUT with SKEY and put result into
1072  * OUTPUT.  SKEY has the secret key parameters.
1073  */
1074 static void
1075 secret (gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey )
1076 {
1077   /* Remove superfluous leading zeroes from INPUT.  */
1078   mpi_normalize (input);
1079
1080   if (!skey->p || !skey->q || !skey->u)
1081     {
1082       secret_core_std (output, input, skey->d, skey->n);
1083     }
1084   else
1085     {
1086       secret_core_crt (output, input, skey->d, mpi_get_nlimbs (skey->n),
1087                        skey->p, skey->q, skey->u);
1088     }
1089 }
1090
1091
1092 static void
1093 secret_blinded (gcry_mpi_t output, gcry_mpi_t input,
1094                 RSA_secret_key *sk, unsigned int nbits)
1095 {
1096   gcry_mpi_t r;            /* Random number needed for blinding.  */
1097   gcry_mpi_t ri;           /* Modular multiplicative inverse of r.  */
1098   gcry_mpi_t bldata;       /* Blinded data to decrypt.  */
1099
1100   /* First, we need a random number r between 0 and n - 1, which is
1101    * relatively prime to n (i.e. it is neither p nor q).  The random
1102    * number needs to be only unpredictable, thus we employ the
1103    * gcry_create_nonce function by using GCRY_WEAK_RANDOM with
1104    * gcry_mpi_randomize.  */
1105   r  = mpi_snew (nbits);
1106   ri = mpi_snew (nbits);
1107   bldata = mpi_snew (nbits);
1108
1109   do
1110     {
1111       _gcry_mpi_randomize (r, nbits, GCRY_WEAK_RANDOM);
1112       mpi_mod (r, r, sk->n);
1113     }
1114   while (!mpi_invm (ri, r, sk->n));
1115
1116   /* Do blinding.  We calculate: y = (x * r^e) mod n, where r is the
1117    * random number, e is the public exponent, x is the non-blinded
1118    * input data and n is the RSA modulus.  */
1119   mpi_powm (bldata, r, sk->e, sk->n);
1120   mpi_mulm (bldata, bldata, input, sk->n);
1121
1122   /* Perform decryption.  */
1123   secret (output, bldata, sk);
1124   _gcry_mpi_release (bldata);
1125
1126   /* Undo blinding.  Here we calculate: y = (x * r^-1) mod n, where x
1127    * is the blinded decrypted data, ri is the modular multiplicative
1128    * inverse of r and n is the RSA modulus.  */
1129   mpi_mulm (output, output, ri, sk->n);
1130
1131   _gcry_mpi_release (r);
1132   _gcry_mpi_release (ri);
1133 }
1134
1135 \f
1136 /*********************************************
1137  **************  interface  ******************
1138  *********************************************/
1139
1140 static gcry_err_code_t
1141 rsa_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
1142 {
1143   gpg_err_code_t ec;
1144   unsigned int nbits;
1145   unsigned long evalue;
1146   RSA_secret_key sk;
1147   gcry_sexp_t deriveparms;
1148   int flags = 0;
1149   gcry_sexp_t l1;
1150   gcry_sexp_t swap_info = NULL;
1151
1152   memset (&sk, 0, sizeof sk);
1153
1154   ec = _gcry_pk_util_get_nbits (genparms, &nbits);
1155   if (ec)
1156     return ec;
1157
1158   ec = _gcry_pk_util_get_rsa_use_e (genparms, &evalue);
1159   if (ec)
1160     return ec;
1161
1162   /* Parse the optional flags list.  */
1163   l1 = sexp_find_token (genparms, "flags", 0);
1164   if (l1)
1165     {
1166       ec = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
1167       sexp_release (l1);
1168       if (ec)
1169         return ec;
1170     }
1171
1172   deriveparms = (genparms?
1173                  sexp_find_token (genparms, "derive-parms", 0) : NULL);
1174   if (!deriveparms)
1175     {
1176       /* Parse the optional "use-x931" flag. */
1177       l1 = sexp_find_token (genparms, "use-x931", 0);
1178       if (l1)
1179         {
1180           flags |= PUBKEY_FLAG_USE_X931;
1181           sexp_release (l1);
1182         }
1183     }
1184
1185   if (deriveparms || (flags & PUBKEY_FLAG_USE_X931))
1186     {
1187       int swapped;
1188       ec = generate_x931 (&sk, nbits, evalue, deriveparms, &swapped);
1189       sexp_release (deriveparms);
1190       if (!ec && swapped)
1191         ec = sexp_new (&swap_info, "(misc-key-info(p-q-swapped))", 0, 1);
1192     }
1193   else
1194     {
1195       /* Parse the optional "transient-key" flag. */
1196       if (!(flags & PUBKEY_FLAG_TRANSIENT_KEY))
1197         {
1198           l1 = sexp_find_token (genparms, "transient-key", 0);
1199           if (l1)
1200             {
1201               flags |= PUBKEY_FLAG_TRANSIENT_KEY;
1202               sexp_release (l1);
1203             }
1204         }
1205       deriveparms = (genparms? sexp_find_token (genparms, "test-parms", 0)
1206                      /**/    : NULL);
1207
1208       /* Generate.  */
1209       if (deriveparms || fips_mode())
1210         {
1211           ec = generate_fips (&sk, nbits, evalue, deriveparms,
1212                               !!(flags & PUBKEY_FLAG_TRANSIENT_KEY));
1213         }
1214       else
1215         {
1216           ec = generate_std (&sk, nbits, evalue,
1217                              !!(flags & PUBKEY_FLAG_TRANSIENT_KEY));
1218         }
1219       sexp_release (deriveparms);
1220     }
1221
1222   if (!ec)
1223     {
1224       ec = sexp_build (r_skey, NULL,
1225                        "(key-data"
1226                        " (public-key"
1227                        "  (rsa(n%m)(e%m)))"
1228                        " (private-key"
1229                        "  (rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))"
1230                        " %S)",
1231                        sk.n, sk.e,
1232                        sk.n, sk.e, sk.d, sk.p, sk.q, sk.u,
1233                        swap_info);
1234     }
1235
1236   mpi_free (sk.n);
1237   mpi_free (sk.e);
1238   mpi_free (sk.p);
1239   mpi_free (sk.q);
1240   mpi_free (sk.d);
1241   mpi_free (sk.u);
1242   sexp_release (swap_info);
1243
1244   return ec;
1245 }
1246
1247
1248 static gcry_err_code_t
1249 rsa_check_secret_key (gcry_sexp_t keyparms)
1250 {
1251   gcry_err_code_t rc;
1252   RSA_secret_key sk = {NULL, NULL, NULL, NULL, NULL, NULL};
1253
1254   /* To check the key we need the optional parameters. */
1255   rc = sexp_extract_param (keyparms, NULL, "nedpqu",
1256                            &sk.n, &sk.e, &sk.d, &sk.p, &sk.q, &sk.u,
1257                            NULL);
1258   if (rc)
1259     goto leave;
1260
1261   if (!check_secret_key (&sk))
1262     rc = GPG_ERR_BAD_SECKEY;
1263
1264  leave:
1265   _gcry_mpi_release (sk.n);
1266   _gcry_mpi_release (sk.e);
1267   _gcry_mpi_release (sk.d);
1268   _gcry_mpi_release (sk.p);
1269   _gcry_mpi_release (sk.q);
1270   _gcry_mpi_release (sk.u);
1271   if (DBG_CIPHER)
1272     log_debug ("rsa_testkey    => %s\n", gpg_strerror (rc));
1273   return rc;
1274 }
1275
1276
1277 static gcry_err_code_t
1278 rsa_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1279 {
1280   gcry_err_code_t rc;
1281   struct pk_encoding_ctx ctx;
1282   gcry_mpi_t data = NULL;
1283   RSA_public_key pk = {NULL, NULL};
1284   gcry_mpi_t ciph = NULL;
1285
1286   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_ENCRYPT,
1287                                    rsa_get_nbits (keyparms));
1288
1289   /* Extract the data.  */
1290   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1291   if (rc)
1292     goto leave;
1293   if (DBG_CIPHER)
1294     log_mpidump ("rsa_encrypt data", data);
1295   if (!data || mpi_is_opaque (data))
1296     {
1297       rc = GPG_ERR_INV_DATA;
1298       goto leave;
1299     }
1300
1301   /* Extract the key.  */
1302   rc = sexp_extract_param (keyparms, NULL, "ne", &pk.n, &pk.e, NULL);
1303   if (rc)
1304     goto leave;
1305   if (DBG_CIPHER)
1306     {
1307       log_mpidump ("rsa_encrypt    n", pk.n);
1308       log_mpidump ("rsa_encrypt    e", pk.e);
1309     }
1310
1311   /* Do RSA computation and build result.  */
1312   ciph = mpi_new (0);
1313   public (ciph, data, &pk);
1314   if (DBG_CIPHER)
1315     log_mpidump ("rsa_encrypt  res", ciph);
1316   if ((ctx.flags & PUBKEY_FLAG_FIXEDLEN))
1317     {
1318       /* We need to make sure to return the correct length to avoid
1319          problems with missing leading zeroes.  */
1320       unsigned char *em;
1321       size_t emlen = (mpi_get_nbits (pk.n)+7)/8;
1322
1323       rc = _gcry_mpi_to_octet_string (&em, NULL, ciph, emlen);
1324       if (!rc)
1325         {
1326           rc = sexp_build (r_ciph, NULL, "(enc-val(rsa(a%b)))", (int)emlen, em);
1327           xfree (em);
1328         }
1329     }
1330   else
1331     rc = sexp_build (r_ciph, NULL, "(enc-val(rsa(a%m)))", ciph);
1332
1333  leave:
1334   _gcry_mpi_release (ciph);
1335   _gcry_mpi_release (pk.n);
1336   _gcry_mpi_release (pk.e);
1337   _gcry_mpi_release (data);
1338   _gcry_pk_util_free_encoding_ctx (&ctx);
1339   if (DBG_CIPHER)
1340     log_debug ("rsa_encrypt    => %s\n", gpg_strerror (rc));
1341   return rc;
1342 }
1343
1344
1345 static gcry_err_code_t
1346 rsa_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1347
1348 {
1349   gpg_err_code_t rc;
1350   struct pk_encoding_ctx ctx;
1351   gcry_sexp_t l1 = NULL;
1352   gcry_mpi_t data = NULL;
1353   RSA_secret_key sk = {NULL, NULL, NULL, NULL, NULL, NULL};
1354   gcry_mpi_t plain = NULL;
1355   unsigned char *unpad = NULL;
1356   size_t unpadlen = 0;
1357
1358   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_DECRYPT,
1359                                    rsa_get_nbits (keyparms));
1360
1361   /* Extract the data.  */
1362   rc = _gcry_pk_util_preparse_encval (s_data, rsa_names, &l1, &ctx);
1363   if (rc)
1364     goto leave;
1365   rc = sexp_extract_param (l1, NULL, "a", &data, NULL);
1366   if (rc)
1367     goto leave;
1368   if (DBG_CIPHER)
1369     log_printmpi ("rsa_decrypt data", data);
1370   if (mpi_is_opaque (data))
1371     {
1372       rc = GPG_ERR_INV_DATA;
1373       goto leave;
1374     }
1375
1376   /* Extract the key.  */
1377   rc = sexp_extract_param (keyparms, NULL, "nedp?q?u?",
1378                            &sk.n, &sk.e, &sk.d, &sk.p, &sk.q, &sk.u,
1379                            NULL);
1380   if (rc)
1381     goto leave;
1382   if (DBG_CIPHER)
1383     {
1384       log_printmpi ("rsa_decrypt    n", sk.n);
1385       log_printmpi ("rsa_decrypt    e", sk.e);
1386       if (!fips_mode ())
1387         {
1388           log_printmpi ("rsa_decrypt    d", sk.d);
1389           log_printmpi ("rsa_decrypt    p", sk.p);
1390           log_printmpi ("rsa_decrypt    q", sk.q);
1391           log_printmpi ("rsa_decrypt    u", sk.u);
1392         }
1393     }
1394
1395   /* Better make sure that there are no superfluous leading zeroes in
1396      the input and it has not been "padded" using multiples of N.
1397      This mitigates side-channel attacks (CVE-2013-4576).  */
1398   mpi_normalize (data);
1399   mpi_fdiv_r (data, data, sk.n);
1400
1401   /* Allocate MPI for the plaintext.  */
1402   plain = mpi_snew (ctx.nbits);
1403
1404   /* We use blinding by default to mitigate timing attacks which can
1405      be practically mounted over the network as shown by Brumley and
1406      Boney in 2003.  */
1407   if ((ctx.flags & PUBKEY_FLAG_NO_BLINDING))
1408     secret (plain, data, &sk);
1409   else
1410     secret_blinded (plain, data, &sk, ctx.nbits);
1411
1412   if (DBG_CIPHER)
1413     log_printmpi ("rsa_decrypt  res", plain);
1414
1415   /* Reverse the encoding and build the s-expression.  */
1416   switch (ctx.encoding)
1417     {
1418     case PUBKEY_ENC_PKCS1:
1419       rc = _gcry_rsa_pkcs1_decode_for_enc (&unpad, &unpadlen, ctx.nbits, plain);
1420       mpi_free (plain);
1421       plain = NULL;
1422       if (!rc)
1423         rc = sexp_build (r_plain, NULL, "(value %b)", (int)unpadlen, unpad);
1424       break;
1425
1426     case PUBKEY_ENC_OAEP:
1427       rc = _gcry_rsa_oaep_decode (&unpad, &unpadlen,
1428                                   ctx.nbits, ctx.hash_algo,
1429                                   plain, ctx.label, ctx.labellen);
1430       mpi_free (plain);
1431       plain = NULL;
1432       if (!rc)
1433         rc = sexp_build (r_plain, NULL, "(value %b)", (int)unpadlen, unpad);
1434       break;
1435
1436     default:
1437       /* Raw format.  For backward compatibility we need to assume a
1438          signed mpi by using the sexp format string "%m".  */
1439       rc = sexp_build (r_plain, NULL,
1440                        (ctx.flags & PUBKEY_FLAG_LEGACYRESULT)
1441                        ? "%m":"(value %m)", plain);
1442       break;
1443     }
1444
1445  leave:
1446   xfree (unpad);
1447   _gcry_mpi_release (plain);
1448   _gcry_mpi_release (sk.n);
1449   _gcry_mpi_release (sk.e);
1450   _gcry_mpi_release (sk.d);
1451   _gcry_mpi_release (sk.p);
1452   _gcry_mpi_release (sk.q);
1453   _gcry_mpi_release (sk.u);
1454   _gcry_mpi_release (data);
1455   sexp_release (l1);
1456   _gcry_pk_util_free_encoding_ctx (&ctx);
1457   if (DBG_CIPHER)
1458     log_debug ("rsa_decrypt    => %s\n", gpg_strerror (rc));
1459   return rc;
1460 }
1461
1462
1463 static gcry_err_code_t
1464 rsa_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1465 {
1466   gpg_err_code_t rc;
1467   struct pk_encoding_ctx ctx;
1468   gcry_mpi_t data = NULL;
1469   RSA_secret_key sk = {NULL, NULL, NULL, NULL, NULL, NULL};
1470   RSA_public_key pk;
1471   gcry_mpi_t sig = NULL;
1472   gcry_mpi_t result = NULL;
1473
1474   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_SIGN,
1475                                    rsa_get_nbits (keyparms));
1476
1477   /* Extract the data.  */
1478   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1479   if (rc)
1480     goto leave;
1481   if (DBG_CIPHER)
1482     log_printmpi ("rsa_sign   data", data);
1483   if (mpi_is_opaque (data))
1484     {
1485       rc = GPG_ERR_INV_DATA;
1486       goto leave;
1487     }
1488
1489   /* Extract the key.  */
1490   rc = sexp_extract_param (keyparms, NULL, "nedp?q?u?",
1491                            &sk.n, &sk.e, &sk.d, &sk.p, &sk.q, &sk.u,
1492                            NULL);
1493   if (rc)
1494     goto leave;
1495   if (DBG_CIPHER)
1496     {
1497       log_printmpi ("rsa_sign      n", sk.n);
1498       log_printmpi ("rsa_sign      e", sk.e);
1499       if (!fips_mode ())
1500         {
1501           log_printmpi ("rsa_sign      d", sk.d);
1502           log_printmpi ("rsa_sign      p", sk.p);
1503           log_printmpi ("rsa_sign      q", sk.q);
1504           log_printmpi ("rsa_sign      u", sk.u);
1505         }
1506     }
1507
1508   /* Do RSA computation.  */
1509   sig = mpi_new (0);
1510   if ((ctx.flags & PUBKEY_FLAG_NO_BLINDING))
1511     secret (sig, data, &sk);
1512   else
1513     secret_blinded (sig, data, &sk, ctx.nbits);
1514   if (DBG_CIPHER)
1515     log_printmpi ("rsa_sign    res", sig);
1516
1517   /* Check that the created signature is good.  This detects a failure
1518      of the CRT algorithm  (Lenstra's attack on RSA's use of the CRT).  */
1519   result = mpi_new (0);
1520   pk.n = sk.n;
1521   pk.e = sk.e;
1522   public (result, sig, &pk);
1523   if (mpi_cmp (result, data))
1524     {
1525       rc = GPG_ERR_BAD_SIGNATURE;
1526       goto leave;
1527     }
1528
1529   /* Convert the result.  */
1530   if ((ctx.flags & PUBKEY_FLAG_FIXEDLEN))
1531     {
1532       /* We need to make sure to return the correct length to avoid
1533          problems with missing leading zeroes.  */
1534       unsigned char *em;
1535       size_t emlen = (mpi_get_nbits (sk.n)+7)/8;
1536
1537       rc = _gcry_mpi_to_octet_string (&em, NULL, sig, emlen);
1538       if (!rc)
1539         {
1540           rc = sexp_build (r_sig, NULL, "(sig-val(rsa(s%b)))", (int)emlen, em);
1541           xfree (em);
1542         }
1543     }
1544   else
1545     rc = sexp_build (r_sig, NULL, "(sig-val(rsa(s%M)))", sig);
1546
1547
1548  leave:
1549   _gcry_mpi_release (result);
1550   _gcry_mpi_release (sig);
1551   _gcry_mpi_release (sk.n);
1552   _gcry_mpi_release (sk.e);
1553   _gcry_mpi_release (sk.d);
1554   _gcry_mpi_release (sk.p);
1555   _gcry_mpi_release (sk.q);
1556   _gcry_mpi_release (sk.u);
1557   _gcry_mpi_release (data);
1558   _gcry_pk_util_free_encoding_ctx (&ctx);
1559   if (DBG_CIPHER)
1560     log_debug ("rsa_sign      => %s\n", gpg_strerror (rc));
1561   return rc;
1562 }
1563
1564
1565 static gcry_err_code_t
1566 rsa_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1567 {
1568   gcry_err_code_t rc;
1569   struct pk_encoding_ctx ctx;
1570   gcry_sexp_t l1 = NULL;
1571   gcry_mpi_t sig = NULL;
1572   gcry_mpi_t data = NULL;
1573   RSA_public_key pk = { NULL, NULL };
1574   gcry_mpi_t result = NULL;
1575
1576   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_VERIFY,
1577                                    rsa_get_nbits (keyparms));
1578
1579   /* Extract the data.  */
1580   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1581   if (rc)
1582     goto leave;
1583   if (DBG_CIPHER)
1584     log_printmpi ("rsa_verify data", data);
1585   if (mpi_is_opaque (data))
1586     {
1587       rc = GPG_ERR_INV_DATA;
1588       goto leave;
1589     }
1590
1591   /* Extract the signature value.  */
1592   rc = _gcry_pk_util_preparse_sigval (s_sig, rsa_names, &l1, NULL);
1593   if (rc)
1594     goto leave;
1595   rc = sexp_extract_param (l1, NULL, "s", &sig, NULL);
1596   if (rc)
1597     goto leave;
1598   if (DBG_CIPHER)
1599     log_printmpi ("rsa_verify  sig", sig);
1600
1601   /* Extract the key.  */
1602   rc = sexp_extract_param (keyparms, NULL, "ne", &pk.n, &pk.e, NULL);
1603   if (rc)
1604     goto leave;
1605   if (DBG_CIPHER)
1606     {
1607       log_printmpi ("rsa_verify    n", pk.n);
1608       log_printmpi ("rsa_verify    e", pk.e);
1609     }
1610
1611   /* Do RSA computation and compare.  */
1612   result = mpi_new (0);
1613   public (result, sig, &pk);
1614   if (DBG_CIPHER)
1615     log_printmpi ("rsa_verify  cmp", result);
1616   if (ctx.verify_cmp)
1617     rc = ctx.verify_cmp (&ctx, result);
1618   else
1619     rc = mpi_cmp (result, data) ? GPG_ERR_BAD_SIGNATURE : 0;
1620
1621  leave:
1622   _gcry_mpi_release (result);
1623   _gcry_mpi_release (pk.n);
1624   _gcry_mpi_release (pk.e);
1625   _gcry_mpi_release (data);
1626   _gcry_mpi_release (sig);
1627   sexp_release (l1);
1628   _gcry_pk_util_free_encoding_ctx (&ctx);
1629   if (DBG_CIPHER)
1630     log_debug ("rsa_verify    => %s\n", rc?gpg_strerror (rc):"Good");
1631   return rc;
1632 }
1633
1634
1635
1636 /* Return the number of bits for the key described by PARMS.  On error
1637  * 0 is returned.  The format of PARMS starts with the algorithm name;
1638  * for example:
1639  *
1640  *   (rsa
1641  *     (n <mpi>)
1642  *     (e <mpi>))
1643  *
1644  * More parameters may be given but we only need N here.
1645  */
1646 static unsigned int
1647 rsa_get_nbits (gcry_sexp_t parms)
1648 {
1649   gcry_sexp_t l1;
1650   gcry_mpi_t n;
1651   unsigned int nbits;
1652
1653   l1 = sexp_find_token (parms, "n", 1);
1654   if (!l1)
1655     return 0; /* Parameter N not found.  */
1656
1657   n = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1658   sexp_release (l1);
1659   nbits = n? mpi_get_nbits (n) : 0;
1660   _gcry_mpi_release (n);
1661   return nbits;
1662 }
1663
1664
1665 /* Compute a keygrip.  MD is the hash context which we are going to
1666    update.  KEYPARAM is an S-expression with the key parameters, this
1667    is usually a public key but may also be a secret key.  An example
1668    of such an S-expression is:
1669
1670       (rsa
1671         (n #00B...#)
1672         (e #010001#))
1673
1674    PKCS-15 says that for RSA only the modulus should be hashed -
1675    however, it is not clear whether this is meant to use the raw bytes
1676    (assuming this is an unsigned integer) or whether the DER required
1677    0 should be prefixed.  We hash the raw bytes.  */
1678 static gpg_err_code_t
1679 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
1680 {
1681   gcry_sexp_t l1;
1682   const char *data;
1683   size_t datalen;
1684
1685   l1 = sexp_find_token (keyparam, "n", 1);
1686   if (!l1)
1687     return GPG_ERR_NO_OBJ;
1688
1689   data = sexp_nth_data (l1, 1, &datalen);
1690   if (!data)
1691     {
1692       sexp_release (l1);
1693       return GPG_ERR_NO_OBJ;
1694     }
1695
1696   _gcry_md_write (md, data, datalen);
1697   sexp_release (l1);
1698
1699   return 0;
1700 }
1701
1702
1703
1704 \f
1705 /*
1706      Self-test section.
1707  */
1708
1709 static const char *
1710 selftest_sign_2048 (gcry_sexp_t pkey, gcry_sexp_t skey)
1711 {
1712   static const char sample_data[] =
1713     "(data (flags pkcs1)"
1714     " (hash sha256 #11223344556677889900aabbccddeeff"
1715     /**/           "102030405060708090a0b0c0d0f01121#))";
1716   static const char sample_data_bad[] =
1717     "(data (flags pkcs1)"
1718     " (hash sha256 #11223344556677889900aabbccddeeff"
1719     /**/           "802030405060708090a0b0c0d0f01121#))";
1720
1721   const char *errtxt = NULL;
1722   gcry_error_t err;
1723   gcry_sexp_t data = NULL;
1724   gcry_sexp_t data_bad = NULL;
1725   gcry_sexp_t sig = NULL;
1726   /* raw signature data reference */
1727   const char ref_data[] =
1728     "6252a19a11e1d5155ed9376036277193d644fa239397fff03e9b92d6f86415d6"
1729     "d30da9273775f290e580d038295ff8ff89522becccfa6ae870bf76b76df402a8"
1730     "54f69347e3db3de8e1e7d4dada281ec556810c7a8ecd0b5f51f9b1c0e7aa7557"
1731     "61aa2b8ba5f811304acc6af0eca41fe49baf33bf34eddaf44e21e036ac7f0b68"
1732     "03cdef1c60021fb7b5b97ebacdd88ab755ce29af568dbc5728cc6e6eff42618d"
1733     "62a0386ca8beed46402bdeeef29b6a3feded906bace411a06a39192bf516ae10"
1734     "67e4320fa8ea113968525f4574d022a3ceeaafdc41079efe1f22cc94bf59d8d3"
1735     "328085da9674857db56de5978a62394aab48aa3b72e23a1b16260cfd9daafe65";
1736   gcry_mpi_t ref_mpi = NULL;
1737   gcry_mpi_t sig_mpi = NULL;
1738
1739   err = sexp_sscan (&data, NULL, sample_data, strlen (sample_data));
1740   if (!err)
1741     err = sexp_sscan (&data_bad, NULL,
1742                       sample_data_bad, strlen (sample_data_bad));
1743   if (err)
1744     {
1745       errtxt = "converting data failed";
1746       goto leave;
1747     }
1748
1749   err = _gcry_pk_sign (&sig, data, skey);
1750   if (err)
1751     {
1752       errtxt = "signing failed";
1753       goto leave;
1754     }
1755
1756   err = _gcry_mpi_scan(&ref_mpi, GCRYMPI_FMT_HEX, ref_data, 0, NULL);
1757   if (err)
1758     {
1759       errtxt = "converting ref_data to mpi failed";
1760       goto leave;
1761     }
1762
1763   err = _gcry_sexp_extract_param(sig, "sig-val!rsa", "s", &sig_mpi, NULL);
1764   if (err)
1765     {
1766       errtxt = "extracting signature data failed";
1767       goto leave;
1768     }
1769
1770   if (mpi_cmp (sig_mpi, ref_mpi))
1771     {
1772       errtxt = "signature does not match reference data";
1773       goto leave;
1774     }
1775
1776   err = _gcry_pk_verify (sig, data, pkey);
1777   if (err)
1778     {
1779       errtxt = "verify failed";
1780       goto leave;
1781     }
1782   err = _gcry_pk_verify (sig, data_bad, pkey);
1783   if (gcry_err_code (err) != GPG_ERR_BAD_SIGNATURE)
1784     {
1785       errtxt = "bad signature not detected";
1786       goto leave;
1787     }
1788
1789
1790  leave:
1791   sexp_release (sig);
1792   sexp_release (data_bad);
1793   sexp_release (data);
1794   _gcry_mpi_release (ref_mpi);
1795   _gcry_mpi_release (sig_mpi);
1796   return errtxt;
1797 }
1798
1799
1800
1801 /* Given an S-expression ENCR_DATA of the form:
1802
1803    (enc-val
1804     (rsa
1805      (a a-value)))
1806
1807    as returned by gcry_pk_decrypt, return the the A-VALUE.  On error,
1808    return NULL.  */
1809 static gcry_mpi_t
1810 extract_a_from_sexp (gcry_sexp_t encr_data)
1811 {
1812   gcry_sexp_t l1, l2, l3;
1813   gcry_mpi_t a_value;
1814
1815   l1 = sexp_find_token (encr_data, "enc-val", 0);
1816   if (!l1)
1817     return NULL;
1818   l2 = sexp_find_token (l1, "rsa", 0);
1819   sexp_release (l1);
1820   if (!l2)
1821     return NULL;
1822   l3 = sexp_find_token (l2, "a", 0);
1823   sexp_release (l2);
1824   if (!l3)
1825     return NULL;
1826   a_value = sexp_nth_mpi (l3, 1, 0);
1827   sexp_release (l3);
1828
1829   return a_value;
1830 }
1831
1832
1833 static const char *
1834 selftest_encr_2048 (gcry_sexp_t pkey, gcry_sexp_t skey)
1835 {
1836   const char *errtxt = NULL;
1837   gcry_error_t err;
1838   static const char plaintext[] =
1839     "Jim quickly realized that the beautiful gowns are expensive.";
1840   gcry_sexp_t plain = NULL;
1841   gcry_sexp_t encr  = NULL;
1842   gcry_mpi_t  ciphertext = NULL;
1843   gcry_sexp_t decr  = NULL;
1844   char *decr_plaintext = NULL;
1845   gcry_sexp_t tmplist = NULL;
1846   /* expected result of encrypting the plaintext with sample_secret_key */
1847   static const char ref_data[] =
1848     "18022e2593a402a737caaa93b4c7e750e20ca265452980e1d6b7710fbd3e"
1849     "7dce72be5c2110fb47691cb38f42170ee3b4a37f2498d4a51567d762585e"
1850     "4cb81d04fbc7df4144f8e5eac2d4b8688521b64011f11d7ad53f4c874004"
1851     "819856f2e2a6f83d1c9c4e73ac26089789c14482b0b8d44139133c88c4a5"
1852     "2dba9dd6d6ffc622666b7d129168333d999706af30a2d7d272db7734e5ed"
1853     "fb8c64ea3018af3ad20f4a013a5060cb0f5e72753967bebe294280a6ed0d"
1854     "dbd3c4f11d0a8696e9d32a0dc03deb0b5e49b2cbd1503392642d4e1211f3"
1855     "e8e2ee38abaa3671ccd57fcde8ca76e85fd2cb77c35706a970a213a27352"
1856     "cec92a9604d543ddb5fc478ff50e0622";
1857   gcry_mpi_t ref_mpi = NULL;
1858
1859   /* Put the plaintext into an S-expression.  */
1860   err = sexp_build (&plain, NULL, "(data (flags raw) (value %s))", plaintext);
1861   if (err)
1862     {
1863       errtxt = "converting data failed";
1864       goto leave;
1865     }
1866
1867   /* Encrypt.  */
1868   err = _gcry_pk_encrypt (&encr, plain, pkey);
1869   if (err)
1870     {
1871       errtxt = "encrypt failed";
1872       goto leave;
1873     }
1874
1875   err = _gcry_mpi_scan(&ref_mpi, GCRYMPI_FMT_HEX, ref_data, 0, NULL);
1876   if (err)
1877     {
1878       errtxt = "converting encrydata to mpi failed";
1879       goto leave;
1880     }
1881
1882   /* Extraxt the ciphertext from the returned S-expression.  */
1883   /*sexp_dump (encr);*/
1884   ciphertext = extract_a_from_sexp (encr);
1885   if (!ciphertext)
1886     {
1887       errtxt = "gcry_pk_decrypt returned garbage";
1888       goto leave;
1889     }
1890
1891   /* Check that the ciphertext does no match the plaintext.  */
1892   /* _gcry_log_printmpi ("plaintext", plaintext); */
1893   /* _gcry_log_printmpi ("ciphertxt", ciphertext); */
1894   if (mpi_cmp (ref_mpi, ciphertext))
1895     {
1896       errtxt = "ciphertext doesn't match reference data";
1897       goto leave;
1898     }
1899
1900   /* Decrypt.  */
1901   err = _gcry_pk_decrypt (&decr, encr, skey);
1902   if (err)
1903     {
1904       errtxt = "decrypt failed";
1905       goto leave;
1906     }
1907
1908   /* Extract the decrypted data from the S-expression.  Note that the
1909      output of gcry_pk_decrypt depends on whether a flags lists occurs
1910      in its input data.  Because we passed the output of
1911      gcry_pk_encrypt directly to gcry_pk_decrypt, such a flag value
1912      won't be there as of today.  To be prepared for future changes we
1913      take care of it anyway.  */
1914   tmplist = sexp_find_token (decr, "value", 0);
1915   if (tmplist)
1916     decr_plaintext = sexp_nth_string (tmplist, 1);
1917   else
1918     decr_plaintext = sexp_nth_string (decr, 0);
1919   if (!decr_plaintext)
1920     {
1921       errtxt = "decrypt returned no plaintext";
1922       goto leave;
1923     }
1924
1925   /* Check that the decrypted plaintext matches the original  plaintext.  */
1926   if (strcmp (plaintext, decr_plaintext))
1927     {
1928       errtxt = "mismatch";
1929       goto leave;
1930     }
1931
1932  leave:
1933   sexp_release (tmplist);
1934   xfree (decr_plaintext);
1935   sexp_release (decr);
1936   _gcry_mpi_release (ciphertext);
1937   _gcry_mpi_release (ref_mpi);
1938   sexp_release (encr);
1939   sexp_release (plain);
1940   return errtxt;
1941 }
1942
1943
1944 static gpg_err_code_t
1945 selftests_rsa (selftest_report_func_t report)
1946 {
1947   const char *what;
1948   const char *errtxt;
1949   gcry_error_t err;
1950   gcry_sexp_t skey = NULL;
1951   gcry_sexp_t pkey = NULL;
1952
1953   /* Convert the S-expressions into the internal representation.  */
1954   what = "convert";
1955   err = sexp_sscan (&skey, NULL, sample_secret_key, strlen (sample_secret_key));
1956   if (!err)
1957     err = sexp_sscan (&pkey, NULL,
1958                       sample_public_key, strlen (sample_public_key));
1959   if (err)
1960     {
1961       errtxt = _gcry_strerror (err);
1962       goto failed;
1963     }
1964
1965   what = "key consistency";
1966   err = _gcry_pk_testkey (skey);
1967   if (err)
1968     {
1969       errtxt = _gcry_strerror (err);
1970       goto failed;
1971     }
1972
1973   what = "sign";
1974   errtxt = selftest_sign_2048 (pkey, skey);
1975   if (errtxt)
1976     goto failed;
1977
1978   what = "encrypt";
1979   errtxt = selftest_encr_2048 (pkey, skey);
1980   if (errtxt)
1981     goto failed;
1982
1983   sexp_release (pkey);
1984   sexp_release (skey);
1985   return 0; /* Succeeded. */
1986
1987  failed:
1988   sexp_release (pkey);
1989   sexp_release (skey);
1990   if (report)
1991     report ("pubkey", GCRY_PK_RSA, what, errtxt);
1992   return GPG_ERR_SELFTEST_FAILED;
1993 }
1994
1995
1996 /* Run a full self-test for ALGO and return 0 on success.  */
1997 static gpg_err_code_t
1998 run_selftests (int algo, int extended, selftest_report_func_t report)
1999 {
2000   gpg_err_code_t ec;
2001
2002   (void)extended;
2003
2004   switch (algo)
2005     {
2006     case GCRY_PK_RSA:
2007       ec = selftests_rsa (report);
2008       break;
2009     default:
2010       ec = GPG_ERR_PUBKEY_ALGO;
2011       break;
2012
2013     }
2014   return ec;
2015 }
2016
2017
2018
2019 \f
2020 gcry_pk_spec_t _gcry_pubkey_spec_rsa =
2021   {
2022     GCRY_PK_RSA, { 0, 1 },
2023     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
2024     "RSA", rsa_names,
2025     "ne", "nedpqu", "a", "s", "n",
2026     rsa_generate,
2027     rsa_check_secret_key,
2028     rsa_encrypt,
2029     rsa_decrypt,
2030     rsa_sign,
2031     rsa_verify,
2032     rsa_get_nbits,
2033     run_selftests,
2034     compute_keygrip
2035   };