g10/pkglue.c

   1 /* pkglue.c - public key operations glue code
   2  * Copyright (C) 2000, 2003, 2010 Free Software Foundation, Inc.
   3  * Copyright (C) 2014 Werner Koch
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27
  28 #include "gpg.h"
  29 #include "util.h"
  30 #include "pkglue.h"
  31 #include "main.h"
  32 #include "options.h"
  33
  34 /* FIXME: Better chnage the fucntion name because mpi_ is used by
  35    gcrypt macros.  */
  36 gcry_mpi_t
  37 get_mpi_from_sexp (gcry_sexp_t sexp, const char *item, int mpifmt)
  38 {
  39   gcry_sexp_t list;
  40   gcry_mpi_t data;
  41
  42   list = gcry_sexp_find_token (sexp, item, 0);
  43   assert (list);
  44   data = gcry_sexp_nth_mpi (list, 1, mpifmt);
  45   assert (data);
  46   gcry_sexp_release (list);
  47   return data;
  48 }
  49
  50
  51
  52 /****************
  53  * Emulate our old PK interface here - sometime in the future we might
  54  * change the internal design to directly fit to libgcrypt.
  55  */
  56 int
  57 pk_verify (pubkey_algo_t pkalgo, gcry_mpi_t hash,
  58            gcry_mpi_t *data, gcry_mpi_t *pkey)
  59 {
  60   gcry_sexp_t s_sig, s_hash, s_pkey;
  61   int rc;
  62
  63   /* Make a sexp from pkey.  */
  64   if (pkalgo == PUBKEY_ALGO_DSA)
  65     {
  66       rc = gcry_sexp_build (&s_pkey, NULL,
  67                             "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
  68                             pkey[0], pkey[1], pkey[2], pkey[3]);
  69     }
  70   else if (pkalgo == PUBKEY_ALGO_ELGAMAL_E || pkalgo == PUBKEY_ALGO_ELGAMAL)
  71     {
  72       rc = gcry_sexp_build (&s_pkey, NULL,
  73                             "(public-key(elg(p%m)(g%m)(y%m)))",
  74                             pkey[0], pkey[1], pkey[2]);
  75     }
  76   else if (pkalgo == PUBKEY_ALGO_RSA || pkalgo == PUBKEY_ALGO_RSA_S)
  77     {
  78       rc = gcry_sexp_build (&s_pkey, NULL,
  79                             "(public-key(rsa(n%m)(e%m)))", pkey[0], pkey[1]);
  80     }
  81   else if (pkalgo == PUBKEY_ALGO_ECDSA)
  82     {
  83       char *curve = openpgp_oid_to_str (pkey[0]);
  84       if (!curve)
  85         rc = gpg_error_from_syserror ();
  86       else
  87         {
  88           rc = gcry_sexp_build (&s_pkey, NULL,
  89                                 "(public-key(ecdsa(curve %s)(q%m)))",
  90                                 curve, pkey[1]);
  91           xfree (curve);
  92         }
  93     }
  94   else if (pkalgo == PUBKEY_ALGO_EDDSA)
  95     {
  96       char *curve = openpgp_oid_to_str (pkey[0]);
  97       if (!curve)
  98         rc = gpg_error_from_syserror ();
  99       else
 100         {
 101           rc = gcry_sexp_build (&s_pkey, NULL,
 102                                 "(public-key(ecc(curve %s)"
 103                                 "(flags eddsa)(q%m)))",
 104                                 curve, pkey[1]);
 105           xfree (curve);
 106         }
 107     }
 108   else
 109     return GPG_ERR_PUBKEY_ALGO;
 110
 111   if (rc)
 112     BUG ();  /* gcry_sexp_build should never fail.  */
 113
 114   /* Put hash into a S-Exp s_hash. */
 115   if (pkalgo == PUBKEY_ALGO_EDDSA)
 116     {
 117       if (gcry_sexp_build (&s_hash, NULL,
 118                            "(data(flags eddsa)(hash-algo sha512)(value %m))",
 119                            hash))
 120         BUG (); /* gcry_sexp_build should never fail.  */
 121     }
 122   else
 123     {
 124       if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
 125         BUG (); /* gcry_sexp_build should never fail.  */
 126     }
 127
 128   /* Put data into a S-Exp s_sig. */
 129   s_sig = NULL;
 130   if (pkalgo == PUBKEY_ALGO_DSA)
 131     {
 132       if (!data[0] || !data[1])
 133         rc = gpg_error (GPG_ERR_BAD_MPI);
 134       else
 135         rc = gcry_sexp_build (&s_sig, NULL,
 136                               "(sig-val(dsa(r%m)(s%m)))", data[0], data[1]);
 137     }
 138   else if (pkalgo == PUBKEY_ALGO_ECDSA)
 139     {
 140       if (!data[0] || !data[1])
 141         rc = gpg_error (GPG_ERR_BAD_MPI);
 142       else
 143         rc = gcry_sexp_build (&s_sig, NULL,
 144                               "(sig-val(ecdsa(r%m)(s%m)))", data[0], data[1]);
 145     }
 146   else if (pkalgo == PUBKEY_ALGO_EDDSA)
 147     {
 148       if (!data[0] || !data[1])
 149         rc = gpg_error (GPG_ERR_BAD_MPI);
 150       else
 151         rc = gcry_sexp_build (&s_sig, NULL,
 152                               "(sig-val(eddsa(r%M)(s%M)))", data[0], data[1]);
 153     }
 154   else if (pkalgo == PUBKEY_ALGO_ELGAMAL || pkalgo == PUBKEY_ALGO_ELGAMAL_E)
 155     {
 156       if (!data[0] || !data[1])
 157         rc = gpg_error (GPG_ERR_BAD_MPI);
 158       else
 159         rc = gcry_sexp_build (&s_sig, NULL,
 160                               "(sig-val(elg(r%m)(s%m)))", data[0], data[1]);
 161     }
 162   else if (pkalgo == PUBKEY_ALGO_RSA || pkalgo == PUBKEY_ALGO_RSA_S)
 163     {
 164       if (!data[0])
 165         rc = gpg_error (GPG_ERR_BAD_MPI);
 166       else
 167         rc = gcry_sexp_build (&s_sig, NULL, "(sig-val(rsa(s%m)))", data[0]);
 168     }
 169   else
 170     BUG ();
 171
 172   if (!rc)
 173     rc = gcry_pk_verify (s_sig, s_hash, s_pkey);
 174
 175   gcry_sexp_release (s_sig);
 176   gcry_sexp_release (s_hash);
 177   gcry_sexp_release (s_pkey);
 178   return rc;
 179 }
 180
 181
 182
 183
 184 /****************
 185  * Emulate our old PK interface here - sometime in the future we might
 186  * change the internal design to directly fit to libgcrypt.
 187  * PK is only required to compute the fingerprint for ECDH.
 188  */
 189 int
 190 pk_encrypt (pubkey_algo_t algo, gcry_mpi_t *resarr, gcry_mpi_t data,
 191             PKT_public_key *pk, gcry_mpi_t *pkey)
 192 {
 193   gcry_sexp_t s_ciph = NULL;
 194   gcry_sexp_t s_data = NULL;
 195   gcry_sexp_t s_pkey = NULL;
 196   int rc;
 197
 198   /* Make a sexp from pkey.  */
 199   if (algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
 200     {
 201       rc = gcry_sexp_build (&s_pkey, NULL,
 202                             "(public-key(elg(p%m)(g%m)(y%m)))",
 203                             pkey[0], pkey[1], pkey[2]);
 204       /* Put DATA into a simplified S-expression.  */
 205       if (!rc)
 206         rc = gcry_sexp_build (&s_data, NULL, "%m", data);
 207     }
 208   else if (algo == PUBKEY_ALGO_RSA || algo == PUBKEY_ALGO_RSA_E)
 209     {
 210       rc = gcry_sexp_build (&s_pkey, NULL,
 211                             "(public-key(rsa(n%m)(e%m)))",
 212                             pkey[0], pkey[1]);
 213       /* Put DATA into a simplified S-expression.  */
 214       if (!rc)
 215         rc = gcry_sexp_build (&s_data, NULL, "%m", data);
 216     }
 217   else if (algo == PUBKEY_ALGO_ECDH)
 218     {
 219       gcry_mpi_t k;
 220
 221       rc = pk_ecdh_generate_ephemeral_key (pkey, &k);
 222       if (!rc)
 223         {
 224           char *curve;
 225
 226           curve = openpgp_oid_to_str (pkey[0]);
 227           if (!curve)
 228             rc = gpg_error_from_syserror ();
 229           else
 230             {
 231               /* Now use the ephemeral secret to compute the shared point.  */
 232               rc = gcry_sexp_build (&s_pkey, NULL,
 233                                     "(public-key(ecdh(curve%s)(q%m)))",
 234                                     curve, pkey[1]);
 235               xfree (curve);
 236               /* Put K into a simplified S-expression.  */
 237               if (!rc)
 238                 rc = gcry_sexp_build (&s_data, NULL, "%m", k);
 239             }
 240           gcry_mpi_release (k);
 241         }
 242     }
 243   else
 244     rc = gpg_error (GPG_ERR_PUBKEY_ALGO);
 245
 246   /* Pass it to libgcrypt. */
 247   if (!rc)
 248     rc = gcry_pk_encrypt (&s_ciph, s_data, s_pkey);
 249
 250   gcry_sexp_release (s_data);
 251   gcry_sexp_release (s_pkey);
 252
 253   if (rc)
 254     ;
 255   else if (algo == PUBKEY_ALGO_ECDH)
 256     {
 257       gcry_mpi_t shared, public, result;
 258       byte fp[MAX_FINGERPRINT_LEN];
 259       size_t fpn;
 260
 261       /* Get the shared point and the ephemeral public key.  */
 262       shared = get_mpi_from_sexp (s_ciph, "s", GCRYMPI_FMT_USG);
 263       public = get_mpi_from_sexp (s_ciph, "e", GCRYMPI_FMT_USG);
 264       gcry_sexp_release (s_ciph);
 265       s_ciph = NULL;
 266       if (DBG_CRYPTO)
 267         {
 268           log_debug ("ECDH ephemeral key:");
 269           gcry_mpi_dump (public);
 270           log_printf ("\n");
 271         }
 272
 273       result = NULL;
 274       fingerprint_from_pk (pk, fp, &fpn);
 275       if (fpn != 20)
 276         rc = gpg_error (GPG_ERR_INV_LENGTH);
 277       else
 278         rc = pk_ecdh_encrypt_with_shared_point (1 /*=encrypton*/, shared,
 279                                                 fp, data, pkey, &result);
 280       gcry_mpi_release (shared);
 281       if (!rc)
 282         {
 283           resarr[0] = public;
 284           resarr[1] = result;
 285         }
 286       else
 287         {
 288           gcry_mpi_release (public);
 289           gcry_mpi_release (result);
 290         }
 291     }
 292   else /* Elgamal or RSA case.  */
 293     { /* Fixme: Add better error handling or make gnupg use
 294          S-expressions directly.  */
 295       resarr[0] = get_mpi_from_sexp (s_ciph, "a", GCRYMPI_FMT_USG);
 296       if (!is_RSA (algo))
 297         resarr[1] = get_mpi_from_sexp (s_ciph, "b", GCRYMPI_FMT_USG);
 298     }
 299
 300   gcry_sexp_release (s_ciph);
 301   return rc;
 302 }
 303
 304
 305 /* Check whether SKEY is a suitable secret key. */
 306 int
 307 pk_check_secret_key (pubkey_algo_t pkalgo, gcry_mpi_t *skey)
 308 {
 309   gcry_sexp_t s_skey;
 310   int rc;
 311
 312   if (pkalgo == PUBKEY_ALGO_DSA)
 313     {
 314       rc = gcry_sexp_build (&s_skey, NULL,
 315                             "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
 316                             skey[0], skey[1], skey[2], skey[3], skey[4]);
 317     }
 318   else if (pkalgo == PUBKEY_ALGO_ELGAMAL || pkalgo == PUBKEY_ALGO_ELGAMAL_E)
 319     {
 320       rc = gcry_sexp_build (&s_skey, NULL,
 321                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
 322                             skey[0], skey[1], skey[2], skey[3]);
 323     }
 324   else if (is_RSA (pkalgo))
 325     {
 326       rc = gcry_sexp_build (&s_skey, NULL,
 327                             "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
 328                             skey[0], skey[1], skey[2], skey[3], skey[4],
 329                             skey[5]);
 330     }
 331   else if (pkalgo == PUBKEY_ALGO_ECDSA || pkalgo == PUBKEY_ALGO_ECDH)
 332     {
 333       char *curve = openpgp_oid_to_str (skey[0]);
 334       if (!curve)
 335         rc = gpg_error_from_syserror ();
 336       else
 337         {
 338           rc = gcry_sexp_build (&s_skey, NULL,
 339                                 "(private-key(ecc(curve%s)(q%m)(d%m)))",
 340                                 curve, skey[1], skey[2]);
 341           xfree (curve);
 342         }
 343     }
 344   else if (pkalgo == PUBKEY_ALGO_EDDSA)
 345     {
 346       char *curve = openpgp_oid_to_str (skey[0]);
 347       if (!curve)
 348         rc = gpg_error_from_syserror ();
 349       else
 350         {
 351           rc = gcry_sexp_build (&s_skey, NULL,
 352                                 "(private-key(ecc(curve %s)"
 353                                 "(flags eddsa)(q%m)(d%m)))",
 354                                 curve, skey[1], skey[2]);
 355           xfree (curve);
 356         }
 357     }
 358   else
 359     return GPG_ERR_PUBKEY_ALGO;
 360
 361   if (!rc)
 362     {
 363       rc = gcry_pk_testkey (s_skey);
 364       gcry_sexp_release (s_skey);
 365     }
 366   return rc;
 367 }