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