938bc17d0026d6aa8470a8df480a12cd616b510d
[gnupg.git] / sm / import.c
1 /* import.c - Import certificates
2  *      Copyright (C) 2001, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h> 
27 #include <time.h>
28 #include <assert.h>
29 #include <signal.h>
30 #include <fcntl.h>
31 #include <sys/wait.h>
32
33 #include "gpgsm.h"
34 #include <gcrypt.h>
35 #include <ksba.h>
36
37 #include "keydb.h"
38 #include "i18n.h"
39
40 #ifdef _POSIX_OPEN_MAX
41 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
42 #else
43 #define MAX_OPEN_FDS 20
44 #endif
45
46
47 struct stats_s {
48   unsigned long count;
49   unsigned long imported;
50   unsigned long unchanged;
51   unsigned long not_imported;
52   unsigned long secret_read;
53   unsigned long secret_imported;
54   unsigned long secret_dups;
55  };
56
57
58 static gpg_error_t parse_p12 (ctrl_t ctrl, ksba_reader_t reader, FILE **retfp,
59                               struct stats_s *stats);
60
61
62
63 static void
64 print_imported_status (CTRL ctrl, ksba_cert_t cert, int new_cert)
65 {
66   char *fpr;
67      
68   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
69   if (new_cert)
70     gpgsm_status2 (ctrl, STATUS_IMPORTED, fpr, "[X.509]", NULL);
71
72   gpgsm_status2 (ctrl, STATUS_IMPORT_OK, 
73                  new_cert? "1":"0",  fpr, NULL);
74
75   xfree (fpr);
76 }
77
78
79 /* Print an IMPORT_PROBLEM status.  REASON is one of:
80    0 := "No specific reason given".
81    1 := "Invalid Certificate".
82    2 := "Issuer Certificate missing".
83    3 := "Certificate Chain too long".
84    4 := "Error storing certificate".
85 */
86 static void
87 print_import_problem (CTRL ctrl, ksba_cert_t cert, int reason)
88 {
89   char *fpr = NULL;
90   char buf[25];
91   int i;
92
93   sprintf (buf, "%d", reason);
94   if (cert)
95     {
96       fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
97       /* detetect an error (all high) value */
98       for (i=0; fpr[i] == 'F'; i++)
99         ;
100       if (!fpr[i])
101         {
102           xfree (fpr);
103           fpr = NULL;
104         }
105     }
106   gpgsm_status2 (ctrl, STATUS_IMPORT_PROBLEM, buf, fpr, NULL);
107   xfree (fpr);
108 }
109
110
111 void
112 print_imported_summary (CTRL ctrl, struct stats_s *stats)
113 {
114   char buf[14*25];
115
116   if (!opt.quiet)
117     {
118       log_info (_("total number processed: %lu\n"), stats->count);
119       if (stats->imported) 
120         {
121           log_info (_("              imported: %lu"), stats->imported );
122           log_printf ("\n");
123         }
124       if (stats->unchanged)
125         log_info (_("             unchanged: %lu\n"), stats->unchanged);
126       if (stats->secret_read)
127         log_info (_("      secret keys read: %lu\n"), stats->secret_read );
128       if (stats->secret_imported)
129         log_info (_("  secret keys imported: %lu\n"), stats->secret_imported );
130       if (stats->secret_dups)
131         log_info (_(" secret keys unchanged: %lu\n"), stats->secret_dups );
132       if (stats->not_imported)
133         log_info (_("          not imported: %lu\n"), stats->not_imported);
134     }
135
136   sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
137           stats->count,
138           0l /*stats->no_user_id*/,
139           stats->imported,
140           0l /*stats->imported_rsa*/,
141           stats->unchanged,
142           0l /*stats->n_uids*/,
143           0l /*stats->n_subk*/,
144           0l /*stats->n_sigs*/,
145           0l /*stats->n_revoc*/,
146           stats->secret_read,
147           stats->secret_imported,
148           stats->secret_dups,
149           0l /*stats->skipped_new_keys*/,
150           stats->not_imported
151           );
152   gpgsm_status (ctrl, STATUS_IMPORT_RES, buf);
153 }
154
155
156
157 static void
158 check_and_store (CTRL ctrl, struct stats_s *stats, ksba_cert_t cert, int depth)
159 {
160   int rc;
161
162   if (stats)
163     stats->count++;
164   if ( depth >= 50 )
165     {
166       log_error (_("certificate chain too long\n"));
167       if (stats)
168         stats->not_imported++;
169       print_import_problem (ctrl, cert, 3);
170       return;
171     }
172
173   /* Some basic checks, but don't care about missing certificates;
174      this is so that we are able to import entire certificate chains
175      w/o requiring a special order (i.e. root-CA first).  This used
176      to be different but because gpgsm_verify even imports
177      certificates without any checks, it doesn't matter much and the
178      code gets much cleaner.  A housekeeping function to remove
179      certificates w/o an anchor would be nice, though. 
180      
181      Optionally we do a full validation in addition to the basic test.
182   */
183   rc = gpgsm_basic_cert_check (cert);
184   if (!rc && ctrl->with_validation)
185     rc = gpgsm_validate_chain (ctrl, cert, NULL, 0, NULL, 0);
186   if (!rc || (!ctrl->with_validation
187               && gpg_err_code (rc) == GPG_ERR_MISSING_CERT) )
188     {
189       int existed;
190
191       if (!keydb_store_cert (cert, 0, &existed))
192         {
193           ksba_cert_t next = NULL;
194
195           if (!existed)
196             {
197               print_imported_status (ctrl, cert, 1);
198               if (stats)
199                 stats->imported++;
200             }
201           else
202             {
203               print_imported_status (ctrl, cert, 0);
204               if (stats)
205                 stats->unchanged++;
206             }
207             
208           if (opt.verbose > 1 && existed)
209             {
210               if (depth)
211                 log_info ("issuer certificate already in DB\n");
212               else
213                 log_info ("certificate already in DB\n");
214             }
215           else if (opt.verbose && !existed)
216             {
217               if (depth)
218                 log_info ("issuer certificate imported\n");
219               else
220                 log_info ("certificate imported\n");
221             }
222
223           /* Now lets walk up the chain and import all certificates up
224              the chain.  This is required in case we already stored
225              parent certificates in the ephemeral keybox.  Do not
226              update the statistics, though. */
227           if (!gpgsm_walk_cert_chain (cert, &next))
228             {
229               check_and_store (ctrl, NULL, next, depth+1);
230               ksba_cert_release (next);
231             }
232         }
233       else
234         {
235           log_error (_("error storing certificate\n"));
236           if (stats)
237             stats->not_imported++;
238           print_import_problem (ctrl, cert, 4);
239         }
240     }
241   else
242     {
243       log_error (_("basic certificate checks failed - not imported\n"));
244       if (stats)
245         stats->not_imported++;
246       print_import_problem (ctrl, cert,
247                             gpg_err_code (rc) == GPG_ERR_MISSING_CERT? 2 :
248                             gpg_err_code (rc) == GPG_ERR_BAD_CERT?     1 : 0);
249     }
250 }
251
252
253 \f
254
255 static int
256 import_one (CTRL ctrl, struct stats_s *stats, int in_fd)
257 {
258   int rc;
259   Base64Context b64reader = NULL;
260   ksba_reader_t reader;
261   ksba_cert_t cert = NULL;
262   ksba_cms_t cms = NULL;
263   FILE *fp = NULL;
264   ksba_content_type_t ct;
265   int any = 0;
266
267   fp = fdopen ( dup (in_fd), "rb");
268   if (!fp)
269     {
270       rc = gpg_error (gpg_err_code_from_errno (errno));
271       log_error ("fdopen() failed: %s\n", strerror (errno));
272       goto leave;
273     }
274
275   rc = gpgsm_create_reader (&b64reader, ctrl, fp, 1, &reader);
276   if (rc)
277     {
278       log_error ("can't create reader: %s\n", gpg_strerror (rc));
279       goto leave;
280     }
281   
282   
283   /* We need to loop here to handle multiple PEM objects in one
284      file. */
285   do
286     {
287       ksba_cms_release (cms); cms = NULL;
288       ksba_cert_release (cert); cert = NULL;
289       
290       ct = ksba_cms_identify (reader);
291       if (ct == KSBA_CT_SIGNED_DATA)
292         { /* This is probably a signed-only message - import the certs */
293           ksba_stop_reason_t stopreason;
294           int i;
295           
296           rc = ksba_cms_new (&cms);
297           if (rc)
298             goto leave;
299           
300           rc = ksba_cms_set_reader_writer (cms, reader, NULL);
301           if (rc)
302             {
303               log_error ("ksba_cms_set_reader_writer failed: %s\n",
304                          gpg_strerror (rc));
305               goto leave;
306             }
307
308           do 
309             {
310               rc = ksba_cms_parse (cms, &stopreason);
311               if (rc)
312                 {
313                   log_error ("ksba_cms_parse failed: %s\n", gpg_strerror (rc));
314                   goto leave;
315                 }
316
317               if (stopreason == KSBA_SR_BEGIN_DATA)
318                 log_info ("not a certs-only message\n");
319             }
320           while (stopreason != KSBA_SR_READY);   
321       
322           for (i=0; (cert=ksba_cms_get_cert (cms, i)); i++)
323             {
324               check_and_store (ctrl, stats, cert, 0);
325               ksba_cert_release (cert); 
326               cert = NULL;
327             }
328           if (!i)
329             log_error ("no certificate found\n");
330           else
331             any = 1;
332         }
333       else if (ct == KSBA_CT_PKCS12)
334         { /* This seems to be a pkcs12 message.  We use an external
335              tool to parse the message and to store the private keys.
336              We need to use a another reader here to parse the
337              certificate we included in the p12 file; then we continue
338              to look for other pkcs12 files (works only if they are in
339              PEM format. */
340           FILE *certfp;
341           Base64Context b64p12rdr;
342           ksba_reader_t p12rdr;
343           
344           rc = parse_p12 (ctrl, reader, &certfp, stats);
345           if (!rc)
346             {
347               any = 1;
348               
349               rewind (certfp);
350               rc = gpgsm_create_reader (&b64p12rdr, ctrl, certfp, 1, &p12rdr);
351               if (rc)
352                 {
353                   log_error ("can't create reader: %s\n", gpg_strerror (rc));
354                   fclose (certfp);
355                   goto leave;
356                 }
357
358               do
359                 {
360                   ksba_cert_release (cert); cert = NULL;
361                   rc = ksba_cert_new (&cert);
362                   if (!rc)
363                     {
364                       rc = ksba_cert_read_der (cert, p12rdr);
365                       if (!rc)
366                         check_and_store (ctrl, stats, cert, 0);
367                     }
368                   ksba_reader_clear (p12rdr, NULL, NULL);
369                 }
370               while (!rc && !gpgsm_reader_eof_seen (b64p12rdr));
371
372               if (gpg_err_code (rc) == GPG_ERR_EOF)
373                 rc = 0;
374               gpgsm_destroy_reader (b64p12rdr);
375               fclose (certfp);
376               if (rc)
377                 goto leave;
378             }
379         }
380       else if (ct == KSBA_CT_NONE)
381         { /* Failed to identify this message - assume a certificate */
382
383           rc = ksba_cert_new (&cert);
384           if (rc)
385             goto leave;
386
387           rc = ksba_cert_read_der (cert, reader);
388           if (rc)
389             goto leave;
390
391           check_and_store (ctrl, stats, cert, 0);
392           any = 1;
393         }
394       else
395         {
396           log_error ("can't extract certificates from input\n");
397           rc = gpg_error (GPG_ERR_NO_DATA);
398         }
399       
400       ksba_reader_clear (reader, NULL, NULL);
401     }
402   while (!gpgsm_reader_eof_seen (b64reader));
403
404  leave:
405   if (any && gpg_err_code (rc) == GPG_ERR_EOF)
406     rc = 0;
407   ksba_cms_release (cms);
408   ksba_cert_release (cert);
409   gpgsm_destroy_reader (b64reader);
410   if (fp)
411     fclose (fp);
412   return rc;
413 }
414
415
416 int
417 gpgsm_import (CTRL ctrl, int in_fd)
418 {
419   int rc;
420   struct stats_s stats;
421
422   memset (&stats, 0, sizeof stats);
423   rc = import_one (ctrl, &stats, in_fd);
424   print_imported_summary (ctrl, &stats);
425   /* If we never printed an error message do it now so that a command
426      line invocation will return with an error (log_error keeps a
427      global errorcount) */
428   if (rc && !log_get_errorcount (0))
429     log_error (_("error importing certificate: %s\n"), gpg_strerror (rc));
430   return rc;
431 }
432
433
434 int
435 gpgsm_import_files (CTRL ctrl, int nfiles, char **files,
436                     int (*of)(const char *fname))
437 {
438   int rc = 0;
439   struct stats_s stats;
440
441   memset (&stats, 0, sizeof stats);
442   
443   if (!nfiles)
444     rc = import_one (ctrl, &stats, 0);
445   else
446     {
447       for (; nfiles && !rc ; nfiles--, files++)
448         {
449           int fd = of (*files);
450           rc = import_one (ctrl, &stats, fd);
451           close (fd);
452           if (rc == -1)
453             rc = 0;
454         }
455     }
456   print_imported_summary (ctrl, &stats);
457   /* If we never printed an error message do it now so that a command
458      line invocation will return with an error (log_error keeps a
459      global errorcount) */
460   if (rc && !log_get_errorcount (0))
461     log_error (_("error importing certificate: %s\n"), gpg_strerror (rc));
462   return rc;
463 }
464
465
466 /* Fork and exec the protecttool, connect the file descriptor of
467    INFILE to stdin, return a new stream in STATUSFILE, write the
468    output to OUTFILE and the pid of the process in PID.  Returns 0 on
469    success or an error code. */
470 static gpg_error_t
471 popen_protect_tool (const char *pgmname,
472                     FILE *infile, FILE *outfile, FILE **statusfile, pid_t *pid)
473 {
474   gpg_error_t err;
475   int fd, fdout, rp[2];
476   int n, i;
477
478   fflush (infile);
479   rewind (infile);
480   fd = fileno (infile);
481   fdout = fileno (outfile);
482   if (fd == -1 || fdout == -1)
483     log_fatal ("no file descriptor for temporary file: %s\n",
484                strerror (errno));
485
486   /* Now start the protect-tool. */
487   if (pipe (rp) == -1)
488     {
489       err = gpg_error_from_errno (errno);
490       log_error (_("error creating a pipe: %s\n"), strerror (errno));
491       return err;
492     }
493       
494   *pid = fork ();
495   if (*pid == -1)
496     {
497       err = gpg_error_from_errno (errno);
498       log_error (_("error forking process: %s\n"), strerror (errno));
499       close (rp[0]);
500       close (rp[1]);
501       return err;
502     }
503
504   if (!*pid)
505     { /* Child. */
506       const char *arg0;
507
508       arg0 = strrchr (pgmname, '/');
509       if (arg0)
510         arg0++;
511       else
512         arg0 = pgmname;
513
514       /* Connect the infile to stdin. */
515       if (fd != 0 && dup2 (fd, 0) == -1)
516         log_fatal ("dup2 stdin failed: %s\n", strerror (errno));
517
518       /* Connect the outfile to stdout. */
519       if (fdout != 1 && dup2 (fdout, 1) == -1)
520         log_fatal ("dup2 stdout failed: %s\n", strerror (errno));
521       
522       /* Connect stderr to our pipe. */
523       if (rp[1] != 2 && dup2 (rp[1], 2) == -1)
524         log_fatal ("dup2 stderr failed: %s\n", strerror (errno));
525
526       /* Close all other files. */
527       n = sysconf (_SC_OPEN_MAX);
528       if (n < 0)
529         n = MAX_OPEN_FDS;
530       for (i=3; i < n; i++)
531         close(i);
532       errno = 0;
533
534       setup_pinentry_env ();
535
536       if (opt.fixed_passphrase)
537         execlp (pgmname, arg0,
538                 "--homedir", opt.homedir,
539                 "--p12-import",
540                 "--store", 
541                 "--no-fail-on-exist",
542                 "--enable-status-msg",
543                 "--passphrase", opt.fixed_passphrase,
544                 "--",
545                 NULL);
546       else
547         execlp (pgmname, arg0,
548                 "--homedir", opt.homedir,
549                 "--p12-import",
550                 "--store", 
551                 "--no-fail-on-exist",
552                 "--enable-status-msg",
553                 "--",
554                 NULL);
555       /* No way to print anything, as we have closed all streams. */
556       _exit (31);
557     }
558
559   /* Parent. */
560   close (rp[1]);
561   *statusfile = fdopen (rp[0], "r");
562   if (!*statusfile)
563     {
564       err = gpg_error_from_errno (errno);
565       log_error ("can't fdopen pipe for reading: %s", strerror (errno));
566       kill (*pid, SIGTERM);
567       return err;
568     }
569
570   return 0;
571 }
572
573
574 /* Assume that the reader is at a pkcs#12 message and try to import
575    certificates from that stupid format.  We will also store secret
576    keys.  All of the pkcs#12 parsing and key storing is handled by the
577    gpg-protect-tool, we merely have to take care of receiving the
578    certificates. On success RETFP returns a temporary file with
579    certificates. */
580 static gpg_error_t
581 parse_p12 (ctrl_t ctrl, ksba_reader_t reader,
582            FILE **retfp, struct stats_s *stats)
583 {
584   const char *pgmname;
585   gpg_error_t err = 0, child_err = 0;
586   int i, c, cont_line;
587   unsigned int pos;
588   FILE *tmpfp, *certfp = NULL, *fp = NULL;
589   char buffer[1024];
590   size_t nread;
591   pid_t pid = -1;
592   int bad_pass = 0;
593
594   if (!opt.protect_tool_program || !*opt.protect_tool_program)
595     pgmname = GNUPG_DEFAULT_PROTECT_TOOL;
596   else
597     pgmname = opt.protect_tool_program;
598
599   *retfp = NULL;
600
601   /* To avoid an extra feeder process or doing selects and because
602      gpg-protect-tool will anyway parse the entire pkcs#12 message in
603      memory, we simply use tempfiles here and pass them to
604      the gpg-protect-tool. */
605   tmpfp = tmpfile ();
606   if (!tmpfp)
607     {
608       err = gpg_error_from_errno (errno);
609       log_error (_("error creating temporary file: %s\n"), strerror (errno));
610       goto cleanup;
611     }
612   while (!(err = ksba_reader_read (reader, buffer, sizeof buffer, &nread)))
613     {
614       if (nread && fwrite (buffer, nread, 1, tmpfp) != 1)
615         {
616           err = gpg_error_from_errno (errno);
617           log_error (_("error writing to temporary file: %s\n"),
618                      strerror (errno));
619           goto cleanup;
620         }
621     }
622   if (gpg_err_code (err) == GPG_ERR_EOF)
623     err = 0;
624   if (err)
625     {
626       log_error (_("error reading input: %s\n"), gpg_strerror (err));
627       goto cleanup;
628     }
629
630   certfp = tmpfile ();
631   if (!certfp)
632     {
633       err = gpg_error_from_errno (errno);
634       log_error (_("error creating temporary file: %s\n"), strerror (errno));
635       goto cleanup;
636     }
637
638   err = popen_protect_tool (pgmname, tmpfp, certfp, &fp, &pid);
639   if (err)
640     {
641       pid = -1;
642       goto cleanup;
643     }
644   fclose (tmpfp);
645   tmpfp = NULL;
646
647   /* Read stderr of the protect tool. */
648   pos = 0;
649   cont_line = 0;
650   while ((c=getc (fp)) != EOF)
651     {
652       /* fixme: We could here grep for status information of the
653          protect tool to figure out better error codes for
654          CHILD_ERR. */
655       buffer[pos++] = c;
656       if (pos >= sizeof buffer - 5 || c == '\n')
657         {
658           buffer[pos - (c == '\n')] = 0;
659           if (cont_line)
660             log_printf ("%s", buffer);
661           else
662             {
663               if (!strncmp (buffer, "gpg-protect-tool: [PROTECT-TOOL:] ",34))
664                 {
665                   char *p, *pend;
666
667                   p = buffer + 34;
668                   pend = strchr (p, ' ');
669                   if (pend)
670                     *pend = 0;
671                   if ( !strcmp (p, "secretkey-stored"))
672                     {
673                       stats->count++;
674                       stats->secret_read++;
675                       stats->secret_imported++;
676                     }
677                   else if ( !strcmp (p, "secretkey-exists"))
678                     {
679                       stats->count++;
680                       stats->secret_read++;
681                       stats->secret_dups++;
682                     }
683                   else if ( !strcmp (p, "bad-passphrase"))
684                     ;
685                 }
686               else 
687                 {
688                   log_info ("%s", buffer);
689                   if (!strncmp (buffer, "gpg-protect-tool: "
690                                 "possibly bad passphrase given",46))
691                     bad_pass++;
692                 }
693             }
694           pos = 0;
695           cont_line = (c != '\n');
696         }
697     }
698
699   if (pos)
700     {
701       buffer[pos] = 0;
702       if (cont_line)
703         log_printf ("%s\n", buffer);
704       else
705         log_info ("%s\n", buffer);
706     }
707
708
709   /* If we found no error in the output of the cild, setup a suitable
710      error code, which will later be reset if the exit status of the
711      child is 0. */
712   if (!child_err)
713     child_err = gpg_error (GPG_ERR_DECRYPT_FAILED);
714
715
716  cleanup:
717   if (tmpfp)
718     fclose (tmpfp);
719   if (fp)
720     fclose (fp);
721   if (pid != -1)
722     {
723       int status;
724
725       while ( (i=waitpid (pid, &status, 0)) == -1 && errno == EINTR)
726         ;
727       if (i == -1)
728         log_error (_("waiting for protect-tool to terminate failed: %s\n"),
729                    strerror (errno));
730       else if (WIFEXITED (status) && WEXITSTATUS (status) == 31)
731         log_error (_("error running `%s': probably not installed\n"), pgmname);
732       else if (WIFEXITED (status) && WEXITSTATUS (status))
733         log_error (_("error running `%s': exit status %d\n"), pgmname,
734                      WEXITSTATUS (status));
735       else if (!WIFEXITED (status))
736         log_error (_("error running `%s': terminated\n"), pgmname);
737       else 
738         child_err = 0;
739     }
740   if (!err)
741     err = child_err;
742   if (err)
743     {
744       if (certfp)
745         fclose (certfp);
746     }
747   else
748     *retfp = certfp;
749
750   if (bad_pass)
751     {
752       /* We only write a plain error code and not direct
753          BAD_PASSPHRASE because the pkcs12 parser might issue this
754          message multiple times, BAd_PASSPHRASE in general requires a
755          keyID and parts of the import might actually succeed so that
756          IMPORT_PROBLEM is also not appropriate. */
757       gpgsm_status_with_err_code (ctrl, STATUS_ERROR,
758                                   "import.parsep12", GPG_ERR_BAD_PASSPHRASE);
759     }
760   
761   return err;
762 }