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