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