Use octet_string_from_mpi in oaep_decode.
[libgcrypt.git] / cipher / pubkey.c
1 /* pubkey.c  -  pubkey dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2002, 2003, 2005,
3  *               2007, 2008, 2011 Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "g10lib.h"
28 #include "mpi.h"
29 #include "cipher.h"
30 #include "ath.h"
31
32
33 static gcry_err_code_t pubkey_decrypt (int algo, gcry_mpi_t *result,
34                                        gcry_mpi_t *data, gcry_mpi_t *skey,
35                                        int flags);
36 static gcry_err_code_t pubkey_sign (int algo, gcry_mpi_t *resarr,
37                                     gcry_mpi_t hash, gcry_mpi_t *skey);
38 static gcry_err_code_t pubkey_verify (int algo, gcry_mpi_t hash,
39                                       gcry_mpi_t *data, gcry_mpi_t *pkey,
40                                      int (*cmp) (void *, gcry_mpi_t),
41                                       void *opaque);
42
43
44 /* A dummy extraspec so that we do not need to tests the extraspec
45    field from the module specification against NULL and instead
46    directly test the respective fields of extraspecs.  */
47 static pk_extra_spec_t dummy_extra_spec;
48
49
50 /* This is the list of the default public-key ciphers included in
51    libgcrypt.  FIPS_ALLOWED indicated whether the algorithm is used in
52    FIPS mode. */
53 static struct pubkey_table_entry
54 {
55   gcry_pk_spec_t *pubkey;
56   pk_extra_spec_t *extraspec;
57   unsigned int algorithm;
58   int fips_allowed;
59 } pubkey_table[] =
60   {
61 #if USE_RSA
62     { &_gcry_pubkey_spec_rsa,
63       &_gcry_pubkey_extraspec_rsa,   GCRY_PK_RSA, 1},
64 #endif
65 #if USE_ELGAMAL
66     { &_gcry_pubkey_spec_elg,
67       &_gcry_pubkey_extraspec_elg,    GCRY_PK_ELG   },
68     { &_gcry_pubkey_spec_elg,
69       &_gcry_pubkey_extraspec_elg,    GCRY_PK_ELG_E },
70 #endif
71 #if USE_DSA
72     { &_gcry_pubkey_spec_dsa,
73       &_gcry_pubkey_extraspec_dsa,   GCRY_PK_DSA, 1   },
74 #endif
75 #if USE_ECC
76     { &_gcry_pubkey_spec_ecdsa,
77       &_gcry_pubkey_extraspec_ecdsa, GCRY_PK_ECDSA, 0 },
78     { &_gcry_pubkey_spec_ecdh,
79       &_gcry_pubkey_extraspec_ecdsa, GCRY_PK_ECDH, 0 },
80 #endif
81     { NULL, 0 },
82   };
83
84 /* List of registered ciphers.  */
85 static gcry_module_t pubkeys_registered;
86
87 /* This is the lock protecting PUBKEYS_REGISTERED.  */
88 static ath_mutex_t pubkeys_registered_lock = ATH_MUTEX_INITIALIZER;;
89
90 /* Flag to check whether the default pubkeys have already been
91    registered.  */
92 static int default_pubkeys_registered;
93
94 /* Convenient macro for registering the default digests.  */
95 #define REGISTER_DEFAULT_PUBKEYS                   \
96   do                                               \
97     {                                              \
98       ath_mutex_lock (&pubkeys_registered_lock);   \
99       if (! default_pubkeys_registered)            \
100         {                                          \
101           pk_register_default ();                  \
102           default_pubkeys_registered = 1;          \
103         }                                          \
104       ath_mutex_unlock (&pubkeys_registered_lock); \
105     }                                              \
106   while (0)
107
108 /* These dummy functions are used in case a cipher implementation
109    refuses to provide it's own functions.  */
110
111 static gcry_err_code_t
112 dummy_generate (int algorithm, unsigned int nbits, unsigned long dummy,
113                 gcry_mpi_t *skey, gcry_mpi_t **retfactors)
114 {
115   (void)algorithm;
116   (void)nbits;
117   (void)dummy;
118   (void)skey;
119   (void)retfactors;
120   fips_signal_error ("using dummy public key function");
121   return GPG_ERR_NOT_IMPLEMENTED;
122 }
123
124 static gcry_err_code_t
125 dummy_check_secret_key (int algorithm, gcry_mpi_t *skey)
126 {
127   (void)algorithm;
128   (void)skey;
129   fips_signal_error ("using dummy public key function");
130   return GPG_ERR_NOT_IMPLEMENTED;
131 }
132
133 static gcry_err_code_t
134 dummy_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
135                gcry_mpi_t *pkey, int flags)
136 {
137   (void)algorithm;
138   (void)resarr;
139   (void)data;
140   (void)pkey;
141   (void)flags;
142   fips_signal_error ("using dummy public key function");
143   return GPG_ERR_NOT_IMPLEMENTED;
144 }
145
146 static gcry_err_code_t
147 dummy_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data,
148                gcry_mpi_t *skey, int flags)
149 {
150   (void)algorithm;
151   (void)result;
152   (void)data;
153   (void)skey;
154   (void)flags;
155   fips_signal_error ("using dummy public key function");
156   return GPG_ERR_NOT_IMPLEMENTED;
157 }
158
159 static gcry_err_code_t
160 dummy_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
161             gcry_mpi_t *skey)
162 {
163   (void)algorithm;
164   (void)resarr;
165   (void)data;
166   (void)skey;
167   fips_signal_error ("using dummy public key function");
168   return GPG_ERR_NOT_IMPLEMENTED;
169 }
170
171 static gcry_err_code_t
172 dummy_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data,
173               gcry_mpi_t *pkey,
174               int (*cmp) (void *, gcry_mpi_t), void *opaquev)
175 {
176   (void)algorithm;
177   (void)hash;
178   (void)data;
179   (void)pkey;
180   (void)cmp;
181   (void)opaquev;
182   fips_signal_error ("using dummy public key function");
183   return GPG_ERR_NOT_IMPLEMENTED;
184 }
185
186 static unsigned
187 dummy_get_nbits (int algorithm, gcry_mpi_t *pkey)
188 {
189   (void)algorithm;
190   (void)pkey;
191   fips_signal_error ("using dummy public key function");
192   return 0;
193 }
194
195 /* Internal function.  Register all the pubkeys included in
196    PUBKEY_TABLE.  Returns zero on success or an error code.  */
197 static void
198 pk_register_default (void)
199 {
200   gcry_err_code_t err = 0;
201   int i;
202
203   for (i = 0; (! err) && pubkey_table[i].pubkey; i++)
204     {
205 #define pubkey_use_dummy(func)                       \
206       if (! pubkey_table[i].pubkey->func)            \
207         pubkey_table[i].pubkey->func = dummy_##func;
208
209       pubkey_use_dummy (generate);
210       pubkey_use_dummy (check_secret_key);
211       pubkey_use_dummy (encrypt);
212       pubkey_use_dummy (decrypt);
213       pubkey_use_dummy (sign);
214       pubkey_use_dummy (verify);
215       pubkey_use_dummy (get_nbits);
216 #undef pubkey_use_dummy
217
218       err = _gcry_module_add (&pubkeys_registered,
219                               pubkey_table[i].algorithm,
220                               (void *) pubkey_table[i].pubkey,
221                               (void *) pubkey_table[i].extraspec,
222                               NULL);
223     }
224
225   if (err)
226     BUG ();
227 }
228
229 /* Internal callback function.  Used via _gcry_module_lookup.  */
230 static int
231 gcry_pk_lookup_func_name (void *spec, void *data)
232 {
233   gcry_pk_spec_t *pubkey = (gcry_pk_spec_t *) spec;
234   char *name = (char *) data;
235   const char **aliases = pubkey->aliases;
236   int ret = stricmp (name, pubkey->name);
237
238   while (ret && *aliases)
239     ret = stricmp (name, *aliases++);
240
241   return ! ret;
242 }
243
244 /* Internal function.  Lookup a pubkey entry by it's name.  */
245 static gcry_module_t
246 gcry_pk_lookup_name (const char *name)
247 {
248   gcry_module_t pubkey;
249
250   pubkey = _gcry_module_lookup (pubkeys_registered, (void *) name,
251                                 gcry_pk_lookup_func_name);
252
253   return pubkey;
254 }
255
256 /* Register a new pubkey module whose specification can be found in
257    PUBKEY.  On success, a new algorithm ID is stored in ALGORITHM_ID
258    and a pointer representhing this module is stored in MODULE.  */
259 gcry_error_t
260 _gcry_pk_register (gcry_pk_spec_t *pubkey,
261                    pk_extra_spec_t *extraspec,
262                    unsigned int *algorithm_id,
263                    gcry_module_t *module)
264 {
265   gcry_err_code_t err = GPG_ERR_NO_ERROR;
266   gcry_module_t mod;
267
268   /* We do not support module loading in fips mode.  */
269   if (fips_mode ())
270     return gpg_error (GPG_ERR_NOT_SUPPORTED);
271
272   ath_mutex_lock (&pubkeys_registered_lock);
273   err = _gcry_module_add (&pubkeys_registered, 0,
274                           (void *) pubkey,
275                           (void *)(extraspec? extraspec : &dummy_extra_spec),
276                           &mod);
277   ath_mutex_unlock (&pubkeys_registered_lock);
278
279   if (! err)
280     {
281       *module = mod;
282       *algorithm_id = mod->mod_id;
283     }
284
285   return err;
286 }
287
288 /* Unregister the pubkey identified by ID, which must have been
289    registered with gcry_pk_register.  */
290 void
291 gcry_pk_unregister (gcry_module_t module)
292 {
293   ath_mutex_lock (&pubkeys_registered_lock);
294   _gcry_module_release (module);
295   ath_mutex_unlock (&pubkeys_registered_lock);
296 }
297
298 static void
299 release_mpi_array (gcry_mpi_t *array)
300 {
301   for (; *array; array++)
302     {
303       mpi_free(*array);
304       *array = NULL;
305     }
306 }
307
308 /****************
309  * Map a string to the pubkey algo
310  */
311 int
312 gcry_pk_map_name (const char *string)
313 {
314   gcry_module_t pubkey;
315   int algorithm = 0;
316
317   if (!string)
318     return 0;
319
320   REGISTER_DEFAULT_PUBKEYS;
321
322   ath_mutex_lock (&pubkeys_registered_lock);
323   pubkey = gcry_pk_lookup_name (string);
324   if (pubkey)
325     {
326       algorithm = pubkey->mod_id;
327       _gcry_module_release (pubkey);
328     }
329   ath_mutex_unlock (&pubkeys_registered_lock);
330
331   return algorithm;
332 }
333
334
335 /* Map the public key algorithm whose ID is contained in ALGORITHM to
336    a string representation of the algorithm name.  For unknown
337    algorithm IDs this functions returns "?". */
338 const char *
339 gcry_pk_algo_name (int algorithm)
340 {
341   gcry_module_t pubkey;
342   const char *name;
343
344   REGISTER_DEFAULT_PUBKEYS;
345
346   ath_mutex_lock (&pubkeys_registered_lock);
347   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
348   if (pubkey)
349     {
350       name = ((gcry_pk_spec_t *) pubkey->spec)->name;
351       _gcry_module_release (pubkey);
352     }
353   else
354     name = "?";
355   ath_mutex_unlock (&pubkeys_registered_lock);
356
357   return name;
358 }
359
360
361 /* A special version of gcry_pk_algo name to return the first aliased
362    name of the algorithm.  This is required to adhere to the spki
363    specs where the algorithm names are lowercase. */
364 const char *
365 _gcry_pk_aliased_algo_name (int algorithm)
366 {
367   const char *name = NULL;
368   gcry_module_t module;
369
370   REGISTER_DEFAULT_PUBKEYS;
371
372   ath_mutex_lock (&pubkeys_registered_lock);
373   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
374   if (module)
375     {
376       gcry_pk_spec_t *pubkey = (gcry_pk_spec_t *) module->spec;
377
378       name = pubkey->aliases? *pubkey->aliases : NULL;
379       if (!name || !*name)
380         name = pubkey->name;
381       _gcry_module_release (module);
382     }
383   ath_mutex_unlock (&pubkeys_registered_lock);
384
385   return name;
386 }
387
388
389 static void
390 disable_pubkey_algo (int algorithm)
391 {
392   gcry_module_t pubkey;
393
394   ath_mutex_lock (&pubkeys_registered_lock);
395   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
396   if (pubkey)
397     {
398       if (! (pubkey-> flags & FLAG_MODULE_DISABLED))
399         pubkey->flags |= FLAG_MODULE_DISABLED;
400       _gcry_module_release (pubkey);
401     }
402   ath_mutex_unlock (&pubkeys_registered_lock);
403 }
404
405
406 /****************
407  * A USE of 0 means: don't care.
408  */
409 static gcry_err_code_t
410 check_pubkey_algo (int algorithm, unsigned use)
411 {
412   gcry_err_code_t err = GPG_ERR_NO_ERROR;
413   gcry_pk_spec_t *pubkey;
414   gcry_module_t module;
415
416   REGISTER_DEFAULT_PUBKEYS;
417
418   ath_mutex_lock (&pubkeys_registered_lock);
419   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
420   if (module)
421     {
422       pubkey = (gcry_pk_spec_t *) module->spec;
423
424       if (((use & GCRY_PK_USAGE_SIGN)
425            && (! (pubkey->use & GCRY_PK_USAGE_SIGN)))
426           || ((use & GCRY_PK_USAGE_ENCR)
427               && (! (pubkey->use & GCRY_PK_USAGE_ENCR))))
428         err = GPG_ERR_WRONG_PUBKEY_ALGO;
429       else if (module->flags & FLAG_MODULE_DISABLED)
430         err = GPG_ERR_PUBKEY_ALGO;
431       _gcry_module_release (module);
432     }
433   else
434     err = GPG_ERR_PUBKEY_ALGO;
435   ath_mutex_unlock (&pubkeys_registered_lock);
436
437   return err;
438 }
439
440
441 /****************
442  * Return the number of public key material numbers
443  */
444 static int
445 pubkey_get_npkey (int algorithm)
446 {
447   gcry_module_t pubkey;
448   int npkey = 0;
449
450   REGISTER_DEFAULT_PUBKEYS;
451
452   ath_mutex_lock (&pubkeys_registered_lock);
453   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
454   if (pubkey)
455     {
456       npkey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_pkey);
457       _gcry_module_release (pubkey);
458     }
459   ath_mutex_unlock (&pubkeys_registered_lock);
460
461   return npkey;
462 }
463
464 /****************
465  * Return the number of secret key material numbers
466  */
467 static int
468 pubkey_get_nskey (int algorithm)
469 {
470   gcry_module_t pubkey;
471   int nskey = 0;
472
473   REGISTER_DEFAULT_PUBKEYS;
474
475   ath_mutex_lock (&pubkeys_registered_lock);
476   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
477   if (pubkey)
478     {
479       nskey = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_skey);
480       _gcry_module_release (pubkey);
481     }
482   ath_mutex_unlock (&pubkeys_registered_lock);
483
484   return nskey;
485 }
486
487 /****************
488  * Return the number of signature material numbers
489  */
490 static int
491 pubkey_get_nsig (int algorithm)
492 {
493   gcry_module_t pubkey;
494   int nsig = 0;
495
496   REGISTER_DEFAULT_PUBKEYS;
497
498   ath_mutex_lock (&pubkeys_registered_lock);
499   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
500   if (pubkey)
501     {
502       nsig = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_sig);
503       _gcry_module_release (pubkey);
504     }
505   ath_mutex_unlock (&pubkeys_registered_lock);
506
507   return nsig;
508 }
509
510 /****************
511  * Return the number of encryption material numbers
512  */
513 static int
514 pubkey_get_nenc (int algorithm)
515 {
516   gcry_module_t pubkey;
517   int nenc = 0;
518
519   REGISTER_DEFAULT_PUBKEYS;
520
521   ath_mutex_lock (&pubkeys_registered_lock);
522   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
523   if (pubkey)
524     {
525       nenc = strlen (((gcry_pk_spec_t *) pubkey->spec)->elements_enc);
526       _gcry_module_release (pubkey);
527     }
528   ath_mutex_unlock (&pubkeys_registered_lock);
529
530   return nenc;
531 }
532
533
534 /* Generate a new public key with algorithm ALGORITHM of size NBITS
535    and return it at SKEY.  USE_E depends on the ALGORITHM.  GENPARMS
536    is passed to the algorithm module if it features an extended
537    generation function.  RETFACTOR is used by some algorithms to
538    return certain additional information which are in general not
539    required.
540
541    The function returns the error code number or 0 on success. */
542 static gcry_err_code_t
543 pubkey_generate (int algorithm,
544                  unsigned int nbits,
545                  unsigned long use_e,
546                  gcry_sexp_t genparms,
547                  gcry_mpi_t *skey, gcry_mpi_t **retfactors,
548                  gcry_sexp_t *r_extrainfo)
549 {
550   gcry_err_code_t ec = GPG_ERR_PUBKEY_ALGO;
551   gcry_module_t pubkey;
552
553   REGISTER_DEFAULT_PUBKEYS;
554
555   ath_mutex_lock (&pubkeys_registered_lock);
556   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
557   if (pubkey)
558     {
559       pk_extra_spec_t *extraspec = pubkey->extraspec;
560
561       if (extraspec && extraspec->ext_generate)
562         {
563           /* Use the extended generate function.  */
564           ec = extraspec->ext_generate
565             (algorithm, nbits, use_e, genparms, skey, retfactors, r_extrainfo);
566         }
567       else
568         {
569           /* Use the standard generate function.  */
570           ec = ((gcry_pk_spec_t *) pubkey->spec)->generate
571             (algorithm, nbits, use_e, skey, retfactors);
572         }
573       _gcry_module_release (pubkey);
574     }
575   ath_mutex_unlock (&pubkeys_registered_lock);
576
577   return ec;
578 }
579
580
581 static gcry_err_code_t
582 pubkey_check_secret_key (int algorithm, gcry_mpi_t *skey)
583 {
584   gcry_err_code_t err = GPG_ERR_PUBKEY_ALGO;
585   gcry_module_t pubkey;
586
587   REGISTER_DEFAULT_PUBKEYS;
588
589   ath_mutex_lock (&pubkeys_registered_lock);
590   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
591   if (pubkey)
592     {
593       err = ((gcry_pk_spec_t *) pubkey->spec)->check_secret_key
594         (algorithm, skey);
595       _gcry_module_release (pubkey);
596     }
597   ath_mutex_unlock (&pubkeys_registered_lock);
598
599   return err;
600 }
601
602
603 /****************
604  * This is the interface to the public key encryption.  Encrypt DATA
605  * with PKEY and put it into RESARR which should be an array of MPIs
606  * of size PUBKEY_MAX_NENC (or less if the algorithm allows this -
607  * check with pubkey_get_nenc() )
608  */
609 static gcry_err_code_t
610 pubkey_encrypt (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
611                 gcry_mpi_t *pkey, int flags)
612 {
613   gcry_pk_spec_t *pubkey;
614   gcry_module_t module;
615   gcry_err_code_t rc;
616   int i;
617
618   /* Note: In fips mode DBG_CIPHER will enver evaluate to true but as
619      an extra failsafe protection we explicitly test for fips mode
620      here. */
621   if (DBG_CIPHER && !fips_mode ())
622     {
623       log_debug ("pubkey_encrypt: algo=%d\n", algorithm);
624       for(i = 0; i < pubkey_get_npkey (algorithm); i++)
625         log_mpidump ("  pkey:", pkey[i]);
626       log_mpidump ("  data:", data);
627     }
628
629   ath_mutex_lock (&pubkeys_registered_lock);
630   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
631   if (module)
632     {
633       pubkey = (gcry_pk_spec_t *) module->spec;
634       rc = pubkey->encrypt (algorithm, resarr, data, pkey, flags);
635       _gcry_module_release (module);
636       goto ready;
637     }
638   rc = GPG_ERR_PUBKEY_ALGO;
639
640  ready:
641   ath_mutex_unlock (&pubkeys_registered_lock);
642
643   if (!rc && DBG_CIPHER && !fips_mode ())
644     {
645       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
646         log_mpidump("  encr:", resarr[i] );
647     }
648   return rc;
649 }
650
651
652 /****************
653  * This is the interface to the public key decryption.
654  * ALGO gives the algorithm to use and this implicitly determines
655  * the size of the arrays.
656  * result is a pointer to a mpi variable which will receive a
657  * newly allocated mpi or NULL in case of an error.
658  */
659 static gcry_err_code_t
660 pubkey_decrypt (int algorithm, gcry_mpi_t *result, gcry_mpi_t *data,
661                 gcry_mpi_t *skey, int flags)
662 {
663   gcry_pk_spec_t *pubkey;
664   gcry_module_t module;
665   gcry_err_code_t rc;
666   int i;
667
668   *result = NULL; /* so the caller can always do a mpi_free */
669   if (DBG_CIPHER && !fips_mode ())
670     {
671       log_debug ("pubkey_decrypt: algo=%d\n", algorithm);
672       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
673         log_mpidump ("  skey:", skey[i]);
674       for(i = 0; i < pubkey_get_nenc (algorithm); i++)
675         log_mpidump ("  data:", data[i]);
676     }
677
678   ath_mutex_lock (&pubkeys_registered_lock);
679   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
680   if (module)
681     {
682       pubkey = (gcry_pk_spec_t *) module->spec;
683       rc = pubkey->decrypt (algorithm, result, data, skey, flags);
684       _gcry_module_release (module);
685       goto ready;
686     }
687
688   rc = GPG_ERR_PUBKEY_ALGO;
689
690  ready:
691   ath_mutex_unlock (&pubkeys_registered_lock);
692
693   if (!rc && DBG_CIPHER && !fips_mode ())
694     log_mpidump (" plain:", *result);
695
696   return rc;
697 }
698
699
700 /****************
701  * This is the interface to the public key signing.
702  * Sign data with skey and put the result into resarr which
703  * should be an array of MPIs of size PUBKEY_MAX_NSIG (or less if the
704  * algorithm allows this - check with pubkey_get_nsig() )
705  */
706 static gcry_err_code_t
707 pubkey_sign (int algorithm, gcry_mpi_t *resarr, gcry_mpi_t data,
708              gcry_mpi_t *skey)
709 {
710   gcry_pk_spec_t *pubkey;
711   gcry_module_t module;
712   gcry_err_code_t rc;
713   int i;
714
715   if (DBG_CIPHER && !fips_mode ())
716     {
717       log_debug ("pubkey_sign: algo=%d\n", algorithm);
718       for(i = 0; i < pubkey_get_nskey (algorithm); i++)
719         log_mpidump ("  skey:", skey[i]);
720       log_mpidump("  data:", data );
721     }
722
723   ath_mutex_lock (&pubkeys_registered_lock);
724   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
725   if (module)
726     {
727       pubkey = (gcry_pk_spec_t *) module->spec;
728       rc = pubkey->sign (algorithm, resarr, data, skey);
729       _gcry_module_release (module);
730       goto ready;
731     }
732
733   rc = GPG_ERR_PUBKEY_ALGO;
734
735  ready:
736   ath_mutex_unlock (&pubkeys_registered_lock);
737
738   if (!rc && DBG_CIPHER && !fips_mode ())
739     for (i = 0; i < pubkey_get_nsig (algorithm); i++)
740       log_mpidump ("   sig:", resarr[i]);
741
742   return rc;
743 }
744
745 /****************
746  * Verify a public key signature.
747  * Return 0 if the signature is good
748  */
749 static gcry_err_code_t
750 pubkey_verify (int algorithm, gcry_mpi_t hash, gcry_mpi_t *data,
751                gcry_mpi_t *pkey,
752                int (*cmp)(void *, gcry_mpi_t), void *opaquev)
753 {
754   gcry_pk_spec_t *pubkey;
755   gcry_module_t module;
756   gcry_err_code_t rc;
757   int i;
758
759   if (DBG_CIPHER && !fips_mode ())
760     {
761       log_debug ("pubkey_verify: algo=%d\n", algorithm);
762       for (i = 0; i < pubkey_get_npkey (algorithm); i++)
763         log_mpidump ("  pkey", pkey[i]);
764       for (i = 0; i < pubkey_get_nsig (algorithm); i++)
765         log_mpidump ("   sig", data[i]);
766       log_mpidump ("  hash", hash);
767     }
768
769   ath_mutex_lock (&pubkeys_registered_lock);
770   module = _gcry_module_lookup_id (pubkeys_registered, algorithm);
771   if (module)
772     {
773       pubkey = (gcry_pk_spec_t *) module->spec;
774       rc = pubkey->verify (algorithm, hash, data, pkey, cmp, opaquev);
775       _gcry_module_release (module);
776       goto ready;
777     }
778
779   rc = GPG_ERR_PUBKEY_ALGO;
780
781  ready:
782   ath_mutex_unlock (&pubkeys_registered_lock);
783   return rc;
784 }
785
786
787 /* Turn VALUE into an octet string and store it in an allocated buffer
788    at R_FRAME or - if R_RAME is NULL - copy it into the caller
789    provided buffer SPACE; either SPACE or R_FRAME may be used.  If
790    SPACE if not NULL, the caller must provide a buffer of at least
791    NBYTES.  If the resulting octet string is shorter than NBYTES pad
792    it to the left with zeroes.  If VALUE does not fit into NBYTES
793    return an error code.  */
794 static gpg_err_code_t
795 octet_string_from_mpi (unsigned char **r_frame, void *space,
796                        gcry_mpi_t value, size_t nbytes)
797 {
798   gpg_err_code_t rc;
799   size_t nframe, noff, n;
800   unsigned char *frame;
801
802   if (!r_frame == !space)
803     return GPG_ERR_INV_ARG;  /* Only one may be used.  */
804
805   if (r_frame)
806     *r_frame = NULL;
807
808   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
809                                       NULL, 0, &nframe, value));
810   if (rc)
811     return rc;
812   if (nframe > nbytes)
813     return GPG_ERR_TOO_LARGE; /* Value too long to fit into NBYTES.  */
814
815   noff = (nframe < nbytes)? nbytes - nframe : 0;
816   n = nframe + noff;
817   if (space)
818     frame = space;
819   else
820     {
821       frame = mpi_is_secure (value)? gcry_malloc_secure (n) : gcry_malloc (n);
822       if (!frame)
823         {
824           rc = gpg_err_code_from_syserror ();
825           return rc;
826         }
827     }
828   if (noff)
829     memset (frame, 0, noff);
830   nframe += noff;
831   rc = gcry_err_code (gcry_mpi_print (GCRYMPI_FMT_USG,
832                                       frame+noff, nframe-noff, NULL, value));
833   if (rc)
834     {
835       gcry_free (frame);
836       return rc;
837     }
838
839   if (r_frame)
840     *r_frame = frame;
841   return 0;
842 }
843
844
845 /* Encode {VALUE,VALUELEN} for an NBITS keys using the pkcs#1 block
846    type 2 padding.  On sucess the result is stored as a new MPI at
847    R_RESULT.  On error the value at R_RESULT is undefined.
848
849    We encode the value in this way:
850
851      0  2  RND(n bytes)  0  VALUE
852
853    0   is a marker we unfortunately can't encode because we return an
854        MPI which strips all leading zeroes.
855    2   is the block type.
856    RND are non-zero random bytes.
857
858    (Note that OpenPGP includes the cipher algorithm and a checksum in
859    VALUE; the caller needs to prepare the value accordingly.)
860   */
861 static gcry_err_code_t
862 pkcs1_encode_for_encryption (gcry_mpi_t *r_result, unsigned int nbits,
863                              const unsigned char *value, size_t valuelen)
864 {
865   gcry_err_code_t rc = 0;
866   gcry_error_t err;
867   unsigned char *frame = NULL;
868   size_t nframe = (nbits+7) / 8;
869   int i;
870   size_t n;
871   unsigned char *p;
872
873   if (valuelen + 7 > nframe || !nframe)
874     {
875       /* Can't encode a VALUELEN value in a NFRAME bytes frame.  */
876       return GPG_ERR_TOO_SHORT; /* The key is too short.  */
877     }
878
879   if ( !(frame = gcry_malloc_secure (nframe)))
880     return gpg_err_code_from_syserror ();
881
882   n = 0;
883   frame[n++] = 0;
884   frame[n++] = 2; /* block type */
885   i = nframe - 3 - valuelen;
886   gcry_assert (i > 0);
887   p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
888   /* Replace zero bytes by new values. */
889   for (;;)
890     {
891       int j, k;
892       unsigned char *pp;
893
894       /* Count the zero bytes. */
895       for (j=k=0; j < i; j++)
896         {
897           if (!p[j])
898             k++;
899         }
900       if (!k)
901         break; /* Okay: no (more) zero bytes. */
902
903       k += k/128 + 3; /* Better get some more. */
904       pp = gcry_random_bytes_secure (k, GCRY_STRONG_RANDOM);
905       for (j=0; j < i && k; )
906         {
907           if (!p[j])
908             p[j] = pp[--k];
909           if (p[j])
910             j++;
911         }
912       gcry_free (pp);
913     }
914   memcpy (frame+n, p, i);
915   n += i;
916   gcry_free (p);
917
918   frame[n++] = 0;
919   memcpy (frame+n, value, valuelen);
920   n += valuelen;
921   gcry_assert (n == nframe);
922
923   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, n, &nframe);
924   if (err)
925     rc = gcry_err_code (err);
926   else if (DBG_CIPHER)
927     log_mpidump ("PKCS#1 block type 2 encoded data", *r_result);
928   gcry_free (frame);
929
930   return rc;
931 }
932
933
934 /* Decode a plaintext in VALUE assuming pkcs#1 block type 2 padding.
935    NBITS is the size of the secret key.  On success the result is
936    stored as a newly allocated buffer at R_RESULT and its valid length at
937    R_RESULTLEN.  On error NULL is stored at R_RESULT.  */
938 static gcry_err_code_t
939 pkcs1_decode_for_encryption (unsigned char **r_result, size_t *r_resultlen,
940                              unsigned int nbits, gcry_mpi_t value)
941 {
942   gcry_error_t err;
943   unsigned char *frame = NULL;
944   size_t nframe = (nbits+7) / 8;
945   size_t n;
946
947   *r_result = NULL;
948
949   if ( !(frame = gcry_malloc_secure (nframe)))
950     return gpg_err_code_from_syserror ();
951
952   err = gcry_mpi_print (GCRYMPI_FMT_USG, frame, nframe, &n, value);
953   if (err)
954     {
955       gcry_free (frame);
956       return gcry_err_code (err);
957     }
958
959   nframe = n; /* Set NFRAME to the actual length.  */
960
961   /* FRAME = 0x00 || 0x02 || PS || 0x00 || M
962
963      pkcs#1 requires that the first byte is zero.  Our MPIs usually
964      strip leading zero bytes; thus we are not able to detect them.
965      However due to the way gcry_mpi_print is implemented we may see
966      leading zero bytes nevertheless.  We handle this by making the
967      first zero byte optional.  */
968   if (nframe < 4)
969     {
970       gcry_free (frame);
971       return GPG_ERR_ENCODING_PROBLEM;  /* Too short.  */
972     }
973   n = 0;
974   if (!frame[0])
975     n++;
976   if (frame[n++] != 0x02)
977     {
978       gcry_free (frame);
979       return GPG_ERR_ENCODING_PROBLEM;  /* Wrong block type.  */
980     }
981
982   /* Skip the non-zero random bytes and the terminating zero byte.  */
983   for (; n < nframe && frame[n] != 0x00; n++)
984     ;
985   if (n+1 >= nframe)
986     {
987       gcry_free (frame);
988       return GPG_ERR_ENCODING_PROBLEM; /* No zero byte.  */
989     }
990   n++; /* Skip the zero byte.  */
991
992   /* To avoid an extra allocation we reuse the frame buffer.  The only
993      caller of this function will anyway free the result soon.  */
994   memmove (frame, frame + n, nframe - n);
995   *r_result = frame;
996   *r_resultlen = nframe - n;
997
998   if (DBG_CIPHER)
999     log_printhex ("value extracted from PKCS#1 block type 2 encoded data:",
1000                   *r_result, *r_resultlen);
1001
1002   return 0;
1003 }
1004
1005
1006 /* Encode {VALUE,VALUELEN} for an NBITS keys and hash algorith ALGO
1007    using the pkcs#1 block type 1 padding.  On success the result is
1008    stored as a new MPI at R_RESULT.  On error the value at R_RESULT is
1009    undefined.
1010
1011    We encode the value in this way:
1012
1013      0  1  PAD(n bytes)  0  ASN(asnlen bytes) VALUE(valuelen bytes)
1014
1015    0   is a marker we unfortunately can't encode because we return an
1016        MPI which strips all leading zeroes.
1017    1   is the block type.
1018    PAD consists of 0xff bytes.
1019    0   marks the end of the padding.
1020    ASN is the DER encoding of the hash algorithm; along with the VALUE
1021        it yields a valid DER encoding.
1022
1023    (Note that PGP prior to version 2.3 encoded the message digest as:
1024       0   1   MD(16 bytes)   0   PAD(n bytes)   1
1025     The MD is always 16 bytes here because it's always MD5.  GnuPG
1026     does not not support pre-v2.3 signatures, but I'm including this
1027     comment so the information is easily found if needed.)
1028 */
1029 static gcry_err_code_t
1030 pkcs1_encode_for_signature (gcry_mpi_t *r_result, unsigned int nbits,
1031                             const unsigned char *value, size_t valuelen,
1032                             int algo)
1033 {
1034   gcry_err_code_t rc = 0;
1035   gcry_error_t err;
1036   byte asn[100];
1037   byte *frame = NULL;
1038   size_t nframe = (nbits+7) / 8;
1039   int i;
1040   size_t n;
1041   size_t asnlen, dlen;
1042
1043   asnlen = DIM(asn);
1044   dlen = gcry_md_get_algo_dlen (algo);
1045
1046   if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
1047     {
1048       /* We don't have yet all of the above algorithms.  */
1049       return GPG_ERR_NOT_IMPLEMENTED;
1050     }
1051
1052   if ( valuelen != dlen )
1053     {
1054       /* Hash value does not match the length of digest for
1055          the given algorithm.  */
1056       return GPG_ERR_CONFLICT;
1057     }
1058
1059   if ( !dlen || dlen + asnlen + 4 > nframe)
1060     {
1061       /* Can't encode an DLEN byte digest MD into an NFRAME byte
1062          frame.  */
1063       return GPG_ERR_TOO_SHORT;
1064     }
1065
1066   if ( !(frame = gcry_malloc (nframe)) )
1067     return gpg_err_code_from_syserror ();
1068
1069   /* Assemble the pkcs#1 block type 1. */
1070   n = 0;
1071   frame[n++] = 0;
1072   frame[n++] = 1; /* block type */
1073   i = nframe - valuelen - asnlen - 3 ;
1074   gcry_assert (i > 1);
1075   memset (frame+n, 0xff, i );
1076   n += i;
1077   frame[n++] = 0;
1078   memcpy (frame+n, asn, asnlen);
1079   n += asnlen;
1080   memcpy (frame+n, value, valuelen );
1081   n += valuelen;
1082   gcry_assert (n == nframe);
1083
1084   /* Convert it into an MPI. */
1085   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, n, &nframe);
1086   if (err)
1087     rc = gcry_err_code (err);
1088   else if (DBG_CIPHER)
1089     log_mpidump ("PKCS#1 block type 1 encoded data", *r_result);
1090   gcry_free (frame);
1091
1092   return rc;
1093 }
1094
1095
1096 /* Mask generation function for OAEP.  See RFC-3447 B.2.1.  */
1097 static gcry_err_code_t
1098 mgf1 (unsigned char *output, size_t outlen, unsigned char *seed, size_t seedlen,
1099       int algo)
1100 {
1101   size_t dlen, nbytes, n;
1102   int idx;
1103   gcry_md_hd_t hd;
1104   gcry_error_t err;
1105
1106   err = gcry_md_open (&hd, algo, 0);
1107   if (err)
1108     return gpg_err_code (err);
1109
1110   dlen = gcry_md_get_algo_dlen (algo);
1111
1112   /* We skip step 1 which would be assert(OUTLEN <= 2^32).  The loop
1113      in step 3 is merged with step 4 by concatenating no more octets
1114      than what would fit into OUTPUT.  The ceiling for the counter IDX
1115      is implemented indirectly.  */
1116   nbytes = 0;  /* Step 2.  */
1117   idx = 0;
1118   while ( nbytes < outlen )
1119     {
1120       unsigned char c[4], *digest;
1121
1122       if (idx)
1123         gcry_md_reset (hd);
1124
1125       c[0] = (idx >> 24) & 0xFF;
1126       c[1] = (idx >> 16) & 0xFF;
1127       c[2] = (idx >> 8) & 0xFF;
1128       c[3] = idx & 0xFF;
1129       idx++;
1130
1131       gcry_md_write (hd, seed, seedlen);
1132       gcry_md_write (hd, c, 4);
1133       digest = gcry_md_read (hd, 0);
1134
1135       n = (outlen - nbytes < dlen)? (outlen - nbytes) : dlen;
1136       memcpy (output+nbytes, digest, n);
1137       nbytes += n;
1138     }
1139
1140   gcry_md_close (hd);
1141   return GPG_ERR_NO_ERROR;
1142 }
1143
1144
1145 /* RFC-3447 (pkcs#1 v2.1) OAEP encoding.  NBITS is the length of the
1146    key measured in bits.  ALGO is the hash function; it must be a
1147    valid and usable algorithm.  {VALUE,VALUELEN} is the message to
1148    encrypt.  {LABEL,LABELLEN} is the optional label to be associated
1149    with the message, if LABEL is NULL the default is to use the empty
1150    string as label.  On success the encoded ciphertext is returned at
1151    R_RESULT.
1152
1153    If {RANDOM_OVERRIDE, RANDOM_OVERRIDE_LEN} is given it is used as
1154    the seed instead of using a random string for it.  This feature is
1155    only useful for regression tests.
1156
1157    Here is figure 1 from the RFC depicting the process:
1158
1159                              +----------+---------+-------+
1160                         DB = |  lHash   |    PS   |   M   |
1161                              +----------+---------+-------+
1162                                             |
1163                   +----------+              V
1164                   |   seed   |--> MGF ---> xor
1165                   +----------+              |
1166                         |                   |
1167                +--+     V                   |
1168                |00|    xor <----- MGF <-----|
1169                +--+     |                   |
1170                  |      |                   |
1171                  V      V                   V
1172                +--+----------+----------------------------+
1173          EM =  |00|maskedSeed|          maskedDB          |
1174                +--+----------+----------------------------+
1175   */
1176 static gcry_err_code_t
1177 oaep_encode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1178              const unsigned char *value, size_t valuelen,
1179              const unsigned char *label, size_t labellen,
1180              const void *random_override, size_t random_override_len)
1181 {
1182   gcry_err_code_t rc = 0;
1183   gcry_error_t err;
1184   unsigned char *frame = NULL;
1185   size_t nframe = (nbits+7) / 8;
1186   unsigned char *p;
1187   size_t hlen;
1188   size_t n;
1189
1190   *r_result = NULL;
1191
1192   /* Set defaults for LABEL.  */
1193   if (!label || !labellen)
1194     {
1195       label = (const unsigned char*)"";
1196       labellen = 0;
1197     }
1198
1199   hlen = gcry_md_get_algo_dlen (algo);
1200
1201   /* We skip step 1a which would be to check that LABELLEN is not
1202      greater than 2^61-1.  See rfc-3447 7.1.1. */
1203
1204   /* Step 1b.  Note that the obsolete rfc-2437 uses the check:
1205      valuelen > nframe - 2 * hlen - 1 .  */
1206   if (valuelen > nframe - 2 * hlen - 2 || !nframe)
1207     {
1208       /* Can't encode a VALUELEN value in a NFRAME bytes frame. */
1209       return GPG_ERR_TOO_SHORT; /* The key is too short.  */
1210     }
1211
1212   /* Allocate the frame.  */
1213   frame = gcry_calloc_secure (1, nframe);
1214   if (!frame)
1215     return gpg_err_code_from_syserror ();
1216
1217   /* Step 2a: Compute the hash of the label.  We store it in the frame
1218      where later the maskedDB will commence.  */
1219   gcry_md_hash_buffer (algo, frame + 1 + hlen, label, labellen);
1220
1221   /* Step 2b: Set octet string to zero.  */
1222   /* This has already been done while allocating FRAME.  */
1223
1224   /* Step 2c: Create DB by concatenating lHash, PS, 0x01 and M.  */
1225   n = nframe - valuelen - 1;
1226   frame[n] = 0x01;
1227   memcpy (frame + n + 1, value, valuelen);
1228
1229   /* Step 3d: Generate seed.  We store it where the maskedSeed will go
1230      later. */
1231   if (random_override)
1232     {
1233       if (random_override_len != hlen)
1234         {
1235           gcry_free (frame);
1236           return GPG_ERR_INV_ARG;
1237         }
1238       memcpy (frame + 1, random_override, hlen);
1239     }
1240   else
1241     gcry_randomize (frame + 1, hlen, GCRY_STRONG_RANDOM);
1242
1243   /* Step 2e and 2f: Create maskedDB.  */
1244   {
1245     unsigned char *dmask;
1246
1247     dmask = gcry_malloc_secure (nframe - hlen - 1);
1248     if (!dmask)
1249       {
1250         rc = gpg_err_code_from_syserror ();
1251         gcry_free (frame);
1252         return rc;
1253       }
1254     rc = mgf1 (dmask, nframe - hlen - 1, frame+1, hlen, algo);
1255     if (rc)
1256       {
1257         gcry_free (dmask);
1258         gcry_free (frame);
1259         return rc;
1260       }
1261     for (n = 1 + hlen, p = dmask; n < nframe; n++)
1262       frame[n] ^= *p++;
1263     gcry_free (dmask);
1264   }
1265
1266   /* Step 2g and 2h: Create maskedSeed.  */
1267   {
1268     unsigned char *smask;
1269
1270     smask = gcry_malloc_secure (hlen);
1271     if (!smask)
1272       {
1273         rc = gpg_err_code_from_syserror ();
1274         gcry_free (frame);
1275         return rc;
1276       }
1277     rc = mgf1 (smask, hlen, frame + 1 + hlen, nframe - hlen - 1, algo);
1278     if (rc)
1279       {
1280         gcry_free (smask);
1281         gcry_free (frame);
1282         return rc;
1283       }
1284     for (n = 1, p = smask; n < 1 + hlen; n++)
1285       frame[n] ^= *p++;
1286     gcry_free (smask);
1287   }
1288
1289   /* Step 2i: Concatenate 0x00, maskedSeed and maskedDB.  */
1290   /* This has already been done by using in-place operations.  */
1291
1292   /* Convert the stuff into an MPI as expected by the caller.  */
1293   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, frame, nframe, NULL);
1294   if (err)
1295     rc = gcry_err_code (err);
1296   else if (DBG_CIPHER)
1297     log_mpidump ("OAEP encoded data", *r_result);
1298   gcry_free (frame);
1299
1300   return rc;
1301 }
1302
1303
1304 /* RFC-3447 (pkcs#1 v2.1) OAEP decoding.  NBITS is the length of the
1305    key measured in bits.  ALGO is the hash function; it must be a
1306    valid and usable algorithm.  VALUE is the raw decrypted message
1307    {LABEL,LABELLEN} is the optional label to be associated with the
1308    message, if LABEL is NULL the default is to use the empty string as
1309    label.  On success the plaintext is returned as a newly allocated
1310    buffer at R_RESULT; its valid length is stored at R_RESULTLEN.  On
1311    error NULL is stored at R_RESULT.  */
1312 static gcry_err_code_t
1313 oaep_decode (unsigned char **r_result, size_t *r_resultlen,
1314              unsigned int nbits, int algo,
1315              gcry_mpi_t value, const unsigned char *label, size_t labellen)
1316 {
1317   gcry_err_code_t rc;
1318   unsigned char *frame = NULL; /* Encoded messages (EM).  */
1319   unsigned char *masked_seed;  /* Points into FRAME.  */
1320   unsigned char *masked_db;    /* Points into FRAME.  */
1321   unsigned char *seed = NULL;  /* Allocated space for the seed and DB.  */
1322   unsigned char *db;           /* Points into SEED.  */
1323   unsigned char *lhash = NULL; /* Hash of the label.  */
1324   size_t nframe;               /* Length of the ciphertext (EM).  */
1325   size_t hlen;                 /* Length of the hash digest.  */
1326   size_t db_len;               /* Length of DB and masked_db.  */
1327   size_t nkey = (nbits+7)/8;   /* Length of the key in bytes.  */
1328   int failed = 0;              /* Error indicator.  */
1329   size_t n;
1330
1331   *r_result = NULL;
1332
1333   /* This code is implemented as described by rfc-3447 7.1.2.  */
1334
1335   /* Set defaults for LABEL.  */
1336   if (!label || !labellen)
1337     {
1338       label = (const unsigned char*)"";
1339       labellen = 0;
1340     }
1341
1342   /* Get the length of the digest.  */
1343   hlen = gcry_md_get_algo_dlen (algo);
1344
1345   /* Hash the label right away.  */
1346   lhash = gcry_malloc (hlen);
1347   if (!lhash)
1348     return gpg_err_code_from_syserror ();
1349   gcry_md_hash_buffer (algo, lhash, label, labellen);
1350
1351   /* Turn the MPI into an octet string.  If the octet string is
1352      shorter than the key we pad it to the left with zeroes.  This may
1353      happen due to the leading zero in OAEP frames and due to the
1354      following random octets (seed^mask) which may have leading zero
1355      bytes.  This all is needed to cope with our leading zeroes
1356      suppressing MPI implementation.  The code implictly implements
1357      Step 1b (bail out if NFRAME != N).  */
1358   rc = octet_string_from_mpi (&frame, NULL, value, nkey);
1359   if (rc)
1360     {
1361       gcry_free (lhash);
1362       return GPG_ERR_ENCODING_PROBLEM;
1363     }
1364   nframe = nkey;
1365
1366   /* Step 1c: Check that the key is long enough.  */
1367   if ( nframe < 2 * hlen + 2 )
1368     {
1369       gcry_free (frame);
1370       gcry_free (lhash);
1371       return GPG_ERR_ENCODING_PROBLEM;
1372     }
1373
1374   /* Step 2 has already been done by the caller and the
1375      gcry_mpi_aprint above.  */
1376
1377   /* Allocate space for SEED and DB.  */
1378   seed = gcry_malloc_secure (nframe - 1);
1379   if (!seed)
1380     {
1381       rc = gpg_err_code_from_syserror ();
1382       gcry_free (frame);
1383       gcry_free (lhash);
1384       return rc;
1385     }
1386   db = seed + hlen;
1387
1388   /* To avoid choosen ciphertext attacks from now on we make sure to
1389      run all code even in the error case; this avoids possible timing
1390      attacks as described by Manger.  */
1391
1392   /* Step 3a: Hash the label.  */
1393   /* This has already been done.  */
1394
1395   /* Step 3b: Separate the encoded message.  */
1396   masked_seed = frame + 1;
1397   masked_db   = frame + 1 + hlen;
1398   db_len      = nframe - 1 - hlen;
1399
1400   /* Step 3c and 3d: seed = maskedSeed ^ mgf(maskedDB, hlen).  */
1401   if (mgf1 (seed, hlen, masked_db, db_len, algo))
1402     failed = 1;
1403   for (n = 0; n < hlen; n++)
1404     seed[n] ^= masked_seed[n];
1405
1406   /* Step 3e and 3f: db = maskedDB ^ mgf(seed, db_len).  */
1407   if (mgf1 (db, db_len, seed, hlen, algo))
1408     failed = 1;
1409   for (n = 0; n < db_len; n++)
1410     db[n] ^= masked_db[n];
1411
1412   /* Step 3g: Check lhash, an possible empty padding string terminated
1413      by 0x01 and the first byte of EM being 0.  */
1414   if (memcmp (lhash, db, hlen))
1415     failed = 1;
1416   for (n = hlen; n < db_len; n++)
1417     if (db[n] == 0x01)
1418       break;
1419   if (n == db_len)
1420     failed = 1;
1421   if (frame[0])
1422     failed = 1;
1423
1424   gcry_free (lhash);
1425   gcry_free (frame);
1426   if (failed)
1427     {
1428       gcry_free (seed);
1429       return GPG_ERR_ENCODING_PROBLEM;
1430     }
1431
1432   /* Step 4: Output M.  */
1433   /* To avoid an extra allocation we reuse the seed buffer.  The only
1434      caller of this function will anyway free the result soon.  */
1435   n++;
1436   memmove (seed, db + n, db_len - n);
1437   *r_result = seed;
1438   *r_resultlen = db_len - n;
1439   seed = NULL;
1440
1441   if (DBG_CIPHER)
1442     log_printhex ("value extracted from OAEP encoded data:",
1443                   *r_result, *r_resultlen);
1444
1445   return 0;
1446 }
1447
1448
1449 /* RFC-3447 (pkcs#1 v2.1) PSS encoding.  Encode {VALUE,VALUELEN} for
1450    an NBITS key.  Note that VALUE is already the mHash from the
1451    picture below.  ALGO is a valid hash algorithm and SALTLEN is the
1452    length of salt to be used.  On success the result is stored as a
1453    new MPI at R_RESULT.  On error the value at R_RESULT is undefined.
1454
1455    If {RANDOM_OVERRIDE, RANDOM_OVERRIDE_LEN} is given it is used as
1456    the salt instead of using a random string for the salt.  This
1457    feature is only useful for regression tests.
1458
1459    Here is figure 2 from the RFC (errata 595 applied) depicting the
1460    process:
1461
1462                                   +-----------+
1463                                   |     M     |
1464                                   +-----------+
1465                                         |
1466                                         V
1467                                       Hash
1468                                         |
1469                                         V
1470                           +--------+----------+----------+
1471                      M' = |Padding1|  mHash   |   salt   |
1472                           +--------+----------+----------+
1473                                          |
1474                +--------+----------+     V
1475          DB =  |Padding2| salt     |   Hash
1476                +--------+----------+     |
1477                          |               |
1478                          V               |    +----+
1479                         xor <--- MGF <---|    |0xbc|
1480                          |               |    +----+
1481                          |               |      |
1482                          V               V      V
1483                +-------------------+----------+----+
1484          EM =  |    maskedDB       |     H    |0xbc|
1485                +-------------------+----------+----+
1486
1487   */
1488 static gcry_err_code_t
1489 pss_encode (gcry_mpi_t *r_result, unsigned int nbits, int algo,
1490             const unsigned char *value, size_t valuelen, int saltlen,
1491             const void *random_override, size_t random_override_len)
1492 {
1493   gcry_err_code_t rc = 0;
1494   gcry_error_t err;
1495   size_t hlen;                 /* Length of the hash digest.  */
1496   unsigned char *em = NULL;    /* Encoded message.  */
1497   size_t emlen = (nbits+7)/8;  /* Length in bytes of EM.  */
1498   unsigned char *h;            /* Points into EM.  */
1499   unsigned char *buf = NULL;   /* Help buffer.  */
1500   size_t buflen;               /* Length of BUF.  */
1501   unsigned char *mhash;        /* Points into BUF.  */
1502   unsigned char *salt;         /* Points into BUF.  */
1503   unsigned char *dbmask;       /* Points into BUF.  */
1504   unsigned char *p;
1505   size_t n;
1506
1507   /* This code is implemented as described by rfc-3447 9.1.1.  */
1508
1509   /* Get the length of the digest.  */
1510   hlen = gcry_md_get_algo_dlen (algo);
1511   gcry_assert (hlen);  /* We expect a valid ALGO here.  */
1512
1513   /* Allocate a help buffer and setup some pointers.  */
1514   buflen = 8 + hlen + saltlen + (emlen - hlen - 1);
1515   buf = gcry_malloc (buflen);
1516   if (!buf)
1517     {
1518       rc = gpg_err_code_from_syserror ();
1519       goto leave;
1520     }
1521   mhash = buf + 8;
1522   salt  = mhash + hlen;
1523   dbmask= salt + saltlen;
1524
1525   /* Step 2: That would be: mHash = Hash(M) but our input is already
1526      mHash thus we do only a consistency check and copy to MHASH.  */
1527   if (valuelen != hlen)
1528     {
1529       rc = GPG_ERR_INV_LENGTH;
1530       goto leave;
1531     }
1532   memcpy (mhash, value, hlen);
1533
1534   /* Step 3: Check length constraints.  */
1535   if (emlen < hlen + saltlen + 2)
1536     {
1537       rc = GPG_ERR_TOO_SHORT;
1538       goto leave;
1539     }
1540
1541   /* Allocate space for EM.  */
1542   em = gcry_malloc (emlen);
1543   if (!em)
1544     {
1545       rc = gpg_err_code_from_syserror ();
1546       goto leave;
1547     }
1548   h = em + emlen - 1 - hlen;
1549
1550   /* Step 4: Create a salt.  */
1551   if (saltlen)
1552     {
1553       if (random_override)
1554         {
1555           if (random_override_len != saltlen)
1556             {
1557               rc = GPG_ERR_INV_ARG;
1558               goto leave;
1559             }
1560           memcpy (salt, random_override, saltlen);
1561         }
1562       else
1563         gcry_randomize (salt, saltlen, GCRY_STRONG_RANDOM);
1564     }
1565
1566   /* Step 5 and 6: M' = Hash(Padding1 || mHash || salt).  */
1567   memset (buf, 0, 8);  /* Padding.  */
1568   gcry_md_hash_buffer (algo, h, buf, 8 + hlen + saltlen);
1569
1570   /* Step 7 and 8: DB = PS || 0x01 || salt.  */
1571   /* Note that we use EM to store DB and later Xor in-place.  */
1572   p = em + emlen - 1 - hlen - saltlen - 1;
1573   memset (em, 0, p - em);
1574   *p++ = 0x01;
1575   memcpy (p, salt, saltlen);
1576
1577   /* Step 9: dbmask = MGF(H, emlen - hlen - 1).  */
1578   mgf1 (dbmask, emlen - hlen - 1, h, hlen, algo);
1579
1580   /* Step 10: maskedDB = DB ^ dbMask */
1581   for (n = 0, p = dbmask; n < emlen - hlen - 1; n++, p++)
1582     em[n] ^= *p;
1583
1584   /* Step 11: Set the leftmost bits to zero.  */
1585   em[0] &= 0xFF >> (8 * emlen - nbits);
1586
1587   /* Step 12: EM = maskedDB || H || 0xbc.  */
1588   em[emlen-1] = 0xbc;
1589
1590   /* Convert EM into an MPI.  */
1591   err = gcry_mpi_scan (r_result, GCRYMPI_FMT_USG, em, emlen, NULL);
1592   if (err)
1593     rc = gcry_err_code (err);
1594   else if (DBG_CIPHER)
1595     log_mpidump ("PSS encoded data", *r_result);
1596
1597  leave:
1598   if (em)
1599     {
1600       wipememory (em, emlen);
1601       gcry_free (em);
1602     }
1603   if (buf)
1604     {
1605       wipememory (buf, buflen);
1606       gcry_free (buf);
1607     }
1608   return rc;
1609 }
1610
1611
1612 /* Verify a signature assuming PSS padding.  VALUE is the hash of the
1613    message (mHash) encoded as an MPI; its length must match the digest
1614    length of ALGO.  ENCODED is the output of the RSA public key
1615    function (EM).  NBITS is the size of the public key.  ALGO is the
1616    hash algorithm and SALTLEN is the length of the used salt.  The
1617    function returns 0 on success or on error code.  */
1618 static gcry_err_code_t
1619 pss_verify (gcry_mpi_t value, gcry_mpi_t encoded, unsigned int nbits, int algo,
1620             size_t saltlen)
1621 {
1622   gcry_err_code_t rc = 0;
1623   size_t hlen;                 /* Length of the hash digest.  */
1624   unsigned char *em = NULL;    /* Encoded message.  */
1625   size_t emlen = (nbits+7)/8;  /* Length in bytes of EM.  */
1626   unsigned char *salt;         /* Points into EM.  */
1627   unsigned char *h;            /* Points into EM.  */
1628   unsigned char *buf = NULL;   /* Help buffer.  */
1629   size_t buflen;               /* Length of BUF.  */
1630   unsigned char *dbmask;       /* Points into BUF.  */
1631   unsigned char *mhash;        /* Points into BUF.  */
1632   unsigned char *p;
1633   size_t n;
1634
1635   /* This code is implemented as described by rfc-3447 9.1.2.  */
1636
1637   /* Get the length of the digest.  */
1638   hlen = gcry_md_get_algo_dlen (algo);
1639   gcry_assert (hlen);  /* We expect a valid ALGO here.  */
1640
1641   /* Allocate a help buffer and setup some pointers.
1642      This buffer is used for two purposes:
1643         +------------------------------+-------+
1644      1. | dbmask                       | mHash |
1645         +------------------------------+-------+
1646            emlen - hlen - 1              hlen
1647
1648         +----------+-------+---------+-+-------+
1649      2. | padding1 | mHash | salt    | | mHash |
1650         +----------+-------+---------+-+-------+
1651              8       hlen    saltlen     hlen
1652   */
1653   buflen = 8 + hlen + saltlen;
1654   if (buflen < emlen - hlen - 1)
1655     buflen = emlen - hlen - 1;
1656   buflen += hlen;
1657   buf = gcry_malloc (buflen);
1658   if (!buf)
1659     {
1660       rc = gpg_err_code_from_syserror ();
1661       goto leave;
1662     }
1663   dbmask = buf;
1664   mhash = buf + buflen - hlen;
1665
1666   /* Step 2: That would be: mHash = Hash(M) but our input is already
1667      mHash thus we only need to convert VALUE into MHASH.  */
1668   rc = octet_string_from_mpi (NULL, mhash, value, hlen);
1669   if (rc)
1670     goto leave;
1671
1672   /* Convert the signature into an octet string.  */
1673   rc = octet_string_from_mpi (&em, NULL, encoded, emlen);
1674   if (rc)
1675     goto leave;
1676
1677   /* Step 3: Check length of EM.  Because we internally use MPI
1678      functions we can't do this properly; EMLEN is always the length
1679      of the key because octet_string_from_mpi needs to left pad the
1680      result with zero to cope with the fact that our MPIs suppress all
1681      leading zeroes.  Thus what we test here are merely the digest and
1682      salt lengths to the key.  */
1683   if (emlen < hlen + saltlen + 2)
1684     {
1685       rc = GPG_ERR_TOO_SHORT; /* For the hash and saltlen.  */
1686       goto leave;
1687     }
1688
1689   /* Step 4: Check last octet.  */
1690   if (em[emlen - 1] != 0xbc)
1691     {
1692       rc = GPG_ERR_BAD_SIGNATURE;
1693       goto leave;
1694     }
1695
1696   /* Step 5: Split EM.  */
1697   h = em + emlen - 1 - hlen;
1698
1699   /* Step 6: Check the leftmost bits.  */
1700   if ((em[0] & ~(0xFF >> (8 * emlen - nbits))))
1701     {
1702       rc = GPG_ERR_BAD_SIGNATURE;
1703       goto leave;
1704     }
1705
1706   /* Step 7: dbmask = MGF(H, emlen - hlen - 1).  */
1707   mgf1 (dbmask, emlen - hlen - 1, h, hlen, algo);
1708
1709   /* Step 8: maskedDB = DB ^ dbMask.  */
1710   for (n = 0, p = dbmask; n < emlen - hlen - 1; n++, p++)
1711     em[n] ^= *p;
1712
1713   /* Step 9: Set leftmost bits in DB to zero.  */
1714   em[0] &= 0xFF >> (8 * emlen - nbits);
1715
1716   /* Step 10: Check the padding of DB.  */
1717   for (n = 0; n < emlen - hlen - saltlen - 2 && !em[n]; n++)
1718     ;
1719   if (n != emlen - hlen - saltlen - 2 || em[n++] != 1)
1720     {
1721       rc = GPG_ERR_BAD_SIGNATURE;
1722       goto leave;
1723     }
1724
1725   /* Step 11: Extract salt from DB.  */
1726   salt = em + n;
1727
1728   /* Step 12:  M' = (0x)00 00 00 00 00 00 00 00 || mHash || salt */
1729   memset (buf, 0, 8);
1730   memcpy (buf+8, mhash, hlen);
1731   memcpy (buf+8+hlen, salt, saltlen);
1732
1733   /* Step 13:  H' = Hash(M').  */
1734   gcry_md_hash_buffer (algo, buf, buf, 8 + hlen + saltlen);
1735
1736   /* Step 14:  Check H == H'.   */
1737   rc = memcmp (h, buf, hlen) ? GPG_ERR_BAD_SIGNATURE : GPG_ERR_NO_ERROR;
1738
1739  leave:
1740   if (em)
1741     {
1742       wipememory (em, emlen);
1743       gcry_free (em);
1744     }
1745   if (buf)
1746     {
1747       wipememory (buf, buflen);
1748       gcry_free (buf);
1749     }
1750   return rc;
1751 }
1752
1753
1754 /* Callback for the pubkey algorithm code to verify PSS signatures.
1755    OPAQUE is the data provided by the actual caller.  The meaning of
1756    TMP depends on the actual algorithm (but there is only RSA); now
1757    for RSA it is the output of running the public key function on the
1758    input.  */
1759 static int
1760 pss_verify_cmp (void *opaque, gcry_mpi_t tmp)
1761 {
1762   struct pk_encoding_ctx *ctx = opaque;
1763   gcry_mpi_t hash = ctx->verify_arg;
1764
1765   return pss_verify (hash, tmp, ctx->nbits - 1, ctx->hash_algo, ctx->saltlen);
1766 }
1767
1768
1769 /* Internal function.   */
1770 static gcry_err_code_t
1771 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
1772                        gcry_mpi_t *elements, const char *algo_name)
1773 {
1774   gcry_err_code_t err = 0;
1775   int i, idx;
1776   const char *name;
1777   gcry_sexp_t list;
1778
1779   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1780     {
1781       list = gcry_sexp_find_token (key_sexp, name, 1);
1782       if (!list)
1783         elements[idx] = NULL;
1784       else
1785         {
1786           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
1787           gcry_sexp_release (list);
1788           if (!elements[idx])
1789             err = GPG_ERR_INV_OBJ;
1790         }
1791     }
1792
1793   if (!err)
1794     {
1795       /* Check that all elements are available.  */
1796       for (name = element_names, idx = 0; *name; name++, idx++)
1797         if (!elements[idx])
1798           break;
1799       if (*name)
1800         {
1801           err = GPG_ERR_NO_OBJ;
1802           /* Some are missing.  Before bailing out we test for
1803              optional parameters.  */
1804           if (algo_name && !strcmp (algo_name, "RSA")
1805               && !strcmp (element_names, "nedpqu") )
1806             {
1807               /* This is RSA.  Test whether we got N, E and D and that
1808                  the optional P, Q and U are all missing.  */
1809               if (elements[0] && elements[1] && elements[2]
1810                   && !elements[3] && !elements[4] && !elements[5])
1811                 err = 0;
1812             }
1813         }
1814     }
1815
1816
1817   if (err)
1818     {
1819       for (i = 0; i < idx; i++)
1820         if (elements[i])
1821           gcry_free (elements[i]);
1822     }
1823   return err;
1824 }
1825
1826
1827 /* Internal function used for ecc.  Note, that this function makes use
1828    of its intimate knowledge about the ECC parameters from ecc.c. */
1829 static gcry_err_code_t
1830 sexp_elements_extract_ecc (gcry_sexp_t key_sexp, const char *element_names,
1831                            gcry_mpi_t *elements, pk_extra_spec_t *extraspec)
1832
1833 {
1834   gcry_err_code_t err = 0;
1835   int idx;
1836   const char *name;
1837   gcry_sexp_t list;
1838
1839   /* Clear the array for easier error cleanup. */
1840   for (name = element_names, idx = 0; *name; name++, idx++)
1841     elements[idx] = NULL;
1842   gcry_assert (idx >= 5); /* We know that ECC has at least 5 elements
1843                              (params only) or 6 (full public key).  */
1844   if (idx == 5)
1845     elements[5] = NULL;   /* Extra clear for the params only case.  */
1846
1847
1848   /* Init the array with the available curve parameters. */
1849   for (name = element_names, idx = 0; *name && !err; name++, idx++)
1850     {
1851       list = gcry_sexp_find_token (key_sexp, name, 1);
1852       if (!list)
1853         elements[idx] = NULL;
1854       else
1855         {
1856           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
1857           gcry_sexp_release (list);
1858           if (!elements[idx])
1859             {
1860               err = GPG_ERR_INV_OBJ;
1861               goto leave;
1862             }
1863         }
1864     }
1865
1866   /* Check whether a curve parameter has been given and then fill any
1867      missing elements.  */
1868   list = gcry_sexp_find_token (key_sexp, "curve", 5);
1869   if (list)
1870     {
1871       if (extraspec->get_param)
1872         {
1873           char *curve;
1874           gcry_mpi_t params[6];
1875
1876           for (idx = 0; idx < DIM(params); idx++)
1877             params[idx] = NULL;
1878
1879           curve = _gcry_sexp_nth_string (list, 1);
1880           gcry_sexp_release (list);
1881           if (!curve)
1882             {
1883               /* No curve name given (or out of core). */
1884               err = GPG_ERR_INV_OBJ;
1885               goto leave;
1886             }
1887           err = extraspec->get_param (curve, params);
1888           gcry_free (curve);
1889           if (err)
1890             goto leave;
1891
1892           for (idx = 0; idx < DIM(params); idx++)
1893             {
1894               if (!elements[idx])
1895                 elements[idx] = params[idx];
1896               else
1897                 mpi_free (params[idx]);
1898             }
1899         }
1900       else
1901         {
1902           gcry_sexp_release (list);
1903           err = GPG_ERR_INV_OBJ; /* "curve" given but ECC not supported. */
1904           goto leave;
1905         }
1906     }
1907
1908   /* Check that all parameters are known.  */
1909   for (name = element_names, idx = 0; *name; name++, idx++)
1910     if (!elements[idx])
1911       {
1912         err = GPG_ERR_NO_OBJ;
1913         goto leave;
1914       }
1915
1916  leave:
1917   if (err)
1918     {
1919       for (name = element_names, idx = 0; *name; name++, idx++)
1920         if (elements[idx])
1921           gcry_free (elements[idx]);
1922     }
1923   return err;
1924 }
1925
1926
1927
1928 /****************
1929  * Convert a S-Exp with either a private or a public key to our
1930  * internal format. Currently we do only support the following
1931  * algorithms:
1932  *    dsa
1933  *    rsa
1934  *    openpgp-dsa
1935  *    openpgp-rsa
1936  *    openpgp-elg
1937  *    openpgp-elg-sig
1938  *    ecdsa
1939  *    ecdh
1940  * Provide a SE with the first element be either "private-key" or
1941  * or "public-key". It is followed by a list with its first element
1942  * be one of the above algorithm identifiers and the remaning
1943  * elements are pairs with parameter-id and value.
1944  * NOTE: we look through the list to find a list beginning with
1945  * "private-key" or "public-key" - the first one found is used.
1946  *
1947  * If OVERRIDE_ELEMS is not NULL those elems override the parameter
1948  * specification taken from the module.  This ise used by
1949  * gcry_pk_get_curve.
1950  *
1951  * Returns: A pointer to an allocated array of MPIs if the return value is
1952  *          zero; the caller has to release this array.
1953  *
1954  * Example of a DSA public key:
1955  *  (private-key
1956  *    (dsa
1957  *      (p <mpi>)
1958  *      (g <mpi>)
1959  *      (y <mpi>)
1960  *      (x <mpi>)
1961  *    )
1962  *  )
1963  * The <mpi> are expected to be in GCRYMPI_FMT_USG
1964  */
1965 static gcry_err_code_t
1966 sexp_to_key (gcry_sexp_t sexp, int want_private, const char *override_elems,
1967              gcry_mpi_t **retarray, gcry_module_t *retalgo)
1968 {
1969   gcry_err_code_t err = 0;
1970   gcry_sexp_t list, l2;
1971   char *name;
1972   const char *elems;
1973   gcry_mpi_t *array;
1974   gcry_module_t module;
1975   gcry_pk_spec_t *pubkey;
1976   pk_extra_spec_t *extraspec;
1977   int is_ecc;
1978
1979   /* Check that the first element is valid.  */
1980   list = gcry_sexp_find_token (sexp,
1981                                want_private? "private-key":"public-key", 0);
1982   if (!list)
1983     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
1984
1985   l2 = gcry_sexp_cadr( list );
1986   gcry_sexp_release ( list );
1987   list = l2;
1988   name = _gcry_sexp_nth_string (list, 0);
1989   if (!name)
1990     {
1991       gcry_sexp_release ( list );
1992       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
1993     }
1994
1995   ath_mutex_lock (&pubkeys_registered_lock);
1996   module = gcry_pk_lookup_name (name);
1997   ath_mutex_unlock (&pubkeys_registered_lock);
1998
1999   /* Fixme: We should make sure that an ECC key is always named "ecc"
2000      and not "ecdsa".  "ecdsa" should be used for the signature
2001      itself.  We need a function to test whether an algorithm given
2002      with a key is compatible with an application of the key (signing,
2003      encryption).  For RSA this is easy, but ECC is the first
2004      algorithm which has many flavours.  */
2005   is_ecc = ( !strcmp (name, "ecdsa")
2006              || !strcmp (name, "ecdh")
2007              || !strcmp (name, "ecc") );
2008   gcry_free (name);
2009
2010   if (!module)
2011     {
2012       gcry_sexp_release (list);
2013       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
2014     }
2015   else
2016     {
2017       pubkey = (gcry_pk_spec_t *) module->spec;
2018       extraspec = module->extraspec;
2019     }
2020
2021   if (override_elems)
2022     elems = override_elems;
2023   else if (want_private)
2024     elems = pubkey->elements_skey;
2025   else
2026     elems = pubkey->elements_pkey;
2027   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
2028   if (!array)
2029     err = gpg_err_code_from_syserror ();
2030   if (!err)
2031     {
2032       if (is_ecc)
2033         err = sexp_elements_extract_ecc (list, elems, array, extraspec);
2034       else
2035         err = sexp_elements_extract (list, elems, array, pubkey->name);
2036     }
2037
2038   gcry_sexp_release (list);
2039
2040   if (err)
2041     {
2042       gcry_free (array);
2043
2044       ath_mutex_lock (&pubkeys_registered_lock);
2045       _gcry_module_release (module);
2046       ath_mutex_unlock (&pubkeys_registered_lock);
2047     }
2048   else
2049     {
2050       *retarray = array;
2051       *retalgo = module;
2052     }
2053
2054   return err;
2055 }
2056
2057
2058 static gcry_err_code_t
2059 sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
2060              gcry_module_t *retalgo)
2061 {
2062   gcry_err_code_t err = 0;
2063   gcry_sexp_t list, l2;
2064   char *name;
2065   const char *elems;
2066   gcry_mpi_t *array;
2067   gcry_module_t module;
2068   gcry_pk_spec_t *pubkey;
2069
2070   /* Check that the first element is valid.  */
2071   list = gcry_sexp_find_token( sexp, "sig-val" , 0 );
2072   if (!list)
2073     return GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
2074
2075   l2 = gcry_sexp_nth (list, 1);
2076   if (!l2)
2077     {
2078       gcry_sexp_release (list);
2079       return GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
2080     }
2081   name = _gcry_sexp_nth_string (l2, 0);
2082   if (!name)
2083     {
2084       gcry_sexp_release (list);
2085       gcry_sexp_release (l2);
2086       return GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
2087     }
2088   else if (!strcmp (name, "flags"))
2089     {
2090       /* Skip flags, since they are not used but here just for the
2091          sake of consistent S-expressions.  */
2092       gcry_free (name);
2093       gcry_sexp_release (l2);
2094       l2 = gcry_sexp_nth (list, 2);
2095       if (!l2)
2096         {
2097           gcry_sexp_release (list);
2098           return GPG_ERR_INV_OBJ;
2099         }
2100       name = _gcry_sexp_nth_string (l2, 0);
2101     }
2102
2103   ath_mutex_lock (&pubkeys_registered_lock);
2104   module = gcry_pk_lookup_name (name);
2105   ath_mutex_unlock (&pubkeys_registered_lock);
2106   gcry_free (name);
2107   name = NULL;
2108
2109   if (!module)
2110     {
2111       gcry_sexp_release (l2);
2112       gcry_sexp_release (list);
2113       return GPG_ERR_PUBKEY_ALGO;  /* Unknown algorithm. */
2114     }
2115   else
2116     pubkey = (gcry_pk_spec_t *) module->spec;
2117
2118   elems = pubkey->elements_sig;
2119   array = gcry_calloc (strlen (elems) + 1 , sizeof *array );
2120   if (!array)
2121     err = gpg_err_code_from_syserror ();
2122
2123   if (!err)
2124     err = sexp_elements_extract (list, elems, array, NULL);
2125
2126   gcry_sexp_release (l2);
2127   gcry_sexp_release (list);
2128
2129   if (err)
2130     {
2131       ath_mutex_lock (&pubkeys_registered_lock);
2132       _gcry_module_release (module);
2133       ath_mutex_unlock (&pubkeys_registered_lock);
2134
2135       gcry_free (array);
2136     }
2137   else
2138     {
2139       *retarray = array;
2140       *retalgo = module;
2141     }
2142
2143   return err;
2144 }
2145
2146 static inline int
2147 get_hash_algo (const char *s, size_t n)
2148 {
2149   static const struct { const char *name; int algo; } hashnames[] = {
2150     { "sha1",   GCRY_MD_SHA1 },
2151     { "md5",    GCRY_MD_MD5 },
2152     { "sha256", GCRY_MD_SHA256 },
2153     { "ripemd160", GCRY_MD_RMD160 },
2154     { "rmd160", GCRY_MD_RMD160 },
2155     { "sha384", GCRY_MD_SHA384 },
2156     { "sha512", GCRY_MD_SHA512 },
2157     { "sha224", GCRY_MD_SHA224 },
2158     { "md2",    GCRY_MD_MD2 },
2159     { "md4",    GCRY_MD_MD4 },
2160     { "tiger",  GCRY_MD_TIGER },
2161     { "haval",  GCRY_MD_HAVAL },
2162     { NULL, 0 }
2163   };
2164   int algo;
2165   int i;
2166
2167   for (i=0; hashnames[i].name; i++)
2168     {
2169       if ( strlen (hashnames[i].name) == n
2170            && !memcmp (hashnames[i].name, s, n))
2171         break;
2172     }
2173   if (hashnames[i].name)
2174     algo = hashnames[i].algo;
2175   else
2176     {
2177       /* In case of not listed or dynamically allocated hash
2178          algorithm we fall back to this somewhat slower
2179          method.  Further, it also allows to use OIDs as
2180          algorithm names. */
2181       char *tmpname;
2182
2183       tmpname = gcry_malloc (n+1);
2184       if (!tmpname)
2185         algo = 0;  /* Out of core - silently give up.  */
2186       else
2187         {
2188           memcpy (tmpname, s, n);
2189           tmpname[n] = 0;
2190           algo = gcry_md_map_name (tmpname);
2191           gcry_free (tmpname);
2192         }
2193     }
2194   return algo;
2195 }
2196
2197
2198 /****************
2199  * Take sexp and return an array of MPI as used for our internal decrypt
2200  * function.
2201  * s_data = (enc-val
2202  *           [(flags [raw, pkcs1, oaep, no-blinding])]
2203  *           [(hash-algo <algo>)]
2204  *           [(label <label>)]
2205  *            (<algo>
2206  *              (<param_name1> <mpi>)
2207  *              ...
2208  *              (<param_namen> <mpi>)
2209  *            ))
2210  * HASH-ALGO and LABEL are specific to OAEP.
2211  * RET_MODERN is set to true when at least an empty flags list has been found.
2212  * CTX is used to return encoding information; it may be NULL in which
2213  * case raw encoding is used.
2214  */
2215 static gcry_err_code_t
2216 sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, gcry_module_t *retalgo,
2217              int *ret_modern, int *flags, struct pk_encoding_ctx *ctx)
2218 {
2219   gcry_err_code_t err = 0;
2220   gcry_sexp_t list = NULL, l2 = NULL;
2221   gcry_pk_spec_t *pubkey = NULL;
2222   gcry_module_t module = NULL;
2223   char *name = NULL;
2224   size_t n;
2225   int parsed_flags = 0;
2226   const char *elems;
2227   gcry_mpi_t *array = NULL;
2228
2229   *ret_modern = 0;
2230
2231   /* Check that the first element is valid.  */
2232   list = gcry_sexp_find_token (sexp, "enc-val" , 0);
2233   if (!list)
2234     {
2235       err = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
2236       goto leave;
2237     }
2238
2239   l2 = gcry_sexp_nth (list, 1);
2240   if (!l2)
2241     {
2242       err = GPG_ERR_NO_OBJ; /* No cdr for the data object.  */
2243       goto leave;
2244     }
2245
2246   /* Extract identifier of sublist.  */
2247   name = _gcry_sexp_nth_string (l2, 0);
2248   if (!name)
2249     {
2250       err = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
2251       goto leave;
2252     }
2253
2254   if (!strcmp (name, "flags"))
2255     {
2256       /* There is a flags element - process it.  */
2257       const char *s;
2258       int i;
2259
2260       *ret_modern = 1;
2261       for (i = gcry_sexp_length (l2) - 1; i > 0; i--)
2262         {
2263           s = gcry_sexp_nth_data (l2, i, &n);
2264           if (! s)
2265             ; /* Not a data element - ignore.  */
2266           else if (n == 3 && !memcmp (s, "raw", 3)
2267                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2268             ctx->encoding = PUBKEY_ENC_RAW;
2269           else if (n == 5 && !memcmp (s, "pkcs1", 5)
2270                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2271             ctx->encoding = PUBKEY_ENC_PKCS1;
2272           else if (n == 4 && !memcmp (s, "oaep", 4)
2273                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2274             ctx->encoding = PUBKEY_ENC_OAEP;
2275           else if (n == 3 && !memcmp (s, "pss", 3)
2276                    && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2277             {
2278               err = GPG_ERR_CONFLICT;
2279               goto leave;
2280             }
2281           else if (n == 11 && ! memcmp (s, "no-blinding", 11))
2282             parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
2283           else
2284             {
2285               err = GPG_ERR_INV_FLAG;
2286               goto leave;
2287             }
2288         }
2289       gcry_sexp_release (l2);
2290
2291       /* Get the OAEP parameters HASH-ALGO and LABEL, if any. */
2292       if (ctx->encoding == PUBKEY_ENC_OAEP)
2293         {
2294           /* Get HASH-ALGO. */
2295           l2 = gcry_sexp_find_token (list, "hash-algo", 0);
2296           if (l2)
2297             {
2298               s = gcry_sexp_nth_data (l2, 1, &n);
2299               if (!s)
2300                 err = GPG_ERR_NO_OBJ;
2301               else
2302                 {
2303                   ctx->hash_algo = get_hash_algo (s, n);
2304                   if (!ctx->hash_algo)
2305                     err = GPG_ERR_DIGEST_ALGO;
2306                 }
2307               gcry_sexp_release (l2);
2308               if (err)
2309                 goto leave;
2310             }
2311
2312           /* Get LABEL. */
2313           l2 = gcry_sexp_find_token (list, "label", 0);
2314           if (l2)
2315             {
2316               s = gcry_sexp_nth_data (l2, 1, &n);
2317               if (!s)
2318                 err = GPG_ERR_NO_OBJ;
2319               else if (n > 0)
2320                 {
2321                   ctx->label = gcry_malloc (n);
2322                   if (!ctx->label)
2323                     err = gpg_err_code_from_syserror ();
2324                   else
2325                     {
2326                       memcpy (ctx->label, s, n);
2327                       ctx->labellen = n;
2328                     }
2329                 }
2330               gcry_sexp_release (l2);
2331               if (err)
2332                 goto leave;
2333             }
2334         }
2335
2336       /* Get the next which has the actual data - skip HASH-ALGO and LABEL. */
2337       for (i = 2; (l2 = gcry_sexp_nth (list, i)) != NULL; i++)
2338         {
2339           s = gcry_sexp_nth_data (l2, 0, &n);
2340           if (!(n == 9 && !memcmp (s, "hash-algo", 9))
2341               && !(n == 5 && !memcmp (s, "label", 5)))
2342             break;
2343           gcry_sexp_release (l2);
2344         }
2345
2346       if (!l2)
2347         {
2348           err = GPG_ERR_NO_OBJ; /* No cdr for the data object. */
2349           goto leave;
2350         }
2351
2352       /* Extract sublist identifier.  */
2353       gcry_free (name);
2354       name = _gcry_sexp_nth_string (l2, 0);
2355       if (!name)
2356         {
2357           err = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
2358           goto leave;
2359         }
2360
2361       gcry_sexp_release (list);
2362       list = l2;
2363       l2 = NULL;
2364     }
2365
2366   ath_mutex_lock (&pubkeys_registered_lock);
2367   module = gcry_pk_lookup_name (name);
2368   ath_mutex_unlock (&pubkeys_registered_lock);
2369
2370   if (!module)
2371     {
2372       err = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
2373       goto leave;
2374     }
2375   pubkey = (gcry_pk_spec_t *) module->spec;
2376
2377   elems = pubkey->elements_enc;
2378   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
2379   if (!array)
2380     {
2381       err = gpg_err_code_from_syserror ();
2382       goto leave;
2383     }
2384
2385   err = sexp_elements_extract (list, elems, array, NULL);
2386
2387  leave:
2388   gcry_sexp_release (list);
2389   gcry_sexp_release (l2);
2390   gcry_free (name);
2391
2392   if (err)
2393     {
2394       ath_mutex_lock (&pubkeys_registered_lock);
2395       _gcry_module_release (module);
2396       ath_mutex_unlock (&pubkeys_registered_lock);
2397       gcry_free (array);
2398       gcry_free (ctx->label);
2399       ctx->label = NULL;
2400     }
2401   else
2402     {
2403       *retarray = array;
2404       *retalgo = module;
2405       *flags = parsed_flags;
2406     }
2407
2408   return err;
2409 }
2410
2411 /* Take the hash value and convert into an MPI, suitable for
2412    passing to the low level functions.  We currently support the
2413    old style way of passing just a MPI and the modern interface which
2414    allows to pass flags so that we can choose between raw and pkcs1
2415    padding - may be more padding options later.
2416
2417    (<mpi>)
2418    or
2419    (data
2420     [(flags [raw, pkcs1, oaep, pss, no-blinding])]
2421     [(hash <algo> <value>)]
2422     [(value <text>)]
2423     [(hash-algo <algo>)]
2424     [(label <label>)]
2425     [(salt-length <length>)]
2426     [(random-override <data>)]
2427    )
2428
2429    Either the VALUE or the HASH element must be present for use
2430    with signatures.  VALUE is used for encryption.
2431
2432    HASH-ALGO and LABEL are specific to OAEP.
2433
2434    SALT-LENGTH is for PSS.
2435
2436    RANDOM-OVERRIDE is used to replace random nonces in PSS for
2437    regression testing.
2438 */
2439 static gcry_err_code_t
2440 sexp_data_to_mpi (gcry_sexp_t input, gcry_mpi_t *ret_mpi,
2441                   struct pk_encoding_ctx *ctx)
2442 {
2443   gcry_err_code_t rc = 0;
2444   gcry_sexp_t ldata, lhash, lvalue;
2445   int i;
2446   size_t n;
2447   const char *s;
2448   int unknown_flag=0;
2449   int parsed_flags = 0;
2450
2451   *ret_mpi = NULL;
2452   ldata = gcry_sexp_find_token (input, "data", 0);
2453   if (!ldata)
2454     { /* assume old style */
2455       *ret_mpi = gcry_sexp_nth_mpi (input, 0, 0);
2456       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
2457     }
2458
2459   /* see whether there is a flags object */
2460   {
2461     gcry_sexp_t lflags = gcry_sexp_find_token (ldata, "flags", 0);
2462     if (lflags)
2463       { /* parse the flags list. */
2464         for (i=gcry_sexp_length (lflags)-1; i > 0; i--)
2465           {
2466             s = gcry_sexp_nth_data (lflags, i, &n);
2467             if (!s)
2468               ; /* not a data element*/
2469             else if ( n == 3 && !memcmp (s, "raw", 3)
2470                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2471               ctx->encoding = PUBKEY_ENC_RAW;
2472             else if ( n == 5 && !memcmp (s, "pkcs1", 5)
2473                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2474               ctx->encoding = PUBKEY_ENC_PKCS1;
2475             else if ( n == 4 && !memcmp (s, "oaep", 4)
2476                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2477               ctx->encoding = PUBKEY_ENC_OAEP;
2478             else if ( n == 3 && !memcmp (s, "pss", 3)
2479                       && ctx->encoding == PUBKEY_ENC_UNKNOWN)
2480               ctx->encoding = PUBKEY_ENC_PSS;
2481             else if (n == 11 && ! memcmp (s, "no-blinding", 11))
2482               parsed_flags |= PUBKEY_FLAG_NO_BLINDING;
2483             else
2484               unknown_flag = 1;
2485           }
2486         gcry_sexp_release (lflags);
2487       }
2488   }
2489
2490   if (ctx->encoding == PUBKEY_ENC_UNKNOWN)
2491     ctx->encoding = PUBKEY_ENC_RAW; /* default to raw */
2492
2493   /* Get HASH or MPI */
2494   lhash = gcry_sexp_find_token (ldata, "hash", 0);
2495   lvalue = lhash? NULL : gcry_sexp_find_token (ldata, "value", 0);
2496
2497   if (!(!lhash ^ !lvalue))
2498     rc = GPG_ERR_INV_OBJ; /* none or both given */
2499   else if (unknown_flag)
2500     rc = GPG_ERR_INV_FLAG;
2501   else if (ctx->encoding == PUBKEY_ENC_RAW && lvalue)
2502     {
2503       *ret_mpi = gcry_sexp_nth_mpi (lvalue, 1, 0);
2504       if (!*ret_mpi)
2505         rc = GPG_ERR_INV_OBJ;
2506     }
2507   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lvalue
2508            && ctx->op == PUBKEY_OP_ENCRYPT)
2509     {
2510       const void * value;
2511       size_t valuelen;
2512
2513       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
2514         rc = GPG_ERR_INV_OBJ;
2515       else
2516         rc = pkcs1_encode_for_encryption (ret_mpi, ctx->nbits, value, valuelen);
2517     }
2518   else if (ctx->encoding == PUBKEY_ENC_PKCS1 && lhash
2519            && (ctx->op == PUBKEY_OP_SIGN || ctx->op == PUBKEY_OP_VERIFY))
2520     {
2521       if (gcry_sexp_length (lhash) != 3)
2522         rc = GPG_ERR_INV_OBJ;
2523       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2524         rc = GPG_ERR_INV_OBJ;
2525       else
2526         {
2527           const void * value;
2528           size_t valuelen;
2529
2530           ctx->hash_algo = get_hash_algo (s, n);
2531
2532           if (!ctx->hash_algo)
2533             rc = GPG_ERR_DIGEST_ALGO;
2534           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
2535                     || !valuelen )
2536             rc = GPG_ERR_INV_OBJ;
2537           else
2538             rc = pkcs1_encode_for_signature (ret_mpi, ctx->nbits,
2539                                              value, valuelen,
2540                                              ctx->hash_algo);
2541         }
2542     }
2543   else if (ctx->encoding == PUBKEY_ENC_OAEP && lvalue
2544            && ctx->op == PUBKEY_OP_ENCRYPT)
2545     {
2546       const void * value;
2547       size_t valuelen;
2548
2549       if ( !(value=gcry_sexp_nth_data (lvalue, 1, &valuelen)) || !valuelen )
2550         rc = GPG_ERR_INV_OBJ;
2551       else
2552         {
2553           gcry_sexp_t list;
2554           void *random_override = NULL;
2555           size_t random_override_len = 0;
2556
2557           /* Get HASH-ALGO. */
2558           list = gcry_sexp_find_token (ldata, "hash-algo", 0);
2559           if (list)
2560             {
2561               s = gcry_sexp_nth_data (list, 1, &n);
2562               if (!s)
2563                 rc = GPG_ERR_NO_OBJ;
2564               else
2565                 {
2566                   ctx->hash_algo = get_hash_algo (s, n);
2567                   if (!ctx->hash_algo)
2568                     rc = GPG_ERR_DIGEST_ALGO;
2569                 }
2570               gcry_sexp_release (list);
2571               if (rc)
2572                 goto leave;
2573             }
2574
2575           /* Get LABEL. */
2576           list = gcry_sexp_find_token (ldata, "label", 0);
2577           if (list)
2578             {
2579               s = gcry_sexp_nth_data (list, 1, &n);
2580               if (!s)
2581                 rc = GPG_ERR_NO_OBJ;
2582               else if (n > 0)
2583                 {
2584                   ctx->label = gcry_malloc (n);
2585                   if (!ctx->label)
2586                     rc = gpg_err_code_from_syserror ();
2587                   else
2588                     {
2589                       memcpy (ctx->label, s, n);
2590                       ctx->labellen = n;
2591                     }
2592                 }
2593               gcry_sexp_release (list);
2594               if (rc)
2595                 goto leave;
2596             }
2597           /* Get optional RANDOM-OVERRIDE.  */
2598           list = gcry_sexp_find_token (ldata, "random-override", 0);
2599           if (list)
2600             {
2601               s = gcry_sexp_nth_data (list, 1, &n);
2602               if (!s)
2603                 rc = GPG_ERR_NO_OBJ;
2604               else if (n > 0)
2605                 {
2606                   random_override = gcry_malloc (n);
2607                   if (!random_override)
2608                     rc = gpg_err_code_from_syserror ();
2609                   else
2610                     {
2611                       memcpy (random_override, s, n);
2612                       random_override_len = n;
2613                     }
2614                 }
2615               gcry_sexp_release (list);
2616               if (rc)
2617                 goto leave;
2618             }
2619
2620           rc = oaep_encode (ret_mpi, ctx->nbits, ctx->hash_algo,
2621                             value, valuelen,
2622                             ctx->label, ctx->labellen,
2623                             random_override, random_override_len);
2624
2625           gcry_free (random_override);
2626         }
2627     }
2628   else if (ctx->encoding == PUBKEY_ENC_PSS && lhash
2629            && ctx->op == PUBKEY_OP_SIGN)
2630     {
2631       if (gcry_sexp_length (lhash) != 3)
2632         rc = GPG_ERR_INV_OBJ;
2633       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2634         rc = GPG_ERR_INV_OBJ;
2635       else
2636         {
2637           const void * value;
2638           size_t valuelen;
2639           void *random_override = NULL;
2640           size_t random_override_len = 0;
2641
2642           ctx->hash_algo = get_hash_algo (s, n);
2643
2644           if (!ctx->hash_algo)
2645             rc = GPG_ERR_DIGEST_ALGO;
2646           else if ( !(value=gcry_sexp_nth_data (lhash, 2, &valuelen))
2647                     || !valuelen )
2648             rc = GPG_ERR_INV_OBJ;
2649           else
2650             {
2651               gcry_sexp_t list;
2652
2653               /* Get SALT-LENGTH. */
2654               list = gcry_sexp_find_token (ldata, "salt-length", 0);
2655               if (list)
2656                 {
2657                   s = gcry_sexp_nth_data (list, 1, &n);
2658                   if (!s)
2659                     {
2660                       rc = GPG_ERR_NO_OBJ;
2661                       goto leave;
2662                     }
2663                   ctx->saltlen = (unsigned int)strtoul (s, NULL, 10);
2664                   gcry_sexp_release (list);
2665                 }
2666
2667               /* Get optional RANDOM-OVERRIDE.  */
2668               list = gcry_sexp_find_token (ldata, "random-override", 0);
2669               if (list)
2670                 {
2671                   s = gcry_sexp_nth_data (list, 1, &n);
2672                   if (!s)
2673                     rc = GPG_ERR_NO_OBJ;
2674                   else if (n > 0)
2675                     {
2676                       random_override = gcry_malloc (n);
2677                       if (!random_override)
2678                         rc = gpg_err_code_from_syserror ();
2679                       else
2680                         {
2681                           memcpy (random_override, s, n);
2682                           random_override_len = n;
2683                         }
2684                     }
2685                   gcry_sexp_release (list);
2686                   if (rc)
2687                     goto leave;
2688                 }
2689
2690               /* Encode the data.  */
2691               rc = pss_encode (ret_mpi, ctx->nbits - 1, ctx->hash_algo,
2692                                value, valuelen, ctx->saltlen,
2693                                random_override, random_override_len);
2694
2695               gcry_free (random_override);
2696             }
2697         }
2698     }
2699   else if (ctx->encoding == PUBKEY_ENC_PSS && lhash
2700            && ctx->op == PUBKEY_OP_VERIFY)
2701     {
2702       if (gcry_sexp_length (lhash) != 3)
2703         rc = GPG_ERR_INV_OBJ;
2704       else if ( !(s=gcry_sexp_nth_data (lhash, 1, &n)) || !n )
2705         rc = GPG_ERR_INV_OBJ;
2706       else
2707         {
2708           ctx->hash_algo = get_hash_algo (s, n);
2709
2710           if (!ctx->hash_algo)
2711             rc = GPG_ERR_DIGEST_ALGO;
2712           else
2713             {
2714               *ret_mpi = gcry_sexp_nth_mpi (lhash, 2, 0);
2715               if (!*ret_mpi)
2716                 rc = GPG_ERR_INV_OBJ;
2717               ctx->verify_cmp = pss_verify_cmp;
2718               ctx->verify_arg = *ret_mpi;
2719             }
2720         }
2721     }
2722   else
2723     rc = GPG_ERR_CONFLICT;
2724
2725  leave:
2726   gcry_sexp_release (ldata);
2727   gcry_sexp_release (lhash);
2728   gcry_sexp_release (lvalue);
2729
2730   if (!rc)
2731     ctx->flags = parsed_flags;
2732   else
2733     {
2734       gcry_free (ctx->label);
2735       ctx->label = NULL;
2736     }
2737
2738   return rc;
2739 }
2740
2741 static void
2742 init_encoding_ctx (struct pk_encoding_ctx *ctx, enum pk_operation op,
2743                    unsigned int nbits)
2744 {
2745   ctx->op = op;
2746   ctx->nbits = nbits;
2747   ctx->encoding = PUBKEY_ENC_UNKNOWN;
2748   ctx->flags = 0;
2749   ctx->hash_algo = GCRY_MD_SHA1;
2750   ctx->label = NULL;
2751   ctx->labellen = 0;
2752   ctx->saltlen = 20;
2753   ctx->verify_cmp = NULL;
2754   ctx->verify_arg = NULL;
2755 }
2756
2757
2758 /*
2759    Do a PK encrypt operation
2760
2761    Caller has to provide a public key as the SEXP pkey and data as a
2762    SEXP with just one MPI in it. Alternatively S_DATA might be a
2763    complex S-Expression, similar to the one used for signature
2764    verification.  This provides a flag which allows to handle PKCS#1
2765    block type 2 padding.  The function returns a a sexp which may be
2766    passed to to pk_decrypt.
2767
2768    Returns: 0 or an errorcode.
2769
2770    s_data = See comment for sexp_data_to_mpi
2771    s_pkey = <key-as-defined-in-sexp_to_key>
2772    r_ciph = (enc-val
2773                (<algo>
2774                  (<param_name1> <mpi>)
2775                  ...
2776                  (<param_namen> <mpi>)
2777                ))
2778
2779 */
2780 gcry_error_t
2781 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
2782 {
2783   gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
2784   const char *algo_name, *algo_elems;
2785   struct pk_encoding_ctx ctx;
2786   gcry_err_code_t rc;
2787   gcry_pk_spec_t *pubkey = NULL;
2788   gcry_module_t module = NULL;
2789
2790   *r_ciph = NULL;
2791
2792   REGISTER_DEFAULT_PUBKEYS;
2793
2794   /* Get the key. */
2795   rc = sexp_to_key (s_pkey, 0, NULL, &pkey, &module);
2796   if (rc)
2797     goto leave;
2798
2799   gcry_assert (module);
2800   pubkey = (gcry_pk_spec_t *) module->spec;
2801
2802   /* If aliases for the algorithm name exists, take the first one
2803      instead of the regular name to adhere to SPKI conventions.  We
2804      assume that the first alias name is the lowercase version of the
2805      regular one.  This change is required for compatibility with
2806      1.1.12 generated S-expressions. */
2807   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
2808   if (!algo_name || !*algo_name)
2809     algo_name = pubkey->name;
2810
2811   algo_elems = pubkey->elements_enc;
2812
2813   /* Get the stuff we want to encrypt. */
2814   init_encoding_ctx (&ctx, PUBKEY_OP_ENCRYPT, gcry_pk_get_nbits (s_pkey));
2815   rc = sexp_data_to_mpi (s_data, &data, &ctx);
2816   if (rc)
2817     goto leave;
2818
2819   /* Now we can encrypt DATA to CIPH. */
2820   ciph = gcry_calloc (strlen (algo_elems) + 1, sizeof (*ciph));
2821   if (!ciph)
2822     {
2823       rc = gpg_err_code_from_syserror ();
2824       goto leave;
2825     }
2826   rc = pubkey_encrypt (module->mod_id, ciph, data, pkey, ctx.flags);
2827   mpi_free (data);
2828   data = NULL;
2829   if (rc)
2830     goto leave;
2831
2832   /* We did it.  Now build the return list */
2833   {
2834     char *string, *p;
2835     int i;
2836     size_t nelem = strlen (algo_elems);
2837     size_t needed = 19 + strlen (algo_name) + (nelem * 5);
2838     void **arg_list;
2839
2840     /* Build the string.  */
2841     string = p = gcry_malloc (needed);
2842     if (!string)
2843       {
2844         rc = gpg_err_code_from_syserror ();
2845         goto leave;
2846       }
2847     p = stpcpy ( p, "(enc-val(" );
2848     p = stpcpy ( p, algo_name );
2849     for (i=0; algo_elems[i]; i++ )
2850       {
2851         *p++ = '(';
2852         *p++ = algo_elems[i];
2853         p = stpcpy ( p, "%m)" );
2854       }
2855     strcpy ( p, "))" );
2856
2857     /* And now the ugly part: We don't have a function to pass an
2858      * array to a format string, so we have to do it this way :-(.  */
2859     /* FIXME: There is now such a format specifier, so we can
2860        change the code to be more clear. */
2861     arg_list = malloc (nelem * sizeof *arg_list);
2862     if (!arg_list)
2863       {
2864         rc = gpg_err_code_from_syserror ();
2865         goto leave;
2866       }
2867
2868     for (i = 0; i < nelem; i++)
2869       arg_list[i] = ciph + i;
2870
2871     rc = gcry_sexp_build_array (r_ciph, NULL, string, arg_list);
2872     free (arg_list);
2873     if (rc)
2874       BUG ();
2875     gcry_free (string);
2876   }
2877
2878  leave:
2879   if (pkey)
2880     {
2881       release_mpi_array (pkey);
2882       gcry_free (pkey);
2883     }
2884
2885   if (ciph)
2886     {
2887       release_mpi_array (ciph);
2888       gcry_free (ciph);
2889     }
2890
2891   if (module)
2892     {
2893       ath_mutex_lock (&pubkeys_registered_lock);
2894       _gcry_module_release (module);
2895       ath_mutex_unlock (&pubkeys_registered_lock);
2896     }
2897
2898   gcry_free (ctx.label);
2899
2900   return gcry_error (rc);
2901 }
2902
2903 /*
2904    Do a PK decrypt operation
2905
2906    Caller has to provide a secret key as the SEXP skey and data in a
2907    format as created by gcry_pk_encrypt.  For historic reasons the
2908    function returns simply an MPI as an S-expression part; this is
2909    deprecated and the new method should be used which returns a real
2910    S-expressionl this is selected by adding at least an empty flags
2911    list to S_DATA.
2912
2913    Returns: 0 or an errorcode.
2914
2915    s_data = (enc-val
2916               [(flags [raw, pkcs1, oaep])]
2917               (<algo>
2918                 (<param_name1> <mpi>)
2919                 ...
2920                 (<param_namen> <mpi>)
2921               ))
2922    s_skey = <key-as-defined-in-sexp_to_key>
2923    r_plain= Either an incomplete S-expression without the parentheses
2924             or if the flags list is used (even if empty) a real S-expression:
2925             (value PLAIN).  In raw mode (or no flags given) the returned value
2926             is to be interpreted as a signed MPI, thus it may have an extra
2927             leading zero octet even if not included in the original data.
2928             With pkcs1 or oaep decoding enabled the returned value is a
2929             verbatim octet string.
2930  */
2931 gcry_error_t
2932 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
2933 {
2934   gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL;
2935   unsigned char *unpad = NULL;
2936   size_t unpadlen = 0;
2937   int modern, flags;
2938   struct pk_encoding_ctx ctx;
2939   gcry_err_code_t rc;
2940   gcry_module_t module_enc = NULL, module_key = NULL;
2941
2942   *r_plain = NULL;
2943   ctx.label = NULL;
2944
2945   REGISTER_DEFAULT_PUBKEYS;
2946
2947   rc = sexp_to_key (s_skey, 1, NULL, &skey, &module_key);
2948   if (rc)
2949     goto leave;
2950
2951   init_encoding_ctx (&ctx, PUBKEY_OP_DECRYPT, gcry_pk_get_nbits (s_skey));
2952   rc = sexp_to_enc (s_data, &data, &module_enc, &modern, &flags, &ctx);
2953   if (rc)
2954     goto leave;
2955
2956   if (module_key->mod_id != module_enc->mod_id)
2957     {
2958       rc = GPG_ERR_CONFLICT; /* Key algo does not match data algo. */
2959       goto leave;
2960     }
2961
2962   rc = pubkey_decrypt (module_key->mod_id, &plain, data, skey, flags);
2963   if (rc)
2964     goto leave;
2965
2966   /* Do un-padding if necessary. */
2967   switch (ctx.encoding)
2968     {
2969     case PUBKEY_ENC_PKCS1:
2970       rc = pkcs1_decode_for_encryption (&unpad, &unpadlen,
2971                                         gcry_pk_get_nbits (s_skey), plain);
2972       mpi_free (plain);
2973       plain = NULL;
2974       if (!rc)
2975         rc = gcry_err_code (gcry_sexp_build (r_plain, NULL, "(value %b)",
2976                                              (int)unpadlen, unpad));
2977       break;
2978
2979     case PUBKEY_ENC_OAEP:
2980       rc = oaep_decode (&unpad, &unpadlen,
2981                         gcry_pk_get_nbits (s_skey), ctx.hash_algo,
2982                         plain, ctx.label, ctx.labellen);
2983       mpi_free (plain);
2984       plain = NULL;
2985       if (!rc)
2986         rc = gcry_err_code (gcry_sexp_build (r_plain, NULL, "(value %b)",
2987                                              (int)unpadlen, unpad));
2988       break;
2989
2990     default:
2991       /* Raw format.  For backward compatibility we need to assume a
2992          signed mpi by using the sexp format string "%m".  */
2993       rc = gcry_err_code (gcry_sexp_build
2994                           (r_plain, NULL, modern? "(value %m)" : "%m", plain));
2995       break;
2996     }
2997
2998  leave:
2999   gcry_free (unpad);
3000
3001   if (skey)
3002     {
3003       release_mpi_array (skey);
3004       gcry_free (skey);
3005     }
3006
3007   mpi_free (plain);
3008
3009   if (data)
3010     {
3011       release_mpi_array (data);
3012       gcry_free (data);
3013     }
3014
3015   if (module_key || module_enc)
3016     {
3017       ath_mutex_lock (&pubkeys_registered_lock);
3018       if (module_key)
3019         _gcry_module_release (module_key);
3020       if (module_enc)
3021         _gcry_module_release (module_enc);
3022       ath_mutex_unlock (&pubkeys_registered_lock);
3023     }
3024
3025   gcry_free (ctx.label);
3026
3027   return gcry_error (rc);
3028 }
3029
3030
3031
3032 /*
3033    Create a signature.
3034
3035    Caller has to provide a secret key as the SEXP skey and data
3036    expressed as a SEXP list hash with only one element which should
3037    instantly be available as a MPI. Alternatively the structure given
3038    below may be used for S_HASH, it provides the abiliy to pass flags
3039    to the operation; the only flag defined by now is "pkcs1" which
3040    does PKCS#1 block type 1 style padding.
3041
3042    Returns: 0 or an errorcode.
3043             In case of 0 the function returns a new SEXP with the
3044             signature value; the structure of this signature depends on the
3045             other arguments but is always suitable to be passed to
3046             gcry_pk_verify
3047
3048    s_hash = See comment for sexp_data_to_mpi
3049
3050    s_skey = <key-as-defined-in-sexp_to_key>
3051    r_sig  = (sig-val
3052               (<algo>
3053                 (<param_name1> <mpi>)
3054                 ...
3055                 (<param_namen> <mpi>))
3056              [(hash algo)])
3057
3058   Note that (hash algo) in R_SIG is not used.
3059 */
3060 gcry_error_t
3061 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
3062 {
3063   gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
3064   gcry_pk_spec_t *pubkey = NULL;
3065   gcry_module_t module = NULL;
3066   const char *algo_name, *algo_elems;
3067   struct pk_encoding_ctx ctx;
3068   int i;
3069   gcry_err_code_t rc;
3070
3071   *r_sig = NULL;
3072
3073   REGISTER_DEFAULT_PUBKEYS;
3074
3075   rc = sexp_to_key (s_skey, 1, NULL, &skey, &module);
3076   if (rc)
3077     goto leave;
3078
3079   gcry_assert (module);
3080   pubkey = (gcry_pk_spec_t *) module->spec;
3081   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
3082   if (!algo_name || !*algo_name)
3083     algo_name = pubkey->name;
3084
3085   algo_elems = pubkey->elements_sig;
3086
3087   /* Get the stuff we want to sign.  Note that pk_get_nbits does also
3088       work on a private key. */
3089   init_encoding_ctx (&ctx, PUBKEY_OP_SIGN, gcry_pk_get_nbits (s_skey));
3090   rc = sexp_data_to_mpi (s_hash, &hash, &ctx);
3091   if (rc)
3092     goto leave;
3093
3094   result = gcry_calloc (strlen (algo_elems) + 1, sizeof (*result));
3095   if (!result)
3096     {
3097       rc = gpg_err_code_from_syserror ();
3098       goto leave;
3099     }
3100   rc = pubkey_sign (module->mod_id, result, hash, skey);
3101   if (rc)
3102     goto leave;
3103
3104   {
3105     char *string, *p;
3106     size_t nelem, needed = strlen (algo_name) + 20;
3107     void **arg_list;
3108
3109     nelem = strlen (algo_elems);
3110
3111     /* Count elements, so that we can allocate enough space. */
3112     needed += 10 * nelem;
3113
3114     /* Build the string. */
3115     string = p = gcry_malloc (needed);
3116     if (!string)
3117       {
3118         rc = gpg_err_code_from_syserror ();
3119         goto leave;
3120       }
3121     p = stpcpy (p, "(sig-val(");
3122     p = stpcpy (p, algo_name);
3123     for (i = 0; algo_elems[i]; i++)
3124       {
3125         *p++ = '(';
3126         *p++ = algo_elems[i];
3127         p = stpcpy (p, "%m)");
3128       }
3129     strcpy (p, "))");
3130
3131     arg_list = malloc (nelem * sizeof *arg_list);
3132     if (!arg_list)
3133       {
3134         rc = gpg_err_code_from_syserror ();
3135         goto leave;
3136       }
3137
3138     for (i = 0; i < nelem; i++)
3139       arg_list[i] = result + i;
3140
3141     rc = gcry_sexp_build_array (r_sig, NULL, string, arg_list);
3142     free (arg_list);
3143     if (rc)
3144       BUG ();
3145     gcry_free (string);
3146   }
3147
3148  leave:
3149   if (skey)
3150     {
3151       release_mpi_array (skey);
3152       gcry_free (skey);
3153     }
3154
3155   if (hash)
3156     mpi_free (hash);
3157
3158   if (result)
3159     {
3160       release_mpi_array (result);
3161       gcry_free (result);
3162     }
3163
3164   return gcry_error (rc);
3165 }
3166
3167
3168 /*
3169    Verify a signature.
3170
3171    Caller has to supply the public key pkey, the signature sig and his
3172    hashvalue data.  Public key has to be a standard public key given
3173    as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
3174    must be an S-Exp like the one in sign too.  */
3175 gcry_error_t
3176 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
3177 {
3178   gcry_module_t module_key = NULL, module_sig = NULL;
3179   gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
3180   struct pk_encoding_ctx ctx;
3181   gcry_err_code_t rc;
3182
3183   REGISTER_DEFAULT_PUBKEYS;
3184
3185   rc = sexp_to_key (s_pkey, 0, NULL, &pkey, &module_key);
3186   if (rc)
3187     goto leave;
3188
3189   rc = sexp_to_sig (s_sig, &sig, &module_sig);
3190   if (rc)
3191     goto leave;
3192
3193   /* Fixme: Check that the algorithm of S_SIG is compatible to the one
3194      of S_PKEY.  */
3195
3196   if (module_key->mod_id != module_sig->mod_id)
3197     {
3198       rc = GPG_ERR_CONFLICT;
3199       goto leave;
3200     }
3201
3202   /* Get the stuff we want to verify. */
3203   init_encoding_ctx (&ctx, PUBKEY_OP_VERIFY, gcry_pk_get_nbits (s_pkey));
3204   rc = sexp_data_to_mpi (s_hash, &hash, &ctx);
3205   if (rc)
3206     goto leave;
3207
3208   rc = pubkey_verify (module_key->mod_id, hash, sig, pkey,
3209                       ctx.verify_cmp, &ctx);
3210
3211  leave:
3212   if (pkey)
3213     {
3214       release_mpi_array (pkey);
3215       gcry_free (pkey);
3216     }
3217   if (sig)
3218     {
3219       release_mpi_array (sig);
3220       gcry_free (sig);
3221     }
3222   if (hash)
3223     mpi_free (hash);
3224
3225   if (module_key || module_sig)
3226     {
3227       ath_mutex_lock (&pubkeys_registered_lock);
3228       if (module_key)
3229         _gcry_module_release (module_key);
3230       if (module_sig)
3231         _gcry_module_release (module_sig);
3232       ath_mutex_unlock (&pubkeys_registered_lock);
3233     }
3234
3235   return gcry_error (rc);
3236 }
3237
3238
3239 /*
3240    Test a key.
3241
3242    This may be used either for a public or a secret key to see whether
3243    the internal structure is okay.
3244
3245    Returns: 0 or an errorcode.
3246
3247    s_key = <key-as-defined-in-sexp_to_key> */
3248 gcry_error_t
3249 gcry_pk_testkey (gcry_sexp_t s_key)
3250 {
3251   gcry_module_t module = NULL;
3252   gcry_mpi_t *key = NULL;
3253   gcry_err_code_t rc;
3254
3255   REGISTER_DEFAULT_PUBKEYS;
3256
3257   /* Note we currently support only secret key checking. */
3258   rc = sexp_to_key (s_key, 1, NULL, &key, &module);
3259   if (! rc)
3260     {
3261       rc = pubkey_check_secret_key (module->mod_id, key);
3262       release_mpi_array (key);
3263       gcry_free (key);
3264     }
3265   return gcry_error (rc);
3266 }
3267
3268
3269 /*
3270   Create a public key pair and return it in r_key.
3271   How the key is created depends on s_parms:
3272   (genkey
3273    (algo
3274      (parameter_name_1 ....)
3275       ....
3276      (parameter_name_n ....)
3277   ))
3278   The key is returned in a format depending on the
3279   algorithm. Both, private and secret keys are returned
3280   and optionally some additional informatin.
3281   For elgamal we return this structure:
3282   (key-data
3283    (public-key
3284      (elg
3285         (p <mpi>)
3286         (g <mpi>)
3287         (y <mpi>)
3288      )
3289    )
3290    (private-key
3291      (elg
3292         (p <mpi>)
3293         (g <mpi>)
3294         (y <mpi>)
3295         (x <mpi>)
3296      )
3297    )
3298    (misc-key-info
3299       (pm1-factors n1 n2 ... nn)
3300    ))
3301  */
3302 gcry_error_t
3303 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
3304 {
3305   gcry_pk_spec_t *pubkey = NULL;
3306   gcry_module_t module = NULL;
3307   gcry_sexp_t list = NULL;
3308   gcry_sexp_t l2 = NULL;
3309   gcry_sexp_t l3 = NULL;
3310   char *name = NULL;
3311   size_t n;
3312   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
3313   int i, j;
3314   const char *algo_name = NULL;
3315   int algo;
3316   const char *sec_elems = NULL, *pub_elems = NULL;
3317   gcry_mpi_t skey[12];
3318   gcry_mpi_t *factors = NULL;
3319   gcry_sexp_t extrainfo = NULL;
3320   unsigned int nbits = 0;
3321   unsigned long use_e = 0;
3322
3323   skey[0] = NULL;
3324   *r_key = NULL;
3325
3326   REGISTER_DEFAULT_PUBKEYS;
3327
3328   list = gcry_sexp_find_token (s_parms, "genkey", 0);
3329   if (!list)
3330     {
3331       rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
3332       goto leave;
3333     }
3334
3335   l2 = gcry_sexp_cadr (list);
3336   gcry_sexp_release (list);
3337   list = l2;
3338   l2 = NULL;
3339   if (! list)
3340     {
3341       rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
3342       goto leave;
3343     }
3344
3345   name = _gcry_sexp_nth_string (list, 0);
3346   if (!name)
3347     {
3348       rc = GPG_ERR_INV_OBJ; /* Algo string missing.  */
3349       goto leave;
3350     }
3351
3352   ath_mutex_lock (&pubkeys_registered_lock);
3353   module = gcry_pk_lookup_name (name);
3354   ath_mutex_unlock (&pubkeys_registered_lock);
3355   gcry_free (name);
3356   name = NULL;
3357   if (!module)
3358     {
3359       rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
3360       goto leave;
3361     }
3362
3363   pubkey = (gcry_pk_spec_t *) module->spec;
3364   algo = module->mod_id;
3365   algo_name = pubkey->aliases? *pubkey->aliases : NULL;
3366   if (!algo_name || !*algo_name)
3367     algo_name = pubkey->name;
3368   pub_elems = pubkey->elements_pkey;
3369   sec_elems = pubkey->elements_skey;
3370   if (strlen (sec_elems) >= DIM(skey))
3371     BUG ();
3372
3373   /* Handle the optional rsa-use-e element.  Actually this belong into
3374      the algorithm module but we have this parameter in the public
3375      module API, so we need to parse it right here.  */
3376   l2 = gcry_sexp_find_token (list, "rsa-use-e", 0);
3377   if (l2)
3378     {
3379       char buf[50];
3380       const char *s;
3381
3382       s = gcry_sexp_nth_data (l2, 1, &n);
3383       if ( !s || n >= DIM (buf) - 1 )
3384         {
3385           rc = GPG_ERR_INV_OBJ; /* No value or value too large.  */
3386           goto leave;
3387         }
3388       memcpy (buf, s, n);
3389       buf[n] = 0;
3390       use_e = strtoul (buf, NULL, 0);
3391       gcry_sexp_release (l2);
3392       l2 = NULL;
3393     }
3394   else
3395     use_e = 65537; /* Not given, use the value generated by old versions. */
3396
3397
3398   /* Get the "nbits" parameter.  */
3399   l2 = gcry_sexp_find_token (list, "nbits", 0);
3400   if (l2)
3401     {
3402       char buf[50];
3403       const char *s;
3404
3405       s = gcry_sexp_nth_data (l2, 1, &n);
3406       if (!s || n >= DIM (buf) - 1 )
3407         {
3408           rc = GPG_ERR_INV_OBJ; /* NBITS given without a cdr.  */
3409           goto leave;
3410         }
3411       memcpy (buf, s, n);
3412       buf[n] = 0;
3413       nbits = (unsigned int)strtoul (buf, NULL, 0);
3414       gcry_sexp_release (l2); l2 = NULL;
3415     }
3416   else
3417     nbits = 0;
3418
3419   /* Pass control to the algorithm module. */
3420   rc = pubkey_generate (module->mod_id, nbits, use_e, list, skey,
3421                         &factors, &extrainfo);
3422   gcry_sexp_release (list); list = NULL;
3423   if (rc)
3424     goto leave;
3425
3426   /* Key generation succeeded: Build an S-expression.  */
3427   {
3428     char *string, *p;
3429     size_t nelem=0, nelem_cp = 0, needed=0;
3430     gcry_mpi_t mpis[30];
3431     int percent_s_idx = -1;
3432
3433     /* Estimate size of format string.  */
3434     nelem = strlen (pub_elems) + strlen (sec_elems);
3435     if (factors)
3436       {
3437         for (i = 0; factors[i]; i++)
3438           nelem++;
3439       }
3440     nelem_cp = nelem;
3441
3442     needed += nelem * 10;
3443     /* (+5 is for EXTRAINFO ("%S")).  */
3444     needed += 2 * strlen (algo_name) + 300 + 5;
3445     if (nelem > DIM (mpis))
3446       BUG ();
3447
3448     /* Build the string. */
3449     nelem = 0;
3450     string = p = gcry_malloc (needed);
3451     if (!string)
3452       {
3453         rc = gpg_err_code_from_syserror ();
3454         goto leave;
3455       }
3456     p = stpcpy (p, "(key-data");
3457     p = stpcpy (p, "(public-key(");
3458     p = stpcpy (p, algo_name);
3459     for(i = 0; pub_elems[i]; i++)
3460       {
3461         *p++ = '(';
3462         *p++ = pub_elems[i];
3463         p = stpcpy (p, "%m)");
3464         mpis[nelem++] = skey[i];
3465       }
3466     if (extrainfo && (algo == GCRY_PK_ECDSA || algo == GCRY_PK_ECDH))
3467       {
3468         /* Very ugly hack to insert the used curve parameter into the
3469            list of public key parameters.  */
3470         percent_s_idx = nelem;
3471         p = stpcpy (p, "%S");
3472       }
3473     p = stpcpy (p, "))");
3474     p = stpcpy (p, "(private-key(");
3475     p = stpcpy (p, algo_name);
3476     for (i = 0; sec_elems[i]; i++)
3477       {
3478         *p++ = '(';
3479         *p++ = sec_elems[i];
3480         p = stpcpy (p, "%m)");
3481         mpis[nelem++] = skey[i];
3482       }
3483     p = stpcpy (p, "))");
3484
3485     /* Hack to make release_mpi_array() work.  */
3486     skey[i] = NULL;
3487
3488     if (extrainfo && percent_s_idx == -1)
3489       {
3490         /* If we have extrainfo we should not have any factors.  */
3491         p = stpcpy (p, "%S");
3492       }
3493     else if (factors && factors[0])
3494       {
3495         p = stpcpy (p, "(misc-key-info(pm1-factors");
3496         for(i = 0; factors[i]; i++)
3497           {
3498             p = stpcpy (p, "%m");
3499             mpis[nelem++] = factors[i];
3500           }
3501         p = stpcpy (p, "))");
3502       }
3503     strcpy (p, ")");
3504     gcry_assert (p - string < needed);
3505
3506     while (nelem < DIM (mpis))
3507       mpis[nelem++] = NULL;
3508
3509     {
3510       int elem_n = strlen (pub_elems) + strlen (sec_elems);
3511       void **arg_list;
3512
3513       /* Allocate one extra for EXTRAINFO ("%S").  */
3514       arg_list = gcry_calloc (nelem_cp+1, sizeof *arg_list);
3515       if (!arg_list)
3516         {
3517           rc = gpg_err_code_from_syserror ();
3518           goto leave;
3519         }
3520       for (i = j = 0; i < elem_n; i++)
3521         {
3522           if (i == percent_s_idx)
3523             arg_list[j++] = &extrainfo;
3524           arg_list[j++] = mpis + i;
3525         }
3526       if (extrainfo && percent_s_idx == -1)
3527         arg_list[j] = &extrainfo;
3528       else if (factors && factors[0])
3529         {
3530           for (; i < nelem_cp; i++)
3531             arg_list[j++] = factors + i - elem_n;
3532         }
3533       rc = gcry_sexp_build_array (r_key, NULL, string, arg_list);
3534       gcry_free (arg_list);
3535       if (rc)
3536         BUG ();
3537       gcry_assert (DIM (mpis) == 30); /* Reminder to make sure that
3538                                          the array gets increased if
3539                                          new parameters are added. */
3540     }
3541     gcry_free (string);
3542   }
3543
3544  leave:
3545   gcry_free (name);
3546   gcry_sexp_release (extrainfo);
3547   release_mpi_array (skey);
3548   /* Don't free SKEY itself, it is an stack allocated array. */
3549
3550   if (factors)
3551     {
3552       release_mpi_array ( factors );
3553       gcry_free (factors);
3554     }
3555
3556   gcry_sexp_release (l3);
3557   gcry_sexp_release (l2);
3558   gcry_sexp_release (list);
3559
3560   if (module)
3561     {
3562       ath_mutex_lock (&pubkeys_registered_lock);
3563       _gcry_module_release (module);
3564       ath_mutex_unlock (&pubkeys_registered_lock);
3565     }
3566
3567   return gcry_error (rc);
3568 }
3569
3570
3571 /*
3572    Get the number of nbits from the public key.
3573
3574    Hmmm: Should we have really this function or is it better to have a
3575    more general function to retrieve different properties of the key?  */
3576 unsigned int
3577 gcry_pk_get_nbits (gcry_sexp_t key)
3578 {
3579   gcry_module_t module = NULL;
3580   gcry_pk_spec_t *pubkey;
3581   gcry_mpi_t *keyarr = NULL;
3582   unsigned int nbits = 0;
3583   gcry_err_code_t rc;
3584
3585   REGISTER_DEFAULT_PUBKEYS;
3586
3587   rc = sexp_to_key (key, 0, NULL, &keyarr, &module);
3588   if (rc == GPG_ERR_INV_OBJ)
3589     rc = sexp_to_key (key, 1, NULL, &keyarr, &module);
3590   if (rc)
3591     return 0; /* Error - 0 is a suitable indication for that. */
3592
3593   pubkey = (gcry_pk_spec_t *) module->spec;
3594   nbits = (*pubkey->get_nbits) (module->mod_id, keyarr);
3595
3596   ath_mutex_lock (&pubkeys_registered_lock);
3597   _gcry_module_release (module);
3598   ath_mutex_unlock (&pubkeys_registered_lock);
3599
3600   release_mpi_array (keyarr);
3601   gcry_free (keyarr);
3602
3603   return nbits;
3604 }
3605
3606
3607 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
3608    key parameters expressed in a way depending on the algorithm.
3609
3610    ARRAY must either be 20 bytes long or NULL; in the latter case a
3611    newly allocated array of that size is returned, otherwise ARRAY or
3612    NULL is returned to indicate an error which is most likely an
3613    unknown algorithm.  The function accepts public or secret keys. */
3614 unsigned char *
3615 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
3616 {
3617   gcry_sexp_t list = NULL, l2 = NULL;
3618   gcry_pk_spec_t *pubkey = NULL;
3619   gcry_module_t module = NULL;
3620   pk_extra_spec_t *extraspec;
3621   const char *s;
3622   char *name = NULL;
3623   int idx;
3624   const char *elems;
3625   gcry_md_hd_t md = NULL;
3626   int okay = 0;
3627
3628   REGISTER_DEFAULT_PUBKEYS;
3629
3630   /* Check that the first element is valid. */
3631   list = gcry_sexp_find_token (key, "public-key", 0);
3632   if (! list)
3633     list = gcry_sexp_find_token (key, "private-key", 0);
3634   if (! list)
3635     list = gcry_sexp_find_token (key, "protected-private-key", 0);
3636   if (! list)
3637     list = gcry_sexp_find_token (key, "shadowed-private-key", 0);
3638   if (! list)
3639     return NULL; /* No public- or private-key object. */
3640
3641   l2 = gcry_sexp_cadr (list);
3642   gcry_sexp_release (list);
3643   list = l2;
3644   l2 = NULL;
3645
3646   name = _gcry_sexp_nth_string (list, 0);
3647   if (!name)
3648     goto fail; /* Invalid structure of object. */
3649
3650   ath_mutex_lock (&pubkeys_registered_lock);
3651   module = gcry_pk_lookup_name (name);
3652   ath_mutex_unlock (&pubkeys_registered_lock);
3653
3654   if (!module)
3655     goto fail; /* Unknown algorithm.  */
3656
3657   pubkey = (gcry_pk_spec_t *) module->spec;
3658   extraspec = module->extraspec;
3659
3660   elems = pubkey->elements_grip;
3661   if (!elems)
3662     goto fail; /* No grip parameter.  */
3663
3664   if (gcry_md_open (&md, GCRY_MD_SHA1, 0))
3665     goto fail;
3666
3667   if (extraspec && extraspec->comp_keygrip)
3668     {
3669       /* Module specific method to compute a keygrip.  */
3670       if (extraspec->comp_keygrip (md, list))
3671         goto fail;
3672     }
3673   else
3674     {
3675       /* Generic method to compute a keygrip.  */
3676       for (idx = 0, s = elems; *s; s++, idx++)
3677         {
3678           const char *data;
3679           size_t datalen;
3680           char buf[30];
3681
3682           l2 = gcry_sexp_find_token (list, s, 1);
3683           if (! l2)
3684             goto fail;
3685           data = gcry_sexp_nth_data (l2, 1, &datalen);
3686           if (! data)
3687             goto fail;
3688
3689           snprintf (buf, sizeof buf, "(1:%c%u:", *s, (unsigned int)datalen);
3690           gcry_md_write (md, buf, strlen (buf));
3691           gcry_md_write (md, data, datalen);
3692           gcry_sexp_release (l2);
3693           l2 = NULL;
3694           gcry_md_write (md, ")", 1);
3695         }
3696     }
3697
3698   if (!array)
3699     {
3700       array = gcry_malloc (20);
3701       if (! array)
3702         goto fail;
3703     }
3704
3705   memcpy (array, gcry_md_read (md, GCRY_MD_SHA1), 20);
3706   okay = 1;
3707
3708  fail:
3709   gcry_free (name);
3710   gcry_sexp_release (l2);
3711   gcry_md_close (md);
3712   gcry_sexp_release (list);
3713   return okay? array : NULL;
3714 }
3715
3716
3717 \f
3718 const char *
3719 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
3720 {
3721   gcry_mpi_t *pkey = NULL;
3722   gcry_sexp_t list = NULL;
3723   gcry_sexp_t l2;
3724   gcry_module_t module = NULL;
3725   pk_extra_spec_t *extraspec;
3726   char *name = NULL;
3727   const char *result = NULL;
3728   int want_private = 1;
3729
3730   if (r_nbits)
3731     *r_nbits = 0;
3732
3733   REGISTER_DEFAULT_PUBKEYS;
3734
3735   if (key)
3736     {
3737       iterator = 0;
3738
3739       /* Check that the first element is valid. */
3740       list = gcry_sexp_find_token (key, "public-key", 0);
3741       if (list)
3742         want_private = 0;
3743       if (!list)
3744         list = gcry_sexp_find_token (key, "private-key", 0);
3745       if (!list)
3746         return NULL; /* No public- or private-key object. */
3747
3748       l2 = gcry_sexp_cadr (list);
3749       gcry_sexp_release (list);
3750       list = l2;
3751       l2 = NULL;
3752
3753       name = _gcry_sexp_nth_string (list, 0);
3754       if (!name)
3755         goto leave; /* Invalid structure of object. */
3756
3757       /* Get the key.  We pass the names of the parameters for
3758          override_elems; this allows to call this function without the
3759          actual public key parameter.  */
3760       if (sexp_to_key (key, want_private, "pabgn", &pkey, &module))
3761         goto leave;
3762     }
3763   else
3764     {
3765       ath_mutex_lock (&pubkeys_registered_lock);
3766       module = gcry_pk_lookup_name ("ecc");
3767       ath_mutex_unlock (&pubkeys_registered_lock);
3768       if (!module)
3769         goto leave;
3770     }
3771
3772   extraspec = module->extraspec;
3773   if (!extraspec || !extraspec->get_curve)
3774     goto leave;
3775
3776   result = extraspec->get_curve (pkey, iterator, r_nbits);
3777
3778  leave:
3779   if (pkey)
3780     {
3781       release_mpi_array (pkey);
3782       gcry_free (pkey);
3783     }
3784   if (module)
3785     {
3786       ath_mutex_lock (&pubkeys_registered_lock);
3787       _gcry_module_release (module);
3788       ath_mutex_unlock (&pubkeys_registered_lock);
3789     }
3790   gcry_free (name);
3791   gcry_sexp_release (list);
3792   return result;
3793 }
3794
3795
3796 \f
3797 gcry_sexp_t
3798 gcry_pk_get_param (int algo, const char *name)
3799 {
3800   gcry_module_t module = NULL;
3801   pk_extra_spec_t *extraspec;
3802   gcry_sexp_t result = NULL;
3803
3804   if (algo != GCRY_PK_ECDSA && algo != GCRY_PK_ECDH)
3805     return NULL;
3806
3807   REGISTER_DEFAULT_PUBKEYS;
3808
3809   ath_mutex_lock (&pubkeys_registered_lock);
3810   module = gcry_pk_lookup_name ("ecc");
3811   ath_mutex_unlock (&pubkeys_registered_lock);
3812   if (module)
3813     {
3814       extraspec = module->extraspec;
3815       if (extraspec && extraspec->get_curve_param)
3816         result = extraspec->get_curve_param (name);
3817
3818       ath_mutex_lock (&pubkeys_registered_lock);
3819       _gcry_module_release (module);
3820       ath_mutex_unlock (&pubkeys_registered_lock);
3821     }
3822   return result;
3823 }
3824
3825
3826 \f
3827 gcry_error_t
3828 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
3829 {
3830   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3831
3832   REGISTER_DEFAULT_PUBKEYS;
3833
3834   switch (cmd)
3835     {
3836     case GCRYCTL_DISABLE_ALGO:
3837       /* This one expects a buffer pointing to an integer with the
3838          algo number.  */
3839       if ((! buffer) || (buflen != sizeof (int)))
3840         err = GPG_ERR_INV_ARG;
3841       else
3842         disable_pubkey_algo (*((int *) buffer));
3843       break;
3844
3845     default:
3846       err = GPG_ERR_INV_OP;
3847     }
3848
3849   return gcry_error (err);
3850 }
3851
3852
3853 /* Return information about the given algorithm
3854
3855    WHAT selects the kind of information returned:
3856
3857     GCRYCTL_TEST_ALGO:
3858         Returns 0 when the specified algorithm is available for use.
3859         Buffer must be NULL, nbytes  may have the address of a variable
3860         with the required usage of the algorithm. It may be 0 for don't
3861         care or a combination of the GCRY_PK_USAGE_xxx flags;
3862
3863     GCRYCTL_GET_ALGO_USAGE:
3864         Return the usage flags for the given algo.  An invalid algo
3865         returns 0.  Disabled algos are ignored here because we
3866         only want to know whether the algo is at all capable of
3867         the usage.
3868
3869    Note: Because this function is in most cases used to return an
3870    integer value, we can make it easier for the caller to just look at
3871    the return value.  The caller will in all cases consult the value
3872    and thereby detecting whether a error occurred or not (i.e. while
3873    checking the block size) */
3874 gcry_error_t
3875 gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
3876 {
3877   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3878
3879   switch (what)
3880     {
3881     case GCRYCTL_TEST_ALGO:
3882       {
3883         int use = nbytes ? *nbytes : 0;
3884         if (buffer)
3885           err = GPG_ERR_INV_ARG;
3886         else if (check_pubkey_algo (algorithm, use))
3887           err = GPG_ERR_PUBKEY_ALGO;
3888         break;
3889       }
3890
3891     case GCRYCTL_GET_ALGO_USAGE:
3892       {
3893         gcry_module_t pubkey;
3894         int use = 0;
3895
3896         REGISTER_DEFAULT_PUBKEYS;
3897
3898         ath_mutex_lock (&pubkeys_registered_lock);
3899         pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
3900         if (pubkey)
3901           {
3902             use = ((gcry_pk_spec_t *) pubkey->spec)->use;
3903             _gcry_module_release (pubkey);
3904           }
3905         ath_mutex_unlock (&pubkeys_registered_lock);
3906
3907         /* FIXME? */
3908         *nbytes = use;
3909
3910         break;
3911       }
3912
3913     case GCRYCTL_GET_ALGO_NPKEY:
3914       {
3915         /* FIXME?  */
3916         int npkey = pubkey_get_npkey (algorithm);
3917         *nbytes = npkey;
3918         break;
3919       }
3920     case GCRYCTL_GET_ALGO_NSKEY:
3921       {
3922         /* FIXME?  */
3923         int nskey = pubkey_get_nskey (algorithm);
3924         *nbytes = nskey;
3925         break;
3926       }
3927     case GCRYCTL_GET_ALGO_NSIGN:
3928       {
3929         /* FIXME?  */
3930         int nsign = pubkey_get_nsig (algorithm);
3931         *nbytes = nsign;
3932         break;
3933       }
3934     case GCRYCTL_GET_ALGO_NENCR:
3935       {
3936         /* FIXME?  */
3937         int nencr = pubkey_get_nenc (algorithm);
3938         *nbytes = nencr;
3939         break;
3940       }
3941
3942     default:
3943       err = GPG_ERR_INV_OP;
3944     }
3945
3946   return gcry_error (err);
3947 }
3948
3949
3950 /* Explicitly initialize this module.  */
3951 gcry_err_code_t
3952 _gcry_pk_init (void)
3953 {
3954   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3955
3956   REGISTER_DEFAULT_PUBKEYS;
3957
3958   return err;
3959 }
3960
3961
3962 gcry_err_code_t
3963 _gcry_pk_module_lookup (int algorithm, gcry_module_t *module)
3964 {
3965   gcry_err_code_t err = GPG_ERR_NO_ERROR;
3966   gcry_module_t pubkey;
3967
3968   REGISTER_DEFAULT_PUBKEYS;
3969
3970   ath_mutex_lock (&pubkeys_registered_lock);
3971   pubkey = _gcry_module_lookup_id (pubkeys_registered, algorithm);
3972   if (pubkey)
3973     *module = pubkey;
3974   else
3975     err = GPG_ERR_PUBKEY_ALGO;
3976   ath_mutex_unlock (&pubkeys_registered_lock);
3977
3978   return err;
3979 }
3980
3981
3982 void
3983 _gcry_pk_module_release (gcry_module_t module)
3984 {
3985   ath_mutex_lock (&pubkeys_registered_lock);
3986   _gcry_module_release (module);
3987   ath_mutex_unlock (&pubkeys_registered_lock);
3988 }
3989
3990 /* Get a list consisting of the IDs of the loaded pubkey modules.  If
3991    LIST is zero, write the number of loaded pubkey modules to
3992    LIST_LENGTH and return.  If LIST is non-zero, the first
3993    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
3994    according size.  In case there are less pubkey modules than
3995    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
3996 gcry_error_t
3997 gcry_pk_list (int *list, int *list_length)
3998 {
3999   gcry_err_code_t err = GPG_ERR_NO_ERROR;
4000
4001   ath_mutex_lock (&pubkeys_registered_lock);
4002   err = _gcry_module_list (pubkeys_registered, list, list_length);
4003   ath_mutex_unlock (&pubkeys_registered_lock);
4004
4005   return err;
4006 }
4007
4008
4009 /* Run the selftests for pubkey algorithm ALGO with optional reporting
4010    function REPORT.  */
4011 gpg_error_t
4012 _gcry_pk_selftest (int algo, int extended, selftest_report_func_t report)
4013 {
4014   gcry_module_t module = NULL;
4015   pk_extra_spec_t *extraspec = NULL;
4016   gcry_err_code_t ec = 0;
4017
4018   REGISTER_DEFAULT_PUBKEYS;
4019
4020   ath_mutex_lock (&pubkeys_registered_lock);
4021   module = _gcry_module_lookup_id (pubkeys_registered, algo);
4022   if (module && !(module->flags & FLAG_MODULE_DISABLED))
4023     extraspec = module->extraspec;
4024   ath_mutex_unlock (&pubkeys_registered_lock);
4025   if (extraspec && extraspec->selftest)
4026     ec = extraspec->selftest (algo, extended, report);
4027   else
4028     {
4029       ec = GPG_ERR_PUBKEY_ALGO;
4030       if (report)
4031         report ("pubkey", algo, "module",
4032                 module && !(module->flags & FLAG_MODULE_DISABLED)?
4033                 "no selftest available" :
4034                 module? "algorithm disabled" : "algorithm not found");
4035     }
4036
4037   if (module)
4038     {
4039       ath_mutex_lock (&pubkeys_registered_lock);
4040       _gcry_module_release (module);
4041       ath_mutex_unlock (&pubkeys_registered_lock);
4042     }
4043   return gpg_error (ec);
4044 }
4045
4046
4047 /* This function is only used by ac.c!  */
4048 gcry_err_code_t
4049 _gcry_pk_get_elements (int algo, char **enc, char **sig)
4050 {
4051   gcry_module_t pubkey;
4052   gcry_pk_spec_t *spec;
4053   gcry_err_code_t err;
4054   char *enc_cp;
4055   char *sig_cp;
4056
4057   REGISTER_DEFAULT_PUBKEYS;
4058
4059   enc_cp = NULL;
4060   sig_cp = NULL;
4061   spec = NULL;
4062
4063   pubkey = _gcry_module_lookup_id (pubkeys_registered, algo);
4064   if (! pubkey)
4065     {
4066       err = GPG_ERR_INTERNAL;
4067       goto out;
4068     }
4069   spec = pubkey->spec;
4070
4071   if (enc)
4072     {
4073       enc_cp = strdup (spec->elements_enc);
4074       if (! enc_cp)
4075         {
4076           err = gpg_err_code_from_syserror ();
4077           goto out;
4078         }
4079     }
4080
4081   if (sig)
4082     {
4083       sig_cp = strdup (spec->elements_sig);
4084       if (! sig_cp)
4085         {
4086           err = gpg_err_code_from_syserror ();
4087           goto out;
4088         }
4089     }
4090
4091   if (enc)
4092     *enc = enc_cp;
4093   if (sig)
4094     *sig = sig_cp;
4095   err = 0;
4096
4097  out:
4098
4099   _gcry_module_release (pubkey);
4100   if (err)
4101     {
4102       free (enc_cp);
4103       free (sig_cp);
4104     }
4105
4106   return err;
4107 }