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