Merge branch 'master' into ueno-pss
[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    Here is figure 1 from the RFC depicting the process:
1096
1097                              +----------+---------+-------+
1098                         DB = |  lHash   |    PS   |   M   |
1099                              +----------+---------+-------+
1100                                             |
1101                   +----------+              V
1102                   |   seed   |--> MGF ---> xor
1103                   +----------+              |
1104                         |                   |
1105                +--+     V                   |
1106                |00|    xor <----- MGF <-----|
1107                +--+     |                   |
1108                  |      |                   |
1109                  V      V                   V
1110                +--+----------+----------------------------+
1111          EM =  |00|maskedSeed|          maskedDB          |
1112                +--+----------+----------------------------+
1113   */
1114 static gcry_err_code_t
1115 oaep_encode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1116              const unsigned char *value, size_t valuelen,
1117              const unsigned char *label, size_t labellen)
1118 {
1119   gcry_err_code_t rc = 0;
1120   gcry_error_t err;
1121   unsigned char *frame = NULL;
1122   size_t nframe = (nbits+7) / 8;
1123   unsigned char *p;
1124   size_t hlen;
1125   size_t n;
1126
1127   *r_result = NULL;
1128
1129   /* Set defaults for LABEL.  */
1130   if (!label || !labellen)
1131     {
1132       label = (const unsigned char*)"";
1133       labellen = 0;
1134     }
1135
1136   hlen = gcry_md_get_algo_dlen (algo);
1137
1138   /* We skip step 1a which would be to check that LABELLEN is not
1139      greater than 2^61-1.  See rfc-3447 7.1.1. */
1140
1141   /* Step 1b.  Note that the obsolete rfc-2437 uses the check:
1142      valuelen > nframe - 2 * hlen - 1 .  */
1143   if (valuelen > nframe - 2 * hlen - 2 || !nframe)
1144     {
1145       /* Can't encode a VALUELEN value in a NFRAME bytes frame. */
1146       return GPG_ERR_TOO_SHORT; /* The key is too short.  */
1147     }
1148
1149   /* Allocate the frame.  */
1150   frame = gcry_calloc_secure (1, nframe);
1151   if (!frame)
1152     return gpg_err_code_from_syserror ();
1153
1154   /* Step 2a: Compute the hash of the label.  We store it in the frame
1155      where later the maskedDB will commence.  */
1156   gcry_md_hash_buffer (algo, frame + 1 + hlen, label, labellen);
1157
1158   /* Step 2b: Set octet string to zero.  */
1159   /* This has already been done while allocating FRAME.  */
1160
1161   /* Step 2c: Create DB by concatenating lHash, PS, 0x01 and M.  */
1162   n = nframe - valuelen - 1;
1163   frame[n] = 0x01;
1164   memcpy (frame + n + 1, value, valuelen);
1165
1166   /* Step 3d: Generate seed.  We store it where the maskedSeed will go
1167      later. */
1168   gcry_randomize (frame + 1, hlen, GCRY_STRONG_RANDOM);
1169
1170   /* Step 2e and 2f: Create maskedDB.  */
1171   {
1172     unsigned char *dmask;
1173
1174     dmask = gcry_malloc_secure (nframe - hlen - 1);
1175     if (!dmask)
1176       {
1177         rc = gpg_err_code_from_syserror ();
1178         gcry_free (frame);
1179         return rc;
1180       }
1181     rc = mgf1 (dmask, nframe - hlen - 1, frame+1, hlen, algo);
1182     if (rc)
1183       {
1184         gcry_free (dmask);
1185         gcry_free (frame);
1186         return rc;
1187       }
1188     for (n = 1 + hlen, p = dmask; n < nframe; n++)
1189       frame[n] ^= *p++;
1190     gcry_free (dmask);
1191   }
1192
1193   /* Step 2g and 2h: Create maskedSeed.  */
1194   {
1195     unsigned char *smask;
1196
1197     smask = gcry_malloc_secure (hlen);
1198     if (!smask)
1199       {
1200         rc = gpg_err_code_from_syserror ();
1201         gcry_free (frame);
1202         return rc;
1203       }
1204     rc = mgf1 (smask, hlen, frame + 1 + hlen, nframe - hlen - 1, algo);
1205     if (rc)
1206       {
1207         gcry_free (smask);
1208         gcry_free (frame);
1209         return rc;
1210       }
1211     for (n = 1, p = smask; n < 1 + hlen; n++)
1212       frame[n] ^= *p++;
1213     gcry_free (smask);
1214   }
1215
1216   /* Step 2i: Concatenate 0x00, maskedSeed and maskedDB.  */
1217   /* This has already been done by using in-place operations.  */
1218
1219   /* Convert the stuff into an MPI as expected by the caller.  */
1220   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, nframe, NULL);
1221   if (err)
1222     rc = gcry_err_code (err);
1223   else if (DBG_CIPHER)
1224     log_mpidump ("OAEP encoded data", *r_result);
1225   gcry_free (frame);
1226
1227   return rc;
1228 }
1229
1230
1231 /* RFC-3447 (pkcs#1 v2.1) OAEP decoding.  NBITS is the length of the
1232    key measured in bits.  ALGO is the hash function; it must be a
1233    valid and usable algorithm.  VALUE is the raw decrypted message
1234    {LABEL,LABELLEN} is the optional label to be associated with the
1235    message, if LABEL is NULL the default is to use the empty string as
1236    label.  On success the plaintext is returned as a newly allocated
1237    buffer at R_RESULT; its valid length is stored at R_RESULTLEN.  On
1238    error NULL is stored at R_RESULT.  */
1239 static gcry_err_code_t
1240 oaep_decode (unsigned char **r_result, size_t *r_resultlen,
1241              unsigned int nbits, int algo,
1242              gcry_mpi_t value, const unsigned char *label, size_t labellen)
1243 {
1244   gcry_err_code_t rc;
1245   unsigned char *frame = NULL; /* Encoded messages (EM).  */
1246   unsigned char *masked_seed;  /* Points into FRAME.  */
1247   unsigned char *masked_db;    /* Points into FRAME.  */
1248   unsigned char *seed = NULL;  /* Allocated space for the seed and DB.  */
1249   unsigned char *db;           /* Points into SEED.  */
1250   unsigned char *lhash = NULL; /* Hash of the label.  */
1251   size_t nframe;               /* Length of the ciphertext (EM).  */
1252   size_t hlen;                 /* Length of the hash digest.  */
1253   size_t db_len;               /* Length of DB and masked_db.  */
1254   size_t nkey = (nbits+7)/8;   /* Length of the key in bytes.  */
1255   int failed = 0;              /* Error indicator.  */
1256   size_t noff, n;
1257
1258   *r_result = NULL;
1259
1260   /* This code is implemented as described by rfc-3447 7.1.2.  */
1261
1262   /* Set defaults for LABEL.  */
1263   if (!label || !labellen)
1264     {
1265       label = (const unsigned char*)"";
1266       labellen = 0;
1267     }
1268
1269   /* Get the length of the digest.  */
1270   hlen = gcry_md_get_algo_dlen (algo);
1271
1272   /* Hash the label right away.  */
1273   lhash = gcry_malloc (hlen);
1274   if (!lhash)
1275     return gpg_err_code_from_syserror ();
1276   gcry_md_hash_buffer (algo, lhash, label, labellen);
1277
1278   /* Turn the MPI into an octet string.  If the octet string is
1279      shorter than the key we pad it to the left with zeroes.  This may
1280      happen due to the leading zero in OAEP frames and due to the
1281      following random octets (seed^mask) which may have leading zero
1282      bytes.  This all is needed to cope with our leading zeroes
1283      suppressing MPI implementation.  The code implictly implements
1284      Step 1b (bail out if NFRAME != N).  */
1285   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
1286                                       NULL, 0, &nframe, value));
1287   if (rc || nframe > nkey)
1288     {
1289       gcry_free (lhash);
1290       return GPG_ERR_ENCODING_PROBLEM;
1291     }
1292   noff = (nframe < nkey)? nkey - nframe : 0;
1293   n = nframe + noff;
1294   frame = mpi_is_secure (value)? gcry_malloc_secure (n) : gcry_malloc (n);
1295   if (!frame)
1296     {
1297       rc = gpg_error_from_syserror ();
1298       gcry_free (lhash);
1299       return rc;
1300     }
1301   if (noff)
1302     memset (frame, 0, noff);
1303   nframe += noff;
1304   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
1305                                       frame+noff, nframe-noff, NULL, value));
1306   if (rc)
1307     {
1308       gcry_free (frame);
1309       gcry_free (lhash);
1310       return rc;
1311     }
1312
1313   /* Step 1c: Check that the key is long enough.  */
1314   if ( nframe < 2 * hlen + 2 )
1315     {
1316       gcry_free (frame);
1317       gcry_free (lhash);
1318       return GPG_ERR_ENCODING_PROBLEM;
1319     }
1320
1321   /* Step 2 has already been done by the caller and the
1322      gcry_mpi_aprint above.  */
1323
1324   /* Allocate space for SEED and DB.  */
1325   seed = gcry_malloc_secure (nframe - 1);
1326   if (!seed)
1327     {
1328       rc = gpg_err_code_from_syserror ();
1329       gcry_free (frame);
1330       gcry_free (lhash);
1331       return rc;
1332     }
1333   db = seed + hlen;
1334
1335   /* To avoid choosen ciphertext attacks from now on we make sure to
1336      run all code even in the error case; this avoids possible timing
1337      attacks as described by Manger.  */
1338
1339   /* Step 3a: Hash the label.  */
1340   /* This has already been done.  */
1341
1342   /* Step 3b: Separate the encoded message.  */
1343   masked_seed = frame + 1;
1344   masked_db   = frame + 1 + hlen;
1345   db_len      = nframe - 1 - hlen;
1346
1347   /* Step 3c and 3d: seed = maskedSeed ^ mgf(maskedDB, hlen).  */
1348   if (mgf1 (seed, hlen, masked_db, db_len, algo))
1349     failed = 1;
1350   for (n = 0; n < hlen; n++)
1351     seed[n] ^= masked_seed[n];
1352
1353   /* Step 3e and 3f: db = maskedDB ^ mgf(seed, db_len).  */
1354   if (mgf1 (db, db_len, seed, hlen, algo))
1355     failed = 1;
1356   for (n = 0; n < db_len; n++)
1357     db[n] ^= masked_db[n];
1358
1359   /* Step 3g: Check lhash, an possible empty padding string terminated
1360      by 0x01 and the first byte of EM being 0.  */
1361   if (memcmp (lhash, db, hlen))
1362     failed = 1;
1363   for (n = hlen; n < db_len; n++)
1364     if (db[n] == 0x01)
1365       break;
1366   if (n == db_len)
1367     failed = 1;
1368   if (frame[0])
1369     failed = 1;
1370
1371   gcry_free (lhash);
1372   gcry_free (frame);
1373   if (failed)
1374     {
1375       gcry_free (seed);
1376       return GPG_ERR_ENCODING_PROBLEM;
1377     }
1378
1379   /* Step 4: Output M.  */
1380   /* To avoid an extra allocation we reuse the seed buffer.  The only
1381      caller of this function will anyway free the result soon.  */
1382   n++;
1383   memmove (seed, db + n, db_len - n);
1384   *r_result = seed;
1385   *r_resultlen = db_len - n;
1386   seed = NULL;
1387
1388   if (DBG_CIPHER)
1389     log_printhex ("value extracted from OAEP encoded data:",
1390                   *r_result, *r_resultlen);
1391
1392   return 0;
1393 }
1394
1395
1396 /* RFC-3447 (pkcs#1 v2.1) PSS encoding.  Encode {VALUE,VALUELEN} for
1397    an NBITS key.  ALGO is a valid hash algorithm and SALTLEN is the
1398    length of salt to be used.  On success the result is stored as a
1399    new MPI at R_RESULT.  On error the value at R_RESULT is undefined.
1400
1401    Here is figure 2 from the RFC (errata 595 applied) depicting the
1402    process:
1403
1404                                   +-----------+
1405                                   |     M     |
1406                                   +-----------+
1407                                         |
1408                                         V
1409                                       Hash
1410                                         |
1411                                         V
1412                           +--------+----------+----------+
1413                      M' = |Padding1|  mHash   |   salt   |
1414                           +--------+----------+----------+
1415                                          |
1416                +--------+----------+     V
1417          DB =  |Padding2| salt     |   Hash
1418                +--------+----------+     |
1419                          |               |
1420                          V               |    +----+
1421                         xor <--- MGF <---|    |0xbc|
1422                          |               |    +----+
1423                          |               |      |
1424                          V               V      V
1425                +-------------------+----------+----+
1426          EM =  |    maskedDB       |     H    |0xbc|
1427                +-------------------+----------+----+
1428
1429   */
1430 static gcry_err_code_t
1431 pss_encode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1432             const unsigned char *value, size_t valuelen,
1433             int saltlen)
1434 {
1435   gcry_err_code_t rc = 0;
1436   gcry_error_t err;
1437   size_t hlen;                 /* Length of the hash digest.  */
1438   unsigned char *em = NULL;    /* Encoded message.  */
1439   size_t emlen = (nbits+7)/8;  /* Length in bytes of EM.  */
1440   unsigned char *h;            /* Points into EM.  */
1441   unsigned char *buf = NULL;   /* Help buffer.  */
1442   size_t buflen;               /* Length of BUF.  */
1443   unsigned char *mhash;        /* Points into BUF.  */
1444   unsigned char *salt;         /* Points into BUF.  */
1445   unsigned char *dbmask;       /* Points into BUF.  */
1446   unsigned char *p;
1447   size_t n;
1448
1449   /* This code is implemented as described by rfc-3447 9.1.1.  */
1450
1451   /* Get the length of the digest.  */
1452   hlen = gcry_md_get_algo_dlen (algo);
1453   gcry_assert (hlen);  /* We expect a valid ALGO here.  */
1454
1455   /* Allocate a help buffer and setup some pointers.  */
1456   buflen = 8 + hlen + saltlen + (emlen - hlen - 1);
1457   buf = gcry_malloc (buflen);
1458   if (!buf)
1459     {
1460       rc = gpg_err_code_from_syserror ();
1461       goto leave;
1462     }
1463   mhash = buf + 8;
1464   salt  = mhash + hlen;
1465   dbmask= salt + saltlen;
1466
1467   /* Step 2: mHash = Hash(M).  */
1468   /* Fixme: We should not do that but use VALUE directly as the hash.  */
1469   gcry_md_hash_buffer (algo, mhash, value, valuelen);
1470
1471   /* Step 3: Check length constraints.  */
1472   if (emlen < hlen + saltlen + 2)
1473     {
1474       rc = GPG_ERR_TOO_SHORT;
1475       goto leave;
1476     }
1477
1478   /* Allocate space for EM.  */
1479   em = gcry_malloc (emlen);
1480   if (!em)
1481     {
1482       rc = gpg_err_code_from_syserror ();
1483       goto leave;
1484     }
1485   h = em + emlen - 1 - hlen;
1486
1487   /* Step 4: Create a salt.  */
1488   if (saltlen)
1489     gcry_randomize (salt, saltlen, GCRY_STRONG_RANDOM);
1490
1491   /* Step 5 and 6: M' = Hash(Padding1 || mHash || salt).  */
1492   memset (buf, 0, 8);  /* Padding.  */
1493   gcry_md_hash_buffer (algo, h, buf, 8 + hlen + saltlen);
1494
1495   /* Step 7 and 8: DB = PS || 0x01 || salt.  */
1496   /* Note that we use EM to store DB and later Xor in-place.  */
1497   p = em + emlen - 1 - hlen - saltlen - 1;
1498   memset (em, 0, p - em);
1499   *p++ = 0x01;
1500   memcpy (p, salt, saltlen);
1501
1502   /* Step 9: dbmask = MGF(H, emlen - hlen - 1).  */
1503   mgf1 (dbmask, emlen - hlen - 1, h, hlen, algo);
1504
1505   /* Step 10: maskedDB = DB ^ dbMask */
1506   for (n = 0, p = dbmask; n < emlen - hlen - 1; n++, p++)
1507     em[n] ^= *p;
1508
1509   /* Step 11: Set the leftmost bits to zero.  */
1510   em[0] &= 0xFF >> (8 * emlen - nbits);
1511
1512   /* Step 12: EM = maskedDB || H || 0xbc.  */
1513   em[emlen-1] = 0xbc;
1514
1515   /* Convert EM into an MPI.  */
1516   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, em, emlen, NULL);
1517   if (err)
1518     rc = gcry_err_code (err);
1519   else if (DBG_CIPHER)
1520     log_mpidump ("PSS encoded data", *r_result);
1521
1522  leave:
1523   if (em)
1524     {
1525       wipememory (em, emlen);
1526       gcry_free (em);
1527     }
1528   if (buf)
1529     {
1530       wipememory (buf, buflen);
1531       gcry_free (buf);
1532     }
1533   return rc;
1534 }
1535
1536
1537 /* Turn VALUE into an octet string and store that at R_FRAME.  If that
1538    octet string is shorter than NBYTES pad it to the left with zeroes.
1539    If VALUE does not fit into NBYTES return an error code. */
1540 static gpg_err_code_t
1541 octet_string_from_mpi (unsigned char **r_frame, gcry_mpi_t value, size_t nbytes)
1542 {
1543   gpg_err_code_t rc;
1544   size_t nframe, noff, n;
1545   unsigned char *frame;
1546
1547   *r_frame = NULL;
1548
1549   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
1550                                       NULL, 0, &nframe, value));
1551   if (rc)
1552     return rc;
1553   if (nframe > nbytes)
1554     return GPG_ERR_TOO_LARGE; /* Value too long to fit into NBYTES.  */
1555
1556   noff = (nframe < nbytes)? nbytes - nframe : 0;
1557   n = nframe + noff;
1558   frame = mpi_is_secure (value)? gcry_malloc_secure (n) : gcry_malloc (n);
1559   if (!frame)
1560     {
1561       rc = gpg_err_code_from_syserror ();
1562       return rc;
1563     }
1564   if (noff)
1565     memset (frame, 0, noff);
1566   nframe += noff;
1567   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
1568                                       frame+noff, nframe-noff, NULL, value));
1569   if (rc)
1570     {
1571       gcry_free (frame);
1572       return rc;
1573     }
1574
1575   *r_frame = frame;
1576   return 0;
1577 }
1578
1579
1580 /* Verify a signature assuming PSS padding.  VALUE is the hash of the
1581    message.  ENCODED is the output of the RSA public key function.
1582    NBITS is the size of the secret key.  ALGO is a hash algorithm and
1583    SALTLEN is the length of the used salt.  The function returns 0 on
1584    success or on error code otherwise.  */
1585 static gcry_err_code_t
1586 pss_verify (gcry_mpi_t value, gcry_mpi_t encoded, unsigned int nbits, int algo,
1587             size_t saltlen)
1588 {
1589   gcry_err_code_t rc = 0;
1590   size_t hlen;                 /* Length of the hash digest.  */
1591   unsigned char *em = NULL;    /* Encoded message.  */
1592   size_t emlen = (nbits+7)/8;  /* Length in bytes of EM.  */
1593   unsigned char *salt;         /* Points into EM.  */
1594   unsigned char *h;            /* Points into EM.  */
1595   unsigned char *buf = NULL;   /* Help buffer.  */
1596   size_t buflen;               /* Length of BUF.  */
1597   unsigned char *dbmask;       /* Points into BUF.  */
1598   unsigned char *mhash;        /* Points into BUF.  */
1599   unsigned char *p;
1600   size_t n;
1601
1602   /* This code is implemented as described by rfc-3447 9.1.2.  */
1603
1604   /* Get the length of the digest.  */
1605   hlen = gcry_md_get_algo_dlen (algo);
1606   gcry_assert (hlen);  /* We expect a valid ALGO here.  */
1607
1608   /* Allocate a help buffer and setup some pointers.
1609      This buffer is used for two purposes:
1610         +------------------------------+-------+
1611      1. | dbmask                       | mHash |
1612         +------------------------------+-------+
1613            emlen - hlen - 1              hlen
1614
1615         +----------+-------+---------+-+-------+
1616      2. | padding1 | mHash | salt    | | mHash |
1617         +----------+-------+---------+-+-------+
1618              8       hlen    saltlen     hlen
1619   */
1620   buflen = 8 + hlen + saltlen;
1621   if (buflen < emlen - hlen - 1)
1622     buflen = emlen - hlen - 1;
1623   buflen += hlen;
1624   buf = gcry_malloc (buflen);
1625   if (!buf)
1626     {
1627       rc = gpg_err_code_from_syserror ();
1628       goto leave;
1629     }
1630   dbmask = buf;
1631   mhash = buf + buflen - hlen;
1632
1633   /* Convert the value into an octet string.  */
1634   /* rc = octet_string_from_mpi (&em, value, emlen); */
1635   /* if (rc) */
1636   /*   goto leave; */
1637
1638   em = gcry_malloc (emlen);
1639   if (!em)
1640     {
1641       rc = gpg_err_code_from_syserror ();
1642       goto leave;
1643     }
1644   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG, em, emlen, &n, value));
1645   if (rc)
1646     goto leave;
1647
1648   /* Step 2: mHash = Hash(M).  */
1649   /* Fixme: We should not do that but use VALUE directly as the hash.  */
1650   gcry_md_hash_buffer (algo, mhash, em, n);
1651   gcry_free (em);
1652   em = NULL;
1653
1654   /* Convert the signature into an octet string.  */
1655   rc = octet_string_from_mpi (&em, encoded, emlen);
1656   if (rc)
1657     goto leave;
1658
1659   /* Step 3: Check length of EM.  Because we internally use MPI
1660      functions we can't do this properly; EMLEN is always the length
1661      of the key because octet_string_from_mpi needs to left pad the
1662      result with zero to cope with the fact that our MPIs suppress all
1663      leading zeroes.  Thus what we test here are merely the digest and
1664      salt lengths to the key.  */
1665   if (emlen < hlen + saltlen + 2)
1666     {
1667       rc = GPG_ERR_TOO_SHORT; /* For the hash and saltlen.  */
1668       goto leave;
1669     }
1670
1671   /* Step 4: Check last octet.  */
1672   if (em[emlen - 1] != 0xbc)
1673     {
1674       rc = GPG_ERR_BAD_SIGNATURE;
1675       goto leave;
1676     }
1677
1678   /* Step 5: Split EM.  */
1679   h = em + emlen - 1 - hlen;
1680
1681   /* Step 6: Check the leftmost bits.  */
1682   if ((em[0] & ~(0xFF >> (8 * emlen - nbits))))
1683     {
1684       rc = GPG_ERR_BAD_SIGNATURE;
1685       goto leave;
1686     }
1687
1688   /* Step 7: dbmask = MGF(H, emlen - hlen - 1).  */
1689   mgf1 (dbmask, emlen - hlen - 1, h, hlen, algo);
1690
1691   /* Step 8: maskedDB = DB ^ dbMask.  */
1692   for (n = 0, p = dbmask; n < emlen - hlen - 1; n++, p++)
1693     em[n] ^= *p;
1694
1695   /* Step 9: Set leftmost bits in DB to zero.  */
1696   em[0] &= 0xFF >> (8 * emlen - nbits);
1697
1698   /* Step 10: Check the padding of DB.  */
1699   for (n = 0; n < emlen - hlen - saltlen - 2 && !em[n]; n++)
1700     ;
1701   if (n != emlen - hlen - saltlen - 2 || em[n++] != 1)
1702     {
1703       rc = GPG_ERR_BAD_SIGNATURE;
1704       goto leave;
1705     }
1706
1707   /* Step 11: Extract salt from DB.  */
1708   salt = em + n;
1709
1710   /* Step 12:  M' = (0x)00 00 00 00 00 00 00 00 || mHash || salt */
1711   memset (buf, 0, 8);
1712   memcpy (buf+8, mhash, hlen);
1713   memcpy (buf+8+hlen, salt, saltlen);
1714
1715   /* Step 13:  H' = Hash(M').  */
1716   gcry_md_hash_buffer (algo, buf, buf, 8 + hlen + saltlen);
1717
1718   /* Step 14:  Check H == H'.   */
1719   rc = memcmp (h, buf, hlen) ? GPG_ERR_BAD_SIGNATURE : GPG_ERR_NO_ERROR;
1720
1721  leave:
1722   if (em)
1723     {
1724       wipememory (em, emlen);
1725       gcry_free (em);
1726     }
1727   if (buf)
1728     {
1729       wipememory (buf, buflen);
1730       gcry_free (buf);
1731     }
1732   return rc;
1733 }
1734
1735
1736 /* Callback for the pubkey algorithm code to verify PSS signatures.
1737    OPAQUE is the data provided by the actual caller.  The meaning of
1738    TMP depends on the actual algorithm (but there is only RSA); now
1739    for RSA it is the output of running the public key function on the
1740    input.  */
1741 static int
1742 pss_verify_cmp (void *opaque, gcry_mpi_t tmp)
1743 {
1744   struct pk_encoding_ctx *ctx = opaque;
1745   gcry_mpi_t hash = ctx->verify_arg;
1746
1747   return pss_verify (hash, tmp, ctx->nbits - 1, ctx->hash_algo, ctx->saltlen);
1748 }
1749
1750
1751 /* Internal function.   */
1752 static gcry_err_code_t
1753 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
1754                        gcry_mpi_t *elements, const char *algo_name)
1755 {
1756   gcry_err_code_t err = 0;
1757   int i, idx;
1758   const char *name;
1759   gcry_sexp_t list;
1760
1761   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1762     {
1763       list = gcry_sexp_find_token (key_sexp, name, 1);
1764       if (!list)
1765         elements[idx] = NULL;
1766       else
1767         {
1768           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
1769           gcry_sexp_release (list);
1770           if (!elements[idx])
1771             err = GPG_ERR_INV_OBJ;
1772         }
1773     }
1774
1775   if (!err)
1776     {
1777       /* Check that all elements are available.  */
1778       for (name = element_names, idx = 0; *name; name++, idx++)
1779         if (!elements[idx])
1780           break;
1781       if (*name)
1782         {
1783           err = GPG_ERR_NO_OBJ;
1784           /* Some are missing.  Before bailing out we test for
1785              optional parameters.  */
1786           if (algo_name && !strcmp (algo_name, "RSA")
1787               && !strcmp (element_names, "nedpqu") )
1788             {
1789               /* This is RSA.  Test whether we got N, E and D and that
1790                  the optional P, Q and U are all missing.  */
1791               if (elements[0] && elements[1] && elements[2]
1792                   && !elements[3] && !elements[4] && !elements[5])
1793                 err = 0;
1794             }
1795         }
1796     }
1797
1798
1799   if (err)
1800     {
1801       for (i = 0; i < idx; i++)
1802         if (elements[i])
1803           gcry_free (elements[i]);
1804     }
1805   return err;
1806 }
1807
1808
1809 /* Internal function used for ecc.  Note, that this function makes use
1810    of its intimate knowledge about the ECC parameters from ecc.c. */
1811 static gcry_err_code_t
1812 sexp_elements_extract_ecc (gcry_sexp_t key_sexp, const char *element_names,
1813                            gcry_mpi_t *elements, pk_extra_spec_t *extraspec)
1814
1815 {
1816   gcry_err_code_t err = 0;
1817   int idx;
1818   const char *name;
1819   gcry_sexp_t list;
1820
1821   /* Clear the array for easier error cleanup. */
1822   for (name = element_names, idx = 0; *name; name++, idx++)
1823     elements[idx] = NULL;
1824   gcry_assert (idx >= 5); /* We know that ECC has at least 5 elements
1825                              (params only) or 6 (full public key).  */
1826   if (idx == 5)
1827     elements[5] = NULL;   /* Extra clear for the params only case.  */
1828
1829
1830   /* Init the array with the available curve parameters. */
1831   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1832     {
1833       list = gcry_sexp_find_token (key_sexp, name, 1);
1834       if (!list)
1835         elements[idx] = NULL;
1836       else
1837         {
1838           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
1839           gcry_sexp_release (list);
1840           if (!elements[idx])
1841             {
1842               err = GPG_ERR_INV_OBJ;
1843               goto leave;
1844             }
1845         }
1846     }
1847
1848   /* Check whether a curve parameter has been given and then fill any
1849      missing elements.  */
1850   list = gcry_sexp_find_token (key_sexp, "curve", 5);
1851   if (list)
1852     {
1853       if (extraspec->get_param)
1854         {
1855           char *curve;
1856           gcry_mpi_t params[6];
1857
1858           for (idx = 0; idx < DIM(params); idx++)
1859             params[idx] = NULL;
1860
1861           curve = _gcry_sexp_nth_string (list, 1);
1862           gcry_sexp_release (list);
1863           if (!curve)
1864             {
1865               /* No curve name given (or out of core). */
1866               err = GPG_ERR_INV_OBJ;
1867               goto leave;
1868             }
1869           err = extraspec->get_param (curve, params);
1870           gcry_free (curve);
1871           if (err)
1872             goto leave;
1873
1874           for (idx = 0; idx < DIM(params); idx++)
1875             {
1876               if (!elements[idx])
1877                 elements[idx] = params[idx];
1878               else
1879                 mpi_free (params[idx]);
1880             }
1881         }
1882       else
1883         {
1884           gcry_sexp_release (list);
1885           err = GPG_ERR_INV_OBJ; /* "curve" given but ECC not supported. */
1886           goto leave;
1887         }
1888     }
1889
1890   /* Check that all parameters are known.  */
1891   for (name = element_names, idx = 0; *name; name++, idx++)
1892     if (!elements[idx])
1893       {
1894         err = GPG_ERR_NO_OBJ;
1895         goto leave;
1896       }
1897
1898  leave:
1899   if (err)
1900     {
1901       for (name = element_names, idx = 0; *name; name++, idx++)
1902         if (elements[idx])
1903           gcry_free (elements[idx]);
1904     }
1905   return err;
1906 }
1907
1908
1909
1910 /****************
1911  * Convert a S-Exp with either a private or a public key to our
1912  * internal format. Currently we do only support the following
1913  * algorithms:
1914  *    dsa
1915  *    rsa
1916  *    openpgp-dsa
1917  *    openpgp-rsa
1918  *    openpgp-elg
1919  *    openpgp-elg-sig
1920  *    ecdsa
1921  *    ecdh
1922  * Provide a SE with the first element be either "private-key" or
1923  * or "public-key". It is followed by a list with its first element
1924  * be one of the above algorithm identifiers and the remaning
1925  * elements are pairs with parameter-id and value.
1926  * NOTE: we look through the list to find a list beginning with
1927  * "private-key" or "public-key" - the first one found is used.
1928  *
1929  * If OVERRIDE_ELEMS is not NULL those elems override the parameter
1930  * specification taken from the module.  This ise used by
1931  * gcry_pk_get_curve.
1932  *
1933  * Returns: A pointer to an allocated array of MPIs if the return value is
1934  *          zero; the caller has to release this array.
1935  *
1936  * Example of a DSA public key:
1937  *  (private-key
1938  *    (dsa
1939  *      (p <mpi>)
1940  *      (g <mpi>)
1941  *      (y <mpi>)
1942  *      (x <mpi>)
1943  *    )
1944  *  )
1945  * The <mpi> are expected to be in GCRYMPI_FMT_USG
1946  */
1947 static gcry_err_code_t
1948 sexp_to_key (gcry_sexp_t sexp, int want_private, const char *override_elems,
1949              gcry_mpi_t **retarray, gcry_module_t *retalgo)
1950 {
1951   gcry_err_code_t err = 0;
1952   gcry_sexp_t list, l2;
1953   char *name;
1954   const char *elems;
1955   gcry_mpi_t *array;
1956   gcry_module_t module;
1957   gcry_pk_spec_t *pubkey;
1958   pk_extra_spec_t *extraspec;
1959   int is_ecc;
1960
1961   /* Check that the first element is valid.  */
1962   list = gcry_sexp_find_token (sexp,
1963                                want_private? "private-key":"public-key", 0);
1964   if (!list)
1965     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
1966
1967   l2 = gcry_sexp_cadr( list );
1968   gcry_sexp_release ( list );
1969   list = l2;
1970   name = _gcry_sexp_nth_string (list, 0);
1971   if (!name)
1972     {
1973       gcry_sexp_release ( list );
1974       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
1975     }
1976
1977   ath_mutex_lock (&pubkeys_registered_lock);
1978   module = gcry_pk_lookup_name (name);
1979   ath_mutex_unlock (&pubkeys_registered_lock);
1980
1981   /* Fixme: We should make sure that an ECC key is always named "ecc"
1982      and not "ecdsa".  "ecdsa" should be used for the signature
1983      itself.  We need a function to test whether an algorithm given
1984      with a key is compatible with an application of the key (signing,
1985      encryption).  For RSA this is easy, but ECC is the first
1986      algorithm which has many flavours.  */
1987   is_ecc = ( !strcmp (name, "ecdsa")
1988              || !strcmp (name, "ecdh")
1989              || !strcmp (name, "ecc") );
1990   gcry_free (name);
1991
1992   if (!module)
1993     {
1994       gcry_sexp_release (list);
1995       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
1996     }
1997   else
1998     {
1999       pubkey = (gcry_pk_spec_t *) module->spec;
2000       extraspec = module->extraspec;
2001     }
2002
2003   if (override_elems)
2004     elems = override_elems;
2005   else if (want_private)
2006     elems = pubkey->elements_skey;
2007   else
2008     elems = pubkey->elements_pkey;
2009   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
2010   if (!array)
2011     err = gpg_err_code_from_syserror ();
2012   if (!err)
2013     {
2014       if (is_ecc)
2015         err = sexp_elements_extract_ecc (list, elems, array, extraspec);
2016       else
2017         err = sexp_elements_extract (list, elems, array, pubkey->name);
2018     }
2019
2020   gcry_sexp_release (list);
2021
2022   if (err)
2023     {
2024       gcry_free (array);
2025
2026       ath_mutex_lock (&pubkeys_registered_lock);
2027       _gcry_module_release (module);
2028       ath_mutex_unlock (&pubkeys_registered_lock);
2029     }
2030   else
2031     {
2032       *retarray = array;
2033       *retalgo = module;
2034     }
2035
2036   return err;
2037 }
2038
2039
2040 static gcry_err_code_t
2041 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
2042              gcry_module_t *retalgo)
2043 {
2044   gcry_err_code_t err = 0;
2045   gcry_sexp_t list, l2;
2046   char *name;
2047   const char *elems;
2048   gcry_mpi_t *array;
2049   gcry_module_t module;
2050   gcry_pk_spec_t *pubkey;
2051
2052   /* Check that the first element is valid.  */
2053   list = gcry_sexp_find_token( sexp, "sig-val" , 0 );
2054   if (!list)
2055     return GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
2056
2057   l2 = gcry_sexp_nth (list, 1);
2058   if (!l2)
2059     {
2060       gcry_sexp_release (list);
2061       return GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
2062     }
2063   name = _gcry_sexp_nth_string (l2, 0);
2064   if (!name)
2065     {
2066       gcry_sexp_release (list);
2067       gcry_sexp_release (l2);
2068       return GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
2069     }
2070   else if (!strcmp (name, "flags"))
2071     {
2072       /* Skip flags, since they are not used but here just for the
2073          sake of consistent S-expressions.  */
2074       gcry_free (name);
2075       gcry_sexp_release (l2);
2076       l2 = gcry_sexp_nth (list, 2);
2077       if (!l2)
2078         {
2079           gcry_sexp_release (list);
2080           return GPG_ERR_INV_OBJ;
2081         }
2082       name = _gcry_sexp_nth_string (l2, 0);
2083     }
2084
2085   ath_mutex_lock (&pubkeys_registered_lock);
2086   module = gcry_pk_lookup_name (name);
2087   ath_mutex_unlock (&pubkeys_registered_lock);
2088   gcry_free (name);
2089   name = NULL;
2090
2091   if (!module)
2092     {
2093       gcry_sexp_release (l2);
2094       gcry_sexp_release (list);
2095       return GPG_ERR_PUBKEY_ALGO;  /* Unknown algorithm. */
2096     }
2097   else
2098     pubkey = (gcry_pk_spec_t *) module->spec;
2099
2100   elems = pubkey->elements_sig;
2101   array = gcry_calloc (strlen (elems) + 1 , sizeof *array );
2102   if (!array)
2103     err = gpg_err_code_from_syserror ();
2104
2105   if (!err)
2106     err = sexp_elements_extract (list, elems, array, NULL);
2107
2108   gcry_sexp_release (l2);
2109   gcry_sexp_release (list);
2110
2111   if (err)
2112     {
2113       ath_mutex_lock (&pubkeys_registered_lock);
2114       _gcry_module_release (module);
2115       ath_mutex_unlock (&pubkeys_registered_lock);
2116
2117       gcry_free (array);
2118     }
2119   else
2120     {
2121       *retarray = array;
2122       *retalgo = module;
2123     }
2124
2125   return err;
2126 }
2127
2128 static inline int
2129 get_hash_algo (const char *s, size_t n)
2130 {
2131   static const struct { const char *name; int algo; } hashnames[] = {
2132     { "sha1",   GCRY_MD_SHA1 },
2133     { "md5",    GCRY_MD_MD5 },
2134     { "sha256", GCRY_MD_SHA256 },
2135     { "ripemd160", GCRY_MD_RMD160 },
2136     { "rmd160", GCRY_MD_RMD160 },
2137     { "sha384", GCRY_MD_SHA384 },
2138     { "sha512", GCRY_MD_SHA512 },
2139     { "sha224", GCRY_MD_SHA224 },
2140     { "md2",    GCRY_MD_MD2 },
2141     { "md4",    GCRY_MD_MD4 },
2142     { "tiger",  GCRY_MD_TIGER },
2143     { "haval",  GCRY_MD_HAVAL },
2144     { NULL, 0 }
2145   };
2146   int algo;
2147   int i;
2148
2149   for (i=0; hashnames[i].name; i++)
2150     {
2151       if ( strlen (hashnames[i].name) == n
2152            && !memcmp (hashnames[i].name, s, n))
2153         break;
2154     }
2155   if (hashnames[i].name)
2156     algo = hashnames[i].algo;
2157   else
2158     {
2159       /* In case of not listed or dynamically allocated hash
2160          algorithm we fall back to this somewhat slower
2161          method.  Further, it also allows to use OIDs as
2162          algorithm names. */
2163       char *tmpname;
2164
2165       tmpname = gcry_malloc (n+1);
2166       if (!tmpname)
2167         algo = 0;  /* Out of core - silently give up.  */
2168       else
2169         {
2170           memcpy (tmpname, s, n);
2171           tmpname[n] = 0;
2172           algo = gcry_md_map_name (tmpname);
2173           gcry_free (tmpname);
2174         }
2175     }
2176   return algo;
2177 }
2178
2179
2180 /****************
2181  * Take sexp and return an array of MPI as used for our internal decrypt
2182  * function.
2183  * s_data = (enc-val
2184  *           [(flags [raw, pkcs1, oaep, no-blinding])]
2185  *           [(hash-algo <algo>)]
2186  *           [(label <label>)]
2187  *            (<algo>
2188  *              (<param_name1> <mpi>)
2189  *              ...
2190  *              (<param_namen> <mpi>)
2191  *            ))
2192  * HASH-ALGO and LABEL are specific to OAEP.
2193  * RET_MODERN is set to true when at least an empty flags list has been found.
2194  * CTX is used to return encoding information; it may be NULL in which
2195  * case raw encoding is used.
2196  */
2197 static gcry_err_code_t
2198 sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
2199              int *ret_modern, int *flags, struct pk_encoding_ctx *ctx)
2200 {
2201   gcry_err_code_t err = 0;
2202   gcry_sexp_t list = NULL, l2 = NULL;
2203   gcry_pk_spec_t *pubkey = NULL;
2204   gcry_module_t module = NULL;
2205   char *name = NULL;
2206   size_t n;
2207   int parsed_flags = 0;
2208   const char *elems;
2209   gcry_mpi_t *array = NULL;
2210
2211   *ret_modern = 0;
2212
2213   /* Check that the first element is valid.  */
2214   list = gcry_sexp_find_token (sexp, "enc-val" , 0);
2215   if (!list)
2216     {
2217       err = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
2218       goto leave;
2219     }
2220
2221   l2 = gcry_sexp_nth (list, 1);
2222   if (!l2)
2223     {
2224       err = GPG_ERR_NO_OBJ; /* No cdr for the data object.  */
2225       goto leave;
2226     }
2227
2228   /* Extract identifier of sublist.  */
2229   name = _gcry_sexp_nth_string (l2, 0);
2230   if (!name)
2231     {
2232       err = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
2233       goto leave;
2234     }
2235
2236   if (!strcmp (name, "flags"))
2237     {
2238       /* There is a flags element - process it.  */
2239       const char *s;
2240       int i;
2241
2242       *ret_modern = 1;
2243       for (i = gcry_sexp_length (l2) - 1; i > 0; i--)
2244         {
2245           s = gcry_sexp_nth_data (l2, i, &n);
2246           if (! s)
2247             ; /* Not a data element - ignore.  */
2248           else if (n == 3 && !memcmp (s, "raw", 3)
2249                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2250             ctx->encoding = PUBKEY_ENC_RAW;
2251           else if (n == 5 && !memcmp (s, "pkcs1", 5)
2252                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2253             ctx->encoding = PUBKEY_ENC_PKCS1;
2254           else if (n == 4 && !memcmp (s, "oaep", 4)
2255                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2256             ctx->encoding = PUBKEY_ENC_OAEP;
2257           else if (n == 3 && !memcmp (s, "pss", 3)
2258                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2259             {
2260               err = GPG_ERR_CONFLICT;
2261               goto leave;
2262             }
2263           else if (n == 11 && ! memcmp (s, "no-blinding", 11))
2264             parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
2265           else
2266             {
2267               err = GPG_ERR_INV_FLAG;
2268               goto leave;
2269             }
2270         }
2271       gcry_sexp_release (l2);
2272
2273       /* Get the OAEP parameters HASH-ALGO and LABEL, if any. */
2274       if (ctx->encoding == PUBKEY_ENC_OAEP)
2275         {
2276           /* Get HASH-ALGO. */
2277           l2 = gcry_sexp_find_token (list, "hash-algo", 0);
2278           if (l2)
2279             {
2280               s = gcry_sexp_nth_data (l2, 1, &n);
2281               if (!s)
2282                 err = GPG_ERR_NO_OBJ;
2283               else
2284                 {
2285                   ctx->hash_algo = get_hash_algo (s, n);
2286                   if (!ctx->hash_algo)
2287                     err = GPG_ERR_DIGEST_ALGO;
2288                 }
2289               gcry_sexp_release (l2);
2290               if (err)
2291                 goto leave;
2292             }
2293
2294           /* Get LABEL. */
2295           l2 = gcry_sexp_find_token (list, "label", 0);
2296           if (l2)
2297             {
2298               s = gcry_sexp_nth_data (l2, 1, &n);
2299               if (!s)
2300                 err = GPG_ERR_NO_OBJ;
2301               else if (n > 0)
2302                 {
2303                   ctx->label = gcry_malloc (n);
2304                   if (!ctx->label)
2305                     err = gpg_err_code_from_syserror ();
2306                   else
2307                     {
2308                       memcpy (ctx->label, s, n);
2309                       ctx->labellen = n;
2310                     }
2311                 }
2312               gcry_sexp_release (l2);
2313               if (err)
2314                 goto leave;
2315             }
2316         }
2317
2318       /* Get the next which has the actual data - skip HASH-ALGO and LABEL. */
2319       for (i = 2; (l2 = gcry_sexp_nth (list, i)) != NULL; i++)
2320         {
2321           s = gcry_sexp_nth_data (l2, 0, &n);
2322           if (!(n == 9 && !memcmp (s, "hash-algo", 9))
2323               && !(n == 5 && !memcmp (s, "label", 5)))
2324             break;
2325           gcry_sexp_release (l2);
2326         }
2327
2328       if (!l2)
2329         {
2330           err = GPG_ERR_NO_OBJ; /* No cdr for the data object. */
2331           goto leave;
2332         }
2333
2334       /* Extract sublist identifier.  */
2335       gcry_free (name);
2336       name = _gcry_sexp_nth_string (l2, 0);
2337       if (!name)
2338         {
2339           err = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
2340           goto leave;
2341         }
2342
2343       gcry_sexp_release (list);
2344       list = l2;
2345       l2 = NULL;
2346     }
2347
2348   ath_mutex_lock (&pubkeys_registered_lock);
2349   module = gcry_pk_lookup_name (name);
2350   ath_mutex_unlock (&pubkeys_registered_lock);
2351
2352   if (!module)
2353     {
2354       err = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
2355       goto leave;
2356     }
2357   pubkey = (gcry_pk_spec_t *) module->spec;
2358
2359   elems = pubkey->elements_enc;
2360   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
2361   if (!array)
2362     {
2363       err = gpg_err_code_from_syserror ();
2364       goto leave;
2365     }
2366
2367   err = sexp_elements_extract (list, elems, array, NULL);
2368
2369  leave:
2370   gcry_sexp_release (list);
2371   gcry_sexp_release (l2);
2372   gcry_free (name);
2373
2374   if (err)
2375     {
2376       ath_mutex_lock (&pubkeys_registered_lock);
2377       _gcry_module_release (module);
2378       ath_mutex_unlock (&pubkeys_registered_lock);
2379       gcry_free (array);
2380       gcry_free (ctx->label);
2381       ctx->label = NULL;
2382     }
2383   else
2384     {
2385       *retarray = array;
2386       *retalgo = module;
2387       *flags = parsed_flags;
2388     }
2389
2390   return err;
2391 }
2392
2393 /* Take the hash value and convert into an MPI, suitable for
2394    passing to the low level functions.  We currently support the
2395    old style way of passing just a MPI and the modern interface which
2396    allows to pass flags so that we can choose between raw and pkcs1
2397    padding - may be more padding options later.
2398
2399    (<mpi>)
2400    or
2401    (data
2402     [(flags [raw, pkcs1, oaep, pss, no-blinding])]
2403     [(hash <algo> <value>)]
2404     [(value <text>)]
2405     [(hash-algo <algo>)]
2406     [(label <label>)]
2407     [(salt-length <length>)]
2408    )
2409
2410    Either the VALUE or the HASH element must be present for use
2411    with signatures.  VALUE is used for encryption.
2412
2413    HASH-ALGO and LABEL are specific to OAEP.
2414
2415    SALT-LENGTH is for PSS.
2416
2417 */
2418 static gcry_err_code_t
2419 sexp_data_to_mpi (gcry_sexp_t input, gcry_mpi_t *ret_mpi,
2420                   struct pk_encoding_ctx *ctx)
2421 {
2422   gcry_err_code_t rc = 0;
2423   gcry_sexp_t ldata, lhash, lvalue;
2424   int i;
2425   size_t n;
2426   const char *s;
2427   int unknown_flag=0;
2428   int parsed_flags = 0;
2429
2430   *ret_mpi = NULL;
2431   ldata = gcry_sexp_find_token (input, "data", 0);
2432   if (!ldata)
2433     { /* assume old style */
2434       *ret_mpi = gcry_sexp_nth_mpi (input, 0, 0);
2435       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
2436     }
2437
2438   /* see whether there is a flags object */
2439   {
2440     gcry_sexp_t lflags = gcry_sexp_find_token (ldata, "flags", 0);
2441     if (lflags)
2442       { /* parse the flags list. */
2443         for (i=gcry_sexp_length (lflags)-1; i > 0; i--)
2444           {
2445             s = gcry_sexp_nth_data (lflags, i, &n);
2446             if (!s)
2447               ; /* not a data element*/
2448             else if ( n == 3 && !memcmp (s, "raw", 3)
2449                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2450               ctx->encoding = PUBKEY_ENC_RAW;
2451             else if ( n == 5 && !memcmp (s, "pkcs1", 5)
2452                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2453               ctx->encoding = PUBKEY_ENC_PKCS1;
2454             else if ( n == 4 && !memcmp (s, "oaep", 4)
2455                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2456               ctx->encoding = PUBKEY_ENC_OAEP;
2457             else if ( n == 3 && !memcmp (s, "pss", 3)
2458                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2459               ctx->encoding = PUBKEY_ENC_PSS;
2460             else if (n == 11 && ! memcmp (s, "no-blinding", 11))
2461               parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
2462             else
2463               unknown_flag = 1;
2464           }
2465         gcry_sexp_release (lflags);
2466       }
2467   }
2468
2469   if (ctx->encoding == PUBKEY_ENC_UNKNOWN)
2470     ctx->encoding = PUBKEY_ENC_RAW; /* default to raw */
2471
2472   /* Get HASH or MPI */
2473   lhash = gcry_sexp_find_token (ldata, "hash", 0);
2474   lvalue = lhash? NULL : gcry_sexp_find_token (ldata, "value", 0);
2475
2476   if (!(!lhash ^ !lvalue))
2477     rc = GPG_ERR_INV_OBJ; /* none or both given */
2478   else if (unknown_flag)
2479     rc = GPG_ERR_INV_FLAG;
2480   else if (ctx->encoding == PUBKEY_ENC_RAW && lvalue)
2481     {
2482       *ret_mpi = gcry_sexp_nth_mpi (lvalue, 1, 0);
2483       if (!*ret_mpi)
2484         rc = GPG_ERR_INV_OBJ;
2485     }
2486   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lvalue
2487            && ctx->op == PUBKEY_OP_ENCRYPT)
2488     {
2489       const void * value;
2490       size_t valuelen;
2491
2492       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
2493         rc = GPG_ERR_INV_OBJ;
2494       else
2495         rc = pkcs1_encode_for_encryption (ret_mpi, ctx->nbits, value, valuelen);
2496     }
2497   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lhash
2498            && (ctx->op == PUBKEY_OP_SIGN || ctx->op == PUBKEY_OP_VERIFY))
2499     {
2500       if (gcry_sexp_length (lhash) != 3)
2501         rc = GPG_ERR_INV_OBJ;
2502       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2503         rc = GPG_ERR_INV_OBJ;
2504       else
2505         {
2506           const void * value;
2507           size_t valuelen;
2508
2509           ctx->hash_algo = get_hash_algo (s, n);
2510
2511           if (!ctx->hash_algo)
2512             rc = GPG_ERR_DIGEST_ALGO;
2513           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
2514                     || !valuelen )
2515             rc = GPG_ERR_INV_OBJ;
2516           else
2517             rc = pkcs1_encode_for_signature (ret_mpi, ctx->nbits,
2518                                              value, valuelen,
2519                                              ctx->hash_algo);
2520         }
2521     }
2522   else if (ctx->encoding == PUBKEY_ENC_OAEP && lvalue
2523            && ctx->op == PUBKEY_OP_ENCRYPT)
2524     {
2525       const void * value;
2526       size_t valuelen;
2527
2528       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
2529         rc = GPG_ERR_INV_OBJ;
2530       else
2531         {
2532           gcry_sexp_t list;
2533
2534           /* Get HASH-ALGO. */
2535           list = gcry_sexp_find_token (ldata, "hash-algo", 0);
2536           if (list)
2537             {
2538               s = gcry_sexp_nth_data (list, 1, &n);
2539               if (!s)
2540                 rc = GPG_ERR_NO_OBJ;
2541               else
2542                 {
2543                   ctx->hash_algo = get_hash_algo (s, n);
2544                   if (!ctx->hash_algo)
2545                     rc = GPG_ERR_DIGEST_ALGO;
2546                 }
2547               gcry_sexp_release (list);
2548               if (rc)
2549                 goto leave;
2550             }
2551
2552           /* Get LABEL. */
2553           list = gcry_sexp_find_token (ldata, "label", 0);
2554           if (list)
2555             {
2556               s = gcry_sexp_nth_data (list, 1, &n);
2557               if (!s)
2558                 rc = GPG_ERR_NO_OBJ;
2559               else if (n > 0)
2560                 {
2561                   ctx->label = gcry_malloc (n);
2562                   if (!ctx->label)
2563                     rc = gpg_err_code_from_syserror ();
2564                   else
2565                     {
2566                       memcpy (ctx->label, s, n);
2567                       ctx->labellen = n;
2568                     }
2569                 }
2570               gcry_sexp_release (list);
2571               if (rc)
2572                 goto leave;
2573             }
2574
2575           rc = oaep_encode (ret_mpi, ctx->nbits, ctx->hash_algo,
2576                             value, valuelen,
2577                             ctx->label, ctx->labellen);
2578         }
2579     }
2580   else if (ctx->encoding == PUBKEY_ENC_PSS && lhash
2581            && ctx->op == PUBKEY_OP_SIGN)
2582     {
2583       if (gcry_sexp_length (lhash) != 3)
2584         rc = GPG_ERR_INV_OBJ;
2585       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2586         rc = GPG_ERR_INV_OBJ;
2587       else
2588         {
2589           const void * value;
2590           size_t valuelen;
2591
2592           ctx->hash_algo = get_hash_algo (s, n);
2593
2594           if (!ctx->hash_algo)
2595             rc = GPG_ERR_DIGEST_ALGO;
2596           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
2597                     || !valuelen )
2598             rc = GPG_ERR_INV_OBJ;
2599           else
2600             {
2601               gcry_sexp_t list;
2602
2603               /* Get SALT-LENGTH. */
2604               list = gcry_sexp_find_token (ldata, "salt-length", 0);
2605               if (list)
2606                 {
2607                   s = gcry_sexp_nth_data (list, 1, &n);
2608                   if (!s)
2609                     {
2610                       rc = GPG_ERR_NO_OBJ;
2611                       goto leave;
2612                     }
2613                   ctx->saltlen = (unsigned int)strtoul (s, NULL, 10);
2614                   gcry_sexp_release (list);
2615                 }
2616               rc = pss_encode (ret_mpi, ctx->nbits - 1, ctx->hash_algo,
2617                                value, valuelen,
2618                                ctx->saltlen);
2619             }
2620         }
2621     }
2622   else if (ctx->encoding == PUBKEY_ENC_PSS && lhash
2623            && ctx->op == PUBKEY_OP_VERIFY)
2624     {
2625       if (gcry_sexp_length (lhash) != 3)
2626         rc = GPG_ERR_INV_OBJ;
2627       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2628         rc = GPG_ERR_INV_OBJ;
2629       else
2630         {
2631           ctx->hash_algo = get_hash_algo (s, n);
2632
2633           if (!ctx->hash_algo)
2634             rc = GPG_ERR_DIGEST_ALGO;
2635           else
2636             {
2637               *ret_mpi = gcry_sexp_nth_mpi (lhash, 2, 0);
2638               if (!*ret_mpi)
2639                 rc = GPG_ERR_INV_OBJ;
2640               ctx->verify_cmp = pss_verify_cmp;
2641               ctx->verify_arg = *ret_mpi;
2642             }
2643         }
2644     }
2645   else
2646     rc = GPG_ERR_CONFLICT;
2647
2648  leave:
2649   gcry_sexp_release (ldata);
2650   gcry_sexp_release (lhash);
2651   gcry_sexp_release (lvalue);
2652
2653   if (!rc)
2654     ctx->flags = parsed_flags;
2655   else
2656     {
2657       gcry_free (ctx->label);
2658       ctx->label = NULL;
2659     }
2660
2661   return rc;
2662 }
2663
2664 static void
2665 init_encoding_ctx (struct pk_encoding_ctx *ctx, enum pk_operation op,
2666                    unsigned int nbits)
2667 {
2668   ctx->op = op;
2669   ctx->nbits = nbits;
2670   ctx->encoding = PUBKEY_ENC_UNKNOWN;
2671   ctx->flags = 0;
2672   ctx->hash_algo = GCRY_MD_SHA1;
2673   ctx->label = NULL;
2674   ctx->labellen = 0;
2675   ctx->saltlen = 20;
2676   ctx->verify_cmp = NULL;
2677   ctx->verify_arg = NULL;
2678 }
2679
2680
2681 /*
2682    Do a PK encrypt operation
2683
2684    Caller has to provide a public key as the SEXP pkey and data as a
2685    SEXP with just one MPI in it. Alternatively S_DATA might be a
2686    complex S-Expression, similar to the one used for signature
2687    verification.  This provides a flag which allows to handle PKCS#1
2688    block type 2 padding.  The function returns a a sexp which may be
2689    passed to to pk_decrypt.
2690
2691    Returns: 0 or an errorcode.
2692
2693    s_data = See comment for sexp_data_to_mpi
2694    s_pkey = <key-as-defined-in-sexp_to_key>
2695    r_ciph = (enc-val
2696                (<algo>
2697                  (<param_name1> <mpi>)
2698                  ...
2699                  (<param_namen> <mpi>)
2700                ))
2701
2702 */
2703 gcry_error_t
2704 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
2705 {
2706   gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
2707   const char *algo_name, *algo_elems;
2708   struct pk_encoding_ctx ctx;
2709   gcry_err_code_t rc;
2710   gcry_pk_spec_t *pubkey = NULL;
2711   gcry_module_t module = NULL;
2712
2713   *r_ciph = NULL;
2714
2715   REGISTER_DEFAULT_PUBKEYS;
2716
2717   /* Get the key. */
2718   rc = sexp_to_key (s_pkey, 0, NULL, &pkey, &module);
2719   if (rc)
2720     goto leave;
2721
2722   gcry_assert (module);
2723   pubkey = (gcry_pk_spec_t *) module->spec;
2724
2725   /* If aliases for the algorithm name exists, take the first one
2726      instead of the regular name to adhere to SPKI conventions.  We
2727      assume that the first alias name is the lowercase version of the
2728      regular one.  This change is required for compatibility with
2729      1.1.12 generated S-expressions. */
2730   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
2731   if (!algo_name || !*algo_name)
2732     algo_name = pubkey->name;
2733
2734   algo_elems = pubkey->elements_enc;
2735
2736   /* Get the stuff we want to encrypt. */
2737   init_encoding_ctx (&ctx, PUBKEY_OP_ENCRYPT, gcry_pk_get_nbits (s_pkey));
2738   rc = sexp_data_to_mpi (s_data, &data, &ctx);
2739   if (rc)
2740     goto leave;
2741
2742   /* Now we can encrypt DATA to CIPH. */
2743   ciph = gcry_calloc (strlen (algo_elems) + 1, sizeof (*ciph));
2744   if (!ciph)
2745     {
2746       rc = gpg_err_code_from_syserror ();
2747       goto leave;
2748     }
2749   rc = pubkey_encrypt (module->mod_id, ciph, data, pkey, ctx.flags);
2750   mpi_free (data);
2751   data = NULL;
2752   if (rc)
2753     goto leave;
2754
2755   /* We did it.  Now build the return list */
2756   {
2757     char *string, *p;
2758     int i;
2759     size_t nelem = strlen (algo_elems);
2760     size_t needed = 19 + strlen (algo_name) + (nelem * 5);
2761     void **arg_list;
2762
2763     /* Build the string.  */
2764     string = p = gcry_malloc (needed);
2765     if (!string)
2766       {
2767         rc = gpg_err_code_from_syserror ();
2768         goto leave;
2769       }
2770     p = stpcpy ( p, "(enc-val(" );
2771     p = stpcpy ( p, algo_name );
2772     for (i=0; algo_elems[i]; i++ )
2773       {
2774         *p++ = '(';
2775         *p++ = algo_elems[i];
2776         p = stpcpy ( p, "%m)" );
2777       }
2778     strcpy ( p, "))" );
2779
2780     /* And now the ugly part: We don't have a function to pass an
2781      * array to a format string, so we have to do it this way :-(.  */
2782     /* FIXME: There is now such a format specifier, so we can
2783        change the code to be more clear. */
2784     arg_list = malloc (nelem * sizeof *arg_list);
2785     if (!arg_list)
2786       {
2787         rc = gpg_err_code_from_syserror ();
2788         goto leave;
2789       }
2790
2791     for (i = 0; i < nelem; i++)
2792       arg_list[i] = ciph + i;
2793
2794     rc = gcry_sexp_build_array (r_ciph, NULL, string, arg_list);
2795     free (arg_list);
2796     if (rc)
2797       BUG ();
2798     gcry_free (string);
2799   }
2800
2801  leave:
2802   if (pkey)
2803     {
2804       release_mpi_array (pkey);
2805       gcry_free (pkey);
2806     }
2807
2808   if (ciph)
2809     {
2810       release_mpi_array (ciph);
2811       gcry_free (ciph);
2812     }
2813
2814   if (module)
2815     {
2816       ath_mutex_lock (&pubkeys_registered_lock);
2817       _gcry_module_release (module);
2818       ath_mutex_unlock (&pubkeys_registered_lock);
2819     }
2820
2821   gcry_free (ctx.label);
2822
2823   return gcry_error (rc);
2824 }
2825
2826 /*
2827    Do a PK decrypt operation
2828
2829    Caller has to provide a secret key as the SEXP skey and data in a
2830    format as created by gcry_pk_encrypt.  For historic reasons the
2831    function returns simply an MPI as an S-expression part; this is
2832    deprecated and the new method should be used which returns a real
2833    S-expressionl this is selected by adding at least an empty flags
2834    list to S_DATA.
2835
2836    Returns: 0 or an errorcode.
2837
2838    s_data = (enc-val
2839               [(flags [raw, pkcs1, oaep])]
2840               (<algo>
2841                 (<param_name1> <mpi>)
2842                 ...
2843                 (<param_namen> <mpi>)
2844               ))
2845    s_skey = <key-as-defined-in-sexp_to_key>
2846    r_plain= Either an incomplete S-expression without the parentheses
2847             or if the flags list is used (even if empty) a real S-expression:
2848             (value PLAIN).  In raw mode (or no flags given) the returned value
2849             is to be interpreted as a signed MPI, thus it may have an extra
2850             leading zero octet even if not included in the original data.
2851             With pkcs1 or oaep decoding enabled the returned value is a
2852             verbatim octet string.
2853  */
2854 gcry_error_t
2855 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
2856 {
2857   gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL;
2858   unsigned char *unpad = NULL;
2859   size_t unpadlen = 0;
2860   int modern, flags;
2861   struct pk_encoding_ctx ctx;
2862   gcry_err_code_t rc;
2863   gcry_module_t module_enc = NULL, module_key = NULL;
2864
2865   *r_plain = NULL;
2866   ctx.label = NULL;
2867
2868   REGISTER_DEFAULT_PUBKEYS;
2869
2870   rc = sexp_to_key (s_skey, 1, NULL, &skey, &module_key);
2871   if (rc)
2872     goto leave;
2873
2874   init_encoding_ctx (&ctx, PUBKEY_OP_DECRYPT, gcry_pk_get_nbits (s_skey));
2875   rc = sexp_to_enc (s_data, &data, &module_enc, &modern, &flags, &ctx);
2876   if (rc)
2877     goto leave;
2878
2879   if (module_key->mod_id != module_enc->mod_id)
2880     {
2881       rc = GPG_ERR_CONFLICT; /* Key algo does not match data algo. */
2882       goto leave;
2883     }
2884
2885   rc = pubkey_decrypt (module_key->mod_id, &plain, data, skey, flags);
2886   if (rc)
2887     goto leave;
2888
2889   /* Do un-padding if necessary. */
2890   switch (ctx.encoding)
2891     {
2892     case PUBKEY_ENC_PKCS1:
2893       rc = pkcs1_decode_for_encryption (&unpad, &unpadlen,
2894                                         gcry_pk_get_nbits (s_skey), plain);
2895       mpi_free (plain);
2896       plain = NULL;
2897       if (!rc)
2898         rc = gcry_err_code (gcry_sexp_build (r_plain, NULL, "(value %b)",
2899                                              (int)unpadlen, unpad));
2900       break;
2901
2902     case PUBKEY_ENC_OAEP:
2903       rc = oaep_decode (&unpad, &unpadlen,
2904                         gcry_pk_get_nbits (s_skey), ctx.hash_algo,
2905                         plain, ctx.label, ctx.labellen);
2906       mpi_free (plain);
2907       plain = NULL;
2908       if (!rc)
2909         rc = gcry_err_code (gcry_sexp_build (r_plain, NULL, "(value %b)",
2910                                              (int)unpadlen, unpad));
2911       break;
2912
2913     default:
2914       /* Raw format.  For backward compatibility we need to assume a
2915          signed mpi by using the sexp format string "%m".  */
2916       rc = gcry_err_code (gcry_sexp_build
2917                           (r_plain, NULL, modern? "(value %m)" : "%m", plain));
2918       break;
2919     }
2920
2921  leave:
2922   gcry_free (unpad);
2923
2924   if (skey)
2925     {
2926       release_mpi_array (skey);
2927       gcry_free (skey);
2928     }
2929
2930   mpi_free (plain);
2931
2932   if (data)
2933     {
2934       release_mpi_array (data);
2935       gcry_free (data);
2936     }
2937
2938   if (module_key || module_enc)
2939     {
2940       ath_mutex_lock (&pubkeys_registered_lock);
2941       if (module_key)
2942         _gcry_module_release (module_key);
2943       if (module_enc)
2944         _gcry_module_release (module_enc);
2945       ath_mutex_unlock (&pubkeys_registered_lock);
2946     }
2947
2948   gcry_free (ctx.label);
2949
2950   return gcry_error (rc);
2951 }
2952
2953
2954
2955 /*
2956    Create a signature.
2957
2958    Caller has to provide a secret key as the SEXP skey and data
2959    expressed as a SEXP list hash with only one element which should
2960    instantly be available as a MPI. Alternatively the structure given
2961    below may be used for S_HASH, it provides the abiliy to pass flags
2962    to the operation; the only flag defined by now is "pkcs1" which
2963    does PKCS#1 block type 1 style padding.
2964
2965    Returns: 0 or an errorcode.
2966             In case of 0 the function returns a new SEXP with the
2967             signature value; the structure of this signature depends on the
2968             other arguments but is always suitable to be passed to
2969             gcry_pk_verify
2970
2971    s_hash = See comment for sexp_data_to_mpi
2972
2973    s_skey = <key-as-defined-in-sexp_to_key>
2974    r_sig  = (sig-val
2975               (<algo>
2976                 (<param_name1> <mpi>)
2977                 ...
2978                 (<param_namen> <mpi>))
2979              [(hash algo)])
2980
2981   Note that (hash algo) in R_SIG is not used.
2982 */
2983 gcry_error_t
2984 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
2985 {
2986   gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
2987   gcry_pk_spec_t *pubkey = NULL;
2988   gcry_module_t module = NULL;
2989   const char *algo_name, *algo_elems;
2990   struct pk_encoding_ctx ctx;
2991   int i;
2992   gcry_err_code_t rc;
2993
2994   *r_sig = NULL;
2995
2996   REGISTER_DEFAULT_PUBKEYS;
2997
2998   rc = sexp_to_key (s_skey, 1, NULL, &skey, &module);
2999   if (rc)
3000     goto leave;
3001
3002   gcry_assert (module);
3003   pubkey = (gcry_pk_spec_t *) module->spec;
3004   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
3005   if (!algo_name || !*algo_name)
3006     algo_name = pubkey->name;
3007
3008   algo_elems = pubkey->elements_sig;
3009
3010   /* Get the stuff we want to sign.  Note that pk_get_nbits does also
3011       work on a private key. */
3012   init_encoding_ctx (&ctx, PUBKEY_OP_SIGN, gcry_pk_get_nbits (s_skey));
3013   rc = sexp_data_to_mpi (s_hash, &hash, &ctx);
3014   if (rc)
3015     goto leave;
3016
3017   result = gcry_calloc (strlen (algo_elems) + 1, sizeof (*result));
3018   if (!result)
3019     {
3020       rc = gpg_err_code_from_syserror ();
3021       goto leave;
3022     }
3023   rc = pubkey_sign (module->mod_id, result, hash, skey);
3024   if (rc)
3025     goto leave;
3026
3027   {
3028     char *string, *p;
3029     size_t nelem, needed = strlen (algo_name) + 20;
3030     void **arg_list;
3031
3032     nelem = strlen (algo_elems);
3033
3034     /* Count elements, so that we can allocate enough space. */
3035     needed += 10 * nelem;
3036
3037     /* Build the string. */
3038     string = p = gcry_malloc (needed);
3039     if (!string)
3040       {
3041         rc = gpg_err_code_from_syserror ();
3042         goto leave;
3043       }
3044     p = stpcpy (p, "(sig-val(");
3045     p = stpcpy (p, algo_name);
3046     for (i = 0; algo_elems[i]; i++)
3047       {
3048         *p++ = '(';
3049         *p++ = algo_elems[i];
3050         p = stpcpy (p, "%m)");
3051       }
3052     strcpy (p, "))");
3053
3054     arg_list = malloc (nelem * sizeof *arg_list);
3055     if (!arg_list)
3056       {
3057         rc = gpg_err_code_from_syserror ();
3058         goto leave;
3059       }
3060
3061     for (i = 0; i < nelem; i++)
3062       arg_list[i] = result + i;
3063
3064     rc = gcry_sexp_build_array (r_sig, NULL, string, arg_list);
3065     free (arg_list);
3066     if (rc)
3067       BUG ();
3068     gcry_free (string);
3069   }
3070
3071  leave:
3072   if (skey)
3073     {
3074       release_mpi_array (skey);
3075       gcry_free (skey);
3076     }
3077
3078   if (hash)
3079     mpi_free (hash);
3080
3081   if (result)
3082     {
3083       release_mpi_array (result);
3084       gcry_free (result);
3085     }
3086
3087   return gcry_error (rc);
3088 }
3089
3090
3091 /*
3092    Verify a signature.
3093
3094    Caller has to supply the public key pkey, the signature sig and his
3095    hashvalue data.  Public key has to be a standard public key given
3096    as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
3097    must be an S-Exp like the one in sign too.  */
3098 gcry_error_t
3099 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
3100 {
3101   gcry_module_t module_key = NULL, module_sig = NULL;
3102   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
3103   struct pk_encoding_ctx ctx;
3104   gcry_err_code_t rc;
3105
3106   REGISTER_DEFAULT_PUBKEYS;
3107
3108   rc = sexp_to_key (s_pkey, 0, NULL, &pkey, &module_key);
3109   if (rc)
3110     goto leave;
3111
3112   rc = sexp_to_sig (s_sig, &sig, &module_sig);
3113   if (rc)
3114     goto leave;
3115
3116   /* Fixme: Check that the algorithm of S_SIG is compatible to the one
3117      of S_PKEY.  */
3118
3119   if (module_key->mod_id != module_sig->mod_id)
3120     {
3121       rc = GPG_ERR_CONFLICT;
3122       goto leave;
3123     }
3124
3125   /* Get the stuff we want to verify. */
3126   init_encoding_ctx (&ctx, PUBKEY_OP_VERIFY, gcry_pk_get_nbits (s_pkey));
3127   rc = sexp_data_to_mpi (s_hash, &hash, &ctx);
3128   if (rc)
3129     goto leave;
3130
3131   rc = pubkey_verify (module_key->mod_id, hash, sig, pkey,
3132                       ctx.verify_cmp, &ctx);
3133
3134  leave:
3135   if (pkey)
3136     {
3137       release_mpi_array (pkey);
3138       gcry_free (pkey);
3139     }
3140   if (sig)
3141     {
3142       release_mpi_array (sig);
3143       gcry_free (sig);
3144     }
3145   if (hash)
3146     mpi_free (hash);
3147
3148   if (module_key || module_sig)
3149     {
3150       ath_mutex_lock (&pubkeys_registered_lock);
3151       if (module_key)
3152         _gcry_module_release (module_key);
3153       if (module_sig)
3154         _gcry_module_release (module_sig);
3155       ath_mutex_unlock (&pubkeys_registered_lock);
3156     }
3157
3158   return gcry_error (rc);
3159 }
3160
3161
3162 /*
3163    Test a key.
3164
3165    This may be used either for a public or a secret key to see whether
3166    the internal structure is okay.
3167
3168    Returns: 0 or an errorcode.
3169
3170    s_key = <key-as-defined-in-sexp_to_key> */
3171 gcry_error_t
3172 gcry_pk_testkey (gcry_sexp_t s_key)
3173 {
3174   gcry_module_t module = NULL;
3175   gcry_mpi_t *key = NULL;
3176   gcry_err_code_t rc;
3177
3178   REGISTER_DEFAULT_PUBKEYS;
3179
3180   /* Note we currently support only secret key checking. */
3181   rc = sexp_to_key (s_key, 1, NULL, &key, &module);
3182   if (! rc)
3183     {
3184       rc = pubkey_check_secret_key (module->mod_id, key);
3185       release_mpi_array (key);
3186       gcry_free (key);
3187     }
3188   return gcry_error (rc);
3189 }
3190
3191
3192 /*
3193   Create a public key pair and return it in r_key.
3194   How the key is created depends on s_parms:
3195   (genkey
3196    (algo
3197      (parameter_name_1 ....)
3198       ....
3199      (parameter_name_n ....)
3200   ))
3201   The key is returned in a format depending on the
3202   algorithm. Both, private and secret keys are returned
3203   and optionally some additional informatin.
3204   For elgamal we return this structure:
3205   (key-data
3206    (public-key
3207      (elg
3208         (p <mpi>)
3209         (g <mpi>)
3210         (y <mpi>)
3211      )
3212    )
3213    (private-key
3214      (elg
3215         (p <mpi>)
3216         (g <mpi>)
3217         (y <mpi>)
3218         (x <mpi>)
3219      )
3220    )
3221    (misc-key-info
3222       (pm1-factors n1 n2 ... nn)
3223    ))
3224  */
3225 gcry_error_t
3226 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
3227 {
3228   gcry_pk_spec_t *pubkey = NULL;
3229   gcry_module_t module = NULL;
3230   gcry_sexp_t list = NULL;
3231   gcry_sexp_t l2 = NULL;
3232   gcry_sexp_t l3 = NULL;
3233   char *name = NULL;
3234   size_t n;
3235   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
3236   int i, j;
3237   const char *algo_name = NULL;
3238   int algo;
3239   const char *sec_elems = NULL, *pub_elems = NULL;
3240   gcry_mpi_t skey[12];
3241   gcry_mpi_t *factors = NULL;
3242   gcry_sexp_t extrainfo = NULL;
3243   unsigned int nbits = 0;
3244   unsigned long use_e = 0;
3245
3246   skey[0] = NULL;
3247   *r_key = NULL;
3248
3249   REGISTER_DEFAULT_PUBKEYS;
3250
3251   list = gcry_sexp_find_token (s_parms, "genkey", 0);
3252   if (!list)
3253     {
3254       rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
3255       goto leave;
3256     }
3257
3258   l2 = gcry_sexp_cadr (list);
3259   gcry_sexp_release (list);
3260   list = l2;
3261   l2 = NULL;
3262   if (! list)
3263     {
3264       rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
3265       goto leave;
3266     }
3267
3268   name = _gcry_sexp_nth_string (list, 0);
3269   if (!name)
3270     {
3271       rc = GPG_ERR_INV_OBJ; /* Algo string missing.  */
3272       goto leave;
3273     }
3274
3275   ath_mutex_lock (&pubkeys_registered_lock);
3276   module = gcry_pk_lookup_name (name);
3277   ath_mutex_unlock (&pubkeys_registered_lock);
3278   gcry_free (name);
3279   name = NULL;
3280   if (!module)
3281     {
3282       rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
3283       goto leave;
3284     }
3285
3286   pubkey = (gcry_pk_spec_t *) module->spec;
3287   algo = module->mod_id;
3288   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
3289   if (!algo_name || !*algo_name)
3290     algo_name = pubkey->name;
3291   pub_elems = pubkey->elements_pkey;
3292   sec_elems = pubkey->elements_skey;
3293   if (strlen (sec_elems) >= DIM(skey))
3294     BUG ();
3295
3296   /* Handle the optional rsa-use-e element.  Actually this belong into
3297      the algorithm module but we have this parameter in the public
3298      module API, so we need to parse it right here.  */
3299   l2 = gcry_sexp_find_token (list, "rsa-use-e", 0);
3300   if (l2)
3301     {
3302       char buf[50];
3303       const char *s;
3304
3305       s = gcry_sexp_nth_data (l2, 1, &n);
3306       if ( !s || n >= DIM (buf) - 1 )
3307         {
3308           rc = GPG_ERR_INV_OBJ; /* No value or value too large.  */
3309           goto leave;
3310         }
3311       memcpy (buf, s, n);
3312       buf[n] = 0;
3313       use_e = strtoul (buf, NULL, 0);
3314       gcry_sexp_release (l2);
3315       l2 = NULL;
3316     }
3317   else
3318     use_e = 65537; /* Not given, use the value generated by old versions. */
3319
3320
3321   /* Get the "nbits" parameter.  */
3322   l2 = gcry_sexp_find_token (list, "nbits", 0);
3323   if (l2)
3324     {
3325       char buf[50];
3326       const char *s;
3327
3328       s = gcry_sexp_nth_data (l2, 1, &n);
3329       if (!s || n >= DIM (buf) - 1 )
3330         {
3331           rc = GPG_ERR_INV_OBJ; /* NBITS given without a cdr.  */
3332           goto leave;
3333         }
3334       memcpy (buf, s, n);
3335       buf[n] = 0;
3336       nbits = (unsigned int)strtoul (buf, NULL, 0);
3337       gcry_sexp_release (l2); l2 = NULL;
3338     }
3339   else
3340     nbits = 0;
3341
3342   /* Pass control to the algorithm module. */
3343   rc = pubkey_generate (module->mod_id, nbits, use_e, list, skey,
3344                         &factors, &extrainfo);
3345   gcry_sexp_release (list); list = NULL;
3346   if (rc)
3347     goto leave;
3348
3349   /* Key generation succeeded: Build an S-expression.  */
3350   {
3351     char *string, *p;
3352     size_t nelem=0, nelem_cp = 0, needed=0;
3353     gcry_mpi_t mpis[30];
3354     int percent_s_idx = -1;
3355
3356     /* Estimate size of format string.  */
3357     nelem = strlen (pub_elems) + strlen (sec_elems);
3358     if (factors)
3359       {
3360         for (i = 0; factors[i]; i++)
3361           nelem++;
3362       }
3363     nelem_cp = nelem;
3364
3365     needed += nelem * 10;
3366     /* (+5 is for EXTRAINFO ("%S")).  */
3367     needed += 2 * strlen (algo_name) + 300 + 5;
3368     if (nelem > DIM (mpis))
3369       BUG ();
3370
3371     /* Build the string. */
3372     nelem = 0;
3373     string = p = gcry_malloc (needed);
3374     if (!string)
3375       {
3376         rc = gpg_err_code_from_syserror ();
3377         goto leave;
3378       }
3379     p = stpcpy (p, "(key-data");
3380     p = stpcpy (p, "(public-key(");
3381     p = stpcpy (p, algo_name);
3382     for(i = 0; pub_elems[i]; i++)
3383       {
3384         *p++ = '(';
3385         *p++ = pub_elems[i];
3386         p = stpcpy (p, "%m)");
3387         mpis[nelem++] = skey[i];
3388       }
3389     if (extrainfo && (algo == GCRY_PK_ECDSA || algo == GCRY_PK_ECDH))
3390       {
3391         /* Very ugly hack to insert the used curve parameter into the
3392            list of public key parameters.  */
3393         percent_s_idx = nelem;
3394         p = stpcpy (p, "%S");
3395       }
3396     p = stpcpy (p, "))");
3397     p = stpcpy (p, "(private-key(");
3398     p = stpcpy (p, algo_name);
3399     for (i = 0; sec_elems[i]; i++)
3400       {
3401         *p++ = '(';
3402         *p++ = sec_elems[i];
3403         p = stpcpy (p, "%m)");
3404         mpis[nelem++] = skey[i];
3405       }
3406     p = stpcpy (p, "))");
3407
3408     /* Hack to make release_mpi_array() work.  */
3409     skey[i] = NULL;
3410
3411     if (extrainfo && percent_s_idx == -1)
3412       {
3413         /* If we have extrainfo we should not have any factors.  */
3414         p = stpcpy (p, "%S");
3415       }
3416     else if (factors && factors[0])
3417       {
3418         p = stpcpy (p, "(misc-key-info(pm1-factors");
3419         for(i = 0; factors[i]; i++)
3420           {
3421             p = stpcpy (p, "%m");
3422             mpis[nelem++] = factors[i];
3423           }
3424         p = stpcpy (p, "))");
3425       }
3426     strcpy (p, ")");
3427     gcry_assert (p - string < needed);
3428
3429     while (nelem < DIM (mpis))
3430       mpis[nelem++] = NULL;
3431
3432     {
3433       int elem_n = strlen (pub_elems) + strlen (sec_elems);
3434       void **arg_list;
3435
3436       /* Allocate one extra for EXTRAINFO ("%S").  */
3437       arg_list = gcry_calloc (nelem_cp+1, sizeof *arg_list);
3438       if (!arg_list)
3439         {
3440           rc = gpg_err_code_from_syserror ();
3441           goto leave;
3442         }
3443       for (i = j = 0; i < elem_n; i++)
3444         {
3445           if (i == percent_s_idx)
3446             arg_list[j++] = &extrainfo;
3447           arg_list[j++] = mpis + i;
3448         }
3449       if (extrainfo && percent_s_idx == -1)
3450         arg_list[j] = &extrainfo;
3451       else if (factors && factors[0])
3452         {
3453           for (; i < nelem_cp; i++)
3454             arg_list[j++] = factors + i - elem_n;
3455         }
3456       rc = gcry_sexp_build_array (r_key, NULL, string, arg_list);
3457       gcry_free (arg_list);
3458       if (rc)
3459         BUG ();
3460       gcry_assert (DIM (mpis) == 30); /* Reminder to make sure that
3461                                          the array gets increased if
3462                                          new parameters are added. */
3463     }
3464     gcry_free (string);
3465   }
3466
3467  leave:
3468   gcry_free (name);
3469   gcry_sexp_release (extrainfo);
3470   release_mpi_array (skey);
3471   /* Don't free SKEY itself, it is an stack allocated array. */
3472
3473   if (factors)
3474     {
3475       release_mpi_array ( factors );
3476       gcry_free (factors);
3477     }
3478
3479   gcry_sexp_release (l3);
3480   gcry_sexp_release (l2);
3481   gcry_sexp_release (list);
3482
3483   if (module)
3484     {
3485       ath_mutex_lock (&pubkeys_registered_lock);
3486       _gcry_module_release (module);
3487       ath_mutex_unlock (&pubkeys_registered_lock);
3488     }
3489
3490   return gcry_error (rc);
3491 }
3492
3493
3494 /*
3495    Get the number of nbits from the public key.
3496
3497    Hmmm: Should we have really this function or is it better to have a
3498    more general function to retrieve different properties of the key?  */
3499 unsigned int
3500 gcry_pk_get_nbits (gcry_sexp_t key)
3501 {
3502   gcry_module_t module = NULL;
3503   gcry_pk_spec_t *pubkey;
3504   gcry_mpi_t *keyarr = NULL;
3505   unsigned int nbits = 0;
3506   gcry_err_code_t rc;
3507
3508   REGISTER_DEFAULT_PUBKEYS;
3509
3510   rc = sexp_to_key (key, 0, NULL, &keyarr, &module);
3511   if (rc == GPG_ERR_INV_OBJ)
3512     rc = sexp_to_key (key, 1, NULL, &keyarr, &module);
3513   if (rc)
3514     return 0; /* Error - 0 is a suitable indication for that. */
3515
3516   pubkey = (gcry_pk_spec_t *) module->spec;
3517   nbits = (*pubkey->get_nbits) (module->mod_id, keyarr);
3518
3519   ath_mutex_lock (&pubkeys_registered_lock);
3520   _gcry_module_release (module);
3521   ath_mutex_unlock (&pubkeys_registered_lock);
3522
3523   release_mpi_array (keyarr);
3524   gcry_free (keyarr);
3525
3526   return nbits;
3527 }
3528
3529
3530 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
3531    key parameters expressed in a way depending on the algorithm.
3532
3533    ARRAY must either be 20 bytes long or NULL; in the latter case a
3534    newly allocated array of that size is returned, otherwise ARRAY or
3535    NULL is returned to indicate an error which is most likely an
3536    unknown algorithm.  The function accepts public or secret keys. */
3537 unsigned char *
3538 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
3539 {
3540   gcry_sexp_t list = NULL, l2 = NULL;
3541   gcry_pk_spec_t *pubkey = NULL;
3542   gcry_module_t module = NULL;
3543   pk_extra_spec_t *extraspec;
3544   const char *s;
3545   char *name = NULL;
3546   int idx;
3547   const char *elems;
3548   gcry_md_hd_t md = NULL;
3549   int okay = 0;
3550
3551   REGISTER_DEFAULT_PUBKEYS;
3552
3553   /* Check that the first element is valid. */
3554   list = gcry_sexp_find_token (key, "public-key", 0);
3555   if (! list)
3556     list = gcry_sexp_find_token (key, "private-key", 0);
3557   if (! list)
3558     list = gcry_sexp_find_token (key, "protected-private-key", 0);
3559   if (! list)
3560     list = gcry_sexp_find_token (key, "shadowed-private-key", 0);
3561   if (! list)
3562     return NULL; /* No public- or private-key object. */
3563
3564   l2 = gcry_sexp_cadr (list);
3565   gcry_sexp_release (list);
3566   list = l2;
3567   l2 = NULL;
3568
3569   name = _gcry_sexp_nth_string (list, 0);
3570   if (!name)
3571     goto fail; /* Invalid structure of object. */
3572
3573   ath_mutex_lock (&pubkeys_registered_lock);
3574   module = gcry_pk_lookup_name (name);
3575   ath_mutex_unlock (&pubkeys_registered_lock);
3576
3577   if (!module)
3578     goto fail; /* Unknown algorithm.  */
3579
3580   pubkey = (gcry_pk_spec_t *) module->spec;
3581   extraspec = module->extraspec;
3582
3583   elems = pubkey->elements_grip;
3584   if (!elems)
3585     goto fail; /* No grip parameter.  */
3586
3587   if (gcry_md_open (&md, GCRY_MD_SHA1, 0))
3588     goto fail;
3589
3590   if (extraspec && extraspec->comp_keygrip)
3591     {
3592       /* Module specific method to compute a keygrip.  */
3593       if (extraspec->comp_keygrip (md, list))
3594         goto fail;
3595     }
3596   else
3597     {
3598       /* Generic method to compute a keygrip.  */
3599       for (idx = 0, s = elems; *s; s++, idx++)
3600         {
3601           const char *data;
3602           size_t datalen;
3603           char buf[30];
3604
3605           l2 = gcry_sexp_find_token (list, s, 1);
3606           if (! l2)
3607             goto fail;
3608           data = gcry_sexp_nth_data (l2, 1, &datalen);
3609           if (! data)
3610             goto fail;
3611
3612           snprintf (buf, sizeof buf, "(1:%c%u:", *s, (unsigned int)datalen);
3613           gcry_md_write (md, buf, strlen (buf));
3614           gcry_md_write (md, data, datalen);
3615           gcry_sexp_release (l2);
3616           l2 = NULL;
3617           gcry_md_write (md, ")", 1);
3618         }
3619     }
3620
3621   if (!array)
3622     {
3623       array = gcry_malloc (20);
3624       if (! array)
3625         goto fail;
3626     }
3627
3628   memcpy (array, gcry_md_read (md, GCRY_MD_SHA1), 20);
3629   okay = 1;
3630
3631  fail:
3632   gcry_free (name);
3633   gcry_sexp_release (l2);
3634   gcry_md_close (md);
3635   gcry_sexp_release (list);
3636   return okay? array : NULL;
3637 }
3638
3639
3640 \f
3641 const char *
3642 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)