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