Removed almost al dup calls.
[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
38
39
40 /* A table to store a fingerprint as used in a duplicates table.  We
41    don't need to hash here because a fingerprint is already a perfect
42    hash value.  This we use the most significant bits to index the
43    table and then use a linked list for the overflow.  Possible
44    enhancement for very large number of certificates:  Add a second
45    level table and then resort to a linked list.  */
46 struct duptable_s
47 {
48   struct duptable_s *next;
49
50   /* Note that we only need to store 19 bytes because the first byte
51      is implictly given by the table index (we require at least 8
52      bits). */
53   unsigned char fpr[19];
54 };
55 typedef struct duptable_s *duptable_t;
56 #define DUPTABLE_BITS 12
57 #define DUPTABLE_SIZE (1 << DUPTABLE_BITS)
58
59
60 static void print_short_info (ksba_cert_t cert, FILE *fp, estream_t stream);
61 static gpg_error_t export_p12 (ctrl_t ctrl,
62                                const unsigned char *certimg, size_t certimglen,
63                                const char *prompt, const char *keygrip,
64                                estream_t *retfp);
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] & ~(~0 << 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   Base64Context 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 (0);
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);
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 (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, NULL, stream);
259               es_putc ('\n', stream);
260             }
261           count++;
262
263           if (!b64writer)
264             {
265               ctrl->pem_name = "CERTIFICATE";
266               rc = gpgsm_create_writer (&b64writer, ctrl,
267                                         NULL, stream, &writer);
268               if (rc)
269                 {
270                   log_error ("can't create writer: %s\n", gpg_strerror (rc));
271                   goto leave;
272                 }
273             }
274
275           rc = ksba_writer_write (writer, image, imagelen);
276           if (rc)
277             {
278               log_error ("write error: %s\n", gpg_strerror (rc));
279               goto leave;
280             }
281
282           if (ctrl->create_pem)
283             {
284               /* We want one certificate per PEM block */
285               rc = gpgsm_finish_writer (b64writer);
286               if (rc) 
287                 {
288                   log_error ("write failed: %s\n", gpg_strerror (rc));
289                   goto leave;
290                 }
291               gpgsm_destroy_writer (b64writer);
292               b64writer = NULL;
293             }
294         }
295
296       ksba_cert_release (cert); 
297       cert = NULL;
298     }
299   if (rc && rc != -1)
300     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
301   else if (b64writer)
302     {
303       rc = gpgsm_finish_writer (b64writer);
304       if (rc) 
305         {
306           log_error ("write failed: %s\n", gpg_strerror (rc));
307           goto leave;
308         }
309     }
310   
311  leave:
312   gpgsm_destroy_writer (b64writer);
313   ksba_cert_release (cert);
314   xfree (desc);
315   keydb_release (hd);
316   destroy_duptable (dtable);
317 }
318
319
320 /* Export a certificates and its private key. */
321 void
322 gpgsm_p12_export (ctrl_t ctrl, const char *name, FILE *fp)
323 {
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   int rc=0;
330   const unsigned char *image;
331   size_t imagelen;
332   char *keygrip = NULL;
333   char *prompt;
334   char buffer[1024];
335   int  nread;
336   estream_t datafp = NULL;
337
338
339   hd = keydb_new (0);
340   if (!hd)
341     {
342       log_error ("keydb_new failed\n");
343       goto leave;
344     }
345
346   desc = xtrycalloc (1, sizeof *desc);
347   if (!desc)
348     {
349       log_error ("allocating memory for export failed: %s\n",
350                  gpg_strerror (out_of_core ()));
351       goto leave;
352     }
353
354   rc = classify_user_id (name, desc);
355   if (rc)
356     {
357       log_error ("key `%s' not found: %s\n",
358                  name, gpg_strerror (rc));
359       goto leave;
360     }
361
362   /* Lookup the certificate and make sure that it is unique. */
363   rc = keydb_search (hd, desc, 1);
364   if (!rc)
365     {
366       rc = keydb_get_cert (hd, &cert);
367       if (rc) 
368         {
369           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
370           goto leave;
371         }
372
373     next_ambiguous:      
374       rc = keydb_search (hd, desc, 1);
375       if (!rc)
376         {
377           ksba_cert_t cert2 = NULL;
378
379           if (!keydb_get_cert (hd, &cert2))
380             {
381               if (gpgsm_certs_identical_p (cert, cert2))
382                 {
383                   ksba_cert_release (cert2);
384                   goto next_ambiguous;
385                 }
386               ksba_cert_release (cert2);
387             }
388           rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
389         }
390       else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
391         rc = 0;
392       if (rc)
393         {
394           log_error ("key `%s' not found: %s\n",
395                      name, gpg_strerror (rc));
396           goto leave;
397         }
398     }
399       
400   keygrip = gpgsm_get_keygrip_hexstring (cert);
401   if (!keygrip || gpgsm_agent_havekey (ctrl, keygrip))
402     {
403       /* Note, that the !keygrip case indicates a bad certificate. */
404       rc = gpg_error (GPG_ERR_NO_SECKEY);
405       log_error ("can't export key `%s': %s\n", name, gpg_strerror (rc));
406       goto leave;
407     }
408   
409   image = ksba_cert_get_image (cert, &imagelen);
410   if (!image)
411     {
412       log_error ("ksba_cert_get_image failed\n");
413       goto leave;
414     }
415
416   if (ctrl->create_pem)
417     {
418       print_short_info (cert, fp, NULL);
419       putc ('\n', fp);
420     }
421
422   if (opt.p12_charset && ctrl->create_pem)
423     {
424       fprintf (fp, "The passphrase is %s encoded.\n\n",
425                opt.p12_charset);
426     }
427
428   ctrl->pem_name = "PKCS12";
429   rc = gpgsm_create_writer (&b64writer, ctrl, fp, NULL, &writer);
430   if (rc)
431     {
432       log_error ("can't create writer: %s\n", gpg_strerror (rc));
433       goto leave;
434     }
435
436
437   prompt = gpgsm_format_keydesc (cert);
438   rc = export_p12 (ctrl, image, imagelen, prompt, keygrip, &datafp);
439   xfree (prompt);
440   if (rc)
441     goto leave;
442   es_rewind (datafp);
443   while ( (nread = es_fread (buffer, 1, sizeof buffer, datafp)) > 0 )
444     if ((rc = ksba_writer_write (writer, buffer, nread)))
445       {
446         log_error ("write failed: %s\n", gpg_strerror (rc));
447         goto leave;
448       }
449   if (es_ferror (datafp))
450     {
451       rc = gpg_error_from_syserror ();
452       log_error ("error reading temporary file: %s\n", gpg_strerror (rc));
453       goto leave;
454     }
455
456   if (ctrl->create_pem)
457     {
458       /* We want one certificate per PEM block */
459       rc = gpgsm_finish_writer (b64writer);
460       if (rc) 
461         {
462           log_error ("write failed: %s\n", gpg_strerror (rc));
463           goto leave;
464         }
465       gpgsm_destroy_writer (b64writer);
466       b64writer = NULL;
467     }
468   
469   ksba_cert_release (cert); 
470   cert = NULL;
471
472  leave:
473   es_fclose (datafp);
474   gpgsm_destroy_writer (b64writer);
475   ksba_cert_release (cert);
476   xfree (desc);
477   keydb_release (hd);
478 }
479
480
481 /* Call either es_putc or the plain putc.  */
482 static void
483 do_putc (int value, FILE *fp, estream_t stream)
484 {
485   if (stream)
486     es_putc (value, stream);
487   else
488     putc (value, fp);
489 }
490
491 /* Call either es_fputs or the plain fputs.  */
492 static void
493 do_fputs (const char *string, FILE *fp, estream_t stream)
494 {
495   if (stream)
496     es_fputs (string, stream);
497   else
498     fputs (string, fp);
499 }
500
501
502 /* Print some info about the certifciate CERT to FP or STREAM */
503 static void
504 print_short_info (ksba_cert_t cert, FILE *fp, estream_t stream)
505 {
506   char *p;
507   ksba_sexp_t sexp;
508   int idx;
509
510   for (idx=0; (p = ksba_cert_get_issuer (cert, idx)); idx++)
511     {
512       do_fputs ((!idx
513                  ?   "Issuer ...: "
514                  : "\n   aka ...: "), fp, stream); 
515       if (stream)
516         gpgsm_es_print_name (stream, p);
517       else
518         gpgsm_print_name (fp, p);
519       xfree (p);
520     }
521   do_putc ('\n', fp, stream);
522
523   do_fputs ("Serial ...: ", fp, stream); 
524   sexp = ksba_cert_get_serial (cert);
525   if (sexp)
526     {
527       int len;
528       const unsigned char *s = sexp;
529       
530       if (*s == '(')
531         {
532           s++;
533           for (len=0; *s && *s != ':' && digitp (s); s++)
534             len = len*10 + atoi_1 (s);
535           if (*s == ':')
536             {
537               if (stream)
538                 es_write_hexstring (stream, s+1, len, 0, NULL);
539               else
540                 print_hexstring (fp, s+1, len, 0);
541             }
542         }
543       xfree (sexp);
544     }
545   do_putc ('\n', fp, stream);
546
547   for (idx=0; (p = ksba_cert_get_subject (cert, idx)); idx++)
548     {
549       do_fputs ((!idx
550                  ?   "Subject ..: "
551                  : "\n    aka ..: "), fp, stream); 
552       if (stream)
553         gpgsm_es_print_name (stream, p);
554       else
555         gpgsm_print_name (fp, p);
556       xfree (p);
557     }
558   do_putc ('\n', fp, stream);
559 }
560
561
562 static gpg_error_t
563 popen_protect_tool (ctrl_t ctrl, const char *pgmname,
564                     FILE *infile, estream_t outfile, FILE **statusfile, 
565                     const char *prompt, const char *keygrip,
566                     pid_t *pid)
567 {
568   const char *argv[22];
569   int i=0;
570
571   /* Make sure that the agent is running so that the protect tool is
572      able to ask for a passphrase.  This has only an effect under W32
573      where the agent is started on demand; sending a NOP does not harm
574      on other platforms.  This is not really necessary anymore because
575      the protect tool does this now by itself; it does not harm either.*/
576   gpgsm_agent_send_nop (ctrl);
577
578   argv[i++] = "--homedir";
579   argv[i++] = opt.homedir;
580   argv[i++] = "--p12-export";
581   argv[i++] = "--have-cert";
582   argv[i++] = "--prompt";
583   argv[i++] = prompt?prompt:"";
584   argv[i++] = "--enable-status-msg";
585   if (opt.p12_charset)
586     {
587       argv[i++] = "--p12-charset";
588       argv[i++] = opt.p12_charset;
589     }
590   if (opt.agent_program)
591     {
592       argv[i++] = "--agent-program";
593       argv[i++] = opt.agent_program;
594     }
595   argv[i++] = "--",
596   argv[i++] = keygrip,
597   argv[i] = NULL;
598   assert (i < sizeof argv);
599
600   return gnupg_spawn_process (pgmname, argv, infile, outfile,
601                               setup_pinentry_env, (128|64),
602                               statusfile, pid);
603 }
604
605
606 static gpg_error_t
607 export_p12 (ctrl_t ctrl, const unsigned char *certimg, size_t certimglen,
608             const char *prompt, const char *keygrip, estream_t *retfp)
609 {
610   const char *pgmname;
611   gpg_error_t err = 0, child_err = 0;
612   int c, cont_line;
613   unsigned int pos;
614   FILE *infp = NULL, *fp = NULL;
615   estream_t outfp = NULL;
616   char buffer[1024];
617   pid_t pid = -1;
618   int bad_pass = 0;
619
620   if (!opt.protect_tool_program || !*opt.protect_tool_program)
621     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
622   else
623     pgmname = opt.protect_tool_program;
624
625   infp = gnupg_tmpfile ();
626   if (!infp)
627     {
628       err = gpg_error_from_syserror ();
629       log_error (_("error creating temporary file: %s\n"), strerror (errno));
630       goto cleanup;
631     }
632
633   if (fwrite (certimg, certimglen, 1, infp) != 1)
634     {
635       err = gpg_error_from_syserror ();
636       log_error (_("error writing to temporary file: %s\n"),
637                  strerror (errno));
638       goto cleanup;
639     }
640
641   outfp = es_tmpfile ();
642   if (!outfp)
643     {
644       err = gpg_error_from_syserror ();
645       log_error (_("error creating temporary file: %s\n"), strerror (errno));
646       goto cleanup;
647     }
648
649   err = popen_protect_tool (ctrl, 
650                             pgmname, infp, outfp, &fp, prompt, keygrip, &pid);
651   if (err)
652     {
653       pid = -1;
654       goto cleanup;
655     }
656   fclose (infp);
657   infp = NULL;
658
659   /* Read stderr of the protect tool. */
660   pos = 0;
661   cont_line = 0;
662   while ((c=getc (fp)) != EOF)
663     {
664       /* fixme: We could here grep for status information of the
665          protect tool to figure out better error codes for
666          CHILD_ERR. */
667       buffer[pos++] = c;
668       if (pos >= sizeof buffer - 5 || c == '\n')
669         {
670           buffer[pos - (c == '\n')] = 0;
671           if (cont_line)
672             log_printf ("%s", buffer);
673           else
674             {
675               if (!strncmp (buffer, "gpg-protect-tool: [PROTECT-TOOL:] ",34))
676                 {
677                   char *p, *pend;
678
679                   p = buffer + 34;
680                   pend = strchr (p, ' ');
681                   if (pend)
682                     *pend = 0;
683                   if ( !strcmp (p, "bad-passphrase"))
684                     bad_pass++;
685                 }
686               else 
687                 log_info ("%s", buffer);
688             }
689           pos = 0;
690           cont_line = (c != '\n');
691         }
692     }
693
694   if (pos)
695     {
696       buffer[pos] = 0;
697       if (cont_line)
698         log_printf ("%s\n", buffer);
699       else
700         log_info ("%s\n", buffer);
701     }
702   else if (cont_line)
703     log_printf ("\n");
704
705   /* If we found no error in the output of the child, setup a suitable
706      error code, which will later be reset if the exit status of the
707      child is 0. */
708   if (!child_err)
709     child_err = gpg_error (GPG_ERR_DECRYPT_FAILED);
710
711  cleanup:
712   if (infp)
713     fclose (infp);
714   if (fp)
715     fclose (fp);
716   if (pid != -1)
717     {
718       if (!gnupg_wait_process (pgmname, pid, NULL))
719         child_err = 0;
720     }
721   if (!err)
722     err = child_err;
723   if (err)
724     {
725       es_fclose (outfp);
726     }
727   else
728     *retfp = outfp;
729   if (bad_pass)
730     {
731       /* During export this is the passphrase used to unprotect the
732          key and not the pkcs#12 thing as in export.  Therefore we can
733          issue the regular passphrase status.  FIXME: replace the all
734          zero keyid by a regular one. */
735       gpgsm_status (ctrl, STATUS_BAD_PASSPHRASE, "0000000000000000");
736     }
737   return err;
738 }
739