pk: Merge extraspecs struct with standard specs struct.
[libgcrypt.git] / cipher / pubkey.c
1 /* pubkey.c  -  pubkey dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2002, 2003, 2005,
3  *               2007, 2008, 2011 Free Software Foundation, Inc.
4  * Copyright (C) 2013 g10 Code GmbH
5  *
6  * This file is part of Libgcrypt.
7  *
8  * Libgcrypt is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser general Public License as
10  * published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * Libgcrypt is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "g10lib.h"
29 #include "mpi.h"
30 #include "cipher.h"
31 #include "ath.h"
32 #include "context.h"
33 #include "pubkey-internal.h"
34
35
36 static gcry_err_code_t pubkey_decrypt (int algo, gcry_mpi_t *result,
37                                        gcry_mpi_t *data, gcry_mpi_t *skey,
38                                        int flags);
39 static gcry_err_code_t pubkey_sign (int algo, gcry_mpi_t *resarr,
40                                     gcry_mpi_t hash, gcry_mpi_t *skey,
41                                     struct pk_encoding_ctx *ctx);
42 static gcry_err_code_t pubkey_verify (int algo, gcry_mpi_t hash,
43                                       gcry_mpi_t *data, gcry_mpi_t *pkey,
44                                       struct pk_encoding_ctx *ctx);
45
46
47 /* This is the list of the default public-key ciphers included in
48    libgcrypt.  FIPS_ALLOWED indicated whether the algorithm is used in
49    FIPS mode. */
50 static struct pubkey_table_entry
51 {
52   gcry_pk_spec_t *pubkey;
53   unsigned int algorithm;
54   int fips_allowed;
55 } pubkey_table[] =
56   {
57 #if USE_RSA
58     { &_gcry_pubkey_spec_rsa,       GCRY_PK_RSA, 1},
59 #endif
60 #if USE_ELGAMAL
61     { &_gcry_pubkey_spec_elg,       GCRY_PK_ELG   },
62     { &_gcry_pubkey_spec_elg,       GCRY_PK_ELG_E },
63 #endif
64 #if USE_DSA
65     { &_gcry_pubkey_spec_dsa,       GCRY_PK_DSA, 1   },
66 #endif
67 #if USE_ECC
68     { &_gcry_pubkey_spec_ecdsa,      GCRY_PK_ECDSA, 0 },
69     { &_gcry_pubkey_spec_ecdh,       GCRY_PK_ECDH, 0 },
70 #endif
71     { NULL, 0 }
72   };
73
74 /* List of registered ciphers.  */
75 static gcry_module_t pubkeys_registered;
76
77 /* This is the lock protecting PUBKEYS_REGISTERED.  */
78 static ath_mutex_t pubkeys_registered_lock;
79
80 /* Flag to check whether the default pubkeys have already been
81    registered.  */
82 static int default_pubkeys_registered;
83
84 /* Convenient macro for registering the default digests.  */
85 #define REGISTER_DEFAULT_PUBKEYS                   \
86   do                                               \
87     {                                              \
88       ath_mutex_lock (&pubkeys_registered_lock);   \
89       if (! default_pubkeys_registered)            \
90         {                                          \
91           pk_register_default ();                  \
92           default_pubkeys_registered = 1;          \
93         }                                          \
94       ath_mutex_unlock (&pubkeys_registered_lock); \
95     }                                              \
96   while (0)
97
98 /* These dummy functions are used in case a cipher implementation
99    refuses to provide it's own functions.  */
100
101 static gcry_err_code_t
102 dummy_generate (int algorithm, unsigned int nbits, unsigned long dummy,
103                 gcry_mpi_t *skey, gcry_mpi_t **retfactors)
104 {
105   (void)algorithm;
106   (void)nbits;
107   (void)dummy;
108   (void)skey;
109   (void)retfactors;
110   fips_signal_error ("using dummy public key function");
111   return GPG_ERR_NOT_IMPLEMENTED;
112 }
113
114 static gcry_err_code_t
115 dummy_check_secret_key (int algorithm, gcry_mpi_t *skey)
116 {
117   (void)algorithm;
118   (void)skey;
119   fips_signal_error ("using dummy public key function");
120   return GPG_ERR_NOT_IMPLEMENTED;
121 }
122
123 static gcry_err_code_t
124 dummy_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
125                gcry_mpi_t *pkey, int flags)
126 {
127   (void)algorithm;
128   (void)resarr;
129   (void)data;
130   (void)pkey;
131   (void)flags;
132   fips_signal_error ("using dummy public key function");
133   return GPG_ERR_NOT_IMPLEMENTED;
134 }
135
136 static gcry_err_code_t
137 dummy_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data,
138                gcry_mpi_t *skey, int flags)
139 {
140   (void)algorithm;
141   (void)result;
142   (void)data;
143   (void)skey;
144   (void)flags;
145   fips_signal_error ("using dummy public key function");
146   return GPG_ERR_NOT_IMPLEMENTED;
147 }
148
149 static gcry_err_code_t
150 dummy_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
151             gcry_mpi_t *skey,
152             int flags, int hashalgo)
153
154 {
155   (void)algorithm;
156   (void)resarr;
157   (void)data;
158   (void)skey;
159   (void)flags;
160   (void)hashalgo;
161   fips_signal_error ("using dummy public key function");
162   return GPG_ERR_NOT_IMPLEMENTED;
163 }
164
165 static gcry_err_code_t
166 dummy_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data,
167               gcry_mpi_t *pkey,
168               int (*cmp) (void *, gcry_mpi_t), void *opaquev,
169               int flags, int hashalgo)
170 {
171   (void)algorithm;
172   (void)hash;
173   (void)data;
174   (void)pkey;
175   (void)cmp;
176   (void)opaquev;
177   (void)flags;
178   (void)hashalgo;
179   fips_signal_error ("using dummy public key function");
180   return GPG_ERR_NOT_IMPLEMENTED;
181 }
182
183 static unsigned
184 dummy_get_nbits (int algorithm, gcry_mpi_t *pkey)
185 {
186   (void)algorithm;
187   (void)pkey;
188   fips_signal_error ("using dummy public key function");
189   return 0;
190 }
191
192 /* Internal function.  Register all the pubkeys included in
193    PUBKEY_TABLE.  Returns zero on success or an error code.  */
194 static void
195 pk_register_default (void)
196 {
197   gcry_err_code_t err = 0;
198   int i;
199
200   for (i = 0; (! err) && pubkey_table[i].pubkey; i++)
201     {
202 #define pubkey_use_dummy(func)                       \
203       if (! pubkey_table[i].pubkey->func)            \
204         pubkey_table[i].pubkey->func = dummy_##func;
205
206       pubkey_use_dummy (generate);
207       pubkey_use_dummy (check_secret_key);
208       pubkey_use_dummy (encrypt);
209       pubkey_use_dummy (decrypt);
210       pubkey_use_dummy (sign);
211       pubkey_use_dummy (verify);
212       pubkey_use_dummy (get_nbits);
213 #undef pubkey_use_dummy
214
215       err = _gcry_module_add (&pubkeys_registered,
216                               pubkey_table[i].algorithm,
217                               (void *) pubkey_table[i].pubkey,
218                               NULL,
219                               NULL);
220     }
221
222   if (err)
223     BUG ();
224 }
225
226 /* Internal callback function.  Used via _gcry_module_lookup.  */
227 static int
228 gcry_pk_lookup_func_name (void *spec, void *data)
229 {
230   gcry_pk_spec_t *pubkey = (gcry_pk_spec_t *) spec;
231   char *name = (char *) data;
232   const char **aliases = pubkey->aliases;
233   int ret = stricmp (name, pubkey->name);
234
235   while (ret && *aliases)
236     ret = stricmp (name, *aliases++);
237
238   return ! ret;
239 }
240
241 /* Internal function.  Lookup a pubkey entry by it's name.  */
242 static gcry_module_t
243 gcry_pk_lookup_name (const char *name)
244 {
245   gcry_module_t pubkey;
246
247   pubkey = _gcry_module_lookup (pubkeys_registered, (void *) name,
248                                 gcry_pk_lookup_func_name);
249
250   return pubkey;
251 }
252
253 /* Register a new pubkey module whose specification can be found in
254    PUBKEY.  On success, a new algorithm ID is stored in ALGORITHM_ID
255    and a pointer representhing this module is stored in MODULE.  */
256 gcry_error_t
257 _gcry_pk_register (gcry_pk_spec_t *pubkey,
258                    unsigned int *algorithm_id,
259                    gcry_module_t *module)
260 {
261   gcry_err_code_t err = GPG_ERR_NO_ERROR;
262   gcry_module_t mod;
263
264   /* We do not support module loading in fips mode.  */
265   if (fips_mode ())
266     return gpg_error (GPG_ERR_NOT_SUPPORTED);
267
268   ath_mutex_lock (&pubkeys_registered_lock);
269   err = _gcry_module_add (&pubkeys_registered, 0,
270                           (void *) pubkey,
271                           NULL,
272                           &mod);
273   ath_mutex_unlock (&pubkeys_registered_lock);
274
275   if (! err)
276     {
277       *module = mod;
278       *algorithm_id = mod->mod_id;
279     }
280
281   return err;
282 }
283
284 /* Unregister the pubkey identified by ID, which must have been
285    registered with gcry_pk_register.  */
286 void
287 _gcry_pk_unregister (gcry_module_t module)
288 {
289   ath_mutex_lock (&pubkeys_registered_lock);
290   _gcry_module_release (module);
291   ath_mutex_unlock (&pubkeys_registered_lock);
292 }
293
294 static void
295 release_mpi_array (gcry_mpi_t *array)
296 {
297   for (; *array; array++)
298     {
299       mpi_free(*array);
300       *array = NULL;
301     }
302 }
303
304 /****************
305  * Map a string to the pubkey algo
306  */
307 int
308 gcry_pk_map_name (const char *string)
309 {
310   gcry_module_t pubkey;
311   int algorithm = 0;
312
313   if (!string)
314     return 0;
315
316   REGISTER_DEFAULT_PUBKEYS;
317
318   ath_mutex_lock (&pubkeys_registered_lock);
319   pubkey = gcry_pk_lookup_name (string);
320   if (pubkey)
321     {
322       algorithm = pubkey->mod_id;
323       _gcry_module_release (pubkey);
324     }
325   ath_mutex_unlock (&pubkeys_registered_lock);
326
327   return algorithm;
328 }
329
330
331 /* Map the public key algorithm whose ID is contained in ALGORITHM to
332    a string representation of the algorithm name.  For unknown
333    algorithm IDs this functions returns "?". */
334 const char *
335 gcry_pk_algo_name (int algorithm)
336 {
337   gcry_module_t pubkey;
338   const char *name;
339
340   REGISTER_DEFAULT_PUBKEYS;
341
342   ath_mutex_lock (&pubkeys_registered_lock);
343   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
344   if (pubkey)
345     {
346       name = ((gcry_pk_spec_t *) pubkey->spec)->name;
347       _gcry_module_release (pubkey);
348     }
349   else
350     name = "?";
351   ath_mutex_unlock (&pubkeys_registered_lock);
352
353   return name;
354 }
355
356
357 /* A special version of gcry_pk_algo name to return the first aliased
358    name of the algorithm.  This is required to adhere to the spki
359    specs where the algorithm names are lowercase. */
360 const char *
361 _gcry_pk_aliased_algo_name (int algorithm)
362 {
363   const char *name = NULL;
364   gcry_module_t module;
365
366   REGISTER_DEFAULT_PUBKEYS;
367
368   ath_mutex_lock (&pubkeys_registered_lock);
369   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
370   if (module)
371     {
372       gcry_pk_spec_t *pubkey = (gcry_pk_spec_t *) module->spec;
373
374       name = pubkey->aliases? *pubkey->aliases : NULL;
375       if (!name || !*name)
376         name = pubkey->name;
377       _gcry_module_release (module);
378     }
379   ath_mutex_unlock (&pubkeys_registered_lock);
380
381   return name;
382 }
383
384
385 static void
386 disable_pubkey_algo (int algorithm)
387 {
388   gcry_module_t pubkey;
389
390   ath_mutex_lock (&pubkeys_registered_lock);
391   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
392   if (pubkey)
393     {
394       if (! (pubkey-> flags & FLAG_MODULE_DISABLED))
395         pubkey->flags |= FLAG_MODULE_DISABLED;
396       _gcry_module_release (pubkey);
397     }
398   ath_mutex_unlock (&pubkeys_registered_lock);
399 }
400
401
402 /****************
403  * A USE of 0 means: don't care.
404  */
405 static gcry_err_code_t
406 check_pubkey_algo (int algorithm, unsigned use)
407 {
408   gcry_err_code_t err = GPG_ERR_NO_ERROR;
409   gcry_pk_spec_t *pubkey;
410   gcry_module_t module;
411
412   REGISTER_DEFAULT_PUBKEYS;
413
414   ath_mutex_lock (&pubkeys_registered_lock);
415   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
416   if (module)
417     {
418       pubkey = (gcry_pk_spec_t *) module->spec;
419
420       if (((use & GCRY_PK_USAGE_SIGN)
421            && (! (pubkey->use & GCRY_PK_USAGE_SIGN)))
422           || ((use & GCRY_PK_USAGE_ENCR)
423               && (! (pubkey->use & GCRY_PK_USAGE_ENCR))))
424         err = GPG_ERR_WRONG_PUBKEY_ALGO;
425       else if (module->flags & FLAG_MODULE_DISABLED)
426         err = GPG_ERR_PUBKEY_ALGO;
427       _gcry_module_release (module);
428     }
429   else
430     err = GPG_ERR_PUBKEY_ALGO;
431   ath_mutex_unlock (&pubkeys_registered_lock);
432
433   return err;
434 }
435
436
437 /****************
438  * Return the number of public key material numbers
439  */
440 static int
441 pubkey_get_npkey (int algorithm)
442 {
443   gcry_module_t pubkey;
444   int npkey = 0;
445
446   REGISTER_DEFAULT_PUBKEYS;
447
448   ath_mutex_lock (&pubkeys_registered_lock);
449   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
450   if (pubkey)
451     {
452       npkey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_pkey);
453       _gcry_module_release (pubkey);
454     }
455   ath_mutex_unlock (&pubkeys_registered_lock);
456
457   return npkey;
458 }
459
460 /****************
461  * Return the number of secret key material numbers
462  */
463 static int
464 pubkey_get_nskey (int algorithm)
465 {
466   gcry_module_t pubkey;
467   int nskey = 0;
468
469   REGISTER_DEFAULT_PUBKEYS;
470
471   ath_mutex_lock (&pubkeys_registered_lock);
472   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
473   if (pubkey)
474     {
475       nskey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_skey);
476       _gcry_module_release (pubkey);
477     }
478   ath_mutex_unlock (&pubkeys_registered_lock);
479
480   return nskey;
481 }
482
483 /****************
484  * Return the number of signature material numbers
485  */
486 static int
487 pubkey_get_nsig (int algorithm)
488 {
489   gcry_module_t pubkey;
490   int nsig = 0;
491
492   REGISTER_DEFAULT_PUBKEYS;
493
494   ath_mutex_lock (&pubkeys_registered_lock);
495   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
496   if (pubkey)
497     {
498       nsig = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_sig);
499       _gcry_module_release (pubkey);
500     }
501   ath_mutex_unlock (&pubkeys_registered_lock);
502
503   return nsig;
504 }
505
506 /****************
507  * Return the number of encryption material numbers
508  */
509 static int
510 pubkey_get_nenc (int algorithm)
511 {
512   gcry_module_t pubkey;
513   int nenc = 0;
514
515   REGISTER_DEFAULT_PUBKEYS;
516
517   ath_mutex_lock (&pubkeys_registered_lock);
518   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
519   if (pubkey)
520     {
521       nenc = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_enc);
522       _gcry_module_release (pubkey);
523     }
524   ath_mutex_unlock (&pubkeys_registered_lock);
525
526   return nenc;
527 }
528
529
530 /* Generate a new public key with algorithm ALGORITHM of size NBITS
531    and return it at SKEY.  USE_E depends on the ALGORITHM.  GENPARMS
532    is passed to the algorithm module if it features an extended
533    generation function.  RETFACTOR is used by some algorithms to
534    return certain additional information which are in general not
535    required.
536
537    The function returns the error code number or 0 on success. */
538 static gcry_err_code_t
539 pubkey_generate (int algorithm,
540                  unsigned int nbits,
541                  unsigned long use_e,
542                  gcry_sexp_t genparms,
543                  gcry_mpi_t *skey, gcry_mpi_t **retfactors,
544                  gcry_sexp_t *r_extrainfo)
545 {
546   gcry_err_code_t ec = GPG_ERR_PUBKEY_ALGO;
547   gcry_module_t pubkey;
548
549   REGISTER_DEFAULT_PUBKEYS;
550
551   ath_mutex_lock (&pubkeys_registered_lock);
552   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
553   if (pubkey)
554     {
555       if (((gcry_pk_spec_t *) pubkey->spec)->ext_generate)
556         {
557
558           /* Use the extended generate function.  */
559           ec = ((gcry_pk_spec_t *) pubkey->spec)->ext_generate
560             (algorithm, nbits, use_e, genparms, skey, retfactors, r_extrainfo);
561         }
562       else
563         {
564           /* Use the standard generate function.  */
565           ec = ((gcry_pk_spec_t *) pubkey->spec)->generate
566             (algorithm, nbits, use_e, skey, retfactors);
567         }
568       _gcry_module_release (pubkey);
569     }
570   ath_mutex_unlock (&pubkeys_registered_lock);
571
572   return ec;
573 }
574
575
576 static gcry_err_code_t
577 pubkey_check_secret_key (int algorithm, gcry_mpi_t *skey)
578 {
579   gcry_err_code_t err = GPG_ERR_PUBKEY_ALGO;
580   gcry_module_t pubkey;
581
582   REGISTER_DEFAULT_PUBKEYS;
583
584   ath_mutex_lock (&pubkeys_registered_lock);
585   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
586   if (pubkey)
587     {
588       err = ((gcry_pk_spec_t *) pubkey->spec)->check_secret_key
589         (algorithm, skey);
590       _gcry_module_release (pubkey);
591     }
592   ath_mutex_unlock (&pubkeys_registered_lock);
593
594   return err;
595 }
596
597
598 /****************
599  * This is the interface to the public key encryption.  Encrypt DATA
600  * with PKEY and put it into RESARR which should be an array of MPIs
601  * of size PUBKEY_MAX_NENC (or less if the algorithm allows this -
602  * check with pubkey_get_nenc() )
603  */
604 static gcry_err_code_t
605 pubkey_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
606                 gcry_mpi_t *pkey, int flags)
607 {
608   gcry_pk_spec_t *pubkey;
609   gcry_module_t module;
610   gcry_err_code_t rc;
611   int i;
612
613   /* Note: In fips mode DBG_CIPHER will enver evaluate to true but as
614      an extra failsafe protection we explicitly test for fips mode
615      here. */
616   if (DBG_CIPHER && !fips_mode ())
617     {
618       log_debug ("pubkey_encrypt: algo=%d\n", algorithm);
619       for(i = 0; i < pubkey_get_npkey (algorithm); i++)
620         log_mpidump ("  pkey", pkey[i]);
621       log_mpidump ("  data", data);
622     }
623
624   ath_mutex_lock (&pubkeys_registered_lock);
625   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
626   if (module)
627     {
628       pubkey = (gcry_pk_spec_t *) module->spec;
629       rc = pubkey->encrypt (algorithm, resarr, data, pkey, flags);
630       _gcry_module_release (module);
631       goto ready;
632     }
633   rc = GPG_ERR_PUBKEY_ALGO;
634
635  ready:
636   ath_mutex_unlock (&pubkeys_registered_lock);
637
638   if (!rc && DBG_CIPHER && !fips_mode ())
639     {
640       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
641         log_mpidump("  encr", resarr[i] );
642     }
643   return rc;
644 }
645
646
647 /****************
648  * This is the interface to the public key decryption.
649  * ALGO gives the algorithm to use and this implicitly determines
650  * the size of the arrays.
651  * result is a pointer to a mpi variable which will receive a
652  * newly allocated mpi or NULL in case of an error.
653  */
654 static gcry_err_code_t
655 pubkey_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data,
656                 gcry_mpi_t *skey, int flags)
657 {
658   gcry_pk_spec_t *pubkey;
659   gcry_module_t module;
660   gcry_err_code_t rc;
661   int i;
662
663   *result = NULL; /* so the caller can always do a mpi_free */
664   if (DBG_CIPHER && !fips_mode ())
665     {
666       log_debug ("pubkey_decrypt: algo=%d\n", algorithm);
667       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
668         log_mpidump ("  skey", skey[i]);
669       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
670         log_mpidump ("  data", data[i]);
671     }
672
673   ath_mutex_lock (&pubkeys_registered_lock);
674   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
675   if (module)
676     {
677       pubkey = (gcry_pk_spec_t *) module->spec;
678       rc = pubkey->decrypt (algorithm, result, data, skey, flags);
679       _gcry_module_release (module);
680       goto ready;
681     }
682
683   rc = GPG_ERR_PUBKEY_ALGO;
684
685  ready:
686   ath_mutex_unlock (&pubkeys_registered_lock);
687
688   if (!rc && DBG_CIPHER && !fips_mode ())
689     log_mpidump (" plain", *result);
690
691   return rc;
692 }
693
694
695 /****************
696  * This is the interface to the public key signing.
697  * Sign data with skey and put the result into resarr which
698  * should be an array of MPIs of size PUBKEY_MAX_NSIG (or less if the
699  * algorithm allows this - check with pubkey_get_nsig() )
700  */
701 static gcry_err_code_t
702 pubkey_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
703              gcry_mpi_t *skey, struct pk_encoding_ctx *ctx)
704 {
705   gcry_pk_spec_t *pubkey;
706   gcry_module_t module;
707   gcry_err_code_t rc;
708   int i;
709
710   if (DBG_CIPHER && !fips_mode ())
711     {
712       log_debug ("pubkey_sign: algo=%d\n", algorithm);
713       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
714         log_mpidump ("  skey", skey[i]);
715       log_mpidump("  data", data );
716     }
717
718   ath_mutex_lock (&pubkeys_registered_lock);
719   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
720   if (module)
721     {
722       pubkey = (gcry_pk_spec_t *) module->spec;
723       rc = pubkey->sign (algorithm, resarr, data, skey,
724                          ctx->flags, ctx->hash_algo);
725       _gcry_module_release (module);
726       goto ready;
727     }
728
729   rc = GPG_ERR_PUBKEY_ALGO;
730
731  ready:
732   ath_mutex_unlock (&pubkeys_registered_lock);
733
734   if (!rc && DBG_CIPHER && !fips_mode ())
735     for (i = 0; i < pubkey_get_nsig (algorithm); i++)
736       log_mpidump ("   sig", resarr[i]);
737
738   return rc;
739 }
740
741 /****************
742  * Verify a public key signature.
743  * Return 0 if the signature is good
744  */
745 static gcry_err_code_t
746 pubkey_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data,
747                gcry_mpi_t *pkey, struct pk_encoding_ctx *ctx)
748 {
749   gcry_pk_spec_t *pubkey;
750   gcry_module_t module;
751   gcry_err_code_t rc;
752   int i;
753
754   if (DBG_CIPHER && !fips_mode ())
755     {
756       log_debug ("pubkey_verify: algo=%d\n", algorithm);
757       for (i = 0; i < pubkey_get_npkey (algorithm); i++)
758         log_mpidump ("  pkey", pkey[i]);
759       for (i = 0; i < pubkey_get_nsig (algorithm); i++)
760         log_mpidump ("   sig", data[i]);
761       log_mpidump ("  hash", hash);
762     }
763
764   ath_mutex_lock (&pubkeys_registered_lock);
765   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
766   if (module)
767     {
768       pubkey = (gcry_pk_spec_t *) module->spec;
769       rc = pubkey->verify (algorithm, hash, data, pkey,
770                            ctx->verify_cmp, ctx,
771                            ctx->flags, ctx->hash_algo);
772       _gcry_module_release (module);
773       goto ready;
774     }
775
776   rc = GPG_ERR_PUBKEY_ALGO;
777
778  ready:
779   ath_mutex_unlock (&pubkeys_registered_lock);
780   return rc;
781 }
782
783
784 /* Turn VALUE into an octet string and store it in an allocated buffer
785    at R_FRAME or - if R_RAME is NULL - copy it into the caller
786    provided buffer SPACE; either SPACE or R_FRAME may be used.  If
787    SPACE if not NULL, the caller must provide a buffer of at least
788    NBYTES.  If the resulting octet string is shorter than NBYTES pad
789    it to the left with zeroes.  If VALUE does not fit into NBYTES
790    return an error code.  */
791 static gpg_err_code_t
792 octet_string_from_mpi (unsigned char **r_frame, void *space,
793                        gcry_mpi_t value, size_t nbytes)
794 {
795   gpg_err_code_t rc;
796   size_t nframe, noff, n;
797   unsigned char *frame;
798
799   if (!r_frame == !space)
800     return GPG_ERR_INV_ARG;  /* Only one may be used.  */
801
802   if (r_frame)
803     *r_frame = NULL;
804
805   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
806                                       NULL, 0, &nframe, value));
807   if (rc)
808     return rc;
809   if (nframe > nbytes)
810     return GPG_ERR_TOO_LARGE; /* Value too long to fit into NBYTES.  */
811
812   noff = (nframe < nbytes)? nbytes - nframe : 0;
813   n = nframe + noff;
814   if (space)
815     frame = space;
816   else
817     {
818       frame = mpi_is_secure (value)? gcry_malloc_secure (n) : gcry_malloc (n);
819       if (!frame)
820         {
821           rc = gpg_err_code_from_syserror ();
822           return rc;
823         }
824     }
825   if (noff)
826     memset (frame, 0, noff);
827   nframe += noff;
828   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
829                                       frame+noff, nframe-noff, NULL, value));
830   if (rc)
831     {
832       gcry_free (frame);
833       return rc;
834     }
835
836   if (r_frame)
837     *r_frame = frame;
838   return 0;
839 }
840
841
842 /* Encode {VALUE,VALUELEN} for an NBITS keys using the pkcs#1 block
843    type 2 padding.  On sucess the result is stored as a new MPI at
844    R_RESULT.  On error the value at R_RESULT is undefined.
845
846    If {RANDOM_OVERRIDE, RANDOM_OVERRIDE_LEN} is given it is used as
847    the seed instead of using a random string for it.  This feature is
848    only useful for regression tests.  Note that this value may not
849    contain zero bytes.
850
851    We encode the value in this way:
852
853      0  2  RND(n bytes)  0  VALUE
854
855    0   is a marker we unfortunately can't encode because we return an
856        MPI which strips all leading zeroes.
857    2   is the block type.
858    RND are non-zero random bytes.
859
860    (Note that OpenPGP includes the cipher algorithm and a checksum in
861    VALUE; the caller needs to prepare the value accordingly.)
862   */
863 static gcry_err_code_t
864 pkcs1_encode_for_encryption (gcry_mpi_t *r_result, unsigned int nbits,
865                              const unsigned char *value, size_t valuelen,
866                              const unsigned char *random_override,
867                              size_t random_override_len)
868 {
869   gcry_err_code_t rc = 0;
870   gcry_error_t err;
871   unsigned char *frame = NULL;
872   size_t nframe = (nbits+7) / 8;
873   int i;
874   size_t n;
875   unsigned char *p;
876
877   if (valuelen + 7 > nframe || !nframe)
878     {
879       /* Can't encode a VALUELEN value in a NFRAME bytes frame.  */
880       return GPG_ERR_TOO_SHORT; /* The key is too short.  */
881     }
882
883   if ( !(frame = gcry_malloc_secure (nframe)))
884     return gpg_err_code_from_syserror ();
885
886   n = 0;
887   frame[n++] = 0;
888   frame[n++] = 2; /* block type */
889   i = nframe - 3 - valuelen;
890   gcry_assert (i > 0);
891
892   if (random_override)
893     {
894       int j;
895
896       if (random_override_len != i)
897         {
898           gcry_free (frame);
899           return GPG_ERR_INV_ARG;
900         }
901       /* Check that random does not include a zero byte.  */
902       for (j=0; j < random_override_len; j++)
903         if (!random_override[j])
904           {
905             gcry_free (frame);
906             return GPG_ERR_INV_ARG;
907           }
908       memcpy (frame + n, random_override, random_override_len);
909       n += random_override_len;
910     }
911   else
912     {
913       p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
914       /* Replace zero bytes by new values. */
915       for (;;)
916         {
917           int j, k;
918           unsigned char *pp;
919
920           /* Count the zero bytes. */
921           for (j=k=0; j < i; j++)
922             {
923               if (!p[j])
924                 k++;
925             }
926           if (!k)
927             break; /* Okay: no (more) zero bytes. */
928
929           k += k/128 + 3; /* Better get some more. */
930           pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
931           for (j=0; j < i && k; )
932             {
933               if (!p[j])
934                 p[j] = pp[--k];
935               if (p[j])
936                 j++;
937             }
938           gcry_free (pp);
939         }
940       memcpy (frame+n, p, i);
941       n += i;
942       gcry_free (p);
943     }
944
945   frame[n++] = 0;
946   memcpy (frame+n, value, valuelen);
947   n += valuelen;
948   gcry_assert (n == nframe);
949
950   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, n, &nframe);
951   if (err)
952     rc = gcry_err_code (err);
953   else if (DBG_CIPHER)
954     log_mpidump ("PKCS#1 block type 2 encoded data", *r_result);
955   gcry_free (frame);
956
957   return rc;
958 }
959
960
961 /* Decode a plaintext in VALUE assuming pkcs#1 block type 2 padding.
962    NBITS is the size of the secret key.  On success the result is
963    stored as a newly allocated buffer at R_RESULT and its valid length at
964    R_RESULTLEN.  On error NULL is stored at R_RESULT.  */
965 static gcry_err_code_t
966 pkcs1_decode_for_encryption (unsigned char **r_result, size_t *r_resultlen,
967                              unsigned int nbits, gcry_mpi_t value)
968 {
969   gcry_error_t err;
970   unsigned char *frame = NULL;
971   size_t nframe = (nbits+7) / 8;
972   size_t n;
973
974   *r_result = NULL;
975
976   if ( !(frame = gcry_malloc_secure (nframe)))
977     return gpg_err_code_from_syserror ();
978
979   err = gcry_mpi_print (GCRYMPI_FMT_USG, frame, nframe, &n, value);
980   if (err)
981     {
982       gcry_free (frame);
983       return gcry_err_code (err);
984     }
985
986   nframe = n; /* Set NFRAME to the actual length.  */
987
988   /* FRAME = 0x00 || 0x02 || PS || 0x00 || M
989
990      pkcs#1 requires that the first byte is zero.  Our MPIs usually
991      strip leading zero bytes; thus we are not able to detect them.
992      However due to the way gcry_mpi_print is implemented we may see
993      leading zero bytes nevertheless.  We handle this by making the
994      first zero byte optional.  */
995   if (nframe < 4)
996     {
997       gcry_free (frame);
998       return GPG_ERR_ENCODING_PROBLEM;  /* Too short.  */
999     }
1000   n = 0;
1001   if (!frame[0])
1002     n++;
1003   if (frame[n++] != 0x02)
1004     {
1005       gcry_free (frame);
1006       return GPG_ERR_ENCODING_PROBLEM;  /* Wrong block type.  */
1007     }
1008
1009   /* Skip the non-zero random bytes and the terminating zero byte.  */
1010   for (; n < nframe && frame[n] != 0x00; n++)
1011     ;
1012   if (n+1 >= nframe)
1013     {
1014       gcry_free (frame);
1015       return GPG_ERR_ENCODING_PROBLEM; /* No zero byte.  */
1016     }
1017   n++; /* Skip the zero byte.  */
1018
1019   /* To avoid an extra allocation we reuse the frame buffer.  The only
1020      caller of this function will anyway free the result soon.  */
1021   memmove (frame, frame + n, nframe - n);
1022   *r_result = frame;
1023   *r_resultlen = nframe - n;
1024
1025   if (DBG_CIPHER)
1026     log_printhex ("value extracted from PKCS#1 block type 2 encoded data",
1027                   *r_result, *r_resultlen);
1028
1029   return 0;
1030 }
1031
1032
1033 /* Encode {VALUE,VALUELEN} for an NBITS keys and hash algorith ALGO
1034    using the pkcs#1 block type 1 padding.  On success the result is
1035    stored as a new MPI at R_RESULT.  On error the value at R_RESULT is
1036    undefined.
1037
1038    We encode the value in this way:
1039
1040      0  1  PAD(n bytes)  0  ASN(asnlen bytes) VALUE(valuelen bytes)
1041
1042    0   is a marker we unfortunately can't encode because we return an
1043        MPI which strips all leading zeroes.
1044    1   is the block type.
1045    PAD consists of 0xff bytes.
1046    0   marks the end of the padding.
1047    ASN is the DER encoding of the hash algorithm; along with the VALUE
1048        it yields a valid DER encoding.
1049
1050    (Note that PGP prior to version 2.3 encoded the message digest as:
1051       0   1   MD(16 bytes)   0   PAD(n bytes)   1
1052     The MD is always 16 bytes here because it's always MD5.  GnuPG
1053     does not not support pre-v2.3 signatures, but I'm including this
1054     comment so the information is easily found if needed.)
1055 */
1056 static gcry_err_code_t
1057 pkcs1_encode_for_signature (gcry_mpi_t *r_result, unsigned int nbits,
1058                             const unsigned char *value, size_t valuelen,
1059                             int algo)
1060 {
1061   gcry_err_code_t rc = 0;
1062   gcry_error_t err;
1063   byte asn[100];
1064   byte *frame = NULL;
1065   size_t nframe = (nbits+7) / 8;
1066   int i;
1067   size_t n;
1068   size_t asnlen, dlen;
1069
1070   asnlen = DIM(asn);
1071   dlen = gcry_md_get_algo_dlen (algo);
1072
1073   if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
1074     {
1075       /* We don't have yet all of the above algorithms.  */
1076       return GPG_ERR_NOT_IMPLEMENTED;
1077     }
1078
1079   if ( valuelen != dlen )
1080     {
1081       /* Hash value does not match the length of digest for
1082          the given algorithm.  */
1083       return GPG_ERR_CONFLICT;
1084     }
1085
1086   if ( !dlen || dlen + asnlen + 4 > nframe)
1087     {
1088       /* Can't encode an DLEN byte digest MD into an NFRAME byte
1089          frame.  */
1090       return GPG_ERR_TOO_SHORT;
1091     }
1092
1093   if ( !(frame = gcry_malloc (nframe)) )
1094     return gpg_err_code_from_syserror ();
1095
1096   /* Assemble the pkcs#1 block type 1. */
1097   n = 0;
1098   frame[n++] = 0;
1099   frame[n++] = 1; /* block type */
1100   i = nframe - valuelen - asnlen - 3 ;
1101   gcry_assert (i > 1);
1102   memset (frame+n, 0xff, i );
1103   n += i;
1104   frame[n++] = 0;
1105   memcpy (frame+n, asn, asnlen);
1106   n += asnlen;
1107   memcpy (frame+n, value, valuelen );
1108   n += valuelen;
1109   gcry_assert (n == nframe);
1110
1111   /* Convert it into an MPI. */
1112   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, n, &nframe);
1113   if (err)
1114     rc = gcry_err_code (err);
1115   else if (DBG_CIPHER)
1116     log_mpidump ("PKCS#1 block type 1 encoded data", *r_result);
1117   gcry_free (frame);
1118
1119   return rc;
1120 }
1121
1122
1123 /* Mask generation function for OAEP.  See RFC-3447 B.2.1.  */
1124 static gcry_err_code_t
1125 mgf1 (unsigned char *output, size_t outlen, unsigned char *seed, size_t seedlen,
1126       int algo)
1127 {
1128   size_t dlen, nbytes, n;
1129   int idx;
1130   gcry_md_hd_t hd;
1131   gcry_error_t err;
1132
1133   err = gcry_md_open (&hd, algo, 0);
1134   if (err)
1135     return gpg_err_code (err);
1136
1137   dlen = gcry_md_get_algo_dlen (algo);
1138
1139   /* We skip step 1 which would be assert(OUTLEN <= 2^32).  The loop
1140      in step 3 is merged with step 4 by concatenating no more octets
1141      than what would fit into OUTPUT.  The ceiling for the counter IDX
1142      is implemented indirectly.  */
1143   nbytes = 0;  /* Step 2.  */
1144   idx = 0;
1145   while ( nbytes < outlen )
1146     {
1147       unsigned char c[4], *digest;
1148
1149       if (idx)
1150         gcry_md_reset (hd);
1151
1152       c[0] = (idx >> 24) & 0xFF;
1153       c[1] = (idx >> 16) & 0xFF;
1154       c[2] = (idx >> 8) & 0xFF;
1155       c[3] = idx & 0xFF;
1156       idx++;
1157
1158       gcry_md_write (hd, seed, seedlen);
1159       gcry_md_write (hd, c, 4);
1160       digest = gcry_md_read (hd, 0);
1161
1162       n = (outlen - nbytes < dlen)? (outlen - nbytes) : dlen;
1163       memcpy (output+nbytes, digest, n);
1164       nbytes += n;
1165     }
1166
1167   gcry_md_close (hd);
1168   return GPG_ERR_NO_ERROR;
1169 }
1170
1171
1172 /* RFC-3447 (pkcs#1 v2.1) OAEP encoding.  NBITS is the length of the
1173    key measured in bits.  ALGO is the hash function; it must be a
1174    valid and usable algorithm.  {VALUE,VALUELEN} is the message to
1175    encrypt.  {LABEL,LABELLEN} is the optional label to be associated
1176    with the message, if LABEL is NULL the default is to use the empty
1177    string as label.  On success the encoded ciphertext is returned at
1178    R_RESULT.
1179
1180    If {RANDOM_OVERRIDE, RANDOM_OVERRIDE_LEN} is given it is used as
1181    the seed instead of using a random string for it.  This feature is
1182    only useful for regression tests.
1183
1184    Here is figure 1 from the RFC depicting the process:
1185
1186                              +----------+---------+-------+
1187                         DB = |  lHash   |    PS   |   M   |
1188                              +----------+---------+-------+
1189                                             |
1190                   +----------+              V
1191                   |   seed   |--> MGF ---> xor
1192                   +----------+              |
1193                         |                   |
1194                +--+     V                   |
1195                |00|    xor <----- MGF <-----|
1196                +--+     |                   |
1197                  |      |                   |
1198                  V      V                   V
1199                +--+----------+----------------------------+
1200          EM =  |00|maskedSeed|          maskedDB          |
1201                +--+----------+----------------------------+
1202   */
1203 static gcry_err_code_t
1204 oaep_encode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1205              const unsigned char *value, size_t valuelen,
1206              const unsigned char *label, size_t labellen,
1207              const void *random_override, size_t random_override_len)
1208 {
1209   gcry_err_code_t rc = 0;
1210   gcry_error_t err;
1211   unsigned char *frame = NULL;
1212   size_t nframe = (nbits+7) / 8;
1213   unsigned char *p;
1214   size_t hlen;
1215   size_t n;
1216
1217   *r_result = NULL;
1218
1219   /* Set defaults for LABEL.  */
1220   if (!label || !labellen)
1221     {
1222       label = (const unsigned char*)"";
1223       labellen = 0;
1224     }
1225
1226   hlen = gcry_md_get_algo_dlen (algo);
1227
1228   /* We skip step 1a which would be to check that LABELLEN is not
1229      greater than 2^61-1.  See rfc-3447 7.1.1. */
1230
1231   /* Step 1b.  Note that the obsolete rfc-2437 uses the check:
1232      valuelen > nframe - 2 * hlen - 1 .  */
1233   if (valuelen > nframe - 2 * hlen - 2 || !nframe)
1234     {
1235       /* Can't encode a VALUELEN value in a NFRAME bytes frame. */
1236       return GPG_ERR_TOO_SHORT; /* The key is too short.  */
1237     }
1238
1239   /* Allocate the frame.  */
1240   frame = gcry_calloc_secure (1, nframe);
1241   if (!frame)
1242     return gpg_err_code_from_syserror ();
1243
1244   /* Step 2a: Compute the hash of the label.  We store it in the frame
1245      where later the maskedDB will commence.  */
1246   gcry_md_hash_buffer (algo, frame + 1 + hlen, label, labellen);
1247
1248   /* Step 2b: Set octet string to zero.  */
1249   /* This has already been done while allocating FRAME.  */
1250
1251   /* Step 2c: Create DB by concatenating lHash, PS, 0x01 and M.  */
1252   n = nframe - valuelen - 1;
1253   frame[n] = 0x01;
1254   memcpy (frame + n + 1, value, valuelen);
1255
1256   /* Step 3d: Generate seed.  We store it where the maskedSeed will go
1257      later. */
1258   if (random_override)
1259     {
1260       if (random_override_len != hlen)
1261         {
1262           gcry_free (frame);
1263           return GPG_ERR_INV_ARG;
1264         }
1265       memcpy (frame + 1, random_override, hlen);
1266     }
1267   else
1268     gcry_randomize (frame + 1, hlen, GCRY_STRONG_RANDOM);
1269
1270   /* Step 2e and 2f: Create maskedDB.  */
1271   {
1272     unsigned char *dmask;
1273
1274     dmask = gcry_malloc_secure (nframe - hlen - 1);
1275     if (!dmask)
1276       {
1277         rc = gpg_err_code_from_syserror ();
1278         gcry_free (frame);
1279         return rc;
1280       }
1281     rc = mgf1 (dmask, nframe - hlen - 1, frame+1, hlen, algo);
1282     if (rc)
1283       {
1284         gcry_free (dmask);
1285         gcry_free (frame);
1286         return rc;
1287       }
1288     for (n = 1 + hlen, p = dmask; n < nframe; n++)
1289       frame[n] ^= *p++;
1290     gcry_free (dmask);
1291   }
1292
1293   /* Step 2g and 2h: Create maskedSeed.  */
1294   {
1295     unsigned char *smask;
1296
1297     smask = gcry_malloc_secure (hlen);
1298     if (!smask)
1299       {
1300         rc = gpg_err_code_from_syserror ();
1301         gcry_free (frame);
1302         return rc;
1303       }
1304     rc = mgf1 (smask, hlen, frame + 1 + hlen, nframe - hlen - 1, algo);
1305     if (rc)
1306       {
1307         gcry_free (smask);
1308         gcry_free (frame);
1309         return rc;
1310       }
1311     for (n = 1, p = smask; n < 1 + hlen; n++)
1312       frame[n] ^= *p++;
1313     gcry_free (smask);
1314   }
1315
1316   /* Step 2i: Concatenate 0x00, maskedSeed and maskedDB.  */
1317   /* This has already been done by using in-place operations.  */
1318
1319   /* Convert the stuff into an MPI as expected by the caller.  */
1320   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, nframe, NULL);
1321   if (err)
1322     rc = gcry_err_code (err);
1323   else if (DBG_CIPHER)
1324     log_mpidump ("OAEP encoded data", *r_result);
1325   gcry_free (frame);
1326
1327   return rc;
1328 }
1329
1330
1331 /* RFC-3447 (pkcs#1 v2.1) OAEP decoding.  NBITS is the length of the
1332    key measured in bits.  ALGO is the hash function; it must be a
1333    valid and usable algorithm.  VALUE is the raw decrypted message
1334    {LABEL,LABELLEN} is the optional label to be associated with the
1335    message, if LABEL is NULL the default is to use the empty string as
1336    label.  On success the plaintext is returned as a newly allocated
1337    buffer at R_RESULT; its valid length is stored at R_RESULTLEN.  On
1338    error NULL is stored at R_RESULT.  */
1339 static gcry_err_code_t
1340 oaep_decode (unsigned char **r_result, size_t *r_resultlen,
1341              unsigned int nbits, int algo,
1342              gcry_mpi_t value, const unsigned char *label, size_t labellen)
1343 {
1344   gcry_err_code_t rc;
1345   unsigned char *frame = NULL; /* Encoded messages (EM).  */
1346   unsigned char *masked_seed;  /* Points into FRAME.  */
1347   unsigned char *masked_db;    /* Points into FRAME.  */
1348   unsigned char *seed = NULL;  /* Allocated space for the seed and DB.  */
1349   unsigned char *db;           /* Points into SEED.  */
1350   unsigned char *lhash = NULL; /* Hash of the label.  */
1351   size_t nframe;               /* Length of the ciphertext (EM).  */
1352   size_t hlen;                 /* Length of the hash digest.  */
1353   size_t db_len;               /* Length of DB and masked_db.  */
1354   size_t nkey = (nbits+7)/8;   /* Length of the key in bytes.  */
1355   int failed = 0;              /* Error indicator.  */
1356   size_t n;
1357
1358   *r_result = NULL;
1359
1360   /* This code is implemented as described by rfc-3447 7.1.2.  */
1361
1362   /* Set defaults for LABEL.  */
1363   if (!label || !labellen)
1364     {
1365       label = (const unsigned char*)"";
1366       labellen = 0;
1367     }
1368
1369   /* Get the length of the digest.  */
1370   hlen = gcry_md_get_algo_dlen (algo);
1371
1372   /* Hash the label right away.  */
1373   lhash = gcry_malloc (hlen);
1374   if (!lhash)
1375     return gpg_err_code_from_syserror ();
1376   gcry_md_hash_buffer (algo, lhash, label, labellen);
1377
1378   /* Turn the MPI into an octet string.  If the octet string is
1379      shorter than the key we pad it to the left with zeroes.  This may
1380      happen due to the leading zero in OAEP frames and due to the
1381      following random octets (seed^mask) which may have leading zero
1382      bytes.  This all is needed to cope with our leading zeroes
1383      suppressing MPI implementation.  The code implictly implements
1384      Step 1b (bail out if NFRAME != N).  */
1385   rc = octet_string_from_mpi (&frame, NULL, value, nkey);
1386   if (rc)
1387     {
1388       gcry_free (lhash);
1389       return GPG_ERR_ENCODING_PROBLEM;
1390     }
1391   nframe = nkey;
1392
1393   /* Step 1c: Check that the key is long enough.  */
1394   if ( nframe < 2 * hlen + 2 )
1395     {
1396       gcry_free (frame);
1397       gcry_free (lhash);
1398       return GPG_ERR_ENCODING_PROBLEM;
1399     }
1400
1401   /* Step 2 has already been done by the caller and the
1402      gcry_mpi_aprint above.  */
1403
1404   /* Allocate space for SEED and DB.  */
1405   seed = gcry_malloc_secure (nframe - 1);
1406   if (!seed)
1407     {
1408       rc = gpg_err_code_from_syserror ();
1409       gcry_free (frame);
1410       gcry_free (lhash);
1411       return rc;
1412     }
1413   db = seed + hlen;
1414
1415   /* To avoid choosen ciphertext attacks from now on we make sure to
1416      run all code even in the error case; this avoids possible timing
1417      attacks as described by Manger.  */
1418
1419   /* Step 3a: Hash the label.  */
1420   /* This has already been done.  */
1421
1422   /* Step 3b: Separate the encoded message.  */
1423   masked_seed = frame + 1;
1424   masked_db   = frame + 1 + hlen;
1425   db_len      = nframe - 1 - hlen;
1426
1427   /* Step 3c and 3d: seed = maskedSeed ^ mgf(maskedDB, hlen).  */
1428   if (mgf1 (seed, hlen, masked_db, db_len, algo))
1429     failed = 1;
1430   for (n = 0; n < hlen; n++)
1431     seed[n] ^= masked_seed[n];
1432
1433   /* Step 3e and 3f: db = maskedDB ^ mgf(seed, db_len).  */
1434   if (mgf1 (db, db_len, seed, hlen, algo))
1435     failed = 1;
1436   for (n = 0; n < db_len; n++)
1437     db[n] ^= masked_db[n];
1438
1439   /* Step 3g: Check lhash, an possible empty padding string terminated
1440      by 0x01 and the first byte of EM being 0.  */
1441   if (memcmp (lhash, db, hlen))
1442     failed = 1;
1443   for (n = hlen; n < db_len; n++)
1444     if (db[n] == 0x01)
1445       break;
1446   if (n == db_len)
1447     failed = 1;
1448   if (frame[0])
1449     failed = 1;
1450
1451   gcry_free (lhash);
1452   gcry_free (frame);
1453   if (failed)
1454     {
1455       gcry_free (seed);
1456       return GPG_ERR_ENCODING_PROBLEM;
1457     }
1458
1459   /* Step 4: Output M.  */
1460   /* To avoid an extra allocation we reuse the seed buffer.  The only
1461      caller of this function will anyway free the result soon.  */
1462   n++;
1463   memmove (seed, db + n, db_len - n);
1464   *r_result = seed;
1465   *r_resultlen = db_len - n;
1466   seed = NULL;
1467
1468   if (DBG_CIPHER)
1469     log_printhex ("value extracted from OAEP encoded data",
1470                   *r_result, *r_resultlen);
1471
1472   return 0;
1473 }
1474
1475
1476 /* RFC-3447 (pkcs#1 v2.1) PSS encoding.  Encode {VALUE,VALUELEN} for
1477    an NBITS key.  Note that VALUE is already the mHash from the
1478    picture below.  ALGO is a valid hash algorithm and SALTLEN is the
1479    length of salt to be used.  On success the result is stored as a
1480    new MPI at R_RESULT.  On error the value at R_RESULT is undefined.
1481
1482    If {RANDOM_OVERRIDE, RANDOM_OVERRIDE_LEN} is given it is used as
1483    the salt instead of using a random string for the salt.  This
1484    feature is only useful for regression tests.
1485
1486    Here is figure 2 from the RFC (errata 595 applied) depicting the
1487    process:
1488
1489                                   +-----------+
1490                                   |     M     |
1491                                   +-----------+
1492                                         |
1493                                         V
1494                                       Hash
1495                                         |
1496                                         V
1497                           +--------+----------+----------+
1498                      M' = |Padding1|  mHash   |   salt   |
1499                           +--------+----------+----------+
1500                                          |
1501                +--------+----------+     V
1502          DB =  |Padding2| salt     |   Hash
1503                +--------+----------+     |
1504                          |               |
1505                          V               |    +----+
1506                         xor <--- MGF <---|    |0xbc|
1507                          |               |    +----+
1508                          |               |      |
1509                          V               V      V
1510                +-------------------+----------+----+
1511          EM =  |    maskedDB       |     H    |0xbc|
1512                +-------------------+----------+----+
1513
1514   */
1515 static gcry_err_code_t
1516 pss_encode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1517             const unsigned char *value, size_t valuelen, int saltlen,
1518             const void *random_override, size_t random_override_len)
1519 {
1520   gcry_err_code_t rc = 0;
1521   gcry_error_t err;
1522   size_t hlen;                 /* Length of the hash digest.  */
1523   unsigned char *em = NULL;    /* Encoded message.  */
1524   size_t emlen = (nbits+7)/8;  /* Length in bytes of EM.  */
1525   unsigned char *h;            /* Points into EM.  */
1526   unsigned char *buf = NULL;   /* Help buffer.  */
1527   size_t buflen;               /* Length of BUF.  */
1528   unsigned char *mhash;        /* Points into BUF.  */
1529   unsigned char *salt;         /* Points into BUF.  */
1530   unsigned char *dbmask;       /* Points into BUF.  */
1531   unsigned char *p;
1532   size_t n;
1533
1534   /* This code is implemented as described by rfc-3447 9.1.1.  */
1535
1536   /* Get the length of the digest.  */
1537   hlen = gcry_md_get_algo_dlen (algo);
1538   gcry_assert (hlen);  /* We expect a valid ALGO here.  */
1539
1540   /* Allocate a help buffer and setup some pointers.  */
1541   buflen = 8 + hlen + saltlen + (emlen - hlen - 1);
1542   buf = gcry_malloc (buflen);
1543   if (!buf)
1544     {
1545       rc = gpg_err_code_from_syserror ();
1546       goto leave;
1547     }
1548   mhash = buf + 8;
1549   salt  = mhash + hlen;
1550   dbmask= salt + saltlen;
1551
1552   /* Step 2: That would be: mHash = Hash(M) but our input is already
1553      mHash thus we do only a consistency check and copy to MHASH.  */
1554   if (valuelen != hlen)
1555     {
1556       rc = GPG_ERR_INV_LENGTH;
1557       goto leave;
1558     }
1559   memcpy (mhash, value, hlen);
1560
1561   /* Step 3: Check length constraints.  */
1562   if (emlen < hlen + saltlen + 2)
1563     {
1564       rc = GPG_ERR_TOO_SHORT;
1565       goto leave;
1566     }
1567
1568   /* Allocate space for EM.  */
1569   em = gcry_malloc (emlen);
1570   if (!em)
1571     {
1572       rc = gpg_err_code_from_syserror ();
1573       goto leave;
1574     }
1575   h = em + emlen - 1 - hlen;
1576
1577   /* Step 4: Create a salt.  */
1578   if (saltlen)
1579     {
1580       if (random_override)
1581         {
1582           if (random_override_len != saltlen)
1583             {
1584               rc = GPG_ERR_INV_ARG;
1585               goto leave;
1586             }
1587           memcpy (salt, random_override, saltlen);
1588         }
1589       else
1590         gcry_randomize (salt, saltlen, GCRY_STRONG_RANDOM);
1591     }
1592
1593   /* Step 5 and 6: M' = Hash(Padding1 || mHash || salt).  */
1594   memset (buf, 0, 8);  /* Padding.  */
1595   gcry_md_hash_buffer (algo, h, buf, 8 + hlen + saltlen);
1596
1597   /* Step 7 and 8: DB = PS || 0x01 || salt.  */
1598   /* Note that we use EM to store DB and later Xor in-place.  */
1599   p = em + emlen - 1 - hlen - saltlen - 1;
1600   memset (em, 0, p - em);
1601   *p++ = 0x01;
1602   memcpy (p, salt, saltlen);
1603
1604   /* Step 9: dbmask = MGF(H, emlen - hlen - 1).  */
1605   mgf1 (dbmask, emlen - hlen - 1, h, hlen, algo);
1606
1607   /* Step 10: maskedDB = DB ^ dbMask */
1608   for (n = 0, p = dbmask; n < emlen - hlen - 1; n++, p++)
1609     em[n] ^= *p;
1610
1611   /* Step 11: Set the leftmost bits to zero.  */
1612   em[0] &= 0xFF >> (8 * emlen - nbits);
1613
1614   /* Step 12: EM = maskedDB || H || 0xbc.  */
1615   em[emlen-1] = 0xbc;
1616
1617   /* Convert EM into an MPI.  */
1618   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, em, emlen, NULL);
1619   if (err)
1620     rc = gcry_err_code (err);
1621   else if (DBG_CIPHER)
1622     log_mpidump ("PSS encoded data", *r_result);
1623
1624  leave:
1625   if (em)
1626     {
1627       wipememory (em, emlen);
1628       gcry_free (em);
1629     }
1630   if (buf)
1631     {
1632       wipememory (buf, buflen);
1633       gcry_free (buf);
1634     }
1635   return rc;
1636 }
1637
1638
1639 /* Verify a signature assuming PSS padding.  VALUE is the hash of the
1640    message (mHash) encoded as an MPI; its length must match the digest
1641    length of ALGO.  ENCODED is the output of the RSA public key
1642    function (EM).  NBITS is the size of the public key.  ALGO is the
1643    hash algorithm and SALTLEN is the length of the used salt.  The
1644    function returns 0 on success or on error code.  */
1645 static gcry_err_code_t
1646 pss_verify (gcry_mpi_t value, gcry_mpi_t encoded, unsigned int nbits, int algo,
1647             size_t saltlen)
1648 {
1649   gcry_err_code_t rc = 0;
1650   size_t hlen;                 /* Length of the hash digest.  */
1651   unsigned char *em = NULL;    /* Encoded message.  */
1652   size_t emlen = (nbits+7)/8;  /* Length in bytes of EM.  */
1653   unsigned char *salt;         /* Points into EM.  */
1654   unsigned char *h;            /* Points into EM.  */
1655   unsigned char *buf = NULL;   /* Help buffer.  */
1656   size_t buflen;               /* Length of BUF.  */
1657   unsigned char *dbmask;       /* Points into BUF.  */
1658   unsigned char *mhash;        /* Points into BUF.  */
1659   unsigned char *p;
1660   size_t n;
1661
1662   /* This code is implemented as described by rfc-3447 9.1.2.  */
1663
1664   /* Get the length of the digest.  */
1665   hlen = gcry_md_get_algo_dlen (algo);
1666   gcry_assert (hlen);  /* We expect a valid ALGO here.  */
1667
1668   /* Allocate a help buffer and setup some pointers.
1669      This buffer is used for two purposes:
1670         +------------------------------+-------+
1671      1. | dbmask                       | mHash |
1672         +------------------------------+-------+
1673            emlen - hlen - 1              hlen
1674
1675         +----------+-------+---------+-+-------+
1676      2. | padding1 | mHash | salt    | | mHash |
1677         +----------+-------+---------+-+-------+
1678              8       hlen    saltlen     hlen
1679   */
1680   buflen = 8 + hlen + saltlen;
1681   if (buflen < emlen - hlen - 1)
1682     buflen = emlen - hlen - 1;
1683   buflen += hlen;
1684   buf = gcry_malloc (buflen);
1685   if (!buf)
1686     {
1687       rc = gpg_err_code_from_syserror ();
1688       goto leave;
1689     }
1690   dbmask = buf;
1691   mhash = buf + buflen - hlen;
1692
1693   /* Step 2: That would be: mHash = Hash(M) but our input is already
1694      mHash thus we only need to convert VALUE into MHASH.  */
1695   rc = octet_string_from_mpi (NULL, mhash, value, hlen);
1696   if (rc)
1697     goto leave;
1698
1699   /* Convert the signature into an octet string.  */
1700   rc = octet_string_from_mpi (&em, NULL, encoded, emlen);
1701   if (rc)
1702     goto leave;
1703
1704   /* Step 3: Check length of EM.  Because we internally use MPI
1705      functions we can't do this properly; EMLEN is always the length
1706      of the key because octet_string_from_mpi needs to left pad the
1707      result with zero to cope with the fact that our MPIs suppress all
1708      leading zeroes.  Thus what we test here are merely the digest and
1709      salt lengths to the key.  */
1710   if (emlen < hlen + saltlen + 2)
1711     {
1712       rc = GPG_ERR_TOO_SHORT; /* For the hash and saltlen.  */
1713       goto leave;
1714     }
1715
1716   /* Step 4: Check last octet.  */
1717   if (em[emlen - 1] != 0xbc)
1718     {
1719       rc = GPG_ERR_BAD_SIGNATURE;
1720       goto leave;
1721     }
1722
1723   /* Step 5: Split EM.  */
1724   h = em + emlen - 1 - hlen;
1725
1726   /* Step 6: Check the leftmost bits.  */
1727   if ((em[0] & ~(0xFF >> (8 * emlen - nbits))))
1728     {
1729       rc = GPG_ERR_BAD_SIGNATURE;
1730       goto leave;
1731     }
1732
1733   /* Step 7: dbmask = MGF(H, emlen - hlen - 1).  */
1734   mgf1 (dbmask, emlen - hlen - 1, h, hlen, algo);
1735
1736   /* Step 8: maskedDB = DB ^ dbMask.  */
1737   for (n = 0, p = dbmask; n < emlen - hlen - 1; n++, p++)
1738     em[n] ^= *p;
1739
1740   /* Step 9: Set leftmost bits in DB to zero.  */
1741   em[0] &= 0xFF >> (8 * emlen - nbits);
1742
1743   /* Step 10: Check the padding of DB.  */
1744   for (n = 0; n < emlen - hlen - saltlen - 2 && !em[n]; n++)
1745     ;
1746   if (n != emlen - hlen - saltlen - 2 || em[n++] != 1)
1747     {
1748       rc = GPG_ERR_BAD_SIGNATURE;
1749       goto leave;
1750     }
1751
1752   /* Step 11: Extract salt from DB.  */
1753   salt = em + n;
1754
1755   /* Step 12:  M' = (0x)00 00 00 00 00 00 00 00 || mHash || salt */
1756   memset (buf, 0, 8);
1757   memcpy (buf+8, mhash, hlen);
1758   memcpy (buf+8+hlen, salt, saltlen);
1759
1760   /* Step 13:  H' = Hash(M').  */
1761   gcry_md_hash_buffer (algo, buf, buf, 8 + hlen + saltlen);
1762
1763   /* Step 14:  Check H == H'.   */
1764   rc = memcmp (h, buf, hlen) ? GPG_ERR_BAD_SIGNATURE : GPG_ERR_NO_ERROR;
1765
1766  leave:
1767   if (em)
1768     {
1769       wipememory (em, emlen);
1770       gcry_free (em);
1771     }
1772   if (buf)
1773     {
1774       wipememory (buf, buflen);
1775       gcry_free (buf);
1776     }
1777   return rc;
1778 }
1779
1780
1781 /* Callback for the pubkey algorithm code to verify PSS signatures.
1782    OPAQUE is the data provided by the actual caller.  The meaning of
1783    TMP depends on the actual algorithm (but there is only RSA); now
1784    for RSA it is the output of running the public key function on the
1785    input.  */
1786 static int
1787 pss_verify_cmp (void *opaque, gcry_mpi_t tmp)
1788 {
1789   struct pk_encoding_ctx *ctx = opaque;
1790   gcry_mpi_t hash = ctx->verify_arg;
1791
1792   return pss_verify (hash, tmp, ctx->nbits - 1, ctx->hash_algo, ctx->saltlen);
1793 }
1794
1795
1796 /* Internal function.   */
1797 static gcry_err_code_t
1798 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
1799                        gcry_mpi_t *elements, const char *algo_name, int opaque)
1800 {
1801   gcry_err_code_t err = 0;
1802   int i, idx;
1803   const char *name;
1804   gcry_sexp_t list;
1805
1806   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1807     {
1808       list = gcry_sexp_find_token (key_sexp, name, 1);
1809       if (!list)
1810         elements[idx] = NULL;
1811       else if (opaque)
1812         {
1813           elements[idx] = _gcry_sexp_nth_opaque_mpi (list, 1);
1814           gcry_sexp_release (list);
1815           if (!elements[idx])
1816             err = GPG_ERR_INV_OBJ;
1817         }
1818       else
1819         {
1820           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
1821           gcry_sexp_release (list);
1822           if (!elements[idx])
1823             err = GPG_ERR_INV_OBJ;
1824         }
1825     }
1826
1827   if (!err)
1828     {
1829       /* Check that all elements are available.  */
1830       for (name = element_names, i = 0; *name; name++, i++)
1831         if (!elements[i])
1832           break;
1833       if (*name)
1834         {
1835           err = GPG_ERR_NO_OBJ;
1836           /* Some are missing.  Before bailing out we test for
1837              optional parameters.  */
1838           if (algo_name && !strcmp (algo_name, "RSA")
1839               && !strcmp (element_names, "nedpqu") )
1840             {
1841               /* This is RSA.  Test whether we got N, E and D and that
1842                  the optional P, Q and U are all missing.  */
1843               if (elements[0] && elements[1] && elements[2]
1844                   && !elements[3] && !elements[4] && !elements[5])
1845                 err = 0;
1846             }
1847         }
1848     }
1849
1850
1851   if (err)
1852     {
1853       for (i = 0; i < idx; i++)
1854         if (elements[i])
1855           mpi_free (elements[i]);
1856     }
1857   return err;
1858 }
1859
1860
1861 /* Internal function used for ecc.  Note, that this function makes use
1862    of its intimate knowledge about the ECC parameters from ecc.c. */
1863 static gcry_err_code_t
1864 sexp_elements_extract_ecc (gcry_sexp_t key_sexp, const char *element_names,
1865                            gcry_mpi_t *elements, gcry_pk_spec_t *spec,
1866                            int want_private)
1867
1868 {
1869   gcry_err_code_t err = 0;
1870   int idx;
1871   const char *name;
1872   gcry_sexp_t list;
1873
1874   /* Clear the array for easier error cleanup. */
1875   for (name = element_names, idx = 0; *name; name++, idx++)
1876     elements[idx] = NULL;
1877   gcry_assert (idx >= 5); /* We know that ECC has at least 5 elements
1878                              (params only) or 6 (full public key).  */
1879   if (idx == 5)
1880     elements[5] = NULL;   /* Extra clear for the params only case.  */
1881
1882
1883   /* Init the array with the available curve parameters. */
1884   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1885     {
1886       list = gcry_sexp_find_token (key_sexp, name, 1);
1887       if (!list)
1888         elements[idx] = NULL;
1889       else
1890         {
1891           switch (idx)
1892             {
1893             case 5: /* The public and */
1894             case 6: /* the secret key must to be passed opaque.  */
1895               elements[idx] = _gcry_sexp_nth_opaque_mpi (list, 1);
1896               break;
1897             default:
1898               elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_STD);
1899               break;
1900             }
1901           gcry_sexp_release (list);
1902           if (!elements[idx])
1903             {
1904               err = GPG_ERR_INV_OBJ;
1905               goto leave;
1906             }
1907         }
1908     }
1909
1910   /* Check whether a curve parameter has been given and then fill any
1911      missing elements.  */
1912   list = gcry_sexp_find_token (key_sexp, "curve", 5);
1913   if (list)
1914     {
1915       if (spec->get_param)
1916         {
1917           char *curve;
1918           gcry_mpi_t params[6];
1919
1920           for (idx = 0; idx < DIM(params); idx++)
1921             params[idx] = NULL;
1922
1923           curve = _gcry_sexp_nth_string (list, 1);
1924           gcry_sexp_release (list);
1925           if (!curve)
1926             {
1927               /* No curve name given (or out of core). */
1928               err = GPG_ERR_INV_OBJ;
1929               goto leave;
1930             }
1931           err = spec->get_param (curve, params);
1932           gcry_free (curve);
1933           if (err)
1934             goto leave;
1935
1936           for (idx = 0; idx < DIM(params); idx++)
1937             {
1938               if (!elements[idx])
1939                 elements[idx] = params[idx];
1940               else
1941                 mpi_free (params[idx]);
1942             }
1943         }
1944       else
1945         {
1946           gcry_sexp_release (list);
1947           err = GPG_ERR_INV_OBJ; /* "curve" given but ECC not supported. */
1948           goto leave;
1949         }
1950     }
1951
1952   /* Check that all parameters are known.  */
1953   for (name = element_names, idx = 0; *name; name++, idx++)
1954     if (!elements[idx])
1955       {
1956         if (want_private && *name == 'q')
1957           ; /* Q is optional.  */
1958         else
1959           {
1960             err = GPG_ERR_NO_OBJ;
1961             goto leave;
1962           }
1963       }
1964
1965  leave:
1966   if (err)
1967     {
1968       for (name = element_names, idx = 0; *name; name++, idx++)
1969         if (elements[idx])
1970           mpi_free (elements[idx]);
1971     }
1972   return err;
1973 }
1974
1975
1976
1977 /****************
1978  * Convert a S-Exp with either a private or a public key to our
1979  * internal format. Currently we do only support the following
1980  * algorithms:
1981  *    dsa
1982  *    rsa
1983  *    openpgp-dsa
1984  *    openpgp-rsa
1985  *    openpgp-elg
1986  *    openpgp-elg-sig
1987  *    ecdsa
1988  *    ecdh
1989  * Provide a SE with the first element be either "private-key" or
1990  * or "public-key". It is followed by a list with its first element
1991  * be one of the above algorithm identifiers and the remaning
1992  * elements are pairs with parameter-id and value.
1993  * NOTE: we look through the list to find a list beginning with
1994  * "private-key" or "public-key" - the first one found is used.
1995  *
1996  * If OVERRIDE_ELEMS is not NULL those elems override the parameter
1997  * specification taken from the module.  This ise used by
1998  * gcry_pk_get_curve.
1999  *
2000  * Returns: A pointer to an allocated array of MPIs if the return value is
2001  *          zero; the caller has to release this array.
2002  *
2003  * Example of a DSA public key:
2004  *  (private-key
2005  *    (dsa
2006  *      (p <mpi>)
2007  *      (g <mpi>)
2008  *      (y <mpi>)
2009  *      (x <mpi>)
2010  *    )
2011  *  )
2012  * The <mpi> are expected to be in GCRYMPI_FMT_USG
2013  */
2014 static gcry_err_code_t
2015 sexp_to_key (gcry_sexp_t sexp, int want_private, int use,
2016              const char *override_elems,
2017              gcry_mpi_t **retarray, gcry_module_t *retalgo, int *r_is_ecc)
2018 {
2019   gcry_err_code_t err = 0;
2020   gcry_sexp_t list, l2;
2021   char *name;
2022   const char *elems;
2023   gcry_mpi_t *array;
2024   gcry_module_t module;
2025   gcry_pk_spec_t *pubkey;
2026   int is_ecc;
2027
2028   /* Check that the first element is valid.  If we are looking for a
2029      public key but a private key was supplied, we allow the use of
2030      the private key anyway.  The rationale for this is that the
2031      private key is a superset of the public key. */
2032   list = gcry_sexp_find_token (sexp,
2033                                want_private? "private-key":"public-key", 0);
2034   if (!list && !want_private)
2035     list = gcry_sexp_find_token (sexp, "private-key", 0);
2036   if (!list)
2037     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
2038
2039   l2 = gcry_sexp_cadr( list );
2040   gcry_sexp_release ( list );
2041   list = l2;
2042   name = _gcry_sexp_nth_string (list, 0);
2043   if (!name)
2044     {
2045       gcry_sexp_release ( list );
2046       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
2047     }
2048
2049   /* Fixme: We should make sure that an ECC key is always named "ecc"
2050      and not "ecdsa".  "ecdsa" should be used for the signature
2051      itself.  We need a function to test whether an algorithm given
2052      with a key is compatible with an application of the key (signing,
2053      encryption).  For RSA this is easy, but ECC is the first
2054      algorithm which has many flavours.
2055
2056      We use an ugly hack here to decide whether to use ecdsa or ecdh.
2057   */
2058   if (!strcmp (name, "ecc"))
2059     is_ecc = 2;
2060   else if (!strcmp (name, "ecdsa") || !strcmp (name, "ecdh"))
2061     is_ecc = 1;
2062   else
2063     is_ecc = 0;
2064
2065   ath_mutex_lock (&pubkeys_registered_lock);
2066   if (is_ecc == 2 && (use & GCRY_PK_USAGE_SIGN))
2067     module = gcry_pk_lookup_name ("ecdsa");
2068   else if (is_ecc == 2 && (use & GCRY_PK_USAGE_ENCR))
2069     module = gcry_pk_lookup_name ("ecdh");
2070   else
2071     module = gcry_pk_lookup_name (name);
2072   ath_mutex_unlock (&pubkeys_registered_lock);
2073
2074   gcry_free (name);
2075
2076   if (!module)
2077     {
2078       gcry_sexp_release (list);
2079       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
2080     }
2081   else
2082     {
2083       pubkey = (gcry_pk_spec_t *) module->spec;
2084     }
2085
2086   if (override_elems)
2087     elems = override_elems;
2088   else if (want_private)
2089     elems = pubkey->elements_skey;
2090   else
2091     elems = pubkey->elements_pkey;
2092   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
2093   if (!array)
2094     err = gpg_err_code_from_syserror ();
2095   if (!err)
2096     {
2097       if (is_ecc)
2098         err = sexp_elements_extract_ecc (list, elems, array, pubkey,
2099                                          want_private);
2100       else
2101         err = sexp_elements_extract (list, elems, array, pubkey->name, 0);
2102     }
2103
2104   gcry_sexp_release (list);
2105
2106   if (err)
2107     {
2108       gcry_free (array);
2109
2110       ath_mutex_lock (&pubkeys_registered_lock);
2111       _gcry_module_release (module);
2112       ath_mutex_unlock (&pubkeys_registered_lock);
2113     }
2114   else
2115     {
2116       *retarray = array;
2117       *retalgo = module;
2118       if (r_is_ecc)
2119         *r_is_ecc = is_ecc;
2120     }
2121
2122   return err;
2123 }
2124
2125
2126 /* Parse SEXP and store the elements into a newly allocated array of
2127    MPIs which will be stored at RETARRAY.  If OPAQUE is set, store the
2128    MPI as opaque data.  */
2129 static gcry_err_code_t
2130 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
2131              gcry_module_t *retalgo, int opaque)
2132 {
2133   gcry_err_code_t err = 0;
2134   gcry_sexp_t list, l2;
2135   char *name;
2136   const char *elems;
2137   gcry_mpi_t *array;
2138   gcry_module_t module;
2139   gcry_pk_spec_t *pubkey;
2140
2141   /* Check that the first element is valid.  */
2142   list = gcry_sexp_find_token( sexp, "sig-val" , 0 );
2143   if (!list)
2144     return GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
2145
2146   l2 = gcry_sexp_nth (list, 1);
2147   if (!l2)
2148     {
2149       gcry_sexp_release (list);
2150       return GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
2151     }
2152   name = _gcry_sexp_nth_string (l2, 0);
2153   if (!name)
2154     {
2155       gcry_sexp_release (list);
2156       gcry_sexp_release (l2);
2157       return GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
2158     }
2159   else if (!strcmp (name, "flags"))
2160     {
2161       /* Skip flags, since they are not used but here just for the
2162          sake of consistent S-expressions.  */
2163       gcry_free (name);
2164       gcry_sexp_release (l2);
2165       l2 = gcry_sexp_nth (list, 2);
2166       if (!l2)
2167         {
2168           gcry_sexp_release (list);
2169           return GPG_ERR_INV_OBJ;
2170         }
2171       name = _gcry_sexp_nth_string (l2, 0);
2172     }
2173
2174   ath_mutex_lock (&pubkeys_registered_lock);
2175   module = gcry_pk_lookup_name (name);
2176   ath_mutex_unlock (&pubkeys_registered_lock);
2177   gcry_free (name);
2178   name = NULL;
2179
2180   if (!module)
2181     {
2182       gcry_sexp_release (l2);
2183       gcry_sexp_release (list);
2184       return GPG_ERR_PUBKEY_ALGO;  /* Unknown algorithm. */
2185     }
2186   else
2187     pubkey = (gcry_pk_spec_t *) module->spec;
2188
2189   elems = pubkey->elements_sig;
2190   array = gcry_calloc (strlen (elems) + 1 , sizeof *array );
2191   if (!array)
2192     err = gpg_err_code_from_syserror ();
2193
2194   if (!err)
2195     err = sexp_elements_extract (list, elems, array, NULL, opaque);
2196
2197   gcry_sexp_release (l2);
2198   gcry_sexp_release (list);
2199
2200   if (err)
2201     {
2202       ath_mutex_lock (&pubkeys_registered_lock);
2203       _gcry_module_release (module);
2204       ath_mutex_unlock (&pubkeys_registered_lock);
2205
2206       gcry_free (array);
2207     }
2208   else
2209     {
2210       *retarray = array;
2211       *retalgo = module;
2212     }
2213
2214   return err;
2215 }
2216
2217 static inline int
2218 get_hash_algo (const char *s, size_t n)
2219 {
2220   static const struct { const char *name; int algo; } hashnames[] = {
2221     { "sha1",   GCRY_MD_SHA1 },
2222     { "md5",    GCRY_MD_MD5 },
2223     { "sha256", GCRY_MD_SHA256 },
2224     { "ripemd160", GCRY_MD_RMD160 },
2225     { "rmd160", GCRY_MD_RMD160 },
2226     { "sha384", GCRY_MD_SHA384 },
2227     { "sha512", GCRY_MD_SHA512 },
2228     { "sha224", GCRY_MD_SHA224 },
2229     { "md2",    GCRY_MD_MD2 },
2230     { "md4",    GCRY_MD_MD4 },
2231     { "tiger",  GCRY_MD_TIGER },
2232     { "haval",  GCRY_MD_HAVAL },
2233     { NULL, 0 }
2234   };
2235   int algo;
2236   int i;
2237
2238   for (i=0; hashnames[i].name; i++)
2239     {
2240       if ( strlen (hashnames[i].name) == n
2241            && !memcmp (hashnames[i].name, s, n))
2242         break;
2243     }
2244   if (hashnames[i].name)
2245     algo = hashnames[i].algo;
2246   else
2247     {
2248       /* In case of not listed or dynamically allocated hash
2249          algorithm we fall back to this somewhat slower
2250          method.  Further, it also allows to use OIDs as
2251          algorithm names. */
2252       char *tmpname;
2253
2254       tmpname = gcry_malloc (n+1);
2255       if (!tmpname)
2256         algo = 0;  /* Out of core - silently give up.  */
2257       else
2258         {
2259           memcpy (tmpname, s, n);
2260           tmpname[n] = 0;
2261           algo = gcry_md_map_name (tmpname);
2262           gcry_free (tmpname);
2263         }
2264     }
2265   return algo;
2266 }
2267
2268
2269 /****************
2270  * Take sexp and return an array of MPI as used for our internal decrypt
2271  * function.
2272  * s_data = (enc-val
2273  *           [(flags [raw, pkcs1, oaep, no-blinding])]
2274  *           [(hash-algo <algo>)]
2275  *           [(label <label>)]
2276  *            (<algo>
2277  *              (<param_name1> <mpi>)
2278  *              ...
2279  *              (<param_namen> <mpi>)
2280  *            ))
2281  * HASH-ALGO and LABEL are specific to OAEP.
2282  * RET_MODERN is set to true when at least an empty flags list has been found.
2283  * CTX is used to return encoding information; it may be NULL in which
2284  * case raw encoding is used.
2285  */
2286 static gcry_err_code_t
2287 sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
2288              int *ret_modern, int *flags, struct pk_encoding_ctx *ctx)
2289 {
2290   gcry_err_code_t err = 0;
2291   gcry_sexp_t list = NULL, l2 = NULL;
2292   gcry_pk_spec_t *pubkey = NULL;
2293   gcry_module_t module = NULL;
2294   char *name = NULL;
2295   size_t n;
2296   int parsed_flags = 0;
2297   const char *elems;
2298   gcry_mpi_t *array = NULL;
2299
2300   *ret_modern = 0;
2301
2302   /* Check that the first element is valid.  */
2303   list = gcry_sexp_find_token (sexp, "enc-val" , 0);
2304   if (!list)
2305     {
2306       err = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
2307       goto leave;
2308     }
2309
2310   l2 = gcry_sexp_nth (list, 1);
2311   if (!l2)
2312     {
2313       err = GPG_ERR_NO_OBJ; /* No cdr for the data object.  */
2314       goto leave;
2315     }
2316
2317   /* Extract identifier of sublist.  */
2318   name = _gcry_sexp_nth_string (l2, 0);
2319   if (!name)
2320     {
2321       err = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
2322       goto leave;
2323     }
2324
2325   if (!strcmp (name, "flags"))
2326     {
2327       /* There is a flags element - process it.  */
2328       const char *s;
2329       int i;
2330
2331       *ret_modern = 1;
2332       for (i = gcry_sexp_length (l2) - 1; i > 0; i--)
2333         {
2334           s = gcry_sexp_nth_data (l2, i, &n);
2335           if (! s)
2336             ; /* Not a data element - ignore.  */
2337           else if (n == 3 && !memcmp (s, "raw", 3)
2338                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2339             ctx->encoding = PUBKEY_ENC_RAW;
2340           else if (n == 5 && !memcmp (s, "pkcs1", 5)
2341                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2342             ctx->encoding = PUBKEY_ENC_PKCS1;
2343           else if (n == 4 && !memcmp (s, "oaep", 4)
2344                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2345             ctx->encoding = PUBKEY_ENC_OAEP;
2346           else if (n == 3 && !memcmp (s, "pss", 3)
2347                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2348             {
2349               err = GPG_ERR_CONFLICT;
2350               goto leave;
2351             }
2352           else if (n == 11 && ! memcmp (s, "no-blinding", 11))
2353             parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
2354           else
2355             {
2356               err = GPG_ERR_INV_FLAG;
2357               goto leave;
2358             }
2359         }
2360       gcry_sexp_release (l2);
2361
2362       /* Get the OAEP parameters HASH-ALGO and LABEL, if any. */
2363       if (ctx->encoding == PUBKEY_ENC_OAEP)
2364         {
2365           /* Get HASH-ALGO. */
2366           l2 = gcry_sexp_find_token (list, "hash-algo", 0);
2367           if (l2)
2368             {
2369               s = gcry_sexp_nth_data (l2, 1, &n);
2370               if (!s)
2371                 err = GPG_ERR_NO_OBJ;
2372               else
2373                 {
2374                   ctx->hash_algo = get_hash_algo (s, n);
2375                   if (!ctx->hash_algo)
2376                     err = GPG_ERR_DIGEST_ALGO;
2377                 }
2378               gcry_sexp_release (l2);
2379               if (err)
2380                 goto leave;
2381             }
2382
2383           /* Get LABEL. */
2384           l2 = gcry_sexp_find_token (list, "label", 0);
2385           if (l2)
2386             {
2387               s = gcry_sexp_nth_data (l2, 1, &n);
2388               if (!s)
2389                 err = GPG_ERR_NO_OBJ;
2390               else if (n > 0)
2391                 {
2392                   ctx->label = gcry_malloc (n);
2393                   if (!ctx->label)
2394                     err = gpg_err_code_from_syserror ();
2395                   else
2396                     {
2397                       memcpy (ctx->label, s, n);
2398                       ctx->labellen = n;
2399                     }
2400                 }
2401               gcry_sexp_release (l2);
2402               if (err)
2403                 goto leave;
2404             }
2405         }
2406
2407       /* Get the next which has the actual data - skip HASH-ALGO and LABEL. */
2408       for (i = 2; (l2 = gcry_sexp_nth (list, i)) != NULL; i++)
2409         {
2410           s = gcry_sexp_nth_data (l2, 0, &n);
2411           if (!(n == 9 && !memcmp (s, "hash-algo", 9))
2412               && !(n == 5 && !memcmp (s, "label", 5))
2413               && !(n == 15 && !memcmp (s, "random-override", 15)))
2414             break;
2415           gcry_sexp_release (l2);
2416         }
2417
2418       if (!l2)
2419         {
2420           err = GPG_ERR_NO_OBJ; /* No cdr for the data object. */
2421           goto leave;
2422         }
2423
2424       /* Extract sublist identifier.  */
2425       gcry_free (name);
2426       name = _gcry_sexp_nth_string (l2, 0);
2427       if (!name)
2428         {
2429           err = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
2430           goto leave;
2431         }
2432
2433       gcry_sexp_release (list);
2434       list = l2;
2435       l2 = NULL;
2436     }
2437
2438   ath_mutex_lock (&pubkeys_registered_lock);
2439   module = gcry_pk_lookup_name (name);
2440   ath_mutex_unlock (&pubkeys_registered_lock);
2441
2442   if (!module)
2443     {
2444       err = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
2445       goto leave;
2446     }
2447   pubkey = (gcry_pk_spec_t *) module->spec;
2448
2449   elems = pubkey->elements_enc;
2450   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
2451   if (!array)
2452     {
2453       err = gpg_err_code_from_syserror ();
2454       goto leave;
2455     }
2456
2457   err = sexp_elements_extract (list, elems, array, NULL, 0);
2458
2459  leave:
2460   gcry_sexp_release (list);
2461   gcry_sexp_release (l2);
2462   gcry_free (name);
2463
2464   if (err)
2465     {
2466       ath_mutex_lock (&pubkeys_registered_lock);
2467       _gcry_module_release (module);
2468       ath_mutex_unlock (&pubkeys_registered_lock);
2469       gcry_free (array);
2470       gcry_free (ctx->label);
2471       ctx->label = NULL;
2472     }
2473   else
2474     {
2475       *retarray = array;
2476       *retalgo = module;
2477       *flags = parsed_flags;
2478     }
2479
2480   return err;
2481 }
2482
2483 /* Take the hash value and convert into an MPI, suitable for
2484    passing to the low level functions.  We currently support the
2485    old style way of passing just a MPI and the modern interface which
2486    allows to pass flags so that we can choose between raw and pkcs1
2487    padding - may be more padding options later.
2488
2489    (<mpi>)
2490    or
2491    (data
2492     [(flags [raw, direct, pkcs1, oaep, pss, no-blinding, rfc6979, eddsa])]
2493     [(hash <algo> <value>)]
2494     [(value <text>)]
2495     [(hash-algo <algo>)]
2496     [(label <label>)]
2497     [(salt-length <length>)]
2498     [(random-override <data>)]
2499    )
2500
2501    Either the VALUE or the HASH element must be present for use
2502    with signatures.  VALUE is used for encryption.
2503
2504    HASH-ALGO is specific to OAEP and EDDSA.
2505
2506    LABEL is specific to OAEP.
2507
2508    SALT-LENGTH is for PSS.
2509
2510    RANDOM-OVERRIDE is used to replace random nonces for regression
2511    testing.  */
2512 static gcry_err_code_t
2513 sexp_data_to_mpi (gcry_sexp_t input, gcry_mpi_t *ret_mpi,
2514                   struct pk_encoding_ctx *ctx)
2515 {
2516   gcry_err_code_t rc = 0;
2517   gcry_sexp_t ldata, lhash, lvalue;
2518   int i;
2519   size_t n;
2520   const char *s;
2521   int unknown_flag = 0;
2522   int parsed_flags = 0;
2523   int explicit_raw = 0;
2524
2525   *ret_mpi = NULL;
2526   ldata = gcry_sexp_find_token (input, "data", 0);
2527   if (!ldata)
2528     { /* assume old style */
2529       *ret_mpi = gcry_sexp_nth_mpi (input, 0, 0);
2530       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
2531     }
2532
2533   /* see whether there is a flags object */
2534   {
2535     gcry_sexp_t lflags = gcry_sexp_find_token (ldata, "flags", 0);
2536     if (lflags)
2537       { /* parse the flags list. */
2538         for (i=gcry_sexp_length (lflags)-1; i > 0; i--)
2539           {
2540             s = gcry_sexp_nth_data (lflags, i, &n);
2541             if (!s)
2542               ; /* not a data element*/
2543             else if (n == 7 && !memcmp (s, "rfc6979", 7))
2544               parsed_flags |= PUBKEY_FLAG_RFC6979;
2545             else if (n == 5 && !memcmp (s, "eddsa", 5))
2546               {
2547                 ctx->encoding = PUBKEY_ENC_RAW;
2548                 parsed_flags |= PUBKEY_FLAG_EDDSA;
2549               }
2550             else if ( n == 3 && !memcmp (s, "raw", 3)
2551                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2552               {
2553                 ctx->encoding = PUBKEY_ENC_RAW;
2554                 explicit_raw = 1;
2555               }
2556             else if ( n == 5 && !memcmp (s, "pkcs1", 5)
2557                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2558               ctx->encoding = PUBKEY_ENC_PKCS1;
2559             else if ( n == 4 && !memcmp (s, "oaep", 4)
2560                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2561               ctx->encoding = PUBKEY_ENC_OAEP;
2562             else if ( n == 3 && !memcmp (s, "pss", 3)
2563                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2564               ctx->encoding = PUBKEY_ENC_PSS;
2565             else if (n == 11 && ! memcmp (s, "no-blinding", 11))
2566               parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
2567             else
2568               unknown_flag = 1;
2569           }
2570         gcry_sexp_release (lflags);
2571       }
2572   }
2573
2574   if (ctx->encoding == PUBKEY_ENC_UNKNOWN)
2575     ctx->encoding = PUBKEY_ENC_RAW; /* default to raw */
2576
2577   /* Get HASH or MPI */
2578   lhash = gcry_sexp_find_token (ldata, "hash", 0);
2579   lvalue = lhash? NULL : gcry_sexp_find_token (ldata, "value", 0);
2580
2581   if (!(!lhash ^ !lvalue))
2582     rc = GPG_ERR_INV_OBJ; /* none or both given */
2583   else if (unknown_flag)
2584     rc = GPG_ERR_INV_FLAG;
2585   else if (ctx->encoding == PUBKEY_ENC_RAW
2586            && (parsed_flags & PUBKEY_FLAG_EDDSA))
2587     {
2588       /* Prepare for EdDSA.  */
2589       gcry_sexp_t list;
2590       void *value;
2591       size_t valuelen;
2592
2593       if (!lvalue)
2594         {
2595           rc = GPG_ERR_INV_OBJ;
2596           goto leave;
2597         }
2598       /* Get HASH-ALGO. */
2599       list = gcry_sexp_find_token (ldata, "hash-algo", 0);
2600       if (list)
2601         {
2602           s = gcry_sexp_nth_data (list, 1, &n);
2603           if (!s)
2604             rc = GPG_ERR_NO_OBJ;
2605           else
2606             {
2607               ctx->hash_algo = get_hash_algo (s, n);
2608               if (!ctx->hash_algo)
2609                 rc = GPG_ERR_DIGEST_ALGO;
2610             }
2611           gcry_sexp_release (list);
2612         }
2613       else
2614         rc = GPG_ERR_INV_OBJ;
2615       if (rc)
2616         goto leave;
2617
2618       /* Get VALUE.  */
2619       value = gcry_sexp_nth_buffer (lvalue, 1, &valuelen);
2620       if (!value)
2621         {
2622           /* We assume that a zero length message is meant by
2623              "(value)".  This is commonly used by test vectors.  Note
2624              that S-expression do not allow zero length items. */
2625           valuelen = 0;
2626           value = gcry_malloc (1);
2627           if (!value)
2628             rc = gpg_err_code_from_syserror ();
2629         }
2630       else if ((valuelen * 8) < valuelen)
2631         {
2632           gcry_free (value);
2633           rc = GPG_ERR_TOO_LARGE;
2634         }
2635       if (rc)
2636         goto leave;
2637
2638       /* Note that mpi_set_opaque takes ownership of VALUE.  */
2639       *ret_mpi = gcry_mpi_set_opaque (NULL, value, valuelen*8);
2640     }
2641   else if (ctx->encoding == PUBKEY_ENC_RAW && lhash
2642            && (explicit_raw || (parsed_flags & PUBKEY_FLAG_RFC6979)))
2643     {
2644       /* Raw encoding along with a hash element.  This is commonly
2645          used for DSA.  For better backward error compatibility we
2646          allow this only if either the rfc6979 flag has been given or
2647          the raw flags was explicitly given.  */
2648       if (gcry_sexp_length (lhash) != 3)
2649         rc = GPG_ERR_INV_OBJ;
2650       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2651         rc = GPG_ERR_INV_OBJ;
2652       else
2653         {
2654           void *value;
2655           size_t valuelen;
2656
2657           ctx->hash_algo = get_hash_algo (s, n);
2658           if (!ctx->hash_algo)
2659             rc = GPG_ERR_DIGEST_ALGO;
2660           else if (!(value=gcry_sexp_nth_buffer (lhash, 2, &valuelen)))
2661             rc = GPG_ERR_INV_OBJ;
2662           else if ((valuelen * 8) < valuelen)
2663             {
2664               gcry_free (value);
2665               rc = GPG_ERR_TOO_LARGE;
2666             }
2667           else
2668             *ret_mpi = gcry_mpi_set_opaque (NULL, value, valuelen*8);
2669         }
2670     }
2671   else if (ctx->encoding == PUBKEY_ENC_RAW && lvalue)
2672     {
2673       /* RFC6969 may only be used with the a hash value and not the
2674          MPI based value.  */
2675       if (parsed_flags & PUBKEY_FLAG_RFC6979)
2676         {
2677           rc = GPG_ERR_CONFLICT;
2678           goto leave;
2679         }
2680
2681       /* Get the value */
2682       *ret_mpi = gcry_sexp_nth_mpi (lvalue, 1, GCRYMPI_FMT_USG);
2683       if (!*ret_mpi)
2684         rc = GPG_ERR_INV_OBJ;
2685     }
2686   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lvalue
2687            && ctx->op == PUBKEY_OP_ENCRYPT)
2688     {
2689       const void * value;
2690       size_t valuelen;
2691       gcry_sexp_t list;
2692       void *random_override = NULL;
2693       size_t random_override_len = 0;
2694
2695       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
2696         rc = GPG_ERR_INV_OBJ;
2697       else
2698         {
2699           /* Get optional RANDOM-OVERRIDE.  */
2700           list = gcry_sexp_find_token (ldata, "random-override", 0);
2701           if (list)
2702             {
2703               s = gcry_sexp_nth_data (list, 1, &n);
2704               if (!s)
2705                 rc = GPG_ERR_NO_OBJ;
2706               else if (n > 0)
2707                 {
2708                   random_override = gcry_malloc (n);
2709                   if (!random_override)
2710                     rc = gpg_err_code_from_syserror ();
2711                   else
2712                     {
2713                       memcpy (random_override, s, n);
2714                       random_override_len = n;
2715                     }
2716                 }
2717               gcry_sexp_release (list);
2718               if (rc)
2719                 goto leave;
2720             }
2721
2722           rc = pkcs1_encode_for_encryption (ret_mpi, ctx->nbits,
2723                                             value, valuelen,
2724                                             random_override,
2725                                             random_override_len);
2726           gcry_free (random_override);
2727         }
2728     }
2729   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lhash
2730            && (ctx->op == PUBKEY_OP_SIGN || ctx->op == PUBKEY_OP_VERIFY))
2731     {
2732       if (gcry_sexp_length (lhash) != 3)
2733         rc = GPG_ERR_INV_OBJ;
2734       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2735         rc = GPG_ERR_INV_OBJ;
2736       else
2737         {
2738           const void * value;
2739           size_t valuelen;
2740
2741           ctx->hash_algo = get_hash_algo (s, n);
2742
2743           if (!ctx->hash_algo)
2744             rc = GPG_ERR_DIGEST_ALGO;
2745           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
2746                     || !valuelen )
2747             rc = GPG_ERR_INV_OBJ;
2748           else
2749             rc = pkcs1_encode_for_signature (ret_mpi, ctx->nbits,
2750                                              value, valuelen,
2751                                              ctx->hash_algo);
2752         }
2753     }
2754   else if (ctx->encoding == PUBKEY_ENC_OAEP && lvalue
2755            && ctx->op == PUBKEY_OP_ENCRYPT)
2756     {
2757       const void * value;
2758       size_t valuelen;
2759
2760       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
2761         rc = GPG_ERR_INV_OBJ;
2762       else
2763         {
2764           gcry_sexp_t list;
2765           void *random_override = NULL;
2766           size_t random_override_len = 0;
2767
2768           /* Get HASH-ALGO. */
2769           list = gcry_sexp_find_token (ldata, "hash-algo", 0);
2770           if (list)
2771             {
2772               s = gcry_sexp_nth_data (list, 1, &n);
2773               if (!s)
2774                 rc = GPG_ERR_NO_OBJ;
2775               else
2776                 {
2777                   ctx->hash_algo = get_hash_algo (s, n);
2778                   if (!ctx->hash_algo)
2779                     rc = GPG_ERR_DIGEST_ALGO;
2780                 }
2781               gcry_sexp_release (list);
2782               if (rc)
2783                 goto leave;
2784             }
2785
2786           /* Get LABEL. */
2787           list = gcry_sexp_find_token (ldata, "label", 0);
2788           if (list)
2789             {
2790               s = gcry_sexp_nth_data (list, 1, &n);
2791               if (!s)
2792                 rc = GPG_ERR_NO_OBJ;
2793               else if (n > 0)
2794                 {
2795                   ctx->label = gcry_malloc (n);
2796                   if (!ctx->label)
2797                     rc = gpg_err_code_from_syserror ();
2798                   else
2799                     {
2800                       memcpy (ctx->label, s, n);
2801                       ctx->labellen = n;
2802                     }
2803                 }
2804               gcry_sexp_release (list);
2805               if (rc)
2806                 goto leave;
2807             }
2808           /* Get optional RANDOM-OVERRIDE.  */
2809           list = gcry_sexp_find_token (ldata, "random-override", 0);
2810           if (list)
2811             {
2812               s = gcry_sexp_nth_data (list, 1, &n);
2813               if (!s)
2814                 rc = GPG_ERR_NO_OBJ;
2815               else if (n > 0)
2816                 {
2817                   random_override = gcry_malloc (n);
2818                   if (!random_override)
2819                     rc = gpg_err_code_from_syserror ();
2820                   else
2821                     {
2822                       memcpy (random_override, s, n);
2823                       random_override_len = n;
2824                     }
2825                 }
2826               gcry_sexp_release (list);
2827               if (rc)
2828                 goto leave;
2829             }
2830
2831           rc = oaep_encode (ret_mpi, ctx->nbits, ctx->hash_algo,
2832                             value, valuelen,
2833                             ctx->label, ctx->labellen,
2834                             random_override, random_override_len);
2835
2836           gcry_free (random_override);
2837         }
2838     }
2839   else if (ctx->encoding == PUBKEY_ENC_PSS && lhash
2840            && ctx->op == PUBKEY_OP_SIGN)
2841     {
2842       if (gcry_sexp_length (lhash) != 3)
2843         rc = GPG_ERR_INV_OBJ;
2844       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2845         rc = GPG_ERR_INV_OBJ;
2846       else
2847         {
2848           const void * value;
2849           size_t valuelen;
2850           void *random_override = NULL;
2851           size_t random_override_len = 0;
2852
2853           ctx->hash_algo = get_hash_algo (s, n);
2854
2855           if (!ctx->hash_algo)
2856             rc = GPG_ERR_DIGEST_ALGO;
2857           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
2858                     || !valuelen )
2859             rc = GPG_ERR_INV_OBJ;
2860           else
2861             {
2862               gcry_sexp_t list;
2863
2864               /* Get SALT-LENGTH. */
2865               list = gcry_sexp_find_token (ldata, "salt-length", 0);
2866               if (list)
2867                 {
2868                   s = gcry_sexp_nth_data (list, 1, &n);
2869                   if (!s)
2870                     {
2871                       rc = GPG_ERR_NO_OBJ;
2872                       goto leave;
2873                     }
2874                   ctx->saltlen = (unsigned int)strtoul (s, NULL, 10);
2875                   gcry_sexp_release (list);
2876                 }
2877
2878               /* Get optional RANDOM-OVERRIDE.  */
2879               list = gcry_sexp_find_token (ldata, "random-override", 0);
2880               if (list)
2881                 {
2882                   s = gcry_sexp_nth_data (list, 1, &n);
2883                   if (!s)
2884                     rc = GPG_ERR_NO_OBJ;
2885                   else if (n > 0)
2886                     {
2887                       random_override = gcry_malloc (n);
2888                       if (!random_override)
2889                         rc = gpg_err_code_from_syserror ();
2890                       else
2891                         {
2892                           memcpy (random_override, s, n);
2893                           random_override_len = n;
2894                         }
2895                     }
2896                   gcry_sexp_release (list);
2897                   if (rc)
2898                     goto leave;
2899                 }
2900
2901               /* Encode the data.  (NBITS-1 is due to 8.1.1, step 1.) */
2902               rc = pss_encode (ret_mpi, ctx->nbits - 1, ctx->hash_algo,
2903                                value, valuelen, ctx->saltlen,
2904                                random_override, random_override_len);
2905
2906               gcry_free (random_override);
2907             }
2908         }
2909     }
2910   else if (ctx->encoding == PUBKEY_ENC_PSS && lhash
2911            && ctx->op == PUBKEY_OP_VERIFY)
2912     {
2913       if (gcry_sexp_length (lhash) != 3)
2914         rc = GPG_ERR_INV_OBJ;
2915       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2916         rc = GPG_ERR_INV_OBJ;
2917       else
2918         {
2919           ctx->hash_algo = get_hash_algo (s, n);
2920
2921           if (!ctx->hash_algo)
2922             rc = GPG_ERR_DIGEST_ALGO;
2923           else
2924             {
2925               *ret_mpi = gcry_sexp_nth_mpi (lhash, 2, GCRYMPI_FMT_USG);
2926               if (!*ret_mpi)
2927                 rc = GPG_ERR_INV_OBJ;
2928               ctx->verify_cmp = pss_verify_cmp;
2929               ctx->verify_arg = *ret_mpi;
2930             }
2931         }
2932     }
2933   else
2934     rc = GPG_ERR_CONFLICT;
2935
2936  leave:
2937   gcry_sexp_release (ldata);
2938   gcry_sexp_release (lhash);
2939   gcry_sexp_release (lvalue);
2940
2941   if (!rc)
2942     ctx->flags = parsed_flags;
2943   else
2944     {
2945       gcry_free (ctx->label);
2946       ctx->label = NULL;
2947     }
2948
2949   return rc;
2950 }
2951
2952 static void
2953 init_encoding_ctx (struct pk_encoding_ctx *ctx, enum pk_operation op,
2954                    unsigned int nbits)
2955 {
2956   ctx->op = op;
2957   ctx->nbits = nbits;
2958   ctx->encoding = PUBKEY_ENC_UNKNOWN;
2959   ctx->flags = 0;
2960   ctx->hash_algo = GCRY_MD_SHA1;
2961   ctx->label = NULL;
2962   ctx->labellen = 0;
2963   ctx->saltlen = 20;
2964   ctx->verify_cmp = NULL;
2965   ctx->verify_arg = NULL;
2966 }
2967
2968
2969 /*
2970    Do a PK encrypt operation
2971
2972    Caller has to provide a public key as the SEXP pkey and data as a
2973    SEXP with just one MPI in it. Alternatively S_DATA might be a
2974    complex S-Expression, similar to the one used for signature
2975    verification.  This provides a flag which allows to handle PKCS#1
2976    block type 2 padding.  The function returns a sexp which may be
2977    passed to to pk_decrypt.
2978
2979    Returns: 0 or an errorcode.
2980
2981    s_data = See comment for sexp_data_to_mpi
2982    s_pkey = <key-as-defined-in-sexp_to_key>
2983    r_ciph = (enc-val
2984                (<algo>
2985                  (<param_name1> <mpi>)
2986                  ...
2987                  (<param_namen> <mpi>)
2988                ))
2989
2990 */
2991 gcry_error_t
2992 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
2993 {
2994   gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
2995   const char *algo_name, *algo_elems;
2996   struct pk_encoding_ctx ctx;
2997   gcry_err_code_t rc;
2998   gcry_pk_spec_t *pubkey = NULL;
2999   gcry_module_t module = NULL;
3000
3001   *r_ciph = NULL;
3002
3003   REGISTER_DEFAULT_PUBKEYS;
3004
3005   /* Get the key. */
3006   rc = sexp_to_key (s_pkey, 0, GCRY_PK_USAGE_ENCR, NULL, &pkey, &module, NULL);
3007   if (rc)
3008     goto leave;
3009
3010   gcry_assert (module);
3011   pubkey = (gcry_pk_spec_t *) module->spec;
3012
3013   /* If aliases for the algorithm name exists, take the first one
3014      instead of the regular name to adhere to SPKI conventions.  We
3015      assume that the first alias name is the lowercase version of the
3016      regular one.  This change is required for compatibility with
3017      1.1.12 generated S-expressions. */
3018   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
3019   if (!algo_name || !*algo_name)
3020     algo_name = pubkey->name;
3021
3022   algo_elems = pubkey->elements_enc;
3023
3024   /* Get the stuff we want to encrypt. */
3025   init_encoding_ctx (&ctx, PUBKEY_OP_ENCRYPT, gcry_pk_get_nbits (s_pkey));
3026   rc = sexp_data_to_mpi (s_data, &data, &ctx);
3027   if (rc)
3028     goto leave;
3029
3030   /* Now we can encrypt DATA to CIPH. */
3031   ciph = gcry_calloc (strlen (algo_elems) + 1, sizeof (*ciph));
3032   if (!ciph)
3033     {
3034       rc = gpg_err_code_from_syserror ();
3035       goto leave;
3036     }
3037   rc = pubkey_encrypt (module->mod_id, ciph, data, pkey, ctx.flags);
3038   mpi_free (data);
3039   data = NULL;
3040   if (rc)
3041     goto leave;
3042
3043   /* We did it.  Now build the return list */
3044   if (ctx.encoding == PUBKEY_ENC_OAEP
3045       || ctx.encoding == PUBKEY_ENC_PKCS1)
3046     {
3047       /* We need to make sure to return the correct length to avoid
3048          problems with missing leading zeroes.  We know that this
3049          encoding does only make sense with RSA thus we don't need to
3050          build the S-expression on the fly.  */
3051       unsigned char *em;
3052       size_t emlen = (ctx.nbits+7)/8;
3053
3054       rc = octet_string_from_mpi (&em, NULL, ciph[0], emlen);
3055       if (rc)
3056         goto leave;
3057       rc = gcry_err_code (gcry_sexp_build (r_ciph, NULL,
3058                                            "(enc-val(%s(a%b)))",
3059                                            algo_name, (int)emlen, em));
3060       gcry_free (em);
3061       if (rc)
3062         goto leave;
3063     }
3064   else
3065     {
3066       char *string, *p;
3067       int i;
3068       size_t nelem = strlen (algo_elems);
3069       size_t needed = 19 + strlen (algo_name) + (nelem * 5);
3070       void **arg_list;
3071
3072       /* Build the string.  */
3073       string = p = gcry_malloc (needed);
3074       if (!string)
3075         {
3076           rc = gpg_err_code_from_syserror ();
3077           goto leave;
3078         }
3079       p = stpcpy ( p, "(enc-val(" );
3080       p = stpcpy ( p, algo_name );
3081       for (i=0; algo_elems[i]; i++ )
3082         {
3083           *p++ = '(';
3084           *p++ = algo_elems[i];
3085           p = stpcpy ( p, "%m)" );
3086         }
3087       strcpy ( p, "))" );
3088
3089       /* And now the ugly part: We don't have a function to pass an
3090        * array to a format string, so we have to do it this way :-(.  */
3091       /* FIXME: There is now such a format specifier, so we can
3092          change the code to be more clear. */
3093       arg_list = malloc (nelem * sizeof *arg_list);
3094       if (!arg_list)
3095         {
3096           rc = gpg_err_code_from_syserror ();
3097           goto leave;
3098         }
3099
3100       for (i = 0; i < nelem; i++)
3101         arg_list[i] = ciph + i;
3102
3103       rc = gcry_sexp_build_array (r_ciph, NULL, string, arg_list);
3104       free (arg_list);
3105       if (rc)
3106         BUG ();
3107       gcry_free (string);
3108     }
3109
3110  leave:
3111   if (pkey)
3112     {
3113       release_mpi_array (pkey);
3114       gcry_free (pkey);
3115     }
3116
3117   if (ciph)
3118     {
3119       release_mpi_array (ciph);
3120       gcry_free (ciph);
3121     }
3122
3123   if (module)
3124     {
3125       ath_mutex_lock (&pubkeys_registered_lock);
3126       _gcry_module_release (module);
3127       ath_mutex_unlock (&pubkeys_registered_lock);
3128     }
3129
3130   gcry_free (ctx.label);
3131
3132   return gcry_error (rc);
3133 }
3134
3135 /*
3136    Do a PK decrypt operation
3137
3138    Caller has to provide a secret key as the SEXP skey and data in a
3139    format as created by gcry_pk_encrypt.  For historic reasons the
3140    function returns simply an MPI as an S-expression part; this is
3141    deprecated and the new method should be used which returns a real
3142    S-expressionl this is selected by adding at least an empty flags
3143    list to S_DATA.
3144
3145    Returns: 0 or an errorcode.
3146
3147    s_data = (enc-val
3148               [(flags [raw, pkcs1, oaep])]
3149               (<algo>
3150                 (<param_name1> <mpi>)
3151                 ...
3152                 (<param_namen> <mpi>)
3153               ))
3154    s_skey = <key-as-defined-in-sexp_to_key>
3155    r_plain= Either an incomplete S-expression without the parentheses
3156             or if the flags list is used (even if empty) a real S-expression:
3157             (value PLAIN).  In raw mode (or no flags given) the returned value
3158             is to be interpreted as a signed MPI, thus it may have an extra
3159             leading zero octet even if not included in the original data.
3160             With pkcs1 or oaep decoding enabled the returned value is a
3161             verbatim octet string.
3162  */
3163 gcry_error_t
3164 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
3165 {
3166   gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL;
3167   unsigned char *unpad = NULL;
3168   size_t unpadlen = 0;
3169   int modern, flags;
3170   struct pk_encoding_ctx ctx;
3171   gcry_err_code_t rc;
3172   gcry_module_t module_enc = NULL, module_key = NULL;
3173
3174   *r_plain = NULL;
3175   ctx.label = NULL;
3176
3177   REGISTER_DEFAULT_PUBKEYS;
3178
3179   rc = sexp_to_key (s_skey, 1, GCRY_PK_USAGE_ENCR, NULL,
3180                     &skey, &module_key, NULL);
3181   if (rc)
3182     goto leave;
3183
3184   init_encoding_ctx (&ctx, PUBKEY_OP_DECRYPT, gcry_pk_get_nbits (s_skey));
3185   rc = sexp_to_enc (s_data, &data, &module_enc, &modern, &flags, &ctx);
3186   if (rc)
3187     goto leave;
3188
3189   if (module_key->mod_id != module_enc->mod_id)
3190     {
3191       rc = GPG_ERR_CONFLICT; /* Key algo does not match data algo. */
3192       goto leave;
3193     }
3194
3195   rc = pubkey_decrypt (module_key->mod_id, &plain, data, skey, flags);
3196   if (rc)
3197     goto leave;
3198
3199   /* Do un-padding if necessary. */
3200   switch (ctx.encoding)
3201     {
3202     case PUBKEY_ENC_PKCS1:
3203       rc = pkcs1_decode_for_encryption (&unpad, &unpadlen,
3204                                         gcry_pk_get_nbits (s_skey), plain);
3205       mpi_free (plain);
3206       plain = NULL;
3207       if (!rc)
3208         rc = gcry_err_code (gcry_sexp_build (r_plain, NULL, "(value %b)",
3209                                              (int)unpadlen, unpad));
3210       break;
3211
3212     case PUBKEY_ENC_OAEP:
3213       rc = oaep_decode (&unpad, &unpadlen,
3214                         gcry_pk_get_nbits (s_skey), ctx.hash_algo,
3215                         plain, ctx.label, ctx.labellen);
3216       mpi_free (plain);
3217       plain = NULL;
3218       if (!rc)
3219         rc = gcry_err_code (gcry_sexp_build (r_plain, NULL, "(value %b)",
3220                                              (int)unpadlen, unpad));
3221       break;
3222
3223     default:
3224       /* Raw format.  For backward compatibility we need to assume a
3225          signed mpi by using the sexp format string "%m".  */
3226       rc = gcry_err_code (gcry_sexp_build
3227                           (r_plain, NULL, modern? "(value %m)" : "%m", plain));
3228       break;
3229     }
3230
3231  leave:
3232   gcry_free (unpad);
3233
3234   if (skey)
3235     {
3236       release_mpi_array (skey);
3237       gcry_free (skey);
3238     }
3239
3240   mpi_free (plain);
3241
3242   if (data)
3243     {
3244       release_mpi_array (data);
3245       gcry_free (data);
3246     }
3247
3248   if (module_key || module_enc)
3249     {
3250       ath_mutex_lock (&pubkeys_registered_lock);
3251       if (module_key)
3252         _gcry_module_release (module_key);
3253       if (module_enc)
3254         _gcry_module_release (module_enc);
3255       ath_mutex_unlock (&pubkeys_registered_lock);
3256     }
3257
3258   gcry_free (ctx.label);
3259
3260   return gcry_error (rc);
3261 }
3262
3263
3264
3265 /*
3266    Create a signature.
3267
3268    Caller has to provide a secret key as the SEXP skey and data
3269    expressed as a SEXP list hash with only one element which should
3270    instantly be available as a MPI. Alternatively the structure given
3271    below may be used for S_HASH, it provides the abiliy to pass flags
3272    to the operation; the flags defined by now are "pkcs1" which does
3273    PKCS#1 block type 1 style padding and "pss" for PSS encoding.
3274
3275    Returns: 0 or an errorcode.
3276             In case of 0 the function returns a new SEXP with the
3277             signature value; the structure of this signature depends on the
3278             other arguments but is always suitable to be passed to
3279             gcry_pk_verify
3280
3281    s_hash = See comment for sexp_data_to_mpi
3282
3283    s_skey = <key-as-defined-in-sexp_to_key>
3284    r_sig  = (sig-val
3285               (<algo>
3286                 (<param_name1> <mpi>)
3287                 ...
3288                 (<param_namen> <mpi>))
3289              [(hash algo)])
3290
3291   Note that (hash algo) in R_SIG is not used.
3292 */
3293 gcry_error_t
3294 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
3295 {
3296   gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
3297   gcry_pk_spec_t *pubkey = NULL;
3298   gcry_module_t module = NULL;
3299   const char *algo_name, *algo_elems;
3300   struct pk_encoding_ctx ctx;
3301   int i;
3302   int is_ecc;
3303   gcry_err_code_t rc;
3304
3305   *r_sig = NULL;
3306
3307   REGISTER_DEFAULT_PUBKEYS;
3308
3309   rc = sexp_to_key (s_skey, 1, GCRY_PK_USAGE_SIGN, NULL,
3310                     &skey, &module, &is_ecc);
3311   if (rc)
3312     goto leave;
3313
3314   gcry_assert (module);
3315   pubkey = (gcry_pk_spec_t *) module->spec;
3316   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
3317   if (!algo_name || !*algo_name)
3318     algo_name = pubkey->name;
3319
3320   algo_elems = pubkey->elements_sig;
3321
3322   /* Get the stuff we want to sign.  Note that pk_get_nbits does also
3323      work on a private key.  We don't need the number of bits for ECC
3324      here, thus set it to 0 so that we don't need to parse it.  */
3325   init_encoding_ctx (&ctx, PUBKEY_OP_SIGN,
3326                      is_ecc? 0 : gcry_pk_get_nbits (s_skey));
3327   rc = sexp_data_to_mpi (s_hash, &hash, &ctx);
3328   if (rc)
3329     goto leave;
3330
3331   result = gcry_calloc (strlen (algo_elems) + 1, sizeof (*result));
3332   if (!result)
3333     {
3334       rc = gpg_err_code_from_syserror ();
3335       goto leave;
3336     }
3337   rc = pubkey_sign (module->mod_id, result, hash, skey, &ctx);
3338   if (rc)
3339     goto leave;
3340
3341   if (ctx.encoding == PUBKEY_ENC_PSS
3342       || ctx.encoding == PUBKEY_ENC_PKCS1)
3343     {
3344       /* We need to make sure to return the correct length to avoid
3345          problems with missing leading zeroes.  We know that this
3346          encoding does only make sense with RSA thus we don't need to
3347          build the S-expression on the fly.  */
3348       unsigned char *em;
3349       size_t emlen = (ctx.nbits+7)/8;
3350
3351       rc = octet_string_from_mpi (&em, NULL, result[0], emlen);
3352       if (rc)
3353         goto leave;
3354       rc = gcry_err_code (gcry_sexp_build (r_sig, NULL,
3355                                            "(sig-val(%s(s%b)))",
3356                                            algo_name, (int)emlen, em));
3357       gcry_free (em);
3358       if (rc)
3359         goto leave;
3360     }
3361   else
3362     {
3363       /* General purpose output encoding.  Do it on the fly.  */
3364       char *string, *p;
3365       size_t nelem, needed = strlen (algo_name) + 20;
3366       void **arg_list;
3367
3368       nelem = strlen (algo_elems);
3369
3370       /* Count elements, so that we can allocate enough space. */
3371       needed += 10 * nelem;
3372
3373       /* Build the string. */
3374       string = p = gcry_malloc (needed);
3375       if (!string)
3376         {
3377           rc = gpg_err_code_from_syserror ();
3378           goto leave;
3379         }
3380       p = stpcpy (p, "(sig-val(");
3381       p = stpcpy (p, algo_name);
3382       for (i = 0; algo_elems[i]; i++)
3383         {
3384           *p++ = '(';
3385           *p++ = algo_elems[i];
3386           p = stpcpy (p, "%M)");
3387         }
3388       strcpy (p, "))");
3389
3390       arg_list = malloc (nelem * sizeof *arg_list);
3391       if (!arg_list)
3392         {
3393           rc = gpg_err_code_from_syserror ();
3394           goto leave;
3395         }
3396
3397       for (i = 0; i < nelem; i++)
3398         arg_list[i] = result + i;
3399
3400       rc = gcry_sexp_build_array (r_sig, NULL, string, arg_list);
3401       free (arg_list);
3402       if (rc)
3403         BUG ();
3404       gcry_free (string);
3405     }
3406
3407  leave:
3408   if (skey)
3409     {
3410       if (is_ecc)
3411         /* Q is optional and may be NULL, while there is D after Q.  */
3412         for (i = 0; i < 7; i++)
3413           {
3414             if (skey[i])
3415               mpi_free (skey[i]);
3416             skey[i] = NULL;
3417           }
3418       else
3419         release_mpi_array (skey);
3420       gcry_free (skey);
3421     }
3422
3423   if (hash)
3424     mpi_free (hash);
3425
3426   if (result)
3427     {
3428       release_mpi_array (result);
3429       gcry_free (result);
3430     }
3431
3432   return gcry_error (rc);
3433 }
3434
3435
3436 /*
3437    Verify a signature.
3438
3439    Caller has to supply the public key pkey, the signature sig and his
3440    hashvalue data.  Public key has to be a standard public key given
3441    as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
3442    must be an S-Exp like the one in sign too.  */
3443 gcry_error_t
3444 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
3445 {
3446   gcry_module_t module_key = NULL, module_sig = NULL;
3447   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
3448   struct pk_encoding_ctx ctx;
3449   gcry_err_code_t rc;
3450
3451   REGISTER_DEFAULT_PUBKEYS;
3452
3453   rc = sexp_to_key (s_pkey, 0, GCRY_PK_USAGE_SIGN, NULL,
3454                     &pkey, &module_key, NULL);
3455   if (rc)
3456     goto leave;
3457
3458   /* Get the stuff we want to verify. */
3459   init_encoding_ctx (&ctx, PUBKEY_OP_VERIFY, gcry_pk_get_nbits (s_pkey));
3460   rc = sexp_data_to_mpi (s_hash, &hash, &ctx);
3461   if (rc)
3462     goto leave;
3463
3464   /* Get the signature.  */
3465   rc = sexp_to_sig (s_sig, &sig, &module_sig,
3466                     !!(ctx.flags & PUBKEY_FLAG_EDDSA));
3467   if (rc)
3468     goto leave;
3469   /* Fixme: Check that the algorithm of S_SIG is compatible to the one
3470      of S_PKEY.  */
3471
3472   if (module_key->mod_id != module_sig->mod_id)
3473     {
3474       rc = GPG_ERR_CONFLICT;
3475       goto leave;
3476     }
3477
3478   rc = pubkey_verify (module_key->mod_id, hash, sig, pkey, &ctx);
3479
3480  leave:
3481   if (pkey)
3482     {
3483       release_mpi_array (pkey);
3484       gcry_free (pkey);
3485     }
3486   if (sig)
3487     {
3488       release_mpi_array (sig);
3489       gcry_free (sig);
3490     }
3491   if (hash)
3492     mpi_free (hash);
3493
3494   if (module_key || module_sig)
3495     {
3496       ath_mutex_lock (&pubkeys_registered_lock);
3497       if (module_key)
3498         _gcry_module_release (module_key);
3499       if (module_sig)
3500         _gcry_module_release (module_sig);
3501       ath_mutex_unlock (&pubkeys_registered_lock);
3502     }
3503
3504   return gcry_error (rc);
3505 }
3506
3507
3508 /*
3509    Test a key.
3510
3511    This may be used either for a public or a secret key to see whether
3512    the internal structure is okay.
3513
3514    Returns: 0 or an errorcode.
3515
3516    s_key = <key-as-defined-in-sexp_to_key> */
3517 gcry_error_t
3518 gcry_pk_testkey (gcry_sexp_t s_key)
3519 {
3520   gcry_module_t module = NULL;
3521   gcry_mpi_t *key = NULL;
3522   gcry_err_code_t rc;
3523
3524   REGISTER_DEFAULT_PUBKEYS;
3525
3526   /* Note we currently support only secret key checking. */
3527   rc = sexp_to_key (s_key, 1, 0, NULL, &key, &module, NULL);
3528   if (! rc)
3529     {
3530       rc = pubkey_check_secret_key (module->mod_id, key);
3531       release_mpi_array (key);
3532       gcry_free (key);
3533     }
3534   return gcry_error (rc);
3535 }
3536
3537
3538 /*
3539   Create a public key pair and return it in r_key.
3540   How the key is created depends on s_parms:
3541   (genkey
3542    (algo
3543      (parameter_name_1 ....)
3544       ....
3545      (parameter_name_n ....)
3546   ))
3547   The key is returned in a format depending on the
3548   algorithm. Both, private and secret keys are returned
3549   and optionally some additional informatin.
3550   For elgamal we return this structure:
3551   (key-data
3552    (public-key
3553      (elg
3554         (p <mpi>)
3555         (g <mpi>)
3556         (y <mpi>)
3557      )
3558    )
3559    (private-key
3560      (elg
3561         (p <mpi>)
3562         (g <mpi>)
3563         (y <mpi>)
3564         (x <mpi>)
3565      )
3566    )
3567    (misc-key-info
3568       (pm1-factors n1 n2 ... nn)
3569    ))
3570  */
3571 gcry_error_t
3572 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
3573 {
3574   gcry_pk_spec_t *pubkey = NULL;
3575   gcry_module_t module = NULL;
3576   gcry_sexp_t list = NULL;
3577   gcry_sexp_t l2 = NULL;
3578   gcry_sexp_t l3 = NULL;
3579   char *name = NULL;
3580   size_t n;
3581   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
3582   int i, j;
3583   const char *algo_name = NULL;
3584   int algo;
3585   const char *sec_elems = NULL, *pub_elems = NULL;
3586   gcry_mpi_t skey[12];
3587   gcry_mpi_t *factors = NULL;
3588   gcry_sexp_t extrainfo = NULL;
3589   unsigned int nbits = 0;
3590   unsigned long use_e = 0;
3591
3592   skey[0] = NULL;
3593   *r_key = NULL;
3594
3595   REGISTER_DEFAULT_PUBKEYS;
3596
3597   list = gcry_sexp_find_token (s_parms, "genkey", 0);
3598   if (!list)
3599     {
3600       rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
3601       goto leave;
3602     }
3603
3604   l2 = gcry_sexp_cadr (list);
3605   gcry_sexp_release (list);
3606   list = l2;
3607   l2 = NULL;
3608   if (! list)
3609     {
3610       rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
3611       goto leave;
3612     }
3613
3614   name = _gcry_sexp_nth_string (list, 0);
3615   if (!name)
3616     {
3617       rc = GPG_ERR_INV_OBJ; /* Algo string missing.  */
3618       goto leave;
3619     }
3620
3621   ath_mutex_lock (&pubkeys_registered_lock);
3622   module = gcry_pk_lookup_name (name);
3623   ath_mutex_unlock (&pubkeys_registered_lock);
3624   gcry_free (name);
3625   name = NULL;
3626   if (!module)
3627     {
3628       rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
3629       goto leave;
3630     }
3631
3632   pubkey = (gcry_pk_spec_t *) module->spec;
3633   algo = module->mod_id;
3634   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
3635   if (!algo_name || !*algo_name)
3636     algo_name = pubkey->name;
3637   pub_elems = pubkey->elements_pkey;
3638   sec_elems = pubkey->elements_skey;
3639   if (strlen (sec_elems) >= DIM(skey))
3640     BUG ();
3641
3642   /* Handle the optional rsa-use-e element.  Actually this belong into
3643      the algorithm module but we have this parameter in the public
3644      module API, so we need to parse it right here.  */
3645   l2 = gcry_sexp_find_token (list, "rsa-use-e", 0);
3646   if (l2)
3647     {
3648       char buf[50];
3649       const char *s;
3650
3651       s = gcry_sexp_nth_data (l2, 1, &n);
3652       if ( !s || n >= DIM (buf) - 1 )
3653         {
3654           rc = GPG_ERR_INV_OBJ; /* No value or value too large.  */
3655           goto leave;
3656         }
3657       memcpy (buf, s, n);
3658       buf[n] = 0;
3659       use_e = strtoul (buf, NULL, 0);
3660       gcry_sexp_release (l2);
3661       l2 = NULL;
3662     }
3663   else
3664     use_e = 65537; /* Not given, use the value generated by old versions. */
3665
3666
3667   /* Get the "nbits" parameter.  */
3668   l2 = gcry_sexp_find_token (list, "nbits", 0);
3669   if (l2)
3670     {
3671       char buf[50];
3672       const char *s;
3673
3674       s = gcry_sexp_nth_data (l2, 1, &n);
3675       if (!s || n >= DIM (buf) - 1 )
3676         {
3677           rc = GPG_ERR_INV_OBJ; /* NBITS given without a cdr.  */
3678           goto leave;
3679         }
3680       memcpy (buf, s, n);
3681       buf[n] = 0;
3682       nbits = (unsigned int)strtoul (buf, NULL, 0);
3683       gcry_sexp_release (l2); l2 = NULL;
3684     }
3685   else
3686     nbits = 0;
3687
3688   /* Pass control to the algorithm module. */
3689   rc = pubkey_generate (module->mod_id, nbits, use_e, list, skey,
3690                         &factors, &extrainfo);
3691   gcry_sexp_release (list); list = NULL;
3692   if (rc)
3693     goto leave;
3694
3695   /* Key generation succeeded: Build an S-expression.  */
3696   {
3697     char *string, *p;
3698     size_t nelem=0, nelem_cp = 0, needed=0;
3699     gcry_mpi_t mpis[30];
3700     int percent_s_idx = -1;
3701     int percent_s_idx2 = -1;
3702
3703     /* Estimate size of format string.  */
3704     nelem = strlen (pub_elems) + strlen (sec_elems);
3705     if (factors)
3706       {
3707         for (i = 0; factors[i]; i++)
3708           nelem++;
3709       }
3710     if (extrainfo)
3711       nelem += 2;
3712     nelem_cp = nelem;
3713
3714     needed += nelem * 10;
3715     /* (+10 for two times EXTRAINFO ("%S")).  */
3716     needed += 2 * strlen (algo_name) + 300 + 10;
3717     if (nelem > DIM (mpis))
3718       BUG ();
3719
3720     /* Build the string. */
3721     nelem = 0;
3722     string = p = gcry_malloc (needed);
3723     if (!string)
3724       {
3725         rc = gpg_err_code_from_syserror ();
3726         goto leave;
3727       }
3728     p = stpcpy (p, "(key-data");
3729     p = stpcpy (p, "(public-key(");
3730     p = stpcpy (p, algo_name);
3731     for(i = 0; pub_elems[i]; i++)
3732       {
3733         *p++ = '(';
3734         *p++ = pub_elems[i];
3735         p = stpcpy (p, "%m)");
3736         mpis[nelem++] = skey[i];
3737       }
3738     if (extrainfo && (algo == GCRY_PK_ECDSA || algo == GCRY_PK_ECDH))
3739       {
3740         /* Very ugly hack to insert the used curve parameter into the
3741            list of public key parameters.  */
3742         percent_s_idx = nelem++;
3743         p = stpcpy (p, "%S");
3744       }
3745     p = stpcpy (p, "))");
3746     p = stpcpy (p, "(private-key(");
3747     p = stpcpy (p, algo_name);
3748     for (i = 0; sec_elems[i]; i++)
3749       {
3750         *p++ = '(';
3751         *p++ = sec_elems[i];
3752         p = stpcpy (p, "%m)");
3753         mpis[nelem++] = skey[i];
3754       }
3755     if (extrainfo && (algo == GCRY_PK_ECDSA || algo == GCRY_PK_ECDH))
3756       {
3757         percent_s_idx2 = nelem++;
3758         p = stpcpy (p, "%S");
3759       }
3760     p = stpcpy (p, "))");
3761
3762     /* Hack to make release_mpi_array() work.  */
3763     skey[i] = NULL;
3764
3765     if (extrainfo)
3766       {
3767         /* If we have extrainfo we should not have any factors.  */
3768         if (percent_s_idx == -1)
3769           {
3770             percent_s_idx = nelem++;
3771             p = stpcpy (p, "%S");
3772           }
3773       }
3774     else if (factors && factors[0])
3775       {
3776         p = stpcpy (p, "(misc-key-info(pm1-factors");
3777         for(i = 0; factors[i]; i++)
3778           {
3779             p = stpcpy (p, "%m");
3780             mpis[nelem++] = factors[i];
3781           }
3782         p = stpcpy (p, "))");
3783       }
3784     strcpy (p, ")");
3785     gcry_assert (p - string < needed);
3786
3787     while (nelem < DIM (mpis))
3788       mpis[nelem++] = NULL;
3789
3790     {
3791       int elem_n = strlen (pub_elems) + strlen (sec_elems);
3792       void **arg_list;
3793
3794       if (percent_s_idx != -1)
3795         elem_n++;
3796       if (percent_s_idx2 != -1)
3797         elem_n++;
3798
3799       arg_list = gcry_calloc (nelem_cp, sizeof *arg_list);
3800       if (!arg_list)
3801         {
3802           rc = gpg_err_code_from_syserror ();
3803           goto leave;
3804         }
3805       for (i = j = 0; i < elem_n; i++)
3806         {
3807           if (i == percent_s_idx)
3808             arg_list[j++] = &extrainfo;
3809           else if (i == percent_s_idx2)
3810             arg_list[j++] = &extrainfo;
3811           else
3812             arg_list[j++] = mpis + i;
3813         }
3814       if (extrainfo)
3815         ;
3816       else if (factors && factors[0])
3817         {
3818           for (; i < nelem_cp; i++)
3819             arg_list[j++] = factors + i - elem_n;
3820         }
3821       rc = gcry_sexp_build_array (r_key, NULL, string, arg_list);
3822       gcry_free (arg_list);
3823       if (rc)
3824         BUG ();
3825       gcry_assert (DIM (mpis) == 30); /* Reminder to make sure that
3826                                          the array gets increased if
3827                                          new parameters are added. */
3828     }
3829     gcry_free (string);
3830   }
3831
3832  leave:
3833   gcry_free (name);
3834   gcry_sexp_release (extrainfo);
3835   release_mpi_array (skey);
3836   /* Don't free SKEY itself, it is an stack allocated array. */
3837
3838   if (factors)
3839     {
3840       release_mpi_array ( factors );
3841       gcry_free (factors);
3842     }
3843
3844   gcry_sexp_release (l3);
3845   gcry_sexp_release (l2);
3846   gcry_sexp_release (list);
3847
3848   if (module)
3849     {
3850       ath_mutex_lock (&pubkeys_registered_lock);
3851       _gcry_module_release (module);
3852       ath_mutex_unlock (&pubkeys_registered_lock);
3853     }
3854
3855   return gcry_error (rc);
3856 }
3857
3858
3859 /*
3860    Get the number of nbits from the public key.
3861
3862    Hmmm: Should we have really this function or is it better to have a
3863    more general function to retrieve different properties of the key?  */
3864 unsigned int
3865 gcry_pk_get_nbits (gcry_sexp_t key)
3866 {
3867   gcry_module_t module = NULL;
3868   gcry_pk_spec_t *pubkey;
3869   gcry_mpi_t *keyarr = NULL;
3870   unsigned int nbits = 0;
3871   gcry_err_code_t rc;
3872
3873   REGISTER_DEFAULT_PUBKEYS;
3874
3875   /* FIXME: Parsing KEY is often too much overhead.  For example for
3876      ECC we would only need to look at P and stop parsing right
3877      away.  */
3878
3879   rc = sexp_to_key (key, 0, 0, NULL, &keyarr, &module, NULL);
3880   if (rc == GPG_ERR_INV_OBJ)
3881     rc = sexp_to_key (key, 1, 0, NULL, &keyarr, &module, NULL);
3882   if (rc)
3883     return 0; /* Error - 0 is a suitable indication for that. */
3884
3885   pubkey = (gcry_pk_spec_t *) module->spec;
3886   nbits = (*pubkey->get_nbits) (module->mod_id, keyarr);
3887
3888   ath_mutex_lock (&pubkeys_registered_lock);
3889   _gcry_module_release (module);
3890   ath_mutex_unlock (&pubkeys_registered_lock);
3891
3892   release_mpi_array (keyarr);
3893   gcry_free (keyarr);
3894
3895   return nbits;
3896 }
3897
3898
3899 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
3900    key parameters expressed in a way depending on the algorithm.
3901
3902    ARRAY must either be 20 bytes long or NULL; in the latter case a
3903    newly allocated array of that size is returned, otherwise ARRAY or
3904    NULL is returned to indicate an error which is most likely an
3905    unknown algorithm.  The function accepts public or secret keys. */
3906 unsigned char *
3907 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
3908 {
3909   gcry_sexp_t list = NULL, l2 = NULL;
3910   gcry_pk_spec_t *pubkey = NULL;
3911   gcry_module_t module = NULL;
3912   const char *s;
3913   char *name = NULL;
3914   int idx;
3915   const char *elems;
3916   gcry_md_hd_t md = NULL;
3917   int okay = 0;
3918
3919   REGISTER_DEFAULT_PUBKEYS;
3920
3921   /* Check that the first element is valid. */
3922   list = gcry_sexp_find_token (key, "public-key", 0);
3923   if (! list)
3924     list = gcry_sexp_find_token (key, "private-key", 0);
3925   if (! list)
3926     list = gcry_sexp_find_token (key, "protected-private-key", 0);
3927   if (! list)
3928     list = gcry_sexp_find_token (key, "shadowed-private-key", 0);
3929   if (! list)
3930     return NULL; /* No public- or private-key object. */
3931
3932   l2 = gcry_sexp_cadr (list);
3933   gcry_sexp_release (list);
3934   list = l2;
3935   l2 = NULL;
3936
3937   name = _gcry_sexp_nth_string (list, 0);
3938   if (!name)
3939     goto fail; /* Invalid structure of object. */
3940
3941   ath_mutex_lock (&pubkeys_registered_lock);
3942   module = gcry_pk_lookup_name (name);
3943   ath_mutex_unlock (&pubkeys_registered_lock);
3944
3945   if (!module)
3946     goto fail; /* Unknown algorithm.  */
3947
3948   pubkey = (gcry_pk_spec_t *) module->spec;
3949
3950   elems = pubkey->elements_grip;
3951   if (!elems)
3952     goto fail; /* No grip parameter.  */
3953
3954   if (gcry_md_open (&md, GCRY_MD_SHA1, 0))
3955     goto fail;
3956
3957   if (pubkey->comp_keygrip)
3958     {
3959       /* Module specific method to compute a keygrip.  */
3960       if (pubkey->comp_keygrip (md, list))
3961         goto fail;
3962     }
3963   else
3964     {
3965       /* Generic method to compute a keygrip.  */
3966       for (idx = 0, s = elems; *s; s++, idx++)
3967         {
3968           const char *data;
3969           size_t datalen;
3970           char buf[30];
3971
3972           l2 = gcry_sexp_find_token (list, s, 1);
3973           if (! l2)
3974             goto fail;
3975           data = gcry_sexp_nth_data (l2, 1, &datalen);
3976           if (! data)
3977             goto fail;
3978
3979           snprintf (buf, sizeof buf, "(1:%c%u:", *s, (unsigned int)datalen);
3980           gcry_md_write (md, buf, strlen (buf));
3981           gcry_md_write (md, data, datalen);
3982           gcry_sexp_release (l2);
3983           l2 = NULL;
3984           gcry_md_write (md, ")", 1);
3985         }
3986     }
3987
3988   if (!array)
3989     {
3990       array = gcry_malloc (20);
3991       if (! array)
3992         goto fail;
3993     }
3994
3995   memcpy (array, gcry_md_read (md, GCRY_MD_SHA1), 20);
3996   okay = 1;
3997
3998  fail:
3999   gcry_free (name);
4000   gcry_sexp_release (l2);
4001   gcry_md_close (md);
4002   gcry_sexp_release (list);
4003   return okay? array : NULL;
4004 }
4005
4006
4007 \f
4008 const char *
4009 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
4010 {
4011   gcry_mpi_t *pkey = NULL;
4012   gcry_sexp_t list = NULL;
4013   gcry_sexp_t l2;
4014   gcry_module_t module = NULL;
4015   char *name = NULL;
4016   const char *result = NULL;
4017   int want_private = 1;
4018   gcry_pk_spec_t *spec;
4019
4020   if (r_nbits)
4021     *r_nbits = 0;
4022
4023   REGISTER_DEFAULT_PUBKEYS;
4024
4025   if (key)
4026     {
4027       iterator = 0;
4028
4029       /* Check that the first element is valid. */
4030       list = gcry_sexp_find_token (key, "public-key", 0);
4031       if (list)
4032         want_private = 0;
4033       if (!list)
4034         list = gcry_sexp_find_token (key, "private-key", 0);
4035       if (!list)
4036         return NULL; /* No public- or private-key object. */
4037
4038       l2 = gcry_sexp_cadr (list);
4039       gcry_sexp_release (list);
4040       list = l2;
4041       l2 = NULL;
4042
4043       name = _gcry_sexp_nth_string (list, 0);
4044       if (!name)
4045         goto leave; /* Invalid structure of object. */
4046
4047       /* Get the key.  We pass the names of the parameters for
4048          override_elems; this allows to call this function without the
4049          actual public key parameter.  */
4050       if (sexp_to_key (key, want_private, 0, "pabgn", &pkey, &module, NULL))
4051         goto leave;
4052     }
4053   else
4054     {
4055       ath_mutex_lock (&pubkeys_registered_lock);
4056       module = gcry_pk_lookup_name ("ecc");
4057       ath_mutex_unlock (&pubkeys_registered_lock);
4058       if (!module)
4059         goto leave;
4060     }
4061
4062   spec = module->spec;
4063   if (!spec || !spec->get_curve)
4064     goto leave;
4065
4066   result = spec->get_curve (pkey, iterator, r_nbits);
4067
4068  leave:
4069   if (pkey)
4070     {
4071       release_mpi_array (pkey);
4072       gcry_free (pkey);
4073     }
4074   if (module)
4075     {
4076       ath_mutex_lock (&pubkeys_registered_lock);
4077       _gcry_module_release (module);
4078       ath_mutex_unlock (&pubkeys_registered_lock);
4079     }
4080   gcry_free (name);
4081   gcry_sexp_release (list);
4082   return result;
4083 }
4084
4085
4086 \f
4087 gcry_sexp_t
4088 gcry_pk_get_param (int algo, const char *name)
4089 {
4090   gcry_module_t module = NULL;
4091   gcry_sexp_t result = NULL;
4092   gcry_pk_spec_t *spec;
4093
4094   if (algo != GCRY_PK_ECDSA && algo != GCRY_PK_ECDH)
4095     return NULL;
4096
4097   REGISTER_DEFAULT_PUBKEYS;
4098
4099   ath_mutex_lock (&pubkeys_registered_lock);
4100   module = gcry_pk_lookup_name ("ecc");
4101   ath_mutex_unlock (&pubkeys_registered_lock);
4102   if (module)
4103     {
4104       spec = module->spec;
4105       if (spec && spec->get_curve_param)
4106         result = spec->get_curve_param (name);
4107
4108       ath_mutex_lock (&pubkeys_registered_lock);
4109       _gcry_module_release (module);
4110       ath_mutex_unlock (&pubkeys_registered_lock);
4111     }
4112   return result;
4113 }
4114
4115
4116 \f
4117 gcry_error_t
4118 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
4119 {
4120   gcry_err_code_t err = GPG_ERR_NO_ERROR;
4121
4122   REGISTER_DEFAULT_PUBKEYS;
4123
4124   switch (cmd)
4125     {
4126     case GCRYCTL_DISABLE_ALGO:
4127       /* This one expects a buffer pointing to an integer with the
4128          algo number.  */
4129       if ((! buffer) || (buflen != sizeof (int)))
4130         err = GPG_ERR_INV_ARG;
4131       else
4132         disable_pubkey_algo (*((int *) buffer));
4133       break;
4134
4135     default:
4136       err = GPG_ERR_INV_OP;
4137     }
4138
4139   return gcry_error (err);
4140 }
4141
4142
4143 /* Return information about the given algorithm
4144
4145    WHAT selects the kind of information returned:
4146
4147     GCRYCTL_TEST_ALGO:
4148         Returns 0 when the specified algorithm is available for use.
4149         Buffer must be NULL, nbytes  may have the address of a variable
4150         with the required usage of the algorithm. It may be 0 for don't
4151         care or a combination of the GCRY_PK_USAGE_xxx flags;
4152
4153     GCRYCTL_GET_ALGO_USAGE:
4154         Return the usage flags for the given algo.  An invalid algo
4155         returns 0.  Disabled algos are ignored here because we
4156         only want to know whether the algo is at all capable of
4157         the usage.
4158
4159    Note: Because this function is in most cases used to return an
4160    integer value, we can make it easier for the caller to just look at
4161    the return value.  The caller will in all cases consult the value
4162    and thereby detecting whether a error occurred or not (i.e. while
4163    checking the block size) */
4164 gcry_error_t
4165 gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
4166 {
4167   gcry_err_code_t err = GPG_ERR_NO_ERROR;
4168
4169   switch (what)
4170     {
4171     case GCRYCTL_TEST_ALGO:
4172       {
4173         int use = nbytes ? *nbytes : 0;
4174         if (buffer)
4175           err = GPG_ERR_INV_ARG;
4176         else if (check_pubkey_algo (algorithm, use))
4177           err = GPG_ERR_PUBKEY_ALGO;
4178         break;
4179       }
4180
4181     case GCRYCTL_GET_ALGO_USAGE:
4182       {
4183         gcry_module_t pubkey;
4184         int use = 0;
4185
4186         REGISTER_DEFAULT_PUBKEYS;
4187
4188         ath_mutex_lock (&pubkeys_registered_lock);
4189         pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
4190         if (pubkey)
4191           {
4192             use = ((gcry_pk_spec_t *) pubkey->spec)->use;
4193             _gcry_module_release (pubkey);
4194           }
4195         ath_mutex_unlock (&pubkeys_registered_lock);
4196
4197         /* FIXME? */
4198         *nbytes = use;
4199
4200         break;
4201       }
4202
4203     case GCRYCTL_GET_ALGO_NPKEY:
4204       {
4205         /* FIXME?  */
4206         int npkey = pubkey_get_npkey (algorithm);
4207         *nbytes = npkey;
4208         break;
4209       }
4210     case GCRYCTL_GET_ALGO_NSKEY:
4211       {
4212         /* FIXME?  */
4213         int nskey = pubkey_get_nskey (algorithm);
4214         *nbytes = nskey;
4215         break;
4216       }
4217     case GCRYCTL_GET_ALGO_NSIGN:
4218       {
4219         /* FIXME?  */
4220         int nsign = pubkey_get_nsig (algorithm);
4221         *nbytes = nsign;
4222         break;
4223       }
4224     case GCRYCTL_GET_ALGO_NENCR:
4225       {
4226         /* FIXME?  */
4227         int nencr = pubkey_get_nenc (algorithm);
4228         *nbytes = nencr;
4229         break;
4230       }
4231
4232     default: