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