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