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