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