Avoid using the protect-tool to import pkcs#12.
[gnupg.git] / sm / import.c
1 /* import.c - Import certificates
2  * Copyright (C) 2001, 2003, 2004, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <time.h>
26 #include <assert.h>
27 #include <unistd.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 #include "sysutils.h"
37 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
38 #include "../common/membuf.h"
39 #include "minip12.h"
40
41 /* The arbitrary limit of one PKCS#12 object.  */
42 #define MAX_P12OBJ_SIZE 128 /*kb*/
43
44
45 struct stats_s {
46   unsigned long count;
47   unsigned long imported;
48   unsigned long unchanged;
49   unsigned long not_imported;
50   unsigned long secret_read;
51   unsigned long secret_imported;
52   unsigned long secret_dups;
53  };
54
55
56 struct rsa_secret_key_s 
57 {
58   gcry_mpi_t n;     /* public modulus */
59   gcry_mpi_t e;     /* public exponent */
60   gcry_mpi_t d;     /* exponent */
61   gcry_mpi_t p;     /* prime  p. */
62   gcry_mpi_t q;     /* prime  q. */
63   gcry_mpi_t u;     /* inverse of p mod q. */
64 };
65
66
67 static gpg_error_t parse_p12 (ctrl_t ctrl, ksba_reader_t reader,
68                               struct stats_s *stats);
69
70
71
72 static void
73 print_imported_status (ctrl_t ctrl, ksba_cert_t cert, int new_cert)
74 {
75   char *fpr;
76      
77   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
78   if (new_cert)
79     gpgsm_status2 (ctrl, STATUS_IMPORTED, fpr, "[X.509]", NULL);
80
81   gpgsm_status2 (ctrl, STATUS_IMPORT_OK, 
82                  new_cert? "1":"0",  fpr, NULL);
83
84   xfree (fpr);
85 }
86
87
88 /* Print an IMPORT_PROBLEM status.  REASON is one of:
89    0 := "No specific reason given".
90    1 := "Invalid Certificate".
91    2 := "Issuer Certificate missing".
92    3 := "Certificate Chain too long".
93    4 := "Error storing certificate".
94 */
95 static void
96 print_import_problem (ctrl_t ctrl, ksba_cert_t cert, int reason)
97 {
98   char *fpr = NULL;
99   char buf[25];
100   int i;
101
102   sprintf (buf, "%d", reason);
103   if (cert)
104     {
105       fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
106       /* detetect an error (all high) value */
107       for (i=0; fpr[i] == 'F'; i++)
108         ;
109       if (!fpr[i])
110         {
111           xfree (fpr);
112           fpr = NULL;
113         }
114     }
115   gpgsm_status2 (ctrl, STATUS_IMPORT_PROBLEM, buf, fpr, NULL);
116   xfree (fpr);
117 }
118
119
120 void
121 print_imported_summary (ctrl_t ctrl, struct stats_s *stats)
122 {
123   char buf[14*25];
124
125   if (!opt.quiet)
126     {
127       log_info (_("total number processed: %lu\n"), stats->count);
128       if (stats->imported) 
129         {
130           log_info (_("              imported: %lu"), stats->imported );
131           log_printf ("\n");
132         }
133       if (stats->unchanged)
134         log_info (_("             unchanged: %lu\n"), stats->unchanged);
135       if (stats->secret_read)
136         log_info (_("      secret keys read: %lu\n"), stats->secret_read );
137       if (stats->secret_imported)
138         log_info (_("  secret keys imported: %lu\n"), stats->secret_imported );
139       if (stats->secret_dups)
140         log_info (_(" secret keys unchanged: %lu\n"), stats->secret_dups );
141       if (stats->not_imported)
142         log_info (_("          not imported: %lu\n"), stats->not_imported);
143     }
144
145   sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
146           stats->count,
147           0l /*stats->no_user_id*/,
148           stats->imported,
149           0l /*stats->imported_rsa*/,
150           stats->unchanged,
151           0l /*stats->n_uids*/,
152           0l /*stats->n_subk*/,
153           0l /*stats->n_sigs*/,
154           0l /*stats->n_revoc*/,
155           stats->secret_read,
156           stats->secret_imported,
157           stats->secret_dups,
158           0l /*stats->skipped_new_keys*/,
159           stats->not_imported
160           );
161   gpgsm_status (ctrl, STATUS_IMPORT_RES, buf);
162 }
163
164
165
166 static void
167 check_and_store (ctrl_t ctrl, struct stats_s *stats,
168                  ksba_cert_t cert, int depth)
169 {
170   int rc;
171
172   if (stats)
173     stats->count++;
174   if ( depth >= 50 )
175     {
176       log_error (_("certificate chain too long\n"));
177       if (stats)
178         stats->not_imported++;
179       print_import_problem (ctrl, cert, 3);
180       return;
181     }
182
183   /* Some basic checks, but don't care about missing certificates;
184      this is so that we are able to import entire certificate chains
185      w/o requiring a special order (i.e. root-CA first).  This used
186      to be different but because gpgsm_verify even imports
187      certificates without any checks, it doesn't matter much and the
188      code gets much cleaner.  A housekeeping function to remove
189      certificates w/o an anchor would be nice, though. 
190      
191      Optionally we do a full validation in addition to the basic test.
192   */
193   rc = gpgsm_basic_cert_check (ctrl, cert);
194   if (!rc && ctrl->with_validation)
195     rc = gpgsm_validate_chain (ctrl, cert, "", NULL, 0, NULL, 0, NULL);
196   if (!rc || (!ctrl->with_validation
197               && gpg_err_code (rc) == GPG_ERR_MISSING_CERT) )
198     {
199       int existed;
200
201       if (!keydb_store_cert (cert, 0, &existed))
202         {
203           ksba_cert_t next = NULL;
204
205           if (!existed)
206             {
207               print_imported_status (ctrl, cert, 1);
208               if (stats)
209                 stats->imported++;
210             }
211           else
212             {
213               print_imported_status (ctrl, cert, 0);
214               if (stats)
215                 stats->unchanged++;
216             }
217             
218           if (opt.verbose > 1 && existed)
219             {
220               if (depth)
221                 log_info ("issuer certificate already in DB\n");
222               else
223                 log_info ("certificate already in DB\n");
224             }
225           else if (opt.verbose && !existed)
226             {
227               if (depth)
228                 log_info ("issuer certificate imported\n");
229               else
230                 log_info ("certificate imported\n");
231             }
232
233           /* Now lets walk up the chain and import all certificates up
234              the chain.  This is required in case we already stored
235              parent certificates in the ephemeral keybox.  Do not
236              update the statistics, though. */
237           if (!gpgsm_walk_cert_chain (ctrl, cert, &next))
238             {
239               check_and_store (ctrl, NULL, next, depth+1);
240               ksba_cert_release (next);
241             }
242         }
243       else
244         {
245           log_error (_("error storing certificate\n"));
246           if (stats)
247             stats->not_imported++;
248           print_import_problem (ctrl, cert, 4);
249         }
250     }
251   else
252     {
253       log_error (_("basic certificate checks failed - not imported\n"));
254       if (stats)
255         stats->not_imported++;
256       print_import_problem (ctrl, cert,
257                             gpg_err_code (rc) == GPG_ERR_MISSING_CERT? 2 :
258                             gpg_err_code (rc) == GPG_ERR_BAD_CERT?     1 : 0);
259     }
260 }
261
262
263 \f
264
265 static int
266 import_one (ctrl_t ctrl, struct stats_s *stats, int in_fd)
267 {
268   int rc;
269   Base64Context b64reader = NULL;
270   ksba_reader_t reader;
271   ksba_cert_t cert = NULL;
272   ksba_cms_t cms = NULL;
273   estream_t fp = NULL;
274   ksba_content_type_t ct;
275   int any = 0;
276
277   fp = es_fdopen_nc (in_fd, "rb");
278   if (!fp)
279     {
280       rc = gpg_error_from_syserror ();
281       log_error ("fdopen() failed: %s\n", strerror (errno));
282       goto leave;
283     }
284
285   rc = gpgsm_create_reader (&b64reader, ctrl, fp, 1, &reader);
286   if (rc)
287     {
288       log_error ("can't create reader: %s\n", gpg_strerror (rc));
289       goto leave;
290     }
291   
292   
293   /* We need to loop here to handle multiple PEM objects in one
294      file. */
295   do
296     {
297       ksba_cms_release (cms); cms = NULL;
298       ksba_cert_release (cert); cert = NULL;
299       
300       ct = ksba_cms_identify (reader);
301       if (ct == KSBA_CT_SIGNED_DATA)
302         { /* This is probably a signed-only message - import the certs */
303           ksba_stop_reason_t stopreason;
304           int i;
305           
306           rc = ksba_cms_new (&cms);
307           if (rc)
308             goto leave;
309           
310           rc = ksba_cms_set_reader_writer (cms, reader, NULL);
311           if (rc)
312             {
313               log_error ("ksba_cms_set_reader_writer failed: %s\n",
314                          gpg_strerror (rc));
315               goto leave;
316             }
317
318           do 
319             {
320               rc = ksba_cms_parse (cms, &stopreason);
321               if (rc)
322                 {
323                   log_error ("ksba_cms_parse failed: %s\n", gpg_strerror (rc));
324                   goto leave;
325                 }
326
327               if (stopreason == KSBA_SR_BEGIN_DATA)
328                 log_info ("not a certs-only message\n");
329             }
330           while (stopreason != KSBA_SR_READY);   
331       
332           for (i=0; (cert=ksba_cms_get_cert (cms, i)); i++)
333             {
334               check_and_store (ctrl, stats, cert, 0);
335               ksba_cert_release (cert); 
336               cert = NULL;
337             }
338           if (!i)
339             log_error ("no certificate found\n");
340           else
341             any = 1;
342         }
343       else if (ct == KSBA_CT_PKCS12)
344         { 
345           /* This seems to be a pkcs12 message. */
346           rc = parse_p12 (ctrl, reader, stats);
347           if (!rc)
348             any = 1;
349         }
350       else if (ct == KSBA_CT_NONE)
351         { /* Failed to identify this message - assume a certificate */
352
353           rc = ksba_cert_new (&cert);
354           if (rc)
355             goto leave;
356
357           rc = ksba_cert_read_der (cert, reader);
358           if (rc)
359             goto leave;
360
361           check_and_store (ctrl, stats, cert, 0);
362           any = 1;
363         }
364       else
365         {
366           log_error ("can't extract certificates from input\n");
367           rc = gpg_error (GPG_ERR_NO_DATA);
368         }
369       
370       ksba_reader_clear (reader, NULL, NULL);
371     }
372   while (!gpgsm_reader_eof_seen (b64reader));
373
374  leave:
375   if (any && gpg_err_code (rc) == GPG_ERR_EOF)
376     rc = 0;
377   ksba_cms_release (cms);
378   ksba_cert_release (cert);
379   gpgsm_destroy_reader (b64reader);
380   es_fclose (fp);
381   return rc;
382 }
383
384
385 \f
386 /* Re-import certifciates.  IN_FD is a list of linefeed delimited
387    fingerprints t re-import.  The actual re-import is done by clearing
388    the ephemeral flag.  */
389 static int
390 reimport_one (ctrl_t ctrl, struct stats_s *stats, int in_fd)
391 {
392   gpg_error_t err = 0;
393   estream_t fp = NULL;
394   char line[100];  /* Sufficient for a fingerprint.  */
395   KEYDB_HANDLE kh;
396   KEYDB_SEARCH_DESC desc;
397   ksba_cert_t cert = NULL;
398   unsigned int flags;
399
400   kh = keydb_new (0);
401   if (!kh)
402     {
403       err = gpg_error (GPG_ERR_ENOMEM);;
404       log_error (_("failed to allocate keyDB handle\n"));
405       goto leave;
406     }
407   keydb_set_ephemeral (kh, 1);
408    
409   fp = es_fdopen_nc (in_fd, "r");
410   if (!fp)
411     {
412       err = gpg_error_from_syserror ();
413       log_error ("es_fdopen(%d) failed: %s\n", in_fd, gpg_strerror (err));
414       goto leave;
415     }
416
417   while (es_fgets (line, DIM(line)-1, fp) )
418     {
419       if (*line && line[strlen(line)-1] != '\n')
420         {
421           err = gpg_error (GPG_ERR_LINE_TOO_LONG);
422           goto leave;
423         }
424       trim_spaces (line);
425       if (!*line)
426         continue;
427     
428       stats->count++;
429
430       err = classify_user_id (line, &desc);
431       if (err)
432         {
433           print_import_problem (ctrl, NULL, 0);
434           stats->not_imported++;
435           continue;
436         }
437
438       keydb_search_reset (kh);
439       err = keydb_search (kh, &desc, 1);
440       if (err)
441         {
442           print_import_problem (ctrl, NULL, 0);
443           stats->not_imported++;
444           continue;
445         }
446
447       ksba_cert_release (cert);
448       cert = NULL;
449       err = keydb_get_cert (kh, &cert);
450       if (err)
451         {
452           log_error ("keydb_get_cert() failed: %s\n", gpg_strerror (err));
453           print_import_problem (ctrl, NULL, 1);
454           stats->not_imported++;
455           continue;
456         }
457
458       err = keydb_get_flags (kh, KEYBOX_FLAG_BLOB, 0, &flags);
459       if (err)
460         {
461           log_error (_("error getting stored flags: %s\n"), gpg_strerror (err));
462           print_imported_status (ctrl, cert, 0);
463           stats->not_imported++;
464           continue;
465         }
466       if ( !(flags & KEYBOX_FLAG_BLOB_EPHEMERAL) )
467         {
468           print_imported_status (ctrl, cert, 0);
469           stats->unchanged++;
470           continue;
471         }
472
473       err = keydb_set_cert_flags (cert, 1, KEYBOX_FLAG_BLOB, 0,
474                                   KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
475       if (err)
476         {
477           log_error ("clearing ephemeral flag failed: %s\n",
478                      gpg_strerror (err)); 
479           print_import_problem (ctrl, cert, 0);
480           stats->not_imported++;
481           continue;
482         }
483
484       print_imported_status (ctrl, cert, 1);
485       stats->imported++;
486     }
487   err = 0;
488   if (es_ferror (fp))
489     {
490       err = gpg_error_from_syserror ();
491       log_error ("error reading fd %d: %s\n", in_fd, gpg_strerror (err));
492       goto leave;
493     }
494
495  leave:
496   ksba_cert_release (cert);
497   keydb_release (kh);
498   es_fclose (fp);
499   return err;
500 }
501
502
503 \f
504 int
505 gpgsm_import (ctrl_t ctrl, int in_fd, int reimport_mode)
506 {
507   int rc;
508   struct stats_s stats;
509
510   memset (&stats, 0, sizeof stats);
511   if (reimport_mode)
512     rc = reimport_one (ctrl, &stats, in_fd);
513   else
514     rc = import_one (ctrl, &stats, in_fd);
515   print_imported_summary (ctrl, &stats);
516   /* If we never printed an error message do it now so that a command
517      line invocation will return with an error (log_error keeps a
518      global errorcount) */
519   if (rc && !log_get_errorcount (0))
520     log_error (_("error importing certificate: %s\n"), gpg_strerror (rc));
521   return rc;
522 }
523
524
525 int
526 gpgsm_import_files (ctrl_t ctrl, int nfiles, char **files,
527                     int (*of)(const char *fname))
528 {
529   int rc = 0;
530   struct stats_s stats;
531
532   memset (&stats, 0, sizeof stats);
533   
534   if (!nfiles)
535     rc = import_one (ctrl, &stats, 0);
536   else
537     {
538       for (; nfiles && !rc ; nfiles--, files++)
539         {
540           int fd = of (*files);
541           rc = import_one (ctrl, &stats, fd);
542           close (fd);
543           if (rc == -1)
544             rc = 0;
545         }
546     }
547   print_imported_summary (ctrl, &stats);
548   /* If we never printed an error message do it now so that a command
549      line invocation will return with an error (log_error keeps a
550      global errorcount) */
551   if (rc && !log_get_errorcount (0))
552     log_error (_("error importing certificate: %s\n"), gpg_strerror (rc));
553   return rc;
554 }
555
556
557 /* Check that the RSA secret key SKEY is valid.  Swap parameters to
558    the libgcrypt standard.  */
559 static gpg_error_t
560 rsa_key_check (struct rsa_secret_key_s *skey)
561 {
562   int err = 0;
563   gcry_mpi_t t = gcry_mpi_snew (0);
564   gcry_mpi_t t1 = gcry_mpi_snew (0);
565   gcry_mpi_t t2 = gcry_mpi_snew (0);
566   gcry_mpi_t phi = gcry_mpi_snew (0);
567
568   /* Check that n == p * q.  */
569   gcry_mpi_mul (t, skey->p, skey->q);
570   if (gcry_mpi_cmp( t, skey->n) )
571     {
572       log_error ("RSA oops: n != p * q\n");
573       err++;
574     }
575
576   /* Check that p is less than q.  */
577   if (gcry_mpi_cmp (skey->p, skey->q) > 0)
578     {
579       gcry_mpi_t tmp;
580
581       log_info ("swapping secret primes\n");
582       tmp = gcry_mpi_copy (skey->p);
583       gcry_mpi_set (skey->p, skey->q);
584       gcry_mpi_set (skey->q, tmp);
585       gcry_mpi_release (tmp);
586       /* Recompute u.  */
587       gcry_mpi_invm (skey->u, skey->p, skey->q);
588     }
589
590   /* Check that e divides neither p-1 nor q-1.  */
591   gcry_mpi_sub_ui (t, skey->p, 1 );
592   gcry_mpi_div (NULL, t, t, skey->e, 0);
593   if (!gcry_mpi_cmp_ui( t, 0) )
594     {
595       log_error ("RSA oops: e divides p-1\n");
596       err++;
597     }
598   gcry_mpi_sub_ui (t, skey->q, 1);
599   gcry_mpi_div (NULL, t, t, skey->e, 0);
600   if (!gcry_mpi_cmp_ui( t, 0))
601     {
602       log_info ("RSA oops: e divides q-1\n" );
603       err++;
604     }
605
606   /* Check that d is correct.  */
607   gcry_mpi_sub_ui (t1, skey->p, 1);
608   gcry_mpi_sub_ui (t2, skey->q, 1);
609   gcry_mpi_mul (phi, t1, t2);
610   gcry_mpi_invm (t, skey->e, phi);
611   if (gcry_mpi_cmp (t, skey->d))
612     { 
613       /* No: try universal exponent. */
614       gcry_mpi_gcd (t, t1, t2);
615       gcry_mpi_div (t, NULL, phi, t, 0);
616       gcry_mpi_invm (t, skey->e, t);
617       if (gcry_mpi_cmp (t, skey->d))
618         {
619           log_error ("RSA oops: bad secret exponent\n");
620           err++;
621         }
622     }
623
624   /* Check for correctness of u.  */
625   gcry_mpi_invm (t, skey->p, skey->q);
626   if (gcry_mpi_cmp (t, skey->u))
627     {
628       log_info ("RSA oops: bad u parameter\n");
629       err++;
630     }
631
632   if (err)
633     log_info ("RSA secret key check failed\n");
634
635   gcry_mpi_release (t);
636   gcry_mpi_release (t1);
637   gcry_mpi_release (t2);
638   gcry_mpi_release (phi);
639
640   return err? gpg_error (GPG_ERR_BAD_SECKEY):0;
641 }
642
643
644 /* Object passed to store_cert_cb.  */
645 struct store_cert_parm_s
646 {
647   gpg_error_t err;        /* First error seen.  */
648   struct stats_s *stats;  /* The stats object.  */
649   ctrl_t ctrl;            /* The control object.  */
650 };
651
652 /* Helper to store the DER encoded certificate CERTDATA of length
653    CERTDATALEN.  */ 
654 static void
655 store_cert_cb (void *opaque,
656                const unsigned char *certdata, size_t certdatalen)
657 {
658   struct store_cert_parm_s *parm = opaque;
659   gpg_error_t err;
660   ksba_cert_t cert;
661
662   err = ksba_cert_new (&cert);
663   if (err)
664     {
665       if (!parm->err)
666         parm->err = err;
667       return;
668     }
669
670   err = ksba_cert_init_from_mem (cert, certdata, certdatalen);
671   if (err)
672     {
673       log_error ("failed to parse a certificate: %s\n", gpg_strerror (err));
674       if (!parm->err)
675         parm->err = err;
676     }
677   else
678     check_and_store (parm->ctrl, parm->stats, cert, 0);
679   ksba_cert_release (cert);
680 }
681
682
683 /* Assume that the reader is at a pkcs#12 message and try to import
684    certificates from that stupid format.  We will transfer secret
685    keys to the agent.  */
686 static gpg_error_t
687 parse_p12 (ctrl_t ctrl, ksba_reader_t reader, struct stats_s *stats)
688 {
689   gpg_error_t err = 0;
690   char buffer[1024];
691   size_t ntotal, nread;
692   membuf_t p12mbuf;
693   char *p12buffer = NULL;
694   size_t p12buflen;
695   size_t p12bufoff;
696   gcry_mpi_t *kparms = NULL;
697   struct rsa_secret_key_s sk;
698   char *passphrase = NULL;
699   unsigned char *key = NULL;
700   size_t keylen;
701   void *kek = NULL;
702   size_t keklen;
703   unsigned char *wrappedkey = NULL;
704   size_t wrappedkeylen;
705   gcry_cipher_hd_t cipherhd = NULL;
706   gcry_sexp_t s_key = NULL;
707   unsigned char grip[20];
708   int bad_pass = 0;
709   int i;
710   struct store_cert_parm_s store_cert_parm;
711
712   memset (&store_cert_parm, 0, sizeof store_cert_parm);
713   store_cert_parm.ctrl = ctrl;
714   store_cert_parm.stats = stats;
715
716   init_membuf (&p12mbuf, 4096);
717   ntotal = 0;
718   while (!(err = ksba_reader_read (reader, buffer, sizeof buffer, &nread)))
719     {
720       if (ntotal >= MAX_P12OBJ_SIZE*1024)
721         {
722           /* Arbitrary limit to avoid DoS attacks. */
723           err = gpg_error (GPG_ERR_TOO_LARGE);
724           log_error ("pkcs#12 object is larger than %dk\n", MAX_P12OBJ_SIZE);
725           break;
726         }
727       put_membuf (&p12mbuf, buffer, nread);
728       ntotal += nread;
729     }
730   if (gpg_err_code (err) == GPG_ERR_EOF)
731     err = 0;
732   if (!err)
733     {
734       p12buffer = get_membuf (&p12mbuf, &p12buflen);
735       if (!p12buffer)
736         err = gpg_error_from_syserror ();
737     }
738   if (err)
739     {
740       log_error (_("error reading input: %s\n"), gpg_strerror (err));
741       goto leave;
742     }
743
744   /* GnuPG 2.0.4 accidently created binary P12 files with the string
745      "The passphrase is %s encoded.\n\n" prepended to the ASN.1 data.
746      We fix that here.  */
747   if (p12buflen > 29 && !memcmp (p12buffer, "The passphrase is ", 18))
748     {
749       for (p12bufoff=18;
750            p12bufoff < p12buflen && p12buffer[p12bufoff] != '\n';
751            p12bufoff++)
752         ;
753       p12bufoff++;
754       if (p12bufoff < p12buflen && p12buffer[p12bufoff] == '\n')
755         p12bufoff++;
756     }
757   else
758     p12bufoff = 0;
759
760
761   err = gpgsm_agent_ask_passphrase
762     (ctrl, _("Please enter the passphrase to unprotect the PKCS#12 object."),
763      &passphrase);
764   if (err)
765     goto leave;
766
767   kparms = p12_parse (p12buffer + p12bufoff, p12buflen - p12bufoff,
768                       passphrase, store_cert_cb, &store_cert_parm, &bad_pass);
769
770   xfree (passphrase);
771   passphrase = NULL;
772
773   if (!kparms)
774     {
775       log_error ("error parsing or decrypting the PKCS#12 file\n");
776       err = gpg_error (GPG_ERR_INV_OBJ);
777       goto leave;
778     }
779
780 /*    print_mpi ("   n", kparms[0]); */
781 /*    print_mpi ("   e", kparms[1]); */
782 /*    print_mpi ("   d", kparms[2]); */
783 /*    print_mpi ("   p", kparms[3]); */
784 /*    print_mpi ("   q", kparms[4]); */
785 /*    print_mpi ("dmp1", kparms[5]); */
786 /*    print_mpi ("dmq1", kparms[6]); */
787 /*    print_mpi ("   u", kparms[7]); */
788
789   sk.n = kparms[0];
790   sk.e = kparms[1];
791   sk.d = kparms[2];
792   sk.q = kparms[3];
793   sk.p = kparms[4];
794   sk.u = kparms[7];
795   err = rsa_key_check (&sk);
796   if (err)
797     goto leave;
798 /*    print_mpi ("   n", sk.n); */
799 /*    print_mpi ("   e", sk.e); */
800 /*    print_mpi ("   d", sk.d); */
801 /*    print_mpi ("   p", sk.p); */
802 /*    print_mpi ("   q", sk.q); */
803 /*    print_mpi ("   u", sk.u); */
804   
805   /* Create an S-expresion from the parameters. */
806   err = gcry_sexp_build (&s_key, NULL,
807                          "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
808                          sk.n, sk.e, sk.d, sk.p, sk.q, sk.u, NULL);
809   for (i=0; i < 8; i++)
810     gcry_mpi_release (kparms[i]);
811   gcry_free (kparms);
812   kparms = NULL;
813   if (err)
814     {
815       log_error ("failed to created S-expression from key: %s\n",
816                  gpg_strerror (err));
817       goto leave;
818     }
819
820   /* Compute the keygrip. */
821   if (!gcry_pk_get_keygrip (s_key, grip))
822     {
823       err = gpg_error (GPG_ERR_GENERAL);
824       log_error ("can't calculate keygrip\n");
825       goto leave;
826     }
827   log_printhex ("keygrip=", grip, 20);
828
829   /* Convert to canonical encoding using a function which pads it to a
830      multiple of 64 bits.  We need this padding for AESWRAP.  */
831   err = make_canon_sexp_pad (s_key, &key, &keylen);
832   if (err)
833     {
834       log_error ("error creating canonical S-expression\n");
835       goto leave;
836     }
837   gcry_sexp_release (s_key);
838   s_key = NULL;
839
840   /* Get the current KEK.  */
841   err = gpgsm_agent_keywrap_key (ctrl, 0, &kek, &keklen);
842   if (err)
843     {
844       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
845       goto leave;
846     }
847
848   /* Wrap the key.  */
849   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
850                           GCRY_CIPHER_MODE_AESWRAP, 0);
851   if (err)
852     goto leave;
853   err = gcry_cipher_setkey (cipherhd, kek, keklen);
854   if (err)
855     goto leave;
856   xfree (kek);
857   kek = NULL;
858
859   wrappedkeylen = keylen + 8;
860   wrappedkey = xtrymalloc (wrappedkeylen);
861   if (!wrappedkey)
862     {
863       err = gpg_error_from_syserror ();
864       goto leave;
865     }
866
867   err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
868   if (err)
869     goto leave;
870   xfree (key);
871   key = NULL;
872   gcry_cipher_close (cipherhd);
873   cipherhd = NULL;
874
875   /* Send the wrapped key to the agent.  */
876   err = gpgsm_agent_import_key (ctrl, wrappedkey, wrappedkeylen);
877   if (!err)
878     {
879       stats->count++;
880       stats->secret_read++;
881       stats->secret_imported++;
882     }
883   else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
884     {
885       err = 0;
886       stats->count++;
887       stats->secret_read++;
888       stats->secret_dups++;
889     }
890
891   /* If we did not get an error from storing the secret key we return
892      a possible error from parsing the certificates.  We do this after
893      storing the secret keys so that a bad certificate does not
894      inhibit our chance to store the secret key.  */
895   if (!err && store_cert_parm.err)
896     err = store_cert_parm.err;
897
898  leave:
899   if (kparms)
900     {
901       for (i=0; i < 8; i++)
902         gcry_mpi_release (kparms[i]);
903       gcry_free (kparms);
904       kparms = NULL;
905     }
906   xfree (key);
907   gcry_sexp_release (s_key);
908   xfree (passphrase);
909   gcry_cipher_close (cipherhd);
910   xfree (wrappedkey);
911   xfree (kek);
912   xfree (get_membuf (&p12mbuf, NULL));
913   xfree (p12buffer);
914
915   if (bad_pass)
916     {
917       /* We only write a plain error code and not direct
918          BAD_PASSPHRASE because the pkcs12 parser might issue this
919          message multiple times, BAD_PASSPHRASE in general requires a
920          keyID and parts of the import might actually succeed so that
921          IMPORT_PROBLEM is also not appropriate. */
922       gpgsm_status_with_err_code (ctrl, STATUS_ERROR,
923                                   "import.parsep12", GPG_ERR_BAD_PASSPHRASE);
924     }
925   
926   return err;
927 }