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