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