gpg: Make import filter data object more flexible.
[gnupg.git] / g10 / import.c
1 /* import.c - import a key into our key storage.
2  * Copyright (C) 1998-2007, 2010-2011 Free Software Foundation, Inc.
3  * Copyright (C) 2014, 2016  Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "gpg.h"
28 #include "options.h"
29 #include "packet.h"
30 #include "status.h"
31 #include "keydb.h"
32 #include "util.h"
33 #include "trustdb.h"
34 #include "main.h"
35 #include "i18n.h"
36 #include "ttyio.h"
37 #include "status.h"
38 #include "recsel.h"
39 #include "keyserver-internal.h"
40 #include "call-agent.h"
41 #include "../common/membuf.h"
42 #include "../common/init.h"
43 #include "../common/mbox-util.h"
44
45
46 struct import_stats_s
47 {
48   ulong count;
49   ulong no_user_id;
50   ulong imported;
51   ulong n_uids;
52   ulong n_sigs;
53   ulong n_subk;
54   ulong unchanged;
55   ulong n_revoc;
56   ulong secret_read;
57   ulong secret_imported;
58   ulong secret_dups;
59   ulong skipped_new_keys;
60   ulong not_imported;
61   ulong n_sigs_cleaned;
62   ulong n_uids_cleaned;
63   ulong v3keys;   /* Number of V3 keys seen.  */
64 };
65
66
67 /* Node flag to indicate that a user ID or a subkey has a
68  * valid self-signature.  */
69 #define NODE_GOOD_SELFSIG  1
70 /* Node flag to indicate that a user ID or subkey has
71  * an invalid self-signature.  */
72 #define NODE_BAD_SELFSIG   2
73 /* Node flag to indicate that the node shall be deleted.  */
74 #define NODE_DELETION_MARK 4
75 /* A node flag used to temporary mark a node. */
76 #define NODE_FLAG_A  8
77
78
79 /* A an object and a global instance to store selectors created from
80  * --import-filter keep-uid=EXPR.
81  * --import-filter drop-sig=EXPR.
82  *
83  * FIXME: We should put this into the CTRL object but that requires a
84  * lot more changes right now.  For now we use save and restore
85  * fucntion to temporary change them.
86  */
87 /* Definition of the import filters.  */
88 struct import_filter_s
89 {
90   recsel_expr_t keep_uid;
91   recsel_expr_t drop_sig;
92 };
93 /* The current instance.  */
94 struct import_filter_s import_filter;
95
96
97 static int import (ctrl_t ctrl,
98                    IOBUF inp, const char* fname, struct import_stats_s *stats,
99                    unsigned char **fpr, size_t *fpr_len, unsigned int options,
100                    import_screener_t screener, void *screener_arg);
101 static int read_block (IOBUF a, PACKET **pending_pkt, kbnode_t *ret_root,
102                        int *r_v3keys);
103 static void revocation_present (ctrl_t ctrl, kbnode_t keyblock);
104 static int import_one (ctrl_t ctrl,
105                        kbnode_t keyblock,
106                        struct import_stats_s *stats,
107                        unsigned char **fpr, size_t *fpr_len,
108                        unsigned int options, int from_sk, int silent,
109                        import_screener_t screener, void *screener_arg);
110 static int import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
111                               struct import_stats_s *stats, int batch,
112                               unsigned int options, int for_migration,
113                               import_screener_t screener, void *screener_arg);
114 static int import_revoke_cert (kbnode_t node, struct import_stats_s *stats);
115 static int chk_self_sigs (kbnode_t keyblock, u32 *keyid, int *non_self);
116 static int delete_inv_parts (kbnode_t keyblock,
117                              u32 *keyid, unsigned int options);
118 static int merge_blocks (kbnode_t keyblock_orig,
119                          kbnode_t keyblock, u32 *keyid,
120                          int *n_uids, int *n_sigs, int *n_subk );
121 static int append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs);
122 static int append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs);
123 static int merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs);
124 static int merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs);
125
126
127 \f
128 static void
129 release_import_filter (import_filter_t filt)
130 {
131   recsel_release (filt->keep_uid);
132   filt->keep_uid = NULL;
133   recsel_release (filt->drop_sig);
134   filt->drop_sig = NULL;
135 }
136
137 static void
138 cleanup_import_globals (void)
139 {
140   release_import_filter (&import_filter);
141 }
142
143
144 int
145 parse_import_options(char *str,unsigned int *options,int noisy)
146 {
147   struct parse_options import_opts[]=
148     {
149       {"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
150        N_("import signatures that are marked as local-only")},
151
152       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
153        N_("repair damage from the pks keyserver during import")},
154
155       {"keep-ownertrust", IMPORT_KEEP_OWNERTTRUST, NULL,
156        N_("do not clear the ownertrust values during import")},
157
158       {"fast-import",IMPORT_FAST,NULL,
159        N_("do not update the trustdb after import")},
160
161       {"import-show",IMPORT_SHOW,NULL,
162        N_("show key during import")},
163
164       {"merge-only",IMPORT_MERGE_ONLY,NULL,
165        N_("only accept updates to existing keys")},
166
167       {"import-clean",IMPORT_CLEAN,NULL,
168        N_("remove unusable parts from key after import")},
169
170       {"import-minimal",IMPORT_MINIMAL|IMPORT_CLEAN,NULL,
171        N_("remove as much as possible from key after import")},
172
173       {"import-export", IMPORT_EXPORT, NULL,
174        N_("run import filters and export key immediately")},
175
176       /* Aliases for backward compatibility */
177       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
178       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
179       /* dummy */
180       {"import-unusable-sigs",0,NULL,NULL},
181       {"import-clean-sigs",0,NULL,NULL},
182       {"import-clean-uids",0,NULL,NULL},
183       {"convert-sk-to-pk",0, NULL,NULL}, /* Not anymore needed due to
184                                             the new design.  */
185       {NULL,0,NULL,NULL}
186     };
187
188   return parse_options(str,options,import_opts,noisy);
189 }
190
191
192 /* Parse and set an import filter from string.  STRING has the format
193  * "NAME=EXPR" with NAME being the name of the filter.  Spaces before
194  * and after NAME are not allowed.  If this function is all called
195  * several times all expressions for the same NAME are concatenated.
196  * Supported filter names are:
197  *
198  *  - keep-uid :: If the expression evaluates to true for a certain
199  *                user ID packet, that packet and all it dependencies
200  *                will be imported.  The expression may use these
201  *                variables:
202  *
203  *                - uid  :: The entire user ID.
204  *                - mbox :: The mail box part of the user ID.
205  *                - primary :: Evaluate to true for the primary user ID.
206  */
207 gpg_error_t
208 parse_and_set_import_filter (const char *string)
209 {
210   gpg_error_t err;
211
212   /* Auto register the cleanup function.  */
213   register_mem_cleanup_func (cleanup_import_globals);
214
215   if (!strncmp (string, "keep-uid=", 9))
216     err = recsel_parse_expr (&import_filter.keep_uid, string+9);
217   else if (!strncmp (string, "drop-sig=", 9))
218     err = recsel_parse_expr (&import_filter.drop_sig, string+9);
219   else
220     err = gpg_error (GPG_ERR_INV_NAME);
221
222   return err;
223 }
224
225
226 /* Save the current import filters, return them, and clear the current
227  * filters.  Returns NULL on error and sets ERRNO.  */
228 import_filter_t
229 save_and_clear_import_filter (void)
230 {
231   import_filter_t filt;
232
233   filt = xtrycalloc (1, sizeof *filt);
234   if (!filt)
235     return NULL;
236   *filt = import_filter;
237   memset (&import_filter, 0, sizeof import_filter);
238
239   return filt;
240 }
241
242
243 /* Release the current import filters and restore them from NEWFILT.
244  * Ownership of NEWFILT is moved to this function.  */
245 void
246 restore_import_filter (import_filter_t filt)
247 {
248   if (filt)
249     {
250       release_import_filter (&import_filter);
251       import_filter = *filt;
252       xfree (filt);
253     }
254 }
255
256
257 import_stats_t
258 import_new_stats_handle (void)
259 {
260   return xmalloc_clear ( sizeof (struct import_stats_s) );
261 }
262
263
264 void
265 import_release_stats_handle (import_stats_t p)
266 {
267   xfree (p);
268 }
269
270
271 /* Read a key from a file.  Only the first key in the file is
272  * considered and stored at R_KEYBLOCK.  FNAME is the name of the
273  * file.
274  */
275 gpg_error_t
276 read_key_from_file (ctrl_t ctrl, const char *fname, kbnode_t *r_keyblock)
277 {
278   gpg_error_t err;
279   iobuf_t inp;
280   PACKET *pending_pkt = NULL;
281   kbnode_t keyblock = NULL;
282   u32 keyid[2];
283   int v3keys;   /* Dummy */
284   int non_self; /* Dummy */
285
286   (void)ctrl;
287
288   *r_keyblock = NULL;
289
290   inp = iobuf_open (fname);
291   if (!inp)
292     err = gpg_error_from_syserror ();
293   else if (is_secured_file (iobuf_get_fd (inp)))
294     {
295       iobuf_close (inp);
296       inp = NULL;
297       err = gpg_error (GPG_ERR_EPERM);
298     }
299   else
300     err = 0;
301   if (err)
302     {
303       log_error (_("can't open '%s': %s\n"),
304                  iobuf_is_pipe_filename (fname)? "[stdin]": fname,
305                  gpg_strerror (err));
306       if (gpg_err_code (err) == GPG_ERR_ENOENT)
307         err = gpg_error (GPG_ERR_NO_PUBKEY);
308       goto leave;
309     }
310
311   /* Push the armor filter.  */
312   {
313     armor_filter_context_t *afx;
314     afx = new_armor_context ();
315     afx->only_keyblocks = 1;
316     push_armor_filter (afx, inp);
317     release_armor_context (afx);
318   }
319
320   /* Read the first non-v3 keyblock.  */
321   while (!(err = read_block (inp, &pending_pkt, &keyblock, &v3keys)))
322     {
323       if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
324         break;
325       log_info (_("skipping block of type %d\n"), keyblock->pkt->pkttype);
326       release_kbnode (keyblock);
327       keyblock = NULL;
328     }
329   if (err)
330     {
331       if (gpg_err_code (err) != GPG_ERR_INV_KEYRING)
332         log_error (_("error reading '%s': %s\n"),
333                    iobuf_is_pipe_filename (fname)? "[stdin]": fname,
334                    gpg_strerror (err));
335       goto leave;
336     }
337
338   keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);
339
340   if (!find_next_kbnode (keyblock, PKT_USER_ID))
341     {
342       err = gpg_error (GPG_ERR_NO_USER_ID);
343       goto leave;
344     }
345
346   collapse_uids (&keyblock);
347
348   clear_kbnode_flags (keyblock);
349   if (chk_self_sigs (keyblock, keyid, &non_self))
350     {
351       err = gpg_error (GPG_ERR_INV_KEYRING);
352       goto leave;
353     }
354
355   if (!delete_inv_parts (keyblock, keyid, 0) )
356     {
357       err = gpg_error (GPG_ERR_NO_USER_ID);
358       goto leave;
359     }
360
361   *r_keyblock = keyblock;
362   keyblock = NULL;
363
364  leave:
365   if (inp)
366     {
367       iobuf_close (inp);
368       /* Must invalidate that ugly cache to actually close the file. */
369       iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
370     }
371   release_kbnode (keyblock);
372   /* FIXME: Do we need to free PENDING_PKT ? */
373   return err;
374 }
375
376
377
378 /*
379  * Import the public keys from the given filename. Input may be armored.
380  * This function rejects all keys which are not validly self signed on at
381  * least one userid. Only user ids which are self signed will be imported.
382  * Other signatures are not checked.
383  *
384  * Actually this function does a merge. It works like this:
385  *
386  *  - get the keyblock
387  *  - check self-signatures and remove all userids and their signatures
388  *    without/invalid self-signatures.
389  *  - reject the keyblock, if we have no valid userid.
390  *  - See whether we have this key already in one of our pubrings.
391  *    If not, simply add it to the default keyring.
392  *  - Compare the key and the self-signatures of the new and the one in
393  *    our keyring.  If they are different something weird is going on;
394  *    ask what to do.
395  *  - See whether we have only non-self-signature on one user id; if not
396  *    ask the user what to do.
397  *  - compare the signatures: If we already have this signature, check
398  *    that they compare okay; if not, issue a warning and ask the user.
399  *    (consider looking at the timestamp and use the newest?)
400  *  - Simply add the signature.  Can't verify here because we may not have
401  *    the signature's public key yet; verification is done when putting it
402  *    into the trustdb, which is done automagically as soon as this pubkey
403  *    is used.
404  *  - Proceed with next signature.
405  *
406  *  Key revocation certificates have special handling.
407  */
408 static int
409 import_keys_internal (ctrl_t ctrl, iobuf_t inp, char **fnames, int nnames,
410                       import_stats_t stats_handle,
411                       unsigned char **fpr, size_t *fpr_len,
412                       unsigned int options,
413                       import_screener_t screener, void *screener_arg)
414 {
415   int i;
416   int rc = 0;
417   struct import_stats_s *stats = stats_handle;
418
419   if (!stats)
420     stats = import_new_stats_handle ();
421
422   if (inp)
423     {
424       rc = import (ctrl, inp, "[stream]", stats, fpr, fpr_len, options,
425                    screener, screener_arg);
426     }
427   else
428     {
429       if (!fnames && !nnames)
430         nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
431
432       for (i=0; i < nnames; i++)
433         {
434           const char *fname = fnames? fnames[i] : NULL;
435           IOBUF inp2 = iobuf_open(fname);
436
437           if (!fname)
438             fname = "[stdin]";
439           if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
440             {
441               iobuf_close (inp2);
442               inp2 = NULL;
443               gpg_err_set_errno (EPERM);
444             }
445           if (!inp2)
446             log_error (_("can't open '%s': %s\n"), fname, strerror (errno));
447           else
448             {
449               rc = import (ctrl, inp2, fname, stats, fpr, fpr_len, options,
450                            screener, screener_arg);
451               iobuf_close (inp2);
452               /* Must invalidate that ugly cache to actually close it. */
453               iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
454               if (rc)
455                 log_error ("import from '%s' failed: %s\n",
456                            fname, gpg_strerror (rc) );
457             }
458           if (!fname)
459             break;
460         }
461     }
462
463   if (!stats_handle)
464     {
465       import_print_stats (stats);
466       import_release_stats_handle (stats);
467     }
468
469   /* If no fast import and the trustdb is dirty (i.e. we added a key
470      or userID that had something other than a selfsig, a signature
471      that was other than a selfsig, or any revocation), then
472      update/check the trustdb if the user specified by setting
473      interactive or by not setting no-auto-check-trustdb */
474
475   if (!(options & IMPORT_FAST))
476     check_or_update_trustdb (ctrl);
477
478   return rc;
479 }
480
481
482 void
483 import_keys (ctrl_t ctrl, char **fnames, int nnames,
484              import_stats_t stats_handle, unsigned int options )
485 {
486   import_keys_internal (ctrl, NULL, fnames, nnames, stats_handle,
487                         NULL, NULL, options, NULL, NULL);
488 }
489
490 int
491 import_keys_stream (ctrl_t ctrl, IOBUF inp, import_stats_t stats_handle,
492                     unsigned char **fpr, size_t *fpr_len, unsigned int options)
493 {
494   return import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
495                                fpr, fpr_len, options, NULL, NULL);
496 }
497
498
499 /* Variant of import_keys_stream reading from an estream_t.  */
500 int
501 import_keys_es_stream (ctrl_t ctrl, estream_t fp,
502                        import_stats_t stats_handle,
503                        unsigned char **fpr, size_t *fpr_len,
504                        unsigned int options,
505                        import_screener_t screener, void *screener_arg)
506 {
507   int rc;
508   iobuf_t inp;
509
510   inp = iobuf_esopen (fp, "rb", 1);
511   if (!inp)
512     {
513       rc = gpg_error_from_syserror ();
514       log_error ("iobuf_esopen failed: %s\n", gpg_strerror (rc));
515       return rc;
516     }
517
518   rc = import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
519                              fpr, fpr_len, options,
520                              screener, screener_arg);
521
522   iobuf_close (inp);
523   return rc;
524 }
525
526
527 static int
528 import (ctrl_t ctrl, IOBUF inp, const char* fname,struct import_stats_s *stats,
529         unsigned char **fpr,size_t *fpr_len, unsigned int options,
530         import_screener_t screener, void *screener_arg)
531 {
532   PACKET *pending_pkt = NULL;
533   kbnode_t keyblock = NULL;  /* Need to initialize because gcc can't
534                                 grasp the return semantics of
535                                 read_block. */
536   int rc = 0;
537   int v3keys;
538
539   getkey_disable_caches ();
540
541   if (!opt.no_armor) /* Armored reading is not disabled.  */
542     {
543       armor_filter_context_t *afx;
544
545       afx = new_armor_context ();
546       afx->only_keyblocks = 1;
547       push_armor_filter (afx, inp);
548       release_armor_context (afx);
549     }
550
551   while (!(rc = read_block (inp, &pending_pkt, &keyblock, &v3keys)))
552     {
553       stats->v3keys += v3keys;
554       if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY)
555         rc = import_one (ctrl, keyblock,
556                          stats, fpr, fpr_len, options, 0, 0,
557                          screener, screener_arg);
558       else if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
559         rc = import_secret_one (ctrl, keyblock, stats,
560                                 opt.batch, options, 0,
561                                 screener, screener_arg);
562       else if (keyblock->pkt->pkttype == PKT_SIGNATURE
563                && keyblock->pkt->pkt.signature->sig_class == 0x20 )
564         rc = import_revoke_cert (keyblock, stats);
565       else
566         {
567           log_info (_("skipping block of type %d\n"), keyblock->pkt->pkttype);
568         }
569       release_kbnode (keyblock);
570
571       /* fixme: we should increment the not imported counter but
572          this does only make sense if we keep on going despite of
573          errors.  For now we do this only if the imported key is too
574          large. */
575       if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
576             && gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
577         {
578           stats->not_imported++;
579         }
580       else if (rc)
581         break;
582
583       if (!(++stats->count % 100) && !opt.quiet)
584         log_info (_("%lu keys processed so far\n"), stats->count );
585     }
586   stats->v3keys += v3keys;
587   if (rc == -1)
588     rc = 0;
589   else if (rc && gpg_err_code (rc) != GPG_ERR_INV_KEYRING)
590     log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (rc));
591
592   return rc;
593 }
594
595
596 /* Helper to migrate secring.gpg to GnuPG 2.1.  */
597 gpg_error_t
598 import_old_secring (ctrl_t ctrl, const char *fname)
599 {
600   gpg_error_t err;
601   iobuf_t inp;
602   PACKET *pending_pkt = NULL;
603   kbnode_t keyblock = NULL;  /* Need to initialize because gcc can't
604                                 grasp the return semantics of
605                                 read_block. */
606   struct import_stats_s *stats;
607   int v3keys;
608
609   inp = iobuf_open (fname);
610   if (inp && is_secured_file (iobuf_get_fd (inp)))
611     {
612       iobuf_close (inp);
613       inp = NULL;
614       gpg_err_set_errno (EPERM);
615     }
616   if (!inp)
617     {
618       err = gpg_error_from_syserror ();
619       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
620       return err;
621     }
622
623   getkey_disable_caches();
624   stats = import_new_stats_handle ();
625   while (!(err = read_block (inp, &pending_pkt, &keyblock, &v3keys)))
626     {
627       if (keyblock->pkt->pkttype == PKT_SECRET_KEY)
628         err = import_secret_one (ctrl, keyblock, stats, 1, 0, 1,
629                                  NULL, NULL);
630       release_kbnode (keyblock);
631       if (err)
632         break;
633     }
634   import_release_stats_handle (stats);
635   if (err == -1)
636     err = 0;
637   else if (err && gpg_err_code (err) != GPG_ERR_INV_KEYRING)
638     log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
639   else if (err)
640     log_error ("import from '%s' failed: %s\n", fname, gpg_strerror (err));
641
642   iobuf_close (inp);
643   iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
644
645   return err;
646 }
647
648
649 void
650 import_print_stats (import_stats_t stats)
651 {
652   if (!opt.quiet)
653     {
654       log_info(_("Total number processed: %lu\n"),
655                stats->count + stats->v3keys);
656       if (stats->v3keys)
657         log_info(_("    skipped PGP-2 keys: %lu\n"), stats->v3keys);
658       if (stats->skipped_new_keys )
659         log_info(_("      skipped new keys: %lu\n"),
660                  stats->skipped_new_keys );
661       if (stats->no_user_id )
662         log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
663       if (stats->imported)
664         {
665           log_info(_("              imported: %lu"), stats->imported );
666           log_printf ("\n");
667         }
668       if (stats->unchanged )
669         log_info(_("             unchanged: %lu\n"), stats->unchanged );
670       if (stats->n_uids )
671         log_info(_("          new user IDs: %lu\n"), stats->n_uids );
672       if (stats->n_subk )
673         log_info(_("           new subkeys: %lu\n"), stats->n_subk );
674       if (stats->n_sigs )
675         log_info(_("        new signatures: %lu\n"), stats->n_sigs );
676       if (stats->n_revoc )
677         log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
678       if (stats->secret_read )
679         log_info(_("      secret keys read: %lu\n"), stats->secret_read );
680       if (stats->secret_imported )
681         log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
682       if (stats->secret_dups )
683         log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
684       if (stats->not_imported )
685         log_info(_("          not imported: %lu\n"), stats->not_imported );
686       if (stats->n_sigs_cleaned)
687         log_info(_("    signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
688       if (stats->n_uids_cleaned)
689         log_info(_("      user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
690     }
691
692   if (is_status_enabled ())
693     {
694       char buf[15*20];
695
696       snprintf (buf, sizeof buf,
697                 "%lu %lu %lu 0 %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
698                 stats->count + stats->v3keys,
699                 stats->no_user_id,
700                 stats->imported,
701                 stats->unchanged,
702                 stats->n_uids,
703                 stats->n_subk,
704                 stats->n_sigs,
705                 stats->n_revoc,
706                 stats->secret_read,
707                 stats->secret_imported,
708                 stats->secret_dups,
709                 stats->skipped_new_keys,
710                 stats->not_imported,
711                 stats->v3keys );
712       write_status_text (STATUS_IMPORT_RES, buf);
713     }
714 }
715
716
717 /* Return true if PKTTYPE is valid in a keyblock.  */
718 static int
719 valid_keyblock_packet (int pkttype)
720 {
721   switch (pkttype)
722     {
723     case PKT_PUBLIC_KEY:
724     case PKT_PUBLIC_SUBKEY:
725     case PKT_SECRET_KEY:
726     case PKT_SECRET_SUBKEY:
727     case PKT_SIGNATURE:
728     case PKT_USER_ID:
729     case PKT_ATTRIBUTE:
730     case PKT_RING_TRUST:
731       return 1;
732     default:
733       return 0;
734     }
735 }
736
737
738 /****************
739  * Read the next keyblock from stream A.
740  * PENDING_PKT should be initialzed to NULL
741  * and not changed by the caller.
742  * Return: 0 = okay, -1 no more blocks or another errorcode.
743  *         The int at at R_V3KEY counts the number of unsupported v3
744  *         keyblocks.
745  */
746 static int
747 read_block( IOBUF a, PACKET **pending_pkt, kbnode_t *ret_root, int *r_v3keys)
748 {
749   int rc;
750   PACKET *pkt;
751   kbnode_t root = NULL;
752   int in_cert, in_v3key;
753
754   *r_v3keys = 0;
755
756   if (*pending_pkt)
757     {
758       root = new_kbnode( *pending_pkt );
759       *pending_pkt = NULL;
760       in_cert = 1;
761     }
762   else
763     in_cert = 0;
764
765   pkt = xmalloc (sizeof *pkt);
766   init_packet (pkt);
767   in_v3key = 0;
768   while ((rc=parse_packet(a, pkt)) != -1)
769     {
770       if (rc && (gpg_err_code (rc) == GPG_ERR_LEGACY_KEY
771                  && (pkt->pkttype == PKT_PUBLIC_KEY
772                      || pkt->pkttype == PKT_SECRET_KEY)))
773         {
774           in_v3key = 1;
775           ++*r_v3keys;
776           free_packet (pkt);
777           init_packet (pkt);
778           continue;
779         }
780       else if (rc ) /* (ignore errors) */
781         {
782           if (gpg_err_code (rc) == GPG_ERR_UNKNOWN_PACKET)
783             ; /* Do not show a diagnostic.  */
784           else
785             {
786               log_error("read_block: read error: %s\n", gpg_strerror (rc) );
787               rc = GPG_ERR_INV_KEYRING;
788               goto ready;
789             }
790           free_packet( pkt );
791           init_packet(pkt);
792           continue;
793         }
794
795         if (in_v3key && !(pkt->pkttype == PKT_PUBLIC_KEY
796                           || pkt->pkttype == PKT_SECRET_KEY))
797           {
798             free_packet( pkt );
799             init_packet(pkt);
800             continue;
801           }
802         in_v3key = 0;
803
804         if (!root && pkt->pkttype == PKT_SIGNATURE
805                   && pkt->pkt.signature->sig_class == 0x20 )
806           {
807             /* This is a revocation certificate which is handled in a
808              * special way.  */
809             root = new_kbnode( pkt );
810             pkt = NULL;
811             goto ready;
812           }
813
814         /* Make a linked list of all packets.  */
815         switch (pkt->pkttype)
816           {
817           case PKT_COMPRESSED:
818             if (check_compress_algo (pkt->pkt.compressed->algorithm))
819               {
820                 rc = GPG_ERR_COMPR_ALGO;
821                 goto ready;
822               }
823             else
824               {
825                 compress_filter_context_t *cfx = xmalloc_clear( sizeof *cfx );
826                 pkt->pkt.compressed->buf = NULL;
827                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
828               }
829             free_packet( pkt );
830             init_packet(pkt);
831             break;
832
833           case PKT_RING_TRUST:
834             /* Skip those packets.  */
835             free_packet( pkt );
836             init_packet(pkt);
837             break;
838
839           case PKT_PUBLIC_KEY:
840           case PKT_SECRET_KEY:
841             if (in_cert ) /* Store this packet.  */
842               {
843                 *pending_pkt = pkt;
844                 pkt = NULL;
845                 goto ready;
846               }
847             in_cert = 1;
848           default:
849             if (in_cert && valid_keyblock_packet (pkt->pkttype))
850               {
851                 if (!root )
852                   root = new_kbnode (pkt);
853                 else
854                   add_kbnode (root, new_kbnode (pkt));
855                 pkt = xmalloc (sizeof *pkt);
856               }
857             init_packet(pkt);
858             break;
859           }
860     }
861
862  ready:
863   if (rc == -1 && root )
864     rc = 0;
865
866   if (rc )
867     release_kbnode( root );
868   else
869     *ret_root = root;
870   free_packet( pkt );
871   xfree( pkt );
872   return rc;
873 }
874
875
876 /* Walk through the subkeys on a pk to find if we have the PKS
877    disease: multiple subkeys with their binding sigs stripped, and the
878    sig for the first subkey placed after the last subkey.  That is,
879    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
880    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
881    and sub3, as they are already lost, but we can try and rescue sub1
882    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
883    sub2 sub3".  Returns TRUE if the keyblock was modified. */
884 static int
885 fix_pks_corruption (kbnode_t keyblock)
886 {
887   int changed = 0;
888   int keycount = 0;
889   kbnode_t node;
890   kbnode_t last = NULL;
891   kbnode_t sknode=NULL;
892
893   /* First determine if we have the problem at all.  Look for 2 or
894      more subkeys in a row, followed by a single binding sig. */
895   for (node=keyblock; node; last=node, node=node->next)
896     {
897       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
898         {
899           keycount++;
900           if(!sknode)
901             sknode=node;
902         }
903       else if (node->pkt->pkttype == PKT_SIGNATURE
904                && node->pkt->pkt.signature->sig_class == 0x18
905                && keycount >= 2
906                && !node->next)
907         {
908           /* We might have the problem, as this key has two subkeys in
909              a row without any intervening packets. */
910
911           /* Sanity check */
912           if (!last)
913             break;
914
915           /* Temporarily attach node to sknode. */
916           node->next = sknode->next;
917           sknode->next = node;
918           last->next = NULL;
919
920           /* Note we aren't checking whether this binding sig is a
921              selfsig.  This is not necessary here as the subkey and
922              binding sig will be rejected later if that is the
923              case. */
924           if (check_key_signature (keyblock,node,NULL))
925             {
926               /* Not a match, so undo the changes. */
927               sknode->next = node->next;
928               last->next = node;
929               node->next = NULL;
930               break;
931             }
932           else
933             {
934               /* Mark it good so we don't need to check it again */
935               sknode->flag |= NODE_GOOD_SELFSIG;
936               changed = 1;
937               break;
938             }
939         }
940       else
941         keycount = 0;
942     }
943
944   return changed;
945 }
946
947
948 /* Versions of GnuPG before 1.4.11 and 2.0.16 allowed to import bogus
949    direct key signatures.  A side effect of this was that a later
950    import of the same good direct key signatures was not possible
951    because the cmp_signature check in merge_blocks considered them
952    equal.  Although direct key signatures are now checked during
953    import, there might still be bogus signatures sitting in a keyring.
954    We need to detect and delete them before doing a merge.  This
955    function returns the number of removed sigs.  */
956 static int
957 fix_bad_direct_key_sigs (kbnode_t keyblock, u32 *keyid)
958 {
959   gpg_error_t err;
960   kbnode_t node;
961   int count = 0;
962
963   for (node = keyblock->next; node; node=node->next)
964     {
965       if (node->pkt->pkttype == PKT_USER_ID)
966         break;
967       if (node->pkt->pkttype == PKT_SIGNATURE
968           && IS_KEY_SIG (node->pkt->pkt.signature))
969         {
970           err = check_key_signature (keyblock, node, NULL);
971           if (err && gpg_err_code (err) != GPG_ERR_PUBKEY_ALGO )
972             {
973               /* If we don't know the error, we can't decide; this is
974                  not a problem because cmp_signature can't compare the
975                  signature either.  */
976               log_info ("key %s: invalid direct key signature removed\n",
977                         keystr (keyid));
978               delete_kbnode (node);
979               count++;
980             }
981         }
982     }
983
984   return count;
985 }
986
987
988 static void
989 print_import_ok (PKT_public_key *pk, unsigned int reason)
990 {
991   byte array[MAX_FINGERPRINT_LEN], *s;
992   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
993   size_t i, n;
994
995   snprintf (buf, sizeof buf, "%u ", reason);
996   p = buf + strlen (buf);
997
998   fingerprint_from_pk (pk, array, &n);
999   s = array;
1000   for (i=0; i < n ; i++, s++, p += 2)
1001     sprintf (p, "%02X", *s);
1002
1003   write_status_text (STATUS_IMPORT_OK, buf);
1004 }
1005
1006
1007 static void
1008 print_import_check (PKT_public_key * pk, PKT_user_id * id)
1009 {
1010   char * buf;
1011   byte fpr[24];
1012   u32 keyid[2];
1013   size_t i, n;
1014   size_t pos = 0;
1015
1016   buf = xmalloc (17+41+id->len+32);
1017   keyid_from_pk (pk, keyid);
1018   sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
1019   pos = 17;
1020   fingerprint_from_pk (pk, fpr, &n);
1021   for (i = 0; i < n; i++, pos += 2)
1022     sprintf (buf+pos, "%02X", fpr[i]);
1023   strcat (buf, " ");
1024   strcat (buf, id->name);
1025   write_status_text (STATUS_IMPORT_CHECK, buf);
1026   xfree (buf);
1027 }
1028
1029
1030 static void
1031 check_prefs_warning(PKT_public_key *pk)
1032 {
1033   log_info(_("WARNING: key %s contains preferences for unavailable\n"
1034              "algorithms on these user IDs:\n"), keystr_from_pk(pk));
1035 }
1036
1037
1038 static void
1039 check_prefs (ctrl_t ctrl, kbnode_t keyblock)
1040 {
1041   kbnode_t node;
1042   PKT_public_key *pk;
1043   int problem=0;
1044
1045   merge_keys_and_selfsig(keyblock);
1046   pk=keyblock->pkt->pkt.public_key;
1047
1048   for(node=keyblock;node;node=node->next)
1049     {
1050       if(node->pkt->pkttype==PKT_USER_ID
1051          && node->pkt->pkt.user_id->created
1052          && node->pkt->pkt.user_id->prefs)
1053         {
1054           PKT_user_id *uid = node->pkt->pkt.user_id;
1055           prefitem_t *prefs = uid->prefs;
1056           char *user = utf8_to_native(uid->name,strlen(uid->name),0);
1057
1058           for(;prefs->type;prefs++)
1059             {
1060               char num[10]; /* prefs->value is a byte, so we're over
1061                                safe here */
1062
1063               sprintf(num,"%u",prefs->value);
1064
1065               if(prefs->type==PREFTYPE_SYM)
1066                 {
1067                   if (openpgp_cipher_test_algo (prefs->value))
1068                     {
1069                       const char *algo =
1070                         (openpgp_cipher_test_algo (prefs->value)
1071                          ? num
1072                          : openpgp_cipher_algo_name (prefs->value));
1073                       if(!problem)
1074                         check_prefs_warning(pk);
1075                       log_info(_("         \"%s\": preference for cipher"
1076                                  " algorithm %s\n"), user, algo);
1077                       problem=1;
1078                     }
1079                 }
1080               else if(prefs->type==PREFTYPE_HASH)
1081                 {
1082                   if(openpgp_md_test_algo(prefs->value))
1083                     {
1084                       const char *algo =
1085                         (gcry_md_test_algo (prefs->value)
1086                          ? num
1087                          : gcry_md_algo_name (prefs->value));
1088                       if(!problem)
1089                         check_prefs_warning(pk);
1090                       log_info(_("         \"%s\": preference for digest"
1091                                  " algorithm %s\n"), user, algo);
1092                       problem=1;
1093                     }
1094                 }
1095               else if(prefs->type==PREFTYPE_ZIP)
1096                 {
1097                   if(check_compress_algo (prefs->value))
1098                     {
1099                       const char *algo=compress_algo_to_string(prefs->value);
1100                       if(!problem)
1101                         check_prefs_warning(pk);
1102                       log_info(_("         \"%s\": preference for compression"
1103                                  " algorithm %s\n"),user,algo?algo:num);
1104                       problem=1;
1105                     }
1106                 }
1107             }
1108
1109           xfree(user);
1110         }
1111     }
1112
1113   if(problem)
1114     {
1115       log_info(_("it is strongly suggested that you update"
1116                  " your preferences and\n"));
1117       log_info(_("re-distribute this key to avoid potential algorithm"
1118                  " mismatch problems\n"));
1119
1120       if(!opt.batch)
1121         {
1122           strlist_t sl = NULL;
1123           strlist_t locusr = NULL;
1124           size_t fprlen=0;
1125           byte fpr[MAX_FINGERPRINT_LEN], *p;
1126           char username[(MAX_FINGERPRINT_LEN*2)+1];
1127           unsigned int i;
1128
1129           p = fingerprint_from_pk (pk,fpr,&fprlen);
1130           for(i=0;i<fprlen;i++,p++)
1131             sprintf(username+2*i,"%02X",*p);
1132           add_to_strlist(&locusr,username);
1133
1134           append_to_strlist(&sl,"updpref");
1135           append_to_strlist(&sl,"save");
1136
1137           keyedit_menu (ctrl, username, locusr, sl, 1, 1 );
1138           free_strlist(sl);
1139           free_strlist(locusr);
1140         }
1141       else if(!opt.quiet)
1142         log_info(_("you can update your preferences with:"
1143                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
1144     }
1145 }
1146
1147
1148 /* Helper for apply_*_filter in im,port.c and export.c.  */
1149 const char *
1150 impex_filter_getval (void *cookie, const char *propname)
1151 {
1152   /* FIXME: Malloc our static buffers and access them via the cookie.  */
1153   kbnode_t node = cookie;
1154   static char numbuf[20];
1155   const char *result;
1156
1157   if (node->pkt->pkttype == PKT_USER_ID)
1158     {
1159       if (!strcmp (propname, "uid"))
1160         result = node->pkt->pkt.user_id->name;
1161       else if (!strcmp (propname, "mbox"))
1162         {
1163           if (!node->pkt->pkt.user_id->mbox)
1164             {
1165               node->pkt->pkt.user_id->mbox
1166                 = mailbox_from_userid (node->pkt->pkt.user_id->name);
1167             }
1168           result = node->pkt->pkt.user_id->mbox;
1169         }
1170       else if (!strcmp (propname, "primary"))
1171         result = node->pkt->pkt.user_id->is_primary? "1":"0";
1172       else
1173         result = NULL;
1174     }
1175   else if (node->pkt->pkttype == PKT_SIGNATURE
1176            || node->pkt->pkttype == PKT_ATTRIBUTE)
1177     {
1178       PKT_signature *sig = node->pkt->pkt.signature;
1179
1180       if (!strcmp (propname, "sig_created"))
1181         {
1182           snprintf (numbuf, sizeof numbuf, "%lu", (ulong)sig->timestamp);
1183           result = numbuf;
1184         }
1185       else if (!strcmp (propname, "sig_created_d"))
1186         {
1187           result = datestr_from_sig (sig);
1188         }
1189       else if (!strcmp (propname, "sig_algo"))
1190         {
1191           snprintf (numbuf, sizeof numbuf, "%d", sig->pubkey_algo);
1192           result = numbuf;
1193         }
1194       else if (!strcmp (propname, "sig_digest_algo"))
1195         {
1196           snprintf (numbuf, sizeof numbuf, "%d", sig->digest_algo);
1197           result = numbuf;
1198         }
1199       else
1200         result = NULL;
1201     }
1202   else if (node->pkt->pkttype == PKT_PUBLIC_KEY
1203            || node->pkt->pkttype == PKT_SECRET_KEY
1204            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1205            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1206     {
1207       PKT_public_key *pk = node->pkt->pkt.public_key;
1208
1209       if (!strcmp (propname, "secret"))
1210         {
1211           result = (node->pkt->pkttype == PKT_SECRET_KEY
1212                     || node->pkt->pkttype == PKT_SECRET_SUBKEY)? "1":"0";
1213         }
1214       else if (!strcmp (propname, "key_algo"))
1215         {
1216           snprintf (numbuf, sizeof numbuf, "%d", pk->pubkey_algo);
1217           result = numbuf;
1218         }
1219       if (!strcmp (propname, "key_created"))
1220         {
1221           snprintf (numbuf, sizeof numbuf, "%lu", (ulong)pk->timestamp);
1222           result = numbuf;
1223         }
1224       else if (!strcmp (propname, "key_created_d"))
1225         {
1226           result = datestr_from_pk (pk);
1227         }
1228       else
1229         result = NULL;
1230     }
1231   else
1232     result = NULL;
1233
1234   return result;
1235 }
1236
1237
1238 /*
1239  * Apply the keep-uid filter to the keyblock.  The deleted nodes are
1240  * marked and thus the caller should call commit_kbnode afterwards.
1241  * KEYBLOCK must not have any blocks marked as deleted.
1242  */
1243 static void
1244 apply_keep_uid_filter (kbnode_t keyblock, recsel_expr_t selector)
1245 {
1246   kbnode_t node;
1247
1248   for (node = keyblock->next; node; node = node->next )
1249     {
1250       if (node->pkt->pkttype == PKT_USER_ID)
1251         {
1252           if (!recsel_select (selector, impex_filter_getval, node))
1253             {
1254
1255               /* log_debug ("keep-uid: deleting '%s'\n", */
1256               /*            node->pkt->pkt.user_id->name); */
1257               /* The UID packet and all following packets up to the
1258                * next UID or a subkey.  */
1259               delete_kbnode (node);
1260               for (; node->next
1261                      && node->next->pkt->pkttype != PKT_USER_ID
1262                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1263                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
1264                    node = node->next)
1265                 delete_kbnode (node->next);
1266             }
1267           /* else */
1268           /*   log_debug ("keep-uid: keeping '%s'\n", */
1269           /*              node->pkt->pkt.user_id->name); */
1270         }
1271     }
1272 }
1273
1274
1275 /*
1276  * Apply the drop-sig filter to the keyblock.  The deleted nodes are
1277  * marked and thus the caller should call commit_kbnode afterwards.
1278  * KEYBLOCK must not have any blocks marked as deleted.
1279  */
1280 static void
1281 apply_drop_sig_filter (kbnode_t keyblock, recsel_expr_t selector)
1282 {
1283   kbnode_t node;
1284   int active = 0;
1285   u32 main_keyid[2];
1286   PKT_signature *sig;
1287
1288   keyid_from_pk (keyblock->pkt->pkt.public_key, main_keyid);
1289
1290   /* Loop over all signatures for user id and attribute packets which
1291    * are not self signatures.  */
1292   for (node = keyblock->next; node; node = node->next )
1293     {
1294       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1295           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1296         break; /* ready.  */
1297       if (node->pkt->pkttype == PKT_USER_ID)
1298         active = 1;
1299       if (!active)
1300         continue;
1301       if (node->pkt->pkttype != PKT_SIGNATURE
1302           && node->pkt->pkttype != PKT_ATTRIBUTE)
1303         continue;
1304
1305       sig = node->pkt->pkt.signature;
1306       if (main_keyid[0] == sig->keyid[0] || main_keyid[1] == sig->keyid[1])
1307         continue;  /* Skip self-signatures.  */
1308
1309       if (IS_UID_SIG(sig) || IS_UID_REV(sig))
1310         {
1311           if (recsel_select (selector, impex_filter_getval, node))
1312             delete_kbnode (node);
1313         }
1314     }
1315 }
1316
1317
1318 /*
1319  * Try to import one keyblock. Return an error only in serious cases,
1320  * but never for an invalid keyblock.  It uses log_error to increase
1321  * the internal errorcount, so that invalid input can be detected by
1322  * programs which called gpg.  If SILENT is no messages are printed -
1323  * even most error messages are suppressed.
1324  */
1325 static int
1326 import_one (ctrl_t ctrl,
1327             kbnode_t keyblock, struct import_stats_s *stats,
1328             unsigned char **fpr, size_t *fpr_len, unsigned int options,
1329             int from_sk, int silent,
1330             import_screener_t screener, void *screener_arg)
1331 {
1332   PKT_public_key *pk;
1333   PKT_public_key *pk_orig = NULL;
1334   kbnode_t node, uidnode;
1335   kbnode_t keyblock_orig = NULL;
1336   byte fpr2[MAX_FINGERPRINT_LEN];
1337   size_t fpr2len;
1338   u32 keyid[2];
1339   int rc = 0;
1340   int new_key = 0;
1341   int mod_key = 0;
1342   int same_key = 0;
1343   int non_self = 0;
1344   size_t an;
1345   char pkstrbuf[PUBKEY_STRING_SIZE];
1346   int merge_keys_done = 0;
1347
1348   /* Get the key and print some info about it. */
1349   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1350   if (!node )
1351     BUG();
1352
1353   pk = node->pkt->pkt.public_key;
1354
1355   fingerprint_from_pk (pk, fpr2, &fpr2len);
1356   for (an = fpr2len; an < MAX_FINGERPRINT_LEN; an++)
1357     fpr2[an] = 0;
1358   keyid_from_pk( pk, keyid );
1359   uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1360
1361   if (opt.verbose && !opt.interactive && !silent)
1362     {
1363       log_info( "pub  %s/%s %s  ",
1364                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
1365                 keystr_from_pk(pk), datestr_from_pk(pk) );
1366       if (uidnode)
1367         print_utf8_buffer (log_get_stream (),
1368                            uidnode->pkt->pkt.user_id->name,
1369                            uidnode->pkt->pkt.user_id->len );
1370       log_printf ("\n");
1371     }
1372
1373
1374   if (!uidnode )
1375     {
1376       if (!silent)
1377         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
1378       return 0;
1379     }
1380
1381   if (screener && screener (keyblock, screener_arg))
1382     {
1383       log_error (_("key %s: %s\n"), keystr_from_pk (pk),
1384                  _("rejected by import screener"));
1385       return 0;
1386     }
1387
1388   if (opt.interactive && !silent)
1389     {
1390       if (is_status_enabled())
1391         print_import_check (pk, uidnode->pkt->pkt.user_id);
1392       merge_keys_and_selfsig (keyblock);
1393       tty_printf ("\n");
1394       show_basic_key_info (keyblock);
1395       tty_printf ("\n");
1396       if (!cpr_get_answer_is_yes ("import.okay",
1397                                   "Do you want to import this key? (y/N) "))
1398         return 0;
1399     }
1400
1401   collapse_uids(&keyblock);
1402
1403   /* Clean the key that we're about to import, to cut down on things
1404      that we have to clean later.  This has no practical impact on the
1405      end result, but does result in less logging which might confuse
1406      the user. */
1407   if (options&IMPORT_CLEAN)
1408     clean_key (keyblock,opt.verbose,options&IMPORT_MINIMAL,NULL,NULL);
1409
1410   clear_kbnode_flags( keyblock );
1411
1412   if ((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
1413       && opt.verbose)
1414     log_info (_("key %s: PKS subkey corruption repaired\n"),
1415               keystr_from_pk(pk));
1416
1417   if (chk_self_sigs (keyblock, keyid, &non_self))
1418     return 0;  /* Invalid keyblock - error already printed.  */
1419
1420   /* If we allow such a thing, mark unsigned uids as valid */
1421   if (opt.allow_non_selfsigned_uid)
1422     {
1423       for (node=keyblock; node; node = node->next )
1424         if (node->pkt->pkttype == PKT_USER_ID
1425             && !(node->flag & NODE_GOOD_SELFSIG)
1426             && !(node->flag & NODE_BAD_SELFSIG) )
1427           {
1428             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
1429                                       node->pkt->pkt.user_id->len,0);
1430             /* Fake a good signature status for the user id.  */
1431             node->flag |= NODE_GOOD_SELFSIG;
1432             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
1433                       keystr_from_pk(pk),user);
1434             xfree(user);
1435           }
1436     }
1437
1438   if (!delete_inv_parts (keyblock, keyid, options ) )
1439     {
1440       if (!silent)
1441         {
1442           log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
1443           if (!opt.quiet )
1444             log_info(_("this may be caused by a missing self-signature\n"));
1445         }
1446       stats->no_user_id++;
1447       return 0;
1448     }
1449
1450   /* Get rid of deleted nodes.  */
1451   commit_kbnode (&keyblock);
1452
1453   /* Apply import filter.  */
1454   if (import_filter.keep_uid)
1455     {
1456       apply_keep_uid_filter (keyblock, import_filter.keep_uid);
1457       commit_kbnode (&keyblock);
1458     }
1459   if (import_filter.drop_sig)
1460     {
1461       apply_drop_sig_filter (keyblock, import_filter.drop_sig);
1462       commit_kbnode (&keyblock);
1463     }
1464
1465
1466   /* Show the key in the form it is merged or inserted.  We skip this
1467    * if "import-export" is also active without --armor or the output
1468    * file has explicily been given. */
1469   if ((options & IMPORT_SHOW)
1470       && !((options & IMPORT_EXPORT) && !opt.armor && !opt.outfile))
1471     {
1472       merge_keys_and_selfsig (keyblock);
1473       merge_keys_done = 1;
1474       /* Note that we do not want to show the validity because the key
1475        * has not yet imported.  */
1476       list_keyblock_direct (ctrl, keyblock, 0, 0, 1, 1);
1477       es_fflush (es_stdout);
1478     }
1479
1480   /* Write the keyblock to the output and do not actually import.  */
1481   if ((options & IMPORT_EXPORT))
1482     {
1483       if (!merge_keys_done)
1484         {
1485           merge_keys_and_selfsig (keyblock);
1486           merge_keys_done = 1;
1487         }
1488       rc = write_keyblock_to_output (keyblock, opt.armor, opt.export_options);
1489       goto leave;
1490     }
1491
1492   if (opt.dry_run)
1493     goto leave;
1494
1495   /* Do we have this key already in one of our pubrings ? */
1496   pk_orig = xmalloc_clear( sizeof *pk_orig );
1497   rc = get_pubkey_byfprint_fast (pk_orig, fpr2, fpr2len);
1498   if (rc && gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
1499       && gpg_err_code (rc) != GPG_ERR_UNUSABLE_PUBKEY )
1500     {
1501       if (!silent)
1502         log_error (_("key %s: public key not found: %s\n"),
1503                    keystr(keyid), gpg_strerror (rc));
1504     }
1505   else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
1506     {
1507       if (opt.verbose && !silent )
1508         log_info( _("key %s: new key - skipped\n"), keystr(keyid));
1509       rc = 0;
1510       stats->skipped_new_keys++;
1511     }
1512   else if (rc )  /* Insert this key. */
1513     {
1514       KEYDB_HANDLE hd;
1515
1516       hd = keydb_new ();
1517       if (!hd)
1518         return gpg_error_from_syserror ();
1519
1520       rc = keydb_locate_writable (hd);
1521       if (rc)
1522         {
1523           log_error (_("no writable keyring found: %s\n"), gpg_strerror (rc));
1524           keydb_release (hd);
1525           return GPG_ERR_GENERAL;
1526         }
1527       if (opt.verbose > 1 )
1528         log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );
1529
1530       rc = keydb_insert_keyblock (hd, keyblock );
1531       if (rc)
1532         log_error (_("error writing keyring '%s': %s\n"),
1533                    keydb_get_resource_name (hd), gpg_strerror (rc));
1534       else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
1535         {
1536           /* This should not be possible since we delete the
1537              ownertrust when a key is deleted, but it can happen if
1538              the keyring and trustdb are out of sync.  It can also
1539              be made to happen with the trusted-key command and by
1540              importing and locally exported key. */
1541
1542           clear_ownertrusts (pk);
1543           if (non_self)
1544             revalidation_mark ();
1545         }
1546       keydb_release (hd);
1547
1548       /* We are ready.  */
1549       if (!opt.quiet && !silent)
1550         {
1551           char *p = get_user_id_byfpr_native (fpr2);
1552           log_info (_("key %s: public key \"%s\" imported\n"),
1553                     keystr(keyid), p);
1554           xfree(p);
1555         }
1556       if (is_status_enabled())
1557         {
1558           char *us = get_long_user_id_string( keyid );
1559           write_status_text( STATUS_IMPORTED, us );
1560           xfree(us);
1561           print_import_ok (pk, 1);
1562         }
1563       stats->imported++;
1564       new_key = 1;
1565     }
1566   else /* merge */
1567     {
1568       KEYDB_HANDLE hd;
1569       int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
1570
1571       /* Compare the original against the new key; just to be sure nothing
1572        * weird is going on */
1573       if (cmp_public_keys( pk_orig, pk ) )
1574         {
1575           if (!silent)
1576             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
1577           goto leave;
1578         }
1579
1580       /* Now read the original keyblock again so that we can use
1581          that handle for updating the keyblock.  */
1582       hd = keydb_new ();
1583       if (!hd)
1584         {
1585           rc = gpg_error_from_syserror ();
1586           goto leave;
1587         }
1588       keydb_disable_caching (hd);
1589       rc = keydb_search_fpr (hd, fpr2);
1590       if (rc )
1591         {
1592           log_error (_("key %s: can't locate original keyblock: %s\n"),
1593                      keystr(keyid), gpg_strerror (rc));
1594           keydb_release (hd);
1595           goto leave;
1596         }
1597       rc = keydb_get_keyblock (hd, &keyblock_orig);
1598       if (rc)
1599         {
1600           log_error (_("key %s: can't read original keyblock: %s\n"),
1601                      keystr(keyid), gpg_strerror (rc));
1602           keydb_release (hd);
1603           goto leave;
1604         }
1605
1606       /* Make sure the original direct key sigs are all sane.  */
1607       n_sigs_cleaned = fix_bad_direct_key_sigs (keyblock_orig, keyid);
1608       if (n_sigs_cleaned)
1609         commit_kbnode (&keyblock_orig);
1610
1611       /* and try to merge the block */
1612       clear_kbnode_flags( keyblock_orig );
1613       clear_kbnode_flags( keyblock );
1614       n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
1615       rc = merge_blocks (keyblock_orig, keyblock,
1616                          keyid, &n_uids, &n_sigs, &n_subk );
1617       if (rc )
1618         {
1619           keydb_release (hd);
1620           goto leave;
1621         }
1622
1623       if ((options & IMPORT_CLEAN))
1624         clean_key (keyblock_orig,opt.verbose,options&IMPORT_MINIMAL,
1625                    &n_uids_cleaned,&n_sigs_cleaned);
1626
1627       if (n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned)
1628         {
1629           mod_key = 1;
1630           /* KEYBLOCK_ORIG has been updated; write */
1631           rc = keydb_update_keyblock (hd, keyblock_orig);
1632           if (rc)
1633             log_error (_("error writing keyring '%s': %s\n"),
1634                        keydb_get_resource_name (hd), gpg_strerror (rc) );
1635           else if (non_self)
1636             revalidation_mark ();
1637
1638           /* We are ready.  */
1639           if (!opt.quiet && !silent)
1640             {
1641               char *p = get_user_id_byfpr_native (fpr2);
1642               if (n_uids == 1 )
1643                 log_info( _("key %s: \"%s\" 1 new user ID\n"),
1644                           keystr(keyid),p);
1645               else if (n_uids )
1646                 log_info( _("key %s: \"%s\" %d new user IDs\n"),
1647                           keystr(keyid),p,n_uids);
1648               if (n_sigs == 1 )
1649                 log_info( _("key %s: \"%s\" 1 new signature\n"),
1650                           keystr(keyid), p);
1651               else if (n_sigs )
1652                 log_info( _("key %s: \"%s\" %d new signatures\n"),
1653                           keystr(keyid), p, n_sigs );
1654               if (n_subk == 1 )
1655                 log_info( _("key %s: \"%s\" 1 new subkey\n"),
1656                           keystr(keyid), p);
1657               else if (n_subk )
1658                 log_info( _("key %s: \"%s\" %d new subkeys\n"),
1659                           keystr(keyid), p, n_subk );
1660               if (n_sigs_cleaned==1)
1661                 log_info(_("key %s: \"%s\" %d signature cleaned\n"),
1662                          keystr(keyid),p,n_sigs_cleaned);
1663               else if (n_sigs_cleaned)
1664                 log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
1665                          keystr(keyid),p,n_sigs_cleaned);
1666               if (n_uids_cleaned==1)
1667                 log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
1668                          keystr(keyid),p,n_uids_cleaned);
1669               else if (n_uids_cleaned)
1670                 log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
1671                          keystr(keyid),p,n_uids_cleaned);
1672               xfree(p);
1673             }
1674
1675           stats->n_uids +=n_uids;
1676           stats->n_sigs +=n_sigs;
1677           stats->n_subk +=n_subk;
1678           stats->n_sigs_cleaned +=n_sigs_cleaned;
1679           stats->n_uids_cleaned +=n_uids_cleaned;
1680
1681           if (is_status_enabled () && !silent)
1682             print_import_ok (pk, ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
1683         }
1684       else
1685         {
1686           same_key = 1;
1687           if (is_status_enabled ())
1688             print_import_ok (pk, 0);
1689
1690           if (!opt.quiet && !silent)
1691             {
1692               char *p = get_user_id_byfpr_native (fpr2);
1693               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
1694               xfree(p);
1695             }
1696
1697           stats->unchanged++;
1698         }
1699
1700       keydb_release (hd); hd = NULL;
1701     }
1702
1703  leave:
1704   if (mod_key || new_key || same_key)
1705     {
1706       /* A little explanation for this: we fill in the fingerprint
1707          when importing keys as it can be useful to know the
1708          fingerprint in certain keyserver-related cases (a keyserver
1709          asked for a particular name, but the key doesn't have that
1710          name).  However, in cases where we're importing more than
1711          one key at a time, we cannot know which key to fingerprint.
1712          In these cases, rather than guessing, we do not
1713          fingerprinting at all, and we must hope the user ID on the
1714          keys are useful.  Note that we need to do this for new
1715          keys, merged keys and even for unchanged keys.  This is
1716          required because for example the --auto-key-locate feature
1717          may import an already imported key and needs to know the
1718          fingerprint of the key in all cases.  */
1719       if (fpr)
1720         {
1721           xfree (*fpr);
1722           /* Note that we need to compare against 0 here because
1723              COUNT gets only incremented after returning from this
1724              function.  */
1725           if (!stats->count)
1726             *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
1727           else
1728             *fpr = NULL;
1729         }
1730     }
1731
1732   /* Now that the key is definitely incorporated into the keydb, we
1733      need to check if a designated revocation is present or if the
1734      prefs are not rational so we can warn the user. */
1735
1736   if (mod_key)
1737     {
1738       revocation_present (ctrl, keyblock_orig);
1739       if (!from_sk && have_secret_key_with_kid (keyid))
1740         check_prefs (ctrl, keyblock_orig);
1741     }
1742   else if (new_key)
1743     {
1744       revocation_present (ctrl, keyblock);
1745       if (!from_sk && have_secret_key_with_kid (keyid))
1746         check_prefs (ctrl, keyblock);
1747     }
1748
1749   release_kbnode( keyblock_orig );
1750   free_public_key( pk_orig );
1751
1752   return rc;
1753 }
1754
1755
1756 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
1757    function prints diagnostics and returns an error code.  If BATCH is
1758    true the secret keys are stored by gpg-agent in the transfer format
1759    (i.e. no re-protection and aksing for passphrases). */
1760 gpg_error_t
1761 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
1762                       kbnode_t sec_keyblock, int batch, int force)
1763 {
1764   gpg_error_t err = 0;
1765   void *kek = NULL;
1766   size_t keklen;
1767   kbnode_t ctx = NULL;
1768   kbnode_t node;
1769   PKT_public_key *main_pk, *pk;
1770   struct seckey_info *ski;
1771   int nskey;
1772   membuf_t mbuf;
1773   int i, j;
1774   void *format_args[2*PUBKEY_MAX_NSKEY];
1775   gcry_sexp_t skey, prot, tmpsexp;
1776   gcry_sexp_t curve = NULL;
1777   unsigned char *transferkey = NULL;
1778   size_t transferkeylen;
1779   gcry_cipher_hd_t cipherhd = NULL;
1780   unsigned char *wrappedkey = NULL;
1781   size_t wrappedkeylen;
1782   char *cache_nonce = NULL;
1783   int stub_key_skipped = 0;
1784
1785   /* Get the current KEK.  */
1786   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
1787   if (err)
1788     {
1789       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
1790       goto leave;
1791     }
1792
1793   /* Prepare a cipher context.  */
1794   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
1795                           GCRY_CIPHER_MODE_AESWRAP, 0);
1796   if (!err)
1797     err = gcry_cipher_setkey (cipherhd, kek, keklen);
1798   if (err)
1799     goto leave;
1800   xfree (kek);
1801   kek = NULL;
1802
1803   main_pk = NULL;
1804   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
1805     {
1806       if (node->pkt->pkttype != PKT_SECRET_KEY
1807           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
1808         continue;
1809       pk = node->pkt->pkt.public_key;
1810       if (!main_pk)
1811         main_pk = pk;
1812
1813       /* Make sure the keyids are available.  */
1814       keyid_from_pk (pk, NULL);
1815       if (node->pkt->pkttype == PKT_SECRET_KEY)
1816         {
1817           pk->main_keyid[0] = pk->keyid[0];
1818           pk->main_keyid[1] = pk->keyid[1];
1819         }
1820       else
1821         {
1822           pk->main_keyid[0] = main_pk->keyid[0];
1823           pk->main_keyid[1] = main_pk->keyid[1];
1824         }
1825
1826
1827       ski = pk->seckey_info;
1828       if (!ski)
1829         BUG ();
1830
1831       if (stats)
1832         {
1833           stats->count++;
1834           stats->secret_read++;
1835         }
1836
1837       /* We ignore stub keys.  The way we handle them in other parts
1838          of the code is by asking the agent whether any secret key is
1839          available for a given keyblock and then concluding that we
1840          have a secret key; all secret (sub)keys of the keyblock the
1841          agent does not know of are then stub keys.  This works also
1842          for card stub keys.  The learn command or the card-status
1843          command may be used to check with the agent whether a card
1844          has been inserted and a stub key is in turn generated by the
1845          agent.  */
1846       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
1847         {
1848           stub_key_skipped = 1;
1849           continue;
1850         }
1851
1852       /* Convert our internal secret key object into an S-expression.  */
1853       nskey = pubkey_get_nskey (pk->pubkey_algo);
1854       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
1855         {
1856           err = gpg_error (GPG_ERR_BAD_SECKEY);
1857           log_error ("internal error: %s\n", gpg_strerror (err));
1858           goto leave;
1859         }
1860
1861       init_membuf (&mbuf, 50);
1862       put_membuf_str (&mbuf, "(skey");
1863       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1864           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1865           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1866         {
1867           /* The ECC case.  */
1868           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
1869           if (!curvestr)
1870             err = gpg_error_from_syserror ();
1871           else
1872             {
1873               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
1874               gcry_sexp_release (curve);
1875               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
1876                                      curvename?curvename:curvestr);
1877               xfree (curvestr);
1878               if (!err)
1879                 {
1880                   j = 0;
1881                   /* Append the public key element Q.  */
1882                   put_membuf_str (&mbuf, " _ %m");
1883                   format_args[j++] = pk->pkey + 1;
1884
1885                   /* Append the secret key element D.  For ECDH we
1886                      skip PKEY[2] because this holds the KEK which is
1887                      not needed by gpg-agent.  */
1888                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
1889                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1890                     put_membuf_str (&mbuf, " e %m");
1891                   else
1892                     put_membuf_str (&mbuf, " _ %m");
1893                   format_args[j++] = pk->pkey + i;
1894                 }
1895             }
1896         }
1897       else
1898         {
1899           /* Standard case for the old (non-ECC) algorithms.  */
1900           for (i=j=0; i < nskey; i++)
1901             {
1902               if (!pk->pkey[i])
1903                 continue; /* Protected keys only have NPKEY+1 elements.  */
1904
1905               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1906                 put_membuf_str (&mbuf, " e %m");
1907               else
1908                 put_membuf_str (&mbuf, " _ %m");
1909               format_args[j++] = pk->pkey + i;
1910             }
1911         }
1912       put_membuf_str (&mbuf, ")");
1913       put_membuf (&mbuf, "", 1);
1914       if (err)
1915         xfree (get_membuf (&mbuf, NULL));
1916       else
1917         {
1918           char *format = get_membuf (&mbuf, NULL);
1919           if (!format)
1920             err = gpg_error_from_syserror ();
1921           else
1922             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
1923           xfree (format);
1924         }
1925       if (err)
1926         {
1927           log_error ("error building skey array: %s\n", gpg_strerror (err));
1928           goto leave;
1929         }
1930
1931       if (ski->is_protected)
1932         {
1933           char countbuf[35];
1934
1935           /* Note that the IVLEN may be zero if we are working on a
1936              dummy key.  We can't express that in an S-expression and
1937              thus we send dummy data for the IV.  */
1938           snprintf (countbuf, sizeof countbuf, "%lu",
1939                     (unsigned long)ski->s2k.count);
1940           err = gcry_sexp_build
1941             (&prot, NULL,
1942              " (protection %s %s %b %d %s %b %s)\n",
1943              ski->sha1chk? "sha1":"sum",
1944              openpgp_cipher_algo_name (ski->algo),
1945              ski->ivlen? (int)ski->ivlen:1,
1946              ski->ivlen? ski->iv: (const unsigned char*)"X",
1947              ski->s2k.mode,
1948              openpgp_md_algo_name (ski->s2k.hash_algo),
1949              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
1950              countbuf);
1951         }
1952       else
1953         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
1954
1955       tmpsexp = NULL;
1956       xfree (transferkey);
1957       transferkey = NULL;
1958       if (!err)
1959         err = gcry_sexp_build (&tmpsexp, NULL,
1960                                "(openpgp-private-key\n"
1961                                " (version %d)\n"
1962                                " (algo %s)\n"
1963                                " %S%S\n"
1964                                " (csum %d)\n"
1965                                " %S)\n",
1966                                pk->version,
1967                                openpgp_pk_algo_name (pk->pubkey_algo),
1968                                curve, skey,
1969                                (int)(unsigned long)ski->csum, prot);
1970       gcry_sexp_release (skey);
1971       gcry_sexp_release (prot);
1972       if (!err)
1973         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
1974       gcry_sexp_release (tmpsexp);
1975       if (err)
1976         {
1977           log_error ("error building transfer key: %s\n", gpg_strerror (err));
1978           goto leave;
1979         }
1980
1981       /* Wrap the key.  */
1982       wrappedkeylen = transferkeylen + 8;
1983       xfree (wrappedkey);
1984       wrappedkey = xtrymalloc (wrappedkeylen);
1985       if (!wrappedkey)
1986         err = gpg_error_from_syserror ();
1987       else
1988         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
1989                                    transferkey, transferkeylen);
1990       if (err)
1991         goto leave;
1992       xfree (transferkey);
1993       transferkey = NULL;
1994
1995       /* Send the wrapped key to the agent.  */
1996       {
1997         char *desc = gpg_format_keydesc (pk, FORMAT_KEYDESC_IMPORT, 1);
1998         err = agent_import_key (ctrl, desc, &cache_nonce,
1999                                 wrappedkey, wrappedkeylen, batch, force);
2000         xfree (desc);
2001       }
2002       if (!err)
2003         {
2004           if (opt.verbose)
2005             log_info (_("key %s: secret key imported\n"),
2006                       keystr_from_pk_with_sub (main_pk, pk));
2007           if (stats)
2008             stats->secret_imported++;
2009         }
2010       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
2011         {
2012           if (opt.verbose)
2013             log_info (_("key %s: secret key already exists\n"),
2014                       keystr_from_pk_with_sub (main_pk, pk));
2015           err = 0;
2016           if (stats)
2017             stats->secret_dups++;
2018         }
2019       else
2020         {
2021           log_error (_("key %s: error sending to agent: %s\n"),
2022                      keystr_from_pk_with_sub (main_pk, pk),
2023                      gpg_strerror (err));
2024           if (gpg_err_code (err) == GPG_ERR_CANCELED
2025               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
2026             break; /* Don't try the other subkeys.  */
2027         }
2028     }
2029
2030   if (!err && stub_key_skipped)
2031     /* We need to notify user how to migrate stub keys.  */
2032     err = gpg_error (GPG_ERR_NOT_PROCESSED);
2033
2034  leave:
2035   gcry_sexp_release (curve);
2036   xfree (cache_nonce);
2037   xfree (wrappedkey);
2038   xfree (transferkey);
2039   gcry_cipher_close (cipherhd);
2040   xfree (kek);
2041   return err;
2042 }
2043
2044
2045 /* Walk a secret keyblock and produce a public keyblock out of it.
2046    Returns a new node or NULL on error. */
2047 static kbnode_t
2048 sec_to_pub_keyblock (kbnode_t sec_keyblock)
2049 {
2050   kbnode_t pub_keyblock = NULL;
2051   kbnode_t ctx = NULL;
2052   kbnode_t secnode, pubnode;
2053
2054   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
2055     {
2056       if (secnode->pkt->pkttype == PKT_SECRET_KEY
2057           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
2058         {
2059           /* Make a public key.  */
2060           PACKET *pkt;
2061           PKT_public_key *pk;
2062
2063           pkt = xtrycalloc (1, sizeof *pkt);
2064           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
2065           if (!pk)
2066             {
2067               xfree (pkt);
2068               release_kbnode (pub_keyblock);
2069               return NULL;
2070             }
2071           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
2072             pkt->pkttype = PKT_PUBLIC_KEY;
2073           else
2074             pkt->pkttype = PKT_PUBLIC_SUBKEY;
2075           pkt->pkt.public_key = pk;
2076
2077           pubnode = new_kbnode (pkt);
2078         }
2079       else
2080         {
2081           pubnode = clone_kbnode (secnode);
2082         }
2083
2084       if (!pub_keyblock)
2085         pub_keyblock = pubnode;
2086       else
2087         add_kbnode (pub_keyblock, pubnode);
2088     }
2089
2090   return pub_keyblock;
2091 }
2092
2093 /****************
2094  * Ditto for secret keys.  Handling is simpler than for public keys.
2095  * We allow secret key importing only when allow is true, this is so
2096  * that a secret key can not be imported accidentally and thereby tampering
2097  * with the trust calculation.
2098  */
2099 static int
2100 import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
2101                    struct import_stats_s *stats, int batch, unsigned int options,
2102                    int for_migration,
2103                    import_screener_t screener, void *screener_arg)
2104 {
2105   PKT_public_key *pk;
2106   struct seckey_info *ski;
2107   kbnode_t node, uidnode;
2108   u32 keyid[2];
2109   int rc = 0;
2110   int nr_prev;
2111   kbnode_t pub_keyblock;
2112   char pkstrbuf[PUBKEY_STRING_SIZE];
2113
2114   /* Get the key and print some info about it */
2115   node = find_kbnode (keyblock, PKT_SECRET_KEY);
2116   if (!node)
2117     BUG ();
2118
2119   pk = node->pkt->pkt.public_key;
2120
2121   keyid_from_pk (pk, keyid);
2122   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
2123
2124   if (screener && screener (keyblock, screener_arg))
2125     {
2126       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
2127                  _("rejected by import screener"));
2128       return 0;
2129   }
2130
2131   if (opt.verbose && !for_migration)
2132     {
2133       log_info ("sec  %s/%s %s   ",
2134                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2135                 keystr_from_pk (pk), datestr_from_pk (pk));
2136       if (uidnode)
2137         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
2138                            uidnode->pkt->pkt.user_id->len);
2139       log_printf ("\n");
2140     }
2141   stats->secret_read++;
2142
2143   if ((options & IMPORT_NO_SECKEY))
2144     {
2145       if (!for_migration)
2146         log_error (_("importing secret keys not allowed\n"));
2147       return 0;
2148     }
2149
2150   if (!uidnode)
2151     {
2152       if (!for_migration)
2153         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
2154       return 0;
2155     }
2156
2157   ski = pk->seckey_info;
2158   if (!ski)
2159     {
2160       /* Actually an internal error.  */
2161       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
2162       return 0;
2163     }
2164
2165   /* A quick check to not import keys with an invalid protection
2166      cipher algorithm (only checks the primary key, though).  */
2167   if (ski->algo > 110)
2168     {
2169       if (!for_migration)
2170         log_error (_("key %s: secret key with invalid cipher %d"
2171                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
2172       return 0;
2173     }
2174
2175 #ifdef ENABLE_SELINUX_HACKS
2176   if (1)
2177     {
2178       /* We don't allow importing secret keys because that may be used
2179          to put a secret key into the keyring and the user might later
2180          be tricked into signing stuff with that key.  */
2181       log_error (_("importing secret keys not allowed\n"));
2182       return 0;
2183     }
2184 #endif
2185
2186   clear_kbnode_flags (keyblock);
2187
2188   nr_prev = stats->skipped_new_keys;
2189
2190   /* Make a public key out of the key. */
2191   pub_keyblock = sec_to_pub_keyblock (keyblock);
2192   if (!pub_keyblock)
2193     log_error ("key %s: failed to create public key from secret key\n",
2194                    keystr_from_pk (pk));
2195   else
2196     {
2197       /* Note that this outputs an IMPORT_OK status message for the
2198          public key block, and below we will output another one for
2199          the secret keys.  FIXME?  */
2200       import_one (ctrl, pub_keyblock, stats,
2201                   NULL, NULL, options, 1, for_migration,
2202                   screener, screener_arg);
2203
2204       /* Fixme: We should check for an invalid keyblock and
2205          cancel the secret key import in this case.  */
2206       release_kbnode (pub_keyblock);
2207
2208       /* At least we cancel the secret key import when the public key
2209          import was skipped due to MERGE_ONLY option and a new
2210          key.  */
2211       if (stats->skipped_new_keys <= nr_prev)
2212         {
2213           /* Read the keyblock again to get the effects of a merge.  */
2214           /* Fixme: we should do this based on the fingerprint or
2215              even better let import_one return the merged
2216              keyblock.  */
2217           node = get_pubkeyblock (keyid);
2218           if (!node)
2219             log_error ("key %s: failed to re-lookup public key\n",
2220                        keystr_from_pk (pk));
2221           else
2222             {
2223               gpg_error_t err;
2224
2225               /* transfer_secret_keys collects subkey stats.  */
2226               struct import_stats_s subkey_stats = {0};
2227
2228               err = transfer_secret_keys (ctrl, &subkey_stats, keyblock,
2229                                           batch, 0);
2230               if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
2231                 {
2232                   /* TRANSLATORS: For smartcard, each private key on
2233                      host has a reference (stub) to a smartcard and
2234                      actual private key data is stored on the card.  A
2235                      single smartcard can have up to three private key
2236                      data.  Importing private key stub is always
2237                      skipped in 2.1, and it returns
2238                      GPG_ERR_NOT_PROCESSED.  Instead, user should be
2239                      suggested to run 'gpg --card-status', then,
2240                      references to a card will be automatically
2241                      created again.  */
2242                   log_info (_("To migrate '%s', with each smartcard, "
2243                               "run: %s\n"), "secring.gpg", "gpg --card-status");
2244                   err = 0;
2245                 }
2246               if (!err)
2247                 {
2248                   int status = 16;
2249                   if (!opt.quiet)
2250                     log_info (_("key %s: secret key imported\n"),
2251                               keystr_from_pk (pk));
2252                   if (subkey_stats.secret_imported)
2253                     {
2254                       status |= 1;
2255                       stats->secret_imported += 1;
2256                     }
2257                   if (subkey_stats.secret_dups)
2258                     stats->secret_dups += 1;
2259
2260                   if (is_status_enabled ())
2261                     print_import_ok (pk, status);
2262                   check_prefs (ctrl, node);
2263                 }
2264               release_kbnode (node);
2265             }
2266         }
2267     }
2268
2269   return rc;
2270 }
2271
2272
2273 /****************
2274  * Import a revocation certificate; this is a single signature packet.
2275  */
2276 static int
2277 import_revoke_cert (kbnode_t node, struct import_stats_s *stats)
2278 {
2279   PKT_public_key *pk = NULL;
2280   kbnode_t onode;
2281   kbnode_t keyblock = NULL;
2282   KEYDB_HANDLE hd = NULL;
2283   u32 keyid[2];
2284   int rc = 0;
2285
2286   log_assert (!node->next );
2287   log_assert (node->pkt->pkttype == PKT_SIGNATURE );
2288   log_assert (node->pkt->pkt.signature->sig_class == 0x20 );
2289
2290   keyid[0] = node->pkt->pkt.signature->keyid[0];
2291   keyid[1] = node->pkt->pkt.signature->keyid[1];
2292
2293   pk = xmalloc_clear( sizeof *pk );
2294   rc = get_pubkey( pk, keyid );
2295   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
2296     {
2297       log_error(_("key %s: no public key -"
2298                   " can't apply revocation certificate\n"), keystr(keyid));
2299       rc = 0;
2300       goto leave;
2301     }
2302   else if (rc )
2303     {
2304       log_error(_("key %s: public key not found: %s\n"),
2305                 keystr(keyid), gpg_strerror (rc));
2306       goto leave;
2307     }
2308
2309   /* Read the original keyblock. */
2310   hd = keydb_new ();
2311   if (!hd)
2312     {
2313       rc = gpg_error_from_syserror ();
2314       goto leave;
2315     }
2316
2317   {
2318     byte afp[MAX_FINGERPRINT_LEN];
2319     size_t an;
2320
2321     fingerprint_from_pk (pk, afp, &an);
2322     while (an < MAX_FINGERPRINT_LEN)
2323       afp[an++] = 0;
2324     rc = keydb_search_fpr (hd, afp);
2325   }
2326   if (rc)
2327     {
2328       log_error (_("key %s: can't locate original keyblock: %s\n"),
2329                  keystr(keyid), gpg_strerror (rc));
2330       goto leave;
2331     }
2332   rc = keydb_get_keyblock (hd, &keyblock );
2333   if (rc)
2334     {
2335       log_error (_("key %s: can't read original keyblock: %s\n"),
2336                  keystr(keyid), gpg_strerror (rc));
2337       goto leave;
2338     }
2339
2340   /* it is okay, that node is not in keyblock because
2341    * check_key_signature works fine for sig_class 0x20 in this
2342    * special case. */
2343   rc = check_key_signature( keyblock, node, NULL);
2344   if (rc )
2345     {
2346       log_error( _("key %s: invalid revocation certificate"
2347                    ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
2348       goto leave;
2349     }
2350
2351   /* check whether we already have this */
2352   for(onode=keyblock->next; onode; onode=onode->next ) {
2353     if (onode->pkt->pkttype == PKT_USER_ID )
2354       break;
2355     else if (onode->pkt->pkttype == PKT_SIGNATURE
2356              && !cmp_signatures(node->pkt->pkt.signature,
2357                                 onode->pkt->pkt.signature))
2358       {
2359         rc = 0;
2360         goto leave; /* yes, we already know about it */
2361       }
2362   }
2363
2364   /* insert it */
2365   insert_kbnode( keyblock, clone_kbnode(node), 0 );
2366
2367   /* and write the keyblock back */
2368   rc = keydb_update_keyblock (hd, keyblock );
2369   if (rc)
2370     log_error (_("error writing keyring '%s': %s\n"),
2371                keydb_get_resource_name (hd), gpg_strerror (rc) );
2372   keydb_release (hd);
2373   hd = NULL;
2374
2375   /* we are ready */
2376   if (!opt.quiet )
2377     {
2378       char *p=get_user_id_native (keyid);
2379       log_info( _("key %s: \"%s\" revocation certificate imported\n"),
2380                 keystr(keyid),p);
2381       xfree(p);
2382     }
2383   stats->n_revoc++;
2384
2385   /* If the key we just revoked was ultimately trusted, remove its
2386      ultimate trust.  This doesn't stop the user from putting the
2387      ultimate trust back, but is a reasonable solution for now. */
2388   if(get_ownertrust(pk)==TRUST_ULTIMATE)
2389     clear_ownertrusts(pk);
2390
2391   revalidation_mark ();
2392
2393  leave:
2394   keydb_release (hd);
2395   release_kbnode( keyblock );
2396   free_public_key( pk );
2397   return rc;
2398 }
2399
2400
2401 /* Loop over the keyblock and check all self signatures.  On return
2402  * the following bis in the node flags are set:
2403  *
2404  * - NODE_GOOD_SELFSIG  :: User ID or subkey has a self-signature
2405  * - NODE_BAD_SELFSIG   :: Used ID or subkey has an invalid self-signature
2406  * - NODE_DELETION_MARK :: This node shall be deleted
2407  *
2408  * NON_SELF is set to true if there are any sigs other than self-sigs
2409  * in this keyblock.
2410  *
2411  * Returns 0 on success or -1 (but not an error code) if the keyblock
2412  * is invalid.
2413  */
2414 static int
2415 chk_self_sigs (kbnode_t keyblock, u32 *keyid, int *non_self )
2416 {
2417   kbnode_t n, knode = NULL;
2418   PKT_signature *sig;
2419   int rc;
2420   u32 bsdate=0, rsdate=0;
2421   kbnode_t bsnode = NULL, rsnode = NULL;
2422
2423   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
2424     {
2425       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2426         {
2427           knode = n;
2428           bsdate = 0;
2429           rsdate = 0;
2430           bsnode = NULL;
2431           rsnode = NULL;
2432           continue;
2433         }
2434
2435       if ( n->pkt->pkttype != PKT_SIGNATURE )
2436         continue;
2437
2438       sig = n->pkt->pkt.signature;
2439       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
2440         {
2441           *non_self = 1;
2442           continue;
2443         }
2444
2445       /* This just caches the sigs for later use.  That way we
2446          import a fully-cached key which speeds things up. */
2447       if (!opt.no_sig_cache)
2448         check_key_signature (keyblock, n, NULL);
2449
2450       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
2451         {
2452           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
2453           if ( !unode )
2454             {
2455               log_error( _("key %s: no user ID for signature\n"),
2456                          keystr(keyid));
2457               return -1;  /* The complete keyblock is invalid.  */
2458             }
2459
2460           /* If it hasn't been marked valid yet, keep trying.  */
2461           if (!(unode->flag & NODE_GOOD_SELFSIG))
2462             {
2463               rc = check_key_signature (keyblock, n, NULL);
2464               if ( rc )
2465                 {
2466                   if ( opt.verbose )
2467                     {
2468                       char *p = utf8_to_native
2469                         (unode->pkt->pkt.user_id->name,
2470                          strlen (unode->pkt->pkt.user_id->name),0);
2471                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
2472                                 _("key %s: unsupported public key "
2473                                   "algorithm on user ID \"%s\"\n"):
2474                                 _("key %s: invalid self-signature "
2475                                   "on user ID \"%s\"\n"),
2476                                 keystr (keyid),p);
2477                       xfree (p);
2478                     }
2479                 }
2480               else
2481                 unode->flag |= NODE_GOOD_SELFSIG;
2482             }
2483         }
2484       else if (IS_KEY_SIG (sig))
2485         {
2486           rc = check_key_signature (keyblock, n, NULL);
2487           if ( rc )
2488             {
2489               if (opt.verbose)
2490                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2491                           _("key %s: unsupported public key algorithm\n"):
2492                           _("key %s: invalid direct key signature\n"),
2493                           keystr (keyid));
2494               n->flag |= NODE_DELETION_MARK;
2495             }
2496         }
2497       else if ( IS_SUBKEY_SIG (sig) )
2498         {
2499           /* Note that this works based solely on the timestamps like
2500              the rest of gpg.  If the standard gets revocation
2501              targets, this may need to be revised.  */
2502
2503           if ( !knode )
2504             {
2505               if (opt.verbose)
2506                 log_info (_("key %s: no subkey for key binding\n"),
2507                           keystr (keyid));
2508               n->flag |= NODE_DELETION_MARK;
2509             }
2510           else
2511             {
2512               rc = check_key_signature (keyblock, n, NULL);
2513               if ( rc )
2514                 {
2515                   if (opt.verbose)
2516                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2517                               _("key %s: unsupported public key"
2518                                 " algorithm\n"):
2519                               _("key %s: invalid subkey binding\n"),
2520                               keystr (keyid));
2521                   n->flag |= NODE_DELETION_MARK;
2522                 }
2523               else
2524                 {
2525                   /* It's valid, so is it newer? */
2526                   if (sig->timestamp >= bsdate)
2527                     {
2528                       knode->flag |= NODE_GOOD_SELFSIG; /* Subkey is valid.  */
2529                       if (bsnode)
2530                         {
2531                           /* Delete the last binding sig since this
2532                              one is newer */
2533                           bsnode->flag |= NODE_DELETION_MARK;
2534                           if (opt.verbose)
2535                             log_info (_("key %s: removed multiple subkey"
2536                                         " binding\n"),keystr(keyid));
2537                         }
2538
2539                       bsnode = n;
2540                       bsdate = sig->timestamp;
2541                     }
2542                   else
2543                     n->flag |= NODE_DELETION_MARK; /* older */
2544                 }
2545             }
2546         }
2547       else if ( IS_SUBKEY_REV (sig) )
2548         {
2549           /* We don't actually mark the subkey as revoked right now,
2550              so just check that the revocation sig is the most recent
2551              valid one.  Note that we don't care if the binding sig is
2552              newer than the revocation sig.  See the comment in
2553              getkey.c:merge_selfsigs_subkey for more.  */
2554           if ( !knode )
2555             {
2556               if (opt.verbose)
2557                 log_info (_("key %s: no subkey for key revocation\n"),
2558                           keystr(keyid));
2559               n->flag |= NODE_DELETION_MARK;
2560             }
2561           else
2562             {
2563               rc = check_key_signature (keyblock, n, NULL);
2564               if ( rc )
2565                 {
2566                   if(opt.verbose)
2567                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2568                               _("key %s: unsupported public"
2569                                 " key algorithm\n"):
2570                               _("key %s: invalid subkey revocation\n"),
2571                               keystr(keyid));
2572                   n->flag |= NODE_DELETION_MARK;
2573                 }
2574               else
2575                 {
2576                   /* It's valid, so is it newer? */
2577                   if (sig->timestamp >= rsdate)
2578                     {
2579                       if (rsnode)
2580                         {
2581                           /* Delete the last revocation sig since
2582                              this one is newer.  */
2583                           rsnode->flag |= NODE_DELETION_MARK;
2584                           if (opt.verbose)
2585                             log_info (_("key %s: removed multiple subkey"
2586                                         " revocation\n"),keystr(keyid));
2587                         }
2588
2589                       rsnode = n;
2590                       rsdate = sig->timestamp;
2591                     }
2592                   else
2593                     n->flag |= NODE_DELETION_MARK; /* older */
2594                 }
2595             }
2596         }
2597     }
2598
2599   return 0;
2600 }
2601
2602
2603 /* Delete all parts which are invalid and those signatures whose
2604  * public key algorithm is not available in this implemenation; but
2605  * consider RSA as valid, because parse/build_packets knows about it.
2606  *
2607  * Returns: True if at least one valid user-id is left over.
2608  */
2609 static int
2610 delete_inv_parts (kbnode_t keyblock, u32 *keyid, unsigned int options)
2611 {
2612   kbnode_t node;
2613   int nvalid=0, uid_seen=0, subkey_seen=0;
2614
2615   for (node=keyblock->next; node; node = node->next )
2616     {
2617       if (node->pkt->pkttype == PKT_USER_ID)
2618         {
2619           uid_seen = 1;
2620           if ((node->flag & NODE_BAD_SELFSIG)
2621               || !(node->flag & NODE_GOOD_SELFSIG))
2622             {
2623               if (opt.verbose )
2624                 {
2625                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
2626                                          node->pkt->pkt.user_id->len,0);
2627                   log_info( _("key %s: skipped user ID \"%s\"\n"),
2628                             keystr(keyid),p);
2629                   xfree(p);
2630                 }
2631               delete_kbnode( node ); /* the user-id */
2632               /* and all following packets up to the next user-id */
2633               while (node->next
2634                      && node->next->pkt->pkttype != PKT_USER_ID
2635                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
2636                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
2637                 delete_kbnode( node->next );
2638                 node = node->next;
2639               }
2640             }
2641           else
2642             nvalid++;
2643         }
2644       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2645                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
2646         {
2647           if ((node->flag & NODE_BAD_SELFSIG)
2648               || !(node->flag & NODE_GOOD_SELFSIG))
2649             {
2650               if (opt.verbose )
2651                 log_info( _("key %s: skipped subkey\n"),keystr(keyid));
2652
2653               delete_kbnode( node ); /* the subkey */
2654               /* and all following signature packets */
2655               while (node->next
2656                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
2657                 delete_kbnode( node->next );
2658                 node = node->next;
2659               }
2660             }
2661           else
2662             subkey_seen = 1;
2663         }
2664       else if (node->pkt->pkttype == PKT_SIGNATURE
2665                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
2666                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
2667         {
2668           delete_kbnode( node ); /* build_packet() can't handle this */
2669         }
2670       else if (node->pkt->pkttype == PKT_SIGNATURE
2671                && !node->pkt->pkt.signature->flags.exportable
2672                && !(options&IMPORT_LOCAL_SIGS)
2673                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
2674         {
2675           /* here we violate the rfc a bit by still allowing
2676            * to import non-exportable signature when we have the
2677            * the secret key used to create this signature - it
2678            * seems that this makes sense */
2679           if(opt.verbose)
2680             log_info( _("key %s: non exportable signature"
2681                         " (class 0x%02X) - skipped\n"),
2682                       keystr(keyid), node->pkt->pkt.signature->sig_class );
2683           delete_kbnode( node );
2684         }
2685       else if (node->pkt->pkttype == PKT_SIGNATURE
2686                && node->pkt->pkt.signature->sig_class == 0x20)
2687         {
2688           if (uid_seen )
2689             {
2690               if(opt.verbose)
2691                 log_info( _("key %s: revocation certificate"
2692                             " at wrong place - skipped\n"),keystr(keyid));
2693               delete_kbnode( node );
2694             }
2695           else
2696             {
2697               /* If the revocation cert is from a different key than
2698                  the one we're working on don't check it - it's
2699                  probably from a revocation key and won't be
2700                  verifiable with this key anyway. */
2701
2702               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
2703                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
2704                 {
2705                   int rc = check_key_signature( keyblock, node, NULL);
2706                   if (rc )
2707                     {
2708                       if(opt.verbose)
2709                         log_info( _("key %s: invalid revocation"
2710                                     " certificate: %s - skipped\n"),
2711                                   keystr(keyid), gpg_strerror (rc));
2712                       delete_kbnode( node );
2713                     }
2714                 }
2715             }
2716         }
2717       else if (node->pkt->pkttype == PKT_SIGNATURE
2718                && (node->pkt->pkt.signature->sig_class == 0x18
2719                    || node->pkt->pkt.signature->sig_class == 0x28)
2720                && !subkey_seen )
2721         {
2722           if(opt.verbose)
2723             log_info( _("key %s: subkey signature"
2724                         " in wrong place - skipped\n"), keystr(keyid));
2725           delete_kbnode( node );
2726         }
2727       else if (node->pkt->pkttype == PKT_SIGNATURE
2728                && !IS_CERT(node->pkt->pkt.signature))
2729         {
2730           if(opt.verbose)
2731             log_info(_("key %s: unexpected signature class (0x%02X) -"
2732                        " skipped\n"),keystr(keyid),
2733                      node->pkt->pkt.signature->sig_class);
2734           delete_kbnode(node);
2735           }
2736       else if ((node->flag & NODE_DELETION_MARK))
2737         delete_kbnode( node );
2738     }
2739
2740   /* note: because keyblock is the public key, it is never marked
2741    * for deletion and so keyblock cannot change */
2742   commit_kbnode( &keyblock );
2743   return nvalid;
2744 }
2745
2746
2747 /****************
2748  * It may happen that the imported keyblock has duplicated user IDs.
2749  * We check this here and collapse those user IDs together with their
2750  * sigs into one.
2751  * Returns: True if the keyblock has changed.
2752  */
2753 int
2754 collapse_uids( kbnode_t *keyblock )
2755 {
2756   kbnode_t uid1;
2757   int any=0;
2758
2759   for(uid1=*keyblock;uid1;uid1=uid1->next)
2760     {
2761       kbnode_t uid2;
2762
2763       if(is_deleted_kbnode(uid1))
2764         continue;
2765
2766       if(uid1->pkt->pkttype!=PKT_USER_ID)
2767         continue;
2768
2769       for(uid2=uid1->next;uid2;uid2=uid2->next)
2770         {
2771           if(is_deleted_kbnode(uid2))
2772             continue;
2773
2774           if(uid2->pkt->pkttype!=PKT_USER_ID)
2775             continue;
2776
2777           if(cmp_user_ids(uid1->pkt->pkt.user_id,
2778                           uid2->pkt->pkt.user_id)==0)
2779             {
2780               /* We have a duplicated uid */
2781               kbnode_t sig1,last;
2782
2783               any=1;
2784
2785               /* Now take uid2's signatures, and attach them to
2786                  uid1 */
2787               for(last=uid2;last->next;last=last->next)
2788                 {
2789                   if(is_deleted_kbnode(last))
2790                     continue;
2791
2792                   if(last->next->pkt->pkttype==PKT_USER_ID
2793                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
2794                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
2795                     break;
2796                 }
2797
2798               /* Snip out uid2 */
2799               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
2800
2801               /* Now put uid2 in place as part of uid1 */
2802               last->next=uid1->next;
2803               uid1->next=uid2;
2804               delete_kbnode(uid2);
2805
2806               /* Now dedupe uid1 */
2807               for(sig1=uid1->next;sig1;sig1=sig1->next)
2808                 {
2809                   kbnode_t sig2;
2810
2811                   if(is_deleted_kbnode(sig1))
2812                     continue;
2813
2814                   if(sig1->pkt->pkttype==PKT_USER_ID
2815                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
2816                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
2817                     break;
2818
2819                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
2820                     continue;
2821
2822                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
2823                     {
2824                       if(is_deleted_kbnode(sig2))
2825                         continue;
2826
2827                       if(sig2->pkt->pkttype==PKT_USER_ID
2828                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
2829                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
2830                         break;
2831
2832                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
2833                         continue;
2834
2835                       if(cmp_signatures(sig1->pkt->pkt.signature,
2836                                         sig2->pkt->pkt.signature)==0)
2837                         {
2838                           /* We have a match, so delete the second
2839                              signature */
2840                           delete_kbnode(sig2);
2841                           sig2=last;
2842                         }
2843                     }
2844                 }
2845             }
2846         }
2847     }
2848
2849   commit_kbnode(keyblock);
2850
2851   if(any && !opt.quiet)
2852     {
2853       const char *key="???";
2854
2855       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
2856         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2857       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
2858         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2859
2860       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
2861     }
2862
2863   return any;
2864 }
2865
2866
2867 /* Check for a 0x20 revocation from a revocation key that is not
2868    present.  This may be called without the benefit of merge_xxxx so
2869    you can't rely on pk->revkey and friends. */
2870 static void
2871 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
2872 {
2873   kbnode_t onode, inode;
2874   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2875
2876   for(onode=keyblock->next;onode;onode=onode->next)
2877     {
2878       /* If we reach user IDs, we're done. */
2879       if(onode->pkt->pkttype==PKT_USER_ID)
2880         break;
2881
2882       if(onode->pkt->pkttype==PKT_SIGNATURE &&
2883          onode->pkt->pkt.signature->sig_class==0x1F &&
2884          onode->pkt->pkt.signature->revkey)
2885         {
2886           int idx;
2887           PKT_signature *sig=onode->pkt->pkt.signature;
2888
2889           for(idx=0;idx<sig->numrevkeys;idx++)
2890             {
2891               u32 keyid[2];
2892
2893               keyid_from_fingerprint(sig->revkey[idx].fpr,
2894                                      MAX_FINGERPRINT_LEN,keyid);
2895
2896               for(inode=keyblock->next;inode;inode=inode->next)
2897                 {
2898                   /* If we reach user IDs, we're done. */
2899                   if(inode->pkt->pkttype==PKT_USER_ID)
2900                     break;
2901
2902                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
2903                      inode->pkt->pkt.signature->sig_class==0x20 &&
2904                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
2905                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
2906                     {
2907                       /* Okay, we have a revocation key, and a
2908                          revocation issued by it.  Do we have the key
2909                          itself? */
2910                       int rc;
2911
2912                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx].fpr,
2913                                                    MAX_FINGERPRINT_LEN);
2914                       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2915                           || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2916                         {
2917                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
2918
2919                           /* No, so try and get it */
2920                           if ((opt.keyserver_options.options
2921                                & KEYSERVER_AUTO_KEY_RETRIEVE)
2922                               && keyserver_any_configured (ctrl))
2923                             {
2924                               log_info(_("WARNING: key %s may be revoked:"
2925                                          " fetching revocation key %s\n"),
2926                                        tempkeystr,keystr(keyid));
2927                               keyserver_import_fprint (ctrl,
2928                                                        sig->revkey[idx].fpr,
2929                                                        MAX_FINGERPRINT_LEN,
2930                                                        opt.keyserver);
2931
2932                               /* Do we have it now? */
2933                               rc=get_pubkey_byfprint_fast (NULL,
2934                                                      sig->revkey[idx].fpr,
2935                                                      MAX_FINGERPRINT_LEN);
2936                             }
2937
2938                           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2939                               || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2940                             log_info(_("WARNING: key %s may be revoked:"
2941                                        " revocation key %s not present.\n"),
2942                                      tempkeystr,keystr(keyid));
2943
2944                           xfree(tempkeystr);
2945                         }
2946                     }
2947                 }
2948             }
2949         }
2950     }
2951 }
2952
2953
2954 /*
2955  * compare and merge the blocks
2956  *
2957  * o compare the signatures: If we already have this signature, check
2958  *   that they compare okay; if not, issue a warning and ask the user.
2959  * o Simply add the signature.  Can't verify here because we may not have
2960  *   the signature's public key yet; verification is done when putting it
2961  *   into the trustdb, which is done automagically as soon as this pubkey
2962  *   is used.
2963  * Note: We indicate newly inserted packets with NODE_FLAG_A.
2964  */
2965 static int
2966 merge_blocks (kbnode_t keyblock_orig, kbnode_t keyblock,
2967               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
2968 {
2969   kbnode_t onode, node;
2970   int rc, found;
2971
2972   /* 1st: handle revocation certificates */
2973   for (node=keyblock->next; node; node=node->next )
2974     {
2975       if (node->pkt->pkttype == PKT_USER_ID )
2976         break;
2977       else if (node->pkt->pkttype == PKT_SIGNATURE
2978                && node->pkt->pkt.signature->sig_class == 0x20)
2979         {
2980           /* check whether we already have this */
2981           found = 0;
2982           for (onode=keyblock_orig->next; onode; onode=onode->next)
2983             {
2984               if (onode->pkt->pkttype == PKT_USER_ID )
2985                 break;
2986               else if (onode->pkt->pkttype == PKT_SIGNATURE
2987                        && onode->pkt->pkt.signature->sig_class == 0x20
2988                        && !cmp_signatures(onode->pkt->pkt.signature,
2989                                           node->pkt->pkt.signature))
2990                 {
2991                   found = 1;
2992                   break;
2993                 }
2994             }
2995           if (!found)
2996             {
2997               kbnode_t n2 = clone_kbnode(node);
2998               insert_kbnode( keyblock_orig, n2, 0 );
2999               n2->flag |= NODE_FLAG_A;
3000               ++*n_sigs;
3001               if(!opt.quiet)
3002                 {
3003                   char *p=get_user_id_native (keyid);
3004                   log_info(_("key %s: \"%s\" revocation"
3005                              " certificate added\n"), keystr(keyid),p);
3006                   xfree(p);
3007                 }
3008             }
3009         }
3010     }
3011
3012   /* 2nd: merge in any direct key (0x1F) sigs */
3013   for(node=keyblock->next; node; node=node->next)
3014     {
3015       if (node->pkt->pkttype == PKT_USER_ID )
3016         break;
3017       else if (node->pkt->pkttype == PKT_SIGNATURE
3018                && node->pkt->pkt.signature->sig_class == 0x1F)
3019         {
3020           /* check whether we already have this */
3021           found = 0;
3022           for (onode=keyblock_orig->next; onode; onode=onode->next)
3023             {
3024               if (onode->pkt->pkttype == PKT_USER_ID)
3025                 break;
3026               else if (onode->pkt->pkttype == PKT_SIGNATURE
3027                        && onode->pkt->pkt.signature->sig_class == 0x1F
3028                        && !cmp_signatures(onode->pkt->pkt.signature,
3029                                           node->pkt->pkt.signature))
3030                 {
3031                   found = 1;
3032                   break;
3033                 }
3034             }
3035           if (!found )
3036             {
3037               kbnode_t n2 = clone_kbnode(node);
3038               insert_kbnode( keyblock_orig, n2, 0 );
3039               n2->flag |= NODE_FLAG_A;
3040               ++*n_sigs;
3041               if(!opt.quiet)
3042                 log_info( _("key %s: direct key signature added\n"),
3043                           keystr(keyid));
3044             }
3045         }
3046     }
3047
3048   /* 3rd: try to merge new certificates in */
3049   for (onode=keyblock_orig->next; onode; onode=onode->next)
3050     {
3051       if (!(onode->flag & NODE_FLAG_A) && onode->pkt->pkttype == PKT_USER_ID)
3052         {
3053           /* find the user id in the imported keyblock */
3054           for (node=keyblock->next; node; node=node->next)
3055             if (node->pkt->pkttype == PKT_USER_ID
3056                 && !cmp_user_ids( onode->pkt->pkt.user_id,
3057                                   node->pkt->pkt.user_id ) )
3058               break;
3059           if (node ) /* found: merge */
3060             {
3061               rc = merge_sigs (onode, node, n_sigs);
3062               if (rc )
3063                 return rc;
3064             }
3065         }
3066     }
3067
3068   /* 4th: add new user-ids */
3069   for (node=keyblock->next; node; node=node->next)
3070     {
3071       if (node->pkt->pkttype == PKT_USER_ID)
3072         {
3073           /* do we have this in the original keyblock */
3074           for (onode=keyblock_orig->next; onode; onode=onode->next )
3075             if (onode->pkt->pkttype == PKT_USER_ID
3076                 && !cmp_user_ids( onode->pkt->pkt.user_id,
3077                                   node->pkt->pkt.user_id ) )
3078               break;
3079           if (!onode ) /* this is a new user id: append */
3080             {
3081               rc = append_uid (keyblock_orig, node, n_sigs);
3082               if (rc )
3083                 return rc;
3084               ++*n_uids;
3085             }
3086         }
3087     }
3088
3089   /* 5th: add new subkeys */
3090   for (node=keyblock->next; node; node=node->next)
3091     {
3092       onode = NULL;
3093       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3094         {
3095           /* do we have this in the original keyblock? */
3096           for(onode=keyblock_orig->next; onode; onode=onode->next)
3097             if (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
3098                 && !cmp_public_keys( onode->pkt->pkt.public_key,
3099                                      node->pkt->pkt.public_key))
3100               break;
3101           if (!onode ) /* This is a new subkey: append.  */
3102             {
3103               rc = append_key (keyblock_orig, node, n_sigs);
3104               if (rc)
3105                 return rc;
3106               ++*n_subk;
3107             }
3108         }
3109       else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
3110         {
3111           /* do we have this in the original keyblock? */
3112           for (onode=keyblock_orig->next; onode; onode=onode->next )
3113             if (onode->pkt->pkttype == PKT_SECRET_SUBKEY
3114                 && !cmp_public_keys (onode->pkt->pkt.public_key,
3115                                      node->pkt->pkt.public_key) )
3116               break;
3117           if (!onode ) /* This is a new subkey: append.  */
3118             {
3119               rc = append_key (keyblock_orig, node, n_sigs);
3120               if (rc )
3121                 return rc;
3122               ++*n_subk;
3123             }
3124         }
3125     }
3126
3127   /* 6th: merge subkey certificates */
3128   for (onode=keyblock_orig->next; onode; onode=onode->next)
3129     {
3130       if (!(onode->flag & NODE_FLAG_A)
3131           && (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
3132               || onode->pkt->pkttype == PKT_SECRET_SUBKEY))
3133         {
3134           /* find the subkey in the imported keyblock */
3135           for(node=keyblock->next; node; node=node->next)
3136             {
3137               if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3138                    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
3139                   && !cmp_public_keys( onode->pkt->pkt.public_key,
3140                                        node->pkt->pkt.public_key ) )
3141                 break;
3142             }
3143           if (node) /* Found: merge.  */
3144             {
3145               rc = merge_keysigs( onode, node, n_sigs);
3146               if (rc )
3147                 return rc;
3148             }
3149         }
3150     }
3151
3152   return 0;
3153 }
3154
3155
3156 /* Helper function for merge_blocks.
3157  * Append the userid starting with NODE and all signatures to KEYBLOCK.
3158  */
3159 static int
3160 append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs)
3161 {
3162   kbnode_t n;
3163   kbnode_t n_where = NULL;
3164
3165   log_assert (node->pkt->pkttype == PKT_USER_ID );
3166
3167   /* find the position */
3168   for (n = keyblock; n; n_where = n, n = n->next)
3169     {
3170       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
3171           || n->pkt->pkttype == PKT_SECRET_SUBKEY )
3172         break;
3173     }
3174   if (!n)
3175     n_where = NULL;
3176
3177   /* and append/insert */
3178   while (node)
3179     {
3180       /* we add a clone to the original keyblock, because this
3181        * one is released first */
3182       n = clone_kbnode(node);
3183       if (n_where)
3184         {
3185           insert_kbnode( n_where, n, 0 );
3186           n_where = n;
3187         }
3188       else
3189         add_kbnode( keyblock, n );
3190       n->flag |= NODE_FLAG_A;
3191       node->flag |= NODE_FLAG_A;
3192       if (n->pkt->pkttype == PKT_SIGNATURE )
3193         ++*n_sigs;
3194
3195       node = node->next;
3196       if (node && node->pkt->pkttype != PKT_SIGNATURE )
3197         break;
3198     }
3199
3200   return 0;
3201 }
3202
3203
3204 /* Helper function for merge_blocks
3205  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
3206  * (how should we handle comment packets here?)
3207  */
3208 static int
3209 merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs)
3210 {
3211   kbnode_t n, n2;
3212   int found = 0;
3213
3214   log_assert (dst->pkt->pkttype == PKT_USER_ID);
3215   log_assert (src->pkt->pkttype == PKT_USER_ID);
3216
3217   for (n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next)
3218     {
3219       if (n->pkt->pkttype != PKT_SIGNATURE )
3220         continue;
3221       if (n->pkt->pkt.signature->sig_class == 0x18
3222           || n->pkt->pkt.signature->sig_class == 0x28 )
3223         continue; /* skip signatures which are only valid on subkeys */
3224
3225       found = 0;
3226       for (n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
3227         if (!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
3228           {
3229             found++;
3230             break;
3231           }
3232       if (!found )
3233         {
3234           /* This signature is new or newer, append N to DST.
3235            * We add a clone to the original keyblock, because this
3236            * one is released first */
3237           n2 = clone_kbnode(n);
3238           insert_kbnode( dst, n2, PKT_SIGNATURE );
3239           n2->flag |= NODE_FLAG_A;
3240           n->flag |= NODE_FLAG_A;
3241           ++*n_sigs;
3242         }
3243     }
3244
3245   return 0;
3246 }
3247
3248
3249 /* Helper function for merge_blocks
3250  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
3251  */
3252 static int
3253 merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs)
3254 {
3255   kbnode_t n, n2;
3256   int found = 0;
3257
3258   log_assert (dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
3259               || dst->pkt->pkttype == PKT_SECRET_SUBKEY);
3260
3261   for (n=src->next; n ; n = n->next)
3262     {
3263       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
3264           || n->pkt->pkttype == PKT_PUBLIC_KEY )
3265         break;
3266       if (n->pkt->pkttype != PKT_SIGNATURE )
3267         continue;
3268
3269       found = 0;
3270       for (n2=dst->next; n2; n2 = n2->next)
3271         {
3272           if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
3273               || n2->pkt->pkttype == PKT_PUBLIC_KEY )
3274             break;
3275           if (n2->pkt->pkttype == PKT_SIGNATURE
3276               && (n->pkt->pkt.signature->keyid[0]
3277                   == n2->pkt->pkt.signature->keyid[0])
3278               && (n->pkt->pkt.signature->keyid[1]
3279                   == n2->pkt->pkt.signature->keyid[1])
3280               && (n->pkt->pkt.signature->timestamp
3281                   <= n2->pkt->pkt.signature->timestamp)
3282               && (n->pkt->pkt.signature->sig_class
3283                   == n2->pkt->pkt.signature->sig_class))
3284             {
3285               found++;
3286               break;
3287             }
3288         }
3289       if (!found )
3290         {
3291           /* This signature is new or newer, append N to DST.
3292            * We add a clone to the original keyblock, because this
3293            * one is released first */
3294           n2 = clone_kbnode(n);
3295           insert_kbnode( dst, n2, PKT_SIGNATURE );
3296           n2->flag |= NODE_FLAG_A;
3297           n->flag |= NODE_FLAG_A;
3298           ++*n_sigs;
3299         }
3300     }
3301
3302   return 0;
3303 }
3304
3305
3306 /* Helper function for merge_blocks.
3307  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
3308  * Mark all new and copied packets by setting flag bit 0.
3309  */
3310 static int
3311 append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs)
3312 {
3313   kbnode_t n;
3314
3315   log_assert (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3316               || node->pkt->pkttype == PKT_SECRET_SUBKEY);
3317
3318   while (node)
3319     {
3320       /* we add a clone to the original keyblock, because this
3321        * one is released first */
3322       n = clone_kbnode(node);
3323       add_kbnode( keyblock, n );
3324       n->flag |= NODE_FLAG_A;
3325       node->flag |= NODE_FLAG_A;
3326       if (n->pkt->pkttype == PKT_SIGNATURE )
3327         ++*n_sigs;
3328
3329       node = node->next;
3330       if (node && node->pkt->pkttype != PKT_SIGNATURE )
3331         break;
3332     }
3333
3334   return 0;
3335 }