sm/export.c

   1 /* export.c - Export certificates and private keys.
   2  * Copyright (C) 2002, 2003, 2004, 2007, 2009,
   3  *               2010 Free Software Foundation, Inc.
   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 <time.h>
  27 #include <assert.h>
  28
  29 #include "gpgsm.h"
  30 #include <gcrypt.h>
  31 #include <ksba.h>
  32
  33 #include "keydb.h"
  34 #include "exechelp.h"
  35 #include "i18n.h"
  36 #include "sysutils.h"
  37 #include "minip12.h"
  38
  39 /* A table to store a fingerprint as used in a duplicates table.  We
  40    don't need to hash here because a fingerprint is already a perfect
  41    hash value.  This we use the most significant bits to index the
  42    table and then use a linked list for the overflow.  Possible
  43    enhancement for very large number of certificates:  Add a second
  44    level table and then resort to a linked list.  */
  45 struct duptable_s
  46 {
  47   struct duptable_s *next;
  48
  49   /* Note that we only need to store 19 bytes because the first byte
  50      is implictly given by the table index (we require at least 8
  51      bits). */
  52   unsigned char fpr[19];
  53 };
  54 typedef struct duptable_s *duptable_t;
  55 #define DUPTABLE_BITS 12
  56 #define DUPTABLE_SIZE (1 << DUPTABLE_BITS)
  57
  58
  59 static void print_short_info (ksba_cert_t cert, estream_t stream);
  60 static gpg_error_t export_p12 (ctrl_t ctrl,
  61                                const unsigned char *certimg, size_t certimglen,
  62                                const char *prompt, const char *keygrip,
  63                                void **r_result, size_t *r_resultlen);
  64
  65
  66 /* Create a table used to indetify duplicated certificates. */
  67 static duptable_t *
  68 create_duptable (void)
  69 {
  70   return xtrycalloc (DUPTABLE_SIZE, sizeof (duptable_t));
  71 }
  72
  73 static void
  74 destroy_duptable (duptable_t *table)
  75 {
  76   int idx;
  77   duptable_t t, t2;
  78
  79   if (table)
  80     {
  81       for (idx=0; idx < DUPTABLE_SIZE; idx++)
  82         for (t = table[idx]; t; t = t2)
  83           {
  84             t2 = t->next;
  85             xfree (t);
  86           }
  87       xfree (table);
  88     }
  89 }
  90
  91 /* Insert the 20 byte fingerprint FPR into TABLE.  Sets EXITS to true
  92    if the fingerprint already exists in the table. */
  93 static gpg_error_t
  94 insert_duptable (duptable_t *table, unsigned char *fpr, int *exists)
  95 {
  96   size_t idx;
  97   duptable_t t;
  98
  99   *exists = 0;
 100   idx = fpr[0];
 101 #if DUPTABLE_BITS > 16 || DUPTABLE_BITS < 8
 102 #error cannot handle a table larger than 16 bits or smaller than 8 bits
 103 #elif DUPTABLE_BITS > 8
 104   idx <<= (DUPTABLE_BITS - 8);
 105   idx |= (fpr[1] & ~(~0 << 4));
 106 #endif
 107
 108   for (t = table[idx]; t; t = t->next)
 109     if (!memcmp (t->fpr, fpr+1, 19))
 110       break;
 111   if (t)
 112     {
 113       *exists = 1;
 114       return 0;
 115     }
 116   /* Insert that fingerprint. */
 117   t = xtrymalloc (sizeof *t);
 118   if (!t)
 119     return gpg_error_from_syserror ();
 120   memcpy (t->fpr, fpr+1, 19);
 121   t->next = table[idx];
 122   table[idx] = t;
 123   return 0;
 124 }
 125
 126
 127 /* Export all certificates or just those given in NAMES.  The output
 128    is written to STREAM.  */
 129 void
 130 gpgsm_export (ctrl_t ctrl, strlist_t names, estream_t stream)
 131 {
 132   KEYDB_HANDLE hd = NULL;
 133   KEYDB_SEARCH_DESC *desc = NULL;
 134   int ndesc;
 135   Base64Context b64writer = NULL;
 136   ksba_writer_t writer;
 137   strlist_t sl;
 138   ksba_cert_t cert = NULL;
 139   int rc=0;
 140   int count = 0;
 141   int i;
 142   duptable_t *dtable;
 143
 144
 145   dtable = create_duptable ();
 146   if (!dtable)
 147     {
 148       log_error ("creating duplicates table failed: %s\n", strerror (errno));
 149       goto leave;
 150     }
 151
 152   hd = keydb_new (0);
 153   if (!hd)
 154     {
 155       log_error ("keydb_new failed\n");
 156       goto leave;
 157     }
 158
 159   if (!names)
 160     ndesc = 1;
 161   else
 162     {
 163       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++)
 164         ;
 165     }
 166
 167   desc = xtrycalloc (ndesc, sizeof *desc);
 168   if (!ndesc)
 169     {
 170       log_error ("allocating memory for export failed: %s\n",
 171                  gpg_strerror (out_of_core ()));
 172       goto leave;
 173     }
 174
 175   if (!names)
 176     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
 177   else
 178     {
 179       for (ndesc=0, sl=names; sl; sl = sl->next)
 180         {
 181           rc = classify_user_id (sl->d, desc+ndesc, 0);
 182           if (rc)
 183             {
 184               log_error ("key `%s' not found: %s\n",
 185                          sl->d, gpg_strerror (rc));
 186               rc = 0;
 187             }
 188           else
 189             ndesc++;
 190         }
 191     }
 192
 193   /* If all specifications are done by fingerprint or keygrip, we
 194      switch to ephemeral mode so that _all_ currently available and
 195      matching certificates are exported.  */
 196   if (names && ndesc)
 197     {
 198       for (i=0; (i < ndesc
 199                  && (desc[i].mode == KEYDB_SEARCH_MODE_FPR
 200                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR20
 201                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR16
 202                      || desc[i].mode == KEYDB_SEARCH_MODE_KEYGRIP)); i++)
 203         ;
 204       if (i == ndesc)
 205         keydb_set_ephemeral (hd, 1);
 206     }
 207
 208   while (!(rc = keydb_search (hd, desc, ndesc)))
 209     {
 210       unsigned char fpr[20];
 211       int exists;
 212
 213       if (!names)
 214         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
 215
 216       rc = keydb_get_cert (hd, &cert);
 217       if (rc)
 218         {
 219           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
 220           goto leave;
 221         }
 222
 223       gpgsm_get_fingerprint (cert, 0, fpr, NULL);
 224       rc = insert_duptable (dtable, fpr, &exists);
 225       if (rc)
 226         {
 227           log_error ("inserting into duplicates table failed: %s\n",
 228                      gpg_strerror (rc));
 229           goto leave;
 230         }
 231
 232       if (!exists && count && !ctrl->create_pem)
 233         {
 234           log_info ("exporting more than one certificate "
 235                     "is not possible in binary mode\n");
 236           log_info ("ignoring other certificates\n");
 237           break;
 238         }
 239
 240       if (!exists)
 241         {
 242           const unsigned char *image;
 243           size_t imagelen;
 244
 245           image = ksba_cert_get_image (cert, &imagelen);
 246           if (!image)
 247             {
 248               log_error ("ksba_cert_get_image failed\n");
 249               goto leave;
 250             }
 251
 252
 253           if (ctrl->create_pem)
 254             {
 255               if (count)
 256                 es_putc ('\n', stream);
 257               print_short_info (cert, stream);
 258               es_putc ('\n', stream);
 259             }
 260           count++;
 261
 262           if (!b64writer)
 263             {
 264               ctrl->pem_name = "CERTIFICATE";
 265               rc = gpgsm_create_writer (&b64writer, ctrl, stream, &writer);
 266               if (rc)
 267                 {
 268                   log_error ("can't create writer: %s\n", gpg_strerror (rc));
 269                   goto leave;
 270                 }
 271             }
 272
 273           rc = ksba_writer_write (writer, image, imagelen);
 274           if (rc)
 275             {
 276               log_error ("write error: %s\n", gpg_strerror (rc));
 277               goto leave;
 278             }
 279
 280           if (ctrl->create_pem)
 281             {
 282               /* We want one certificate per PEM block */
 283               rc = gpgsm_finish_writer (b64writer);
 284               if (rc)
 285                 {
 286                   log_error ("write failed: %s\n", gpg_strerror (rc));
 287                   goto leave;
 288                 }
 289               gpgsm_destroy_writer (b64writer);
 290               b64writer = NULL;
 291             }
 292         }
 293
 294       ksba_cert_release (cert);
 295       cert = NULL;
 296     }
 297   if (rc && rc != -1)
 298     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
 299   else if (b64writer)
 300     {
 301       rc = gpgsm_finish_writer (b64writer);
 302       if (rc)
 303         {
 304           log_error ("write failed: %s\n", gpg_strerror (rc));
 305           goto leave;
 306         }
 307     }
 308
 309  leave:
 310   gpgsm_destroy_writer (b64writer);
 311   ksba_cert_release (cert);
 312   xfree (desc);
 313   keydb_release (hd);
 314   destroy_duptable (dtable);
 315 }
 316
 317
 318 /* Export a certificate and its private key. */
 319 void
 320 gpgsm_p12_export (ctrl_t ctrl, const char *name, estream_t stream)
 321 {
 322   gpg_error_t err = 0;
 323   KEYDB_HANDLE hd;
 324   KEYDB_SEARCH_DESC *desc = NULL;
 325   Base64Context b64writer = NULL;
 326   ksba_writer_t writer;
 327   ksba_cert_t cert = NULL;
 328   const unsigned char *image;
 329   size_t imagelen;
 330   char *keygrip = NULL;
 331   char *prompt;
 332   void *data;
 333   size_t datalen;
 334
 335
 336   hd = keydb_new (0);
 337   if (!hd)
 338     {
 339       log_error ("keydb_new failed\n");
 340       goto leave;
 341     }
 342
 343   desc = xtrycalloc (1, sizeof *desc);
 344   if (!desc)
 345     {
 346       log_error ("allocating memory for export failed: %s\n",
 347                  gpg_strerror (out_of_core ()));
 348       goto leave;
 349     }
 350
 351   err = classify_user_id (name, desc, 0);
 352   if (err)
 353     {
 354       log_error ("key `%s' not found: %s\n",
 355                  name, gpg_strerror (err));
 356       goto leave;
 357     }
 358
 359   /* Lookup the certificate and make sure that it is unique. */
 360   err = keydb_search (hd, desc, 1);
 361   if (!err)
 362     {
 363       err = keydb_get_cert (hd, &cert);
 364       if (err)
 365         {
 366           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (err));
 367           goto leave;
 368         }
 369
 370     next_ambiguous:
 371       err = keydb_search (hd, desc, 1);
 372       if (!err)
 373         {
 374           ksba_cert_t cert2 = NULL;
 375
 376           if (!keydb_get_cert (hd, &cert2))
 377             {
 378               if (gpgsm_certs_identical_p (cert, cert2))
 379                 {
 380                   ksba_cert_release (cert2);
 381                   goto next_ambiguous;
 382                 }
 383               ksba_cert_release (cert2);
 384             }
 385           err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
 386         }
 387       else if (err == -1 || gpg_err_code (err) == GPG_ERR_EOF)
 388         err = 0;
 389       if (err)
 390         {
 391           log_error ("key `%s' not found: %s\n",
 392                      name, gpg_strerror (err));
 393           goto leave;
 394         }
 395     }
 396
 397   keygrip = gpgsm_get_keygrip_hexstring (cert);
 398   if (!keygrip || gpgsm_agent_havekey (ctrl, keygrip))
 399     {
 400       /* Note, that the !keygrip case indicates a bad certificate. */
 401       err = gpg_error (GPG_ERR_NO_SECKEY);
 402       log_error ("can't export key `%s': %s\n", name, gpg_strerror (err));
 403       goto leave;
 404     }
 405
 406   image = ksba_cert_get_image (cert, &imagelen);
 407   if (!image)
 408     {
 409       log_error ("ksba_cert_get_image failed\n");
 410       goto leave;
 411     }
 412
 413   if (ctrl->create_pem)
 414     {
 415       print_short_info (cert, stream);
 416       es_putc ('\n', stream);
 417     }
 418
 419   if (opt.p12_charset && ctrl->create_pem)
 420     {
 421       es_fprintf (stream, "The passphrase is %s encoded.\n\n",
 422                   opt.p12_charset);
 423     }
 424
 425   ctrl->pem_name = "PKCS12";
 426   err = gpgsm_create_writer (&b64writer, ctrl, stream, &writer);
 427   if (err)
 428     {
 429       log_error ("can't create writer: %s\n", gpg_strerror (err));
 430       goto leave;
 431     }
 432
 433   prompt = gpgsm_format_keydesc (cert);
 434   err = export_p12 (ctrl, image, imagelen, prompt, keygrip, &data, &datalen);
 435   xfree (prompt);
 436   if (err)
 437     goto leave;
 438   err = ksba_writer_write (writer, data, datalen);
 439   xfree (data);
 440   if (err)
 441     {
 442       log_error ("write failed: %s\n", gpg_strerror (err));
 443       goto leave;
 444     }
 445
 446   if (ctrl->create_pem)
 447     {
 448       /* We want one certificate per PEM block */
 449       err = gpgsm_finish_writer (b64writer);
 450       if (err)
 451         {
 452           log_error ("write failed: %s\n", gpg_strerror (err));
 453           goto leave;
 454         }
 455       gpgsm_destroy_writer (b64writer);
 456       b64writer = NULL;
 457     }
 458
 459   ksba_cert_release (cert);
 460   cert = NULL;
 461
 462  leave:
 463   gpgsm_destroy_writer (b64writer);
 464   ksba_cert_release (cert);
 465   xfree (desc);
 466   keydb_release (hd);
 467 }
 468
 469
 470 /* Print some info about the certifciate CERT to FP or STREAM */
 471 static void
 472 print_short_info (ksba_cert_t cert, estream_t stream)
 473 {
 474   char *p;
 475   ksba_sexp_t sexp;
 476   int idx;
 477
 478   for (idx=0; (p = ksba_cert_get_issuer (cert, idx)); idx++)
 479     {
 480       es_fputs ((!idx
 481                  ?   "Issuer ...: "
 482                  : "\n   aka ...: "), stream);
 483       gpgsm_es_print_name (stream, p);
 484       xfree (p);
 485     }
 486   es_putc ('\n', stream);
 487
 488   es_fputs ("Serial ...: ", stream);
 489   sexp = ksba_cert_get_serial (cert);
 490   if (sexp)
 491     {
 492       int len;
 493       const unsigned char *s = sexp;
 494
 495       if (*s == '(')
 496         {
 497           s++;
 498           for (len=0; *s && *s != ':' && digitp (s); s++)
 499             len = len*10 + atoi_1 (s);
 500           if (*s == ':')
 501             es_write_hexstring (stream, s+1, len, 0, NULL);
 502         }
 503       xfree (sexp);
 504     }
 505   es_putc ('\n', stream);
 506
 507   for (idx=0; (p = ksba_cert_get_subject (cert, idx)); idx++)
 508     {
 509       es_fputs ((!idx
 510                  ?   "Subject ..: "
 511                  : "\n    aka ..: "), stream);
 512       gpgsm_es_print_name (stream, p);
 513       xfree (p);
 514     }
 515   es_putc ('\n', stream);
 516 }
 517
 518
 519 \f
 520 /* Parse a private key S-expression and retutn a malloced array with
 521    the RSA paramaters in pkcs#12 order.  The caller needs to
 522    deep-release this array.  */
 523 static gcry_mpi_t *
 524 sexp_to_kparms (gcry_sexp_t sexp)
 525 {
 526   gcry_sexp_t list, l2;
 527   const char *name;
 528   const char *s;
 529   size_t n;
 530   int idx;
 531   const char *elems;
 532   gcry_mpi_t *array;
 533
 534   list = gcry_sexp_find_token (sexp, "private-key", 0 );
 535   if(!list)
 536     return NULL;
 537   l2 = gcry_sexp_cadr (list);
 538   gcry_sexp_release (list);
 539   list = l2;
 540   name = gcry_sexp_nth_data (list, 0, &n);
 541   if(!name || n != 3 || memcmp (name, "rsa", 3))
 542     {
 543       gcry_sexp_release (list);
 544       return NULL;
 545     }
 546
 547   /* Parameter names used with RSA in the pkcs#12 order. */
 548   elems = "nedqp--u";
 549   array = xtrycalloc (strlen(elems) + 1, sizeof *array);
 550   if (!array)
 551     {
 552       gcry_sexp_release (list);
 553       return NULL;
 554     }
 555   for (idx=0, s=elems; *s; s++, idx++ )
 556     {
 557       if (*s == '-')
 558         continue; /* Computed below  */
 559       l2 = gcry_sexp_find_token (list, s, 1);
 560       if (l2)
 561         {
 562           array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
 563           gcry_sexp_release (l2);
 564         }
 565       if (!array[idx]) /* Required parameter not found or invalid.  */
 566         {
 567           for (idx=0; array[idx]; idx++)
 568             gcry_mpi_release (array[idx]);
 569           xfree (array);
 570           gcry_sexp_release (list);
 571           return NULL;
 572         }
 573     }
 574   gcry_sexp_release (list);
 575
 576   array[5] = gcry_mpi_snew (0);  /* compute d mod (q-1) */
 577   gcry_mpi_sub_ui (array[5], array[3], 1);
 578   gcry_mpi_mod (array[5], array[2], array[5]);
 579
 580   array[6] = gcry_mpi_snew (0);  /* compute d mod (p-1) */
 581   gcry_mpi_sub_ui (array[6], array[4], 1);
 582   gcry_mpi_mod (array[6], array[3], array[6]);
 583
 584   return array;
 585 }
 586
 587
 588 static gpg_error_t
 589 export_p12 (ctrl_t ctrl, const unsigned char *certimg, size_t certimglen,
 590             const char *prompt, const char *keygrip,
 591             void **r_result, size_t *r_resultlen)
 592 {
 593   gpg_error_t err = 0;
 594   void *kek = NULL;
 595   size_t keklen;
 596   unsigned char *wrappedkey = NULL;
 597   size_t wrappedkeylen;
 598   gcry_cipher_hd_t cipherhd = NULL;
 599   gcry_sexp_t s_skey = NULL;
 600   gcry_mpi_t *kparms = NULL;
 601   unsigned char *key = NULL;
 602   size_t keylen;
 603   char *passphrase = NULL;
 604   unsigned char *result = NULL;
 605   size_t resultlen;
 606   int i;
 607
 608   *r_result = NULL;
 609
 610   /* Get the current KEK.  */
 611   err = gpgsm_agent_keywrap_key (ctrl, 1, &kek, &keklen);
 612   if (err)
 613     {
 614       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
 615       goto leave;
 616     }
 617
 618   /* Receive the wrapped key from the agent.  */
 619   err = gpgsm_agent_export_key (ctrl, keygrip, prompt,
 620                                 &wrappedkey, &wrappedkeylen);
 621   if (err)
 622     goto leave;
 623
 624
 625   /* Unwrap the key.  */
 626   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
 627                           GCRY_CIPHER_MODE_AESWRAP, 0);
 628   if (err)
 629     goto leave;
 630   err = gcry_cipher_setkey (cipherhd, kek, keklen);
 631   if (err)
 632     goto leave;
 633   xfree (kek);
 634   kek = NULL;
 635
 636   if (wrappedkeylen < 24)
 637     {
 638       err = gpg_error (GPG_ERR_INV_LENGTH);
 639       goto leave;
 640     }
 641   keylen = wrappedkeylen - 8;
 642   key = xtrymalloc_secure (keylen);
 643   if (!key)
 644     {
 645       err = gpg_error_from_syserror ();
 646       goto leave;
 647     }
 648   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
 649   if (err)
 650     goto leave;
 651   xfree (wrappedkey);
 652   wrappedkey = NULL;
 653   gcry_cipher_close (cipherhd);
 654   cipherhd = NULL;
 655
 656
 657   /* Convert to a gcrypt S-expression.  */
 658   err = gcry_sexp_create (&s_skey, key, keylen, 0, xfree_fnc);
 659   if (err)
 660     goto leave;
 661   key = NULL; /* Key is now owned by S_KEY.  */
 662
 663   /* Get the parameters from the S-expression.  */
 664   kparms = sexp_to_kparms (s_skey);
 665   gcry_sexp_release (s_skey);
 666   s_skey = NULL;
 667   if (!kparms)
 668     {
 669       log_error ("error converting key parameters\n");
 670       err = GPG_ERR_BAD_SECKEY;
 671       goto leave;
 672     }
 673
 674   err = gpgsm_agent_ask_passphrase
 675     (ctrl,
 676      i18n_utf8 ("Please enter the passphrase to protect the "
 677                 "new PKCS#12 object."),
 678      1, &passphrase);
 679   if (err)
 680     goto leave;
 681
 682   result = p12_build (kparms, certimg, certimglen, passphrase,
 683                       opt.p12_charset, &resultlen);
 684   xfree (passphrase);
 685   passphrase = NULL;
 686   if (!result)
 687     err = gpg_error (GPG_ERR_GENERAL);
 688
 689  leave:
 690   xfree (key);
 691   gcry_sexp_release (s_skey);
 692   if (kparms)
 693     {
 694       for (i=0; kparms[i]; i++)
 695         gcry_mpi_release (kparms[i]);
 696       xfree (kparms);
 697     }
 698   gcry_cipher_close (cipherhd);
 699   xfree (wrappedkey);
 700   xfree (kek);
 701
 702   if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
 703     {
 704       /* During export this is the passphrase used to unprotect the
 705          key and not the pkcs#12 thing as in export.  Therefore we can
 706          issue the regular passphrase status.  FIXME: replace the all
 707          zero keyid by a regular one. */
 708       gpgsm_status (ctrl, STATUS_BAD_PASSPHRASE, "0000000000000000");
 709     }
 710
 711   if (err)
 712     {
 713       xfree (result);
 714     }
 715   else
 716     {
 717       *r_result = result;
 718       *r_resultlen = resultlen;
 719     }
 720   return err;
 721 }