6bc248c34d25347e99d2606f64dfd0c562a3fbfe
[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
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 #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.  USE_E depends on the ALGORITHM.  GENPARMS
534    is passed to the algorithm module if it features an extended
535    generation function.  RETFACTOR is used by some algorithms to
536    return certain additional information which are in general not
537    required.
538
539    The function returns the error code number or 0 on success. */
540 static gcry_err_code_t
541 pubkey_generate (int algorithm,
542                  unsigned int nbits,
543                  unsigned long use_e,
544                  gcry_sexp_t genparms,
545                  gcry_mpi_t *skey, gcry_mpi_t **retfactors)
546 {
547   gcry_err_code_t ec = GPG_ERR_PUBKEY_ALGO;
548   gcry_module_t pubkey;
549
550   REGISTER_DEFAULT_PUBKEYS;
551
552   ath_mutex_lock (&pubkeys_registered_lock);
553   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
554   if (pubkey)
555     {
556       pk_extra_spec_t *extraspec = pubkey->extraspec;
557
558       if (extraspec && extraspec->ext_generate)
559         {
560           /* Use the extended generate function.  */
561           ec = extraspec->ext_generate 
562             (algorithm, nbits, use_e, genparms, skey, retfactors);
563         }
564       else
565         {
566           /* Use the standard generate function.  */
567           ec = ((gcry_pk_spec_t *) pubkey->spec)->generate 
568             (algorithm, nbits, use_e, skey, retfactors);
569         }
570       _gcry_module_release (pubkey);
571     }
572   ath_mutex_unlock (&pubkeys_registered_lock);
573
574   return ec;
575 }
576
577
578 static gcry_err_code_t
579 pubkey_check_secret_key (int algorithm, gcry_mpi_t *skey)
580 {
581   gcry_err_code_t err = GPG_ERR_PUBKEY_ALGO;
582   gcry_module_t pubkey;
583
584   REGISTER_DEFAULT_PUBKEYS;
585
586   ath_mutex_lock (&pubkeys_registered_lock);
587   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
588   if (pubkey)
589     {
590       err = ((gcry_pk_spec_t *) pubkey->spec)->check_secret_key
591         (algorithm, skey);
592       _gcry_module_release (pubkey);
593     }
594   ath_mutex_unlock (&pubkeys_registered_lock);
595
596   return err;
597 }
598
599
600 /****************
601  * This is the interface to the public key encryption.  Encrypt DATA
602  * with PKEY and put it into RESARR which should be an array of MPIs
603  * of size PUBKEY_MAX_NENC (or less if the algorithm allows this -
604  * check with pubkey_get_nenc() )
605  */
606 static gcry_err_code_t
607 pubkey_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
608                 gcry_mpi_t *pkey, int flags)
609 {
610   gcry_pk_spec_t *pubkey;
611   gcry_module_t module;
612   gcry_err_code_t rc;
613   int i;
614
615   /* Note: In fips mode DBG_CIPHER will enver evaluate to true but as
616      an extra failsafe protection we explicitly test for fips mode
617      here. */ 
618   if (DBG_CIPHER && !fips_mode ())
619     {
620       log_debug ("pubkey_encrypt: algo=%d\n", algorithm);
621       for(i = 0; i < pubkey_get_npkey (algorithm); i++)
622         log_mpidump ("  pkey:", pkey[i]);
623       log_mpidump ("  data:", data);
624     }
625
626   ath_mutex_lock (&pubkeys_registered_lock);
627   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
628   if (module)
629     {
630       pubkey = (gcry_pk_spec_t *) module->spec;
631       rc = pubkey->encrypt (algorithm, resarr, data, pkey, flags);
632       _gcry_module_release (module);
633       goto ready;
634     }
635   rc = GPG_ERR_PUBKEY_ALGO;
636
637  ready:
638   ath_mutex_unlock (&pubkeys_registered_lock);
639
640   if (!rc && DBG_CIPHER && !fips_mode ())
641     {
642       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
643         log_mpidump("  encr:", resarr[i] );
644     }
645   return rc;
646 }
647
648
649 /****************
650  * This is the interface to the public key decryption.
651  * ALGO gives the algorithm to use and this implicitly determines
652  * the size of the arrays.
653  * result is a pointer to a mpi variable which will receive a
654  * newly allocated mpi or NULL in case of an error.
655  */
656 static gcry_err_code_t
657 pubkey_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data,
658                 gcry_mpi_t *skey, int flags)
659 {
660   gcry_pk_spec_t *pubkey;
661   gcry_module_t module;
662   gcry_err_code_t rc;
663   int i;
664
665   *result = NULL; /* so the caller can always do a mpi_free */
666   if (DBG_CIPHER && !fips_mode ())
667     {
668       log_debug ("pubkey_decrypt: algo=%d\n", algorithm);
669       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
670         log_mpidump ("  skey:", skey[i]);
671       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
672         log_mpidump ("  data:", data[i]);
673     }
674
675   ath_mutex_lock (&pubkeys_registered_lock);
676   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
677   if (module)
678     {
679       pubkey = (gcry_pk_spec_t *) module->spec;
680       rc = pubkey->decrypt (algorithm, result, data, skey, flags);
681       _gcry_module_release (module);
682       goto ready;
683     }
684
685   rc = GPG_ERR_PUBKEY_ALGO;
686   
687  ready:
688   ath_mutex_unlock (&pubkeys_registered_lock);
689
690   if (!rc && DBG_CIPHER && !fips_mode ())
691     log_mpidump (" plain:", *result);
692
693   return rc;
694 }
695
696
697 /****************
698  * This is the interface to the public key signing.
699  * Sign data with skey and put the result into resarr which
700  * should be an array of MPIs of size PUBKEY_MAX_NSIG (or less if the
701  * algorithm allows this - check with pubkey_get_nsig() )
702  */
703 static gcry_err_code_t
704 pubkey_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
705              gcry_mpi_t *skey)
706 {
707   gcry_pk_spec_t *pubkey;
708   gcry_module_t module;
709   gcry_err_code_t rc;
710   int i;
711
712   if (DBG_CIPHER && !fips_mode ())
713     {
714       log_debug ("pubkey_sign: algo=%d\n", algorithm);
715       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
716         log_mpidump ("  skey:", skey[i]);
717       log_mpidump("  data:", data );
718     }
719
720   ath_mutex_lock (&pubkeys_registered_lock);
721   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
722   if (module)
723     {
724       pubkey = (gcry_pk_spec_t *) module->spec;
725       rc = pubkey->sign (algorithm, resarr, data, skey);
726       _gcry_module_release (module);
727       goto ready;
728     }
729
730   rc = GPG_ERR_PUBKEY_ALGO;
731
732  ready:
733   ath_mutex_unlock (&pubkeys_registered_lock);
734
735   if (!rc && DBG_CIPHER && !fips_mode ())
736     for (i = 0; i < pubkey_get_nsig (algorithm); i++)
737       log_mpidump ("   sig:", resarr[i]);
738
739   return rc;
740 }
741
742 /****************
743  * Verify a public key signature.
744  * Return 0 if the signature is good
745  */
746 static gcry_err_code_t
747 pubkey_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data,
748                gcry_mpi_t *pkey,
749                int (*cmp)(void *, gcry_mpi_t), void *opaquev)
750 {
751   gcry_pk_spec_t *pubkey;
752   gcry_module_t module;
753   gcry_err_code_t rc;
754   int i;
755
756   if (DBG_CIPHER && !fips_mode ())
757     {
758       log_debug ("pubkey_verify: algo=%d\n", algorithm);
759       for (i = 0; i < pubkey_get_npkey (algorithm); i++)
760         log_mpidump ("  pkey:", pkey[i]);
761       for (i = 0; i < pubkey_get_nsig (algorithm); i++)
762         log_mpidump ("   sig:", data[i]);
763       log_mpidump ("  hash:", hash);
764     }
765
766   ath_mutex_lock (&pubkeys_registered_lock);
767   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
768   if (module)
769     {
770       pubkey = (gcry_pk_spec_t *) module->spec;
771       rc = pubkey->verify (algorithm, hash, data, pkey, cmp, opaquev);
772       _gcry_module_release (module);
773       goto ready;
774     }
775
776   rc = GPG_ERR_PUBKEY_ALGO;
777
778  ready:
779   ath_mutex_unlock (&pubkeys_registered_lock);
780   return rc;
781 }
782
783
784 /* Internal function.   */
785 static gcry_err_code_t
786 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
787                        gcry_mpi_t *elements, const char *algo_name)
788 {
789   gcry_err_code_t err = 0;
790   int i, idx;
791   const char *name;
792   gcry_sexp_t list;
793
794   for (name = element_names, idx = 0; *name && !err; name++, idx++)
795     {
796       list = gcry_sexp_find_token (key_sexp, name, 1);
797       if (!list)
798         elements[idx] = NULL;
799       else
800         {
801           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
802           gcry_sexp_release (list);
803           if (!elements[idx])
804             err = GPG_ERR_INV_OBJ;
805         }
806     }
807
808   if (!err)
809     {
810       /* Check that all elements are available.  */
811       for (name = element_names, idx = 0; *name; name++, idx++)
812         if (!elements[idx])
813           break;
814       if (*name)
815         {
816           err = GPG_ERR_NO_OBJ;
817           /* Some are missing.  Before bailing out we test for
818              optional parameters.  */
819           if (algo_name && !strcmp (algo_name, "RSA")
820               && !strcmp (element_names, "nedpqu") )
821             {
822               /* This is RSA.  Test whether we got N, E and D and that
823                  the optional P, Q and U are all missing.  */
824               if (elements[0] && elements[1] && elements[2]
825                   && !elements[3] && !elements[4] && !elements[5])
826                 err = 0;
827             }
828         }
829     }
830
831
832   if (err)
833     {
834       for (i = 0; i < idx; i++)
835         if (elements[i])
836           gcry_free (elements[i]);
837     }
838   return err;
839 }
840
841
842 /* Internal function used for ecc.  Note, that this function makes use
843    of its intimate knowledge about the ECC parameters from ecc.c. */
844 static gcry_err_code_t
845 sexp_elements_extract_ecc (gcry_sexp_t key_sexp, const char *element_names,
846                            gcry_mpi_t *elements, pk_extra_spec_t *extraspec)
847
848 {
849   gcry_err_code_t err = 0;
850   int idx;
851   const char *name;
852   gcry_sexp_t list;
853
854   /* Clear the array for easier error cleanup. */
855   for (name = element_names, idx = 0; *name; name++, idx++)
856     elements[idx] = NULL;
857   gcry_assert (idx >= 6); /* We know that ECC has at least 6 elements.  */
858
859   /* Init the array with the available curve parameters. */
860   for (name = element_names, idx = 0; *name && !err; name++, idx++)
861     {
862       list = gcry_sexp_find_token (key_sexp, name, 1);
863       if (!list)
864         elements[idx] = NULL;
865       else
866         {
867           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
868           gcry_sexp_release (list);
869           if (!elements[idx])
870             {
871               err = GPG_ERR_INV_OBJ;
872               goto leave;
873             }
874         }
875     }
876
877   /* Check whether a curve parameter has been given and then fill any
878      missing elements.  */
879   list = gcry_sexp_find_token (key_sexp, "curve", 5);
880   if (list)
881     {
882       if (extraspec->get_param)
883         {
884           char *curve;
885           gcry_mpi_t params[6];
886           
887           for (idx = 0; idx < DIM(params); idx++)
888             params[idx] = NULL;
889           
890           curve = _gcry_sexp_nth_string (list, 1);
891           gcry_sexp_release (list);
892           if (!curve)
893             {
894               /* No curve name given (or out of core). */
895               err = GPG_ERR_INV_OBJ; 
896               goto leave;
897             }
898           err = extraspec->get_param (curve, params);
899           gcry_free (curve);
900           if (err)
901             goto leave;
902           
903           for (idx = 0; idx < DIM(params); idx++)
904             {
905               if (!elements[idx])
906                 elements[idx] = params[idx];
907               else
908                 mpi_free (params[idx]);
909             }
910         }
911       else
912         {
913           gcry_sexp_release (list);
914           err = GPG_ERR_INV_OBJ; /* "curve" given but ECC not supported. */
915           goto leave;
916         }
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   pk_extra_spec_t *extraspec;
983   int is_ecc;
984
985   /* Check that the first element is valid.  */
986   list = gcry_sexp_find_token (sexp, 
987                                want_private? "private-key":"public-key", 0);
988   if (!list)
989     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
990
991   l2 = gcry_sexp_cadr( list );
992   gcry_sexp_release ( list );
993   list = l2;
994   name = _gcry_sexp_nth_string (list, 0);
995   if (!name)
996     {
997       gcry_sexp_release ( list );
998       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
999     }
1000
1001   ath_mutex_lock (&pubkeys_registered_lock);
1002   module = gcry_pk_lookup_name (name);
1003   ath_mutex_unlock (&pubkeys_registered_lock);
1004   
1005   /* Fixme: We should make sure that an ECC key is always named "ecc"
1006      and not "ecdsa".  "ecdsa" should be used for the signature
1007      itself.  We need a function to test whether an algorithm given
1008      with a key is compatible with an application of the key (signing,
1009      encryption).  For RSA this is easy, but ECC is the first
1010      algorithm which has many flavours. */
1011   is_ecc = ( !strcmp (name, "ecdsa") || !strcmp (name, "ecc") );
1012   gcry_free (name);
1013   
1014   if (!module)
1015     {
1016       gcry_sexp_release (list);
1017       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
1018     }
1019   else
1020     {
1021       pubkey = (gcry_pk_spec_t *) module->spec;
1022       extraspec = module->extraspec;
1023     }
1024
1025   elems = want_private ? pubkey->elements_skey : pubkey->elements_pkey;
1026   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
1027   if (!array)
1028     err = gpg_err_code_from_errno (errno);
1029   if (!err)
1030     {
1031       if (is_ecc)
1032         err = sexp_elements_extract_ecc (list, elems, array, extraspec);
1033       else
1034         err = sexp_elements_extract (list, elems, array, pubkey->name);
1035     }
1036   
1037   gcry_sexp_release (list);
1038   
1039   if (err)
1040     {
1041       gcry_free (array);
1042
1043       ath_mutex_lock (&pubkeys_registered_lock);
1044       _gcry_module_release (module);
1045       ath_mutex_unlock (&pubkeys_registered_lock);
1046     }
1047   else
1048     {
1049       *retarray = array;
1050       *retalgo = module;
1051     }
1052   
1053   return err;
1054 }
1055
1056
1057 static gcry_err_code_t
1058 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
1059              gcry_module_t *retalgo)
1060 {
1061   gcry_err_code_t err = 0;
1062   gcry_sexp_t list, l2;
1063   char *name;
1064   const char *elems;
1065   gcry_mpi_t *array;
1066   gcry_module_t module;
1067   gcry_pk_spec_t *pubkey;
1068   
1069   /* Check that the first element is valid.  */
1070   list = gcry_sexp_find_token( sexp, "sig-val" , 0 );
1071   if (!list)
1072     return GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
1073
1074   l2 = gcry_sexp_nth (list, 1);
1075   if (!l2)
1076     {
1077       gcry_sexp_release (list);
1078       return GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
1079     }
1080   name = _gcry_sexp_nth_string (l2, 0);
1081   if (!name)
1082     {
1083       gcry_sexp_release (list);
1084       gcry_sexp_release (l2);
1085       return GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
1086     }
1087   else if (!strcmp (name, "flags")) 
1088     {
1089       /* Skip flags, since they are not used but here just for the
1090          sake of consistent S-expressions.  */
1091       gcry_free (name);
1092       gcry_sexp_release (l2);
1093       l2 = gcry_sexp_nth (list, 2);
1094       if (!l2)
1095         {
1096           gcry_sexp_release (list);
1097           return GPG_ERR_INV_OBJ;
1098         }
1099       name = _gcry_sexp_nth_string (l2, 0);
1100     }
1101       
1102   ath_mutex_lock (&pubkeys_registered_lock);
1103   module = gcry_pk_lookup_name (name);
1104   ath_mutex_unlock (&pubkeys_registered_lock);
1105   gcry_free (name);
1106   name = NULL;
1107
1108   if (!module)
1109     {
1110       gcry_sexp_release (l2);
1111       gcry_sexp_release (list);
1112       return GPG_ERR_PUBKEY_ALGO;  /* Unknown algorithm. */
1113     }
1114   else
1115     pubkey = (gcry_pk_spec_t *) module->spec;
1116
1117   elems = pubkey->elements_sig;
1118   array = gcry_calloc (strlen (elems) + 1 , sizeof *array );
1119   if (!array)
1120     err = gpg_err_code_from_errno (errno);
1121
1122   if (!err)
1123     err = sexp_elements_extract (list, elems, array, NULL);
1124
1125   gcry_sexp_release (l2);
1126   gcry_sexp_release (list);
1127
1128   if (err)
1129     {
1130       ath_mutex_lock (&pubkeys_registered_lock);
1131       _gcry_module_release (module);
1132       ath_mutex_unlock (&pubkeys_registered_lock);
1133       
1134       gcry_free (array);
1135     }
1136   else
1137     {
1138       *retarray = array;
1139       *retalgo = module;
1140     }
1141   
1142   return err;
1143 }
1144
1145
1146 /****************
1147  * Take sexp and return an array of MPI as used for our internal decrypt
1148  * function.
1149  * s_data = (enc-val
1150  *           [(flags [pkcs1])]
1151  *            (<algo>
1152  *              (<param_name1> <mpi>)
1153  *              ...
1154  *              (<param_namen> <mpi>)
1155  *            ))
1156  * RET_MODERN is set to true when at least an empty flags list has been found.
1157  */
1158 static gcry_err_code_t
1159 sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
1160              int *ret_modern, int *ret_want_pkcs1, int *flags)
1161 {
1162   gcry_err_code_t err = 0;
1163   gcry_sexp_t list = NULL, l2 = NULL;
1164   gcry_pk_spec_t *pubkey = NULL;
1165   gcry_module_t module = NULL;
1166   char *name = NULL;
1167   size_t n;
1168   int parsed_flags = 0;
1169   const char *elems;
1170   gcry_mpi_t *array = NULL;
1171
1172   *ret_want_pkcs1 = 0;
1173   *ret_modern = 0;
1174
1175   /* Check that the first element is valid.  */
1176   list = gcry_sexp_find_token (sexp, "enc-val" , 0);
1177   if (!list)
1178     {
1179       err = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
1180       goto leave;
1181     }
1182
1183   l2 = gcry_sexp_nth (list, 1);
1184   if (!l2)
1185     {
1186       err = GPG_ERR_NO_OBJ; /* No cdr for the data object.  */
1187       goto leave;
1188     }
1189
1190   /* Extract identifier of sublist.  */
1191   name = _gcry_sexp_nth_string (l2, 0);
1192   if (!name)
1193     {
1194       err = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
1195       goto leave;
1196     }
1197   
1198   if (!strcmp (name, "flags"))
1199     {
1200       /* There is a flags element - process it.  */
1201       const char *s;
1202       int i;
1203       
1204       *ret_modern = 1;
1205       for (i = gcry_sexp_length (l2) - 1; i > 0; i--)
1206         {
1207           s = gcry_sexp_nth_data (l2, i, &n);
1208           if (! s)
1209             ; /* Not a data element - ignore.  */
1210           else if (n == 3 && !memcmp (s, "raw", 3))
1211             ; /* This is just a dummy as it is the default.  */
1212           else if (n == 5 && !memcmp (s, "pkcs1", 5))
1213             *ret_want_pkcs1 = 1;
1214           else if (n == 11 && ! memcmp (s, "no-blinding", 11))
1215             parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
1216           else
1217             {
1218               err = GPG_ERR_INV_FLAG;
1219               goto leave;
1220             }
1221         }
1222       
1223       /* Get the next which has the actual data. */
1224       gcry_sexp_release (l2);
1225       l2 = gcry_sexp_nth (list, 2);
1226       if (!l2)
1227         {
1228           err = GPG_ERR_NO_OBJ; /* No cdr for the data object. */
1229           goto leave;
1230         }
1231
1232       /* Extract sublist identifier.  */
1233       gcry_free (name);
1234       name = _gcry_sexp_nth_string (l2, 0);
1235       if (!name)
1236         {
1237           err = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
1238           goto leave;
1239         }
1240
1241       gcry_sexp_release (list);
1242       list = l2;
1243       l2 = NULL;
1244     }
1245
1246   ath_mutex_lock (&pubkeys_registered_lock);
1247   module = gcry_pk_lookup_name (name);
1248   ath_mutex_unlock (&pubkeys_registered_lock);
1249   
1250   if (!module)
1251     {
1252       err = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
1253       goto leave;
1254     }
1255   pubkey = (gcry_pk_spec_t *) module->spec;
1256
1257   elems = pubkey->elements_enc;
1258   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
1259   if (!array)
1260     {
1261       err = gpg_err_code_from_errno (errno);
1262       goto leave;
1263     }
1264
1265   err = sexp_elements_extract (list, elems, array, NULL);
1266
1267  leave:
1268   gcry_sexp_release (list);
1269   gcry_sexp_release (l2);
1270   gcry_free (name);
1271
1272   if (err)
1273     {
1274       ath_mutex_lock (&pubkeys_registered_lock);
1275       _gcry_module_release (module);
1276       ath_mutex_unlock (&pubkeys_registered_lock);
1277       gcry_free (array);
1278     }
1279   else
1280     {
1281       *retarray = array;
1282       *retalgo = module;
1283       *flags = parsed_flags;
1284     }
1285
1286   return err;
1287 }
1288
1289 /* Take the hash value and convert into an MPI, suitable for
1290    passing to the low level functions.  We currently support the
1291    old style way of passing just a MPI and the modern interface which
1292    allows to pass flags so that we can choose between raw and pkcs1
1293    padding - may be more padding options later. 
1294
1295    (<mpi>)
1296    or
1297    (data
1298     [(flags [pkcs1])]
1299     [(hash <algo> <value>)]
1300     [(value <text>)]
1301    )
1302    
1303    Either the VALUE or the HASH element must be present for use
1304    with signatures.  VALUE is used for encryption.
1305
1306    NBITS is the length of the key in bits. 
1307
1308 */
1309 static gcry_err_code_t
1310 sexp_data_to_mpi (gcry_sexp_t input, unsigned int nbits, gcry_mpi_t *ret_mpi,
1311                   int for_encryption, int *flags)
1312 {
1313   gcry_err_code_t rc = 0;
1314   gcry_sexp_t ldata, lhash, lvalue;
1315   int i;
1316   size_t n;
1317   const char *s;
1318   int is_raw = 0, is_pkcs1 = 0, unknown_flag=0; 
1319   int parsed_flags = 0, dummy_flags;
1320
1321   if (! flags)
1322     flags = &dummy_flags;
1323   
1324   *ret_mpi = NULL;
1325   ldata = gcry_sexp_find_token (input, "data", 0);
1326   if (!ldata)
1327     { /* assume old style */
1328       *ret_mpi = gcry_sexp_nth_mpi (input, 0, 0);
1329       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
1330     }
1331
1332   /* see whether there is a flags object */
1333   {
1334     gcry_sexp_t lflags = gcry_sexp_find_token (ldata, "flags", 0);
1335     if (lflags)
1336       { /* parse the flags list. */
1337         for (i=gcry_sexp_length (lflags)-1; i > 0; i--)
1338           {
1339             s = gcry_sexp_nth_data (lflags, i, &n);
1340             if (!s)
1341               ; /* not a data element*/
1342             else if ( n == 3 && !memcmp (s, "raw", 3))
1343               is_raw = 1;
1344             else if ( n == 5 && !memcmp (s, "pkcs1", 5))
1345               is_pkcs1 = 1;
1346             else if (n == 11 && ! memcmp (s, "no-blinding", 11))
1347               parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
1348             else
1349               unknown_flag = 1;
1350           }
1351         gcry_sexp_release (lflags);
1352       }
1353   }
1354
1355   if (!is_pkcs1 && !is_raw)
1356     is_raw = 1; /* default to raw */
1357
1358   /* Get HASH or MPI */
1359   lhash = gcry_sexp_find_token (ldata, "hash", 0);
1360   lvalue = lhash? NULL : gcry_sexp_find_token (ldata, "value", 0);
1361
1362   if (!(!lhash ^ !lvalue))
1363     rc = GPG_ERR_INV_OBJ; /* none or both given */
1364   else if (unknown_flag)
1365     rc = GPG_ERR_INV_FLAG;
1366   else if (is_raw && is_pkcs1 && !for_encryption)
1367     rc = GPG_ERR_CONFLICT;
1368   else if (is_raw && lvalue)
1369     {
1370       *ret_mpi = gcry_sexp_nth_mpi (lvalue, 1, 0);
1371       if (!*ret_mpi)
1372         rc = GPG_ERR_INV_OBJ;
1373     }
1374   else if (is_pkcs1 && lvalue && for_encryption)
1375     { 
1376       /* Create pkcs#1 block type 2 padding. */
1377       unsigned char *frame = NULL;
1378       size_t nframe = (nbits+7) / 8;
1379       const void * value;
1380       size_t valuelen;
1381       unsigned char *p;
1382
1383       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
1384         rc = GPG_ERR_INV_OBJ;
1385       else if (valuelen + 7 > nframe || !nframe)
1386         {
1387           /* Can't encode a VALUELEN value in a NFRAME bytes frame. */
1388           rc = GPG_ERR_TOO_SHORT; /* the key is too short */
1389         }
1390       else if ( !(frame = gcry_malloc_secure (nframe)))
1391         rc = gpg_err_code_from_errno (errno);
1392       else
1393         {
1394           n = 0;
1395           frame[n++] = 0;
1396           frame[n++] = 2; /* block type */
1397           i = nframe - 3 - valuelen;
1398           gcry_assert (i > 0);
1399           p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
1400           /* Replace zero bytes by new values. */
1401           for (;;)
1402             {
1403               int j, k;
1404               unsigned char *pp;
1405               
1406               /* Count the zero bytes. */
1407               for (j=k=0; j < i; j++)
1408                 {
1409                   if (!p[j])
1410                     k++;
1411                 }
1412               if (!k)
1413                 break; /* Okay: no (more) zero bytes. */
1414               
1415               k += k/128 + 3; /* Better get some more. */
1416               pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
1417               for (j=0; j < i && k; )
1418                 {
1419                   if (!p[j])
1420                     p[j] = pp[--k];
1421                   if (p[j])
1422                     j++;
1423                 }
1424               gcry_free (pp);
1425             }
1426           memcpy (frame+n, p, i);
1427           n += i;
1428           gcry_free (p);
1429           
1430           frame[n++] = 0;
1431           memcpy (frame+n, value, valuelen);
1432           n += valuelen;
1433           gcry_assert (n == nframe);
1434
1435           /* FIXME, error checking?  */
1436           gcry_mpi_scan (ret_mpi, GCRYMPI_FMT_USG, frame, n, &nframe);
1437         }
1438
1439       gcry_free(frame);
1440     }
1441   else if (is_pkcs1 && lhash && !for_encryption)
1442     { 
1443       /* Create pkcs#1 block type 1 padding. */
1444       if (gcry_sexp_length (lhash) != 3)
1445         rc = GPG_ERR_INV_OBJ;
1446       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
1447         rc = GPG_ERR_INV_OBJ;
1448       else
1449         {
1450           static struct { const char *name; int algo; } hashnames[] = 
1451           { { "sha1",   GCRY_MD_SHA1 },
1452             { "md5",    GCRY_MD_MD5 },
1453             { "sha256", GCRY_MD_SHA256 },
1454             { "ripemd160", GCRY_MD_RMD160 },
1455             { "rmd160", GCRY_MD_RMD160 },
1456             { "sha384", GCRY_MD_SHA384 },
1457             { "sha512", GCRY_MD_SHA512 },
1458             { "sha224", GCRY_MD_SHA224 },
1459             { "md2",    GCRY_MD_MD2 },
1460             { "md4",    GCRY_MD_MD4 },
1461             { "tiger",  GCRY_MD_TIGER },
1462             { "haval",  GCRY_MD_HAVAL },
1463             { NULL, 0 }
1464           };
1465           int algo;
1466           byte asn[100];
1467           byte *frame = NULL;
1468           size_t nframe = (nbits+7) / 8;
1469           const void * value;
1470           size_t valuelen;
1471           size_t asnlen, dlen;
1472             
1473           for (i=0; hashnames[i].name; i++)
1474             {
1475               if ( strlen (hashnames[i].name) == n
1476                    && !memcmp (hashnames[i].name, s, n))
1477                 break;
1478             }
1479           if (hashnames[i].name)
1480             algo = hashnames[i].algo;
1481           else
1482             {
1483               /* In case of not listed or dynamically allocated hash
1484                  algorithm we fall back to this somewhat slower
1485                  method.  Further, it also allows to use OIDs as
1486                  algorithm names. */
1487               char *tmpname;
1488
1489               tmpname = gcry_malloc (n+1);
1490               if (!tmpname)
1491                 algo = 0;  /* Out of core - silently give up.  */
1492               else
1493                 {
1494                   memcpy (tmpname, s, n);
1495                   tmpname[n] = 0;
1496                   algo = gcry_md_map_name (tmpname);
1497                   gcry_free (tmpname);
1498                 }
1499             }
1500
1501           asnlen = DIM(asn);
1502           dlen = gcry_md_get_algo_dlen (algo);
1503
1504           if (!algo)
1505             rc = GPG_ERR_DIGEST_ALGO;
1506           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
1507                     || !valuelen )
1508             rc = GPG_ERR_INV_OBJ;
1509           else if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
1510             {
1511               /* We don't have yet all of the above algorithms.  */
1512               rc = GPG_ERR_NOT_IMPLEMENTED;
1513             }
1514           else if ( valuelen != dlen )
1515             {
1516               /* Hash value does not match the length of digest for
1517                  the given algorithm. */
1518               rc = GPG_ERR_CONFLICT;
1519             }
1520           else if( !dlen || dlen + asnlen + 4 > nframe)
1521             {
1522               /* Can't encode an DLEN byte digest MD into a NFRAME
1523                  byte frame. */
1524               rc = GPG_ERR_TOO_SHORT;
1525             }
1526           else if ( !(frame = gcry_malloc (nframe)) )
1527             rc = gpg_err_code_from_errno (errno);
1528           else
1529             { /* Assemble the pkcs#1 block type 1. */
1530               n = 0;
1531               frame[n++] = 0;
1532               frame[n++] = 1; /* block type */
1533               i = nframe - valuelen - asnlen - 3 ;
1534               gcry_assert (i > 1);
1535               memset (frame+n, 0xff, i );
1536               n += i;
1537               frame[n++] = 0;
1538               memcpy (frame+n, asn, asnlen);
1539               n += asnlen;
1540               memcpy (frame+n, value, valuelen );
1541               n += valuelen;
1542               gcry_assert (n == nframe);
1543       
1544               /* Convert it into an MPI.  FIXME: error checking?  */
1545               gcry_mpi_scan (ret_mpi, GCRYMPI_FMT_USG, frame, n, &nframe);
1546             }
1547           
1548           gcry_free (frame);
1549         }
1550     }
1551   else
1552     rc = GPG_ERR_CONFLICT;
1553    
1554   gcry_sexp_release (ldata);
1555   gcry_sexp_release (lhash);
1556   gcry_sexp_release (lvalue);
1557
1558   if (!rc)
1559     *flags = parsed_flags;
1560
1561   return rc;
1562 }
1563
1564
1565 /*
1566    Do a PK encrypt operation
1567   
1568    Caller has to provide a public key as the SEXP pkey and data as a
1569    SEXP with just one MPI in it. Alternativly S_DATA might be a
1570    complex S-Expression, similar to the one used for signature
1571    verification.  This provides a flag which allows to handle PKCS#1
1572    block type 2 padding.  The function returns a a sexp which may be
1573    passed to to pk_decrypt.
1574   
1575    Returns: 0 or an errorcode.
1576   
1577    s_data = See comment for sexp_data_to_mpi
1578    s_pkey = <key-as-defined-in-sexp_to_key>
1579    r_ciph = (enc-val
1580                (<algo>
1581                  (<param_name1> <mpi>)
1582                  ...
1583                  (<param_namen> <mpi>)
1584                ))
1585
1586 */
1587 gcry_error_t
1588 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
1589 {
1590   gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
1591   const char *algo_name, *algo_elems;
1592   int flags;
1593   gcry_err_code_t rc;
1594   gcry_pk_spec_t *pubkey = NULL;
1595   gcry_module_t module = NULL;
1596
1597   *r_ciph = NULL;
1598
1599   REGISTER_DEFAULT_PUBKEYS;
1600
1601   /* Get the key. */
1602   rc = sexp_to_key (s_pkey, 0, &pkey, &module);
1603   if (rc)
1604     goto leave;
1605
1606   gcry_assert (module);
1607   pubkey = (gcry_pk_spec_t *) module->spec;
1608
1609   /* If aliases for the algorithm name exists, take the first one
1610      instead of the regular name to adhere to SPKI conventions.  We
1611      assume that the first alias name is the lowercase version of the
1612      regular one.  This change is required for compatibility with
1613      1.1.12 generated S-expressions. */
1614   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
1615   if (!algo_name || !*algo_name)
1616     algo_name = pubkey->name;
1617   
1618   algo_elems = pubkey->elements_enc;
1619   
1620   /* Get the stuff we want to encrypt. */
1621   rc = sexp_data_to_mpi (s_data, gcry_pk_get_nbits (s_pkey), &data, 1,
1622                          &flags);
1623   if (rc)
1624     goto leave;
1625
1626   /* Now we can encrypt DATA to CIPH. */
1627   ciph = gcry_calloc (strlen (algo_elems) + 1, sizeof (*ciph));
1628   if (!ciph)
1629     {
1630       rc = gpg_err_code_from_errno (errno);
1631       goto leave;
1632     }
1633   rc = pubkey_encrypt (module->mod_id, ciph, data, pkey, flags);
1634   mpi_free (data);
1635   data = NULL;
1636   if (rc)
1637     goto leave;
1638
1639   /* We did it.  Now build the return list */
1640   {
1641     char *string, *p;
1642     int i;
1643     size_t nelem = strlen (algo_elems);
1644     size_t needed = 19 + strlen (algo_name) + (nelem * 5);
1645     void **arg_list;
1646     
1647     /* Build the string.  */
1648     string = p = gcry_malloc (needed);
1649     if (!string)
1650       {
1651         rc = gpg_err_code_from_errno (errno);
1652         goto leave;
1653       }
1654     p = stpcpy ( p, "(enc-val(" );
1655     p = stpcpy ( p, algo_name );
1656     for (i=0; algo_elems[i]; i++ )
1657       {
1658         *p++ = '(';
1659         *p++ = algo_elems[i];
1660         p = stpcpy ( p, "%m)" );
1661       }
1662     strcpy ( p, "))" );
1663     
1664     /* And now the ugly part: We don't have a function to pass an
1665      * array to a format string, so we have to do it this way :-(.  */
1666     /* FIXME: There is now such a format specifier, so we can
1667        change the code to be more clear. */
1668     arg_list = malloc (nelem * sizeof *arg_list);
1669     if (!arg_list)
1670       {
1671         rc = gpg_err_code_from_errno (errno);
1672         goto leave;
1673       }
1674
1675     for (i = 0; i < nelem; i++)
1676       arg_list[i] = ciph + i;
1677     
1678     rc = gcry_sexp_build_array (r_ciph, NULL, string, arg_list);
1679     free (arg_list);
1680     if (rc)
1681       BUG ();
1682     gcry_free (string);
1683   }
1684
1685  leave:
1686   if (pkey)
1687     {
1688       release_mpi_array (pkey);
1689       gcry_free (pkey);
1690     }
1691
1692   if (ciph)
1693     {
1694       release_mpi_array (ciph);
1695       gcry_free (ciph);
1696     }
1697
1698   if (module)
1699     {
1700       ath_mutex_lock (&pubkeys_registered_lock);
1701       _gcry_module_release (module);
1702       ath_mutex_unlock (&pubkeys_registered_lock);
1703     }
1704
1705   return gcry_error (rc);
1706 }
1707
1708 /* 
1709    Do a PK decrypt operation
1710   
1711    Caller has to provide a secret key as the SEXP skey and data in a
1712    format as created by gcry_pk_encrypt.  For historic reasons the
1713    function returns simply an MPI as an S-expression part; this is
1714    deprecated and the new method should be used which returns a real
1715    S-expressionl this is selected by adding at least an empty flags
1716    list to S_DATA.
1717    
1718    Returns: 0 or an errorcode.
1719   
1720    s_data = (enc-val
1721               [(flags)]
1722               (<algo>
1723                 (<param_name1> <mpi>)
1724                 ...
1725                 (<param_namen> <mpi>)
1726               ))
1727    s_skey = <key-as-defined-in-sexp_to_key>
1728    r_plain= Either an incomplete S-expression without the parentheses
1729             or if the flags list is used (even if empty) a real S-expression:
1730             (value PLAIN). 
1731  */
1732 gcry_error_t
1733 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
1734 {
1735   gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL;
1736   int modern, want_pkcs1, flags;
1737   gcry_err_code_t rc;
1738   gcry_module_t module_enc = NULL, module_key = NULL;
1739   gcry_pk_spec_t *pubkey = NULL;
1740
1741   *r_plain = NULL;
1742
1743   REGISTER_DEFAULT_PUBKEYS;
1744
1745   rc = sexp_to_key (s_skey, 1, &skey, &module_key);
1746   if (rc)
1747     goto leave;
1748
1749   rc = sexp_to_enc (s_data, &data, &module_enc, &modern, &want_pkcs1, &flags);
1750   if (rc)
1751     goto leave;
1752   
1753   if (module_key->mod_id != module_enc->mod_id)
1754     {
1755       rc = GPG_ERR_CONFLICT; /* Key algo does not match data algo. */
1756       goto leave;
1757     }
1758
1759   pubkey = (gcry_pk_spec_t *) module_key->spec;
1760
1761   rc = pubkey_decrypt (module_key->mod_id, &plain, data, skey, flags);
1762   if (rc)
1763     goto leave;
1764
1765   if (gcry_sexp_build (r_plain, NULL, modern? "(value %m)" : "%m", plain))
1766     BUG ();
1767   
1768  leave:
1769   if (skey)
1770     {
1771       release_mpi_array (skey);
1772       gcry_free (skey);
1773     }
1774
1775   if (plain)
1776     mpi_free (plain);
1777
1778   if (data)
1779     {
1780       release_mpi_array (data);
1781       gcry_free (data);
1782     }
1783
1784   if (module_key || module_enc)
1785     {
1786       ath_mutex_lock (&pubkeys_registered_lock);
1787       if (module_key)
1788         _gcry_module_release (module_key);
1789       if (module_enc)
1790         _gcry_module_release (module_enc);
1791       ath_mutex_unlock (&pubkeys_registered_lock);
1792     }
1793
1794   return gcry_error (rc);
1795 }
1796
1797
1798
1799 /*
1800    Create a signature.
1801   
1802    Caller has to provide a secret key as the SEXP skey and data
1803    expressed as a SEXP list hash with only one element which should
1804    instantly be available as a MPI. Alternatively the structure given
1805    below may be used for S_HASH, it provides the abiliy to pass flags
1806    to the operation; the only flag defined by now is "pkcs1" which
1807    does PKCS#1 block type 1 style padding.
1808   
1809    Returns: 0 or an errorcode.
1810             In case of 0 the function returns a new SEXP with the
1811             signature value; the structure of this signature depends on the
1812             other arguments but is always suitable to be passed to
1813             gcry_pk_verify
1814   
1815    s_hash = See comment for sexp_data_to_mpi
1816                
1817    s_skey = <key-as-defined-in-sexp_to_key>
1818    r_sig  = (sig-val
1819               (<algo>
1820                 (<param_name1> <mpi>)
1821                 ...
1822                 (<param_namen> <mpi>))
1823              [(hash algo)]) 
1824
1825   Note that (hash algo) in R_SIG is not used.
1826 */
1827 gcry_error_t
1828 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
1829 {
1830   gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
1831   gcry_pk_spec_t *pubkey = NULL;
1832   gcry_module_t module = NULL;
1833   const char *algo_name, *algo_elems;
1834   int i;
1835   gcry_err_code_t rc;
1836
1837   *r_sig = NULL;
1838
1839   REGISTER_DEFAULT_PUBKEYS;
1840
1841   rc = sexp_to_key (s_skey, 1, &skey, &module);
1842   if (rc)
1843     goto leave;
1844
1845   gcry_assert (module);
1846   pubkey = (gcry_pk_spec_t *) module->spec;
1847   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
1848   if (!algo_name || !*algo_name)
1849     algo_name = pubkey->name;
1850   
1851   algo_elems = pubkey->elements_sig;
1852
1853   /* Get the stuff we want to sign.  Note that pk_get_nbits does also
1854       work on a private key. */
1855   rc = sexp_data_to_mpi (s_hash, gcry_pk_get_nbits (s_skey),
1856                              &hash, 0, NULL);
1857   if (rc)
1858     goto leave;
1859
1860   result = gcry_calloc (strlen (algo_elems) + 1, sizeof (*result));
1861   if (!result)
1862     {
1863       rc = gpg_err_code_from_errno (errno);
1864       goto leave;
1865     }
1866   rc = pubkey_sign (module->mod_id, result, hash, skey);
1867   if (rc)
1868     goto leave;
1869
1870   {
1871     char *string, *p;
1872     size_t nelem, needed = strlen (algo_name) + 20;
1873     void **arg_list;
1874
1875     nelem = strlen (algo_elems);
1876     
1877     /* Count elements, so that we can allocate enough space. */
1878     needed += 10 * nelem;
1879
1880     /* Build the string. */
1881     string = p = gcry_malloc (needed);
1882     if (!string)
1883       {
1884         rc = gpg_err_code_from_errno (errno);
1885         goto leave;
1886       }
1887     p = stpcpy (p, "(sig-val(");
1888     p = stpcpy (p, algo_name);
1889     for (i = 0; algo_elems[i]; i++)
1890       {
1891         *p++ = '(';
1892         *p++ = algo_elems[i];
1893         p = stpcpy (p, "%m)");
1894       }
1895     strcpy (p, "))");
1896
1897     arg_list = malloc (nelem * sizeof *arg_list);
1898     if (!arg_list)
1899       {
1900         rc = gpg_err_code_from_errno (errno);
1901         goto leave;
1902       }
1903
1904     for (i = 0; i < nelem; i++)
1905       arg_list[i] = result + i;
1906
1907     rc = gcry_sexp_build_array (r_sig, NULL, string, arg_list);
1908     free (arg_list);
1909     if (rc)
1910       BUG ();
1911     gcry_free (string);
1912   }
1913
1914  leave:
1915   if (skey)
1916     {
1917       release_mpi_array (skey);
1918       gcry_free (skey);
1919     }
1920
1921   if (hash)
1922     mpi_free (hash);
1923
1924   if (result)
1925     {
1926       release_mpi_array (result);
1927       gcry_free (result);
1928     }
1929
1930   return gcry_error (rc);
1931 }
1932
1933
1934 /*
1935    Verify a signature.
1936
1937    Caller has to supply the public key pkey, the signature sig and his
1938    hashvalue data.  Public key has to be a standard public key given
1939    as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
1940    must be an S-Exp like the one in sign too.  */
1941 gcry_error_t
1942 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
1943 {
1944   gcry_module_t module_key = NULL, module_sig = NULL;
1945   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
1946   gcry_err_code_t rc;
1947
1948   REGISTER_DEFAULT_PUBKEYS;
1949  
1950   rc = sexp_to_key (s_pkey, 0, &pkey, &module_key);
1951   if (rc)
1952     goto leave;
1953
1954   rc = sexp_to_sig (s_sig, &sig, &module_sig);
1955   if (rc)
1956     goto leave;
1957
1958   /* Fixme: Check that the algorithm of S_SIG is compatible to the one
1959      of S_PKEY.  */
1960
1961   if (module_key->mod_id != module_sig->mod_id)
1962     {
1963       rc = GPG_ERR_CONFLICT;
1964       goto leave;
1965     }
1966
1967   rc = sexp_data_to_mpi (s_hash, gcry_pk_get_nbits (s_pkey), &hash, 0, 0);
1968   if (rc)
1969     goto leave;
1970
1971   rc = pubkey_verify (module_key->mod_id, hash, sig, pkey, NULL, NULL);
1972
1973  leave:
1974   if (pkey)
1975     {
1976       release_mpi_array (pkey);
1977       gcry_free (pkey);
1978     }
1979   if (sig)
1980     {
1981       release_mpi_array (sig);
1982       gcry_free (sig);
1983     }
1984   if (hash)
1985     mpi_free (hash);
1986
1987   if (module_key || module_sig)
1988     {
1989       ath_mutex_lock (&pubkeys_registered_lock);
1990       if (module_key)
1991         _gcry_module_release (module_key);
1992       if (module_sig)
1993         _gcry_module_release (module_sig);
1994       ath_mutex_unlock (&pubkeys_registered_lock);
1995     }
1996
1997   return gcry_error (rc);
1998 }
1999
2000
2001 /*
2002    Test a key.
2003
2004    This may be used either for a public or a secret key to see whether
2005    the internal structure is okay.
2006   
2007    Returns: 0 or an errorcode.
2008   
2009    s_key = <key-as-defined-in-sexp_to_key> */
2010 gcry_error_t
2011 gcry_pk_testkey (gcry_sexp_t s_key)
2012 {
2013   gcry_module_t module = NULL;
2014   gcry_mpi_t *key = NULL;
2015   gcry_err_code_t rc;
2016   
2017   REGISTER_DEFAULT_PUBKEYS;
2018
2019   /* Note we currently support only secret key checking. */
2020   rc = sexp_to_key (s_key, 1, &key, &module);
2021   if (! rc)
2022     {
2023       rc = pubkey_check_secret_key (module->mod_id, key);
2024       release_mpi_array (key);
2025       gcry_free (key);
2026     }
2027   return gcry_error (rc);
2028 }
2029
2030
2031 /*
2032   Create a public key pair and return it in r_key.
2033   How the key is created depends on s_parms:
2034   (genkey
2035    (algo
2036      (parameter_name_1 ....)
2037       ....
2038      (parameter_name_n ....)
2039   ))
2040   The key is returned in a format depending on the
2041   algorithm. Both, private and secret keys are returned
2042   and optionally some additional informatin.
2043   For elgamal we return this structure:
2044   (key-data
2045    (public-key
2046      (elg
2047         (p <mpi>)
2048         (g <mpi>)
2049         (y <mpi>)
2050      )
2051    )
2052    (private-key
2053      (elg
2054         (p <mpi>)
2055         (g <mpi>)
2056         (y <mpi>)
2057         (x <mpi>)
2058      )
2059    )
2060    (misc-key-info
2061       (pm1-factors n1 n2 ... nn)
2062    ))
2063  */
2064 gcry_error_t
2065 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
2066 {
2067   gcry_pk_spec_t *pubkey = NULL;
2068   gcry_module_t module = NULL;
2069   gcry_sexp_t list = NULL;
2070   gcry_sexp_t l2 = NULL;
2071   gcry_sexp_t l3 = NULL;
2072   char *name = NULL;
2073   size_t n;
2074   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
2075   int i;
2076   const char *algo_name = NULL;
2077   int algo;
2078   const char *sec_elems = NULL, *pub_elems = NULL;
2079   gcry_mpi_t skey[12], *factors = NULL;
2080   unsigned int nbits = 0;
2081   unsigned long use_e = 0;
2082
2083   skey[0] = NULL;
2084   *r_key = NULL;
2085
2086   REGISTER_DEFAULT_PUBKEYS;
2087
2088   list = gcry_sexp_find_token (s_parms, "genkey", 0);
2089   if (!list)
2090     {
2091       rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
2092       goto leave;
2093     }
2094
2095   l2 = gcry_sexp_cadr (list);
2096   gcry_sexp_release (list);
2097   list = l2;
2098   l2 = NULL;
2099   if (! list)
2100     {
2101       rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
2102       goto leave;
2103     }
2104
2105   name = _gcry_sexp_nth_string (list, 0);
2106   if (!name)
2107     {
2108       rc = GPG_ERR_INV_OBJ; /* Algo string missing.  */
2109       goto leave;
2110     }
2111   
2112   ath_mutex_lock (&pubkeys_registered_lock);
2113   module = gcry_pk_lookup_name (name);
2114   ath_mutex_unlock (&pubkeys_registered_lock);
2115   gcry_free (name);
2116   name = NULL;
2117   if (!module)
2118     {
2119       rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
2120       goto leave;
2121     }
2122   
2123   pubkey = (gcry_pk_spec_t *) module->spec;
2124   algo = module->mod_id;
2125   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
2126   if (!algo_name || !*algo_name)
2127     algo_name = pubkey->name;
2128   pub_elems = pubkey->elements_pkey;
2129   sec_elems = pubkey->elements_skey;
2130   if (strlen (sec_elems) >= DIM(skey))
2131     BUG ();
2132
2133   /* Handle the optional rsa-use-e element.  Actually this belong into
2134      the algorithm module but we have this parameter in the public
2135      moudle API, so we need to parse it right here.  */
2136   l2 = gcry_sexp_find_token (list, "rsa-use-e", 0);
2137   if (l2)
2138     {
2139       char buf[50];
2140       const char *s;
2141
2142       s = gcry_sexp_nth_data (l2, 1, &n);
2143       if ( !s || n >= DIM (buf) - 1 )
2144         {
2145           rc = GPG_ERR_INV_OBJ; /* No value or value too large.  */
2146           goto leave;
2147         }
2148       memcpy (buf, s, n);
2149       buf[n] = 0;
2150       use_e = strtoul (buf, NULL, 0);
2151       gcry_sexp_release (l2);
2152       l2 = NULL;
2153     }
2154   else
2155     use_e = 65537; /* Not given, use the value generated by old versions. */
2156
2157
2158   /* Get the "nbits" parameter.  */
2159   l2 = gcry_sexp_find_token (list, "nbits", 0);
2160   if (l2)
2161     {
2162       char buf[50];
2163       const char *s;
2164
2165       s = gcry_sexp_nth_data (l2, 1, &n);
2166       if (!s || n >= DIM (buf) - 1 )
2167         {
2168           rc = GPG_ERR_INV_OBJ; /* NBITS given without a cdr.  */
2169           goto leave;
2170         }
2171       memcpy (buf, s, n);
2172       buf[n] = 0;
2173       nbits = (unsigned int)strtoul (buf, NULL, 0);
2174       gcry_sexp_release (l2); l2 = NULL;
2175     }
2176   else 
2177     nbits = 0;
2178
2179   /* Pass control to the algorithm module. */
2180   rc = pubkey_generate (module->mod_id, nbits, use_e, list, skey, &factors);
2181   gcry_sexp_release (list); list = NULL;
2182   if (rc)
2183     goto leave;
2184
2185   /* Key generation succeeded: Build an S-expression.  */
2186   {
2187     char *string, *p;
2188     size_t nelem=0, nelem_cp = 0, needed=0;
2189     gcry_mpi_t mpis[30];
2190     
2191     nelem = strlen (pub_elems) + strlen (sec_elems);
2192     for (i = 0; factors[i]; i++)
2193       nelem++;
2194     nelem_cp = nelem;
2195
2196     needed += nelem * 10;
2197     needed += 2 * strlen (algo_name) + 300;
2198     if (nelem > DIM (mpis))
2199       BUG ();
2200
2201     /* Build the string. */
2202     nelem = 0;
2203     string = p = gcry_malloc (needed);
2204     if (!string)
2205       {
2206         rc = gpg_err_code_from_errno (errno);
2207         goto leave;
2208       }
2209     p = stpcpy (p, "(key-data");
2210     p = stpcpy (p, "(public-key(");
2211     p = stpcpy (p, algo_name);
2212     for(i = 0; pub_elems[i]; i++)
2213       {
2214         *p++ = '(';
2215         *p++ = pub_elems[i];
2216         p = stpcpy (p, "%m)");
2217         mpis[nelem++] = skey[i];
2218       }
2219     p = stpcpy (p, "))");
2220     p = stpcpy (p, "(private-key(");
2221     p = stpcpy (p, algo_name);
2222     for (i = 0; sec_elems[i]; i++)
2223       {
2224         *p++ = '(';
2225         *p++ = sec_elems[i];
2226         p = stpcpy (p, "%m)");
2227         mpis[nelem++] = skey[i];
2228       }
2229     p = stpcpy (p, "))");
2230
2231     /* Hack to make release_mpi_array() work.  */
2232     skey[i] = NULL;
2233
2234     if (factors[0])
2235       {
2236         p = stpcpy (p, "(misc-key-info(pm1-factors");
2237         for(i = 0; factors[i]; i++)
2238           {
2239             p = stpcpy (p, "%m");
2240             mpis[nelem++] = factors[i];
2241           }
2242         p = stpcpy (p, "))");
2243       }
2244     strcpy (p, ")");
2245     gcry_assert (p - string < needed);
2246
2247     while (nelem < DIM (mpis))
2248       mpis[nelem++] = NULL;
2249
2250     {
2251       int elem_n = strlen (pub_elems) + strlen (sec_elems);
2252       void **arg_list;
2253
2254       arg_list = malloc (nelem_cp * sizeof *arg_list);
2255       if (!arg_list)
2256         {
2257           rc = gpg_err_code_from_errno (errno);
2258           goto leave;
2259         }
2260       for (i = 0; i < elem_n; i++)
2261         arg_list[i] = mpis + i;
2262       for (; i < nelem_cp; i++)
2263         arg_list[i] = factors + i - elem_n;
2264       
2265       rc = gcry_sexp_build_array (r_key, NULL, string, arg_list);
2266       free (arg_list);
2267       if (rc)
2268         BUG ();
2269       gcry_assert (DIM (mpis) == 30); /* Reminder to make sure that
2270                                          the array gets increased if
2271                                          new parameters are added. */
2272     }
2273     gcry_free (string);
2274   }
2275
2276  leave:
2277   gcry_free (name);
2278   release_mpi_array (skey);
2279   /* Don't free SKEY itself, it is an stack allocated array. */
2280
2281   if (factors)
2282     {
2283       release_mpi_array ( factors );
2284       gcry_free (factors);
2285     }
2286   
2287   gcry_sexp_release (l3);
2288   gcry_sexp_release (l2);
2289   gcry_sexp_release (list);
2290
2291   if (module)
2292     {
2293       ath_mutex_lock (&pubkeys_registered_lock);
2294       _gcry_module_release (module);
2295       ath_mutex_unlock (&pubkeys_registered_lock);
2296     }
2297
2298   return gcry_error (rc);
2299 }
2300
2301
2302 /* 
2303    Get the number of nbits from the public key.
2304
2305    Hmmm: Should we have really this function or is it better to have a
2306    more general function to retrieve different properties of the key?  */
2307 unsigned int
2308 gcry_pk_get_nbits (gcry_sexp_t key)
2309 {
2310   gcry_module_t module = NULL;
2311   gcry_pk_spec_t *pubkey;
2312   gcry_mpi_t *keyarr = NULL;
2313   unsigned int nbits = 0;
2314   gcry_err_code_t rc;
2315
2316   REGISTER_DEFAULT_PUBKEYS;
2317
2318   rc = sexp_to_key (key, 0, &keyarr, &module);
2319   if (rc == GPG_ERR_INV_OBJ)
2320     rc = sexp_to_key (key, 1, &keyarr, &module);
2321   if (rc)
2322     return 0; /* Error - 0 is a suitable indication for that. */
2323
2324   pubkey = (gcry_pk_spec_t *) module->spec;
2325   nbits = (*pubkey->get_nbits) (module->mod_id, keyarr);
2326   
2327   ath_mutex_lock (&pubkeys_registered_lock);
2328   _gcry_module_release (module);
2329   ath_mutex_unlock (&pubkeys_registered_lock);
2330
2331   release_mpi_array (keyarr);
2332   gcry_free (keyarr);
2333
2334   return nbits;
2335 }
2336
2337
2338 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
2339    key parameters expressed in a way depended on the algorithm.
2340
2341    ARRAY must either be 20 bytes long or NULL; in the latter case a
2342    newly allocated array of that size is returned, otherwise ARRAY or
2343    NULL is returned to indicate an error which is most likely an
2344    unknown algorithm.  The function accepts public or secret keys. */
2345 unsigned char *
2346 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
2347 {
2348   gcry_sexp_t list = NULL, l2 = NULL;
2349   gcry_pk_spec_t *pubkey = NULL;
2350   gcry_module_t module = NULL;
2351   pk_extra_spec_t *extraspec;
2352   const char *s;
2353   char *name = NULL;
2354   int idx;
2355   const char *elems;
2356   gcry_md_hd_t md = NULL;
2357
2358   REGISTER_DEFAULT_PUBKEYS;
2359
2360   /* Check that the first element is valid. */
2361   list = gcry_sexp_find_token (key, "public-key", 0);
2362   if (! list)
2363     list = gcry_sexp_find_token (key, "private-key", 0);
2364   if (! list)
2365     list = gcry_sexp_find_token (key, "protected-private-key", 0);
2366   if (! list)
2367     list = gcry_sexp_find_token (key, "shadowed-private-key", 0);
2368   if (! list)
2369     return NULL; /* No public- or private-key object. */
2370
2371   l2 = gcry_sexp_cadr (list);
2372   gcry_sexp_release (list);
2373   list = l2;
2374   l2 = NULL;
2375
2376   name = _gcry_sexp_nth_string (list, 0);
2377   if (!name)
2378     goto fail; /* Invalid structure of object. */
2379
2380   ath_mutex_lock (&pubkeys_registered_lock);
2381   module = gcry_pk_lookup_name (name);
2382   ath_mutex_unlock (&pubkeys_registered_lock);
2383
2384   if (!module)
2385     goto fail; /* Unknown algorithm.  */
2386
2387   pubkey = (gcry_pk_spec_t *) module->spec;
2388   extraspec = module->extraspec;
2389
2390   elems = pubkey->elements_grip;
2391   if (!elems)
2392     goto fail; /* No grip parameter.  */
2393     
2394   if (gcry_md_open (&md, GCRY_MD_SHA1, 0))
2395     goto fail;
2396
2397   if (extraspec && extraspec->comp_keygrip)
2398     {
2399       /* Module specific method to compute a keygrip.  */
2400       if (extraspec->comp_keygrip (md, list))
2401         goto fail;
2402     }
2403   else
2404     {
2405       /* Generic method to compute a keygrip.  */
2406       for (idx = 0, s = elems; *s; s++, idx++)
2407         {
2408           const char *data;
2409           size_t datalen;
2410           char buf[30];
2411           
2412           l2 = gcry_sexp_find_token (list, s, 1);
2413           if (! l2)
2414             goto fail;
2415           data = gcry_sexp_nth_data (l2, 1, &datalen);
2416           if (! data)
2417             goto fail;
2418           
2419           snprintf (buf, sizeof buf, "(1:%c%u:", *s, (unsigned int)datalen);
2420           gcry_md_write (md, buf, strlen (buf));
2421           gcry_md_write (md, data, datalen);
2422           gcry_sexp_release (l2);
2423           gcry_md_write (md, ")", 1);
2424         }
2425     }
2426   
2427   if (!array)
2428     {
2429       array = gcry_malloc (20);
2430       if (! array)
2431         goto fail;
2432     }
2433
2434   memcpy (array, gcry_md_read (md, GCRY_MD_SHA1), 20);
2435   gcry_md_close (md);
2436   gcry_sexp_release (list);
2437   return array;
2438
2439  fail:
2440   gcry_free (name);
2441   gcry_sexp_release (l2);
2442   gcry_md_close (md);
2443   gcry_sexp_release (list);
2444   return NULL;
2445 }
2446
2447
2448 gcry_error_t
2449 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
2450 {
2451   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2452
2453   REGISTER_DEFAULT_PUBKEYS;
2454
2455   switch (cmd)
2456     {
2457     case GCRYCTL_DISABLE_ALGO:
2458       /* This one expects a buffer pointing to an integer with the
2459          algo number.  */
2460       if ((! buffer) || (buflen != sizeof (int)))
2461         err = GPG_ERR_INV_ARG;
2462       else
2463         disable_pubkey_algo (*((int *) buffer));
2464       break;
2465
2466     default:
2467       err = GPG_ERR_INV_OP;
2468     }
2469
2470   return gcry_error (err);
2471 }
2472
2473
2474 /* Return information about the given algorithm
2475
2476    WHAT selects the kind of information returned:
2477
2478     GCRYCTL_TEST_ALGO:
2479         Returns 0 when the specified algorithm is available for use.
2480         Buffer must be NULL, nbytes  may have the address of a variable
2481         with the required usage of the algorithm. It may be 0 for don't
2482         care or a combination of the GCRY_PK_USAGE_xxx flags;
2483
2484     GCRYCTL_GET_ALGO_USAGE:
2485         Return the usage glafs for the give algo.  An invalid alog
2486         does return 0.  Disabled algos are ignored here becuase we
2487         only want to know whether the algo is at all capable of
2488         the usage.
2489   
2490    Note: Because this function is in most cases used to return an
2491    integer value, we can make it easier for the caller to just look at
2492    the return value.  The caller will in all cases consult the value
2493    and thereby detecting whether a error occured or not (i.e. while
2494    checking the block size) */
2495 gcry_error_t
2496 gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
2497 {
2498   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2499
2500   switch (what)
2501     {
2502     case GCRYCTL_TEST_ALGO:
2503       {
2504         int use = nbytes ? *nbytes : 0;
2505         if (buffer)
2506           err = GPG_ERR_INV_ARG;
2507         else if (check_pubkey_algo (algorithm, use))
2508           err = GPG_ERR_PUBKEY_ALGO;
2509         break;
2510       }
2511
2512     case GCRYCTL_GET_ALGO_USAGE:
2513       {
2514         gcry_module_t pubkey;
2515         int use = 0;
2516
2517         REGISTER_DEFAULT_PUBKEYS;
2518
2519         ath_mutex_lock (&pubkeys_registered_lock);
2520         pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
2521         if (pubkey)
2522           {
2523             use = ((gcry_pk_spec_t *) pubkey->spec)->use;
2524             _gcry_module_release (pubkey);
2525           }
2526         ath_mutex_unlock (&pubkeys_registered_lock);
2527
2528         /* FIXME? */
2529         *nbytes = use;
2530
2531         break;
2532       }
2533
2534     case GCRYCTL_GET_ALGO_NPKEY:
2535       {
2536         /* FIXME?  */
2537         int npkey = pubkey_get_npkey (algorithm);
2538         *nbytes = npkey;
2539         break;
2540       }
2541     case GCRYCTL_GET_ALGO_NSKEY:
2542       {
2543         /* FIXME?  */
2544         int nskey = pubkey_get_nskey (algorithm);
2545         *nbytes = nskey;
2546         break;
2547       }
2548     case GCRYCTL_GET_ALGO_NSIGN:
2549       {
2550         /* FIXME?  */
2551         int nsign = pubkey_get_nsig (algorithm);
2552         *nbytes = nsign;
2553         break;
2554       }
2555     case GCRYCTL_GET_ALGO_NENCR:
2556       {
2557         /* FIXME?  */
2558         int nencr = pubkey_get_nenc (algorithm);
2559         *nbytes = nencr;
2560         break;
2561       }
2562
2563     default:
2564       err = GPG_ERR_INV_OP;
2565     }
2566
2567   return gcry_error (err);
2568 }
2569
2570
2571 /* Explicitly initialize this module.  */
2572 gcry_err_code_t
2573 _gcry_pk_init (void)
2574 {
2575   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2576
2577   REGISTER_DEFAULT_PUBKEYS;
2578
2579   return err;
2580 }
2581
2582
2583 gcry_err_code_t
2584 _gcry_pk_module_lookup (int algorithm, gcry_module_t *module)
2585 {
2586   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2587   gcry_module_t pubkey;
2588
2589   REGISTER_DEFAULT_PUBKEYS;
2590
2591   ath_mutex_lock (&pubkeys_registered_lock);
2592   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
2593   if (pubkey)
2594     *module = pubkey;
2595   else
2596     err = GPG_ERR_PUBKEY_ALGO;
2597   ath_mutex_unlock (&pubkeys_registered_lock);
2598
2599   return err;
2600 }
2601
2602
2603 void
2604 _gcry_pk_module_release (gcry_module_t module)
2605 {
2606   ath_mutex_lock (&pubkeys_registered_lock);
2607   _gcry_module_release (module);
2608   ath_mutex_unlock (&pubkeys_registered_lock);
2609 }
2610
2611 /* Get a list consisting of the IDs of the loaded pubkey modules.  If
2612    LIST is zero, write the number of loaded pubkey modules to
2613    LIST_LENGTH and return.  If LIST is non-zero, the first
2614    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
2615    according size.  In case there are less pubkey modules than
2616    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
2617 gcry_error_t
2618 gcry_pk_list (int *list, int *list_length)
2619 {
2620   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2621
2622   ath_mutex_lock (&pubkeys_registered_lock);
2623   err = _gcry_module_list (pubkeys_registered, list, list_length);
2624   ath_mutex_unlock (&pubkeys_registered_lock);
2625
2626   return err;
2627 }
2628
2629
2630 /* Run the selftests for pubkey algorithm ALGO with optional reporting
2631    function REPORT.  */
2632 gpg_error_t
2633 _gcry_pk_selftest (int algo, int extended, selftest_report_func_t report)
2634 {
2635   gcry_module_t module = NULL;
2636   pk_extra_spec_t *extraspec = NULL;
2637   gcry_err_code_t ec = 0;
2638
2639   REGISTER_DEFAULT_PUBKEYS;
2640
2641   ath_mutex_lock (&pubkeys_registered_lock);
2642   module = _gcry_module_lookup_id (pubkeys_registered, algo);
2643   if (module && !(module->flags & FLAG_MODULE_DISABLED))
2644     extraspec = module->extraspec;
2645   ath_mutex_unlock (&pubkeys_registered_lock);
2646   if (extraspec && extraspec->selftest)
2647     ec = extraspec->selftest (algo, extended, report);
2648   else
2649     {
2650       ec = GPG_ERR_PUBKEY_ALGO;
2651       if (report)
2652         report ("pubkey", algo, "module", 
2653                 module && !(module->flags & FLAG_MODULE_DISABLED)?
2654                 "no selftest available" :
2655                 module? "algorithm disabled" : "algorithm not found");
2656     }
2657
2658   if (module)
2659     {
2660       ath_mutex_lock (&pubkeys_registered_lock);
2661       _gcry_module_release (module);
2662       ath_mutex_unlock (&pubkeys_registered_lock);
2663     }
2664   return gpg_error (ec);
2665 }
2666
2667
2668 /* This function is only used by ac.c!  */
2669 gcry_err_code_t
2670 _gcry_pk_get_elements (int algo, char **enc, char **sig)
2671 {
2672   gcry_module_t pubkey;
2673   gcry_pk_spec_t *spec;
2674   gcry_err_code_t err;
2675   char *enc_cp;
2676   char *sig_cp;
2677
2678   REGISTER_DEFAULT_PUBKEYS;
2679
2680   enc_cp = NULL;
2681   sig_cp = NULL;
2682   spec = NULL;
2683
2684   pubkey = _gcry_module_lookup_id (pubkeys_registered, algo);
2685   if (! pubkey)
2686     {
2687       err = GPG_ERR_INTERNAL;
2688       goto out;
2689     }
2690   spec = pubkey->spec;
2691
2692   if (enc)
2693     {
2694       enc_cp = strdup (spec->elements_enc);
2695       if (! enc_cp)
2696         {
2697           err = gpg_err_code_from_errno (errno);
2698           goto out;
2699         }
2700     }
2701   
2702   if (sig)
2703     {
2704       sig_cp = strdup (spec->elements_sig);
2705       if (! sig_cp)
2706         {
2707           err = gpg_err_code_from_errno (errno);
2708           goto out;
2709         }
2710     }
2711
2712   if (enc)
2713     *enc = enc_cp;
2714   if (sig)
2715     *sig = sig_cp;
2716   err = 0;
2717
2718  out:
2719
2720   _gcry_module_release (pubkey);
2721   if (err)
2722     {
2723       free (enc_cp);
2724       free (sig_cp);
2725     }
2726
2727   return err;
2728 }