7bea9ccc5c00f828e3c902562d127231844c4854
[gnupg.git] / 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 "../common/exechelp.h"
35 #include "../common/i18n.h"
36 #include "../common/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 (keygrip);
483   xfree (desc);
484   keydb_release (hd);
485 }
486
487
488 /* Print some info about the certifciate CERT to FP or STREAM */
489 static void
490 print_short_info (ksba_cert_t cert, estream_t stream)
491 {
492   char *p;
493   ksba_sexp_t sexp;
494   int idx;
495
496   for (idx=0; (p = ksba_cert_get_issuer (cert, idx)); idx++)
497     {
498       es_fputs ((!idx
499                  ?   "Issuer ...: "
500                  : "\n   aka ...: "), stream);
501       gpgsm_es_print_name (stream, p);
502       xfree (p);
503     }
504   es_putc ('\n', stream);
505
506   es_fputs ("Serial ...: ", stream);
507   sexp = ksba_cert_get_serial (cert);
508   if (sexp)
509     {
510       int len;
511       const unsigned char *s = sexp;
512
513       if (*s == '(')
514         {
515           s++;
516           for (len=0; *s && *s != ':' && digitp (s); s++)
517             len = len*10 + atoi_1 (s);
518           if (*s == ':')
519             es_write_hexstring (stream, s+1, len, 0, NULL);
520         }
521       xfree (sexp);
522     }
523   es_putc ('\n', stream);
524
525   for (idx=0; (p = ksba_cert_get_subject (cert, idx)); idx++)
526     {
527       es_fputs ((!idx
528                  ?   "Subject ..: "
529                  : "\n    aka ..: "), stream);
530       gpgsm_es_print_name (stream, p);
531       xfree (p);
532     }
533   es_putc ('\n', stream);
534
535   p = gpgsm_get_keygrip_hexstring (cert);
536   if (p)
537     {
538       es_fprintf (stream, "Keygrip ..: %s\n", p);
539       xfree (p);
540     }
541 }
542
543
544 \f
545 /* Parse a private key S-expression and return a malloced array with
546    the RSA parameters in pkcs#12 order.  The caller needs to
547    deep-release this array.  */
548 static gcry_mpi_t *
549 sexp_to_kparms (gcry_sexp_t sexp)
550 {
551   gcry_sexp_t list, l2;
552   const char *name;
553   const char *s;
554   size_t n;
555   int idx;
556   const char *elems;
557   gcry_mpi_t *array;
558
559   list = gcry_sexp_find_token (sexp, "private-key", 0 );
560   if(!list)
561     return NULL;
562   l2 = gcry_sexp_cadr (list);
563   gcry_sexp_release (list);
564   list = l2;
565   name = gcry_sexp_nth_data (list, 0, &n);
566   if(!name || n != 3 || memcmp (name, "rsa", 3))
567     {
568       gcry_sexp_release (list);
569       return NULL;
570     }
571
572   /* Parameter names used with RSA in the pkcs#12 order. */
573   elems = "nedqp--u";
574   array = xtrycalloc (strlen(elems) + 1, sizeof *array);
575   if (!array)
576     {
577       gcry_sexp_release (list);
578       return NULL;
579     }
580   for (idx=0, s=elems; *s; s++, idx++ )
581     {
582       if (*s == '-')
583         continue; /* Computed below  */
584       l2 = gcry_sexp_find_token (list, s, 1);
585       if (l2)
586         {
587           array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
588           gcry_sexp_release (l2);
589         }
590       if (!array[idx]) /* Required parameter not found or invalid.  */
591         {
592           for (idx=0; array[idx]; idx++)
593             gcry_mpi_release (array[idx]);
594           xfree (array);
595           gcry_sexp_release (list);
596           return NULL;
597         }
598     }
599   gcry_sexp_release (list);
600
601   array[5] = gcry_mpi_snew (0);  /* compute d mod (q-1) */
602   gcry_mpi_sub_ui (array[5], array[3], 1);
603   gcry_mpi_mod (array[5], array[2], array[5]);
604
605   array[6] = gcry_mpi_snew (0);  /* compute d mod (p-1) */
606   gcry_mpi_sub_ui (array[6], array[4], 1);
607   gcry_mpi_mod (array[6], array[2], array[6]);
608
609   return array;
610 }
611
612
613 static gpg_error_t
614 export_p12 (ctrl_t ctrl, const unsigned char *certimg, size_t certimglen,
615             const char *prompt, const char *keygrip, int rawmode,
616             void **r_result, size_t *r_resultlen)
617 {
618   gpg_error_t err = 0;
619   void *kek = NULL;
620   size_t keklen;
621   unsigned char *wrappedkey = NULL;
622   size_t wrappedkeylen;
623   gcry_cipher_hd_t cipherhd = NULL;
624   gcry_sexp_t s_skey = NULL;
625   gcry_mpi_t *kparms = NULL;
626   unsigned char *key = NULL;
627   size_t keylen;
628   char *passphrase = NULL;
629   unsigned char *result = NULL;
630   size_t resultlen;
631   int i;
632
633   *r_result = NULL;
634
635   /* Get the current KEK.  */
636   err = gpgsm_agent_keywrap_key (ctrl, 1, &kek, &keklen);
637   if (err)
638     {
639       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
640       goto leave;
641     }
642
643   /* Receive the wrapped key from the agent.  */
644   err = gpgsm_agent_export_key (ctrl, keygrip, prompt,
645                                 &wrappedkey, &wrappedkeylen);
646   if (err)
647     goto leave;
648
649
650   /* Unwrap the key.  */
651   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
652                           GCRY_CIPHER_MODE_AESWRAP, 0);
653   if (err)
654     goto leave;
655   err = gcry_cipher_setkey (cipherhd, kek, keklen);
656   if (err)
657     goto leave;
658   xfree (kek);
659   kek = NULL;
660
661   if (wrappedkeylen < 24)
662     {
663       err = gpg_error (GPG_ERR_INV_LENGTH);
664       goto leave;
665     }
666   keylen = wrappedkeylen - 8;
667   key = xtrymalloc_secure (keylen);
668   if (!key)
669     {
670       err = gpg_error_from_syserror ();
671       goto leave;
672     }
673   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
674   if (err)
675     goto leave;
676   xfree (wrappedkey);
677   wrappedkey = NULL;
678   gcry_cipher_close (cipherhd);
679   cipherhd = NULL;
680
681
682   /* Convert to a gcrypt S-expression.  */
683   err = gcry_sexp_create (&s_skey, key, keylen, 0, xfree_fnc);
684   if (err)
685     goto leave;
686   key = NULL; /* Key is now owned by S_KEY.  */
687
688   /* Get the parameters from the S-expression.  */
689   kparms = sexp_to_kparms (s_skey);
690   gcry_sexp_release (s_skey);
691   s_skey = NULL;
692   if (!kparms)
693     {
694       log_error ("error converting key parameters\n");
695       err = GPG_ERR_BAD_SECKEY;
696       goto leave;
697     }
698
699   if (rawmode)
700     {
701       /* Export in raw mode, that is only the pkcs#1/#8 private key. */
702       result = p12_raw_build (kparms, rawmode, &resultlen);
703       if (!result)
704         err = gpg_error (GPG_ERR_GENERAL);
705     }
706   else
707     {
708       err = gpgsm_agent_ask_passphrase
709         (ctrl,
710          i18n_utf8 ("Please enter the passphrase to protect the "
711                     "new PKCS#12 object."),
712          1, &passphrase);
713       if (err)
714         goto leave;
715
716       result = p12_build (kparms, certimg, certimglen, passphrase,
717                           opt.p12_charset, &resultlen);
718       xfree (passphrase);
719       passphrase = NULL;
720       if (!result)
721         err = gpg_error (GPG_ERR_GENERAL);
722     }
723
724  leave:
725   xfree (key);
726   gcry_sexp_release (s_skey);
727   if (kparms)
728     {
729       for (i=0; kparms[i]; i++)
730         gcry_mpi_release (kparms[i]);
731       xfree (kparms);
732     }
733   gcry_cipher_close (cipherhd);
734   xfree (wrappedkey);
735   xfree (kek);
736
737   if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
738     {
739       /* During export this is the passphrase used to unprotect the
740          key and not the pkcs#12 thing as in export.  Therefore we can
741          issue the regular passphrase status.  FIXME: replace the all
742          zero keyid by a regular one. */
743       gpgsm_status (ctrl, STATUS_BAD_PASSPHRASE, "0000000000000000");
744     }
745
746   if (err)
747     {
748       xfree (result);
749     }
750   else
751     {
752       *r_result = result;
753       *r_resultlen = resultlen;
754     }
755   return err;
756 }