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