Fixed pkcs#1 unpadding
[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 new MPI at R_RESULT.  On error the value at R_RESULT is
879    undefined.  */
880 static gcry_err_code_t
881 pkcs1_decode_for_encryption (gcry_mpi_t *r_result, unsigned int nbits,
882                              gcry_mpi_t value)
883 {
884   gcry_err_code_t rc = 0;
885   gcry_error_t err;
886   unsigned char *frame = NULL;
887   size_t nframe = (nbits+7) / 8;
888   size_t n;
889
890   if ( !(frame = gcry_malloc_secure (nframe)))
891     return gpg_err_code_from_syserror ();
892
893   err = gcry_mpi_print (GCRYMPI_FMT_USG, frame, nframe, &n, value);
894   if (err)
895     {
896       gcry_free (frame);
897       return gcry_err_code (err);
898     }
899
900   nframe = n; /* Set NFRAME to the actual length.  */
901
902   /* FRAME = 0x00 || 0x02 || PS || 0x00 || M
903
904      pkcs#1 requires that the first byte is zero.  Our MPIs usually
905      strip leading zero bytes; thus we are not able to detect them.
906      However due to the way gcry_mpi_print is implemented we may see
907      leading zero bytes nevertheless.  We handle this by making the
908      first zero byte optional.  */
909   if (nframe < 4)
910     {
911       gcry_free (frame);
912       return GPG_ERR_ENCODING_PROBLEM;  /* Too short.  */
913     }
914   n = 0;
915   if (!frame[0])
916     n++;
917   if (frame[n++] != 0x02)
918     {
919       gcry_free (frame);
920       return GPG_ERR_ENCODING_PROBLEM;  /* Wrong block type.  */
921     }
922
923   /* Skip the non-zero random bytes and the terminating zero byte.  */
924   for (; n < nframe && frame[n] != 0x00; n++)
925     ;
926   if (n+1 >= nframe)
927     {
928       gcry_free (frame);
929       return GPG_ERR_ENCODING_PROBLEM; /* No zero byte.  */
930     }
931   n++; /* Skip the zero byte.  */
932
933   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, &frame[n], nframe - n, NULL);
934   if (err)
935     rc = gcry_err_code (err);
936   else if (DBG_CIPHER)
937     log_mpidump ("value extracted from PKCS#1 block type 2 encoded data",
938                  *r_result);
939   gcry_free (frame);
940
941   return rc;
942 }
943
944
945 /* Encode {VALUE,VALUELEN} for an NBITS keys and hash algorith ALGO
946    using the pkcs#1 block type 1 padding.  On success the result is
947    stored as a new MPI at R_RESULT.  On error the value at R_RESULT is
948    undefined.
949
950    We encode the value in this way:
951
952      0  1  PAD(n bytes)  0  ASN(asnlen bytes) VALUE(valuelen bytes)
953
954    0   is a marker we unfortunately can't encode because we return an
955        MPI which strips all leading zeroes.
956    1   is the block type.
957    PAD consists of 0xff bytes.
958    0   marks the end of the padding.
959    ASN is the DER encoding of the hash algorithm; along with the VALUE
960        it yields a valid DER encoding.
961
962    (Note that PGP prior to version 2.3 encoded the message digest as:
963       0   1   MD(16 bytes)   0   PAD(n bytes)   1
964     The MD is always 16 bytes here because it's always MD5.  GnuPG
965     does not not support pre-v2.3 signatures, but I'm including this
966     comment so the information is easily found if needed.)
967 */
968 static gcry_err_code_t
969 pkcs1_encode_for_signature (gcry_mpi_t *r_result, unsigned int nbits,
970                             const unsigned char *value, size_t valuelen,
971                             int algo)
972 {
973   gcry_err_code_t rc = 0;
974   gcry_error_t err;
975   byte asn[100];
976   byte *frame = NULL;
977   size_t nframe = (nbits+7) / 8;
978   int i;
979   size_t n;
980   size_t asnlen, dlen;
981
982   asnlen = DIM(asn);
983   dlen = gcry_md_get_algo_dlen (algo);
984
985   if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
986     {
987       /* We don't have yet all of the above algorithms.  */
988       return GPG_ERR_NOT_IMPLEMENTED;
989     }
990
991   if ( valuelen != dlen )
992     {
993       /* Hash value does not match the length of digest for
994          the given algorithm.  */
995       return GPG_ERR_CONFLICT;
996     }
997
998   if ( !dlen || dlen + asnlen + 4 > nframe)
999     {
1000       /* Can't encode an DLEN byte digest MD into an NFRAME byte
1001          frame.  */
1002       return GPG_ERR_TOO_SHORT;
1003     }
1004
1005   if ( !(frame = gcry_malloc (nframe)) )
1006     return gpg_err_code_from_syserror ();
1007
1008   /* Assemble the pkcs#1 block type 1. */
1009   n = 0;
1010   frame[n++] = 0;
1011   frame[n++] = 1; /* block type */
1012   i = nframe - valuelen - asnlen - 3 ;
1013   gcry_assert (i > 1);
1014   memset (frame+n, 0xff, i );
1015   n += i;
1016   frame[n++] = 0;
1017   memcpy (frame+n, asn, asnlen);
1018   n += asnlen;
1019   memcpy (frame+n, value, valuelen );
1020   n += valuelen;
1021   gcry_assert (n == nframe);
1022
1023   /* Convert it into an MPI. */
1024   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, n, &nframe);
1025   if (err)
1026     rc = gcry_err_code (err);
1027   else if (DBG_CIPHER)
1028     log_mpidump ("PKCS#1 block type 1 encoded data", *r_result);
1029   gcry_free (frame);
1030
1031   return rc;
1032 }
1033
1034
1035 static gcry_err_code_t
1036 mgf1 (unsigned char *output, size_t outlen, unsigned char *seed, size_t seedlen,
1037       int algo)
1038 {
1039   size_t dlen;
1040   int idx;
1041   gcry_md_hd_t hd;
1042   gcry_error_t err;
1043   unsigned char *p;
1044
1045   err = gcry_md_test_algo (algo);
1046   if (err)
1047     return gpg_err_code (err);
1048
1049   memset (output, 0, outlen);
1050   dlen = gcry_md_get_algo_dlen (algo);
1051   for (idx = 0, p = output; idx < (outlen + dlen - 1) / dlen; idx++, p += dlen)
1052     {
1053       unsigned char c[4], *digest;
1054
1055       c[0] = (idx >> 24) & 0xFF;
1056       c[1] = (idx >> 16) & 0xFF;
1057       c[2] = (idx >> 8) & 0xFF;
1058       c[3] = idx & 0xFF;
1059
1060       err = gcry_md_open (&hd, algo, 0);
1061       if (err)
1062         return gpg_err_code (err);
1063
1064       gcry_md_write (hd, seed, seedlen);
1065       gcry_md_write (hd, c, 4);
1066       digest = gcry_md_read (hd, 0);
1067       if (outlen - (p - output) >= dlen)
1068         memcpy (p, digest, dlen);
1069       else
1070         memcpy (p, digest, outlen - (p - output));
1071       gcry_md_close (hd);
1072     }
1073   return GPG_ERR_NO_ERROR;
1074 }
1075
1076 static gcry_err_code_t
1077 oaep_encode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1078              const unsigned char *value, size_t valuelen,
1079              const unsigned char *label, size_t labellen)
1080 {
1081   gcry_err_code_t rc = 0;
1082   gcry_error_t err;
1083   unsigned char *frame = NULL;
1084   size_t nframe = (nbits+7) / 8;
1085   unsigned char *dmask, *smask, *p;
1086   size_t dlen;
1087   gcry_md_hd_t hd;
1088   size_t n;
1089
1090   dlen = gcry_md_get_algo_dlen (algo);
1091   if (valuelen > nframe - 2 * dlen - 1 || !nframe)
1092     /* Can't encode a VALUELEN value in a NFRAME bytes frame. */
1093     return GPG_ERR_TOO_SHORT; /* the key is too short */
1094   if ( !(frame = gcry_malloc_secure (nframe)))
1095     return gpg_err_code_from_syserror ();
1096
1097   /* FRAME = 00 || SEED || DB */
1098   memset (frame, 0, nframe);
1099   n = 0;
1100   frame[n++] = 0;
1101   gcry_randomize (&frame[n], dlen, GCRY_STRONG_RANDOM);
1102
1103   n += dlen;
1104   gcry_md_open (&hd, algo, 0);
1105   gcry_md_write (hd, label, labellen);
1106   memcpy (&frame[n], gcry_md_read (hd, 0), dlen);
1107   gcry_md_close (hd);
1108   n = nframe - valuelen - 1;
1109   frame[n++] = 1;
1110   memcpy (&frame[n], value, valuelen);
1111
1112   if ( !(dmask = gcry_malloc_secure (nframe - dlen - 1)))
1113     {
1114       rc = gpg_err_code_from_syserror ();
1115       gcry_free (frame);
1116       return rc;
1117     }
1118   mgf1 (dmask, nframe - dlen - 1, &frame[1], dlen, algo);
1119   for (n = 1 + dlen, p = dmask; n < nframe; n++)
1120     frame[n] ^= *p++;
1121   gcry_free (dmask);
1122   n += valuelen;
1123
1124   if ( !(smask = gcry_malloc_secure (dlen)))
1125     {
1126       rc = gpg_err_code_from_syserror ();
1127       gcry_free (frame);
1128       return rc;
1129     }
1130   mgf1 (smask, dlen, &frame[1 + dlen], nframe - dlen - 1, algo);
1131   for (n = 1, p = smask; n < 1 + dlen; n++)
1132     frame[n] ^= *p++;
1133   gcry_free (smask);
1134   n = nframe;
1135
1136   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, n, &nframe);
1137   if (err)
1138     rc = gcry_err_code (err);
1139   else if (DBG_CIPHER)
1140     log_mpidump ("OAEP encoded data", *r_result);
1141   gcry_free (frame);
1142
1143   return rc;
1144 }
1145
1146 static gcry_err_code_t
1147 oaep_decode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1148              gcry_mpi_t value, const unsigned char *label, size_t labellen)
1149 {
1150   gcry_err_code_t rc = 0;
1151   gcry_error_t err;
1152   unsigned char *frame = NULL, *dmask, *smask, *p;
1153   size_t nframe = (nbits+7) / 8;
1154   size_t dlen;
1155   gcry_md_hd_t hd;
1156   size_t n;
1157
1158   if ( !(frame = gcry_malloc_secure (nframe)))
1159     return gpg_err_code_from_syserror ();
1160
1161   err = gcry_mpi_print (GCRYMPI_FMT_USG, frame, nframe, &n, value);
1162   if (err)
1163     {
1164       gcry_free (frame);
1165       return gcry_err_code (err);
1166     }
1167   if (n < nframe)
1168     {
1169       memmove (frame + (nframe - n), frame, n);
1170       memset (frame, 0, (nframe - n));
1171     }
1172
1173   /* FRAME = 00 || MASKED_SEED || MASKED_DB */
1174   if (frame[0])
1175     {
1176       gcry_free (frame);
1177       return GPG_ERR_ENCODING_PROBLEM;
1178     }
1179
1180   dlen = gcry_md_get_algo_dlen (algo);
1181   if (nframe < 1 + 2 * dlen + 1)
1182     {
1183       gcry_free (frame);
1184       return GPG_ERR_TOO_SHORT;
1185     }
1186   if ( !(smask = gcry_malloc_secure (dlen)))
1187     {
1188       rc = gpg_err_code_from_syserror ();
1189       gcry_free (frame);
1190       return rc;
1191     }
1192   mgf1 (smask, dlen, &frame[1 + dlen], nframe - dlen - 1, algo);
1193   for (n = 1, p = smask; n < 1 + dlen; n++)
1194     frame[n] ^= *p++;
1195   gcry_free (smask);
1196
1197   if ( !(dmask = gcry_malloc_secure (nframe - dlen - 1)))
1198     {
1199       rc = gpg_err_code_from_syserror ();
1200       gcry_free (frame);
1201       return rc;
1202     }
1203   mgf1 (dmask, nframe - dlen - 1, &frame[1], dlen, algo);
1204   for (n = 1 + dlen, p = dmask; n < nframe; n++)
1205     frame[n] ^= *p++;
1206   gcry_free (dmask);
1207
1208   gcry_md_open (&hd, algo, 0);
1209   gcry_md_write (hd, label, labellen);
1210   memcpy (&frame[1], gcry_md_read (hd, 0), dlen);
1211   gcry_md_close (hd);
1212
1213   if (memcmp (&frame[1], &frame[1 + dlen], dlen))
1214     {
1215       gcry_free (frame);
1216       return GPG_ERR_ENCODING_PROBLEM;
1217     }
1218
1219   for (n = 1 + dlen * 2; n < nframe && !frame[n]; n++)
1220     ;
1221   if (n < nframe && frame[n] != 1)
1222     {
1223       gcry_free (frame);
1224       return GPG_ERR_ENCODING_PROBLEM;
1225     }
1226
1227   n++;
1228   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, &frame[n], nframe - n, NULL);
1229   if (err)
1230     rc = gcry_err_code (err);
1231   else if (DBG_CIPHER)
1232     log_mpidump ("value extracted from OAEP encoded data", *r_result);
1233   gcry_free (frame);
1234
1235   return rc;
1236 }
1237
1238 /* Internal function.   */
1239 static gcry_err_code_t
1240 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
1241                        gcry_mpi_t *elements, const char *algo_name)
1242 {
1243   gcry_err_code_t err = 0;
1244   int i, idx;
1245   const char *name;
1246   gcry_sexp_t list;
1247
1248   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1249     {
1250       list = gcry_sexp_find_token (key_sexp, name, 1);
1251       if (!list)
1252         elements[idx] = NULL;
1253       else
1254         {
1255           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
1256           gcry_sexp_release (list);
1257           if (!elements[idx])
1258             err = GPG_ERR_INV_OBJ;
1259         }
1260     }
1261
1262   if (!err)
1263     {
1264       /* Check that all elements are available.  */
1265       for (name = element_names, idx = 0; *name; name++, idx++)
1266         if (!elements[idx])
1267           break;
1268       if (*name)
1269         {
1270           err = GPG_ERR_NO_OBJ;
1271           /* Some are missing.  Before bailing out we test for
1272              optional parameters.  */
1273           if (algo_name && !strcmp (algo_name, "RSA")
1274               && !strcmp (element_names, "nedpqu") )
1275             {
1276               /* This is RSA.  Test whether we got N, E and D and that
1277                  the optional P, Q and U are all missing.  */
1278               if (elements[0] && elements[1] && elements[2]
1279                   && !elements[3] && !elements[4] && !elements[5])
1280                 err = 0;
1281             }
1282         }
1283     }
1284
1285
1286   if (err)
1287     {
1288       for (i = 0; i < idx; i++)
1289         if (elements[i])
1290           gcry_free (elements[i]);
1291     }
1292   return err;
1293 }
1294
1295
1296 /* Internal function used for ecc.  Note, that this function makes use
1297    of its intimate knowledge about the ECC parameters from ecc.c. */
1298 static gcry_err_code_t
1299 sexp_elements_extract_ecc (gcry_sexp_t key_sexp, const char *element_names,
1300                            gcry_mpi_t *elements, pk_extra_spec_t *extraspec)
1301
1302 {
1303   gcry_err_code_t err = 0;
1304   int idx;
1305   const char *name;
1306   gcry_sexp_t list;
1307
1308   /* Clear the array for easier error cleanup. */
1309   for (name = element_names, idx = 0; *name; name++, idx++)
1310     elements[idx] = NULL;
1311   gcry_assert (idx >= 5); /* We know that ECC has at least 5 elements
1312                              (params only) or 6 (full public key).  */
1313   if (idx == 5)
1314     elements[5] = NULL;   /* Extra clear for the params only case.  */
1315
1316
1317   /* Init the array with the available curve parameters. */
1318   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1319     {
1320       list = gcry_sexp_find_token (key_sexp, name, 1);
1321       if (!list)
1322         elements[idx] = NULL;
1323       else
1324         {
1325           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
1326           gcry_sexp_release (list);
1327           if (!elements[idx])
1328             {
1329               err = GPG_ERR_INV_OBJ;
1330               goto leave;
1331             }
1332         }
1333     }
1334
1335   /* Check whether a curve parameter has been given and then fill any
1336      missing elements.  */
1337   list = gcry_sexp_find_token (key_sexp, "curve", 5);
1338   if (list)
1339     {
1340       if (extraspec->get_param)
1341         {
1342           char *curve;
1343           gcry_mpi_t params[6];
1344
1345           for (idx = 0; idx < DIM(params); idx++)
1346             params[idx] = NULL;
1347
1348           curve = _gcry_sexp_nth_string (list, 1);
1349           gcry_sexp_release (list);
1350           if (!curve)
1351             {
1352               /* No curve name given (or out of core). */
1353               err = GPG_ERR_INV_OBJ;
1354               goto leave;
1355             }
1356           err = extraspec->get_param (curve, params);
1357           gcry_free (curve);
1358           if (err)
1359             goto leave;
1360
1361           for (idx = 0; idx < DIM(params); idx++)
1362             {
1363               if (!elements[idx])
1364                 elements[idx] = params[idx];
1365               else
1366                 mpi_free (params[idx]);
1367             }
1368         }
1369       else
1370         {
1371           gcry_sexp_release (list);
1372           err = GPG_ERR_INV_OBJ; /* "curve" given but ECC not supported. */
1373           goto leave;
1374         }
1375     }
1376
1377   /* Check that all parameters are known.  */
1378   for (name = element_names, idx = 0; *name; name++, idx++)
1379     if (!elements[idx])
1380       {
1381         err = GPG_ERR_NO_OBJ;
1382         goto leave;
1383       }
1384
1385  leave:
1386   if (err)
1387     {
1388       for (name = element_names, idx = 0; *name; name++, idx++)
1389         if (elements[idx])
1390           gcry_free (elements[idx]);
1391     }
1392   return err;
1393 }
1394
1395
1396
1397 /****************
1398  * Convert a S-Exp with either a private or a public key to our
1399  * internal format. Currently we do only support the following
1400  * algorithms:
1401  *    dsa
1402  *    rsa
1403  *    openpgp-dsa
1404  *    openpgp-rsa
1405  *    openpgp-elg
1406  *    openpgp-elg-sig
1407  *    ecdsa
1408  *    ecdh
1409  * Provide a SE with the first element be either "private-key" or
1410  * or "public-key". It is followed by a list with its first element
1411  * be one of the above algorithm identifiers and the remaning
1412  * elements are pairs with parameter-id and value.
1413  * NOTE: we look through the list to find a list beginning with
1414  * "private-key" or "public-key" - the first one found is used.
1415  *
1416  * If OVERRIDE_ELEMS is not NULL those elems override the parameter
1417  * specification taken from the module.  This ise used by
1418  * gcry_pk_get_curve.
1419  *
1420  * Returns: A pointer to an allocated array of MPIs if the return value is
1421  *          zero; the caller has to release this array.
1422  *
1423  * Example of a DSA public key:
1424  *  (private-key
1425  *    (dsa
1426  *      (p <mpi>)
1427  *      (g <mpi>)
1428  *      (y <mpi>)
1429  *      (x <mpi>)
1430  *    )
1431  *  )
1432  * The <mpi> are expected to be in GCRYMPI_FMT_USG
1433  */
1434 static gcry_err_code_t
1435 sexp_to_key (gcry_sexp_t sexp, int want_private, const char *override_elems,
1436              gcry_mpi_t **retarray, gcry_module_t *retalgo)
1437 {
1438   gcry_err_code_t err = 0;
1439   gcry_sexp_t list, l2;
1440   char *name;
1441   const char *elems;
1442   gcry_mpi_t *array;
1443   gcry_module_t module;
1444   gcry_pk_spec_t *pubkey;
1445   pk_extra_spec_t *extraspec;
1446   int is_ecc;
1447
1448   /* Check that the first element is valid.  */
1449   list = gcry_sexp_find_token (sexp,
1450                                want_private? "private-key":"public-key", 0);
1451   if (!list)
1452     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
1453
1454   l2 = gcry_sexp_cadr( list );
1455   gcry_sexp_release ( list );
1456   list = l2;
1457   name = _gcry_sexp_nth_string (list, 0);
1458   if (!name)
1459     {
1460       gcry_sexp_release ( list );
1461       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
1462     }
1463
1464   ath_mutex_lock (&pubkeys_registered_lock);
1465   module = gcry_pk_lookup_name (name);
1466   ath_mutex_unlock (&pubkeys_registered_lock);
1467
1468   /* Fixme: We should make sure that an ECC key is always named "ecc"
1469      and not "ecdsa".  "ecdsa" should be used for the signature
1470      itself.  We need a function to test whether an algorithm given
1471      with a key is compatible with an application of the key (signing,
1472      encryption).  For RSA this is easy, but ECC is the first
1473      algorithm which has many flavours.  */
1474   is_ecc = ( !strcmp (name, "ecdsa")
1475              || !strcmp (name, "ecdh")
1476              || !strcmp (name, "ecc") );
1477   gcry_free (name);
1478
1479   if (!module)
1480     {
1481       gcry_sexp_release (list);
1482       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
1483     }
1484   else
1485     {
1486       pubkey = (gcry_pk_spec_t *) module->spec;
1487       extraspec = module->extraspec;
1488     }
1489
1490   if (override_elems)
1491     elems = override_elems;
1492   else if (want_private)
1493     elems = pubkey->elements_skey;
1494   else
1495     elems = pubkey->elements_pkey;
1496   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
1497   if (!array)
1498     err = gpg_err_code_from_syserror ();
1499   if (!err)
1500     {
1501       if (is_ecc)
1502         err = sexp_elements_extract_ecc (list, elems, array, extraspec);
1503       else
1504         err = sexp_elements_extract (list, elems, array, pubkey->name);
1505     }
1506
1507   gcry_sexp_release (list);
1508
1509   if (err)
1510     {
1511       gcry_free (array);
1512
1513       ath_mutex_lock (&pubkeys_registered_lock);
1514       _gcry_module_release (module);
1515       ath_mutex_unlock (&pubkeys_registered_lock);
1516     }
1517   else
1518     {
1519       *retarray = array;
1520       *retalgo = module;
1521     }
1522
1523   return err;
1524 }
1525
1526
1527 static gcry_err_code_t
1528 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
1529              gcry_module_t *retalgo)
1530 {
1531   gcry_err_code_t err = 0;
1532   gcry_sexp_t list, l2;
1533   char *name;
1534   const char *elems;
1535   gcry_mpi_t *array;
1536   gcry_module_t module;
1537   gcry_pk_spec_t *pubkey;
1538
1539   /* Check that the first element is valid.  */
1540   list = gcry_sexp_find_token( sexp, "sig-val" , 0 );
1541   if (!list)
1542     return GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
1543
1544   l2 = gcry_sexp_nth (list, 1);
1545   if (!l2)
1546     {
1547       gcry_sexp_release (list);
1548       return GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
1549     }
1550   name = _gcry_sexp_nth_string (l2, 0);
1551   if (!name)
1552     {
1553       gcry_sexp_release (list);
1554       gcry_sexp_release (l2);
1555       return GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
1556     }
1557   else if (!strcmp (name, "flags"))
1558     {
1559       /* Skip flags, since they are not used but here just for the
1560          sake of consistent S-expressions.  */
1561       gcry_free (name);
1562       gcry_sexp_release (l2);
1563       l2 = gcry_sexp_nth (list, 2);
1564       if (!l2)
1565         {
1566           gcry_sexp_release (list);
1567           return GPG_ERR_INV_OBJ;
1568         }
1569       name = _gcry_sexp_nth_string (l2, 0);
1570     }
1571
1572   ath_mutex_lock (&pubkeys_registered_lock);
1573   module = gcry_pk_lookup_name (name);
1574   ath_mutex_unlock (&pubkeys_registered_lock);
1575   gcry_free (name);
1576   name = NULL;
1577
1578   if (!module)
1579     {
1580       gcry_sexp_release (l2);
1581       gcry_sexp_release (list);
1582       return GPG_ERR_PUBKEY_ALGO;  /* Unknown algorithm. */
1583     }
1584   else
1585     pubkey = (gcry_pk_spec_t *) module->spec;
1586
1587   elems = pubkey->elements_sig;
1588   array = gcry_calloc (strlen (elems) + 1 , sizeof *array );
1589   if (!array)
1590     err = gpg_err_code_from_syserror ();
1591
1592   if (!err)
1593     err = sexp_elements_extract (list, elems, array, NULL);
1594
1595   gcry_sexp_release (l2);
1596   gcry_sexp_release (list);
1597
1598   if (err)
1599     {
1600       ath_mutex_lock (&pubkeys_registered_lock);
1601       _gcry_module_release (module);
1602       ath_mutex_unlock (&pubkeys_registered_lock);
1603
1604       gcry_free (array);
1605     }
1606   else
1607     {
1608       *retarray = array;
1609       *retalgo = module;
1610     }
1611
1612   return err;
1613 }
1614
1615 static inline int
1616 get_hash_algo (const char *s, size_t n)
1617 {
1618   static const struct { const char *name; int algo; } hashnames[] = {
1619     { "sha1",   GCRY_MD_SHA1 },
1620     { "md5",    GCRY_MD_MD5 },
1621     { "sha256", GCRY_MD_SHA256 },
1622     { "ripemd160", GCRY_MD_RMD160 },
1623     { "rmd160", GCRY_MD_RMD160 },
1624     { "sha384", GCRY_MD_SHA384 },
1625     { "sha512", GCRY_MD_SHA512 },
1626     { "sha224", GCRY_MD_SHA224 },
1627     { "md2",    GCRY_MD_MD2 },
1628     { "md4",    GCRY_MD_MD4 },
1629     { "tiger",  GCRY_MD_TIGER },
1630     { "haval",  GCRY_MD_HAVAL },
1631     { NULL, 0 }
1632   };
1633   int algo;
1634   int i;
1635
1636   for (i=0; hashnames[i].name; i++)
1637     {
1638       if ( strlen (hashnames[i].name) == n
1639            && !memcmp (hashnames[i].name, s, n))
1640         break;
1641     }
1642   if (hashnames[i].name)
1643     algo = hashnames[i].algo;
1644   else
1645     {
1646       /* In case of not listed or dynamically allocated hash
1647          algorithm we fall back to this somewhat slower
1648          method.  Further, it also allows to use OIDs as
1649          algorithm names. */
1650       char *tmpname;
1651
1652       tmpname = gcry_malloc (n+1);
1653       if (!tmpname)
1654         algo = 0;  /* Out of core - silently give up.  */
1655       else
1656         {
1657           memcpy (tmpname, s, n);
1658           tmpname[n] = 0;
1659           algo = gcry_md_map_name (tmpname);
1660           gcry_free (tmpname);
1661         }
1662     }
1663   return algo;
1664 }
1665
1666
1667 /****************
1668  * Take sexp and return an array of MPI as used for our internal decrypt
1669  * function.
1670  * s_data = (enc-val
1671  *           [(flags [raw, pkcs1, oaep, no-blinding])]
1672  *           [(hash-algo <algo>)]
1673  *           [(label <label>)]
1674  *            (<algo>
1675  *              (<param_name1> <mpi>)
1676  *              ...
1677  *              (<param_namen> <mpi>)
1678  *            ))
1679  * HASH-ALGO and LABEL are specific to OAEP.
1680  * RET_MODERN is set to true when at least an empty flags list has been found.
1681  * CTX is used to return encoding information; it may be NULL in which
1682  * case raw encoding is used.
1683  */
1684 static gcry_err_code_t
1685 sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
1686              int *ret_modern, int *flags, struct pk_encoding_ctx *ctx)
1687 {
1688   gcry_err_code_t err = 0;
1689   gcry_sexp_t list = NULL, l2 = NULL;
1690   gcry_pk_spec_t *pubkey = NULL;
1691   gcry_module_t module = NULL;
1692   char *name = NULL;
1693   size_t n;
1694   int parsed_flags = 0;
1695   const char *elems;
1696   gcry_mpi_t *array = NULL;
1697   struct pk_encoding_ctx dummy_ctx;
1698
1699   *ret_modern = 0;
1700
1701   if (!ctx)
1702     ctx = &dummy_ctx;
1703   ctx->encoding = PUBKEY_ENC_RAW;
1704   ctx->hash_algo = GCRY_MD_SHA1;
1705   ctx->label = NULL;
1706   ctx->labellen = 0;
1707
1708   /* Check that the first element is valid.  */
1709   list = gcry_sexp_find_token (sexp, "enc-val" , 0);
1710   if (!list)
1711     {
1712       err = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
1713       goto leave;
1714     }
1715
1716   l2 = gcry_sexp_nth (list, 1);
1717   if (!l2)
1718     {
1719       err = GPG_ERR_NO_OBJ; /* No cdr for the data object.  */
1720       goto leave;
1721     }
1722
1723   /* Extract identifier of sublist.  */
1724   name = _gcry_sexp_nth_string (l2, 0);
1725   if (!name)
1726     {
1727       err = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
1728       goto leave;
1729     }
1730
1731   if (!strcmp (name, "flags"))
1732     {
1733       /* There is a flags element - process it.  */
1734       const char *s;
1735       int i;
1736
1737       *ret_modern = 1;
1738       for (i = gcry_sexp_length (l2) - 1; i > 0; i--)
1739         {
1740           s = gcry_sexp_nth_data (l2, i, &n);
1741           if (! s)
1742             ; /* Not a data element - ignore.  */
1743           else if (n == 3 && !memcmp (s, "raw", 3)
1744                    && ctx->encoding == PUBKEY_ENC_RAW)
1745             ; /* This is just a dummy as it is the default.  */
1746           else if (n == 5 && !memcmp (s, "pkcs1", 5)
1747                    && ctx->encoding == PUBKEY_ENC_RAW)
1748             ctx->encoding = PUBKEY_ENC_PKCS1;
1749           else if (n == 4 && !memcmp (s, "oaep", 4)
1750                    && ctx->encoding == PUBKEY_ENC_RAW)
1751             ctx->encoding = PUBKEY_ENC_OAEP;
1752           else if (n == 11 && ! memcmp (s, "no-blinding", 11))
1753             parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
1754           else
1755             {
1756               err = GPG_ERR_INV_FLAG;
1757               goto leave;
1758             }
1759         }
1760       gcry_sexp_release (l2);
1761
1762       /* Get the OAEP parameters HASH-ALGO and LABEL, if any. */
1763       if (ctx->encoding == PUBKEY_ENC_OAEP)
1764         {
1765           /* Get HASH-ALGO. */
1766           l2 = gcry_sexp_find_token (list, "hash-algo", 0);
1767           if (l2)
1768             {
1769               s = gcry_sexp_nth_data (l2, 1, &n);
1770               if (!s)
1771                 err = GPG_ERR_NO_OBJ;
1772               else
1773                 {
1774                   ctx->hash_algo = get_hash_algo (s, n);
1775                   if (!ctx->hash_algo)
1776                     err = GPG_ERR_DIGEST_ALGO;
1777                 }
1778               gcry_sexp_release (l2);
1779               if (err)
1780                 goto leave;
1781             }
1782
1783           /* Get LABEL. */
1784           l2 = gcry_sexp_find_token (list, "label", 0);
1785           if (l2)
1786             {
1787               s = gcry_sexp_nth_data (l2, 1, &n);
1788               if (!s)
1789                 err = GPG_ERR_NO_OBJ;
1790               else if (n > 0)
1791                 {
1792                   ctx->label = gcry_malloc (n);
1793                   if (!ctx->label)
1794                     err = gpg_err_code_from_syserror ();
1795                   else
1796                     {
1797                       memcpy (ctx->label, s, n);
1798                       ctx->labellen = n;
1799                     }
1800                 }
1801               gcry_sexp_release (l2);
1802               if (err)
1803                 goto leave;
1804             }
1805         }
1806
1807       /* Get the next which has the actual data - skip HASH-ALGO and LABEL. */
1808       for (i = 2; (l2 = gcry_sexp_nth (list, i)) != NULL; i++)
1809         {
1810           s = gcry_sexp_nth_data (l2, 0, &n);
1811           if (!(n == 9 && !memcmp (s, "hash-algo", 9))
1812               && !(n == 5 && !memcmp (s, "label", 5)))
1813             break;
1814           gcry_sexp_release (l2);
1815         }
1816
1817       if (!l2)
1818         {
1819           err = GPG_ERR_NO_OBJ; /* No cdr for the data object. */
1820           goto leave;
1821         }
1822
1823       /* Extract sublist identifier.  */
1824       gcry_free (name);
1825       name = _gcry_sexp_nth_string (l2, 0);
1826       if (!name)
1827         {
1828           err = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
1829           goto leave;
1830         }
1831
1832       gcry_sexp_release (list);
1833       list = l2;
1834       l2 = NULL;
1835     }
1836
1837   ath_mutex_lock (&pubkeys_registered_lock);
1838   module = gcry_pk_lookup_name (name);
1839   ath_mutex_unlock (&pubkeys_registered_lock);
1840
1841   if (!module)
1842     {
1843       err = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
1844       goto leave;
1845     }
1846   pubkey = (gcry_pk_spec_t *) module->spec;
1847
1848   elems = pubkey->elements_enc;
1849   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
1850   if (!array)
1851     {
1852       err = gpg_err_code_from_syserror ();
1853       goto leave;
1854     }
1855
1856   err = sexp_elements_extract (list, elems, array, NULL);
1857
1858  leave:
1859   gcry_sexp_release (list);
1860   gcry_sexp_release (l2);
1861   gcry_free (name);
1862
1863   if (err)
1864     {
1865       ath_mutex_lock (&pubkeys_registered_lock);
1866       _gcry_module_release (module);
1867       ath_mutex_unlock (&pubkeys_registered_lock);
1868       gcry_free (array);
1869       gcry_free (ctx->label);
1870       ctx->label = NULL;
1871     }
1872   else
1873     {
1874       *retarray = array;
1875       *retalgo = module;
1876       *flags = parsed_flags;
1877     }
1878
1879   return err;
1880 }
1881
1882 /* Take the hash value and convert into an MPI, suitable for
1883    passing to the low level functions.  We currently support the
1884    old style way of passing just a MPI and the modern interface which
1885    allows to pass flags so that we can choose between raw and pkcs1
1886    padding - may be more padding options later.
1887
1888    (<mpi>)
1889    or
1890    (data
1891     [(flags [raw, pkcs1, oaep, no-blinding])]
1892     [(hash <algo> <value>)]
1893     [(value <text>)]
1894     [(hash-algo <algo>)]
1895     [(label <label>)]
1896    )
1897
1898    Either the VALUE or the HASH element must be present for use
1899    with signatures.  VALUE is used for encryption.
1900
1901    HASH-ALGO and LABEL are specific to OAEP.
1902
1903    NBITS is the length of the key in bits.
1904
1905 */
1906 static gcry_err_code_t
1907 sexp_data_to_mpi (gcry_sexp_t input, unsigned int nbits, gcry_mpi_t *ret_mpi,
1908                   int for_encryption, int *flags, struct pk_encoding_ctx *ctx)
1909 {
1910   gcry_err_code_t rc = 0;
1911   gcry_sexp_t ldata, lhash, lvalue;
1912   int i;
1913   size_t n;
1914   const char *s;
1915   int unknown_flag=0;
1916   int parsed_flags = 0, dummy_flags;
1917   struct pk_encoding_ctx dummy_ctx;
1918
1919   if (! flags)
1920     flags = &dummy_flags;
1921
1922   if (! ctx)
1923     ctx = &dummy_ctx;
1924
1925   ctx->encoding = PUBKEY_ENC_UNKNOWN;
1926   ctx->hash_algo = GCRY_MD_SHA1;
1927   ctx->label = NULL;
1928   ctx->labellen = 0;
1929
1930   *ret_mpi = NULL;
1931   ldata = gcry_sexp_find_token (input, "data", 0);
1932   if (!ldata)
1933     { /* assume old style */
1934       *ret_mpi = gcry_sexp_nth_mpi (input, 0, 0);
1935       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
1936     }
1937
1938   /* see whether there is a flags object */
1939   {
1940     gcry_sexp_t lflags = gcry_sexp_find_token (ldata, "flags", 0);
1941     if (lflags)
1942       { /* parse the flags list. */
1943         for (i=gcry_sexp_length (lflags)-1; i > 0; i--)
1944           {
1945             s = gcry_sexp_nth_data (lflags, i, &n);
1946             if (!s)
1947               ; /* not a data element*/
1948             else if ( n == 3 && !memcmp (s, "raw", 3)
1949                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
1950               ctx->encoding = PUBKEY_ENC_RAW;
1951             else if ( n == 5 && !memcmp (s, "pkcs1", 5)
1952                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
1953               ctx->encoding = PUBKEY_ENC_PKCS1;
1954             else if ( n == 4 && !memcmp (s, "oaep", 4)
1955                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
1956               ctx->encoding = PUBKEY_ENC_OAEP;
1957             else if (n == 11 && ! memcmp (s, "no-blinding", 11))
1958               parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
1959             else
1960               unknown_flag = 1;
1961           }
1962         gcry_sexp_release (lflags);
1963       }
1964   }
1965
1966   if (ctx->encoding == PUBKEY_ENC_UNKNOWN)
1967     ctx->encoding = PUBKEY_ENC_RAW; /* default to raw */
1968
1969   /* Get HASH or MPI */
1970   lhash = gcry_sexp_find_token (ldata, "hash", 0);
1971   lvalue = lhash? NULL : gcry_sexp_find_token (ldata, "value", 0);
1972
1973   if (!(!lhash ^ !lvalue))
1974     rc = GPG_ERR_INV_OBJ; /* none or both given */
1975   else if (unknown_flag)
1976     rc = GPG_ERR_INV_FLAG;
1977   else if (ctx->encoding == PUBKEY_ENC_RAW && lvalue)
1978     {
1979       *ret_mpi = gcry_sexp_nth_mpi (lvalue, 1, 0);
1980       if (!*ret_mpi)
1981         rc = GPG_ERR_INV_OBJ;
1982     }
1983   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lvalue && for_encryption)
1984     {
1985       const void * value;
1986       size_t valuelen;
1987
1988       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
1989         rc = GPG_ERR_INV_OBJ;
1990       else
1991         rc = pkcs1_encode_for_encryption (ret_mpi, nbits, value, valuelen);
1992     }
1993   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lhash && !for_encryption)
1994     {
1995       if (gcry_sexp_length (lhash) != 3)
1996         rc = GPG_ERR_INV_OBJ;
1997       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
1998         rc = GPG_ERR_INV_OBJ;
1999       else
2000         {
2001           int algo;
2002           const void * value;
2003           size_t valuelen;
2004
2005           algo = get_hash_algo (s, n);
2006
2007           if (!algo)
2008             rc = GPG_ERR_DIGEST_ALGO;
2009           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
2010                     || !valuelen )
2011             rc = GPG_ERR_INV_OBJ;
2012           else
2013             rc = pkcs1_encode_for_signature (ret_mpi, nbits, value, valuelen,
2014                                              algo);
2015         }
2016     }
2017   else if (ctx->encoding == PUBKEY_ENC_OAEP && lvalue && for_encryption)
2018     {
2019       const void * value;
2020       size_t valuelen;
2021
2022       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
2023         rc = GPG_ERR_INV_OBJ;
2024       else
2025         {
2026           gcry_sexp_t list;
2027
2028           /* Get HASH-ALGO. */
2029           list = gcry_sexp_find_token (ldata, "hash-algo", 0);
2030           if (list)
2031             {
2032               s = gcry_sexp_nth_data (list, 1, &n);
2033               if (!s)
2034                 rc = GPG_ERR_NO_OBJ;
2035               else
2036                 {
2037                   ctx->hash_algo = get_hash_algo (s, n);
2038                   if (!ctx->hash_algo)
2039                     rc = GPG_ERR_DIGEST_ALGO;
2040                 }
2041               gcry_sexp_release (list);
2042               if (rc)
2043                 goto leave;
2044             }
2045
2046           /* Get LABEL. */
2047           list = gcry_sexp_find_token (ldata, "label", 0);
2048           if (list)
2049             {
2050               s = gcry_sexp_nth_data (list, 1, &n);
2051               if (!s)
2052                 rc = GPG_ERR_NO_OBJ;
2053               else if (n > 0)
2054                 {
2055                   ctx->label = gcry_malloc (n);
2056                   if (!ctx->label)
2057                     rc = gpg_err_code_from_syserror ();
2058                   else
2059                     {
2060                       memcpy (ctx->label, s, n);
2061                       ctx->labellen = n;
2062                     }
2063                 }
2064               gcry_sexp_release (list);
2065               if (rc)
2066                 goto leave;
2067             }
2068
2069           rc = oaep_encode (ret_mpi, nbits, ctx->hash_algo, value, valuelen,
2070                             ctx->label, ctx->labellen);
2071         }
2072     }
2073   else
2074     rc = GPG_ERR_CONFLICT;
2075
2076  leave:
2077   gcry_sexp_release (ldata);
2078   gcry_sexp_release (lhash);
2079   gcry_sexp_release (lvalue);
2080
2081   if (!rc)
2082     *flags = parsed_flags;
2083   else
2084     {
2085       gcry_free (ctx->label);
2086       ctx->label = NULL;
2087     }
2088
2089   return rc;
2090 }
2091
2092
2093 /*
2094    Do a PK encrypt operation
2095
2096    Caller has to provide a public key as the SEXP pkey and data as a
2097    SEXP with just one MPI in it. Alternatively S_DATA might be a
2098    complex S-Expression, similar to the one used for signature
2099    verification.  This provides a flag which allows to handle PKCS#1
2100    block type 2 padding.  The function returns a a sexp which may be
2101    passed to to pk_decrypt.
2102
2103    Returns: 0 or an errorcode.
2104
2105    s_data = See comment for sexp_data_to_mpi
2106    s_pkey = <key-as-defined-in-sexp_to_key>
2107    r_ciph = (enc-val
2108                (<algo>
2109                  (<param_name1> <mpi>)
2110                  ...
2111                  (<param_namen> <mpi>)
2112                ))
2113
2114 */
2115 gcry_error_t
2116 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
2117 {
2118   gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
2119   const char *algo_name, *algo_elems;
2120   int flags;
2121   struct pk_encoding_ctx ctx;
2122   gcry_err_code_t rc;
2123   gcry_pk_spec_t *pubkey = NULL;
2124   gcry_module_t module = NULL;
2125
2126   *r_ciph = NULL;
2127
2128   REGISTER_DEFAULT_PUBKEYS;
2129
2130   memset (&ctx, 0, sizeof(struct pk_encoding_ctx));
2131   /* Get the key. */
2132   rc = sexp_to_key (s_pkey, 0, NULL, &pkey, &module);
2133   if (rc)
2134     goto leave;
2135
2136   gcry_assert (module);
2137   pubkey = (gcry_pk_spec_t *) module->spec;
2138
2139   /* If aliases for the algorithm name exists, take the first one
2140      instead of the regular name to adhere to SPKI conventions.  We
2141      assume that the first alias name is the lowercase version of the
2142      regular one.  This change is required for compatibility with
2143      1.1.12 generated S-expressions. */
2144   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
2145   if (!algo_name || !*algo_name)
2146     algo_name = pubkey->name;
2147
2148   algo_elems = pubkey->elements_enc;
2149
2150   /* Get the stuff we want to encrypt. */
2151   rc = sexp_data_to_mpi (s_data, gcry_pk_get_nbits (s_pkey), &data, 1,
2152                          &flags, &ctx);
2153   if (rc)
2154     goto leave;
2155
2156   /* Now we can encrypt DATA to CIPH. */
2157   ciph = gcry_calloc (strlen (algo_elems) + 1, sizeof (*ciph));
2158   if (!ciph)
2159     {
2160       rc = gpg_err_code_from_syserror ();
2161       goto leave;
2162     }
2163   rc = pubkey_encrypt (module->mod_id, ciph, data, pkey, flags);
2164   mpi_free (data);
2165   data = NULL;
2166   if (rc)
2167     goto leave;
2168
2169   /* We did it.  Now build the return list */
2170   {
2171     char *string, *p;
2172     int i;
2173     size_t nelem = strlen (algo_elems);
2174     size_t needed = 19 + strlen (algo_name) + (nelem * 5);
2175     void **arg_list;
2176
2177     /* Build the string.  */
2178     string = p = gcry_malloc (needed);
2179     if (!string)
2180       {
2181         rc = gpg_err_code_from_syserror ();
2182         goto leave;
2183       }
2184     p = stpcpy ( p, "(enc-val(" );
2185     p = stpcpy ( p, algo_name );
2186     for (i=0; algo_elems[i]; i++ )
2187       {
2188         *p++ = '(';
2189         *p++ = algo_elems[i];
2190         p = stpcpy ( p, "%m)" );
2191       }
2192     strcpy ( p, "))" );
2193
2194     /* And now the ugly part: We don't have a function to pass an
2195      * array to a format string, so we have to do it this way :-(.  */
2196     /* FIXME: There is now such a format specifier, so we can
2197        change the code to be more clear. */
2198     arg_list = malloc (nelem * sizeof *arg_list);
2199     if (!arg_list)
2200       {
2201         rc = gpg_err_code_from_syserror ();
2202         goto leave;
2203       }
2204
2205     for (i = 0; i < nelem; i++)
2206       arg_list[i] = ciph + i;
2207
2208     rc = gcry_sexp_build_array (r_ciph, NULL, string, arg_list);
2209     free (arg_list);
2210     if (rc)
2211       BUG ();
2212     gcry_free (string);
2213   }
2214
2215  leave:
2216   if (pkey)
2217     {
2218       release_mpi_array (pkey);
2219       gcry_free (pkey);
2220     }
2221
2222   if (ciph)
2223     {
2224       release_mpi_array (ciph);
2225       gcry_free (ciph);
2226     }
2227
2228   if (module)
2229     {
2230       ath_mutex_lock (&pubkeys_registered_lock);
2231       _gcry_module_release (module);
2232       ath_mutex_unlock (&pubkeys_registered_lock);
2233     }
2234
2235   gcry_free (ctx.label);
2236
2237   return gcry_error (rc);
2238 }
2239
2240 /*
2241    Do a PK decrypt operation
2242
2243    Caller has to provide a secret key as the SEXP skey and data in a
2244    format as created by gcry_pk_encrypt.  For historic reasons the
2245    function returns simply an MPI as an S-expression part; this is
2246    deprecated and the new method should be used which returns a real
2247    S-expressionl this is selected by adding at least an empty flags
2248    list to S_DATA.
2249
2250    Returns: 0 or an errorcode.
2251
2252    s_data = (enc-val
2253               [(flags [raw, pkcs1, oaep])]
2254               (<algo>
2255                 (<param_name1> <mpi>)
2256                 ...
2257                 (<param_namen> <mpi>)
2258               ))
2259    s_skey = <key-as-defined-in-sexp_to_key>
2260    r_plain= Either an incomplete S-expression without the parentheses
2261             or if the flags list is used (even if empty) a real S-expression:
2262             (value PLAIN).
2263  */
2264 gcry_error_t
2265 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
2266 {
2267   gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL, unpad = NULL;
2268   int modern, flags;
2269   struct pk_encoding_ctx ctx;
2270   gcry_err_code_t rc;
2271   gcry_module_t module_enc = NULL, module_key = NULL;
2272
2273   *r_plain = NULL;
2274   ctx.label = NULL;
2275
2276   REGISTER_DEFAULT_PUBKEYS;
2277
2278   rc = sexp_to_key (s_skey, 1, NULL, &skey, &module_key);
2279   if (rc)
2280     goto leave;
2281
2282   rc = sexp_to_enc (s_data, &data, &module_enc, &modern, &flags, &ctx);
2283   if (rc)
2284     goto leave;
2285
2286   if (module_key->mod_id != module_enc->mod_id)
2287     {
2288       rc = GPG_ERR_CONFLICT; /* Key algo does not match data algo. */
2289       goto leave;
2290     }
2291
2292   rc = pubkey_decrypt (module_key->mod_id, &plain, data, skey, flags);
2293   if (rc)
2294     goto leave;
2295
2296   /* Do un-padding if necessary. */
2297   switch (ctx.encoding)
2298     {
2299     case PUBKEY_ENC_PKCS1:
2300       rc = pkcs1_decode_for_encryption (&unpad, gcry_pk_get_nbits (s_skey),
2301                                         plain);
2302       if (rc)
2303         goto leave;
2304       mpi_free (plain);
2305       plain = unpad;
2306       break;
2307     case PUBKEY_ENC_OAEP:
2308       rc = oaep_decode (&unpad, gcry_pk_get_nbits (s_skey), ctx.hash_algo,
2309                         plain, ctx.label, ctx.labellen);
2310       if (rc)
2311         goto leave;
2312       mpi_free (plain);
2313       plain = unpad;
2314       break;
2315     default:
2316       break;
2317     }
2318
2319   if (gcry_sexp_build (r_plain, NULL, modern? "(value %m)" : "%m", plain))
2320     BUG ();
2321
2322  leave:
2323   if (skey)
2324     {
2325       release_mpi_array (skey);
2326       gcry_free (skey);
2327     }
2328
2329   if (plain)
2330     mpi_free (plain);
2331
2332   if (data)
2333     {
2334       release_mpi_array (data);
2335       gcry_free (data);
2336     }
2337
2338   if (module_key || module_enc)
2339     {
2340       ath_mutex_lock (&pubkeys_registered_lock);
2341       if (module_key)
2342         _gcry_module_release (module_key);
2343       if (module_enc)
2344         _gcry_module_release (module_enc);
2345       ath_mutex_unlock (&pubkeys_registered_lock);
2346     }
2347
2348   gcry_free (ctx.label);
2349
2350   return gcry_error (rc);
2351 }
2352
2353
2354
2355 /*
2356    Create a signature.
2357
2358    Caller has to provide a secret key as the SEXP skey and data
2359    expressed as a SEXP list hash with only one element which should
2360    instantly be available as a MPI. Alternatively the structure given
2361    below may be used for S_HASH, it provides the abiliy to pass flags
2362    to the operation; the only flag defined by now is "pkcs1" which
2363    does PKCS#1 block type 1 style padding.
2364
2365    Returns: 0 or an errorcode.
2366             In case of 0 the function returns a new SEXP with the
2367             signature value; the structure of this signature depends on the
2368             other arguments but is always suitable to be passed to
2369             gcry_pk_verify
2370
2371    s_hash = See comment for sexp_data_to_mpi
2372
2373    s_skey = <key-as-defined-in-sexp_to_key>
2374    r_sig  = (sig-val
2375               (<algo>
2376                 (<param_name1> <mpi>)
2377                 ...
2378                 (<param_namen> <mpi>))
2379              [(hash algo)])
2380
2381   Note that (hash algo) in R_SIG is not used.
2382 */
2383 gcry_error_t
2384 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
2385 {
2386   gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
2387   gcry_pk_spec_t *pubkey = NULL;
2388   gcry_module_t module = NULL;
2389   const char *algo_name, *algo_elems;
2390   int i;
2391   gcry_err_code_t rc;
2392
2393   *r_sig = NULL;
2394
2395   REGISTER_DEFAULT_PUBKEYS;
2396
2397   rc = sexp_to_key (s_skey, 1, NULL, &skey, &module);
2398   if (rc)
2399     goto leave;
2400
2401   gcry_assert (module);
2402   pubkey = (gcry_pk_spec_t *) module->spec;
2403   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
2404   if (!algo_name || !*algo_name)
2405     algo_name = pubkey->name;
2406
2407   algo_elems = pubkey->elements_sig;
2408
2409   /* Get the stuff we want to sign.  Note that pk_get_nbits does also
2410       work on a private key. */
2411   rc = sexp_data_to_mpi (s_hash, gcry_pk_get_nbits (s_skey),
2412                              &hash, 0, NULL, NULL);
2413   if (rc)
2414     goto leave;
2415
2416   result = gcry_calloc (strlen (algo_elems) + 1, sizeof (*result));
2417   if (!result)
2418     {
2419       rc = gpg_err_code_from_syserror ();
2420       goto leave;
2421     }
2422   rc = pubkey_sign (module->mod_id, result, hash, skey);
2423   if (rc)
2424     goto leave;
2425
2426   {
2427     char *string, *p;
2428     size_t nelem, needed = strlen (algo_name) + 20;
2429     void **arg_list;
2430
2431     nelem = strlen (algo_elems);
2432
2433     /* Count elements, so that we can allocate enough space. */
2434     needed += 10 * nelem;
2435
2436     /* Build the string. */
2437     string = p = gcry_malloc (needed);
2438     if (!string)
2439       {
2440         rc = gpg_err_code_from_syserror ();
2441         goto leave;
2442       }
2443     p = stpcpy (p, "(sig-val(");
2444     p = stpcpy (p, algo_name);
2445     for (i = 0; algo_elems[i]; i++)
2446       {
2447         *p++ = '(';
2448         *p++ = algo_elems[i];
2449         p = stpcpy (p, "%m)");
2450       }
2451     strcpy (p, "))");
2452
2453     arg_list = malloc (nelem * sizeof *arg_list);
2454     if (!arg_list)
2455       {
2456         rc = gpg_err_code_from_syserror ();
2457         goto leave;
2458       }
2459
2460     for (i = 0; i < nelem; i++)
2461       arg_list[i] = result + i;
2462
2463     rc = gcry_sexp_build_array (r_sig, NULL, string, arg_list);
2464     free (arg_list);
2465     if (rc)
2466       BUG ();
2467     gcry_free (string);
2468   }
2469
2470  leave:
2471   if (skey)
2472     {
2473       release_mpi_array (skey);
2474       gcry_free (skey);
2475     }
2476
2477   if (hash)
2478     mpi_free (hash);
2479
2480   if (result)
2481     {
2482       release_mpi_array (result);
2483       gcry_free (result);
2484     }
2485
2486   return gcry_error (rc);
2487 }
2488
2489
2490 /*
2491    Verify a signature.
2492
2493    Caller has to supply the public key pkey, the signature sig and his
2494    hashvalue data.  Public key has to be a standard public key given
2495    as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
2496    must be an S-Exp like the one in sign too.  */
2497 gcry_error_t
2498 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
2499 {
2500   gcry_module_t module_key = NULL, module_sig = NULL;
2501   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
2502   gcry_err_code_t rc;
2503
2504   REGISTER_DEFAULT_PUBKEYS;
2505
2506   rc = sexp_to_key (s_pkey, 0, NULL, &pkey, &module_key);
2507   if (rc)
2508     goto leave;
2509
2510   rc = sexp_to_sig (s_sig, &sig, &module_sig);
2511   if (rc)
2512     goto leave;
2513
2514   /* Fixme: Check that the algorithm of S_SIG is compatible to the one
2515      of S_PKEY.  */
2516
2517   if (module_key->mod_id != module_sig->mod_id)
2518     {
2519       rc = GPG_ERR_CONFLICT;
2520       goto leave;
2521     }
2522
2523   rc = sexp_data_to_mpi (s_hash, gcry_pk_get_nbits (s_pkey), &hash, 0, 0, NULL);
2524   if (rc)
2525     goto leave;
2526
2527   rc = pubkey_verify (module_key->mod_id, hash, sig, pkey, NULL, NULL);
2528
2529  leave:
2530   if (pkey)
2531     {
2532       release_mpi_array (pkey);
2533       gcry_free (pkey);
2534     }
2535   if (sig)
2536     {
2537       release_mpi_array (sig);
2538       gcry_free (sig);
2539     }
2540   if (hash)
2541     mpi_free (hash);
2542
2543   if (module_key || module_sig)
2544     {
2545       ath_mutex_lock (&pubkeys_registered_lock);
2546       if (module_key)
2547         _gcry_module_release (module_key);
2548       if (module_sig)
2549         _gcry_module_release (module_sig);
2550       ath_mutex_unlock (&pubkeys_registered_lock);
2551     }
2552
2553   return gcry_error (rc);
2554 }
2555
2556
2557 /*
2558    Test a key.
2559
2560    This may be used either for a public or a secret key to see whether
2561    the internal structure is okay.
2562
2563    Returns: 0 or an errorcode.
2564
2565    s_key = <key-as-defined-in-sexp_to_key> */
2566 gcry_error_t
2567 gcry_pk_testkey (gcry_sexp_t s_key)
2568 {
2569   gcry_module_t module = NULL;
2570   gcry_mpi_t *key = NULL;
2571   gcry_err_code_t rc;
2572
2573   REGISTER_DEFAULT_PUBKEYS;
2574
2575   /* Note we currently support only secret key checking. */
2576   rc = sexp_to_key (s_key, 1, NULL, &key, &module);
2577   if (! rc)
2578     {
2579       rc = pubkey_check_secret_key (module->mod_id, key);
2580       release_mpi_array (key);
2581       gcry_free (key);
2582     }
2583   return gcry_error (rc);
2584 }
2585
2586
2587 /*
2588   Create a public key pair and return it in r_key.
2589   How the key is created depends on s_parms:
2590   (genkey
2591    (algo
2592      (parameter_name_1 ....)
2593       ....
2594      (parameter_name_n ....)
2595   ))
2596   The key is returned in a format depending on the
2597   algorithm. Both, private and secret keys are returned
2598   and optionally some additional informatin.
2599   For elgamal we return this structure:
2600   (key-data
2601    (public-key
2602      (elg
2603         (p <mpi>)
2604         (g <mpi>)
2605         (y <mpi>)
2606      )
2607    )
2608    (private-key
2609      (elg
2610         (p <mpi>)
2611         (g <mpi>)
2612         (y <mpi>)
2613         (x <mpi>)
2614      )
2615    )
2616    (misc-key-info
2617       (pm1-factors n1 n2 ... nn)
2618    ))
2619  */
2620 gcry_error_t
2621 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
2622 {
2623   gcry_pk_spec_t *pubkey = NULL;
2624   gcry_module_t module = NULL;
2625   gcry_sexp_t list = NULL;
2626   gcry_sexp_t l2 = NULL;
2627   gcry_sexp_t l3 = NULL;
2628   char *name = NULL;
2629   size_t n;
2630   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
2631   int i, j;
2632   const char *algo_name = NULL;
2633   int algo;
2634   const char *sec_elems = NULL, *pub_elems = NULL;
2635   gcry_mpi_t skey[12];
2636   gcry_mpi_t *factors = NULL;
2637   gcry_sexp_t extrainfo = NULL;
2638   unsigned int nbits = 0;
2639   unsigned long use_e = 0;
2640
2641   skey[0] = NULL;
2642   *r_key = NULL;
2643
2644   REGISTER_DEFAULT_PUBKEYS;
2645
2646   list = gcry_sexp_find_token (s_parms, "genkey", 0);
2647   if (!list)
2648     {
2649       rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
2650       goto leave;
2651     }
2652
2653   l2 = gcry_sexp_cadr (list);
2654   gcry_sexp_release (list);
2655   list = l2;
2656   l2 = NULL;
2657   if (! list)
2658     {
2659       rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
2660       goto leave;
2661     }
2662
2663   name = _gcry_sexp_nth_string (list, 0);
2664   if (!name)
2665     {
2666       rc = GPG_ERR_INV_OBJ; /* Algo string missing.  */
2667       goto leave;
2668     }
2669
2670   ath_mutex_lock (&pubkeys_registered_lock);
2671   module = gcry_pk_lookup_name (name);
2672   ath_mutex_unlock (&pubkeys_registered_lock);
2673   gcry_free (name);
2674   name = NULL;
2675   if (!module)
2676     {
2677       rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
2678       goto leave;
2679     }
2680
2681   pubkey = (gcry_pk_spec_t *) module->spec;
2682   algo = module->mod_id;
2683   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
2684   if (!algo_name || !*algo_name)
2685     algo_name = pubkey->name;
2686   pub_elems = pubkey->elements_pkey;
2687   sec_elems = pubkey->elements_skey;
2688   if (strlen (sec_elems) >= DIM(skey))
2689     BUG ();
2690
2691   /* Handle the optional rsa-use-e element.  Actually this belong into
2692      the algorithm module but we have this parameter in the public
2693      module API, so we need to parse it right here.  */
2694   l2 = gcry_sexp_find_token (list, "rsa-use-e", 0);
2695   if (l2)
2696     {
2697       char buf[50];
2698       const char *s;
2699
2700       s = gcry_sexp_nth_data (l2, 1, &n);
2701       if ( !s || n >= DIM (buf) - 1 )
2702         {
2703           rc = GPG_ERR_INV_OBJ; /* No value or value too large.  */
2704           goto leave;
2705         }
2706       memcpy (buf, s, n);
2707       buf[n] = 0;
2708       use_e = strtoul (buf, NULL, 0);
2709       gcry_sexp_release (l2);
2710       l2 = NULL;
2711     }
2712   else
2713     use_e = 65537; /* Not given, use the value generated by old versions. */
2714
2715
2716   /* Get the "nbits" parameter.  */
2717   l2 = gcry_sexp_find_token (list, "nbits", 0);
2718   if (l2)
2719     {
2720       char buf[50];
2721       const char *s;
2722
2723       s = gcry_sexp_nth_data (l2, 1, &n);
2724       if (!s || n >= DIM (buf) - 1 )
2725         {
2726           rc = GPG_ERR_INV_OBJ; /* NBITS given without a cdr.  */
2727           goto leave;
2728         }
2729       memcpy (buf, s, n);
2730       buf[n] = 0;
2731       nbits = (unsigned int)strtoul (buf, NULL, 0);
2732       gcry_sexp_release (l2); l2 = NULL;
2733     }
2734   else
2735     nbits = 0;
2736
2737   /* Pass control to the algorithm module. */
2738   rc = pubkey_generate (module->mod_id, nbits, use_e, list, skey,
2739                         &factors, &extrainfo);
2740   gcry_sexp_release (list); list = NULL;
2741   if (rc)
2742     goto leave;
2743
2744   /* Key generation succeeded: Build an S-expression.  */
2745   {
2746     char *string, *p;
2747     size_t nelem=0, nelem_cp = 0, needed=0;
2748     gcry_mpi_t mpis[30];
2749     int percent_s_idx = -1;
2750
2751     /* Estimate size of format string.  */
2752     nelem = strlen (pub_elems) + strlen (sec_elems);
2753     if (factors)
2754       {
2755         for (i = 0; factors[i]; i++)
2756           nelem++;
2757       }
2758     nelem_cp = nelem;
2759
2760     needed += nelem * 10;
2761     /* (+5 is for EXTRAINFO ("%S")).  */
2762     needed += 2 * strlen (algo_name) + 300 + 5;
2763     if (nelem > DIM (mpis))
2764       BUG ();
2765
2766     /* Build the string. */
2767     nelem = 0;
2768     string = p = gcry_malloc (needed);
2769     if (!string)
2770       {
2771         rc = gpg_err_code_from_syserror ();
2772         goto leave;
2773       }
2774     p = stpcpy (p, "(key-data");
2775     p = stpcpy (p, "(public-key(");
2776     p = stpcpy (p, algo_name);
2777     for(i = 0; pub_elems[i]; i++)
2778       {
2779         *p++ = '(';
2780         *p++ = pub_elems[i];
2781         p = stpcpy (p, "%m)");
2782         mpis[nelem++] = skey[i];
2783       }
2784     if (extrainfo && (algo == GCRY_PK_ECDSA || algo == GCRY_PK_ECDH))
2785       {
2786         /* Very ugly hack to insert the used curve parameter into the
2787            list of public key parameters.  */
2788         percent_s_idx = nelem;
2789         p = stpcpy (p, "%S");
2790       }
2791     p = stpcpy (p, "))");
2792     p = stpcpy (p, "(private-key(");
2793     p = stpcpy (p, algo_name);
2794     for (i = 0; sec_elems[i]; i++)
2795       {
2796         *p++ = '(';
2797         *p++ = sec_elems[i];
2798         p = stpcpy (p, "%m)");
2799         mpis[nelem++] = skey[i];
2800       }
2801     p = stpcpy (p, "))");
2802
2803     /* Hack to make release_mpi_array() work.  */
2804     skey[i] = NULL;
2805
2806     if (extrainfo && percent_s_idx == -1)
2807       {
2808         /* If we have extrainfo we should not have any factors.  */
2809         p = stpcpy (p, "%S");
2810       }
2811     else if (factors && factors[0])
2812       {
2813         p = stpcpy (p, "(misc-key-info(pm1-factors");
2814         for(i = 0; factors[i]; i++)
2815           {
2816             p = stpcpy (p, "%m");
2817             mpis[nelem++] = factors[i];
2818           }
2819         p = stpcpy (p, "))");
2820       }
2821     strcpy (p, ")");
2822     gcry_assert (p - string < needed);
2823
2824     while (nelem < DIM (mpis))
2825       mpis[nelem++] = NULL;
2826
2827     {
2828       int elem_n = strlen (pub_elems) + strlen (sec_elems);
2829       void **arg_list;
2830
2831       /* Allocate one extra for EXTRAINFO ("%S").  */
2832       arg_list = gcry_calloc (nelem_cp+1, sizeof *arg_list);
2833       if (!arg_list)
2834         {
2835           rc = gpg_err_code_from_syserror ();
2836           goto leave;
2837         }
2838       for (i = j = 0; i < elem_n; i++)
2839         {
2840           if (i == percent_s_idx)
2841             arg_list[j++] = &extrainfo;
2842           arg_list[j++] = mpis + i;
2843         }
2844       if (extrainfo && percent_s_idx == -1)
2845         arg_list[j] = &extrainfo;
2846       else if (factors && factors[0])
2847         {
2848           for (; i < nelem_cp; i++)
2849             arg_list[j++] = factors + i - elem_n;
2850         }
2851       rc = gcry_sexp_build_array (r_key, NULL, string, arg_list);
2852       gcry_free (arg_list);
2853       if (rc)
2854         BUG ();
2855       gcry_assert (DIM (mpis) == 30); /* Reminder to make sure that
2856                                          the array gets increased if
2857                                          new parameters are added. */
2858     }
2859     gcry_free (string);
2860   }
2861
2862  leave:
2863   gcry_free (name);
2864   gcry_sexp_release (extrainfo);
2865   release_mpi_array (skey);
2866   /* Don't free SKEY itself, it is an stack allocated array. */
2867
2868   if (factors)
2869     {
2870       release_mpi_array ( factors );
2871       gcry_free (factors);
2872     }
2873
2874   gcry_sexp_release (l3);
2875   gcry_sexp_release (l2);
2876   gcry_sexp_release (list);
2877
2878   if (module)
2879     {
2880       ath_mutex_lock (&pubkeys_registered_lock);
2881       _gcry_module_release (module);
2882       ath_mutex_unlock (&pubkeys_registered_lock);
2883     }
2884
2885   return gcry_error (rc);
2886 }
2887
2888
2889 /*
2890    Get the number of nbits from the public key.
2891
2892    Hmmm: Should we have really this function or is it better to have a
2893    more general function to retrieve different properties of the key?  */
2894 unsigned int
2895 gcry_pk_get_nbits (gcry_sexp_t key)
2896 {
2897   gcry_module_t module = NULL;
2898   gcry_pk_spec_t *pubkey;
2899   gcry_mpi_t *keyarr = NULL;
2900   unsigned int nbits = 0;
2901   gcry_err_code_t rc;
2902
2903   REGISTER_DEFAULT_PUBKEYS;
2904
2905   rc = sexp_to_key (key, 0, NULL, &keyarr, &module);
2906   if (rc == GPG_ERR_INV_OBJ)
2907     rc = sexp_to_key (key, 1, NULL, &keyarr, &module);
2908   if (rc)
2909     return 0; /* Error - 0 is a suitable indication for that. */
2910
2911   pubkey = (gcry_pk_spec_t *) module->spec;
2912   nbits = (*pubkey->get_nbits) (module->mod_id, keyarr);
2913
2914   ath_mutex_lock (&pubkeys_registered_lock);
2915   _gcry_module_release (module);
2916   ath_mutex_unlock (&pubkeys_registered_lock);
2917
2918   release_mpi_array (keyarr);
2919   gcry_free (keyarr);
2920
2921   return nbits;
2922 }
2923
2924
2925 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
2926    key parameters expressed in a way depending on the algorithm.
2927
2928    ARRAY must either be 20 bytes long or NULL; in the latter case a
2929    newly allocated array of that size is returned, otherwise ARRAY or
2930    NULL is returned to indicate an error which is most likely an
2931    unknown algorithm.  The function accepts public or secret keys. */
2932 unsigned char *
2933 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
2934 {
2935   gcry_sexp_t list = NULL, l2 = NULL;
2936   gcry_pk_spec_t *pubkey = NULL;
2937   gcry_module_t module = NULL;
2938   pk_extra_spec_t *extraspec;
2939   const char *s;
2940   char *name = NULL;
2941   int idx;
2942   const char *elems;
2943   gcry_md_hd_t md = NULL;
2944   int okay = 0;
2945
2946   REGISTER_DEFAULT_PUBKEYS;
2947
2948   /* Check that the first element is valid. */
2949   list = gcry_sexp_find_token (key, "public-key", 0);
2950   if (! list)
2951     list = gcry_sexp_find_token (key, "private-key", 0);
2952   if (! list)
2953     list = gcry_sexp_find_token (key, "protected-private-key", 0);
2954   if (! list)
2955     list = gcry_sexp_find_token (key, "shadowed-private-key", 0);
2956   if (! list)
2957     return NULL; /* No public- or private-key object. */
2958
2959   l2 = gcry_sexp_cadr (list);
2960   gcry_sexp_release (list);
2961   list = l2;
2962   l2 = NULL;
2963
2964   name = _gcry_sexp_nth_string (list, 0);
2965   if (!name)
2966     goto fail; /* Invalid structure of object. */
2967
2968   ath_mutex_lock (&pubkeys_registered_lock);
2969   module = gcry_pk_lookup_name (name);
2970   ath_mutex_unlock (&pubkeys_registered_lock);
2971
2972   if (!module)
2973     goto fail; /* Unknown algorithm.  */
2974
2975   pubkey = (gcry_pk_spec_t *) module->spec;
2976   extraspec = module->extraspec;
2977
2978   elems = pubkey->elements_grip;
2979   if (!elems)
2980     goto fail; /* No grip parameter.  */
2981
2982   if (gcry_md_open (&md, GCRY_MD_SHA1, 0))
2983     goto fail;
2984
2985   if (extraspec && extraspec->comp_keygrip)
2986     {
2987       /* Module specific method to compute a keygrip.  */
2988       if (extraspec->comp_keygrip (md, list))
2989         goto fail;
2990     }
2991   else
2992     {
2993       /* Generic method to compute a keygrip.  */
2994       for (idx = 0, s = elems; *s; s++, idx++)
2995         {
2996           const char *data;
2997           size_t datalen;
2998           char buf[30];
2999
3000           l2 = gcry_sexp_find_token (list, s, 1);
3001           if (! l2)
3002             goto fail;
3003           data = gcry_sexp_nth_data (l2, 1, &datalen);
3004           if (! data)
3005             goto fail;
3006
3007           snprintf (buf, sizeof buf, "(1:%c%u:", *s, (unsigned int)datalen);
3008           gcry_md_write (md, buf, strlen (buf));
3009           gcry_md_write (md, data, datalen);
3010           gcry_sexp_release (l2);
3011           l2 = NULL;
3012           gcry_md_write (md, ")", 1);
3013         }
3014     }
3015
3016   if (!array)
3017     {
3018       array = gcry_malloc (20);
3019       if (! array)
3020         goto fail;
3021     }
3022
3023   memcpy (array, gcry_md_read (md, GCRY_MD_SHA1), 20);
3024   okay = 1;
3025
3026  fail:
3027   gcry_free (name);
3028   gcry_sexp_release (l2);
3029   gcry_md_close (md);
3030   gcry_sexp_release (list);
3031   return okay? array : NULL;
3032 }
3033
3034
3035 \f
3036 const char *
3037 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
3038 {
3039   gcry_mpi_t *pkey = NULL;
3040   gcry_sexp_t list = NULL;
3041   gcry_sexp_t l2;
3042   gcry_module_t module = NULL;
3043   pk_extra_spec_t *extraspec;
3044   char *name = NULL;
3045   const char *result = NULL;
3046   int want_private = 1;
3047
3048   if (r_nbits)
3049     *r_nbits = 0;
3050
3051   REGISTER_DEFAULT_PUBKEYS;
3052
3053   if (key)
3054     {
3055       iterator = 0;
3056
3057       /* Check that the first element is valid. */
3058       list = gcry_sexp_find_token (key, "public-key", 0);
3059       if (list)
3060         want_private = 0;
3061       if (!list)
3062         list = gcry_sexp_find_token (key, "private-key", 0);
3063       if (!list)
3064         return NULL; /* No public- or private-key object. */
3065
3066       l2 = gcry_sexp_cadr (list);
3067       gcry_sexp_release (list);
3068       list = l2;
3069       l2 = NULL;
3070
3071       name = _gcry_sexp_nth_string (list, 0);
3072       if (!name)
3073         goto leave; /* Invalid structure of object. */
3074
3075       /* Get the key.  We pass the names of the parameters for
3076          override_elems; this allows to call this function without the
3077          actual public key parameter.  */
3078       if (sexp_to_key (key, want_private, "pabgn", &pkey, &module))
3079         goto leave;
3080     }
3081   else
3082     {
3083       ath_mutex_lock (&pubkeys_registered_lock);
3084       module = gcry_pk_lookup_name ("ecc");
3085       ath_mutex_unlock (&pubkeys_registered_lock);
3086       if (!module)
3087         goto leave;
3088     }
3089
3090   extraspec = module->extraspec;
3091   if (!extraspec || !extraspec->get_curve)
3092     goto leave;
3093
3094   result = extraspec->get_curve (pkey, iterator, r_nbits);
3095
3096  leave:
3097   if (pkey)
3098     {
3099       release_mpi_array (pkey);
3100       gcry_free (pkey);
3101     }
3102   if (module)
3103     {
3104       ath_mutex_lock (&pubkeys_registered_lock);
3105       _gcry_module_release (module);
3106       ath_mutex_unlock (&pubkeys_registered_lock);
3107     }
3108   gcry_free (name);
3109   gcry_sexp_release (list);
3110   return result;
3111 }
3112
3113
3114 \f
3115 gcry_sexp_t
3116 gcry_pk_get_param (int algo, const char *name)
3117 {
3118   gcry_module_t module = NULL;
3119   pk_extra_spec_t *extraspec;
3120   gcry_sexp_t result = NULL;
3121
3122   if (algo != GCRY_PK_ECDSA && algo != GCRY_PK_ECDH)
3123     return NULL;
3124
3125   REGISTER_DEFAULT_PUBKEYS;
3126
3127   ath_mutex_lock (&pubkeys_registered_lock);
3128   module = gcry_pk_lookup_name ("ecc");
3129   ath_mutex_unlock (&pubkeys_registered_lock);
3130   if (module)
3131     {
3132       extraspec = module->extraspec;
3133       if (extraspec && extraspec->get_curve_param)
3134         result = extraspec->get_curve_param (name);
3135
3136       ath_mutex_lock (&pubkeys_registered_lock);
3137       _gcry_module_release (module);
3138       ath_mutex_unlock (&pubkeys_registered_lock);
3139     }
3140   return result;
3141 }
3142
3143
3144 \f
3145 gcry_error_t
3146 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
3147 {
3148   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3149
3150   REGISTER_DEFAULT_PUBKEYS;
3151
3152   switch (cmd)
3153     {
3154     case GCRYCTL_DISABLE_ALGO:
3155       /* This one expects a buffer pointing to an integer with the
3156          algo number.  */
3157       if ((! buffer) || (buflen != sizeof (int)))
3158         err = GPG_ERR_INV_ARG;
3159       else
3160         disable_pubkey_algo (*((int *) buffer));
3161       break;
3162
3163     default:
3164       err = GPG_ERR_INV_OP;
3165     }
3166
3167   return gcry_error (err);
3168 }
3169
3170
3171 /* Return information about the given algorithm
3172
3173    WHAT selects the kind of information returned:
3174
3175     GCRYCTL_TEST_ALGO:
3176         Returns 0 when the specified algorithm is available for use.
3177         Buffer must be NULL, nbytes  may have the address of a variable
3178         with the required usage of the algorithm. It may be 0 for don't
3179         care or a combination of the GCRY_PK_USAGE_xxx flags;
3180
3181     GCRYCTL_GET_ALGO_USAGE:
3182         Return the usage flags for the given algo.  An invalid algo
3183         returns 0.  Disabled algos are ignored here because we
3184         only want to know whether the algo is at all capable of
3185         the usage.
3186
3187    Note: Because this function is in most cases used to return an
3188    integer value, we can make it easier for the caller to just look at
3189    the return value.  The caller will in all cases consult the value
3190    and thereby detecting whether a error occurred or not (i.e. while
3191    checking the block size) */
3192 gcry_error_t
3193 gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
3194 {
3195   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3196
3197   switch (what)
3198     {
3199     case GCRYCTL_TEST_ALGO:
3200       {
3201         int use = nbytes ? *nbytes : 0;
3202         if (buffer)
3203           err = GPG_ERR_INV_ARG;
3204         else if (check_pubkey_algo (algorithm, use))
3205           err = GPG_ERR_PUBKEY_ALGO;
3206         break;
3207       }
3208
3209     case GCRYCTL_GET_ALGO_USAGE:
3210       {
3211         gcry_module_t pubkey;
3212         int use = 0;
3213
3214         REGISTER_DEFAULT_PUBKEYS;
3215
3216         ath_mutex_lock (&pubkeys_registered_lock);
3217         pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
3218         if (pubkey)
3219           {
3220             use = ((gcry_pk_spec_t *) pubkey->spec)->use;
3221             _gcry_module_release (pubkey);
3222           }
3223         ath_mutex_unlock (&pubkeys_registered_lock);
3224
3225         /* FIXME? */
3226         *nbytes = use;
3227
3228         break;
3229       }
3230
3231     case GCRYCTL_GET_ALGO_NPKEY:
3232       {
3233         /* FIXME?  */
3234         int npkey = pubkey_get_npkey (algorithm);
3235         *nbytes = npkey;
3236         break;
3237       }
3238     case GCRYCTL_GET_ALGO_NSKEY:
3239       {
3240         /* FIXME?  */
3241         int nskey = pubkey_get_nskey (algorithm);
3242         *nbytes = nskey;
3243         break;
3244       }
3245     case GCRYCTL_GET_ALGO_NSIGN:
3246       {
3247         /* FIXME?  */
3248         int nsign = pubkey_get_nsig (algorithm);
3249         *nbytes = nsign;
3250         break;
3251       }
3252     case GCRYCTL_GET_ALGO_NENCR:
3253       {
3254         /* FIXME?  */
3255         int nencr = pubkey_get_nenc (algorithm);
3256         *nbytes = nencr;
3257         break;
3258       }
3259
3260     default:
3261       err = GPG_ERR_INV_OP;
3262     }
3263
3264   return gcry_error (err);
3265 }
3266
3267
3268 /* Explicitly initialize this module.  */
3269 gcry_err_code_t
3270 _gcry_pk_init (void)
3271 {
3272   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3273
3274   REGISTER_DEFAULT_PUBKEYS;
3275
3276   return err;
3277 }
3278
3279
3280 gcry_err_code_t
3281 _gcry_pk_module_lookup (int algorithm, gcry_module_t *module)
3282 {
3283   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3284   gcry_module_t pubkey;
3285
3286   REGISTER_DEFAULT_PUBKEYS;
3287
3288   ath_mutex_lock (&pubkeys_registered_lock);
3289   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
3290   if (pubkey)
3291     *module = pubkey;
3292   else
3293     err = GPG_ERR_PUBKEY_ALGO;
3294   ath_mutex_unlock (&pubkeys_registered_lock);
3295
3296   return err;
3297 }
3298
3299
3300 void
3301 _gcry_pk_module_release (gcry_module_t module)
3302 {
3303   ath_mutex_lock (&pubkeys_registered_lock);
3304   _gcry_module_release (module);
3305   ath_mutex_unlock (&pubkeys_registered_lock);
3306 }
3307
3308 /* Get a list consisting of the IDs of the loaded pubkey modules.  If
3309    LIST is zero, write the number of loaded pubkey modules to
3310    LIST_LENGTH and return.  If LIST is non-zero, the first
3311    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
3312    according size.  In case there are less pubkey modules than
3313    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
3314 gcry_error_t
3315 gcry_pk_list (int *list, int *list_length)
3316 {
3317   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3318
3319   ath_mutex_lock (&pubkeys_registered_lock);
3320   err = _gcry_module_list (pubkeys_registered, list, list_length);
3321   ath_mutex_unlock (&pubkeys_registered_lock);
3322
3323   return err;
3324 }
3325
3326
3327 /* Run the selftests for pubkey algorithm ALGO with optional reporting
3328    function REPORT.  */
3329 gpg_error_t
3330 _gcry_pk_selftest (int algo, int extended, selftest_report_func_t report)
3331 {
3332   gcry_module_t module = NULL;
3333   pk_extra_spec_t *extraspec = NULL;
3334   gcry_err_code_t ec = 0;
3335
3336   REGISTER_DEFAULT_PUBKEYS;
3337
3338   ath_mutex_lock (&pubkeys_registered_lock);
3339   module = _gcry_module_lookup_id (pubkeys_registered, algo);
3340   if (module && !(module->flags & FLAG_MODULE_DISABLED))
3341     extraspec = module->extraspec;
3342   ath_mutex_unlock (&pubkeys_registered_lock);
3343   if (extraspec && extraspec->selftest)
3344     ec = extraspec->selftest (algo, extended, report);
3345   else
3346     {
3347       ec = GPG_ERR_PUBKEY_ALGO;
3348       if (report)
3349         report ("pubkey", algo, "module",
3350                 module && !(module->flags & FLAG_MODULE_DISABLED)?
3351                 "no selftest available" :
3352                 module? "algorithm disabled" : "algorithm not found");
3353     }
3354
3355   if (module)
3356     {
3357       ath_mutex_lock (&pubkeys_registered_lock);
3358       _gcry_module_release (module);
3359       ath_mutex_unlock (&pubkeys_registered_lock);
3360     }
3361   return gpg_error (ec);
3362 }
3363
3364
3365 /* This function is only used by ac.c!  */
3366 gcry_err_code_t
3367 _gcry_pk_get_elements (int algo, char **enc, char **sig)
3368 {
3369   gcry_module_t pubkey;
3370   gcry_pk_spec_t *spec;
3371   gcry_err_code_t err;
3372   char *enc_cp;
3373   char *sig_cp;
3374
3375   REGISTER_DEFAULT_PUBKEYS;
3376
3377   enc_cp = NULL;
3378   sig_cp = NULL;
3379   spec = NULL;
3380
3381   pubkey = _gcry_module_lookup_id (pubkeys_registered, algo);
3382   if (! pubkey)
3383     {
3384       err = GPG_ERR_INTERNAL;
3385       goto out;
3386     }
3387   spec = pubkey->spec;
3388
3389   if (enc)
3390     {
3391       enc_cp = strdup (spec->elements_enc);
3392       if (! enc_cp)
3393         {
3394           err = gpg_err_code_from_syserror ();
3395           goto out;
3396         }
3397     }
3398
3399   if (sig)
3400     {
3401       sig_cp = strdup (spec->elements_sig);
3402       if (! sig_cp)
3403         {
3404           err = gpg_err_code_from_syserror ();
3405           goto out;
3406         }
3407     }
3408
3409   if (enc)
3410     *enc = enc_cp;
3411   if (sig)
3412     *sig = sig_cp;
3413   err = 0;
3414
3415  out:
3416
3417   _gcry_module_release (pubkey);
3418   if (err)
3419     {
3420       free (enc_cp);
3421       free (sig_cp);
3422     }
3423
3424   return err;
3425 }