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