cb3c464a35a77ea59e8e48b1487f9eddc99e7449
[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 implementaion 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
995 /****************
996  * Secret key operation. Encrypt INPUT with SKEY and put result into OUTPUT.
997  *
998  *      m = c^d mod n
999  *
1000  * Or faster:
1001  *
1002  *      m1 = c ^ (d mod (p-1)) mod p
1003  *      m2 = c ^ (d mod (q-1)) mod q
1004  *      h = u * (m2 - m1) mod q
1005  *      m = m1 + h * p
1006  *
1007  * Where m is OUTPUT, c is INPUT and d,n,p,q,u are elements of SKEY.
1008  */
1009 static void
1010 secret (gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey )
1011 {
1012   /* Remove superfluous leading zeroes from INPUT.  */
1013   mpi_normalize (input);
1014
1015   if (!skey->p || !skey->q || !skey->u)
1016     {
1017       mpi_powm (output, input, skey->d, skey->n);
1018     }
1019   else
1020     {
1021       gcry_mpi_t m1 = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
1022       gcry_mpi_t m2 = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
1023       gcry_mpi_t h  = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
1024
1025       /* m1 = c ^ (d mod (p-1)) mod p */
1026       mpi_sub_ui( h, skey->p, 1  );
1027       mpi_fdiv_r( h, skey->d, h );
1028       mpi_powm( m1, input, h, skey->p );
1029       /* m2 = c ^ (d mod (q-1)) mod q */
1030       mpi_sub_ui( h, skey->q, 1  );
1031       mpi_fdiv_r( h, skey->d, h );
1032       mpi_powm( m2, input, h, skey->q );
1033       /* h = u * ( m2 - m1 ) mod q */
1034       mpi_sub( h, m2, m1 );
1035       if ( mpi_has_sign ( h ) )
1036         mpi_add ( h, h, skey->q );
1037       mpi_mulm( h, skey->u, h, skey->q );
1038       /* m = m1 + h * p */
1039       mpi_mul ( h, h, skey->p );
1040       mpi_add ( output, m1, h );
1041
1042       mpi_free ( h );
1043       mpi_free ( m1 );
1044       mpi_free ( m2 );
1045     }
1046 }
1047
1048
1049
1050 /*********************************************
1051  **************  interface  ******************
1052  *********************************************/
1053
1054 static gcry_err_code_t
1055 rsa_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
1056 {
1057   gpg_err_code_t ec;
1058   unsigned int nbits;
1059   unsigned long evalue;
1060   RSA_secret_key sk;
1061   gcry_sexp_t deriveparms;
1062   int flags = 0;
1063   gcry_sexp_t l1;
1064   gcry_sexp_t swap_info = NULL;
1065
1066   memset (&sk, 0, sizeof sk);
1067
1068   ec = _gcry_pk_util_get_nbits (genparms, &nbits);
1069   if (ec)
1070     return ec;
1071
1072   ec = _gcry_pk_util_get_rsa_use_e (genparms, &evalue);
1073   if (ec)
1074     return ec;
1075
1076   /* Parse the optional flags list.  */
1077   l1 = sexp_find_token (genparms, "flags", 0);
1078   if (l1)
1079     {
1080       ec = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
1081       sexp_release (l1);
1082       if (ec)
1083         return ec;
1084     }
1085
1086   deriveparms = (genparms?
1087                  sexp_find_token (genparms, "derive-parms", 0) : NULL);
1088   if (!deriveparms)
1089     {
1090       /* Parse the optional "use-x931" flag. */
1091       l1 = sexp_find_token (genparms, "use-x931", 0);
1092       if (l1)
1093         {
1094           flags |= PUBKEY_FLAG_USE_X931;
1095           sexp_release (l1);
1096         }
1097     }
1098
1099   if (deriveparms || (flags & PUBKEY_FLAG_USE_X931))
1100     {
1101       int swapped;
1102       ec = generate_x931 (&sk, nbits, evalue, deriveparms, &swapped);
1103       sexp_release (deriveparms);
1104       if (!ec && swapped)
1105         ec = sexp_new (&swap_info, "(misc-key-info(p-q-swapped))", 0, 1);
1106     }
1107   else
1108     {
1109       /* Parse the optional "transient-key" flag. */
1110       if (!(flags & PUBKEY_FLAG_TRANSIENT_KEY))
1111         {
1112           l1 = sexp_find_token (genparms, "transient-key", 0);
1113           if (l1)
1114             {
1115               flags |= PUBKEY_FLAG_TRANSIENT_KEY;
1116               sexp_release (l1);
1117             }
1118         }
1119       deriveparms = (genparms? sexp_find_token (genparms, "test-parms", 0)
1120                      /**/    : NULL);
1121
1122       /* Generate.  */
1123       if (deriveparms || fips_mode())
1124         {
1125           ec = generate_fips (&sk, nbits, evalue, deriveparms,
1126                               !!(flags & PUBKEY_FLAG_TRANSIENT_KEY));
1127         }
1128       else
1129         {
1130           ec = generate_std (&sk, nbits, evalue,
1131                              !!(flags & PUBKEY_FLAG_TRANSIENT_KEY));
1132         }
1133       sexp_release (deriveparms);
1134     }
1135
1136   if (!ec)
1137     {
1138       ec = sexp_build (r_skey, NULL,
1139                        "(key-data"
1140                        " (public-key"
1141                        "  (rsa(n%m)(e%m)))"
1142                        " (private-key"
1143                        "  (rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))"
1144                        " %S)",
1145                        sk.n, sk.e,
1146                        sk.n, sk.e, sk.d, sk.p, sk.q, sk.u,
1147                        swap_info);
1148     }
1149
1150   mpi_free (sk.n);
1151   mpi_free (sk.e);
1152   mpi_free (sk.p);
1153   mpi_free (sk.q);
1154   mpi_free (sk.d);
1155   mpi_free (sk.u);
1156   sexp_release (swap_info);
1157
1158   return ec;
1159 }
1160
1161
1162 static gcry_err_code_t
1163 rsa_check_secret_key (gcry_sexp_t keyparms)
1164 {
1165   gcry_err_code_t rc;
1166   RSA_secret_key sk = {NULL, NULL, NULL, NULL, NULL, NULL};
1167
1168   /* To check the key we need the optional parameters. */
1169   rc = sexp_extract_param (keyparms, NULL, "nedpqu",
1170                            &sk.n, &sk.e, &sk.d, &sk.p, &sk.q, &sk.u,
1171                            NULL);
1172   if (rc)
1173     goto leave;
1174
1175   if (!check_secret_key (&sk))
1176     rc = GPG_ERR_BAD_SECKEY;
1177
1178  leave:
1179   _gcry_mpi_release (sk.n);
1180   _gcry_mpi_release (sk.e);
1181   _gcry_mpi_release (sk.d);
1182   _gcry_mpi_release (sk.p);
1183   _gcry_mpi_release (sk.q);
1184   _gcry_mpi_release (sk.u);
1185   if (DBG_CIPHER)
1186     log_debug ("rsa_testkey    => %s\n", gpg_strerror (rc));
1187   return rc;
1188 }
1189
1190
1191 static gcry_err_code_t
1192 rsa_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1193 {
1194   gcry_err_code_t rc;
1195   struct pk_encoding_ctx ctx;
1196   gcry_mpi_t data = NULL;
1197   RSA_public_key pk = {NULL, NULL};
1198   gcry_mpi_t ciph = NULL;
1199
1200   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_ENCRYPT,
1201                                    rsa_get_nbits (keyparms));
1202
1203   /* Extract the data.  */
1204   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1205   if (rc)
1206     goto leave;
1207   if (DBG_CIPHER)
1208     log_mpidump ("rsa_encrypt data", data);
1209   if (mpi_is_opaque (data))
1210     {
1211       rc = GPG_ERR_INV_DATA;
1212       goto leave;
1213     }
1214
1215   /* Extract the key.  */
1216   rc = sexp_extract_param (keyparms, NULL, "ne", &pk.n, &pk.e, NULL);
1217   if (rc)
1218     goto leave;
1219   if (DBG_CIPHER)
1220     {
1221       log_mpidump ("rsa_encrypt    n", pk.n);
1222       log_mpidump ("rsa_encrypt    e", pk.e);
1223     }
1224
1225   /* Do RSA computation and build result.  */
1226   ciph = mpi_new (0);
1227   public (ciph, data, &pk);
1228   if (DBG_CIPHER)
1229     log_mpidump ("rsa_encrypt  res", ciph);
1230   if ((ctx.flags & PUBKEY_FLAG_FIXEDLEN))
1231     {
1232       /* We need to make sure to return the correct length to avoid
1233          problems with missing leading zeroes.  */
1234       unsigned char *em;
1235       size_t emlen = (mpi_get_nbits (pk.n)+7)/8;
1236
1237       rc = _gcry_mpi_to_octet_string (&em, NULL, ciph, emlen);
1238       if (!rc)
1239         {
1240           rc = sexp_build (r_ciph, NULL, "(enc-val(rsa(a%b)))", (int)emlen, em);
1241           xfree (em);
1242         }
1243     }
1244   else
1245     rc = sexp_build (r_ciph, NULL, "(enc-val(rsa(a%m)))", ciph);
1246
1247  leave:
1248   _gcry_mpi_release (ciph);
1249   _gcry_mpi_release (pk.n);
1250   _gcry_mpi_release (pk.e);
1251   _gcry_mpi_release (data);
1252   _gcry_pk_util_free_encoding_ctx (&ctx);
1253   if (DBG_CIPHER)
1254     log_debug ("rsa_encrypt    => %s\n", gpg_strerror (rc));
1255   return rc;
1256 }
1257
1258
1259 static gcry_err_code_t
1260 rsa_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1261
1262 {
1263   gpg_err_code_t rc;
1264   struct pk_encoding_ctx ctx;
1265   gcry_sexp_t l1 = NULL;
1266   gcry_mpi_t data = NULL;
1267   RSA_secret_key sk = {NULL, NULL, NULL, NULL, NULL, NULL};
1268   gcry_mpi_t plain = NULL;
1269   gcry_mpi_t r = NULL;     /* Random number needed for blinding.  */
1270   gcry_mpi_t ri = NULL;    /* Modular multiplicative inverse of r.  */
1271   gcry_mpi_t bldata = NULL;/* Blinded data to decrypt.  */
1272   unsigned char *unpad = NULL;
1273   size_t unpadlen = 0;
1274
1275   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_DECRYPT,
1276                                    rsa_get_nbits (keyparms));
1277
1278   /* Extract the data.  */
1279   rc = _gcry_pk_util_preparse_encval (s_data, rsa_names, &l1, &ctx);
1280   if (rc)
1281     goto leave;
1282   rc = sexp_extract_param (l1, NULL, "a", &data, NULL);
1283   if (rc)
1284     goto leave;
1285   if (DBG_CIPHER)
1286     log_printmpi ("rsa_decrypt data", data);
1287   if (mpi_is_opaque (data))
1288     {
1289       rc = GPG_ERR_INV_DATA;
1290       goto leave;
1291     }
1292
1293   /* Extract the key.  */
1294   rc = sexp_extract_param (keyparms, NULL, "nedp?q?u?",
1295                            &sk.n, &sk.e, &sk.d, &sk.p, &sk.q, &sk.u,
1296                            NULL);
1297   if (rc)
1298     goto leave;
1299   if (DBG_CIPHER)
1300     {
1301       log_printmpi ("rsa_decrypt    n", sk.n);
1302       log_printmpi ("rsa_decrypt    e", sk.e);
1303       if (!fips_mode ())
1304         {
1305           log_printmpi ("rsa_decrypt    d", sk.d);
1306           log_printmpi ("rsa_decrypt    p", sk.p);
1307           log_printmpi ("rsa_decrypt    q", sk.q);
1308           log_printmpi ("rsa_decrypt    u", sk.u);
1309         }
1310     }
1311
1312   /* Better make sure that there are no superfluous leading zeroes in
1313      the input and it has not been "padded" using multiples of N.
1314      This mitigates side-channel attacks (CVE-2013-4576).  */
1315   mpi_normalize (data);
1316   mpi_fdiv_r (data, data, sk.n);
1317
1318   /* Allocate MPI for the plaintext.  */
1319   plain = mpi_snew (ctx.nbits);
1320
1321   /* We use blinding by default to mitigate timing attacks which can
1322      be practically mounted over the network as shown by Brumley and
1323      Boney in 2003.  */
1324   if (!(ctx.flags & PUBKEY_FLAG_NO_BLINDING))
1325     {
1326       /* First, we need a random number r between 0 and n - 1, which
1327          is relatively prime to n (i.e. it is neither p nor q).  The
1328          random number needs to be only unpredictable, thus we employ
1329          the gcry_create_nonce function by using GCRY_WEAK_RANDOM with
1330          gcry_mpi_randomize.  */
1331       r  = mpi_snew (ctx.nbits);
1332       ri = mpi_snew (ctx.nbits);
1333       bldata = mpi_snew (ctx.nbits);
1334
1335       do
1336         {
1337           _gcry_mpi_randomize (r, ctx.nbits, GCRY_WEAK_RANDOM);
1338           mpi_mod (r, r, sk.n);
1339         }
1340       while (!mpi_invm (ri, r, sk.n));
1341
1342       /* Do blinding.  We calculate: y = (x * r^e) mod n, where r is
1343          the random number, e is the public exponent, x is the
1344          non-blinded data and n is the RSA modulus.  */
1345       mpi_powm (bldata, r, sk.e, sk.n);
1346       mpi_mulm (bldata, bldata, data, sk.n);
1347
1348       /* Perform decryption.  */
1349       secret (plain, bldata, &sk);
1350       _gcry_mpi_release (bldata); bldata = NULL;
1351
1352       /* Undo blinding.  Here we calculate: y = (x * r^-1) mod n,
1353          where x is the blinded decrypted data, ri is the modular
1354          multiplicative inverse of r and n is the RSA modulus.  */
1355       mpi_mulm (plain, plain, ri, sk.n);
1356
1357       _gcry_mpi_release (r); r = NULL;
1358       _gcry_mpi_release (ri); ri = NULL;
1359     }
1360   else
1361     secret (plain, data, &sk);
1362
1363   if (DBG_CIPHER)
1364     log_printmpi ("rsa_decrypt  res", plain);
1365
1366   /* Reverse the encoding and build the s-expression.  */
1367   switch (ctx.encoding)
1368     {
1369     case PUBKEY_ENC_PKCS1:
1370       rc = _gcry_rsa_pkcs1_decode_for_enc (&unpad, &unpadlen, ctx.nbits, plain);
1371       mpi_free (plain);
1372       plain = NULL;
1373       if (!rc)
1374         rc = sexp_build (r_plain, NULL, "(value %b)", (int)unpadlen, unpad);
1375       break;
1376
1377     case PUBKEY_ENC_OAEP:
1378       rc = _gcry_rsa_oaep_decode (&unpad, &unpadlen,
1379                                   ctx.nbits, ctx.hash_algo,
1380                                   plain, ctx.label, ctx.labellen);
1381       mpi_free (plain);
1382       plain = NULL;
1383       if (!rc)
1384         rc = sexp_build (r_plain, NULL, "(value %b)", (int)unpadlen, unpad);
1385       break;
1386
1387     default:
1388       /* Raw format.  For backward compatibility we need to assume a
1389          signed mpi by using the sexp format string "%m".  */
1390       rc = sexp_build (r_plain, NULL,
1391                        (ctx.flags & PUBKEY_FLAG_LEGACYRESULT)
1392                        ? "%m":"(value %m)", plain);
1393       break;
1394     }
1395
1396  leave:
1397   xfree (unpad);
1398   _gcry_mpi_release (plain);
1399   _gcry_mpi_release (sk.n);
1400   _gcry_mpi_release (sk.e);
1401   _gcry_mpi_release (sk.d);
1402   _gcry_mpi_release (sk.p);
1403   _gcry_mpi_release (sk.q);
1404   _gcry_mpi_release (sk.u);
1405   _gcry_mpi_release (data);
1406   _gcry_mpi_release (r);
1407   _gcry_mpi_release (ri);
1408   _gcry_mpi_release (bldata);
1409   sexp_release (l1);
1410   _gcry_pk_util_free_encoding_ctx (&ctx);
1411   if (DBG_CIPHER)
1412     log_debug ("rsa_decrypt    => %s\n", gpg_strerror (rc));
1413   return rc;
1414 }
1415
1416
1417 static gcry_err_code_t
1418 rsa_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1419 {
1420   gpg_err_code_t rc;
1421   struct pk_encoding_ctx ctx;
1422   gcry_mpi_t data = NULL;
1423   RSA_secret_key sk = {NULL, NULL, NULL, NULL, NULL, NULL};
1424   RSA_public_key pk;
1425   gcry_mpi_t sig = NULL;
1426   gcry_mpi_t result = NULL;
1427
1428   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_SIGN,
1429                                    rsa_get_nbits (keyparms));
1430
1431   /* Extract the data.  */
1432   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1433   if (rc)
1434     goto leave;
1435   if (DBG_CIPHER)
1436     log_printmpi ("rsa_sign   data", data);
1437   if (mpi_is_opaque (data))
1438     {
1439       rc = GPG_ERR_INV_DATA;
1440       goto leave;
1441     }
1442
1443   /* Extract the key.  */
1444   rc = sexp_extract_param (keyparms, NULL, "nedp?q?u?",
1445                            &sk.n, &sk.e, &sk.d, &sk.p, &sk.q, &sk.u,
1446                            NULL);
1447   if (rc)
1448     goto leave;
1449   if (DBG_CIPHER)
1450     {
1451       log_printmpi ("rsa_sign      n", sk.n);
1452       log_printmpi ("rsa_sign      e", sk.e);
1453       if (!fips_mode ())
1454         {
1455           log_printmpi ("rsa_sign      d", sk.d);
1456           log_printmpi ("rsa_sign      p", sk.p);
1457           log_printmpi ("rsa_sign      q", sk.q);
1458           log_printmpi ("rsa_sign      u", sk.u);
1459         }
1460     }
1461
1462   /* Do RSA computation.  */
1463   sig = mpi_new (0);
1464   secret (sig, data, &sk);
1465   if (DBG_CIPHER)
1466     log_printmpi ("rsa_sign    res", sig);
1467
1468   /* Check that the created signature is good.  This detects a failure
1469      of the CRT algorithm  (Lenstra's attack on RSA's use of the CRT).  */
1470   result = mpi_new (0);
1471   pk.n = sk.n;
1472   pk.e = sk.e;
1473   public (result, sig, &pk);
1474   if (mpi_cmp (result, data))
1475     {
1476       rc = GPG_ERR_BAD_SIGNATURE;
1477       goto leave;
1478     }
1479
1480   /* Convert the result.  */
1481   if ((ctx.flags & PUBKEY_FLAG_FIXEDLEN))
1482     {
1483       /* We need to make sure to return the correct length to avoid
1484          problems with missing leading zeroes.  */
1485       unsigned char *em;
1486       size_t emlen = (mpi_get_nbits (sk.n)+7)/8;
1487
1488       rc = _gcry_mpi_to_octet_string (&em, NULL, sig, emlen);
1489       if (!rc)
1490         {
1491           rc = sexp_build (r_sig, NULL, "(sig-val(rsa(s%b)))", (int)emlen, em);
1492           xfree (em);
1493         }
1494     }
1495   else
1496     rc = sexp_build (r_sig, NULL, "(sig-val(rsa(s%M)))", sig);
1497
1498
1499  leave:
1500   _gcry_mpi_release (result);
1501   _gcry_mpi_release (sig);
1502   _gcry_mpi_release (sk.n);
1503   _gcry_mpi_release (sk.e);
1504   _gcry_mpi_release (sk.d);
1505   _gcry_mpi_release (sk.p);
1506   _gcry_mpi_release (sk.q);
1507   _gcry_mpi_release (sk.u);
1508   _gcry_mpi_release (data);
1509   _gcry_pk_util_free_encoding_ctx (&ctx);
1510   if (DBG_CIPHER)
1511     log_debug ("rsa_sign      => %s\n", gpg_strerror (rc));
1512   return rc;
1513 }
1514
1515
1516 static gcry_err_code_t
1517 rsa_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
1518 {
1519   gcry_err_code_t rc;
1520   struct pk_encoding_ctx ctx;
1521   gcry_sexp_t l1 = NULL;
1522   gcry_mpi_t sig = NULL;
1523   gcry_mpi_t data = NULL;
1524   RSA_public_key pk = { NULL, NULL };
1525   gcry_mpi_t result = NULL;
1526
1527   _gcry_pk_util_init_encoding_ctx (&ctx, PUBKEY_OP_VERIFY,
1528                                    rsa_get_nbits (keyparms));
1529
1530   /* Extract the data.  */
1531   rc = _gcry_pk_util_data_to_mpi (s_data, &data, &ctx);
1532   if (rc)
1533     goto leave;
1534   if (DBG_CIPHER)
1535     log_printmpi ("rsa_verify data", data);
1536   if (mpi_is_opaque (data))
1537     {
1538       rc = GPG_ERR_INV_DATA;
1539       goto leave;
1540     }
1541
1542   /* Extract the signature value.  */
1543   rc = _gcry_pk_util_preparse_sigval (s_sig, rsa_names, &l1, NULL);
1544   if (rc)
1545     goto leave;
1546   rc = sexp_extract_param (l1, NULL, "s", &sig, NULL);
1547   if (rc)
1548     goto leave;
1549   if (DBG_CIPHER)
1550     log_printmpi ("rsa_verify  sig", sig);
1551
1552   /* Extract the key.  */
1553   rc = sexp_extract_param (keyparms, NULL, "ne", &pk.n, &pk.e, NULL);
1554   if (rc)
1555     goto leave;
1556   if (DBG_CIPHER)
1557     {
1558       log_printmpi ("rsa_verify    n", pk.n);
1559       log_printmpi ("rsa_verify    e", pk.e);
1560     }
1561
1562   /* Do RSA computation and compare.  */
1563   result = mpi_new (0);
1564   public (result, sig, &pk);
1565   if (DBG_CIPHER)
1566     log_printmpi ("rsa_verify  cmp", result);
1567   if (ctx.verify_cmp)
1568     rc = ctx.verify_cmp (&ctx, result);
1569   else
1570     rc = mpi_cmp (result, data) ? GPG_ERR_BAD_SIGNATURE : 0;
1571
1572  leave:
1573   _gcry_mpi_release (result);
1574   _gcry_mpi_release (pk.n);
1575   _gcry_mpi_release (pk.e);
1576   _gcry_mpi_release (data);
1577   _gcry_mpi_release (sig);
1578   sexp_release (l1);
1579   _gcry_pk_util_free_encoding_ctx (&ctx);
1580   if (DBG_CIPHER)
1581     log_debug ("rsa_verify    => %s\n", rc?gpg_strerror (rc):"Good");
1582   return rc;
1583 }
1584
1585
1586
1587 /* Return the number of bits for the key described by PARMS.  On error
1588  * 0 is returned.  The format of PARMS starts with the algorithm name;
1589  * for example:
1590  *
1591  *   (rsa
1592  *     (n <mpi>)
1593  *     (e <mpi>))
1594  *
1595  * More parameters may be given but we only need N here.
1596  */
1597 static unsigned int
1598 rsa_get_nbits (gcry_sexp_t parms)
1599 {
1600   gcry_sexp_t l1;
1601   gcry_mpi_t n;
1602   unsigned int nbits;
1603
1604   l1 = sexp_find_token (parms, "n", 1);
1605   if (!l1)
1606     return 0; /* Parameter N not found.  */
1607
1608   n = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1609   sexp_release (l1);
1610   nbits = n? mpi_get_nbits (n) : 0;
1611   _gcry_mpi_release (n);
1612   return nbits;
1613 }
1614
1615
1616 /* Compute a keygrip.  MD is the hash context which we are going to
1617    update.  KEYPARAM is an S-expression with the key parameters, this
1618    is usually a public key but may also be a secret key.  An example
1619    of such an S-expression is:
1620
1621       (rsa
1622         (n #00B...#)
1623         (e #010001#))
1624
1625    PKCS-15 says that for RSA only the modulus should be hashed -
1626    however, it is not clear whether this is meant to use the raw bytes
1627    (assuming this is an unsigned integer) or whether the DER required
1628    0 should be prefixed.  We hash the raw bytes.  */
1629 static gpg_err_code_t
1630 compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparam)
1631 {
1632   gcry_sexp_t l1;
1633   const char *data;
1634   size_t datalen;
1635
1636   l1 = sexp_find_token (keyparam, "n", 1);
1637   if (!l1)
1638     return GPG_ERR_NO_OBJ;
1639
1640   data = sexp_nth_data (l1, 1, &datalen);
1641   if (!data)
1642     {
1643       sexp_release (l1);
1644       return GPG_ERR_NO_OBJ;
1645     }
1646
1647   _gcry_md_write (md, data, datalen);
1648   sexp_release (l1);
1649
1650   return 0;
1651 }
1652
1653
1654
1655 \f
1656 /*
1657      Self-test section.
1658  */
1659
1660 static const char *
1661 selftest_sign_2048 (gcry_sexp_t pkey, gcry_sexp_t skey)
1662 {
1663   static const char sample_data[] =
1664     "(data (flags pkcs1)"
1665     " (hash sha256 #11223344556677889900aabbccddeeff"
1666     /**/           "102030405060708090a0b0c0d0f01121#))";
1667   static const char sample_data_bad[] =
1668     "(data (flags pkcs1)"
1669     " (hash sha256 #11223344556677889900aabbccddeeff"
1670     /**/           "802030405060708090a0b0c0d0f01121#))";
1671
1672   const char *errtxt = NULL;
1673   gcry_error_t err;
1674   gcry_sexp_t data = NULL;
1675   gcry_sexp_t data_bad = NULL;
1676   gcry_sexp_t sig = NULL;
1677   /* raw signature data reference */
1678   const char ref_data[] =
1679     "6252a19a11e1d5155ed9376036277193d644fa239397fff03e9b92d6f86415d6"
1680     "d30da9273775f290e580d038295ff8ff89522becccfa6ae870bf76b76df402a8"
1681     "54f69347e3db3de8e1e7d4dada281ec556810c7a8ecd0b5f51f9b1c0e7aa7557"
1682     "61aa2b8ba5f811304acc6af0eca41fe49baf33bf34eddaf44e21e036ac7f0b68"
1683     "03cdef1c60021fb7b5b97ebacdd88ab755ce29af568dbc5728cc6e6eff42618d"
1684     "62a0386ca8beed46402bdeeef29b6a3feded906bace411a06a39192bf516ae10"
1685     "67e4320fa8ea113968525f4574d022a3ceeaafdc41079efe1f22cc94bf59d8d3"
1686     "328085da9674857db56de5978a62394aab48aa3b72e23a1b16260cfd9daafe65";
1687   gcry_mpi_t ref_mpi = NULL;
1688   gcry_mpi_t sig_mpi = NULL;
1689
1690   err = sexp_sscan (&data, NULL, sample_data, strlen (sample_data));
1691   if (!err)
1692     err = sexp_sscan (&data_bad, NULL,
1693                       sample_data_bad, strlen (sample_data_bad));
1694   if (err)
1695     {
1696       errtxt = "converting data failed";
1697       goto leave;
1698     }
1699
1700   err = _gcry_pk_sign (&sig, data, skey);
1701   if (err)
1702     {
1703       errtxt = "signing failed";
1704       goto leave;
1705     }
1706
1707   err = _gcry_mpi_scan(&ref_mpi, GCRYMPI_FMT_HEX, ref_data, 0, NULL);
1708   if (err)
1709     {
1710       errtxt = "converting ref_data to mpi failed";
1711       goto leave;
1712     }
1713
1714   err = _gcry_sexp_extract_param(sig, "sig-val!rsa", "s", &sig_mpi, NULL);
1715   if (err)
1716     {
1717       errtxt = "extracting signature data failed";
1718       goto leave;
1719     }
1720
1721   if (mpi_cmp (sig_mpi, ref_mpi))
1722     {
1723       errtxt = "signature does not match reference data";
1724       goto leave;
1725     }
1726
1727   err = _gcry_pk_verify (sig, data, pkey);
1728   if (err)
1729     {
1730       errtxt = "verify failed";
1731       goto leave;
1732     }
1733   err = _gcry_pk_verify (sig, data_bad, pkey);
1734   if (gcry_err_code (err) != GPG_ERR_BAD_SIGNATURE)
1735     {
1736       errtxt = "bad signature not detected";
1737       goto leave;
1738     }
1739
1740
1741  leave:
1742   sexp_release (sig);
1743   sexp_release (data_bad);
1744   sexp_release (data);
1745   _gcry_mpi_release (ref_mpi);
1746   _gcry_mpi_release (sig_mpi);
1747   return errtxt;
1748 }
1749
1750
1751
1752 /* Given an S-expression ENCR_DATA of the form:
1753
1754    (enc-val
1755     (rsa
1756      (a a-value)))
1757
1758    as returned by gcry_pk_decrypt, return the the A-VALUE.  On error,
1759    return NULL.  */
1760 static gcry_mpi_t
1761 extract_a_from_sexp (gcry_sexp_t encr_data)
1762 {
1763   gcry_sexp_t l1, l2, l3;
1764   gcry_mpi_t a_value;
1765
1766   l1 = sexp_find_token (encr_data, "enc-val", 0);
1767   if (!l1)
1768     return NULL;
1769   l2 = sexp_find_token (l1, "rsa", 0);
1770   sexp_release (l1);
1771   if (!l2)
1772     return NULL;
1773   l3 = sexp_find_token (l2, "a", 0);
1774   sexp_release (l2);
1775   if (!l3)
1776     return NULL;
1777   a_value = sexp_nth_mpi (l3, 1, 0);
1778   sexp_release (l3);
1779
1780   return a_value;
1781 }
1782
1783
1784 static const char *
1785 selftest_encr_2048 (gcry_sexp_t pkey, gcry_sexp_t skey)
1786 {
1787   const char *errtxt = NULL;
1788   gcry_error_t err;
1789   static const char plaintext[] =
1790     "Jim quickly realized that the beautiful gowns are expensive.";
1791   gcry_sexp_t plain = NULL;
1792   gcry_sexp_t encr  = NULL;
1793   gcry_mpi_t  ciphertext = NULL;
1794   gcry_sexp_t decr  = NULL;
1795   char *decr_plaintext = NULL;
1796   gcry_sexp_t tmplist = NULL;
1797   /* expected result of encrypting the plaintext with sample_secret_key */
1798   static const char ref_data[] =
1799     "18022e2593a402a737caaa93b4c7e750e20ca265452980e1d6b7710fbd3e"
1800     "7dce72be5c2110fb47691cb38f42170ee3b4a37f2498d4a51567d762585e"
1801     "4cb81d04fbc7df4144f8e5eac2d4b8688521b64011f11d7ad53f4c874004"
1802     "819856f2e2a6f83d1c9c4e73ac26089789c14482b0b8d44139133c88c4a5"
1803     "2dba9dd6d6ffc622666b7d129168333d999706af30a2d7d272db7734e5ed"
1804     "fb8c64ea3018af3ad20f4a013a5060cb0f5e72753967bebe294280a6ed0d"
1805     "dbd3c4f11d0a8696e9d32a0dc03deb0b5e49b2cbd1503392642d4e1211f3"
1806     "e8e2ee38abaa3671ccd57fcde8ca76e85fd2cb77c35706a970a213a27352"
1807     "cec92a9604d543ddb5fc478ff50e0622";
1808   gcry_mpi_t ref_mpi = NULL;
1809
1810   /* Put the plaintext into an S-expression.  */
1811   err = sexp_build (&plain, NULL, "(data (flags raw) (value %s))", plaintext);
1812   if (err)
1813     {
1814       errtxt = "converting data failed";
1815       goto leave;
1816     }
1817
1818   /* Encrypt.  */
1819   err = _gcry_pk_encrypt (&encr, plain, pkey);
1820   if (err)
1821     {
1822       errtxt = "encrypt failed";
1823       goto leave;
1824     }
1825
1826   err = _gcry_mpi_scan(&ref_mpi, GCRYMPI_FMT_HEX, ref_data, 0, NULL);
1827   if (err)
1828     {
1829       errtxt = "converting encrydata to mpi failed";
1830       goto leave;
1831     }
1832
1833   /* Extraxt the ciphertext from the returned S-expression.  */
1834   /*sexp_dump (encr);*/
1835   ciphertext = extract_a_from_sexp (encr);
1836   if (!ciphertext)
1837     {
1838       errtxt = "gcry_pk_decrypt returned garbage";
1839       goto leave;
1840     }
1841
1842   /* Check that the ciphertext does no match the plaintext.  */
1843   /* _gcry_log_printmpi ("plaintext", plaintext); */
1844   /* _gcry_log_printmpi ("ciphertxt", ciphertext); */
1845   if (mpi_cmp (ref_mpi, ciphertext))
1846     {
1847       errtxt = "ciphertext doesn't match reference data";
1848       goto leave;
1849     }
1850
1851   /* Decrypt.  */
1852   err = _gcry_pk_decrypt (&decr, encr, skey);
1853   if (err)
1854     {
1855       errtxt = "decrypt failed";
1856       goto leave;
1857     }
1858
1859   /* Extract the decrypted data from the S-expression.  Note that the
1860      output of gcry_pk_decrypt depends on whether a flags lists occurs
1861      in its input data.  Because we passed the output of
1862      gcry_pk_encrypt directly to gcry_pk_decrypt, such a flag value
1863      won't be there as of today.  To be prepared for future changes we
1864      take care of it anyway.  */
1865   tmplist = sexp_find_token (decr, "value", 0);
1866   if (tmplist)
1867     decr_plaintext = sexp_nth_string (tmplist, 1);
1868   else
1869     decr_plaintext = sexp_nth_string (decr, 0);
1870   if (!decr_plaintext)
1871     {
1872       errtxt = "decrypt returned no plaintext";
1873       goto leave;
1874     }
1875
1876   /* Check that the decrypted plaintext matches the original  plaintext.  */
1877   if (strcmp (plaintext, decr_plaintext))
1878     {
1879       errtxt = "mismatch";
1880       goto leave;
1881     }
1882
1883  leave:
1884   sexp_release (tmplist);
1885   xfree (decr_plaintext);
1886   sexp_release (decr);
1887   _gcry_mpi_release (ciphertext);
1888   _gcry_mpi_release (ref_mpi);
1889   sexp_release (encr);
1890   sexp_release (plain);
1891   return errtxt;
1892 }
1893
1894
1895 static gpg_err_code_t
1896 selftests_rsa (selftest_report_func_t report)
1897 {
1898   const char *what;
1899   const char *errtxt;
1900   gcry_error_t err;
1901   gcry_sexp_t skey = NULL;
1902   gcry_sexp_t pkey = NULL;
1903
1904   /* Convert the S-expressions into the internal representation.  */
1905   what = "convert";
1906   err = sexp_sscan (&skey, NULL, sample_secret_key, strlen (sample_secret_key));
1907   if (!err)
1908     err = sexp_sscan (&pkey, NULL,
1909                       sample_public_key, strlen (sample_public_key));
1910   if (err)
1911     {
1912       errtxt = _gcry_strerror (err);
1913       goto failed;
1914     }
1915
1916   what = "key consistency";
1917   err = _gcry_pk_testkey (skey);
1918   if (err)
1919     {
1920       errtxt = _gcry_strerror (err);
1921       goto failed;
1922     }
1923
1924   what = "sign";
1925   errtxt = selftest_sign_2048 (pkey, skey);
1926   if (errtxt)
1927     goto failed;
1928
1929   what = "encrypt";
1930   errtxt = selftest_encr_2048 (pkey, skey);
1931   if (errtxt)
1932     goto failed;
1933
1934   sexp_release (pkey);
1935   sexp_release (skey);
1936   return 0; /* Succeeded. */
1937
1938  failed:
1939   sexp_release (pkey);
1940   sexp_release (skey);
1941   if (report)
1942     report ("pubkey", GCRY_PK_RSA, what, errtxt);
1943   return GPG_ERR_SELFTEST_FAILED;
1944 }
1945
1946
1947 /* Run a full self-test for ALGO and return 0 on success.  */
1948 static gpg_err_code_t
1949 run_selftests (int algo, int extended, selftest_report_func_t report)
1950 {
1951   gpg_err_code_t ec;
1952
1953   (void)extended;
1954
1955   switch (algo)
1956     {
1957     case GCRY_PK_RSA:
1958       ec = selftests_rsa (report);
1959       break;
1960     default:
1961       ec = GPG_ERR_PUBKEY_ALGO;
1962       break;
1963
1964     }
1965   return ec;
1966 }
1967
1968
1969
1970 \f
1971 gcry_pk_spec_t _gcry_pubkey_spec_rsa =
1972   {
1973     GCRY_PK_RSA, { 0, 1 },
1974     (GCRY_PK_USAGE_SIGN | GCRY_PK_USAGE_ENCR),
1975     "RSA", rsa_names,
1976     "ne", "nedpqu", "a", "s", "n",
1977     rsa_generate,
1978     rsa_check_secret_key,
1979     rsa_encrypt,
1980     rsa_decrypt,
1981     rsa_sign,
1982     rsa_verify,
1983     rsa_get_nbits,
1984     run_selftests,
1985     compute_keygrip
1986   };