pubkey: Move sexp parsing for gcry_pk_decrypt 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_ecc,
42 #endif
43 #if USE_RSA
44     &_gcry_pubkey_spec_rsa,
45 #endif
46 #if USE_DSA
47     &_gcry_pubkey_spec_dsa,
48 #endif
49 #if USE_ELGAMAL
50     &_gcry_pubkey_spec_elg,
51 #endif
52     NULL
53   };
54
55
56 static int
57 map_algo (int algo)
58 {
59  switch (algo)
60    {
61    case GCRY_PK_ECDSA:
62    case GCRY_PK_ECDH:
63      return GCRY_PK_ECC;
64    case GCRY_PK_ELG_E:
65      return GCRY_PK_ELG;
66    default:
67      return algo;
68    }
69 }
70
71
72
73 /* Return the spec structure for the public key algorithm ALGO.  For
74    an unknown algorithm NULL is returned.  */
75 static gcry_pk_spec_t *
76 spec_from_algo (int algo)
77 {
78   int idx;
79   gcry_pk_spec_t *spec;
80
81   algo = map_algo (algo);
82
83   for (idx = 0; (spec = pubkey_list[idx]); idx++)
84     if (algo == spec->algo)
85       return spec;
86   return NULL;
87 }
88
89
90 /* Return the spec structure for the public key algorithm with NAME.
91    For an unknown name NULL is returned.  */
92 static gcry_pk_spec_t *
93 spec_from_name (const char *name)
94 {
95   gcry_pk_spec_t *spec;
96   int idx;
97   const char **aliases;
98
99   for (idx=0; (spec = pubkey_list[idx]); idx++)
100     {
101       if (!stricmp (name, spec->name))
102         return spec;
103       for (aliases = spec->aliases; *aliases; aliases++)
104         if (!stricmp (name, *aliases))
105           return spec;
106     }
107
108   return NULL;
109 }
110
111
112
113 /* Given the s-expression SEXP with the first element be either
114  * "private-key" or "public-key" return the spec structure for it.  We
115  * look through the list to find a list beginning with "private-key"
116  * or "public-key" - the first one found is used.  If WANT_PRIVATE is
117  * set the function will only succeed if a private key has been given.
118  * On success the spec is stored at R_SPEC.  On error NULL is stored
119  * at R_SPEC and an error code returned.  If R_PARMS is not NULL and
120  * the fucntion returns success, the parameter list below
121  * "private-key" or "public-key" is stored there and the caller must
122  * call gcry_sexp_release on it.
123  */
124 static gcry_err_code_t
125 spec_from_sexp (gcry_sexp_t sexp, int want_private,
126                 gcry_pk_spec_t **r_spec, gcry_sexp_t *r_parms)
127 {
128   gcry_sexp_t list, l2;
129   char *name;
130   gcry_pk_spec_t *spec;
131
132   *r_spec = NULL;
133   if (r_parms)
134     *r_parms = NULL;
135
136   /* Check that the first element is valid.  If we are looking for a
137      public key but a private key was supplied, we allow the use of
138      the private key anyway.  The rationale for this is that the
139      private key is a superset of the public key.  */
140   list = gcry_sexp_find_token (sexp,
141                                want_private? "private-key":"public-key", 0);
142   if (!list && !want_private)
143     list = gcry_sexp_find_token (sexp, "private-key", 0);
144   if (!list)
145     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
146
147   l2 = gcry_sexp_cadr (list);
148   gcry_sexp_release (list);
149   list = l2;
150   name = _gcry_sexp_nth_string (list, 0);
151   if (!name)
152     {
153       gcry_sexp_release ( list );
154       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
155     }
156   spec = spec_from_name (name);
157   gcry_free (name);
158   if (!spec)
159     {
160       gcry_sexp_release (list);
161       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
162     }
163   *r_spec = spec;
164   if (r_parms)
165     *r_parms = list;
166   else
167     gcry_sexp_release (list);
168   return 0;
169 }
170
171
172
173 /* Disable the use of the algorithm ALGO.  This is not thread safe and
174    should thus be called early.  */
175 static void
176 disable_pubkey_algo (int algo)
177 {
178   gcry_pk_spec_t *spec = spec_from_algo (algo);
179
180   if (spec)
181     spec->flags.disabled = 1;
182 }
183
184
185 \f
186 /* Free the MPIs stored in the NULL terminated ARRAY of MPIs and set
187    the slots to NULL.  */
188 static void
189 release_mpi_array (gcry_mpi_t *array)
190 {
191   for (; *array; array++)
192     {
193       mpi_free(*array);
194       *array = NULL;
195     }
196 }
197
198
199 \f
200 /*
201  * Map a string to the pubkey algo
202  */
203 int
204 gcry_pk_map_name (const char *string)
205 {
206   gcry_pk_spec_t *spec;
207
208   if (!string)
209     return 0;
210   spec = spec_from_name (string);
211   if (!spec)
212     return 0;
213   if (spec->flags.disabled)
214     return 0;
215   return spec->algo;
216 }
217
218
219 /* Map the public key algorithm whose ID is contained in ALGORITHM to
220    a string representation of the algorithm name.  For unknown
221    algorithm IDs this functions returns "?". */
222 const char *
223 gcry_pk_algo_name (int algo)
224 {
225   gcry_pk_spec_t *spec;
226
227   spec = spec_from_algo (algo);
228   if (spec)
229     return spec->name;
230   return "?";
231 }
232
233
234 /****************
235  * A USE of 0 means: don't care.
236  */
237 static gcry_err_code_t
238 check_pubkey_algo (int algo, unsigned use)
239 {
240   gcry_err_code_t err = 0;
241   gcry_pk_spec_t *spec;
242
243   spec = spec_from_algo (algo);
244   if (spec)
245     {
246       if (((use & GCRY_PK_USAGE_SIGN)
247            && (! (spec->use & GCRY_PK_USAGE_SIGN)))
248           || ((use & GCRY_PK_USAGE_ENCR)
249               && (! (spec->use & GCRY_PK_USAGE_ENCR))))
250         err = GPG_ERR_WRONG_PUBKEY_ALGO;
251     }
252   else
253     err = GPG_ERR_PUBKEY_ALGO;
254
255   return err;
256 }
257
258
259 /****************
260  * Return the number of public key material numbers
261  */
262 static int
263 pubkey_get_npkey (int algo)
264 {
265   gcry_pk_spec_t *spec = spec_from_algo (algo);
266
267   return spec? strlen (spec->elements_pkey) : 0;
268 }
269
270
271 /****************
272  * Return the number of secret key material numbers
273  */
274 static int
275 pubkey_get_nskey (int algo)
276 {
277   gcry_pk_spec_t *spec = spec_from_algo (algo);
278
279   return spec? strlen (spec->elements_skey) : 0;
280 }
281
282
283 /****************
284  * Return the number of signature material numbers
285  */
286 static int
287 pubkey_get_nsig (int algo)
288 {
289   gcry_pk_spec_t *spec = spec_from_algo (algo);
290
291   return spec? strlen (spec->elements_sig) : 0;
292 }
293
294 /****************
295  * Return the number of encryption material numbers
296  */
297 static int
298 pubkey_get_nenc (int algo)
299 {
300   gcry_pk_spec_t *spec = spec_from_algo (algo);
301
302   return spec? strlen (spec->elements_enc) : 0;
303 }
304
305
306 static gcry_err_code_t
307 pubkey_check_secret_key (int algo, gcry_mpi_t *skey)
308 {
309   gcry_err_code_t rc;
310   gcry_pk_spec_t *spec = spec_from_algo (algo);
311
312   if (spec && spec->check_secret_key)
313     rc = spec->check_secret_key (algo, skey);
314   else if (spec)
315     rc = GPG_ERR_NOT_IMPLEMENTED;
316   else
317     rc = GPG_ERR_PUBKEY_ALGO;
318
319   return rc;
320 }
321
322
323 /* Internal function.   */
324 static gcry_err_code_t
325 sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
326                        gcry_mpi_t *elements, const char *algo_name, int opaque)
327 {
328   gcry_err_code_t err = 0;
329   int i, idx;
330   const char *name;
331   gcry_sexp_t list;
332
333   for (name = element_names, idx = 0; *name && !err; name++, idx++)
334     {
335       list = gcry_sexp_find_token (key_sexp, name, 1);
336       if (!list)
337         elements[idx] = NULL;
338       else if (opaque)
339         {
340           elements[idx] = _gcry_sexp_nth_opaque_mpi (list, 1);
341           gcry_sexp_release (list);
342           if (!elements[idx])
343             err = GPG_ERR_INV_OBJ;
344         }
345       else
346         {
347           elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_USG);
348           gcry_sexp_release (list);
349           if (!elements[idx])
350             err = GPG_ERR_INV_OBJ;
351         }
352     }
353
354   if (!err)
355     {
356       /* Check that all elements are available.  */
357       for (name = element_names, i = 0; *name; name++, i++)
358         if (!elements[i])
359           break;
360       if (*name)
361         {
362           err = GPG_ERR_NO_OBJ;
363           /* Some are missing.  Before bailing out we test for
364              optional parameters.  */
365           if (algo_name && !strcmp (algo_name, "RSA")
366               && !strcmp (element_names, "nedpqu") )
367             {
368               /* This is RSA.  Test whether we got N, E and D and that
369                  the optional P, Q and U are all missing.  */
370               if (elements[0] && elements[1] && elements[2]
371                   && !elements[3] && !elements[4] && !elements[5])
372                 err = 0;
373             }
374         }
375     }
376
377
378   if (err)
379     {
380       for (i = 0; i < idx; i++)
381         if (elements[i])
382           mpi_free (elements[i]);
383     }
384   return err;
385 }
386
387
388 /* Internal function used for ecc.  Note, that this function makes use
389    of its intimate knowledge about the ECC parameters from ecc.c. */
390 static gcry_err_code_t
391 sexp_elements_extract_ecc (gcry_sexp_t key_sexp, const char *element_names,
392                            gcry_mpi_t *elements, gcry_pk_spec_t *spec,
393                            int want_private)
394
395 {
396   gcry_err_code_t err = 0;
397   int idx;
398   const char *name;
399   gcry_sexp_t list;
400
401   /* Clear the array for easier error cleanup. */
402   for (name = element_names, idx = 0; *name; name++, idx++)
403     elements[idx] = NULL;
404   gcry_assert (idx >= 5); /* We know that ECC has at least 5 elements
405                              (params only) or 6 (full public key).  */
406   if (idx == 5)
407     elements[5] = NULL;   /* Extra clear for the params only case.  */
408
409
410   /* Init the array with the available curve parameters. */
411   for (name = element_names, idx = 0; *name && !err; name++, idx++)
412     {
413       list = gcry_sexp_find_token (key_sexp, name, 1);
414       if (!list)
415         elements[idx] = NULL;
416       else
417         {
418           switch (idx)
419             {
420             case 5: /* The public and */
421             case 6: /* the secret key must to be passed opaque.  */
422               elements[idx] = _gcry_sexp_nth_opaque_mpi (list, 1);
423               break;
424             default:
425               elements[idx] = gcry_sexp_nth_mpi (list, 1, GCRYMPI_FMT_STD);
426               break;
427             }
428           gcry_sexp_release (list);
429           if (!elements[idx])
430             {
431               err = GPG_ERR_INV_OBJ;
432               goto leave;
433             }
434         }
435     }
436
437   /* Check whether a curve parameter has been given and then fill any
438      missing elements.  */
439   list = gcry_sexp_find_token (key_sexp, "curve", 5);
440   if (list)
441     {
442       if (spec->get_param)
443         {
444           char *curve;
445           gcry_mpi_t params[6];
446
447           for (idx = 0; idx < DIM(params); idx++)
448             params[idx] = NULL;
449
450           curve = _gcry_sexp_nth_string (list, 1);
451           gcry_sexp_release (list);
452           if (!curve)
453             {
454               /* No curve name given (or out of core). */
455               err = GPG_ERR_INV_OBJ;
456               goto leave;
457             }
458           err = spec->get_param (curve, params);
459           gcry_free (curve);
460           if (err)
461             goto leave;
462
463           for (idx = 0; idx < DIM(params); idx++)
464             {
465               if (!elements[idx])
466                 elements[idx] = params[idx];
467               else
468                 mpi_free (params[idx]);
469             }
470         }
471       else
472         {
473           gcry_sexp_release (list);
474           err = GPG_ERR_INV_OBJ; /* "curve" given but ECC not supported. */
475           goto leave;
476         }
477     }
478
479   /* Check that all parameters are known.  */
480   for (name = element_names, idx = 0; *name; name++, idx++)
481     if (!elements[idx])
482       {
483         if (want_private && *name == 'q')
484           ; /* Q is optional.  */
485         else
486           {
487             err = GPG_ERR_NO_OBJ;
488             goto leave;
489           }
490       }
491
492  leave:
493   if (err)
494     {
495       for (name = element_names, idx = 0; *name; name++, idx++)
496         if (elements[idx])
497           mpi_free (elements[idx]);
498     }
499   return err;
500 }
501
502
503
504 /****************
505  * Convert a S-Exp with either a private or a public key to our
506  * internal format. Currently we do only support the following
507  * algorithms:
508  *    dsa
509  *    rsa
510  *    openpgp-dsa
511  *    openpgp-rsa
512  *    openpgp-elg
513  *    openpgp-elg-sig
514  *    ecdsa
515  *    ecdh
516  * Provide a SE with the first element be either "private-key" or
517  * or "public-key". It is followed by a list with its first element
518  * be one of the above algorithm identifiers and the remaning
519  * elements are pairs with parameter-id and value.
520  * NOTE: we look through the list to find a list beginning with
521  * "private-key" or "public-key" - the first one found is used.
522  *
523  * If OVERRIDE_ELEMS is not NULL those elems override the parameter
524  * specification taken from the module.  This ise used by
525  * gcry_pk_get_curve.
526  *
527  * Returns: A pointer to an allocated array of MPIs if the return value is
528  *          zero; the caller has to release this array.
529  *
530  * Example of a DSA public key:
531  *  (private-key
532  *    (dsa
533  *      (p <mpi>)
534  *      (g <mpi>)
535  *      (y <mpi>)
536  *      (x <mpi>)
537  *    )
538  *  )
539  * The <mpi> are expected to be in GCRYMPI_FMT_USG
540  */
541 static gcry_err_code_t
542 sexp_to_key (gcry_sexp_t sexp, int want_private, int use,
543              const char *override_elems,
544              gcry_mpi_t **retarray, gcry_pk_spec_t **r_spec, int *r_is_ecc)
545 {
546   gcry_err_code_t err = 0;
547   gcry_sexp_t list, l2;
548   char *name;
549   const char *elems;
550   gcry_mpi_t *array;
551   gcry_pk_spec_t *spec;
552   int is_ecc;
553
554   /* Check that the first element is valid.  If we are looking for a
555      public key but a private key was supplied, we allow the use of
556      the private key anyway.  The rationale for this is that the
557      private key is a superset of the public key. */
558   list = gcry_sexp_find_token (sexp,
559                                want_private? "private-key":"public-key", 0);
560   if (!list && !want_private)
561     list = gcry_sexp_find_token (sexp, "private-key", 0);
562   if (!list)
563     return GPG_ERR_INV_OBJ; /* Does not contain a key object.  */
564
565   l2 = gcry_sexp_cadr( list );
566   gcry_sexp_release ( list );
567   list = l2;
568   name = _gcry_sexp_nth_string (list, 0);
569   if (!name)
570     {
571       gcry_sexp_release ( list );
572       return GPG_ERR_INV_OBJ;      /* Invalid structure of object. */
573     }
574
575   /* Fixme: We should make sure that an ECC key is always named "ecc"
576      and not "ecdsa".  "ecdsa" should be used for the signature
577      itself.  We need a function to test whether an algorithm given
578      with a key is compatible with an application of the key (signing,
579      encryption).  For RSA this is easy, but ECC is the first
580      algorithm which has many flavours.
581
582      We use an ugly hack here to decide whether to use ecdsa or ecdh.
583   */
584   if (!strcmp (name, "ecc"))
585     is_ecc = 2;
586   else if (!strcmp (name, "ecdsa") || !strcmp (name, "ecdh"))
587     is_ecc = 1;
588   else
589     is_ecc = 0;
590
591   if (is_ecc == 2 && (use & GCRY_PK_USAGE_SIGN))
592     spec = spec_from_name ("ecdsa");
593   else if (is_ecc == 2 && (use & GCRY_PK_USAGE_ENCR))
594     spec = spec_from_name ("ecdh");
595   else
596     spec = spec_from_name (name);
597
598   gcry_free (name);
599
600   if (!spec)
601     {
602       gcry_sexp_release (list);
603       return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
604     }
605
606   if (override_elems)
607     elems = override_elems;
608   else if (want_private)
609     elems = spec->elements_skey;
610   else
611     elems = spec->elements_pkey;
612   array = gcry_calloc (strlen (elems) + 1, sizeof (*array));
613   if (!array)
614     err = gpg_err_code_from_syserror ();
615   if (!err)
616     {
617       if (is_ecc)
618         err = sexp_elements_extract_ecc (list, elems, array, spec,
619                                          want_private);
620       else
621         err = sexp_elements_extract (list, elems, array, spec->name, 0);
622     }
623
624   gcry_sexp_release (list);
625
626   if (err)
627     {
628       gcry_free (array);
629     }
630   else
631     {
632       *retarray = array;
633       *r_spec = spec;
634       if (r_is_ecc)
635         *r_is_ecc = is_ecc;
636     }
637
638   return err;
639 }
640
641
642
643 /* FIXME: This is a duplicate.  */
644 static inline int
645 get_hash_algo (const char *s, size_t n)
646 {
647   static const struct { const char *name; int algo; } hashnames[] = {
648     { "sha1",   GCRY_MD_SHA1 },
649     { "md5",    GCRY_MD_MD5 },
650     { "sha256", GCRY_MD_SHA256 },
651     { "ripemd160", GCRY_MD_RMD160 },
652     { "rmd160", GCRY_MD_RMD160 },
653     { "sha384", GCRY_MD_SHA384 },
654     { "sha512", GCRY_MD_SHA512 },
655     { "sha224", GCRY_MD_SHA224 },
656     { "md2",    GCRY_MD_MD2 },
657     { "md4",    GCRY_MD_MD4 },
658     { "tiger",  GCRY_MD_TIGER },
659     { "haval",  GCRY_MD_HAVAL },
660     { NULL, 0 }
661   };
662   int algo;
663   int i;
664
665   for (i=0; hashnames[i].name; i++)
666     {
667       if ( strlen (hashnames[i].name) == n
668            && !memcmp (hashnames[i].name, s, n))
669         break;
670     }
671   if (hashnames[i].name)
672     algo = hashnames[i].algo;
673   else
674     {
675       /* In case of not listed or dynamically allocated hash
676          algorithm we fall back to this somewhat slower
677          method.  Further, it also allows to use OIDs as
678          algorithm names. */
679       char *tmpname;
680
681       tmpname = gcry_malloc (n+1);
682       if (!tmpname)
683         algo = 0;  /* Out of core - silently give up.  */
684       else
685         {
686           memcpy (tmpname, s, n);
687           tmpname[n] = 0;
688           algo = gcry_md_map_name (tmpname);
689           gcry_free (tmpname);
690         }
691     }
692   return algo;
693 }
694
695
696 /*
697    Do a PK encrypt operation
698
699    Caller has to provide a public key as the SEXP pkey and data as a
700    SEXP with just one MPI in it. Alternatively S_DATA might be a
701    complex S-Expression, similar to the one used for signature
702    verification.  This provides a flag which allows to handle PKCS#1
703    block type 2 padding.  The function returns a sexp which may be
704    passed to to pk_decrypt.
705
706    Returns: 0 or an errorcode.
707
708    s_data = See comment for _gcry_pk_util_data_to_mpi
709    s_pkey = <key-as-defined-in-sexp_to_key>
710    r_ciph = (enc-val
711                (<algo>
712                  (<param_name1> <mpi>)
713                  ...
714                  (<param_namen> <mpi>)
715                ))
716
717 */
718 gcry_error_t
719 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
720 {
721   gcry_err_code_t rc;
722   gcry_pk_spec_t *spec;
723   gcry_sexp_t keyparms;
724
725   *r_ciph = NULL;
726
727   rc = spec_from_sexp (s_pkey, 0, &spec, &keyparms);
728   if (rc)
729     goto leave;
730
731   if (spec->encrypt)
732     rc = spec->encrypt (r_ciph, s_data, keyparms);
733   else
734     rc = GPG_ERR_NOT_IMPLEMENTED;
735
736  leave:
737   gcry_sexp_release (keyparms);
738   return gcry_error (rc);
739 }
740
741
742 /*
743    Do a PK decrypt operation
744
745    Caller has to provide a secret key as the SEXP skey and data in a
746    format as created by gcry_pk_encrypt.  For historic reasons the
747    function returns simply an MPI as an S-expression part; this is
748    deprecated and the new method should be used which returns a real
749    S-expressionl this is selected by adding at least an empty flags
750    list to S_DATA.
751
752    Returns: 0 or an errorcode.
753
754    s_data = (enc-val
755               [(flags [raw, pkcs1, oaep])]
756               (<algo>
757                 (<param_name1> <mpi>)
758                 ...
759                 (<param_namen> <mpi>)
760               ))
761    s_skey = <key-as-defined-in-sexp_to_key>
762    r_plain= Either an incomplete S-expression without the parentheses
763             or if the flags list is used (even if empty) a real S-expression:
764             (value PLAIN).  In raw mode (or no flags given) the returned value
765             is to be interpreted as a signed MPI, thus it may have an extra
766             leading zero octet even if not included in the original data.
767             With pkcs1 or oaep decoding enabled the returned value is a
768             verbatim octet string.
769  */
770 gcry_error_t
771 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
772 {
773   gcry_err_code_t rc;
774   gcry_pk_spec_t *spec;
775   gcry_sexp_t keyparms;
776
777   *r_plain = NULL;
778
779   rc = spec_from_sexp (s_skey, 1, &spec, &keyparms);
780   if (rc)
781     goto leave;
782
783   if (spec->decrypt)
784     rc = spec->decrypt (r_plain, s_data, keyparms);
785   else
786     rc = GPG_ERR_NOT_IMPLEMENTED;
787
788  leave:
789   gcry_sexp_release (keyparms);
790   return gcry_error (rc);
791 }
792
793
794
795 /*
796    Create a signature.
797
798    Caller has to provide a secret key as the SEXP skey and data
799    expressed as a SEXP list hash with only one element which should
800    instantly be available as a MPI. Alternatively the structure given
801    below may be used for S_HASH, it provides the abiliy to pass flags
802    to the operation; the flags defined by now are "pkcs1" which does
803    PKCS#1 block type 1 style padding and "pss" for PSS encoding.
804
805    Returns: 0 or an errorcode.
806             In case of 0 the function returns a new SEXP with the
807             signature value; the structure of this signature depends on the
808             other arguments but is always suitable to be passed to
809             gcry_pk_verify
810
811    s_hash = See comment for _gcry-pk_util_data_to_mpi
812
813    s_skey = <key-as-defined-in-sexp_to_key>
814    r_sig  = (sig-val
815               (<algo>
816                 (<param_name1> <mpi>)
817                 ...
818                 (<param_namen> <mpi>))
819              [(hash algo)])
820
821   Note that (hash algo) in R_SIG is not used.
822 */
823 gcry_error_t
824 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
825 {
826   gcry_err_code_t rc;
827   gcry_pk_spec_t *spec;
828   gcry_sexp_t keyparms;
829
830   *r_sig = NULL;
831
832   rc = spec_from_sexp (s_skey, 1, &spec, &keyparms);
833   if (rc)
834     goto leave;
835
836   if (spec->sign)
837     rc = spec->sign (r_sig, s_hash, keyparms);
838   else
839     rc = GPG_ERR_NOT_IMPLEMENTED;
840
841  leave:
842   gcry_sexp_release (keyparms);
843   return gcry_error (rc);
844 }
845
846
847 /*
848    Verify a signature.
849
850    Caller has to supply the public key pkey, the signature sig and his
851    hashvalue data.  Public key has to be a standard public key given
852    as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
853    must be an S-Exp like the one in sign too.  */
854 gcry_error_t
855 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
856 {
857   gcry_err_code_t rc;
858   gcry_pk_spec_t *spec;
859   gcry_sexp_t keyparms;
860
861   rc = spec_from_sexp (s_pkey, 0, &spec, &keyparms);
862   if (rc)
863     goto leave;
864
865   if (spec->verify)
866     rc = spec->verify (s_sig, s_hash, keyparms);
867   else
868     rc = GPG_ERR_NOT_IMPLEMENTED;
869
870  leave:
871   gcry_sexp_release (keyparms);
872   return gcry_error (rc);
873 }
874
875
876 /*
877    Test a key.
878
879    This may be used either for a public or a secret key to see whether
880    the internal structure is okay.
881
882    Returns: 0 or an errorcode.
883
884    s_key = <key-as-defined-in-sexp_to_key> */
885 gcry_error_t
886 gcry_pk_testkey (gcry_sexp_t s_key)
887 {
888   gcry_pk_spec_t *spec = NULL;
889   gcry_mpi_t *key = NULL;
890   gcry_err_code_t rc;
891
892   /* Note we currently support only secret key checking. */
893   rc = sexp_to_key (s_key, 1, 0, NULL, &key, &spec, NULL);
894   if (!rc)
895     {
896       rc = pubkey_check_secret_key (spec->algo, key);
897       release_mpi_array (key);
898       gcry_free (key);
899     }
900   return gcry_error (rc);
901 }
902
903
904 /*
905   Create a public key pair and return it in r_key.
906   How the key is created depends on s_parms:
907   (genkey
908    (algo
909      (parameter_name_1 ....)
910       ....
911      (parameter_name_n ....)
912   ))
913   The key is returned in a format depending on the
914   algorithm. Both, private and secret keys are returned
915   and optionally some additional informatin.
916   For elgamal we return this structure:
917   (key-data
918    (public-key
919      (elg
920         (p <mpi>)
921         (g <mpi>)
922         (y <mpi>)
923      )
924    )
925    (private-key
926      (elg
927         (p <mpi>)
928         (g <mpi>)
929         (y <mpi>)
930         (x <mpi>)
931      )
932    )
933    (misc-key-info
934       (pm1-factors n1 n2 ... nn)
935    ))
936  */
937 gcry_error_t
938 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
939 {
940   gcry_pk_spec_t *spec = NULL;
941   gcry_sexp_t list = NULL;
942   gcry_sexp_t l2 = NULL;
943   char *name = NULL;
944   gcry_err_code_t rc;
945
946   *r_key = NULL;
947
948   list = gcry_sexp_find_token (s_parms, "genkey", 0);
949   if (!list)
950     {
951       rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
952       goto leave;
953     }
954
955   l2 = gcry_sexp_cadr (list);
956   gcry_sexp_release (list);
957   list = l2;
958   l2 = NULL;
959   if (! list)
960     {
961       rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
962       goto leave;
963     }
964
965   name = _gcry_sexp_nth_string (list, 0);
966   if (!name)
967     {
968       rc = GPG_ERR_INV_OBJ; /* Algo string missing.  */
969       goto leave;
970     }
971
972   spec = spec_from_name (name);
973   gcry_free (name);
974   name = NULL;
975   if (!spec)
976     {
977       rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm.  */
978       goto leave;
979     }
980
981   if (spec->generate)
982     rc = spec->generate (list, r_key);
983   else
984     rc = GPG_ERR_NOT_IMPLEMENTED;
985
986  leave:
987   gcry_sexp_release (list);
988   gcry_free (name);
989   gcry_sexp_release (l2);
990
991   return gcry_error (rc);
992 }
993
994
995 /*
996    Get the number of nbits from the public key.
997
998    Hmmm: Should we have really this function or is it better to have a
999    more general function to retrieve different properties of the key?  */
1000 unsigned int
1001 gcry_pk_get_nbits (gcry_sexp_t key)
1002 {
1003   gcry_pk_spec_t *spec;
1004   gcry_sexp_t parms;
1005   unsigned int nbits;
1006
1007   /* Parsing KEY might be considered too much overhead.  For example
1008      for RSA we would only need to look at P and stop parsing right
1009      away.  However, with ECC things are more complicate in that only
1010      a curve name might be specified.  Thus we need to tear the sexp
1011      apart. */
1012
1013   if (spec_from_sexp (key, 0, &spec, &parms))
1014     return 0; /* Error - 0 is a suitable indication for that.  */
1015
1016   nbits = spec->get_nbits (parms);
1017   gcry_sexp_release (parms);
1018   return nbits;
1019 }
1020
1021
1022 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
1023    key parameters expressed in a way depending on the algorithm.
1024
1025    ARRAY must either be 20 bytes long or NULL; in the latter case a
1026    newly allocated array of that size is returned, otherwise ARRAY or
1027    NULL is returned to indicate an error which is most likely an
1028    unknown algorithm.  The function accepts public or secret keys. */
1029 unsigned char *
1030 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
1031 {
1032   gcry_sexp_t list = NULL;
1033   gcry_sexp_t l2 = NULL;
1034   gcry_pk_spec_t *spec = NULL;
1035   const char *s;
1036   char *name = NULL;
1037   int idx;
1038   const char *elems;
1039   gcry_md_hd_t md = NULL;
1040   int okay = 0;
1041
1042   /* Check that the first element is valid. */
1043   list = gcry_sexp_find_token (key, "public-key", 0);
1044   if (! list)
1045     list = gcry_sexp_find_token (key, "private-key", 0);
1046   if (! list)
1047     list = gcry_sexp_find_token (key, "protected-private-key", 0);
1048   if (! list)
1049     list = gcry_sexp_find_token (key, "shadowed-private-key", 0);
1050   if (! list)
1051     return NULL; /* No public- or private-key object. */
1052
1053   l2 = gcry_sexp_cadr (list);
1054   gcry_sexp_release (list);
1055   list = l2;
1056   l2 = NULL;
1057
1058   name = _gcry_sexp_nth_string (list, 0);
1059   if (!name)
1060     goto fail; /* Invalid structure of object. */
1061
1062   spec = spec_from_name (name);
1063   if (!spec)
1064     goto fail; /* Unknown algorithm.  */
1065
1066   elems = spec->elements_grip;
1067   if (!elems)
1068     goto fail; /* No grip parameter.  */
1069
1070   if (gcry_md_open (&md, GCRY_MD_SHA1, 0))
1071     goto fail;
1072
1073   if (spec->comp_keygrip)
1074     {
1075       /* Module specific method to compute a keygrip.  */
1076       if (spec->comp_keygrip (md, list))
1077         goto fail;
1078     }
1079   else
1080     {
1081       /* Generic method to compute a keygrip.  */
1082       for (idx = 0, s = elems; *s; s++, idx++)
1083         {
1084           const char *data;
1085           size_t datalen;
1086           char buf[30];
1087
1088           l2 = gcry_sexp_find_token (list, s, 1);
1089           if (! l2)
1090             goto fail;
1091           data = gcry_sexp_nth_data (l2, 1, &datalen);
1092           if (! data)
1093             goto fail;
1094
1095           snprintf (buf, sizeof buf, "(1:%c%u:", *s, (unsigned int)datalen);
1096           gcry_md_write (md, buf, strlen (buf));
1097           gcry_md_write (md, data, datalen);
1098           gcry_sexp_release (l2);
1099           l2 = NULL;
1100           gcry_md_write (md, ")", 1);
1101         }
1102     }
1103
1104   if (!array)
1105     {
1106       array = gcry_malloc (20);
1107       if (! array)
1108         goto fail;
1109     }
1110
1111   memcpy (array, gcry_md_read (md, GCRY_MD_SHA1), 20);
1112   okay = 1;
1113
1114  fail:
1115   gcry_free (name);
1116   gcry_sexp_release (l2);
1117   gcry_md_close (md);
1118   gcry_sexp_release (list);
1119   return okay? array : NULL;
1120 }
1121
1122
1123 \f
1124 const char *
1125 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
1126 {
1127   gcry_mpi_t *pkey = NULL;
1128   gcry_sexp_t list = NULL;
1129   gcry_sexp_t l2;
1130   char *name = NULL;
1131   const char *result = NULL;
1132   int want_private = 1;
1133   gcry_pk_spec_t *spec = NULL;
1134
1135   if (r_nbits)
1136     *r_nbits = 0;
1137
1138   if (key)
1139     {
1140       iterator = 0;
1141
1142       /* Check that the first element is valid. */
1143       list = gcry_sexp_find_token (key, "public-key", 0);
1144       if (list)
1145         want_private = 0;
1146       if (!list)
1147         list = gcry_sexp_find_token (key, "private-key", 0);
1148       if (!list)
1149         return NULL; /* No public- or private-key object. */
1150
1151       l2 = gcry_sexp_cadr (list);
1152       gcry_sexp_release (list);
1153       list = l2;
1154       l2 = NULL;
1155
1156       name = _gcry_sexp_nth_string (list, 0);
1157       if (!name)
1158         goto leave; /* Invalid structure of object. */
1159
1160       /* Get the key.  We pass the names of the parameters for
1161          override_elems; this allows to call this function without the
1162          actual public key parameter.  */
1163       if (sexp_to_key (key, want_private, 0, "pabgn", &pkey, &spec, NULL))
1164         goto leave;
1165     }
1166   else
1167     {
1168       spec = spec_from_name ("ecc");
1169       if (!spec)
1170         goto leave;
1171     }
1172
1173   if (!spec || !spec->get_curve)
1174     goto leave;
1175
1176   result = spec->get_curve (pkey, iterator, r_nbits);
1177
1178  leave:
1179   if (pkey)
1180     {
1181       release_mpi_array (pkey);
1182       gcry_free (pkey);
1183     }
1184   gcry_free (name);
1185   gcry_sexp_release (list);
1186   return result;
1187 }
1188
1189
1190 \f
1191 gcry_sexp_t
1192 gcry_pk_get_param (int algo, const char *name)
1193 {
1194   gcry_sexp_t result = NULL;
1195   gcry_pk_spec_t *spec = NULL;
1196
1197   algo = map_algo (algo);
1198
1199   if (algo != GCRY_PK_ECC)
1200     return NULL;
1201
1202   spec = spec_from_name ("ecc");
1203   if (spec)
1204     {
1205       if (spec && spec->get_curve_param)
1206         result = spec->get_curve_param (name);
1207     }
1208   return result;
1209 }
1210
1211
1212 \f
1213 gcry_error_t
1214 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
1215 {
1216   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1217
1218   switch (cmd)
1219     {
1220     case GCRYCTL_DISABLE_ALGO:
1221       /* This one expects a buffer pointing to an integer with the
1222          algo number.  */
1223       if ((! buffer) || (buflen != sizeof (int)))
1224         err = GPG_ERR_INV_ARG;
1225       else
1226         disable_pubkey_algo (*((int *) buffer));
1227       break;
1228
1229     default:
1230       err = GPG_ERR_INV_OP;
1231     }
1232
1233   return gcry_error (err);
1234 }
1235
1236
1237 /* Return information about the given algorithm
1238
1239    WHAT selects the kind of information returned:
1240
1241     GCRYCTL_TEST_ALGO:
1242         Returns 0 when the specified algorithm is available for use.
1243         Buffer must be NULL, nbytes  may have the address of a variable
1244         with the required usage of the algorithm. It may be 0 for don't
1245         care or a combination of the GCRY_PK_USAGE_xxx flags;
1246
1247     GCRYCTL_GET_ALGO_USAGE:
1248         Return the usage flags for the given algo.  An invalid algo
1249         returns 0.  Disabled algos are ignored here because we
1250         only want to know whether the algo is at all capable of
1251         the usage.
1252
1253    Note: Because this function is in most cases used to return an
1254    integer value, we can make it easier for the caller to just look at
1255    the return value.  The caller will in all cases consult the value
1256    and thereby detecting whether a error occurred or not (i.e. while
1257    checking the block size) */
1258 gcry_error_t
1259 gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
1260 {
1261   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1262
1263   switch (what)
1264     {
1265     case GCRYCTL_TEST_ALGO:
1266       {
1267         int use = nbytes ? *nbytes : 0;
1268         if (buffer)
1269           err = GPG_ERR_INV_ARG;
1270         else if (check_pubkey_algo (algorithm, use))
1271           err = GPG_ERR_PUBKEY_ALGO;
1272         break;
1273       }
1274
1275     case GCRYCTL_GET_ALGO_USAGE:
1276       {
1277         gcry_pk_spec_t *spec;
1278
1279         spec = spec_from_algo (algorithm);
1280         *nbytes = spec? spec->use : 0;
1281         break;
1282       }
1283
1284     case GCRYCTL_GET_ALGO_NPKEY:
1285       {
1286         /* FIXME?  */
1287         int npkey = pubkey_get_npkey (algorithm);
1288         *nbytes = npkey;
1289         break;
1290       }
1291     case GCRYCTL_GET_ALGO_NSKEY:
1292       {
1293         /* FIXME?  */
1294         int nskey = pubkey_get_nskey (algorithm);
1295         *nbytes = nskey;
1296         break;
1297       }
1298     case GCRYCTL_GET_ALGO_NSIGN:
1299       {
1300         /* FIXME?  */
1301         int nsign = pubkey_get_nsig (algorithm);
1302         *nbytes = nsign;
1303         break;
1304       }
1305     case GCRYCTL_GET_ALGO_NENCR:
1306       {
1307         /* FIXME?  */
1308         int nencr = pubkey_get_nenc (algorithm);
1309         *nbytes = nencr;
1310         break;
1311       }
1312
1313     default:
1314       err = GPG_ERR_INV_OP;
1315     }
1316
1317   return gcry_error (err);
1318 }
1319
1320
1321 /* Return an S-expression representing the context CTX.  Depending on
1322    the state of that context, the S-expression may either be a public
1323    key, a private key or any other object used with public key
1324    operations.  On success a new S-expression is stored at R_SEXP and
1325    0 is returned, on error NULL is store there and an error code is
1326    returned.  MODE is either 0 or one of the GCRY_PK_GET_xxx values.
1327
1328    As of now it only support certain ECC operations because a context
1329    object is right now only defined for ECC.  Over time this function
1330    will be extended to cover more algorithms.  Note also that the name
1331    of the function is gcry_pubkey_xxx and not gcry_pk_xxx.  The idea
1332    is that we will eventually provide variants of the existing
1333    gcry_pk_xxx functions which will take a context parameter.   */
1334 gcry_err_code_t
1335 _gcry_pubkey_get_sexp (gcry_sexp_t *r_sexp, int mode, gcry_ctx_t ctx)
1336 {
1337   mpi_ec_t ec;
1338
1339   if (!r_sexp)
1340     return GPG_ERR_INV_VALUE;
1341   *r_sexp = NULL;
1342   switch (mode)
1343     {
1344     case 0:
1345     case GCRY_PK_GET_PUBKEY:
1346     case GCRY_PK_GET_SECKEY:
1347       break;
1348     default:
1349       return GPG_ERR_INV_VALUE;
1350     }
1351   if (!ctx)
1352     return GPG_ERR_NO_CRYPT_CTX;
1353
1354   ec = _gcry_ctx_find_pointer (ctx, CONTEXT_TYPE_EC);
1355   if (ec)
1356     return _gcry_pk_ecc_get_sexp (r_sexp, mode, ec);
1357
1358   return GPG_ERR_WRONG_CRYPT_CTX;
1359 }
1360
1361
1362 \f
1363 /* Explicitly initialize this module.  */
1364 gcry_err_code_t
1365 _gcry_pk_init (void)
1366 {
1367   return 0;
1368 }
1369
1370
1371 /* Run the selftests for pubkey algorithm ALGO with optional reporting
1372    function REPORT.  */
1373 gpg_error_t
1374 _gcry_pk_selftest (int algo, int extended, selftest_report_func_t report)
1375 {
1376   gcry_err_code_t ec;
1377   gcry_pk_spec_t *spec;
1378
1379   algo = map_algo (algo);
1380   spec = spec_from_algo (algo);
1381   if (spec && !spec->flags.disabled && spec->selftest)
1382     ec = spec->selftest (algo, extended, report);
1383   else
1384     {
1385       ec = GPG_ERR_PUBKEY_ALGO;
1386       /* Fixme: We need to change the report fucntion to allow passing
1387          of an encryption mode (e.g. pkcs1, ecdsa, or ecdh).  */
1388       if (report)
1389         report ("pubkey", algo, "module",
1390                 spec && !spec->flags.disabled?
1391                 "no selftest available" :
1392                 spec? "algorithm disabled" :
1393                 "algorithm not found");
1394     }
1395
1396   return gpg_error (ec);
1397 }