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