Prepare for 1.5.0beta2
[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 <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);
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);
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 }