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