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