* import.c (check_and_store): Do a full validation if
[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 (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 (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 alos 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 (ksba_reader_t reader, FILE **retfp, struct stats_s *stats)
582 {
583   const char *pgmname;
584   gpg_error_t err = 0, child_err = 0;
585   int i, c, cont_line;
586   unsigned int pos;
587   FILE *tmpfp, *certfp = NULL, *fp = NULL;
588   char buffer[1024];
589   size_t nread;
590   pid_t pid = -1;
591
592   if (!opt.protect_tool_program || !*opt.protect_tool_program)
593     pgmname = GNUPG_DEFAULT_PROTECT_TOOL;
594   else
595     pgmname = opt.protect_tool_program;
596
597   *retfp = NULL;
598
599   /* To avoid an extra feeder process or doing selects and because
600      gpg-protect-tool will anyway parse the entire pkcs#12 message in
601      memory, we simply use tempfiles here and pass them to
602      the gpg-protect-tool. */
603   tmpfp = tmpfile ();
604   if (!tmpfp)
605     {
606       err = gpg_error_from_errno (errno);
607       log_error (_("error creating temporary file: %s\n"), strerror (errno));
608       goto cleanup;
609     }
610   while (!(err = ksba_reader_read (reader, buffer, sizeof buffer, &nread)))
611     {
612       if (nread && fwrite (buffer, nread, 1, tmpfp) != 1)
613         {
614           err = gpg_error_from_errno (errno);
615           log_error (_("error writing to temporary file: %s\n"),
616                      strerror (errno));
617           goto cleanup;
618         }
619     }
620   if (gpg_err_code (err) == GPG_ERR_EOF)
621     err = 0;
622   if (err)
623     {
624       log_error (_("error reading input: %s\n"), gpg_strerror (err));
625       goto cleanup;
626     }
627
628   certfp = tmpfile ();
629   if (!certfp)
630     {
631       err = gpg_error_from_errno (errno);
632       log_error (_("error creating temporary file: %s\n"), strerror (errno));
633       goto cleanup;
634     }
635
636   err = popen_protect_tool (pgmname, tmpfp, certfp, &fp, &pid);
637   if (err)
638     {
639       pid = -1;
640       goto cleanup;
641     }
642   fclose (tmpfp);
643   tmpfp = NULL;
644
645   /* Read stderr of the protect tool. */
646   pos = 0;
647   cont_line = 0;
648   while ((c=getc (fp)) != EOF)
649     {
650       /* fixme: We could here grep for status information of the
651          protect tool to figure out better error codes for
652          CHILD_ERR. */
653       buffer[pos++] = c;
654       if (pos >= sizeof buffer - 5 || c == '\n')
655         {
656           buffer[pos - (c == '\n')] = 0;
657           if (cont_line)
658             log_printf ("%s", buffer);
659           else
660             {
661               if (!strncmp (buffer, "gpg-protect-tool: [PROTECT-TOOL:] ",34))
662                 {
663                   char *p, *pend;
664
665                   p = buffer + 34;
666                   pend = strchr (p, ' ');
667                   if (pend)
668                     *pend = 0;
669                   if ( !strcmp (p, "secretkey-stored"))
670                     {
671                       stats->count++;
672                       stats->secret_read++;
673                       stats->secret_imported++;
674                     }
675                   else if ( !strcmp (p, "secretkey-exists"))
676                     {
677                       stats->count++;
678                       stats->secret_read++;
679                       stats->secret_dups++;
680                     }
681                   else if ( !strcmp (p, "bad-passphrase"))
682                     ;
683                 }
684               else
685                 log_info ("%s", buffer);
686             }
687           pos = 0;
688           cont_line = (c != '\n');
689         }
690     }
691
692   if (pos)
693     {
694       buffer[pos] = 0;
695       if (cont_line)
696         log_printf ("%s\n", buffer);
697       else
698         log_info ("%s\n", buffer);
699     }
700
701   /* If we found no error in the output of the cild, setup a suitable
702      error code, which will later be reset if the exit status of the
703      child is 0. */
704   if (!child_err)
705     child_err = gpg_error (GPG_ERR_DECRYPT_FAILED);
706
707
708  cleanup:
709   if (tmpfp)
710     fclose (tmpfp);
711   if (fp)
712     fclose (fp);
713   if (pid != -1)
714     {
715       int status;
716
717       while ( (i=waitpid (pid, &status, 0)) == -1 && errno == EINTR)
718         ;
719       if (i == -1)
720         log_error (_("waiting for protect-tool to terminate failed: %s\n"),
721                    strerror (errno));
722       else if (WIFEXITED (status) && WEXITSTATUS (status) == 31)
723         log_error (_("error running `%s': probably not installed\n"), pgmname);
724       else if (WIFEXITED (status) && WEXITSTATUS (status))
725         log_error (_("error running `%s': exit status %d\n"), pgmname,
726                      WEXITSTATUS (status));
727       else if (!WIFEXITED (status))
728         log_error (_("error running `%s': terminated\n"), pgmname);
729       else 
730         child_err = 0;
731     }
732   if (!err)
733     err = child_err;
734   if (err)
735     {
736       if (certfp)
737         fclose (certfp);
738     }
739   else
740     *retfp = certfp;
741   return err;
742 }