ad5f89b7fa446a588f9e60546408a5391fb7b7fe
[libgcrypt.git] / cipher / pubkey.c
1 /* pubkey.c  -  pubkey dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2002, 2003, 2005, 
3  *               2007, 2008 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 #include <assert.h>
27
28 #include "g10lib.h"
29 #include "mpi.h"
30 #include "cipher.h"
31 #include "ath.h"
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       &dummy_extra_spec,             GCRY_PK_ELG   },
68     { &_gcry_pubkey_spec_elg,
69       &dummy_extra_spec,             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 #endif
79     { NULL, 0 },
80   };
81
82 /* List of registered ciphers.  */
83 static gcry_module_t pubkeys_registered;
84
85 /* This is the lock protecting PUBKEYS_REGISTERED.  */
86 static ath_mutex_t pubkeys_registered_lock = ATH_MUTEX_INITIALIZER;;
87
88 /* Flag to check wether the default pubkeys have already been
89    registered.  */
90 static int default_pubkeys_registered;
91
92 /* Convenient macro for registering the default digests.  */
93 #define REGISTER_DEFAULT_PUBKEYS                   \
94   do                                               \
95     {                                              \
96       ath_mutex_lock (&pubkeys_registered_lock);   \
97       if (! default_pubkeys_registered)            \
98         {                                          \
99           pk_register_default ();                  \
100           default_pubkeys_registered = 1;          \
101         }                                          \
102       ath_mutex_unlock (&pubkeys_registered_lock); \
103     }                                              \
104   while (0)
105
106 /* These dummy functions are used in case a cipher implementation
107    refuses to provide it's own functions.  */
108
109 static gcry_err_code_t
110 dummy_generate (int algorithm, unsigned int nbits, unsigned long dummy,
111                 gcry_mpi_t *skey, gcry_mpi_t **retfactors)
112 {
113   (void)algorithm;
114   (void)nbits;
115   (void)dummy;
116   (void)skey;
117   (void)retfactors;
118   fips_signal_error ("using dummy public key function");
119   return GPG_ERR_NOT_IMPLEMENTED;
120 }
121
122 static gcry_err_code_t
123 dummy_check_secret_key (int algorithm, gcry_mpi_t *skey)
124 {
125   (void)algorithm;
126   (void)skey;
127   fips_signal_error ("using dummy public key function");
128   return GPG_ERR_NOT_IMPLEMENTED;
129 }
130
131 static gcry_err_code_t
132 dummy_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
133                gcry_mpi_t *pkey, int flags)
134 {
135   (void)algorithm;
136   (void)resarr;
137   (void)data;
138   (void)pkey;
139   (void)flags;
140   fips_signal_error ("using dummy public key function");
141   return GPG_ERR_NOT_IMPLEMENTED;
142 }
143
144 static gcry_err_code_t
145 dummy_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data,
146                gcry_mpi_t *skey, int flags)
147 {
148   (void)algorithm;
149   (void)result;
150   (void)data;
151   (void)skey;
152   (void)flags;
153   fips_signal_error ("using dummy public key function");
154   return GPG_ERR_NOT_IMPLEMENTED;
155 }
156
157 static gcry_err_code_t
158 dummy_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
159             gcry_mpi_t *skey)
160 {
161   (void)algorithm;
162   (void)resarr;
163   (void)data;
164   (void)skey;
165   fips_signal_error ("using dummy public key function");
166   return GPG_ERR_NOT_IMPLEMENTED;
167 }
168
169 static gcry_err_code_t
170 dummy_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data,
171               gcry_mpi_t *pkey,
172               int (*cmp) (void *, gcry_mpi_t), void *opaquev)
173 {
174   (void)algorithm;
175   (void)hash;
176   (void)data;
177   (void)pkey;
178   (void)cmp;
179   (void)opaquev;
180   fips_signal_error ("using dummy public key function");
181   return GPG_ERR_NOT_IMPLEMENTED;
182 }
183
184 static unsigned
185 dummy_get_nbits (int algorithm, gcry_mpi_t *pkey)
186 {
187   (void)algorithm;
188   (void)pkey;
189   fips_signal_error ("using dummy public key function");
190   return 0;
191 }
192
193 /* Internal function.  Register all the pubkeys included in
194    PUBKEY_TABLE.  Returns zero on success or an error code.  */
195 static void
196 pk_register_default (void)
197 {
198   gcry_err_code_t err = 0;
199   int i;
200   
201   for (i = 0; (! err) && pubkey_table[i].pubkey; i++)
202     {
203 #define pubkey_use_dummy(func)                       \
204       if (! pubkey_table[i].pubkey->func)            \
205         pubkey_table[i].pubkey->func = dummy_##func;
206
207       pubkey_use_dummy (generate);
208       pubkey_use_dummy (check_secret_key);
209       pubkey_use_dummy (encrypt);
210       pubkey_use_dummy (decrypt);
211       pubkey_use_dummy (sign);
212       pubkey_use_dummy (verify);
213       pubkey_use_dummy (get_nbits);
214 #undef pubkey_use_dummy
215
216       err = _gcry_module_add (&pubkeys_registered,
217                               pubkey_table[i].algorithm,
218                               (void *) pubkey_table[i].pubkey, 
219                               (void *) pubkey_table[i].extraspec, 
220                               NULL);
221     }
222
223   if (err)
224     BUG ();
225 }
226
227 /* Internal callback function.  Used via _gcry_module_lookup.  */
228 static int
229 gcry_pk_lookup_func_name (void *spec, void *data)
230 {
231   gcry_pk_spec_t *pubkey = (gcry_pk_spec_t *) spec;
232   char *name = (char *) data;
233   const char **aliases = pubkey->aliases;
234   int ret = stricmp (name, pubkey->name);
235
236   while (ret && *aliases)
237     ret = stricmp (name, *aliases++);
238
239   return ! ret;
240 }
241
242 /* Internal function.  Lookup a pubkey entry by it's name.  */
243 static gcry_module_t 
244 gcry_pk_lookup_name (const char *name)
245 {
246   gcry_module_t pubkey;
247
248   pubkey = _gcry_module_lookup (pubkeys_registered, (void *) name,
249                                 gcry_pk_lookup_func_name);
250
251   return pubkey;
252 }
253
254 /* Register a new pubkey module whose specification can be found in
255    PUBKEY.  On success, a new algorithm ID is stored in ALGORITHM_ID
256    and a pointer representhing this module is stored in MODULE.  */
257 gcry_error_t
258 _gcry_pk_register (gcry_pk_spec_t *pubkey,
259                    pk_extra_spec_t *extraspec,
260                    unsigned int *algorithm_id,
261                    gcry_module_t *module)
262 {
263   gcry_err_code_t err = GPG_ERR_NO_ERROR;
264   gcry_module_t mod;
265
266   /* We do not support module loading in fips mode.  */
267   if (fips_mode ())
268     return gpg_error (GPG_ERR_NOT_SUPPORTED);
269
270   ath_mutex_lock (&pubkeys_registered_lock);
271   err = _gcry_module_add (&pubkeys_registered, 0,
272                           (void *) pubkey, 
273                           (void *)(extraspec? extraspec : &dummy_extra_spec), 
274                           &mod);
275   ath_mutex_unlock (&pubkeys_registered_lock);
276
277   if (! err)
278     {
279       *module = mod;
280       *algorithm_id = mod->mod_id;
281     }
282
283   return err;
284 }
285
286 /* Unregister the pubkey identified by ID, which must have been
287    registered with gcry_pk_register.  */
288 void
289 gcry_pk_unregister (gcry_module_t module)
290 {
291   ath_mutex_lock (&pubkeys_registered_lock);
292   _gcry_module_release (module);
293   ath_mutex_unlock (&pubkeys_registered_lock);
294 }
295
296 static void
297 release_mpi_array (gcry_mpi_t *array)
298 {
299   for (; *array; array++)
300     {
301       mpi_free(*array);
302       *array = NULL;
303     }
304 }
305
306 /****************
307  * Map a string to the pubkey algo
308  */
309 int
310 gcry_pk_map_name (const char *string)
311 {
312   gcry_module_t pubkey;
313   int algorithm = 0;
314
315   if (!string)
316     return 0;
317
318   REGISTER_DEFAULT_PUBKEYS;
319
320   ath_mutex_lock (&pubkeys_registered_lock);
321   pubkey = gcry_pk_lookup_name (string);
322   if (pubkey)
323     {
324       algorithm = pubkey->mod_id;
325       _gcry_module_release (pubkey);
326     }
327   ath_mutex_unlock (&pubkeys_registered_lock);
328
329   return algorithm;
330 }
331
332
333 /* Map the public key algorithm whose ID is contained in ALGORITHM to
334    a string representation of the algorithm name.  For unknown
335    algorithm IDs this functions returns "?". */
336 const char *
337 gcry_pk_algo_name (int algorithm)
338 {
339   gcry_module_t pubkey;
340   const char *name;
341
342   REGISTER_DEFAULT_PUBKEYS;
343
344   ath_mutex_lock (&pubkeys_registered_lock);
345   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
346   if (pubkey)
347     {
348       name = ((gcry_pk_spec_t *) pubkey->spec)->name;
349       _gcry_module_release (pubkey);
350     }
351   else
352     name = "?";
353   ath_mutex_unlock (&pubkeys_registered_lock);
354
355   return name;
356 }
357
358
359 /* A special version of gcry_pk_algo name to return the first aliased
360    name of the algorithm.  This is required to adhere to the spki
361    specs where the algorithm names are lowercase. */
362 const char *
363 _gcry_pk_aliased_algo_name (int algorithm)
364 {
365   const char *name = NULL;
366   gcry_module_t module;
367
368   REGISTER_DEFAULT_PUBKEYS;
369
370   ath_mutex_lock (&pubkeys_registered_lock);
371   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
372   if (module)
373     {
374       gcry_pk_spec_t *pubkey = (gcry_pk_spec_t *) module->spec;
375
376       name = pubkey->aliases? *pubkey->aliases : NULL;
377       if (!name || !*name)
378         name = pubkey->name;
379       _gcry_module_release (module);
380     }
381   ath_mutex_unlock (&pubkeys_registered_lock);
382
383   return name;
384 }
385
386
387 static void
388 disable_pubkey_algo (int algorithm)
389 {
390   gcry_module_t pubkey;
391
392   ath_mutex_lock (&pubkeys_registered_lock);
393   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
394   if (pubkey)
395     {
396       if (! (pubkey-> flags & FLAG_MODULE_DISABLED))
397         pubkey->flags |= FLAG_MODULE_DISABLED;
398       _gcry_module_release (pubkey);
399     }
400   ath_mutex_unlock (&pubkeys_registered_lock);
401 }
402
403
404 /****************
405  * A USE of 0 means: don't care.
406  */
407 static gcry_err_code_t
408 check_pubkey_algo (int algorithm, unsigned use)
409 {
410   gcry_err_code_t err = GPG_ERR_NO_ERROR;
411   gcry_pk_spec_t *pubkey;
412   gcry_module_t module;
413
414   REGISTER_DEFAULT_PUBKEYS;
415
416   ath_mutex_lock (&pubkeys_registered_lock);
417   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
418   if (module)
419     {
420       pubkey = (gcry_pk_spec_t *) module->spec;
421
422       if (((use & GCRY_PK_USAGE_SIGN)
423            && (! (pubkey->use & GCRY_PK_USAGE_SIGN)))
424           || ((use & GCRY_PK_USAGE_ENCR)
425               && (! (pubkey->use & GCRY_PK_USAGE_ENCR))))
426         err = GPG_ERR_WRONG_PUBKEY_ALGO;
427       else if (module->flags & FLAG_MODULE_DISABLED)
428         err = GPG_ERR_PUBKEY_ALGO;
429       _gcry_module_release (module);
430     }
431   else
432     err = GPG_ERR_PUBKEY_ALGO;
433   ath_mutex_unlock (&pubkeys_registered_lock);
434
435   return err;
436 }
437
438
439 /****************
440  * Return the number of public key material numbers
441  */
442 static int
443 pubkey_get_npkey (int algorithm)
444 {
445   gcry_module_t pubkey;
446   int npkey = 0;
447
448   REGISTER_DEFAULT_PUBKEYS;
449
450   ath_mutex_lock (&pubkeys_registered_lock);
451   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
452   if (pubkey)
453     {
454       npkey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_pkey);
455       _gcry_module_release (pubkey);
456     }
457   ath_mutex_unlock (&pubkeys_registered_lock);
458
459   return npkey;
460 }
461
462 /****************
463  * Return the number of secret key material numbers
464  */
465 static int
466 pubkey_get_nskey (int algorithm)
467 {
468   gcry_module_t pubkey;
469   int nskey = 0;
470
471   REGISTER_DEFAULT_PUBKEYS;
472
473   ath_mutex_lock (&pubkeys_registered_lock);
474   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
475   if (pubkey)
476     {
477       nskey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_skey);
478       _gcry_module_release (pubkey);
479     }
480   ath_mutex_unlock (&pubkeys_registered_lock);
481
482   return nskey;
483 }
484
485 /****************
486  * Return the number of signature material numbers
487  */
488 static int
489 pubkey_get_nsig (int algorithm)
490 {
491   gcry_module_t pubkey;
492   int nsig = 0;
493
494   REGISTER_DEFAULT_PUBKEYS;
495
496   ath_mutex_lock (&pubkeys_registered_lock);
497   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
498   if (pubkey)
499     {
500       nsig = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_sig);
501       _gcry_module_release (pubkey);
502     }
503   ath_mutex_unlock (&pubkeys_registered_lock);
504
505   return nsig;
506 }
507
508 /****************
509  * Return the number of encryption material numbers
510  */
511 static int
512 pubkey_get_nenc (int algorithm)
513 {
514   gcry_module_t pubkey;
515   int nenc = 0;
516
517   REGISTER_DEFAULT_PUBKEYS;
518
519   ath_mutex_lock (&pubkeys_registered_lock);
520   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
521   if (pubkey)
522     {
523       nenc = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_enc);
524       _gcry_module_release (pubkey);
525     }
526   ath_mutex_unlock (&pubkeys_registered_lock);
527
528   return nenc;
529 }
530
531
532 /* Generate a new public key with algorithm ALGORITHM of size NBITS
533    and return it at SKEY. The use of the arguments QBITS, USE_E,
534    XVALUE and CURVE+_NAME depend onthe ALGORITHM.  RETFACTOR is used
535    by some algorithms to return certain additional information which
536    are in general not required.  
537
538    The function returns ther error code number or 0 on success. */
539 static gcry_err_code_t
540 pubkey_generate (int algorithm, unsigned int nbits, unsigned int qbits,
541                  unsigned long use_e, gcry_mpi_t xvalue,
542                  const char *curve_name,
543                  gcry_mpi_t *skey, gcry_mpi_t **retfactors)
544 {
545   gcry_err_code_t err = GPG_ERR_PUBKEY_ALGO;
546   gcry_module_t pubkey;
547
548   REGISTER_DEFAULT_PUBKEYS;
549
550   ath_mutex_lock (&pubkeys_registered_lock);
551   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
552   if (pubkey)
553     {
554       /* Hack to pass QBITS to the DSA generation.  */
555       if (qbits && pubkey->spec == &_gcry_pubkey_spec_dsa)
556         {
557           err = _gcry_dsa_generate2
558             (algorithm, nbits, qbits, 0, skey, retfactors);
559         }
560 #ifdef USE_ELGAMAL
561       else if (xvalue && pubkey->spec == &_gcry_pubkey_spec_elg)
562         {
563           err = _gcry_elg_generate_using_x
564             (algorithm, nbits, xvalue, skey, retfactors);
565         }
566 #endif /*USE_ELGAMAL*/
567 #ifdef USE_ECC
568       else if (curve_name && pubkey->spec == &_gcry_pubkey_spec_ecdsa)
569         {
570           err = _gcry_ecc_generate
571             (algorithm, nbits, curve_name, skey, retfactors);
572         }
573 #endif /*USE_ECC*/
574       else
575         {
576           err = ((gcry_pk_spec_t *) pubkey->spec)->generate 
577             (algorithm, nbits, use_e, skey, retfactors);
578         }
579       _gcry_module_release (pubkey);
580     }
581   ath_mutex_unlock (&pubkeys_registered_lock);
582
583   return err;
584 }
585
586 static gcry_err_code_t
587 pubkey_check_secret_key (int algorithm, gcry_mpi_t *skey)
588 {
589   gcry_err_code_t err = GPG_ERR_PUBKEY_ALGO;
590   gcry_module_t pubkey;
591
592   REGISTER_DEFAULT_PUBKEYS;
593
594   ath_mutex_lock (&pubkeys_registered_lock);
595   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
596   if (pubkey)
597     {
598       err = ((gcry_pk_spec_t *) pubkey->spec)->check_secret_key
599         (algorithm, skey);
600       _gcry_module_release (pubkey);
601     }
602   ath_mutex_unlock (&pubkeys_registered_lock);
603
604   return err;
605 }
606
607
608 /****************
609  * This is the interface to the public key encryption.  Encrypt DATA
610  * with PKEY and put it into RESARR which should be an array of MPIs
611  * of size PUBKEY_MAX_NENC (or less if the algorithm allows this -
612  * check with pubkey_get_nenc() )
613  */
614 static gcry_err_code_t
615 pubkey_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
616                 gcry_mpi_t *pkey, int flags)
617 {
618   gcry_pk_spec_t *pubkey;
619   gcry_module_t module;
620   gcry_err_code_t rc;
621   int i;
622
623   /* Note: In fips mode DBG_CIPHER will enver evaluate to true but as
624      an extra failsafe protection we explicitly test for fips mode
625      here. */ 
626   if (DBG_CIPHER && !fips_mode ())
627     {
628       log_debug ("pubkey_encrypt: algo=%d\n", algorithm);
629       for(i = 0; i < pubkey_get_npkey (algorithm); i++)
630         log_mpidump ("  pkey:", pkey[i]);
631       log_mpidump ("  data:", data);
632     }
633
634   ath_mutex_lock (&pubkeys_registered_lock);
635   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
636   if (module)
637     {
638       pubkey = (gcry_pk_spec_t *) module->spec;
639       rc = pubkey->encrypt (algorithm, resarr, data, pkey, flags);
640       _gcry_module_release (module);
641       goto ready;
642     }
643   rc = GPG_ERR_PUBKEY_ALGO;
644
645  ready:
646   ath_mutex_unlock (&pubkeys_registered_lock);
647
648   if (!rc && DBG_CIPHER && !fips_mode ())
649     {
650       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
651         log_mpidump("  encr:", resarr[i] );
652     }
653   return rc;
654 }
655
656
657 /****************
658  * This is the interface to the public key decryption.
659  * ALGO gives the algorithm to use and this implicitly determines
660  * the size of the arrays.
661  * result is a pointer to a mpi variable which will receive a
662  * newly allocated mpi or NULL in case of an error.
663  */
664 static gcry_err_code_t
665 pubkey_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data,
666                 gcry_mpi_t *skey, int flags)
667 {
668   gcry_pk_spec_t *pubkey;
669   gcry_module_t module;
670   gcry_err_code_t rc;
671   int i;
672
673   *result = NULL; /* so the caller can always do a mpi_free */
674   if (DBG_CIPHER && !fips_mode ())
675     {
676       log_debug ("pubkey_decrypt: algo=%d\n", algorithm);
677       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
678         log_mpidump ("  skey:", skey[i]);
679       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
680         log_mpidump ("  data:", data[i]);
681     }
682
683   ath_mutex_lock (&pubkeys_registered_lock);
684   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
685   if (module)
686     {
687       pubkey = (gcry_pk_spec_t *) module->spec;
688       rc = pubkey->decrypt (algorithm, result, data, skey, flags);
689       _gcry_module_release (module);
690       goto ready;
691     }
692
693   rc = GPG_ERR_PUBKEY_ALGO;
694   
695  ready:
696   ath_mutex_unlock (&pubkeys_registered_lock);
697
698   if (!rc && DBG_CIPHER && !fips_mode ())
699     log_mpidump (" plain:", *result);
700
701   return rc;
702 }
703
704
705 /****************
706  * This is the interface to the public key signing.
707  * Sign data with skey and put the result into resarr which
708  * should be an array of MPIs of size PUBKEY_MAX_NSIG (or less if the
709  * algorithm allows this - check with pubkey_get_nsig() )
710  */
711 static gcry_err_code_t
712 pubkey_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
713              gcry_mpi_t *skey)
714 {
715   gcry_pk_spec_t *pubkey;
716   gcry_module_t module;
717   gcry_err_code_t rc;
718   int i;
719
720   if (DBG_CIPHER && !fips_mode ())
721     {
722       log_debug ("pubkey_sign: algo=%d\n", algorithm);
723       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
724         log_mpidump ("  skey:", skey[i]);
725       log_mpidump("  data:", data );
726     }
727
728   ath_mutex_lock (&pubkeys_registered_lock);
729   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
730   if (module)
731     {
732       pubkey = (gcry_pk_spec_t *) module->spec;
733       rc = pubkey->sign (algorithm, resarr, data, skey);
734       _gcry_module_release (module);
735       goto ready;
736     }
737
738   rc = GPG_ERR_PUBKEY_ALGO;
739
740  ready:
741   ath_mutex_unlock (&pubkeys_registered_lock);
742
743   if (!rc && DBG_CIPHER && !fips_mode ())
744     for (i = 0; i < pubkey_get_nsig (algorithm); i++)
745       log_mpidump ("   sig:", resarr[i]);
746
747   return rc;
748 }
749
750 /****************
751  * Verify a public key signature.
752  * Return 0 if the signature is good
753  */
754 static gcry_err_code_t
755 pubkey_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data,
756                gcry_mpi_t *pkey,
757                int (*cmp)(void *, gcry_mpi_t), void *opaquev)
758 {
759   gcry_pk_spec_t *pubkey;
760   gcry_module_t module;
761   gcry_err_code_t rc;
762   int i;
763
764   if (DBG_CIPHER && !fips_mode ())
765     {
766       log_debug ("pubkey_verify: algo=%d\n", algorithm);
767       for (i = 0; i < pubkey_get_npkey (algorithm); i++)
768         log_mpidump ("  pkey:", pkey[i]);
769       for (i = 0; i < pubkey_get_nsig (algorithm); i++)
770         log_mpidump ("   sig:", data[i]);
771       log_mpidump ("  hash:", hash);
772     }
773
774   ath_mutex_lock (&pubkeys_registered_lock);
775   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
776   if (module)
777     {
778       pubkey = (gcry_pk_spec_t *) module->spec;
779       rc = pubkey->verify (algorithm, hash, data, pkey, cmp, opaquev);
780       _gcry_module_release (module);
781       goto ready;
782     }
783
784   rc = GPG_ERR_PUBKEY_ALGO;
785
786  ready:
787   ath_mutex_unlock (&pubkeys_registered_lock);
788   return rc;
789 }
790
791
792 /* Internal function.   */
793 static gcry_err_code_t
794 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
795                        gcry_mpi_t *elements, const char *algo_name)
796 {
797   gcry_err_code_t err = 0;
798   int i, idx;
799   const char *name;
800   gcry_sexp_t list;
801
802   for (name = element_names, idx = 0; *name && !err; name++, idx++)
803     {
804       list = gcry_sexp_find_token (key_sexp, name, 1);
805       if (!list)
806         elements[idx] = NULL;
807       else
808         {
809           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
810           gcry_sexp_release (list);
811           if (!elements[idx])
812             err = GPG_ERR_INV_OBJ;
813         }
814     }
815
816   if (!err)
817     {
818       /* Check that all elements are available.  */
819       for (name = element_names, idx = 0; *name; name++, idx++)
820         if (!elements[idx])
821           break;
822       if (*name)
823         {
824           err = GPG_ERR_NO_OBJ;
825           /* Some are missing.  Before bailing out we test for
826              optional parameters.  */
827           if (algo_name && !strcmp (algo_name, "RSA")
828               && !strcmp (element_names, "nedpqu") )
829             {
830               /* This is RSA.  Test whether we got N, E and D and that
831                  the optional P, Q and U are all missing.  */
832               if (elements[0] && elements[1] && elements[2]
833                   && !elements[3] && !elements[4] && !elements[5])
834                 err = 0;
835             }
836         }
837     }
838
839
840   if (err)
841     {
842       for (i = 0; i < idx; i++)
843         if (elements[i])
844           gcry_free (elements[i]);
845     }
846   return err;
847 }
848
849 /* Internal function used for ecc.  Note, that this function makes use
850    of its intimate knowledge about the ECC parameters from ecc.c. */
851 static gcry_err_code_t
852 sexp_elements_extract_ecc (gcry_sexp_t key_sexp, const char *element_names,
853                            gcry_mpi_t *elements)
854 {
855   gcry_err_code_t err = 0;
856   int idx;
857   const char *name;
858   gcry_sexp_t list;
859
860   /* Clear the array for easir error cleanup. */
861   for (name = element_names, idx = 0; *name; name++, idx++)
862     elements[idx] = NULL;
863   assert (idx >= 6); /* We know that ECC has at least 6 elements.  */
864
865   /* Init the array with the available curve parameters. */
866   for (name = element_names, idx = 0; *name && !err; name++, idx++)
867     {
868       list = gcry_sexp_find_token (key_sexp, name, 1);
869       if (!list)
870         elements[idx] = NULL;
871       else
872         {
873           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
874           gcry_sexp_release (list);
875           if (!elements[idx])
876             {
877               err = GPG_ERR_INV_OBJ;
878               goto leave;
879             }
880         }
881     }
882
883   /* Check whether a curve parameter has been given and then fill any
884      missing elements.  */
885   list = gcry_sexp_find_token (key_sexp, "curve", 5);
886   if (list)
887     {
888 #if USE_ECC
889       char *curve;
890       gcry_mpi_t params[6];
891
892       for (idx = 0; idx < DIM(params); idx++)
893         params[idx] = NULL;
894
895       curve = _gcry_sexp_nth_string (list, 1);
896       if (!curve)
897         {
898           err = GPG_ERR_INV_OBJ; /* No curve name given (or out of core). */
899           goto leave;
900         }
901       err = _gcry_ecc_get_param (curve, params);
902       gcry_free (curve);
903       if (err)
904         goto leave;
905
906       for (idx = 0; idx < DIM(params); idx++)
907         {
908           if (!elements[idx])
909             elements[idx] = params[idx];
910           else
911             mpi_free (params[idx]);
912         }
913 #else /* !USE_ECC */
914       err = GPG_ERR_INV_OBJ; /* "curve" given but ECC not supported. */
915       goto leave;
916 #endif /* !USE_ECC */
917     }
918
919   /* Check that all parameters are known.  */
920   for (name = element_names, idx = 0; *name; name++, idx++)
921     if (!elements[idx])
922       {
923         err = GPG_ERR_NO_OBJ;
924         goto leave;
925       }
926   
927  leave:
928   if (err)
929     {
930       for (name = element_names, idx = 0; *name; name++, idx++)
931         if (elements[idx])
932           gcry_free (elements[idx]);
933     }
934   return err;
935 }
936
937
938
939 /****************
940  * Convert a S-Exp with either a private or a public key to our
941  * internal format. Currently we do only support the following
942  * algorithms:
943  *    dsa
944  *    rsa
945  *    openpgp-dsa
946  *    openpgp-rsa
947  *    openpgp-elg
948  *    openpgp-elg-sig
949  *    ecdsa
950  * Provide a SE with the first element be either "private-key" or
951  * or "public-key". It is followed by a list with its first element
952  * be one of the above algorithm identifiers and the remaning
953  * elements are pairs with parameter-id and value.
954  * NOTE: we look through the list to find a list beginning with
955  * "private-key" or "public-key" - the first one found is used.
956  *
957  * Returns: A pointer to an allocated array of MPIs if the return value is
958  *          zero; the caller has to release this array.
959  *
960  * Example of a DSA public key:
961  *  (private-key
962  *    (dsa
963  *      (p <mpi>)
964  *      (g <mpi>)
965  *      (y <mpi>)
966  *      (x <mpi>)
967  *    )
968  *  )
969  * The <mpi> are expected to be in GCRYMPI_FMT_USG
970  */
971 static gcry_err_code_t
972 sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
973              gcry_module_t *retalgo)
974 {
975   gcry_err_code_t err = 0;
976   gcry_sexp_t list, l2;
977   char *name;
978   const char *elems;
979   gcry_mpi_t *array;
980   gcry_module_t module;
981   gcry_pk_spec_t *pubkey;
982   int is_ecc;
983
984   /* Check that the first element is valid.  */
985   list = gcry_sexp_find_token (sexp, 
986                                want_private? "private-key":"public-key", 0);
987   if (!list)
988     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
989
990   l2 = gcry_sexp_cadr( list );
991   gcry_sexp_release ( list );
992   list = l2;
993   name = _gcry_sexp_nth_string (list, 0);
994   if (!name)
995     {
996       gcry_sexp_release ( list );
997       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
998     }
999
1000   ath_mutex_lock (&pubkeys_registered_lock);
1001   module = gcry_pk_lookup_name (name);
1002   ath_mutex_unlock (&pubkeys_registered_lock);
1003   
1004   /* Fixme: We should make sure that an ECC key is always named "ecc"
1005      and not "ecdsa".  "ecdsa" should be used for the signature
1006      itself.  We need a function to test whether an algorithm given
1007      with a key is compatible with an application of the key (signing,
1008      encryption).  For RSA this is easy, but ECC is the first
1009      algorithm which has many flavours. */
1010   is_ecc = ( !strcmp (name, "ecdsa") || !strcmp (name, "ecc") );
1011   gcry_free (name);
1012   
1013   if (!module)
1014     {
1015       gcry_sexp_release (list);
1016       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
1017     }
1018   else
1019     pubkey = (gcry_pk_spec_t *) module->spec;
1020
1021   elems = want_private ? pubkey->elements_skey : pubkey->elements_pkey;
1022   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
1023   if (!array)
1024     err = gpg_err_code_from_errno (errno);
1025   if (!err)
1026     {
1027       if (is_ecc)
1028         err = sexp_elements_extract_ecc (list, elems, array);
1029       else
1030         err = sexp_elements_extract (list, elems, array, pubkey->name);
1031     }
1032   
1033   gcry_sexp_release (list);
1034   
1035   if (err)
1036     {
1037       gcry_free (array);
1038
1039       ath_mutex_lock (&pubkeys_registered_lock);
1040       _gcry_module_release (module);
1041       ath_mutex_unlock (&pubkeys_registered_lock);
1042     }
1043   else
1044     {
1045       *retarray = array;
1046       *retalgo = module;
1047     }
1048   
1049   return err;
1050 }
1051
1052
1053 static gcry_err_code_t
1054 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
1055              gcry_module_t *retalgo)
1056 {
1057   gcry_err_code_t err = 0;
1058   gcry_sexp_t list, l2;
1059   char *name;
1060   const char *elems;
1061   gcry_mpi_t *array;
1062   gcry_module_t module;
1063   gcry_pk_spec_t *pubkey;
1064   
1065   /* Check that the first element is valid.  */
1066   list = gcry_sexp_find_token( sexp, "sig-val" , 0 );
1067   if (!list)
1068     return GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
1069
1070   l2 = gcry_sexp_nth (list, 1);
1071   if (!l2)
1072     {
1073       gcry_sexp_release (list);
1074       return GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
1075     }
1076   name = _gcry_sexp_nth_string (l2, 0);
1077   if (!name)
1078     {
1079       gcry_sexp_release (list);
1080       gcry_sexp_release (l2);
1081       return GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
1082     }
1083   else if (!strcmp (name, "flags")) 
1084     {
1085       /* Skip flags, since they are not used but here just for the
1086          sake of consistent S-expressions.  */
1087       gcry_free (name);
1088       gcry_sexp_release (l2);
1089       l2 = gcry_sexp_nth (list, 2);
1090       if (!l2)
1091         {
1092           gcry_sexp_release (list);
1093           return GPG_ERR_INV_OBJ;
1094         }
1095       name = _gcry_sexp_nth_string (l2, 0);
1096     }
1097       
1098   ath_mutex_lock (&pubkeys_registered_lock);
1099   module = gcry_pk_lookup_name (name);
1100   ath_mutex_unlock (&pubkeys_registered_lock);
1101   gcry_free (name);
1102   name = NULL;
1103
1104   if (!module)
1105     {
1106       gcry_sexp_release (l2);
1107       gcry_sexp_release (list);
1108       return GPG_ERR_PUBKEY_ALGO;  /* Unknown algorithm. */
1109     }
1110   else
1111     pubkey = (gcry_pk_spec_t *) module->spec;
1112
1113   elems = pubkey->elements_sig;
1114   array = gcry_calloc (strlen (elems) + 1 , sizeof *array );
1115   if (!array)
1116     err = gpg_err_code_from_errno (errno);
1117
1118   if (!err)
1119     err = sexp_elements_extract (list, elems, array, NULL);
1120
1121   gcry_sexp_release (l2);
1122   gcry_sexp_release (list);
1123
1124   if (err)
1125     {
1126       ath_mutex_lock (&pubkeys_registered_lock);
1127       _gcry_module_release (module);
1128       ath_mutex_unlock (&pubkeys_registered_lock);
1129       
1130       gcry_free (array);
1131     }
1132   else
1133     {
1134       *retarray = array;
1135       *retalgo = module;
1136     }
1137   
1138   return err;
1139 }
1140
1141
1142 /****************
1143  * Take sexp and return an array of MPI as used for our internal decrypt
1144  * function.
1145  * s_data = (enc-val
1146  *           [(flags [pkcs1])]
1147  *            (<algo>
1148  *              (<param_name1> <mpi>)
1149  *              ...
1150  *              (<param_namen> <mpi>)
1151  *            ))
1152  * RET_MODERN is set to true when at least an empty flags list has been found.
1153  */
1154 static gcry_err_code_t
1155 sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
1156              int *ret_modern, int *ret_want_pkcs1, int *flags)
1157 {
1158   gcry_err_code_t err = 0;
1159   gcry_sexp_t list = NULL, l2 = NULL;
1160   gcry_pk_spec_t *pubkey = NULL;
1161   gcry_module_t module = NULL;
1162   char *name = NULL;
1163   size_t n;
1164   int parsed_flags = 0;
1165   const char *elems;
1166   gcry_mpi_t *array = NULL;
1167
1168   *ret_want_pkcs1 = 0;
1169   *ret_modern = 0;
1170
1171   /* Check that the first element is valid.  */
1172   list = gcry_sexp_find_token (sexp, "enc-val" , 0);
1173   if (!list)
1174     {
1175       err = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
1176       goto leave;
1177     }
1178
1179   l2 = gcry_sexp_nth (list, 1);
1180   if (!l2)
1181     {
1182       err = GPG_ERR_NO_OBJ; /* No cdr for the data object.  */
1183       goto leave;
1184     }
1185
1186   /* Extract identifier of sublist.  */
1187   name = _gcry_sexp_nth_string (l2, 0);
1188   if (!name)
1189     {
1190       err = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
1191       goto leave;
1192     }
1193   
1194   if (!strcmp (name, "flags"))
1195     {
1196       /* There is a flags element - process it.  */
1197       const char *s;
1198       int i;
1199       
1200       *ret_modern = 1;
1201       for (i = gcry_sexp_length (l2) - 1; i > 0; i--)
1202         {
1203           s = gcry_sexp_nth_data (l2, i, &n);
1204           if (! s)
1205             ; /* Not a data element - ignore.  */
1206           else if (n == 3 && !memcmp (s, "raw", 3))
1207             ; /* This is just a dummy as it is the default.  */
1208           else if (n == 5 && !memcmp (s, "pkcs1", 5))
1209             *ret_want_pkcs1 = 1;
1210           else if (n == 11 && ! memcmp (s, "no-blinding", 11))
1211             parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
1212           else
1213             {
1214               err = GPG_ERR_INV_FLAG;
1215               goto leave;
1216             }
1217         }
1218       
1219       /* Get the next which has the actual data. */
1220       gcry_sexp_release (l2);
1221       l2 = gcry_sexp_nth (list, 2);
1222       if (!l2)
1223         {
1224           err = GPG_ERR_NO_OBJ; /* No cdr for the data object. */
1225           goto leave;
1226         }
1227
1228       /* Extract sublist identifier.  */
1229       gcry_free (name);
1230       name = _gcry_sexp_nth_string (l2, 0);
1231       if (!name)
1232         {
1233           err = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
1234           goto leave;
1235         }
1236
1237       gcry_sexp_release (list);
1238       list = l2;
1239       l2 = NULL;
1240     }
1241
1242   ath_mutex_lock (&pubkeys_registered_lock);
1243   module = gcry_pk_lookup_name (name);
1244   ath_mutex_unlock (&pubkeys_registered_lock);
1245   
1246   if (!module)
1247     {
1248       err = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
1249       goto leave;
1250     }
1251   pubkey = (gcry_pk_spec_t *) module->spec;
1252
1253   elems = pubkey->elements_enc;
1254   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
1255   if (!array)
1256     {
1257       err = gpg_err_code_from_errno (errno);
1258       goto leave;
1259     }
1260
1261   err = sexp_elements_extract (list, elems, array, NULL);
1262
1263  leave:
1264   gcry_sexp_release (list);
1265   gcry_sexp_release (l2);
1266   gcry_free (name);
1267
1268   if (err)
1269     {
1270       ath_mutex_lock (&pubkeys_registered_lock);
1271       _gcry_module_release (module);
1272       ath_mutex_unlock (&pubkeys_registered_lock);
1273       gcry_free (array);
1274     }
1275   else
1276     {
1277       *retarray = array;
1278       *retalgo = module;
1279       *flags = parsed_flags;
1280     }
1281
1282   return err;
1283 }
1284
1285 /* Take the hash value and convert into an MPI, suitable for
1286    passing to the low level functions.  We currently support the
1287    old style way of passing just a MPI and the modern interface which
1288    allows to pass flags so that we can choose between raw and pkcs1
1289    padding - may be more padding options later. 
1290
1291    (<mpi>)
1292    or
1293    (data
1294     [(flags [pkcs1])]
1295     [(hash <algo> <value>)]
1296     [(value <text>)]
1297    )
1298    
1299    Either the VALUE or the HASH element must be present for use
1300    with signatures.  VALUE is used for encryption.
1301
1302    NBITS is the length of the key in bits. 
1303
1304 */
1305 static gcry_err_code_t
1306 sexp_data_to_mpi (gcry_sexp_t input, unsigned int nbits, gcry_mpi_t *ret_mpi,
1307                   int for_encryption, int *flags)
1308 {
1309   gcry_err_code_t rc = 0;
1310   gcry_sexp_t ldata, lhash, lvalue;
1311   int i;
1312   size_t n;
1313   const char *s;
1314   int is_raw = 0, is_pkcs1 = 0, unknown_flag=0; 
1315   int parsed_flags = 0, dummy_flags;
1316
1317   if (! flags)
1318     flags = &dummy_flags;
1319   
1320   *ret_mpi = NULL;
1321   ldata = gcry_sexp_find_token (input, "data", 0);
1322   if (!ldata)
1323     { /* assume old style */
1324       *ret_mpi = gcry_sexp_nth_mpi (input, 0, 0);
1325       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
1326     }
1327
1328   /* see whether there is a flags object */
1329   {
1330     gcry_sexp_t lflags = gcry_sexp_find_token (ldata, "flags", 0);
1331     if (lflags)
1332       { /* parse the flags list. */
1333         for (i=gcry_sexp_length (lflags)-1; i > 0; i--)
1334           {
1335             s = gcry_sexp_nth_data (lflags, i, &n);
1336             if (!s)
1337               ; /* not a data element*/
1338             else if ( n == 3 && !memcmp (s, "raw", 3))
1339               is_raw = 1;
1340             else if ( n == 5 && !memcmp (s, "pkcs1", 5))
1341               is_pkcs1 = 1;
1342             else if (n == 11 && ! memcmp (s, "no-blinding", 11))
1343               parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
1344             else
1345               unknown_flag = 1;
1346           }
1347         gcry_sexp_release (lflags);
1348       }
1349   }
1350
1351   if (!is_pkcs1 && !is_raw)
1352     is_raw = 1; /* default to raw */
1353
1354   /* Get HASH or MPI */
1355   lhash = gcry_sexp_find_token (ldata, "hash", 0);
1356   lvalue = lhash? NULL : gcry_sexp_find_token (ldata, "value", 0);
1357
1358   if (!(!lhash ^ !lvalue))
1359     rc = GPG_ERR_INV_OBJ; /* none or both given */
1360   else if (unknown_flag)
1361     rc = GPG_ERR_INV_FLAG;
1362   else if (is_raw && is_pkcs1 && !for_encryption)
1363     rc = GPG_ERR_CONFLICT;
1364   else if (is_raw && lvalue)
1365     {
1366       *ret_mpi = gcry_sexp_nth_mpi (lvalue, 1, 0);
1367       if (!*ret_mpi)
1368         rc = GPG_ERR_INV_OBJ;
1369     }
1370   else if (is_pkcs1 && lvalue && for_encryption)
1371     { 
1372       /* Create pkcs#1 block type 2 padding. */
1373       unsigned char *frame = NULL;
1374       size_t nframe = (nbits+7) / 8;
1375       const void * value;
1376       size_t valuelen;
1377       unsigned char *p;
1378
1379       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
1380         rc = GPG_ERR_INV_OBJ;
1381       else if (valuelen + 7 > nframe || !nframe)
1382         {
1383           /* Can't encode a VALUELEN value in a NFRAME bytes frame. */
1384           rc = GPG_ERR_TOO_SHORT; /* the key is too short */
1385         }
1386       else if ( !(frame = gcry_malloc_secure (nframe)))
1387         rc = gpg_err_code_from_errno (errno);
1388       else
1389         {
1390           n = 0;
1391           frame[n++] = 0;
1392           frame[n++] = 2; /* block type */
1393           i = nframe - 3 - valuelen;
1394           assert (i > 0);
1395           p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
1396           /* Replace zero bytes by new values. */
1397           for (;;)
1398             {
1399               int j, k;
1400               unsigned char *pp;
1401               
1402               /* Count the zero bytes. */
1403               for (j=k=0; j < i; j++)
1404                 {
1405                   if (!p[j])
1406                     k++;
1407                 }
1408               if (!k)
1409                 break; /* Okay: no (more) zero bytes. */
1410               
1411               k += k/128 + 3; /* Better get some more. */
1412               pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
1413               for (j=0; j < i && k; )
1414                 {
1415                   if (!p[j])
1416                     p[j] = pp[--k];
1417                   if (p[j])
1418                     j++;
1419                 }
1420               gcry_free (pp);
1421             }
1422           memcpy (frame+n, p, i);
1423           n += i;
1424           gcry_free (p);
1425           
1426           frame[n++] = 0;
1427           memcpy (frame+n, value, valuelen);
1428           n += valuelen;
1429           assert (n == nframe);
1430
1431           /* FIXME, error checking?  */
1432           gcry_mpi_scan (ret_mpi, GCRYMPI_FMT_USG, frame, n, &nframe);
1433         }
1434
1435       gcry_free(frame);
1436     }
1437   else if (is_pkcs1 && lhash && !for_encryption)
1438     { 
1439       /* Create pkcs#1 block type 1 padding. */
1440       if (gcry_sexp_length (lhash) != 3)
1441         rc = GPG_ERR_INV_OBJ;
1442       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
1443         rc = GPG_ERR_INV_OBJ;
1444       else
1445         {
1446           static struct { const char *name; int algo; } hashnames[] = 
1447           { { "sha1",   GCRY_MD_SHA1 },
1448             { "md5",    GCRY_MD_MD5 },
1449             { "sha256", GCRY_MD_SHA256 },
1450             { "ripemd160", GCRY_MD_RMD160 },
1451             { "rmd160", GCRY_MD_RMD160 },
1452             { "sha384", GCRY_MD_SHA384 },
1453             { "sha512", GCRY_MD_SHA512 },
1454             { "sha224", GCRY_MD_SHA224 },
1455             { "md2",    GCRY_MD_MD2 },
1456             { "md4",    GCRY_MD_MD4 },
1457             { "tiger",  GCRY_MD_TIGER },
1458             { "haval",  GCRY_MD_HAVAL },
1459             { NULL, 0 }
1460           };
1461           int algo;
1462           byte asn[100];
1463           byte *frame = NULL;
1464           size_t nframe = (nbits+7) / 8;
1465           const void * value;
1466           size_t valuelen;
1467           size_t asnlen, dlen;
1468             
1469           for (i=0; hashnames[i].name; i++)
1470             {
1471               if ( strlen (hashnames[i].name) == n
1472                    && !memcmp (hashnames[i].name, s, n))
1473                 break;
1474             }
1475           if (hashnames[i].name)
1476             algo = hashnames[i].algo;
1477           else
1478             {
1479               /* In case of not listed or dynamically allocated hash
1480                  algorithm we fall back to this somewhat slower
1481                  method.  Further, it also allows to use OIDs as
1482                  algorithm names. */
1483               char *tmpname;
1484
1485               tmpname = gcry_malloc (n+1);
1486               if (!tmpname)
1487                 algo = 0;  /* Out of core - silently give up.  */
1488               else
1489                 {
1490                   memcpy (tmpname, s, n);
1491                   tmpname[n] = 0;
1492                   algo = gcry_md_map_name (tmpname);
1493                   gcry_free (tmpname);
1494                 }
1495             }
1496
1497           asnlen = DIM(asn);
1498           dlen = gcry_md_get_algo_dlen (algo);
1499
1500           if (!algo)
1501             rc = GPG_ERR_DIGEST_ALGO;
1502           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
1503                     || !valuelen )
1504             rc = GPG_ERR_INV_OBJ;
1505           else if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
1506             {
1507               /* We don't have yet all of the above algorithms.  */
1508               rc = GPG_ERR_NOT_IMPLEMENTED;
1509             }
1510           else if ( valuelen != dlen )
1511             {
1512               /* Hash value does not match the length of digest for
1513                  the given algorithm. */
1514               rc = GPG_ERR_CONFLICT;
1515             }
1516           else if( !dlen || dlen + asnlen + 4 > nframe)
1517             {
1518               /* Can't encode an DLEN byte digest MD into a NFRAME
1519                  byte frame. */
1520               rc = GPG_ERR_TOO_SHORT;
1521             }
1522           else if ( !(frame = gcry_malloc (nframe)) )
1523             rc = gpg_err_code_from_errno (errno);
1524           else
1525             { /* Assemble the pkcs#1 block type 1. */
1526               n = 0;
1527               frame[n++] = 0;
1528               frame[n++] = 1; /* block type */
1529               i = nframe - valuelen - asnlen - 3 ;
1530               assert (i > 1);
1531               memset (frame+n, 0xff, i );
1532               n += i;
1533               frame[n++] = 0;
1534               memcpy (frame+n, asn, asnlen);
1535               n += asnlen;
1536               memcpy (frame+n, value, valuelen );
1537               n += valuelen;
1538               assert (n == nframe);
1539       
1540               /* Convert it into an MPI.  FIXME: error checking?  */
1541               gcry_mpi_scan (ret_mpi, GCRYMPI_FMT_USG, frame, n, &nframe);
1542             }
1543           
1544           gcry_free (frame);
1545         }
1546     }
1547   else
1548     rc = GPG_ERR_CONFLICT;
1549    
1550   gcry_sexp_release (ldata);
1551   gcry_sexp_release (lhash);
1552   gcry_sexp_release (lvalue);
1553
1554   if (!rc)
1555     *flags = parsed_flags;
1556
1557   return rc;
1558 }
1559
1560
1561 /*
1562    Do a PK encrypt operation
1563   
1564    Caller has to provide a public key as the SEXP pkey and data as a
1565    SEXP with just one MPI in it. Alternativly S_DATA might be a
1566    complex S-Expression, similar to the one used for signature
1567    verification.  This provides a flag which allows to handle PKCS#1
1568    block type 2 padding.  The function returns a a sexp which may be
1569    passed to to pk_decrypt.
1570   
1571    Returns: 0 or an errorcode.
1572   
1573    s_data = See comment for sexp_data_to_mpi
1574    s_pkey = <key-as-defined-in-sexp_to_key>
1575    r_ciph = (enc-val
1576                (<algo>
1577                  (<param_name1> <mpi>)
1578                  ...
1579                  (<param_namen> <mpi>)
1580                ))
1581
1582 */
1583 gcry_error_t
1584 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
1585 {
1586   gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
1587   const char *algo_name, *algo_elems;
1588   int flags;
1589   gcry_err_code_t rc;
1590   gcry_pk_spec_t *pubkey = NULL;
1591   gcry_module_t module = NULL;
1592
1593   *r_ciph = NULL;
1594
1595   REGISTER_DEFAULT_PUBKEYS;
1596
1597   /* Get the key. */
1598   rc = sexp_to_key (s_pkey, 0, &pkey, &module);
1599   if (rc)
1600     goto leave;
1601
1602   assert (module);
1603   pubkey = (gcry_pk_spec_t *) module->spec;
1604
1605   /* If aliases for the algorithm name exists, take the first one
1606      instead of the regular name to adhere to SPKI conventions.  We
1607      assume that the first alias name is the lowercase version of the
1608      regular one.  This change is required for compatibility with
1609      1.1.12 generated S-expressions. */
1610   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
1611   if (!algo_name || !*algo_name)
1612     algo_name = pubkey->name;
1613   
1614   algo_elems = pubkey->elements_enc;
1615   
1616   /* Get the stuff we want to encrypt. */
1617   rc = sexp_data_to_mpi (s_data, gcry_pk_get_nbits (s_pkey), &data, 1,
1618                          &flags);
1619   if (rc)
1620     goto leave;
1621
1622   /* Now we can encrypt DATA to CIPH. */
1623   ciph = gcry_calloc (strlen (algo_elems) + 1, sizeof (*ciph));
1624   if (!ciph)
1625     {
1626       rc = gpg_err_code_from_errno (errno);
1627       goto leave;
1628     }
1629   rc = pubkey_encrypt (module->mod_id, ciph, data, pkey, flags);
1630   mpi_free (data);
1631   data = NULL;
1632   if (rc)
1633     goto leave;
1634
1635   /* We did it.  Now build the return list */
1636   {
1637     char *string, *p;
1638     int i;
1639     size_t nelem = strlen (algo_elems);
1640     size_t needed = 19 + strlen (algo_name) + (nelem * 5);
1641     void **arg_list;
1642     
1643     /* Build the string.  */
1644     string = p = gcry_malloc (needed);
1645     if (!string)
1646       {
1647         rc = gpg_err_code_from_errno (errno);
1648         goto leave;
1649       }
1650     p = stpcpy ( p, "(enc-val(" );
1651     p = stpcpy ( p, algo_name );
1652     for (i=0; algo_elems[i]; i++ )
1653       {
1654         *p++ = '(';
1655         *p++ = algo_elems[i];
1656         p = stpcpy ( p, "%m)" );
1657       }
1658     strcpy ( p, "))" );
1659     
1660     /* And now the ugly part: We don't have a function to pass an
1661      * array to a format string, so we have to do it this way :-(.  */
1662     /* FIXME: There is now such a format specifier, so we can
1663        change the code to be more clear. */
1664     arg_list = malloc (nelem * sizeof *arg_list);
1665     if (!arg_list)
1666       {
1667         rc = gpg_err_code_from_errno (errno);
1668         goto leave;
1669       }
1670
1671     for (i = 0; i < nelem; i++)
1672       arg_list[i] = ciph + i;
1673     
1674     rc = gcry_sexp_build_array (r_ciph, NULL, string, arg_list);
1675     free (arg_list);
1676     if (rc)
1677       BUG ();
1678     gcry_free (string);
1679   }
1680
1681  leave:
1682   if (pkey)
1683     {
1684       release_mpi_array (pkey);
1685       gcry_free (pkey);
1686     }
1687
1688   if (ciph)
1689     {
1690       release_mpi_array (ciph);
1691       gcry_free (ciph);
1692     }
1693
1694   if (module)
1695     {
1696       ath_mutex_lock (&pubkeys_registered_lock);
1697       _gcry_module_release (module);
1698       ath_mutex_unlock (&pubkeys_registered_lock);
1699     }
1700
1701   return gcry_error (rc);
1702 }
1703
1704 /* 
1705    Do a PK decrypt operation
1706   
1707    Caller has to provide a secret key as the SEXP skey and data in a
1708    format as created by gcry_pk_encrypt.  For historic reasons the
1709    function returns simply an MPI as an S-expression part; this is
1710    deprecated and the new method should be used which returns a real
1711    S-expressionl this is selected by adding at least an empty flags
1712    list to S_DATA.
1713    
1714    Returns: 0 or an errorcode.
1715   
1716    s_data = (enc-val
1717               [(flags)]
1718               (<algo>
1719                 (<param_name1> <mpi>)
1720                 ...
1721                 (<param_namen> <mpi>)
1722               ))
1723    s_skey = <key-as-defined-in-sexp_to_key>
1724    r_plain= Either an incomplete S-expression without the parentheses
1725             or if the flags list is used (even if empty) a real S-expression:
1726             (value PLAIN). 
1727  */
1728 gcry_error_t
1729 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
1730 {
1731   gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL;
1732   int modern, want_pkcs1, flags;
1733   gcry_err_code_t rc;
1734   gcry_module_t module_enc = NULL, module_key = NULL;
1735   gcry_pk_spec_t *pubkey = NULL;
1736
1737   *r_plain = NULL;
1738
1739   REGISTER_DEFAULT_PUBKEYS;
1740
1741   rc = sexp_to_key (s_skey, 1, &skey, &module_key);
1742   if (rc)
1743     goto leave;
1744
1745   rc = sexp_to_enc (s_data, &data, &module_enc, &modern, &want_pkcs1, &flags);
1746   if (rc)
1747     goto leave;
1748   
1749   if (module_key->mod_id != module_enc->mod_id)
1750     {
1751       rc = GPG_ERR_CONFLICT; /* Key algo does not match data algo. */
1752       goto leave;
1753     }
1754
1755   pubkey = (gcry_pk_spec_t *) module_key->spec;
1756
1757   rc = pubkey_decrypt (module_key->mod_id, &plain, data, skey, flags);
1758   if (rc)
1759     goto leave;
1760
1761   if (gcry_sexp_build (r_plain, NULL, modern? "(value %m)" : "%m", plain))
1762     BUG ();
1763   
1764  leave:
1765   if (skey)
1766     {
1767       release_mpi_array (skey);
1768       gcry_free (skey);
1769     }
1770
1771   if (plain)
1772     mpi_free (plain);
1773
1774   if (data)
1775     {
1776       release_mpi_array (data);
1777       gcry_free (data);
1778     }
1779
1780   if (module_key || module_enc)
1781     {
1782       ath_mutex_lock (&pubkeys_registered_lock);
1783       if (module_key)
1784         _gcry_module_release (module_key);
1785       if (module_enc)
1786         _gcry_module_release (module_enc);
1787       ath_mutex_unlock (&pubkeys_registered_lock);
1788     }
1789
1790   return gcry_error (rc);
1791 }
1792
1793
1794
1795 /*
1796    Create a signature.
1797   
1798    Caller has to provide a secret key as the SEXP skey and data
1799    expressed as a SEXP list hash with only one element which should
1800    instantly be available as a MPI. Alternatively the structure given
1801    below may be used for S_HASH, it provides the abiliy to pass flags
1802    to the operation; the only flag defined by now is "pkcs1" which
1803    does PKCS#1 block type 1 style padding.
1804   
1805    Returns: 0 or an errorcode.
1806             In case of 0 the function returns a new SEXP with the
1807             signature value; the structure of this signature depends on the
1808             other arguments but is always suitable to be passed to
1809             gcry_pk_verify
1810   
1811    s_hash = See comment for sexp_data_to_mpi
1812                
1813    s_skey = <key-as-defined-in-sexp_to_key>
1814    r_sig  = (sig-val
1815               (<algo>
1816                 (<param_name1> <mpi>)
1817                 ...
1818                 (<param_namen> <mpi>))
1819              [(hash algo)]) 
1820
1821   Note that (hash algo) in R_SIG is not used.
1822 */
1823 gcry_error_t
1824 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
1825 {
1826   gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
1827   gcry_pk_spec_t *pubkey = NULL;
1828   gcry_module_t module = NULL;
1829   const char *algo_name, *algo_elems;
1830   int i;
1831   gcry_err_code_t rc;
1832
1833   *r_sig = NULL;
1834
1835   REGISTER_DEFAULT_PUBKEYS;
1836
1837   rc = sexp_to_key (s_skey, 1, &skey, &module);
1838   if (rc)
1839     goto leave;
1840
1841   assert (module);
1842   pubkey = (gcry_pk_spec_t *) module->spec;
1843   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
1844   if (!algo_name || !*algo_name)
1845     algo_name = pubkey->name;
1846   
1847   algo_elems = pubkey->elements_sig;
1848
1849   /* Get the stuff we want to sign.  Note that pk_get_nbits does also
1850       work on a private key. */
1851   rc = sexp_data_to_mpi (s_hash, gcry_pk_get_nbits (s_skey),
1852                              &hash, 0, NULL);
1853   if (rc)
1854     goto leave;
1855
1856   result = gcry_calloc (strlen (algo_elems) + 1, sizeof (*result));
1857   if (!result)
1858     {
1859       rc = gpg_err_code_from_errno (errno);
1860       goto leave;
1861     }
1862   rc = pubkey_sign (module->mod_id, result, hash, skey);
1863   if (rc)
1864     goto leave;
1865
1866   {
1867     char *string, *p;
1868     size_t nelem, needed = strlen (algo_name) + 20;
1869     void **arg_list;
1870
1871     nelem = strlen (algo_elems);
1872     
1873     /* Count elements, so that we can allocate enough space. */
1874     needed += 10 * nelem;
1875
1876     /* Build the string. */
1877     string = p = gcry_malloc (needed);
1878     if (!string)
1879       {
1880         rc = gpg_err_code_from_errno (errno);
1881         goto leave;
1882       }
1883     p = stpcpy (p, "(sig-val(");
1884     p = stpcpy (p, algo_name);
1885     for (i = 0; algo_elems[i]; i++)
1886       {
1887         *p++ = '(';
1888         *p++ = algo_elems[i];
1889         p = stpcpy (p, "%m)");
1890       }
1891     strcpy (p, "))");
1892
1893     arg_list = malloc (nelem * sizeof *arg_list);
1894     if (!arg_list)
1895       {
1896         rc = gpg_err_code_from_errno (errno);
1897         goto leave;
1898       }
1899
1900     for (i = 0; i < nelem; i++)
1901       arg_list[i] = result + i;
1902
1903     rc = gcry_sexp_build_array (r_sig, NULL, string, arg_list);
1904     free (arg_list);
1905     if (rc)
1906       BUG ();
1907     gcry_free (string);
1908   }
1909
1910  leave:
1911   if (skey)
1912     {
1913       release_mpi_array (skey);
1914       gcry_free (skey);
1915     }
1916
1917   if (hash)
1918     mpi_free (hash);
1919
1920   if (result)
1921     {
1922       release_mpi_array (result);
1923       gcry_free (result);
1924     }
1925
1926   return gcry_error (rc);
1927 }
1928
1929
1930 /*
1931    Verify a signature.
1932
1933    Caller has to supply the public key pkey, the signature sig and his
1934    hashvalue data.  Public key has to be a standard public key given
1935    as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
1936    must be an S-Exp like the one in sign too.  */
1937 gcry_error_t
1938 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
1939 {
1940   gcry_module_t module_key = NULL, module_sig = NULL;
1941   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
1942   gcry_err_code_t rc;
1943
1944   REGISTER_DEFAULT_PUBKEYS;
1945  
1946   rc = sexp_to_key (s_pkey, 0, &pkey, &module_key);
1947   if (rc)
1948     goto leave;
1949
1950   rc = sexp_to_sig (s_sig, &sig, &module_sig);
1951   if (rc)
1952     goto leave;
1953
1954   /* Fixme: Check that the algorithm of S_SIG is compatible to the one
1955      of S_PKEY.  */
1956
1957   if (module_key->mod_id != module_sig->mod_id)
1958     {
1959       rc = GPG_ERR_CONFLICT;
1960       goto leave;
1961     }
1962
1963   rc = sexp_data_to_mpi (s_hash, gcry_pk_get_nbits (s_pkey), &hash, 0, 0);
1964   if (rc)
1965     goto leave;
1966
1967   rc = pubkey_verify (module_key->mod_id, hash, sig, pkey, NULL, NULL);
1968
1969  leave:
1970   if (pkey)
1971     {
1972       release_mpi_array (pkey);
1973       gcry_free (pkey);
1974     }
1975   if (sig)
1976     {
1977       release_mpi_array (sig);
1978       gcry_free (sig);
1979     }
1980   if (hash)
1981     mpi_free (hash);
1982
1983   if (module_key || module_sig)
1984     {
1985       ath_mutex_lock (&pubkeys_registered_lock);
1986       if (module_key)
1987         _gcry_module_release (module_key);
1988       if (module_sig)
1989         _gcry_module_release (module_sig);
1990       ath_mutex_unlock (&pubkeys_registered_lock);
1991     }
1992
1993   return gcry_error (rc);
1994 }
1995
1996
1997 /*
1998    Test a key.
1999
2000    This may be used either for a public or a secret key to see whether
2001    the internal structure is okay.
2002   
2003    Returns: 0 or an errorcode.
2004   
2005    s_key = <key-as-defined-in-sexp_to_key> */
2006 gcry_error_t
2007 gcry_pk_testkey (gcry_sexp_t s_key)
2008 {
2009   gcry_module_t module = NULL;
2010   gcry_mpi_t *key = NULL;
2011   gcry_err_code_t rc;
2012   
2013   REGISTER_DEFAULT_PUBKEYS;
2014
2015   /* Note we currently support only secret key checking. */
2016   rc = sexp_to_key (s_key, 1, &key, &module);
2017   if (! rc)
2018     {
2019       rc = pubkey_check_secret_key (module->mod_id, key);
2020       release_mpi_array (key);
2021       gcry_free (key);
2022     }
2023   return gcry_error (rc);
2024 }
2025
2026
2027 /*
2028   Create a public key pair and return it in r_key.
2029   How the key is created depends on s_parms:
2030   (genkey
2031    (algo
2032      (parameter_name_1 ....)
2033       ....
2034      (parameter_name_n ....)
2035   ))
2036   The key is returned in a format depending on the
2037   algorithm. Both, private and secret keys are returned
2038   and optionally some additional informatin.
2039   For elgamal we return this structure:
2040   (key-data
2041    (public-key
2042      (elg
2043         (p <mpi>)
2044         (g <mpi>)
2045         (y <mpi>)
2046      )
2047    )
2048    (private-key
2049      (elg
2050         (p <mpi>)
2051         (g <mpi>)
2052         (y <mpi>)
2053         (x <mpi>)
2054      )
2055    )
2056    (misc-key-info
2057       (pm1-factors n1 n2 ... nn)
2058    ))
2059  */
2060 gcry_error_t
2061 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
2062 {
2063   gcry_pk_spec_t *pubkey = NULL;
2064   gcry_module_t module = NULL;
2065   gcry_sexp_t list = NULL, l2 = NULL;
2066   char *name = NULL;
2067   size_t n;
2068   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
2069   int i;
2070   const char *algo_name = NULL;
2071   int algo;
2072   const char *sec_elems = NULL, *pub_elems = NULL;
2073   gcry_mpi_t skey[12], *factors = NULL;
2074   unsigned int nbits = 0;
2075   unsigned long use_e = 0;
2076   unsigned int qbits;
2077   gcry_mpi_t xvalue = NULL;
2078   char *curve = NULL;
2079
2080   skey[0] = NULL;
2081   *r_key = NULL;
2082
2083   REGISTER_DEFAULT_PUBKEYS;
2084
2085   list = gcry_sexp_find_token (s_parms, "genkey", 0);
2086   if (!list)
2087     {
2088       rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
2089       goto leave;
2090     }
2091
2092   l2 = gcry_sexp_cadr (list);
2093   gcry_sexp_release (list);
2094   list = l2;
2095   l2 = NULL;
2096   if (! list)
2097     {
2098       rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
2099       goto leave;
2100     }
2101
2102   name = _gcry_sexp_nth_string (list, 0);
2103   if (!name)
2104     {
2105       rc = GPG_ERR_INV_OBJ; /* Algo string missing.  */
2106       goto leave;
2107     }
2108   
2109   ath_mutex_lock (&pubkeys_registered_lock);
2110   module = gcry_pk_lookup_name (name);
2111   ath_mutex_unlock (&pubkeys_registered_lock);
2112   gcry_free (name);
2113   name = NULL;
2114   if (!module)
2115     {
2116       rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
2117       goto leave;
2118     }
2119   
2120   pubkey = (gcry_pk_spec_t *) module->spec;
2121   algo = module->mod_id;
2122   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
2123   if (!algo_name || !*algo_name)
2124     algo_name = pubkey->name;
2125   pub_elems = pubkey->elements_pkey;
2126   sec_elems = pubkey->elements_skey;
2127   if (strlen (sec_elems) >= DIM(skey))
2128     BUG ();
2129
2130   /* Handle the optional rsa-use-e element. */
2131   l2 = gcry_sexp_find_token (list, "rsa-use-e", 0);
2132   if (l2)
2133     {
2134       char buf[50];
2135       const char *s;
2136
2137       s = gcry_sexp_nth_data (l2, 1, &n);
2138       if ( !s || n >= DIM (buf) - 1 )
2139         {
2140           rc = GPG_ERR_INV_OBJ; /* No value or value too large.  */
2141           goto leave;
2142         }
2143       memcpy (buf, s, n);
2144       buf[n] = 0;
2145       use_e = strtoul (buf, NULL, 0);
2146       gcry_sexp_release (l2);
2147       l2 = NULL;
2148     }
2149   else
2150     use_e = 65537; /* Not given, use the value generated by old versions. */
2151
2152   /* Handle the optional qbits element. */
2153   l2 = gcry_sexp_find_token (list, "qbits", 0);
2154   if (l2)
2155     {
2156       char buf[50];
2157       const char *s;
2158
2159       s = gcry_sexp_nth_data (l2, 1, &n);
2160       if (!s || n >= DIM (buf) - 1 )
2161         {
2162           rc = GPG_ERR_INV_OBJ; /* No value or value too large.  */
2163           goto leave;
2164         }
2165       memcpy (buf, s, n);
2166       buf[n] = 0;
2167       qbits = (unsigned int)strtoul (buf, NULL, 0);
2168       gcry_sexp_release (l2);
2169       l2 = NULL;
2170     }
2171   else
2172     qbits = 0;
2173
2174   /* Parse the optional xvalue element. */
2175   l2 = gcry_sexp_find_token (list, "xvalue", 0);
2176   if (l2)
2177     {
2178       xvalue = gcry_sexp_nth_mpi (l2, 1, 0);
2179       if (!xvalue)
2180         {
2181           rc = GPG_ERR_BAD_MPI;
2182           goto leave;
2183         }
2184     }
2185
2186   /* Handle the optional "curve" parameter. */
2187   l2 = gcry_sexp_find_token (list, "curve", 0);
2188   if (l2)
2189     {
2190       curve = _gcry_sexp_nth_string (l2, 1);
2191       if (!curve)
2192         {
2193           rc = GPG_ERR_INV_OBJ; /* No curve name or value too large. */
2194           goto leave;
2195         }
2196       gcry_sexp_release (l2);
2197       l2 = NULL;
2198     }
2199
2200
2201   /* Unless a curve name has been given, the "nbits" parameter is
2202      required.  */
2203   l2 = gcry_sexp_find_token (list, "nbits", 0);
2204   gcry_sexp_release (list);
2205   list = l2;
2206   l2 = NULL;
2207   if (!list && !curve)
2208     {
2209       rc = GPG_ERR_NO_OBJ; /* No nbits parameter. */
2210       goto leave;
2211     }
2212   if (list)
2213     {
2214       char buf[50];
2215       const char *s;
2216
2217       s = gcry_sexp_nth_data (list, 1, &n);
2218       if (!s || n >= DIM (buf) - 1 )
2219         {
2220           rc = GPG_ERR_INV_OBJ; /* NBITS given without a cdr.  */
2221           goto leave;
2222         }
2223       memcpy (buf, s, n);
2224       buf[n] = 0;
2225       nbits = (unsigned int)strtoul (buf, NULL, 0);
2226     }
2227   else 
2228     nbits = 0;
2229
2230   rc = pubkey_generate (module->mod_id, nbits, qbits, use_e, xvalue,
2231                         curve, skey, &factors);
2232   if (rc)
2233     goto leave;
2234
2235   {
2236     char *string, *p;
2237     size_t nelem=0, nelem_cp = 0, needed=0;
2238     gcry_mpi_t mpis[30];
2239     
2240     nelem = strlen (pub_elems) + strlen (sec_elems);
2241     for (i = 0; factors[i]; i++)
2242       nelem++;
2243     nelem_cp = nelem;
2244
2245     needed += nelem * 10;
2246     needed += 2 * strlen (algo_name) + 300;
2247     if (nelem > DIM (mpis))
2248       BUG ();
2249
2250     /* Build the string. */
2251     nelem = 0;
2252     string = p = gcry_malloc (needed);
2253     if (!string)
2254       {
2255         rc = gpg_err_code_from_errno (errno);
2256         goto leave;
2257       }
2258     p = stpcpy (p, "(key-data");
2259     p = stpcpy (p, "(public-key(");
2260     p = stpcpy (p, algo_name);
2261     for(i = 0; pub_elems[i]; i++)
2262       {
2263         *p++ = '(';
2264         *p++ = pub_elems[i];
2265         p = stpcpy (p, "%m)");
2266         mpis[nelem++] = skey[i];
2267       }
2268     p = stpcpy (p, "))");
2269     p = stpcpy (p, "(private-key(");
2270     p = stpcpy (p, algo_name);
2271     for (i = 0; sec_elems[i]; i++)
2272       {
2273         *p++ = '(';
2274         *p++ = sec_elems[i];
2275         p = stpcpy (p, "%m)");
2276         mpis[nelem++] = skey[i];
2277       }
2278     p = stpcpy (p, "))");
2279
2280     /* Very ugly hack to make release_mpi_array() work FIXME */
2281     skey[i] = NULL;
2282
2283     if (factors[0])
2284       {
2285         p = stpcpy (p, "(misc-key-info(pm1-factors");
2286         for(i = 0; factors[i]; i++)
2287           {
2288             p = stpcpy (p, "%m");
2289             mpis[nelem++] = factors[i];
2290           }
2291         p = stpcpy (p, "))");
2292       }
2293     strcpy (p, ")");
2294     assert (p - string < needed);
2295
2296     while (nelem < DIM (mpis))
2297       mpis[nelem++] = NULL;
2298
2299     {
2300       int elem_n = strlen (pub_elems) + strlen (sec_elems);
2301       void **arg_list;
2302
2303       arg_list = malloc (nelem_cp * sizeof *arg_list);
2304       if (!arg_list)
2305         {
2306           rc = gpg_err_code_from_errno (errno);
2307           goto leave;
2308         }
2309       for (i = 0; i < elem_n; i++)
2310         arg_list[i] = mpis + i;
2311       for (; i < nelem_cp; i++)
2312         arg_list[i] = factors + i - elem_n;
2313       
2314       rc = gcry_sexp_build_array (r_key, NULL, string, arg_list);
2315       free (arg_list);
2316       if (rc)
2317         BUG ();
2318       assert (DIM (mpis) == 30); /* Reminder to make sure that the
2319                                     array gets increased if new
2320                                     parameters are added. */
2321     }
2322     gcry_free (string);
2323   }
2324
2325  leave:
2326   gcry_free (name);
2327   gcry_free (curve);
2328   release_mpi_array (skey);
2329   /* Don't free SKEY itself, it is a static array. */
2330
2331   gcry_mpi_release (xvalue);
2332   
2333   if (factors)
2334     {
2335       release_mpi_array ( factors );
2336       gcry_free (factors);
2337     }
2338   
2339   if (l2)
2340     gcry_sexp_release (l2);
2341   if (list)
2342     gcry_sexp_release (list);
2343
2344   if (module)
2345     {
2346       ath_mutex_lock (&pubkeys_registered_lock);
2347       _gcry_module_release (module);
2348       ath_mutex_unlock (&pubkeys_registered_lock);
2349     }
2350
2351   return gcry_error (rc);
2352 }
2353
2354
2355 /* 
2356    Get the number of nbits from the public key.
2357
2358    Hmmm: Should we have really this function or is it better to have a
2359    more general function to retrieve different properties of the key?  */
2360 unsigned int
2361 gcry_pk_get_nbits (gcry_sexp_t key)
2362 {
2363   gcry_module_t module = NULL;
2364   gcry_pk_spec_t *pubkey;
2365   gcry_mpi_t *keyarr = NULL;
2366   unsigned int nbits = 0;
2367   gcry_err_code_t rc;
2368
2369   REGISTER_DEFAULT_PUBKEYS;
2370
2371   rc = sexp_to_key (key, 0, &keyarr, &module);
2372   if (rc == GPG_ERR_INV_OBJ)
2373     rc = sexp_to_key (key, 1, &keyarr, &module);
2374   if (rc)
2375     return 0; /* Error - 0 is a suitable indication for that. */
2376
2377   pubkey = (gcry_pk_spec_t *) module->spec;
2378   nbits = (*pubkey->get_nbits) (module->mod_id, keyarr);
2379   
2380   ath_mutex_lock (&pubkeys_registered_lock);
2381   _gcry_module_release (module);
2382   ath_mutex_unlock (&pubkeys_registered_lock);
2383
2384   release_mpi_array (keyarr);
2385   gcry_free (keyarr);
2386
2387   return nbits;
2388 }
2389
2390
2391 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
2392    key parameters expressed in a way depended on the algorithm.
2393
2394    ARRAY must either be 20 bytes long or NULL; in the latter case a
2395    newly allocated array of that size is returned, otherwise ARRAY or
2396    NULL is returned to indicate an error which is most likely an
2397    unknown algorithm.  The function accepts public or secret keys. */
2398 unsigned char *
2399 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
2400 {
2401   gcry_sexp_t list = NULL, l2 = NULL;
2402   gcry_pk_spec_t *pubkey = NULL;
2403   gcry_module_t module = NULL;
2404   const char *s;
2405   char *name = NULL;
2406   int idx;
2407   int is_rsa;
2408   const char *elems;
2409   gcry_md_hd_t md = NULL;
2410
2411   REGISTER_DEFAULT_PUBKEYS;
2412
2413   /* Check that the first element is valid. */
2414   list = gcry_sexp_find_token (key, "public-key", 0);
2415   if (! list)
2416     list = gcry_sexp_find_token (key, "private-key", 0);
2417   if (! list)
2418     list = gcry_sexp_find_token (key, "protected-private-key", 0);
2419   if (! list)
2420     list = gcry_sexp_find_token (key, "shadowed-private-key", 0);
2421   if (! list)
2422     return NULL; /* No public- or private-key object. */
2423
2424   l2 = gcry_sexp_cadr (list);
2425   gcry_sexp_release (list);
2426   list = l2;
2427   l2 = NULL;
2428
2429   name = _gcry_sexp_nth_string (list, 0);
2430   if (!name)
2431     goto fail; /* Invalid structure of object. */
2432
2433   ath_mutex_lock (&pubkeys_registered_lock);
2434   module = gcry_pk_lookup_name (name);
2435   ath_mutex_unlock (&pubkeys_registered_lock);
2436
2437   if (!module)
2438     goto fail; /* Unknown algorithm.  */
2439
2440   pubkey = (gcry_pk_spec_t *) module->spec;
2441
2442   /* FIXME, special handling should be implemented by the algorithms,
2443      not by the libgcrypt core.  */
2444   is_rsa = module->mod_id == GCRY_PK_RSA;
2445   elems = pubkey->elements_grip;
2446   if (! elems)
2447     goto fail; /* No grip parameter.  */
2448     
2449   if (gcry_md_open (&md, GCRY_MD_SHA1, 0))
2450     goto fail;
2451
2452 #if USE_ECC
2453 # ifdef __GNUC__
2454 #  warning needs to be fixed for ECC.
2455 # endif
2456 #endif
2457
2458   for (idx = 0, s = elems; *s; s++, idx++)
2459     {
2460       const char *data;
2461       size_t datalen;
2462
2463       l2 = gcry_sexp_find_token (list, s, 1);
2464       if (! l2)
2465         goto fail;
2466       data = gcry_sexp_nth_data (l2, 1, &datalen);
2467       if (! data)
2468         goto fail;
2469       if (!is_rsa)
2470         {
2471           char buf[30];
2472
2473           sprintf (buf, "(1:%c%u:", *s, (unsigned int)datalen);
2474           gcry_md_write (md, buf, strlen (buf));
2475         }
2476   
2477       /* PKCS-15 says that for RSA only the modulus should be hashed -
2478          however, it is not clear wether this is meant to use the raw
2479          bytes (assuming this is an unsigned integer) or whether the DER
2480          required 0 should be prefixed. We hash the raw bytes.  For
2481          non-RSA we hash S-expressions. */
2482       gcry_md_write (md, data, datalen);
2483       gcry_sexp_release (l2);
2484       if (!is_rsa)
2485         gcry_md_write (md, ")", 1);
2486     }
2487
2488   if (!array)
2489     {
2490       array = gcry_malloc (20);
2491       if (! array)
2492         goto fail;
2493     }
2494
2495   memcpy (array, gcry_md_read (md, GCRY_MD_SHA1), 20);
2496   gcry_md_close (md);
2497   gcry_sexp_release (list);
2498   return array;
2499
2500  fail:
2501   gcry_free (name);
2502   gcry_sexp_release (l2);
2503   gcry_md_close (md);
2504   gcry_sexp_release (list);
2505   return NULL;
2506 }
2507
2508
2509 gcry_error_t
2510 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
2511 {
2512   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2513
2514   REGISTER_DEFAULT_PUBKEYS;
2515
2516   switch (cmd)
2517     {
2518     case GCRYCTL_DISABLE_ALGO:
2519       /* This one expects a buffer pointing to an integer with the
2520          algo number.  */
2521       if ((! buffer) || (buflen != sizeof (int)))
2522         err = GPG_ERR_INV_ARG;
2523       else
2524         disable_pubkey_algo (*((int *) buffer));
2525       break;
2526
2527     default:
2528       err = GPG_ERR_INV_OP;
2529     }
2530
2531   return gcry_error (err);
2532 }
2533
2534
2535 /* Return information about the given algorithm
2536
2537    WHAT selects the kind of information returned:
2538
2539     GCRYCTL_TEST_ALGO:
2540         Returns 0 when the specified algorithm is available for use.
2541         Buffer must be NULL, nbytes  may have the address of a variable
2542         with the required usage of the algorithm. It may be 0 for don't
2543         care or a combination of the GCRY_PK_USAGE_xxx flags;
2544
2545     GCRYCTL_GET_ALGO_USAGE:
2546         Return the usage glafs for the give algo.  An invalid alog
2547         does return 0.  Disabled algos are ignored here becuase we
2548         only want to know whether the algo is at all capable of
2549         the usage.
2550   
2551    Note: Because this function is in most cases used to return an
2552    integer value, we can make it easier for the caller to just look at
2553    the return value.  The caller will in all cases consult the value
2554    and thereby detecting whether a error occured or not (i.e. while
2555    checking the block size) */
2556 gcry_error_t
2557 gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
2558 {
2559   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2560
2561   switch (what)
2562     {
2563     case GCRYCTL_TEST_ALGO:
2564       {
2565         int use = nbytes ? *nbytes : 0;
2566         if (buffer)
2567           err = GPG_ERR_INV_ARG;
2568         else if (check_pubkey_algo (algorithm, use))
2569           err = GPG_ERR_PUBKEY_ALGO;
2570         break;
2571       }
2572
2573     case GCRYCTL_GET_ALGO_USAGE:
2574       {
2575         gcry_module_t pubkey;
2576         int use = 0;
2577
2578         REGISTER_DEFAULT_PUBKEYS;
2579
2580         ath_mutex_lock (&pubkeys_registered_lock);
2581         pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
2582         if (pubkey)
2583           {
2584             use = ((gcry_pk_spec_t *) pubkey->spec)->use;
2585             _gcry_module_release (pubkey);
2586           }
2587         ath_mutex_unlock (&pubkeys_registered_lock);
2588
2589         /* FIXME? */
2590         *nbytes = use;
2591
2592         break;
2593       }
2594
2595     case GCRYCTL_GET_ALGO_NPKEY:
2596       {
2597         /* FIXME?  */
2598         int npkey = pubkey_get_npkey (algorithm);
2599         *nbytes = npkey;
2600         break;
2601       }
2602     case GCRYCTL_GET_ALGO_NSKEY:
2603       {
2604         /* FIXME?  */
2605         int nskey = pubkey_get_nskey (algorithm);
2606         *nbytes = nskey;
2607         break;
2608       }
2609     case GCRYCTL_GET_ALGO_NSIGN:
2610       {
2611         /* FIXME?  */
2612         int nsign = pubkey_get_nsig (algorithm);
2613         *nbytes = nsign;
2614         break;
2615       }
2616     case GCRYCTL_GET_ALGO_NENCR:
2617       {
2618         /* FIXME?  */
2619         int nencr = pubkey_get_nenc (algorithm);
2620         *nbytes = nencr;
2621         break;
2622       }
2623
2624     default:
2625       err = GPG_ERR_INV_OP;
2626     }
2627
2628   return gcry_error (err);
2629 }
2630
2631
2632 /* Explicitly initialize this module.  */
2633 gcry_err_code_t
2634 _gcry_pk_init (void)
2635 {
2636   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2637
2638   REGISTER_DEFAULT_PUBKEYS;
2639
2640   return err;
2641 }
2642
2643
2644 gcry_err_code_t
2645 _gcry_pk_module_lookup (int algorithm, gcry_module_t *module)
2646 {
2647   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2648   gcry_module_t pubkey;
2649
2650   REGISTER_DEFAULT_PUBKEYS;
2651
2652   ath_mutex_lock (&pubkeys_registered_lock);
2653   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
2654   if (pubkey)
2655     *module = pubkey;
2656   else
2657     err = GPG_ERR_PUBKEY_ALGO;
2658   ath_mutex_unlock (&pubkeys_registered_lock);
2659
2660   return err;
2661 }
2662
2663
2664 void
2665 _gcry_pk_module_release (gcry_module_t module)
2666 {
2667   ath_mutex_lock (&pubkeys_registered_lock);
2668   _gcry_module_release (module);
2669   ath_mutex_unlock (&pubkeys_registered_lock);
2670 }
2671
2672 /* Get a list consisting of the IDs of the loaded pubkey modules.  If
2673    LIST is zero, write the number of loaded pubkey modules to
2674    LIST_LENGTH and return.  If LIST is non-zero, the first
2675    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
2676    according size.  In case there are less pubkey modules than
2677    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
2678 gcry_error_t
2679 gcry_pk_list (int *list, int *list_length)
2680 {
2681   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2682
2683   ath_mutex_lock (&pubkeys_registered_lock);
2684   err = _gcry_module_list (pubkeys_registered, list, list_length);
2685   ath_mutex_unlock (&pubkeys_registered_lock);
2686
2687   return err;
2688 }
2689
2690
2691 /* Run the selftests for pubkey algorithm ALGO with optional reporting
2692    function REPORT.  */
2693 gpg_error_t
2694 _gcry_pk_selftest (int algo, selftest_report_func_t report)
2695 {
2696   gcry_module_t module = NULL;
2697   cipher_extra_spec_t *extraspec = NULL;
2698   gcry_err_code_t ec = 0;
2699
2700   REGISTER_DEFAULT_PUBKEYS;
2701
2702   ath_mutex_lock (&pubkeys_registered_lock);
2703   module = _gcry_module_lookup_id (pubkeys_registered, algo);
2704   if (module && !(module->flags & FLAG_MODULE_DISABLED))
2705     extraspec = module->extraspec;
2706   ath_mutex_unlock (&pubkeys_registered_lock);
2707   if (extraspec && extraspec->selftest)
2708     ec = extraspec->selftest (algo, report);
2709   else
2710     {
2711       ec = GPG_ERR_PUBKEY_ALGO;
2712       if (report)
2713         report ("pubkey", algo, "module", 
2714                 module && !(module->flags & FLAG_MODULE_DISABLED)?
2715                 "no selftest available" :
2716                 module? "algorithm disabled" : "algorithm not found");
2717     }
2718
2719   if (module)
2720     {
2721       ath_mutex_lock (&pubkeys_registered_lock);
2722       _gcry_module_release (module);
2723       ath_mutex_unlock (&pubkeys_registered_lock);
2724     }
2725   return gpg_error (ec);
2726 }
2727
2728
2729 /* This function is only used by ac.c!  */
2730 gcry_err_code_t
2731 _gcry_pk_get_elements (int algo, char **enc, char **sig)
2732 {
2733   gcry_module_t pubkey;
2734   gcry_pk_spec_t *spec;
2735   gcry_err_code_t err;
2736   char *enc_cp;
2737   char *sig_cp;
2738
2739   REGISTER_DEFAULT_PUBKEYS;
2740
2741   enc_cp = NULL;
2742   sig_cp = NULL;
2743   spec = NULL;
2744
2745   pubkey = _gcry_module_lookup_id (pubkeys_registered, algo);
2746   if (! pubkey)
2747     {
2748       err = GPG_ERR_INTERNAL;
2749       goto out;
2750     }
2751   spec = pubkey->spec;
2752
2753   if (enc)
2754     {
2755       enc_cp = strdup (spec->elements_enc);
2756       if (! enc_cp)
2757         {
2758           err = gpg_err_code_from_errno (errno);
2759           goto out;
2760         }
2761     }
2762   
2763   if (sig)
2764     {
2765       sig_cp = strdup (spec->elements_sig);
2766       if (! sig_cp)
2767         {
2768           err = gpg_err_code_from_errno (errno);
2769           goto out;
2770         }
2771     }
2772
2773   if (enc)
2774     *enc = enc_cp;
2775   if (sig)
2776     *sig = sig_cp;
2777   err = 0;
2778
2779  out:
2780
2781   _gcry_module_release (pubkey);
2782   if (err)
2783     {
2784       free (enc_cp);
2785       free (sig_cp);
2786     }
2787
2788   return err;
2789 }