First steps towards supporting W32.
[gnupg.git] / sm / export.c
1 /* export.c
2  * Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <time.h>
28 #include <assert.h>
29
30 #include "gpgsm.h"
31 #include <gcrypt.h>
32 #include <ksba.h>
33
34 #include "keydb.h"
35 #include "exechelp.h"
36 #include "i18n.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 alrady 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 certictates: 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                                FILE **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
129
130 /* Export all certificates or just those given in NAMES. If STREAM is
131    not NULL the output is send to this extended stream. */
132 void
133 gpgsm_export (ctrl_t ctrl, strlist_t names, FILE *fp, estream_t stream)
134 {
135   KEYDB_HANDLE hd = NULL;
136   KEYDB_SEARCH_DESC *desc = NULL;
137   int ndesc;
138   Base64Context b64writer = NULL;
139   ksba_writer_t writer;
140   strlist_t sl;
141   ksba_cert_t cert = NULL;
142   int rc=0;
143   int count = 0;
144   int i;
145   duptable_t *dtable;
146
147   
148   dtable = create_duptable ();
149   if (!dtable)
150     {
151       log_error ("creating duplicates table failed: %s\n", strerror (errno));
152       goto leave;
153     }
154
155   hd = keydb_new (0);
156   if (!hd)
157     {
158       log_error ("keydb_new failed\n");
159       goto leave;
160     }
161
162   if (!names)
163     ndesc = 1;
164   else
165     {
166       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++) 
167         ;
168     }
169
170   desc = xtrycalloc (ndesc, sizeof *desc);
171   if (!ndesc)
172     {
173       log_error ("allocating memory for export failed: %s\n",
174                  gpg_strerror (out_of_core ()));
175       goto leave;
176     }
177
178   if (!names)
179     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
180   else 
181     {
182       for (ndesc=0, sl=names; sl; sl = sl->next) 
183         {
184           rc = keydb_classify_name (sl->d, desc+ndesc);
185           if (rc)
186             {
187               log_error ("key `%s' not found: %s\n",
188                          sl->d, gpg_strerror (rc));
189               rc = 0;
190             }
191           else
192             ndesc++;
193         }
194     }
195
196   /* If all specifications are done by fingerprint, we switch to
197      ephemeral mode so that _all_ currently available and matching
198      certificates are exported. 
199
200      fixme: we should in this case keep a list of certificates to
201      avoid accidential export of duplicate certificates. */
202   if (names && ndesc)
203     {
204       for (i=0; (i < ndesc
205                  && (desc[i].mode == KEYDB_SEARCH_MODE_FPR
206                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR20
207                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR16)); i++)
208         ;
209       if (i == ndesc)
210         keydb_set_ephemeral (hd, 1);
211     }
212       
213   while (!(rc = keydb_search (hd, desc, ndesc)))
214     {
215       unsigned char fpr[20];
216       int exists;
217
218       if (!names) 
219         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
220
221       rc = keydb_get_cert (hd, &cert);
222       if (rc) 
223         {
224           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
225           goto leave;
226         }
227
228       gpgsm_get_fingerprint (cert, 0, fpr, NULL);
229       rc = insert_duptable (dtable, fpr, &exists);
230       if (rc)
231         {
232           log_error ("inserting into duplicates table fauiled: %s\n",
233                      gpg_strerror (rc));
234           goto leave;
235         }
236
237       if (!exists && count && !ctrl->create_pem)
238         {
239           log_info ("exporting more than one certificate "
240                     "is not possible in binary mode\n");
241           log_info ("ignoring other certificates\n");
242           break;
243         }
244
245       if (!exists)
246         {
247           const unsigned char *image;
248           size_t imagelen;
249
250           image = ksba_cert_get_image (cert, &imagelen);
251           if (!image)
252             {
253               log_error ("ksba_cert_get_image failed\n");
254               goto leave;
255             }
256
257
258           if (ctrl->create_pem)
259             {
260               if (count)
261                 {
262                   if (stream)
263                     es_putc ('\n', stream);
264                   else
265                     putc ('\n', fp);
266                 }
267               print_short_info (cert, fp, stream);
268               if (stream)
269                 es_putc ('\n', stream);
270               else
271                 putc ('\n', fp);
272             }
273           count++;
274
275           if (!b64writer)
276             {
277               ctrl->pem_name = "CERTIFICATE";
278               rc = gpgsm_create_writer (&b64writer, ctrl, fp, stream, &writer);
279               if (rc)
280                 {
281                   log_error ("can't create writer: %s\n", gpg_strerror (rc));
282                   goto leave;
283                 }
284             }
285
286           rc = ksba_writer_write (writer, image, imagelen);
287           if (rc)
288             {
289               log_error ("write error: %s\n", gpg_strerror (rc));
290               goto leave;
291             }
292
293           if (ctrl->create_pem)
294             {
295               /* We want one certificate per PEM block */
296               rc = gpgsm_finish_writer (b64writer);
297               if (rc) 
298                 {
299                   log_error ("write failed: %s\n", gpg_strerror (rc));
300                   goto leave;
301                 }
302               gpgsm_destroy_writer (b64writer);
303               b64writer = NULL;
304             }
305         }
306
307       ksba_cert_release (cert); 
308       cert = NULL;
309     }
310   if (rc && rc != -1)
311     log_error ("keydb_search failed: %s\n", gpg_strerror (rc));
312   else if (b64writer)
313     {
314       rc = gpgsm_finish_writer (b64writer);
315       if (rc) 
316         {
317           log_error ("write failed: %s\n", gpg_strerror (rc));
318           goto leave;
319         }
320     }
321   
322  leave:
323   gpgsm_destroy_writer (b64writer);
324   ksba_cert_release (cert);
325   xfree (desc);
326   keydb_release (hd);
327   destroy_duptable (dtable);
328 }
329
330
331 /* Export a certificates and its private key. */
332 void
333 gpgsm_p12_export (ctrl_t ctrl, const char *name, FILE *fp)
334 {
335   KEYDB_HANDLE hd;
336   KEYDB_SEARCH_DESC *desc = NULL;
337   Base64Context b64writer = NULL;
338   ksba_writer_t writer;
339   ksba_cert_t cert = NULL;
340   int rc=0;
341   const unsigned char *image;
342   size_t imagelen;
343   char *keygrip = NULL;
344   char *prompt;
345   char buffer[1024];
346   int  nread;
347   FILE *datafp = NULL;
348
349
350   hd = keydb_new (0);
351   if (!hd)
352     {
353       log_error ("keydb_new failed\n");
354       goto leave;
355     }
356
357   desc = xtrycalloc (1, sizeof *desc);
358   if (!desc)
359     {
360       log_error ("allocating memory for export failed: %s\n",
361                  gpg_strerror (out_of_core ()));
362       goto leave;
363     }
364
365   rc = keydb_classify_name (name, desc);
366   if (rc)
367     {
368       log_error ("key `%s' not found: %s\n",
369                  name, gpg_strerror (rc));
370       goto leave;
371     }
372
373   /* Lookup the certificate an make sure that it is unique. */
374   rc = keydb_search (hd, desc, 1);
375   if (!rc)
376     {
377       rc = keydb_get_cert (hd, &cert);
378       if (rc) 
379         {
380           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
381           goto leave;
382         }
383       
384       rc = keydb_search (hd, desc, 1);
385       if (!rc)
386         rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
387       else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
388         rc = 0;
389       if (rc)
390         {
391           log_error ("key `%s' not found: %s\n",
392                      name, gpg_strerror (rc));
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       rc = gpg_error (GPG_ERR_NO_SECKEY);
402       log_error ("can't export key `%s': %s\n", name, gpg_strerror (rc));
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, fp, NULL);
416       putc ('\n', fp);
417     }
418
419   if (opt.p12_charset && ctrl->create_pem)
420     {
421       fprintf (fp, "The passphrase is %s encoded.\n\n",
422                opt.p12_charset);
423     }
424
425   ctrl->pem_name = "PKCS12";
426   rc = gpgsm_create_writer (&b64writer, ctrl, fp, NULL, &writer);
427   if (rc)
428     {
429       log_error ("can't create writer: %s\n", gpg_strerror (rc));
430       goto leave;
431     }
432
433
434   prompt = gpgsm_format_keydesc (cert);
435   rc = export_p12 (ctrl, image, imagelen, prompt, keygrip, &datafp);
436   xfree (prompt);
437   if (rc)
438     goto leave;
439   rewind (datafp);
440   while ( (nread = fread (buffer, 1, sizeof buffer, datafp)) > 0 )
441     if ((rc = ksba_writer_write (writer, buffer, nread)))
442       {
443         log_error ("write failed: %s\n", gpg_strerror (rc));
444         goto leave;
445       }
446   if (ferror (datafp))
447     {
448       rc = gpg_error_from_errno (rc);
449       log_error ("error reading temporary file: %s\n", gpg_strerror (rc));
450       goto leave;
451     }
452
453   if (ctrl->create_pem)
454     {
455       /* We want one certificate per PEM block */
456       rc = gpgsm_finish_writer (b64writer);
457       if (rc) 
458         {
459           log_error ("write failed: %s\n", gpg_strerror (rc));
460           goto leave;
461         }
462       gpgsm_destroy_writer (b64writer);
463       b64writer = NULL;
464     }
465   
466   ksba_cert_release (cert); 
467   cert = NULL;
468
469  leave:
470   if (datafp)
471     fclose (datafp);
472   gpgsm_destroy_writer (b64writer);
473   ksba_cert_release (cert);
474   xfree (desc);
475   keydb_release (hd);
476 }
477
478
479 /* Call either es_putc or the plain putc.  */
480 static void
481 do_putc (int value, FILE *fp, estream_t stream)
482 {
483   if (stream)
484     es_putc (value, stream);
485   else
486     putc (value, fp);
487 }
488
489 /* Call either es_fputs or the plain fputs.  */
490 static void
491 do_fputs (const char *string, FILE *fp, estream_t stream)
492 {
493   if (stream)
494     es_fputs (string, stream);
495   else
496     fputs (string, fp);
497 }
498
499
500 /* Print some info about the certifciate CERT to FP or STREAM */
501 static void
502 print_short_info (ksba_cert_t cert, FILE *fp, estream_t stream)
503 {
504   char *p;
505   ksba_sexp_t sexp;
506   int idx;
507
508   for (idx=0; (p = ksba_cert_get_issuer (cert, idx)); idx++)
509     {
510       do_fputs ((!idx
511                  ?   "Issuer ...: "
512                  : "\n   aka ...: "), fp, stream); 
513       if (stream)
514         gpgsm_es_print_name (stream, p);
515       else
516         gpgsm_print_name (fp, p);
517       xfree (p);
518     }
519   do_putc ('\n', fp, stream);
520
521   do_fputs ("Serial ...: ", fp, stream); 
522   sexp = ksba_cert_get_serial (cert);
523   if (sexp)
524     {
525       int len;
526       const unsigned char *s = sexp;
527       
528       if (*s == '(')
529         {
530           s++;
531           for (len=0; *s && *s != ':' && digitp (s); s++)
532             len = len*10 + atoi_1 (s);
533           if (*s == ':')
534             {
535               if (stream)
536                 es_write_hexstring (stream, s+1, len, 0, NULL);
537               else
538                 print_hexstring (fp, s+1, len, 0);
539             }
540         }
541       xfree (sexp);
542     }
543   do_putc ('\n', fp, stream);
544
545   for (idx=0; (p = ksba_cert_get_subject (cert, idx)); idx++)
546     {
547       do_fputs ((!idx
548                  ?   "Subject ..: "
549                  : "\n    aka ..: "), fp, stream); 
550       if (stream)
551         gpgsm_es_print_name (stream, p);
552       else
553         gpgsm_print_name (fp, p);
554       xfree (p);
555     }
556   do_putc ('\n', fp, stream);
557 }
558
559
560 static gpg_error_t
561 popen_protect_tool (const char *pgmname,
562                     FILE *infile, FILE *outfile, FILE **statusfile, 
563                     const char *prompt, const char *keygrip,
564                     pid_t *pid)
565 {
566   const char *argv[20];
567   int i=0;
568
569   argv[i++] = "--homedir";
570   argv[i++] = opt.homedir;
571   argv[i++] = "--p12-export";
572   argv[i++] = "--have-cert";
573   argv[i++] = "--prompt";
574   argv[i++] = prompt?prompt:"";
575   argv[i++] = "--enable-status-msg";
576   if (opt.p12_charset)
577     {
578       argv[i++] = "--p12-charset";
579       argv[i++] = opt.p12_charset;
580     }
581   argv[i++] = "--",
582   argv[i++] = keygrip,
583   argv[i] = NULL;
584   assert (i < sizeof argv);
585
586   return gnupg_spawn_process (pgmname, argv, infile, outfile,
587                               setup_pinentry_env,
588                               statusfile, pid);
589 }
590
591
592 static gpg_error_t
593 export_p12 (ctrl_t ctrl, const unsigned char *certimg, size_t certimglen,
594             const char *prompt, const char *keygrip,
595             FILE **retfp)
596 {
597   const char *pgmname;
598   gpg_error_t err = 0, child_err = 0;
599   int c, cont_line;
600   unsigned int pos;
601   FILE *infp = NULL, *outfp = NULL, *fp = NULL;
602   char buffer[1024];
603   pid_t pid = -1;
604   int bad_pass = 0;
605
606   if (!opt.protect_tool_program || !*opt.protect_tool_program)
607     pgmname = GNUPG_DEFAULT_PROTECT_TOOL;
608   else
609     pgmname = opt.protect_tool_program;
610
611   infp = tmpfile ();
612   if (!infp)
613     {
614       err = gpg_error_from_syserror ();
615       log_error (_("error creating temporary file: %s\n"), strerror (errno));
616       goto cleanup;
617     }
618
619   if (fwrite (certimg, certimglen, 1, infp) != 1)
620     {
621       err = gpg_error_from_syserror ();
622       log_error (_("error writing to temporary file: %s\n"),
623                  strerror (errno));
624       goto cleanup;
625     }
626
627   outfp = tmpfile ();
628   if (!outfp)
629     {
630       err = gpg_error_from_syserror ();
631       log_error (_("error creating temporary file: %s\n"), strerror (errno));
632       goto cleanup;
633     }
634
635   err = popen_protect_tool (pgmname, infp, outfp, &fp, prompt, keygrip, &pid);
636   if (err)
637     {
638       pid = -1;
639       goto cleanup;
640     }
641   fclose (infp);
642   infp = NULL;
643
644   /* Read stderr of the protect tool. */
645   pos = 0;
646   cont_line = 0;
647   while ((c=getc (fp)) != EOF)
648     {
649       /* fixme: We could here grep for status information of the
650          protect tool to figure out better error codes for
651          CHILD_ERR. */
652       buffer[pos++] = c;
653       if (pos >= sizeof buffer - 5 || c == '\n')
654         {
655           buffer[pos - (c == '\n')] = 0;
656           if (cont_line)
657             log_printf ("%s", buffer);
658           else
659             {
660               if (!strncmp (buffer, "gpg-protect-tool: [PROTECT-TOOL:] ",34))
661                 {
662                   char *p, *pend;
663
664                   p = buffer + 34;
665                   pend = strchr (p, ' ');
666                   if (pend)
667                     *pend = 0;
668                   if ( !strcmp (p, "bad-passphrase"))
669                     bad_pass++;
670                 }
671               else 
672                 log_info ("%s", buffer);
673             }
674           pos = 0;
675           cont_line = (c != '\n');
676         }
677     }
678
679   if (pos)
680     {
681       buffer[pos] = 0;
682       if (cont_line)
683         log_printf ("%s\n", buffer);
684       else
685         log_info ("%s\n", buffer);
686     }
687   else if (cont_line)
688     log_printf ("\n");
689
690   /* If we found no error in the output of the child, setup a suitable
691      error code, which will later be reset if the exit status of the
692      child is 0. */
693   if (!child_err)
694     child_err = gpg_error (GPG_ERR_DECRYPT_FAILED);
695
696  cleanup:
697   if (infp)
698     fclose (infp);
699   if (fp)
700     fclose (fp);
701   if (pid != -1)
702     {
703       if (!gnupg_wait_process (pgmname, pid))
704         child_err = 0;
705     }
706   if (!err)
707     err = child_err;
708   if (err)
709     {
710       if (outfp)
711         fclose (outfp);
712     }
713   else
714     *retfp = outfp;
715   if (bad_pass)
716     {
717       /* During export this is the passphrase used to unprotect the
718          key and not the pkcs#12 thing as in export.  Therefore we can
719          issue the regular passphrase status.  FIXME: replace the all
720          zero keyid by a regular one. */
721       gpgsm_status (ctrl, STATUS_BAD_PASSPHRASE, "0000000000000000");
722     }
723   return err;
724 }
725