Fix for bug 537
[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);
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. */
131 void
132 gpgsm_export (ctrl_t ctrl, strlist_t names, FILE *fp)
133 {
134   KEYDB_HANDLE hd = NULL;
135   KEYDB_SEARCH_DESC *desc = NULL;
136   int ndesc;
137   Base64Context b64writer = NULL;
138   ksba_writer_t writer;
139   strlist_t sl;
140   ksba_cert_t cert = NULL;
141   int rc=0;
142   int count = 0;
143   int i;
144   duptable_t *dtable;
145
146   
147   dtable = create_duptable ();
148   if (!dtable)
149     {
150       log_error ("creating duplicates table failed: %s\n", strerror (errno));
151       goto leave;
152     }
153
154   hd = keydb_new (0);
155   if (!hd)
156     {
157       log_error ("keydb_new failed\n");
158       goto leave;
159     }
160
161   if (!names)
162     ndesc = 1;
163   else
164     {
165       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++) 
166         ;
167     }
168
169   desc = xtrycalloc (ndesc, sizeof *desc);
170   if (!ndesc)
171     {
172       log_error ("allocating memory for export failed: %s\n",
173                  gpg_strerror (out_of_core ()));
174       goto leave;
175     }
176
177   if (!names)
178     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
179   else 
180     {
181       for (ndesc=0, sl=names; sl; sl = sl->next) 
182         {
183           rc = keydb_classify_name (sl->d, desc+ndesc);
184           if (rc)
185             {
186               log_error ("key `%s' not found: %s\n",
187                          sl->d, gpg_strerror (rc));
188               rc = 0;
189             }
190           else
191             ndesc++;
192         }
193     }
194
195   /* If all specifications are done by fingerprint, we switch to
196      ephemeral mode so that _all_ currently available and matching
197      certificates are exported. 
198
199      fixme: we should in this case keep a list of certificates to
200      avoid accidential export of duplicate certificates. */
201   if (names && ndesc)
202     {
203       for (i=0; (i < ndesc
204                  && (desc[i].mode == KEYDB_SEARCH_MODE_FPR
205                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR20
206                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR16)); i++)
207         ;
208       if (i == ndesc)
209         keydb_set_ephemeral (hd, 1);
210     }
211       
212   while (!(rc = keydb_search (hd, desc, ndesc)))
213     {
214       unsigned char fpr[20];
215       int exists;
216
217       if (!names) 
218         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
219
220       rc = keydb_get_cert (hd, &cert);
221       if (rc) 
222         {
223           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
224           goto leave;
225         }
226
227       gpgsm_get_fingerprint (cert, 0, fpr, NULL);
228       rc = insert_duptable (dtable, fpr, &exists);
229       if (rc)
230         {
231           log_error ("inserting into duplicates table fauiled: %s\n",
232                      gpg_strerror (rc));
233           goto leave;
234         }
235
236       if (!exists && count && !ctrl->create_pem)
237         {
238           log_info ("exporting more than one certificate "
239                     "is not possible in binary mode\n");
240           log_info ("ignoring other certificates\n");
241           break;
242         }
243
244       if (!exists)
245         {
246           const unsigned char *image;
247           size_t imagelen;
248
249           image = ksba_cert_get_image (cert, &imagelen);
250           if (!image)
251             {
252               log_error ("ksba_cert_get_image failed\n");
253               goto leave;
254             }
255
256
257           if (ctrl->create_pem)
258             {
259               if (count)
260                 putc ('\n', fp);
261               print_short_info (cert, fp);
262               putc ('\n', fp);
263             }
264           count++;
265
266           if (!b64writer)
267             {
268               ctrl->pem_name = "CERTIFICATE";
269               rc = gpgsm_create_writer (&b64writer, ctrl, fp, &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 = gpgsm_finish_writer (b64writer);
288               if (rc) 
289                 {
290                   log_error ("write failed: %s\n", gpg_strerror (rc));
291                   goto leave;
292                 }
293               gpgsm_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 = gpgsm_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   gpgsm_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 certificates and its private key. */
323 void
324 gpgsm_p12_export (ctrl_t ctrl, const char *name, FILE *fp)
325 {
326   KEYDB_HANDLE hd;
327   KEYDB_SEARCH_DESC *desc = NULL;
328   Base64Context b64writer = NULL;
329   ksba_writer_t writer;
330   ksba_cert_t cert = NULL;
331   int rc=0;
332   const unsigned char *image;
333   size_t imagelen;
334   char *keygrip = NULL;
335   char *prompt;
336   char buffer[1024];
337   int  nread;
338   FILE *datafp = NULL;
339
340
341   hd = keydb_new (0);
342   if (!hd)
343     {
344       log_error ("keydb_new failed\n");
345       goto leave;
346     }
347
348   desc = xtrycalloc (1, sizeof *desc);
349   if (!desc)
350     {
351       log_error ("allocating memory for export failed: %s\n",
352                  gpg_strerror (out_of_core ()));
353       goto leave;
354     }
355
356   rc = keydb_classify_name (name, desc);
357   if (rc)
358     {
359       log_error ("key `%s' not found: %s\n",
360                  name, gpg_strerror (rc));
361       goto leave;
362     }
363
364   /* Lookup the certificate an make sure that it is unique. */
365   rc = keydb_search (hd, desc, 1);
366   if (!rc)
367     {
368       rc = keydb_get_cert (hd, &cert);
369       if (rc) 
370         {
371           log_error ("keydb_get_cert failed: %s\n", gpg_strerror (rc));
372           goto leave;
373         }
374       
375       rc = keydb_search (hd, desc, 1);
376       if (!rc)
377         rc = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
378       else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
379         rc = 0;
380       if (rc)
381         {
382           log_error ("key `%s' not found: %s\n",
383                      name, gpg_strerror (rc));
384           goto leave;
385         }
386     }
387       
388   keygrip = gpgsm_get_keygrip_hexstring (cert);
389   if (!keygrip || gpgsm_agent_havekey (ctrl, keygrip))
390     {
391       /* Note, that the !keygrip case indicates a bad certificate. */
392       rc = gpg_error (GPG_ERR_NO_SECKEY);
393       log_error ("can't export key `%s': %s\n", name, gpg_strerror (rc));
394       goto leave;
395     }
396   
397   image = ksba_cert_get_image (cert, &imagelen);
398   if (!image)
399     {
400       log_error ("ksba_cert_get_image failed\n");
401       goto leave;
402     }
403
404   if (ctrl->create_pem)
405     {
406       print_short_info (cert, fp);
407       putc ('\n', fp);
408     }
409
410   ctrl->pem_name = "PKCS12";
411   rc = gpgsm_create_writer (&b64writer, ctrl, fp, &writer);
412   if (rc)
413     {
414       log_error ("can't create writer: %s\n", gpg_strerror (rc));
415       goto leave;
416     }
417
418
419   prompt = gpgsm_format_keydesc (cert);
420   rc = export_p12 (ctrl, image, imagelen, prompt, keygrip, &datafp);
421   xfree (prompt);
422   if (rc)
423     goto leave;
424   rewind (datafp);
425   while ( (nread = fread (buffer, 1, sizeof buffer, datafp)) > 0 )
426     if ((rc = ksba_writer_write (writer, buffer, nread)))
427       {
428         log_error ("write failed: %s\n", gpg_strerror (rc));
429         goto leave;
430       }
431   if (ferror (datafp))
432     {
433       rc = gpg_error_from_errno (rc);
434       log_error ("error reading temporary file: %s\n", gpg_strerror (rc));
435       goto leave;
436     }
437
438   if (ctrl->create_pem)
439     {
440       /* We want one certificate per PEM block */
441       rc = gpgsm_finish_writer (b64writer);
442       if (rc) 
443         {
444           log_error ("write failed: %s\n", gpg_strerror (rc));
445           goto leave;
446         }
447       gpgsm_destroy_writer (b64writer);
448       b64writer = NULL;
449     }
450   
451   ksba_cert_release (cert); 
452   cert = NULL;
453
454  leave:
455   if (datafp)
456     fclose (datafp);
457   gpgsm_destroy_writer (b64writer);
458   ksba_cert_release (cert);
459   xfree (desc);
460   keydb_release (hd);
461 }
462
463
464 /* Print some info about the certifciate CERT to FP */
465 static void
466 print_short_info (ksba_cert_t cert, FILE *fp)
467 {
468   char *p;
469   ksba_sexp_t sexp;
470   int idx;
471
472   for (idx=0; (p = ksba_cert_get_issuer (cert, idx)); idx++)
473     {
474       fputs (!idx?   "Issuer ...: "
475                  : "\n   aka ...: ", fp); 
476       gpgsm_print_name (fp, p);
477       xfree (p);
478     }
479   putc ('\n', fp);
480
481   fputs ("Serial ...: ", fp); 
482   sexp = ksba_cert_get_serial (cert);
483   if (sexp)
484     {
485       int len;
486       const unsigned char *s = sexp;
487       
488       if (*s == '(')
489         {
490           s++;
491           for (len=0; *s && *s != ':' && digitp (s); s++)
492             len = len*10 + atoi_1 (s);
493           if (*s == ':')
494             for (s++; len; len--, s++)
495               fprintf (fp, "%02X", *s);
496         }
497       xfree (sexp);
498     }
499   putc ('\n', fp);
500
501   for (idx=0; (p = ksba_cert_get_subject (cert, idx)); idx++)
502     {
503       fputs (!idx?   "Subject ..: "
504                  : "\n    aka ..: ", fp); 
505       gpgsm_print_name (fp, p);
506       xfree (p);
507     }
508   putc ('\n', fp);
509 }
510
511
512 static gpg_error_t
513 popen_protect_tool (const char *pgmname,
514                     FILE *infile, FILE *outfile, FILE **statusfile, 
515                     const char *prompt, const char *keygrip,
516                     pid_t *pid)
517 {
518   const char *argv[20];
519   int i=0;
520
521   argv[i++] = "--homedir";
522   argv[i++] = opt.homedir;
523   argv[i++] = "--p12-export";
524   argv[i++] = "--have-cert";
525   argv[i++] = "--prompt";
526   argv[i++] = prompt?prompt:"";
527   argv[i++] = "--enable-status-msg";
528   argv[i++] = "--",
529   argv[i++] = keygrip,
530   argv[i] = NULL;
531   assert (i < sizeof argv);
532
533   return gnupg_spawn_process (pgmname, argv, infile, outfile,
534                               setup_pinentry_env,
535                               statusfile, pid);
536 }
537
538
539 static gpg_error_t
540 export_p12 (ctrl_t ctrl, const unsigned char *certimg, size_t certimglen,
541             const char *prompt, const char *keygrip,
542             FILE **retfp)
543 {
544   const char *pgmname;
545   gpg_error_t err = 0, child_err = 0;
546   int c, cont_line;
547   unsigned int pos;
548   FILE *infp = NULL, *outfp = NULL, *fp = NULL;
549   char buffer[1024];
550   pid_t pid = -1;
551   int bad_pass = 0;
552
553   if (!opt.protect_tool_program || !*opt.protect_tool_program)
554     pgmname = GNUPG_DEFAULT_PROTECT_TOOL;
555   else
556     pgmname = opt.protect_tool_program;
557
558   infp = tmpfile ();
559   if (!infp)
560     {
561       err = gpg_error_from_syserror ();
562       log_error (_("error creating temporary file: %s\n"), strerror (errno));
563       goto cleanup;
564     }
565
566   if (fwrite (certimg, certimglen, 1, infp) != 1)
567     {
568       err = gpg_error_from_syserror ();
569       log_error (_("error writing to temporary file: %s\n"),
570                  strerror (errno));
571       goto cleanup;
572     }
573
574   outfp = tmpfile ();
575   if (!outfp)
576     {
577       err = gpg_error_from_syserror ();
578       log_error (_("error creating temporary file: %s\n"), strerror (errno));
579       goto cleanup;
580     }
581
582   err = popen_protect_tool (pgmname, infp, outfp, &fp, prompt, keygrip, &pid);
583   if (err)
584     {
585       pid = -1;
586       goto cleanup;
587     }
588   fclose (infp);
589   infp = NULL;
590
591   /* Read stderr of the protect tool. */
592   pos = 0;
593   cont_line = 0;
594   while ((c=getc (fp)) != EOF)
595     {
596       /* fixme: We could here grep for status information of the
597          protect tool to figure out better error codes for
598          CHILD_ERR. */
599       buffer[pos++] = c;
600       if (pos >= sizeof buffer - 5 || c == '\n')
601         {
602           buffer[pos - (c == '\n')] = 0;
603           if (cont_line)
604             log_printf ("%s", buffer);
605           else
606             {
607               if (!strncmp (buffer, "gpg-protect-tool: [PROTECT-TOOL:] ",34))
608                 {
609                   char *p, *pend;
610
611                   p = buffer + 34;
612                   pend = strchr (p, ' ');
613                   if (pend)
614                     *pend = 0;
615                   if ( !strcmp (p, "bad-passphrase"))
616                     bad_pass++;
617                 }
618               else 
619                 log_info ("%s", buffer);
620             }
621           pos = 0;
622           cont_line = (c != '\n');
623         }
624     }
625
626   if (pos)
627     {
628       buffer[pos] = 0;
629       if (cont_line)
630         log_printf ("%s\n", buffer);
631       else
632         log_info ("%s\n", buffer);
633     }
634   else if (cont_line)
635     log_printf ("\n");
636
637   /* If we found no error in the output of the child, setup a suitable
638      error code, which will later be reset if the exit status of the
639      child is 0. */
640   if (!child_err)
641     child_err = gpg_error (GPG_ERR_DECRYPT_FAILED);
642
643  cleanup:
644   if (infp)
645     fclose (infp);
646   if (fp)
647     fclose (fp);
648   if (pid != -1)
649     {
650       if (!gnupg_wait_process (pgmname, pid))
651         child_err = 0;
652     }
653   if (!err)
654     err = child_err;
655   if (err)
656     {
657       if (outfp)
658         fclose (outfp);
659     }
660   else
661     *retfp = outfp;
662   if (bad_pass)
663     {
664       /* During export this is the passphrase used to unprotect the
665          key and not the pkcs#12 thing as in export.  Therefore we can
666          issue the regular passphrase status.  FIXME: replace the all
667          zero keyid by a regular one. */
668       gpgsm_status (ctrl, STATUS_BAD_PASSPHRASE, "0000000000000000");
669     }
670   return err;
671 }
672