Implement export of pkcs#12 objects using a direct agent connection.
[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,
266                                         NULL, stream, &writer);
267               if (rc)
268                 {
269                   log_error ("can't create writer: %s\n", gpg_strerror (rc));
270                   goto leave;
271                 }
272             }
273
274           rc = ksba_writer_write (writer, image, imagelen);
275           if (rc)
276             {
277               log_error ("write error: %s\n", gpg_strerror (rc));
278               goto leave;
279             }
280
281           if (ctrl->create_pem)
282             {
283               /* We want one certificate per PEM block */
284               rc = gpgsm_finish_writer (b64writer);
285               if (rc) 
286                 {
287                   log_error ("write failed: %s\n", gpg_strerror (rc));
288                   goto leave;
289                 }
290               gpgsm_destroy_writer (b64writer);
291               b64writer = NULL;
292             }
293         }
294
295       ksba_cert_release (cert); 
296       cert = NULL;
297     }
298   if (rc && rc != -1)
299     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
300   else if (b64writer)
301     {
302       rc = gpgsm_finish_writer (b64writer);
303       if (rc) 
304         {
305           log_error ("write failed: %s\n", gpg_strerror (rc));
306           goto leave;
307         }
308     }
309   
310  leave:
311   gpgsm_destroy_writer (b64writer);
312   ksba_cert_release (cert);
313   xfree (desc);
314   keydb_release (hd);
315   destroy_duptable (dtable);
316 }
317
318
319 /* Export a certificate and its private key. */
320 void
321 gpgsm_p12_export (ctrl_t ctrl, const char *name, estream_t stream)
322 {
323   gpg_error_t err = 0;
324   KEYDB_HANDLE hd;
325   KEYDB_SEARCH_DESC *desc = NULL;
326   Base64Context b64writer = NULL;
327   ksba_writer_t writer;
328   ksba_cert_t cert = NULL;
329   const unsigned char *image;
330   size_t imagelen;
331   char *keygrip = NULL;
332   char *prompt;
333   void *data;
334   size_t datalen;
335
336
337   hd = keydb_new (0);
338   if (!hd)
339     {
340       log_error ("keydb_new failed\n");
341       goto leave;
342     }
343
344   desc = xtrycalloc (1, sizeof *desc);
345   if (!desc)
346     {
347       log_error ("allocating memory for export failed: %s\n",
348                  gpg_strerror (out_of_core ()));
349       goto leave;
350     }
351
352   err = classify_user_id (name, desc);
353   if (err)
354     {
355       log_error ("key `%s' not found: %s\n",
356                  name, gpg_strerror (err));
357       goto leave;
358     }
359
360   /* Lookup the certificate and make sure that it is unique. */
361   err = keydb_search (hd, desc, 1);
362   if (!err)
363     {
364       err = keydb_get_cert (hd, &cert);
365       if (err) 
366         {
367           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (err));
368           goto leave;
369         }
370
371     next_ambiguous:      
372       err = keydb_search (hd, desc, 1);
373       if (!err)
374         {
375           ksba_cert_t cert2 = NULL;
376
377           if (!keydb_get_cert (hd, &cert2))
378             {
379               if (gpgsm_certs_identical_p (cert, cert2))
380                 {
381                   ksba_cert_release (cert2);
382                   goto next_ambiguous;
383                 }
384               ksba_cert_release (cert2);
385             }
386           err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
387         }
388       else if (err == -1 || gpg_err_code (err) == GPG_ERR_EOF)
389         err = 0;
390       if (err)
391         {
392           log_error ("key `%s' not found: %s\n",
393                      name, gpg_strerror (err));
394           goto leave;
395         }
396     }
397       
398   keygrip = gpgsm_get_keygrip_hexstring (cert);
399   if (!keygrip || gpgsm_agent_havekey (ctrl, keygrip))
400     {
401       /* Note, that the !keygrip case indicates a bad certificate. */
402       err = gpg_error (GPG_ERR_NO_SECKEY);
403       log_error ("can't export key `%s': %s\n", name, gpg_strerror (err));
404       goto leave;
405     }
406   
407   image = ksba_cert_get_image (cert, &imagelen);
408   if (!image)
409     {
410       log_error ("ksba_cert_get_image failed\n");
411       goto leave;
412     }
413
414   if (ctrl->create_pem)
415     {
416       print_short_info (cert, stream);
417       es_putc ('\n', stream);
418     }
419
420   if (opt.p12_charset && ctrl->create_pem)
421     {
422       es_fprintf (stream, "The passphrase is %s encoded.\n\n",
423                   opt.p12_charset);
424     }
425
426   ctrl->pem_name = "PKCS12";
427   err = gpgsm_create_writer (&b64writer, ctrl, NULL, stream, &writer);
428   if (err)
429     {
430       log_error ("can't create writer: %s\n", gpg_strerror (err));
431       goto leave;
432     }
433
434   prompt = gpgsm_format_keydesc (cert);
435   err = export_p12 (ctrl, image, imagelen, prompt, keygrip, &data, &datalen);
436   xfree (prompt);
437   if (err)
438     goto leave;
439   err = ksba_writer_write (writer, data, datalen);
440   xfree (data);
441   if (err)
442     {
443       log_error ("write failed: %s\n", gpg_strerror (err));
444       goto leave;
445     }
446
447   if (ctrl->create_pem)
448     {
449       /* We want one certificate per PEM block */
450       err = gpgsm_finish_writer (b64writer);
451       if (err) 
452         {
453           log_error ("write failed: %s\n", gpg_strerror (err));
454           goto leave;
455         }
456       gpgsm_destroy_writer (b64writer);
457       b64writer = NULL;
458     }
459   
460   ksba_cert_release (cert); 
461   cert = NULL;
462
463  leave:
464   gpgsm_destroy_writer (b64writer);
465   ksba_cert_release (cert);
466   xfree (desc);
467   keydb_release (hd);
468 }
469
470
471 /* Print some info about the certifciate CERT to FP or STREAM */
472 static void
473 print_short_info (ksba_cert_t cert, estream_t stream)
474 {
475   char *p;
476   ksba_sexp_t sexp;
477   int idx;
478
479   for (idx=0; (p = ksba_cert_get_issuer (cert, idx)); idx++)
480     {
481       es_fputs ((!idx
482                  ?   "Issuer ...: "
483                  : "\n   aka ...: "), stream); 
484       gpgsm_es_print_name (stream, p);
485       xfree (p);
486     }
487   es_putc ('\n', stream);
488
489   es_fputs ("Serial ...: ", stream); 
490   sexp = ksba_cert_get_serial (cert);
491   if (sexp)
492     {
493       int len;
494       const unsigned char *s = sexp;
495       
496       if (*s == '(')
497         {
498           s++;
499           for (len=0; *s && *s != ':' && digitp (s); s++)
500             len = len*10 + atoi_1 (s);
501           if (*s == ':')
502             es_write_hexstring (stream, s+1, len, 0, NULL);
503         }
504       xfree (sexp);
505     }
506   es_putc ('\n', stream);
507
508   for (idx=0; (p = ksba_cert_get_subject (cert, idx)); idx++)
509     {
510       es_fputs ((!idx
511                  ?   "Subject ..: "
512                  : "\n    aka ..: "), stream); 
513       gpgsm_es_print_name (stream, p);
514       xfree (p);
515     }
516   es_putc ('\n', stream);
517 }
518
519
520 \f
521 /* Parse a private key S-expression and retutn a malloced array with
522    the RSA paramaters in pkcs#12 order.  The caller needs to
523    deep-release this array.  */
524 static gcry_mpi_t *
525 sexp_to_kparms (gcry_sexp_t sexp)
526 {
527   gcry_sexp_t list, l2;
528   const char *name;
529   const char *s;
530   size_t n;
531   int idx;
532   const char *elems;
533   gcry_mpi_t *array;
534
535   list = gcry_sexp_find_token (sexp, "private-key", 0 );
536   if(!list)
537     return NULL; 
538   l2 = gcry_sexp_cadr (list);
539   gcry_sexp_release (list);
540   list = l2;
541   name = gcry_sexp_nth_data (list, 0, &n);
542   if(!name || n != 3 || memcmp (name, "rsa", 3))
543     {
544       gcry_sexp_release (list);
545       return NULL;
546     }
547
548   /* Parameter names used with RSA in the pkcs#12 order. */
549   elems = "nedqp--u";
550   array = xtrycalloc (strlen(elems) + 1, sizeof *array);
551   if (!array)
552     {
553       gcry_sexp_release (list);
554       return NULL;
555     }
556   for (idx=0, s=elems; *s; s++, idx++ ) 
557     {
558       if (*s == '-')
559         continue; /* Computed below  */
560       l2 = gcry_sexp_find_token (list, s, 1);
561       if (l2)
562         {
563           array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
564           gcry_sexp_release (l2);
565         }
566       if (!array[idx]) /* Required parameter not found or invalid.  */
567         {
568           for (idx=0; array[idx]; idx++)
569             gcry_mpi_release (array[idx]);
570           xfree (array);
571           gcry_sexp_release (list);
572           return NULL;
573         }
574     }
575   gcry_sexp_release (list);
576
577   array[5] = gcry_mpi_snew (0);  /* compute d mod (q-1) */
578   gcry_mpi_sub_ui (array[5], array[3], 1);
579   gcry_mpi_mod (array[5], array[2], array[5]);   
580
581   array[6] = gcry_mpi_snew (0);  /* compute d mod (p-1) */
582   gcry_mpi_sub_ui (array[6], array[4], 1);
583   gcry_mpi_mod (array[6], array[3], array[6]);   
584
585   return array;
586 }
587
588
589 static gpg_error_t
590 export_p12 (ctrl_t ctrl, const unsigned char *certimg, size_t certimglen,
591             const char *prompt, const char *keygrip,
592             void **r_result, size_t *r_resultlen)
593 {
594   gpg_error_t err = 0;
595   void *kek = NULL;
596   size_t keklen;
597   unsigned char *wrappedkey = NULL;
598   size_t wrappedkeylen;
599   gcry_cipher_hd_t cipherhd = NULL;
600   gcry_sexp_t s_skey = NULL;
601   gcry_mpi_t *kparms = NULL;
602   unsigned char *key = NULL;
603   size_t keylen;
604   char *passphrase = NULL;
605   unsigned char *result = NULL;
606   size_t resultlen;
607   int i;
608
609   *r_result = NULL;
610
611   /* Get the current KEK.  */
612   err = gpgsm_agent_keywrap_key (ctrl, 1, &kek, &keklen);
613   if (err)
614     {
615       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
616       goto leave;
617     }
618
619   /* Receive the wrapped key from the agent.  */
620   err = gpgsm_agent_export_key (ctrl, keygrip, prompt, 
621                                 &wrappedkey, &wrappedkeylen);
622   if (err)
623     goto leave;
624
625
626   /* Unwrap the key.  */
627   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
628                           GCRY_CIPHER_MODE_AESWRAP, 0);
629   if (err)
630     goto leave;
631   err = gcry_cipher_setkey (cipherhd, kek, keklen);
632   if (err)
633     goto leave;
634   xfree (kek);
635   kek = NULL;
636
637   if (wrappedkeylen < 24)
638     {
639       err = gpg_error (GPG_ERR_INV_LENGTH);
640       goto leave;
641     }
642   keylen = wrappedkeylen - 8;
643   key = xtrymalloc_secure (keylen);
644   if (!key)
645     {
646       err = gpg_error_from_syserror ();
647       goto leave;
648     }
649   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
650   if (err)
651     goto leave;
652   xfree (wrappedkey);
653   wrappedkey = NULL;
654   gcry_cipher_close (cipherhd);
655   cipherhd = NULL;
656
657
658   /* Convert to a gcrypt S-expression.  */
659   err = gcry_sexp_create (&s_skey, key, keylen, 0, xfree_fnc);
660   if (err)
661     goto leave;
662   key = NULL; /* Key is now owned by S_KEY.  */
663
664   /* Get the parameters from the S-expression.  */
665   kparms = sexp_to_kparms (s_skey);
666   gcry_sexp_release (s_skey);
667   s_skey = NULL;
668   if (!kparms)
669     {
670       log_error ("error converting key parameters\n");
671       err = GPG_ERR_BAD_SECKEY;
672       goto leave;
673     } 
674     
675   err = gpgsm_agent_ask_passphrase
676     (ctrl,
677      i18n_utf8 ("Please enter the passphrase to protect the "
678                 "new PKCS#12 object."),
679      1, &passphrase);
680   if (err)
681     goto leave;
682
683   result = p12_build (kparms, certimg, certimglen, passphrase,
684                       opt.p12_charset, &resultlen);
685   xfree (passphrase);
686   passphrase = NULL;
687   if (!result)
688     err = gpg_error (GPG_ERR_GENERAL);
689   
690  leave:
691   xfree (key);
692   gcry_sexp_release (s_skey);
693   if (kparms)
694     {
695       for (i=0; kparms[i]; i++)
696         gcry_mpi_release (kparms[i]);
697       xfree (kparms);
698     }
699   gcry_cipher_close (cipherhd);
700   xfree (wrappedkey);
701   xfree (kek);
702   
703   if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
704     {
705       /* During export this is the passphrase used to unprotect the
706          key and not the pkcs#12 thing as in export.  Therefore we can
707          issue the regular passphrase status.  FIXME: replace the all
708          zero keyid by a regular one. */
709       gpgsm_status (ctrl, STATUS_BAD_PASSPHRASE, "0000000000000000");
710     }
711
712   if (err)
713     {
714       xfree (result);
715     }
716   else
717     {
718       *r_result = result;
719       *r_resultlen = resultlen;
720     }
721   return err;
722 }
723