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