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