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