gpg: Clear the symmetric passphrase cache for encrypted session keys.
[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 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                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
860               }
861             free_packet (pkt, &parsectx);
862             init_packet(pkt);
863             break;
864
865           case PKT_RING_TRUST:
866             /* Skip those packets unless we are in restore mode.  */
867             if ((opt.import_options & IMPORT_RESTORE))
868               goto x_default;
869             free_packet (pkt, &parsectx);
870             init_packet(pkt);
871             break;
872
873           case PKT_PUBLIC_KEY:
874           case PKT_SECRET_KEY:
875             if (in_cert ) /* Store this packet.  */
876               {
877                 *pending_pkt = pkt;
878                 pkt = NULL;
879                 goto ready;
880               }
881             in_cert = 1; /* fall through */
882           default:
883           x_default:
884             if (in_cert && valid_keyblock_packet (pkt->pkttype))
885               {
886                 if (!root )
887                   root = new_kbnode (pkt);
888                 else
889                   add_kbnode (root, new_kbnode (pkt));
890                 pkt = xmalloc (sizeof *pkt);
891               }
892             init_packet(pkt);
893             break;
894           }
895     }
896
897  ready:
898   if (rc == -1 && root )
899     rc = 0;
900
901   if (rc )
902     release_kbnode( root );
903   else
904     *ret_root = root;
905   free_packet (pkt, &parsectx);
906   deinit_parse_packet (&parsectx);
907   xfree( pkt );
908   return rc;
909 }
910
911
912 /* Walk through the subkeys on a pk to find if we have the PKS
913    disease: multiple subkeys with their binding sigs stripped, and the
914    sig for the first subkey placed after the last subkey.  That is,
915    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
916    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
917    and sub3, as they are already lost, but we can try and rescue sub1
918    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
919    sub2 sub3".  Returns TRUE if the keyblock was modified. */
920 static int
921 fix_pks_corruption (ctrl_t ctrl, kbnode_t keyblock)
922 {
923   int changed = 0;
924   int keycount = 0;
925   kbnode_t node;
926   kbnode_t last = NULL;
927   kbnode_t sknode=NULL;
928
929   /* First determine if we have the problem at all.  Look for 2 or
930      more subkeys in a row, followed by a single binding sig. */
931   for (node=keyblock; node; last=node, node=node->next)
932     {
933       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
934         {
935           keycount++;
936           if(!sknode)
937             sknode=node;
938         }
939       else if (node->pkt->pkttype == PKT_SIGNATURE
940                && IS_SUBKEY_SIG (node->pkt->pkt.signature)
941                && keycount >= 2
942                && !node->next)
943         {
944           /* We might have the problem, as this key has two subkeys in
945              a row without any intervening packets. */
946
947           /* Sanity check */
948           if (!last)
949             break;
950
951           /* Temporarily attach node to sknode. */
952           node->next = sknode->next;
953           sknode->next = node;
954           last->next = NULL;
955
956           /* Note we aren't checking whether this binding sig is a
957              selfsig.  This is not necessary here as the subkey and
958              binding sig will be rejected later if that is the
959              case. */
960           if (check_key_signature (ctrl, keyblock,node,NULL))
961             {
962               /* Not a match, so undo the changes. */
963               sknode->next = node->next;
964               last->next = node;
965               node->next = NULL;
966               break;
967             }
968           else
969             {
970               /* Mark it good so we don't need to check it again */
971               sknode->flag |= NODE_GOOD_SELFSIG;
972               changed = 1;
973               break;
974             }
975         }
976       else
977         keycount = 0;
978     }
979
980   return changed;
981 }
982
983
984 /* Versions of GnuPG before 1.4.11 and 2.0.16 allowed to import bogus
985    direct key signatures.  A side effect of this was that a later
986    import of the same good direct key signatures was not possible
987    because the cmp_signature check in merge_blocks considered them
988    equal.  Although direct key signatures are now checked during
989    import, there might still be bogus signatures sitting in a keyring.
990    We need to detect and delete them before doing a merge.  This
991    function returns the number of removed sigs.  */
992 static int
993 fix_bad_direct_key_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid)
994 {
995   gpg_error_t err;
996   kbnode_t node;
997   int count = 0;
998
999   for (node = keyblock->next; node; node=node->next)
1000     {
1001       if (node->pkt->pkttype == PKT_USER_ID)
1002         break;
1003       if (node->pkt->pkttype == PKT_SIGNATURE
1004           && IS_KEY_SIG (node->pkt->pkt.signature))
1005         {
1006           err = check_key_signature (ctrl, keyblock, node, NULL);
1007           if (err && gpg_err_code (err) != GPG_ERR_PUBKEY_ALGO )
1008             {
1009               /* If we don't know the error, we can't decide; this is
1010                  not a problem because cmp_signature can't compare the
1011                  signature either.  */
1012               log_info ("key %s: invalid direct key signature removed\n",
1013                         keystr (keyid));
1014               delete_kbnode (node);
1015               count++;
1016             }
1017         }
1018     }
1019
1020   return count;
1021 }
1022
1023
1024 static void
1025 print_import_ok (PKT_public_key *pk, unsigned int reason)
1026 {
1027   byte array[MAX_FINGERPRINT_LEN], *s;
1028   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
1029   size_t i, n;
1030
1031   snprintf (buf, sizeof buf, "%u ", reason);
1032   p = buf + strlen (buf);
1033
1034   fingerprint_from_pk (pk, array, &n);
1035   s = array;
1036   for (i=0; i < n ; i++, s++, p += 2)
1037     sprintf (p, "%02X", *s);
1038
1039   write_status_text (STATUS_IMPORT_OK, buf);
1040 }
1041
1042
1043 static void
1044 print_import_check (PKT_public_key * pk, PKT_user_id * id)
1045 {
1046   char * buf;
1047   byte fpr[24];
1048   u32 keyid[2];
1049   size_t i, n;
1050   size_t pos = 0;
1051
1052   buf = xmalloc (17+41+id->len+32);
1053   keyid_from_pk (pk, keyid);
1054   sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
1055   pos = 17;
1056   fingerprint_from_pk (pk, fpr, &n);
1057   for (i = 0; i < n; i++, pos += 2)
1058     sprintf (buf+pos, "%02X", fpr[i]);
1059   strcat (buf, " ");
1060   strcat (buf, id->name);
1061   write_status_text (STATUS_IMPORT_CHECK, buf);
1062   xfree (buf);
1063 }
1064
1065
1066 static void
1067 check_prefs_warning(PKT_public_key *pk)
1068 {
1069   log_info(_("WARNING: key %s contains preferences for unavailable\n"
1070              "algorithms on these user IDs:\n"), keystr_from_pk(pk));
1071 }
1072
1073
1074 static void
1075 check_prefs (ctrl_t ctrl, kbnode_t keyblock)
1076 {
1077   kbnode_t node;
1078   PKT_public_key *pk;
1079   int problem=0;
1080
1081   merge_keys_and_selfsig (ctrl, keyblock);
1082   pk=keyblock->pkt->pkt.public_key;
1083
1084   for(node=keyblock;node;node=node->next)
1085     {
1086       if(node->pkt->pkttype==PKT_USER_ID
1087          && node->pkt->pkt.user_id->created
1088          && node->pkt->pkt.user_id->prefs)
1089         {
1090           PKT_user_id *uid = node->pkt->pkt.user_id;
1091           prefitem_t *prefs = uid->prefs;
1092           char *user = utf8_to_native(uid->name,strlen(uid->name),0);
1093
1094           for(;prefs->type;prefs++)
1095             {
1096               char num[10]; /* prefs->value is a byte, so we're over
1097                                safe here */
1098
1099               sprintf(num,"%u",prefs->value);
1100
1101               if(prefs->type==PREFTYPE_SYM)
1102                 {
1103                   if (openpgp_cipher_test_algo (prefs->value))
1104                     {
1105                       const char *algo =
1106                         (openpgp_cipher_test_algo (prefs->value)
1107                          ? num
1108                          : openpgp_cipher_algo_name (prefs->value));
1109                       if(!problem)
1110                         check_prefs_warning(pk);
1111                       log_info(_("         \"%s\": preference for cipher"
1112                                  " algorithm %s\n"), user, algo);
1113                       problem=1;
1114                     }
1115                 }
1116               else if(prefs->type==PREFTYPE_AEAD)
1117                 {
1118                   if (openpgp_aead_test_algo (prefs->value))
1119                     {
1120                       /* FIXME: The test below is wrong.  We should
1121                        * check if ...algo_name yields a "?" and
1122                        * only in that case use NUM.  */
1123                       const char *algo =
1124                         (openpgp_aead_test_algo (prefs->value)
1125                          ? num
1126                          : openpgp_aead_algo_name (prefs->value));
1127                       if(!problem)
1128                         check_prefs_warning(pk);
1129                       log_info(_("         \"%s\": preference for AEAD"
1130                                  " algorithm %s\n"), user, algo);
1131                       problem=1;
1132                     }
1133                 }
1134               else if(prefs->type==PREFTYPE_HASH)
1135                 {
1136                   if(openpgp_md_test_algo(prefs->value))
1137                     {
1138                       const char *algo =
1139                         (gcry_md_test_algo (prefs->value)
1140                          ? num
1141                          : gcry_md_algo_name (prefs->value));
1142                       if(!problem)
1143                         check_prefs_warning(pk);
1144                       log_info(_("         \"%s\": preference for digest"
1145                                  " algorithm %s\n"), user, algo);
1146                       problem=1;
1147                     }
1148                 }
1149               else if(prefs->type==PREFTYPE_ZIP)
1150                 {
1151                   if(check_compress_algo (prefs->value))
1152                     {
1153                       const char *algo=compress_algo_to_string(prefs->value);
1154                       if(!problem)
1155                         check_prefs_warning(pk);
1156                       log_info(_("         \"%s\": preference for compression"
1157                                  " algorithm %s\n"),user,algo?algo:num);
1158                       problem=1;
1159                     }
1160                 }
1161             }
1162
1163           xfree(user);
1164         }
1165     }
1166
1167   if(problem)
1168     {
1169       log_info(_("it is strongly suggested that you update"
1170                  " your preferences and\n"));
1171       log_info(_("re-distribute this key to avoid potential algorithm"
1172                  " mismatch problems\n"));
1173
1174       if(!opt.batch)
1175         {
1176           strlist_t sl = NULL;
1177           strlist_t locusr = NULL;
1178           size_t fprlen=0;
1179           byte fpr[MAX_FINGERPRINT_LEN], *p;
1180           char username[(MAX_FINGERPRINT_LEN*2)+1];
1181           unsigned int i;
1182
1183           p = fingerprint_from_pk (pk,fpr,&fprlen);
1184           for(i=0;i<fprlen;i++,p++)
1185             sprintf(username+2*i,"%02X",*p);
1186           add_to_strlist(&locusr,username);
1187
1188           append_to_strlist(&sl,"updpref");
1189           append_to_strlist(&sl,"save");
1190
1191           keyedit_menu (ctrl, username, locusr, sl, 1, 1 );
1192           free_strlist(sl);
1193           free_strlist(locusr);
1194         }
1195       else if(!opt.quiet)
1196         log_info(_("you can update your preferences with:"
1197                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
1198     }
1199 }
1200
1201
1202 /* Helper for apply_*_filter in import.c and export.c.  */
1203 const char *
1204 impex_filter_getval (void *cookie, const char *propname)
1205 {
1206   /* FIXME: Malloc our static buffers and access them via PARM.  */
1207   struct impex_filter_parm_s *parm = cookie;
1208   ctrl_t ctrl = parm->ctrl;
1209   kbnode_t node = parm->node;
1210   static char numbuf[20];
1211   const char *result;
1212
1213   log_assert (ctrl && ctrl->magic == SERVER_CONTROL_MAGIC);
1214
1215   if (node->pkt->pkttype == PKT_USER_ID
1216       || node->pkt->pkttype == PKT_ATTRIBUTE)
1217     {
1218       PKT_user_id *uid = node->pkt->pkt.user_id;
1219
1220       if (!strcmp (propname, "uid"))
1221         result = uid->name;
1222       else if (!strcmp (propname, "mbox"))
1223         {
1224           if (!uid->mbox)
1225             {
1226               uid->mbox = mailbox_from_userid (uid->name);
1227             }
1228           result = uid->mbox;
1229         }
1230       else if (!strcmp (propname, "primary"))
1231         {
1232           result = uid->flags.primary? "1":"0";
1233         }
1234       else if (!strcmp (propname, "expired"))
1235         {
1236           result = uid->flags.expired? "1":"0";
1237         }
1238       else if (!strcmp (propname, "revoked"))
1239         {
1240           result = uid->flags.revoked? "1":"0";
1241         }
1242       else
1243         result = NULL;
1244     }
1245   else if (node->pkt->pkttype == PKT_SIGNATURE)
1246     {
1247       PKT_signature *sig = node->pkt->pkt.signature;
1248
1249       if (!strcmp (propname, "sig_created"))
1250         {
1251           snprintf (numbuf, sizeof numbuf, "%lu", (ulong)sig->timestamp);
1252           result = numbuf;
1253         }
1254       else if (!strcmp (propname, "sig_created_d"))
1255         {
1256           result = datestr_from_sig (sig);
1257         }
1258       else if (!strcmp (propname, "sig_algo"))
1259         {
1260           snprintf (numbuf, sizeof numbuf, "%d", sig->pubkey_algo);
1261           result = numbuf;
1262         }
1263       else if (!strcmp (propname, "sig_digest_algo"))
1264         {
1265           snprintf (numbuf, sizeof numbuf, "%d", sig->digest_algo);
1266           result = numbuf;
1267         }
1268       else if (!strcmp (propname, "expired"))
1269         {
1270           result = sig->flags.expired? "1":"0";
1271         }
1272       else
1273         result = NULL;
1274     }
1275   else if (node->pkt->pkttype == PKT_PUBLIC_KEY
1276            || node->pkt->pkttype == PKT_SECRET_KEY
1277            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1278            || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1279     {
1280       PKT_public_key *pk = node->pkt->pkt.public_key;
1281
1282       if (!strcmp (propname, "secret"))
1283         {
1284           result = (node->pkt->pkttype == PKT_SECRET_KEY
1285                     || node->pkt->pkttype == PKT_SECRET_SUBKEY)? "1":"0";
1286         }
1287       else if (!strcmp (propname, "key_algo"))
1288         {
1289           snprintf (numbuf, sizeof numbuf, "%d", pk->pubkey_algo);
1290           result = numbuf;
1291         }
1292       else if (!strcmp (propname, "key_created"))
1293         {
1294           snprintf (numbuf, sizeof numbuf, "%lu", (ulong)pk->timestamp);
1295           result = numbuf;
1296         }
1297       else if (!strcmp (propname, "key_created_d"))
1298         {
1299           result = datestr_from_pk (pk);
1300         }
1301       else if (!strcmp (propname, "expired"))
1302         {
1303           result = pk->has_expired? "1":"0";
1304         }
1305       else if (!strcmp (propname, "revoked"))
1306         {
1307           result = pk->flags.revoked? "1":"0";
1308         }
1309       else if (!strcmp (propname, "disabled"))
1310         {
1311           result = pk_is_disabled (pk)? "1":"0";
1312         }
1313       else
1314         result = NULL;
1315     }
1316   else
1317     result = NULL;
1318
1319   return result;
1320 }
1321
1322
1323 /*
1324  * Apply the keep-uid filter to the keyblock.  The deleted nodes are
1325  * marked and thus the caller should call commit_kbnode afterwards.
1326  * KEYBLOCK must not have any blocks marked as deleted.
1327  */
1328 static void
1329 apply_keep_uid_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
1330 {
1331   kbnode_t node;
1332   struct impex_filter_parm_s parm;
1333
1334   parm.ctrl = ctrl;
1335
1336   for (node = keyblock->next; node; node = node->next )
1337     {
1338       if (node->pkt->pkttype == PKT_USER_ID)
1339         {
1340           parm.node = node;
1341           if (!recsel_select (selector, impex_filter_getval, &parm))
1342             {
1343
1344               /* log_debug ("keep-uid: deleting '%s'\n", */
1345               /*            node->pkt->pkt.user_id->name); */
1346               /* The UID packet and all following packets up to the
1347                * next UID or a subkey.  */
1348               delete_kbnode (node);
1349               for (; node->next
1350                      && node->next->pkt->pkttype != PKT_USER_ID
1351                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1352                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
1353                    node = node->next)
1354                 delete_kbnode (node->next);
1355             }
1356           /* else */
1357           /*   log_debug ("keep-uid: keeping '%s'\n", */
1358           /*              node->pkt->pkt.user_id->name); */
1359         }
1360     }
1361 }
1362
1363
1364 /*
1365  * Apply the drop-sig filter to the keyblock.  The deleted nodes are
1366  * marked and thus the caller should call commit_kbnode afterwards.
1367  * KEYBLOCK must not have any blocks marked as deleted.
1368  */
1369 static void
1370 apply_drop_sig_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
1371 {
1372   kbnode_t node;
1373   int active = 0;
1374   u32 main_keyid[2];
1375   PKT_signature *sig;
1376   struct impex_filter_parm_s parm;
1377
1378   parm.ctrl = ctrl;
1379
1380   keyid_from_pk (keyblock->pkt->pkt.public_key, main_keyid);
1381
1382   /* Loop over all signatures for user id and attribute packets which
1383    * are not self signatures.  */
1384   for (node = keyblock->next; node; node = node->next )
1385     {
1386       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1387           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1388         break; /* ready.  */
1389       if (node->pkt->pkttype == PKT_USER_ID
1390           || node->pkt->pkttype == PKT_ATTRIBUTE)
1391         active = 1;
1392       if (!active)
1393         continue;
1394       if (node->pkt->pkttype != PKT_SIGNATURE)
1395         continue;
1396
1397       sig = node->pkt->pkt.signature;
1398       if (main_keyid[0] == sig->keyid[0] || main_keyid[1] == sig->keyid[1])
1399         continue;  /* Skip self-signatures.  */
1400
1401       if (IS_UID_SIG(sig) || IS_UID_REV(sig))
1402         {
1403           parm.node = node;
1404           if (recsel_select (selector, impex_filter_getval, &parm))
1405             delete_kbnode (node);
1406         }
1407     }
1408 }
1409
1410
1411 /* Insert a key origin into a public key packet.  */
1412 static gpg_error_t
1413 insert_key_origin_pk (PKT_public_key *pk, u32 curtime,
1414                       int origin, const char *url)
1415 {
1416   if (origin == KEYORG_WKD || origin == KEYORG_DANE)
1417     {
1418       /* For WKD and DANE we insert origin information also for the
1419        * key but we don't record the URL because we have have no use
1420        * for that: An update using a keyserver has higher precedence
1421        * and will thus update this origin info.  For refresh using WKD
1422        * or DANE we need to go via the User ID anyway.  Recall that we
1423        * are only inserting a new key. */
1424       pk->keyorg = origin;
1425       pk->keyupdate = curtime;
1426     }
1427   else if (origin == KEYORG_KS && url)
1428     {
1429       /* If the key was retrieved from a keyserver using a fingerprint
1430        * request we add the meta information.  Note that the use of a
1431        * fingerprint needs to be enforced by the caller of the import
1432        * function.  This is commonly triggered by verifying a modern
1433        * signature which has an Issuer Fingerprint signature
1434        * subpacket.  */
1435       pk->keyorg = origin;
1436       pk->keyupdate = curtime;
1437       xfree (pk->updateurl);
1438       pk->updateurl = xtrystrdup (url);
1439       if (!pk->updateurl)
1440         return gpg_error_from_syserror ();
1441     }
1442   else if (origin == KEYORG_FILE)
1443     {
1444       pk->keyorg = origin;
1445       pk->keyupdate = curtime;
1446     }
1447   else if (origin == KEYORG_URL)
1448     {
1449       pk->keyorg = origin;
1450       pk->keyupdate = curtime;
1451       if (url)
1452         {
1453           xfree (pk->updateurl);
1454           pk->updateurl = xtrystrdup (url);
1455           if (!pk->updateurl)
1456             return gpg_error_from_syserror ();
1457         }
1458     }
1459
1460   return 0;
1461 }
1462
1463
1464 /* Insert a key origin into a user id packet.  */
1465 static gpg_error_t
1466 insert_key_origin_uid (PKT_user_id *uid, u32 curtime,
1467                        int origin, const char *url)
1468
1469 {
1470   if (origin == KEYORG_WKD || origin == KEYORG_DANE)
1471     {
1472       /* We insert origin information on a UID only when we received
1473        * them via the Web Key Directory or a DANE record.  The key we
1474        * receive here from the WKD has been filtered to contain only
1475        * the user ID as looked up in the WKD.  For a DANE origin we
1476        * this should also be the case.  Thus we will see here only one
1477        * user id.  */
1478       uid->keyorg = origin;
1479       uid->keyupdate = curtime;
1480       if (url)
1481         {
1482           xfree (uid->updateurl);
1483           uid->updateurl = xtrystrdup (url);
1484           if (!uid->updateurl)
1485             return gpg_error_from_syserror ();
1486         }
1487     }
1488   else if (origin == KEYORG_KS && url)
1489     {
1490       /* If the key was retrieved from a keyserver using a fingerprint
1491        * request we mark that also in the user ID.  However we do not
1492        * store the keyserver URL in the UID.  A later update (merge)
1493        * from a more trusted source will replace this info.  */
1494       uid->keyorg = origin;
1495       uid->keyupdate = curtime;
1496     }
1497   else if (origin == KEYORG_FILE)
1498     {
1499       uid->keyorg = origin;
1500       uid->keyupdate = curtime;
1501     }
1502   else if (origin == KEYORG_URL)
1503     {
1504       uid->keyorg = origin;
1505       uid->keyupdate = curtime;
1506     }
1507
1508   return 0;
1509 }
1510
1511
1512 /* Apply meta data to KEYBLOCK.  This sets the origin of the key to
1513  * ORIGIN and the updateurl to URL.  Note that this function is only
1514  * used for a new key, that is not when we are merging keys.  */
1515 static gpg_error_t
1516 insert_key_origin (kbnode_t keyblock, int origin, const char *url)
1517 {
1518   gpg_error_t err;
1519   kbnode_t node;
1520   u32 curtime = make_timestamp ();
1521
1522   for (node = keyblock; node; node = node->next)
1523     {
1524       if (is_deleted_kbnode (node))
1525         ;
1526       else if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1527         {
1528           err = insert_key_origin_pk (node->pkt->pkt.public_key, curtime,
1529                                       origin, url);
1530           if (err)
1531             return err;
1532         }
1533       else if (node->pkt->pkttype == PKT_USER_ID)
1534         {
1535           err = insert_key_origin_uid (node->pkt->pkt.user_id, curtime,
1536                                        origin, url);
1537           if (err)
1538             return err;
1539         }
1540     }
1541
1542   return 0;
1543 }
1544
1545
1546 /* Update meta data on KEYBLOCK.  This updates the key origin on the
1547  * public key according to ORIGIN and URL.  The UIDs are already
1548  * updated when this function is called.  */
1549 static gpg_error_t
1550 update_key_origin (kbnode_t keyblock, u32 curtime, int origin, const char *url)
1551 {
1552   PKT_public_key *pk;
1553
1554   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
1555   pk = keyblock->pkt->pkt.public_key;
1556
1557   if (pk->keyupdate > curtime)
1558     ; /* Don't do it for a time warp.  */
1559   else if (origin == KEYORG_WKD || origin == KEYORG_DANE)
1560     {
1561       /* We only update the origin info if they either have never been
1562        * set or are the origin was the same as the new one.  If this
1563        * is WKD we also update the UID to show from which user id this
1564        * was updated.  */
1565       if (!pk->keyorg || pk->keyorg == KEYORG_WKD || pk->keyorg == KEYORG_DANE)
1566         {
1567           pk->keyorg = origin;
1568           pk->keyupdate = curtime;
1569           xfree (pk->updateurl);
1570           pk->updateurl = NULL;
1571           if (origin == KEYORG_WKD && url)
1572             {
1573               pk->updateurl = xtrystrdup (url);
1574               if (!pk->updateurl)
1575                 return gpg_error_from_syserror ();
1576             }
1577         }
1578     }
1579   else if (origin == KEYORG_KS)
1580     {
1581       /* All updates from a keyserver are considered to have the
1582        * freshed key.  Thus we always set the new key origin.  */
1583       pk->keyorg = origin;
1584       pk->keyupdate = curtime;
1585       xfree (pk->updateurl);
1586       pk->updateurl = NULL;
1587       if (url)
1588         {
1589           pk->updateurl = xtrystrdup (url);
1590           if (!pk->updateurl)
1591             return gpg_error_from_syserror ();
1592         }
1593     }
1594   else if (origin == KEYORG_FILE)
1595     {
1596       /* Updates from a file are considered to be fresh.  */
1597       pk->keyorg = origin;
1598       pk->keyupdate = curtime;
1599       xfree (pk->updateurl);
1600       pk->updateurl = NULL;
1601     }
1602   else if (origin == KEYORG_URL)
1603     {
1604       /* Updates from a URL are considered to be fresh.  */
1605       pk->keyorg = origin;
1606       pk->keyupdate = curtime;
1607       xfree (pk->updateurl);
1608       pk->updateurl = NULL;
1609       if (url)
1610         {
1611           pk->updateurl = xtrystrdup (url);
1612           if (!pk->updateurl)
1613             return gpg_error_from_syserror ();
1614         }
1615     }
1616
1617   return 0;
1618 }
1619
1620
1621 /*
1622  * Try to import one keyblock. Return an error only in serious cases,
1623  * but never for an invalid keyblock.  It uses log_error to increase
1624  * the internal errorcount, so that invalid input can be detected by
1625  * programs which called gpg.  If SILENT is no messages are printed -
1626  * even most error messages are suppressed.  ORIGIN is the origin of
1627  * the key (0 for unknown) and URL the corresponding URL.
1628  */
1629 static gpg_error_t
1630 import_one (ctrl_t ctrl,
1631             kbnode_t keyblock, struct import_stats_s *stats,
1632             unsigned char **fpr, size_t *fpr_len, unsigned int options,
1633             int from_sk, int silent,
1634             import_screener_t screener, void *screener_arg,
1635             int origin, const char *url)
1636 {
1637   gpg_error_t err = 0;
1638   PKT_public_key *pk;
1639   kbnode_t node, uidnode;
1640   kbnode_t keyblock_orig = NULL;
1641   byte fpr2[MAX_FINGERPRINT_LEN];
1642   size_t fpr2len;
1643   u32 keyid[2];
1644   int new_key = 0;
1645   int mod_key = 0;
1646   int same_key = 0;
1647   int non_self = 0;
1648   size_t an;
1649   char pkstrbuf[PUBKEY_STRING_SIZE];
1650   int merge_keys_done = 0;
1651   int any_filter = 0;
1652   KEYDB_HANDLE hd = NULL;
1653
1654   /* Get the key and print some info about it. */
1655   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1656   if (!node )
1657     BUG();
1658
1659   pk = node->pkt->pkt.public_key;
1660
1661   fingerprint_from_pk (pk, fpr2, &fpr2len);
1662   for (an = fpr2len; an < MAX_FINGERPRINT_LEN; an++)
1663     fpr2[an] = 0;
1664   keyid_from_pk( pk, keyid );
1665   uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1666
1667   if (opt.verbose && !opt.interactive && !silent)
1668     {
1669       log_info( "pub  %s/%s %s  ",
1670                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
1671                 keystr_from_pk(pk), datestr_from_pk(pk) );
1672       if (uidnode)
1673         print_utf8_buffer (log_get_stream (),
1674                            uidnode->pkt->pkt.user_id->name,
1675                            uidnode->pkt->pkt.user_id->len );
1676       log_printf ("\n");
1677     }
1678
1679
1680   if (!uidnode )
1681     {
1682       if (!silent)
1683         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
1684       return 0;
1685     }
1686
1687   if (screener && screener (keyblock, screener_arg))
1688     {
1689       log_error (_("key %s: %s\n"), keystr_from_pk (pk),
1690                  _("rejected by import screener"));
1691       return 0;
1692     }
1693
1694   if (opt.interactive && !silent)
1695     {
1696       if (is_status_enabled())
1697         print_import_check (pk, uidnode->pkt->pkt.user_id);
1698       merge_keys_and_selfsig (ctrl, keyblock);
1699       tty_printf ("\n");
1700       show_basic_key_info (ctrl, keyblock);
1701       tty_printf ("\n");
1702       if (!cpr_get_answer_is_yes ("import.okay",
1703                                   "Do you want to import this key? (y/N) "))
1704         return 0;
1705     }
1706
1707   collapse_uids(&keyblock);
1708
1709   /* Clean the key that we're about to import, to cut down on things
1710      that we have to clean later.  This has no practical impact on the
1711      end result, but does result in less logging which might confuse
1712      the user. */
1713   if (options&IMPORT_CLEAN)
1714     clean_key (ctrl, keyblock,
1715                opt.verbose, (options&IMPORT_MINIMAL), NULL, NULL);
1716
1717   clear_kbnode_flags( keyblock );
1718
1719   if ((options&IMPORT_REPAIR_PKS_SUBKEY_BUG)
1720       && fix_pks_corruption (ctrl, keyblock)
1721       && opt.verbose)
1722     log_info (_("key %s: PKS subkey corruption repaired\n"),
1723               keystr_from_pk(pk));
1724
1725   if ((options & IMPORT_REPAIR_KEYS))
1726     key_check_all_keysigs (ctrl, 1, keyblock, 0, 0);
1727
1728   if (chk_self_sigs (ctrl, keyblock, keyid, &non_self))
1729     return 0;  /* Invalid keyblock - error already printed.  */
1730
1731   /* If we allow such a thing, mark unsigned uids as valid */
1732   if (opt.allow_non_selfsigned_uid)
1733     {
1734       for (node=keyblock; node; node = node->next )
1735         if (node->pkt->pkttype == PKT_USER_ID
1736             && !(node->flag & NODE_GOOD_SELFSIG)
1737             && !(node->flag & NODE_BAD_SELFSIG) )
1738           {
1739             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
1740                                       node->pkt->pkt.user_id->len,0);
1741             /* Fake a good signature status for the user id.  */
1742             node->flag |= NODE_GOOD_SELFSIG;
1743             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
1744                       keystr_from_pk(pk),user);
1745             xfree(user);
1746           }
1747     }
1748
1749   if (!delete_inv_parts (ctrl, keyblock, keyid, options ) )
1750     {
1751       if (!silent)
1752         {
1753           log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
1754           if (!opt.quiet )
1755             log_info(_("this may be caused by a missing self-signature\n"));
1756         }
1757       stats->no_user_id++;
1758       return 0;
1759     }
1760
1761   /* Get rid of deleted nodes.  */
1762   commit_kbnode (&keyblock);
1763
1764   /* Apply import filter.  */
1765   if (import_filter.keep_uid)
1766     {
1767       apply_keep_uid_filter (ctrl, keyblock, import_filter.keep_uid);
1768       commit_kbnode (&keyblock);
1769       any_filter = 1;
1770     }
1771   if (import_filter.drop_sig)
1772     {
1773       apply_drop_sig_filter (ctrl, keyblock, import_filter.drop_sig);
1774       commit_kbnode (&keyblock);
1775       any_filter = 1;
1776     }
1777
1778   /* If we ran any filter we need to check that at least one user id
1779    * is left in the keyring.  Note that we do not use log_error in
1780    * this case. */
1781   if (any_filter && !any_uid_left (keyblock))
1782     {
1783       if (!opt.quiet )
1784         log_info ( _("key %s: no valid user IDs\n"), keystr_from_pk (pk));
1785       stats->no_user_id++;
1786       return 0;
1787     }
1788
1789   /* Show the key in the form it is merged or inserted.  We skip this
1790    * if "import-export" is also active without --armor or the output
1791    * file has explicily been given. */
1792   if ((options & IMPORT_SHOW)
1793       && !((options & IMPORT_EXPORT) && !opt.armor && !opt.outfile))
1794     {
1795       merge_keys_and_selfsig (ctrl, keyblock);
1796       merge_keys_done = 1;
1797       /* Note that we do not want to show the validity because the key
1798        * has not yet imported.  */
1799       list_keyblock_direct (ctrl, keyblock, from_sk, 0,
1800                             opt.fingerprint || opt.with_fingerprint, 1);
1801       es_fflush (es_stdout);
1802     }
1803
1804   /* Write the keyblock to the output and do not actually import.  */
1805   if ((options & IMPORT_EXPORT))
1806     {
1807       if (!merge_keys_done)
1808         {
1809           merge_keys_and_selfsig (ctrl, keyblock);
1810           merge_keys_done = 1;
1811         }
1812       err = write_keyblock_to_output (keyblock, opt.armor, opt.export_options);
1813       goto leave;
1814     }
1815
1816   if (opt.dry_run || (options & IMPORT_DRY_RUN))
1817     goto leave;
1818
1819   /* Do we have this key already in one of our pubrings ? */
1820   err = get_keyblock_byfprint_fast (&keyblock_orig, &hd,
1821                                     fpr2, fpr2len, 1/*locked*/);
1822   if ((err
1823        && gpg_err_code (err) != GPG_ERR_NO_PUBKEY
1824        && gpg_err_code (err) != GPG_ERR_UNUSABLE_PUBKEY)
1825       || !hd)
1826     {
1827       /* The !hd above is to catch a misbehaving function which
1828        * returns NO_PUBKEY for failing to allocate a handle.  */
1829       if (!silent)
1830         log_error (_("key %s: public key not found: %s\n"),
1831                    keystr(keyid), gpg_strerror (err));
1832     }
1833   else if (err && (opt.import_options&IMPORT_MERGE_ONLY) )
1834     {
1835       if (opt.verbose && !silent )
1836         log_info( _("key %s: new key - skipped\n"), keystr(keyid));
1837       err = 0;
1838       stats->skipped_new_keys++;
1839     }
1840   else if (err)  /* Insert this key. */
1841     {
1842       /* Note: ERR can only be NO_PUBKEY or UNUSABLE_PUBKEY.  */
1843       int n_sigs_cleaned, n_uids_cleaned;
1844
1845       err = keydb_locate_writable (hd);
1846       if (err)
1847         {
1848           log_error (_("no writable keyring found: %s\n"), gpg_strerror (err));
1849           err = gpg_error (GPG_ERR_GENERAL);
1850           goto leave;
1851         }
1852       if (opt.verbose > 1 )
1853         log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );
1854
1855       if ((options & IMPORT_CLEAN))
1856         clean_key (ctrl, keyblock, opt.verbose, (options&IMPORT_MINIMAL),
1857                    &n_uids_cleaned,&n_sigs_cleaned);
1858
1859       /* Unless we are in restore mode apply meta data to the
1860        * keyblock.  Note that this will never change the first packet
1861        * and thus the address of KEYBLOCK won't change.  */
1862       if ( !(options & IMPORT_RESTORE) )
1863         {
1864           err = insert_key_origin (keyblock, origin, url);
1865           if (err)
1866             {
1867               log_error ("insert_key_origin failed: %s\n", gpg_strerror (err));
1868               err = gpg_error (GPG_ERR_GENERAL);
1869               goto leave;
1870             }
1871         }
1872
1873       err = keydb_insert_keyblock (hd, keyblock );
1874       if (err)
1875         log_error (_("error writing keyring '%s': %s\n"),
1876                    keydb_get_resource_name (hd), gpg_strerror (err));
1877       else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
1878         {
1879           /* This should not be possible since we delete the
1880              ownertrust when a key is deleted, but it can happen if
1881              the keyring and trustdb are out of sync.  It can also
1882              be made to happen with the trusted-key command and by
1883              importing and locally exported key. */
1884
1885           clear_ownertrusts (ctrl, pk);
1886           if (non_self)
1887             revalidation_mark (ctrl);
1888         }
1889
1890       /* Release the handle and thus unlock the keyring asap.  */
1891       keydb_release (hd);
1892       hd = NULL;
1893
1894       /* We are ready.  */
1895       if (!opt.quiet && !silent)
1896         {
1897           char *p = get_user_id_byfpr_native (ctrl, fpr2);
1898           log_info (_("key %s: public key \"%s\" imported\n"),
1899                     keystr(keyid), p);
1900           xfree(p);
1901         }
1902       if (is_status_enabled())
1903         {
1904           char *us = get_long_user_id_string (ctrl, keyid);
1905           write_status_text( STATUS_IMPORTED, us );
1906           xfree(us);
1907           print_import_ok (pk, 1);
1908         }
1909       stats->imported++;
1910       new_key = 1;
1911     }
1912   else /* Key already exists - merge.  */
1913     {
1914       int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
1915       u32 curtime = make_timestamp ();
1916
1917       /* Compare the original against the new key; just to be sure nothing
1918        * weird is going on */
1919       if (cmp_public_keys (keyblock_orig->pkt->pkt.public_key, pk))
1920         {
1921           if (!silent)
1922             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
1923           goto leave;
1924         }
1925
1926       /* Make sure the original direct key sigs are all sane.  */
1927       n_sigs_cleaned = fix_bad_direct_key_sigs (ctrl, keyblock_orig, keyid);
1928       if (n_sigs_cleaned)
1929         commit_kbnode (&keyblock_orig);
1930
1931       /* Try to merge KEYBLOCK into KEYBLOCK_ORIG.  */
1932       clear_kbnode_flags( keyblock_orig );
1933       clear_kbnode_flags( keyblock );
1934       n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
1935       err = merge_blocks (ctrl, options, keyblock_orig, keyblock, keyid,
1936                           curtime, origin, url,
1937                           &n_uids, &n_sigs, &n_subk );
1938       if (err)
1939         goto leave;
1940
1941       if ((options & IMPORT_CLEAN))
1942         clean_key (ctrl, keyblock_orig, opt.verbose, (options&IMPORT_MINIMAL),
1943                    &n_uids_cleaned,&n_sigs_cleaned);
1944
1945       if (n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned)
1946         {
1947           /* Unless we are in restore mode apply meta data to the
1948            * keyblock.  Note that this will never change the first packet
1949            * and thus the address of KEYBLOCK won't change.  */
1950           if ( !(options & IMPORT_RESTORE) )
1951             {
1952               err = update_key_origin (keyblock_orig, curtime, origin, url);
1953               if (err)
1954                 {
1955                   log_error ("update_key_origin failed: %s\n",
1956                              gpg_strerror (err));
1957                   goto leave;
1958                 }
1959             }
1960
1961           mod_key = 1;
1962           /* KEYBLOCK_ORIG has been updated; write */
1963           err = keydb_update_keyblock (ctrl, hd, keyblock_orig);
1964           if (err)
1965             log_error (_("error writing keyring '%s': %s\n"),
1966                        keydb_get_resource_name (hd), gpg_strerror (err));
1967           else if (non_self)
1968             revalidation_mark (ctrl);
1969
1970           /* Release the handle and thus unlock the keyring asap.  */
1971           keydb_release (hd);
1972           hd = NULL;
1973
1974           /* We are ready.  */
1975           if (!opt.quiet && !silent)
1976             {
1977               char *p = get_user_id_byfpr_native (ctrl, fpr2);
1978               if (n_uids == 1 )
1979                 log_info( _("key %s: \"%s\" 1 new user ID\n"),
1980                           keystr(keyid),p);
1981               else if (n_uids )
1982                 log_info( _("key %s: \"%s\" %d new user IDs\n"),
1983                           keystr(keyid),p,n_uids);
1984               if (n_sigs == 1 )
1985                 log_info( _("key %s: \"%s\" 1 new signature\n"),
1986                           keystr(keyid), p);
1987               else if (n_sigs )
1988                 log_info( _("key %s: \"%s\" %d new signatures\n"),
1989                           keystr(keyid), p, n_sigs );
1990               if (n_subk == 1 )
1991                 log_info( _("key %s: \"%s\" 1 new subkey\n"),
1992                           keystr(keyid), p);
1993               else if (n_subk )
1994                 log_info( _("key %s: \"%s\" %d new subkeys\n"),
1995                           keystr(keyid), p, n_subk );
1996               if (n_sigs_cleaned==1)
1997                 log_info(_("key %s: \"%s\" %d signature cleaned\n"),
1998                          keystr(keyid),p,n_sigs_cleaned);
1999               else if (n_sigs_cleaned)
2000                 log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
2001                          keystr(keyid),p,n_sigs_cleaned);
2002               if (n_uids_cleaned==1)
2003                 log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
2004                          keystr(keyid),p,n_uids_cleaned);
2005               else if (n_uids_cleaned)
2006                 log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
2007                          keystr(keyid),p,n_uids_cleaned);
2008               xfree(p);
2009             }
2010
2011           stats->n_uids +=n_uids;
2012           stats->n_sigs +=n_sigs;
2013           stats->n_subk +=n_subk;
2014           stats->n_sigs_cleaned +=n_sigs_cleaned;
2015           stats->n_uids_cleaned +=n_uids_cleaned;
2016
2017           if (is_status_enabled () && !silent)
2018             print_import_ok (pk, ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
2019         }
2020       else
2021         {
2022           /* Release the handle and thus unlock the keyring asap.  */
2023           keydb_release (hd);
2024           hd = NULL;
2025
2026           /* Fixme: we do not track the time we last checked a key for
2027            * updates.  To do this we would need to rewrite even the
2028            * keys which have no changes.  */
2029           same_key = 1;
2030           if (is_status_enabled ())
2031             print_import_ok (pk, 0);
2032
2033           if (!opt.quiet && !silent)
2034             {
2035               char *p = get_user_id_byfpr_native (ctrl, fpr2);
2036               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
2037               xfree(p);
2038             }
2039
2040           stats->unchanged++;
2041         }
2042     }
2043
2044  leave:
2045   keydb_release (hd);
2046   if (mod_key || new_key || same_key)
2047     {
2048       /* A little explanation for this: we fill in the fingerprint
2049          when importing keys as it can be useful to know the
2050          fingerprint in certain keyserver-related cases (a keyserver
2051          asked for a particular name, but the key doesn't have that
2052          name).  However, in cases where we're importing more than
2053          one key at a time, we cannot know which key to fingerprint.
2054          In these cases, rather than guessing, we do not
2055          fingerprinting at all, and we must hope the user ID on the
2056          keys are useful.  Note that we need to do this for new
2057          keys, merged keys and even for unchanged keys.  This is
2058          required because for example the --auto-key-locate feature
2059          may import an already imported key and needs to know the
2060          fingerprint of the key in all cases.  */
2061       if (fpr)
2062         {
2063           xfree (*fpr);
2064           /* Note that we need to compare against 0 here because
2065              COUNT gets only incremented after returning from this
2066              function.  */
2067           if (!stats->count)
2068             *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
2069           else
2070             *fpr = NULL;
2071         }
2072     }
2073
2074   /* Now that the key is definitely incorporated into the keydb, we
2075      need to check if a designated revocation is present or if the
2076      prefs are not rational so we can warn the user. */
2077
2078   if (mod_key)
2079     {
2080       revocation_present (ctrl, keyblock_orig);
2081       if (!from_sk && have_secret_key_with_kid (keyid))
2082         check_prefs (ctrl, keyblock_orig);
2083     }
2084   else if (new_key)
2085     {
2086       revocation_present (ctrl, keyblock);
2087       if (!from_sk && have_secret_key_with_kid (keyid))
2088         check_prefs (ctrl, keyblock);
2089     }
2090
2091   release_kbnode( keyblock_orig );
2092
2093   return err;
2094 }
2095
2096
2097 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
2098    function prints diagnostics and returns an error code.  If BATCH is
2099    true the secret keys are stored by gpg-agent in the transfer format
2100    (i.e. no re-protection and aksing for passphrases). */
2101 gpg_error_t
2102 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
2103                       kbnode_t sec_keyblock, int batch, int force)
2104 {
2105   gpg_error_t err = 0;
2106   void *kek = NULL;
2107   size_t keklen;
2108   kbnode_t ctx = NULL;
2109   kbnode_t node;
2110   PKT_public_key *main_pk, *pk;
2111   struct seckey_info *ski;
2112   int nskey;
2113   membuf_t mbuf;
2114   int i, j;
2115   void *format_args[2*PUBKEY_MAX_NSKEY];
2116   gcry_sexp_t skey, prot, tmpsexp;
2117   gcry_sexp_t curve = NULL;
2118   unsigned char *transferkey = NULL;
2119   size_t transferkeylen;
2120   gcry_cipher_hd_t cipherhd = NULL;
2121   unsigned char *wrappedkey = NULL;
2122   size_t wrappedkeylen;
2123   char *cache_nonce = NULL;
2124   int stub_key_skipped = 0;
2125
2126   /* Get the current KEK.  */
2127   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
2128   if (err)
2129     {
2130       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
2131       goto leave;
2132     }
2133
2134   /* Prepare a cipher context.  */
2135   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2136                           GCRY_CIPHER_MODE_AESWRAP, 0);
2137   if (!err)
2138     err = gcry_cipher_setkey (cipherhd, kek, keklen);
2139   if (err)
2140     goto leave;
2141   xfree (kek);
2142   kek = NULL;
2143
2144   main_pk = NULL;
2145   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
2146     {
2147       if (node->pkt->pkttype != PKT_SECRET_KEY
2148           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2149         continue;
2150       pk = node->pkt->pkt.public_key;
2151       if (!main_pk)
2152         main_pk = pk;
2153
2154       /* Make sure the keyids are available.  */
2155       keyid_from_pk (pk, NULL);
2156       if (node->pkt->pkttype == PKT_SECRET_KEY)
2157         {
2158           pk->main_keyid[0] = pk->keyid[0];
2159           pk->main_keyid[1] = pk->keyid[1];
2160         }
2161       else
2162         {
2163           pk->main_keyid[0] = main_pk->keyid[0];
2164           pk->main_keyid[1] = main_pk->keyid[1];
2165         }
2166
2167
2168       ski = pk->seckey_info;
2169       if (!ski)
2170         BUG ();
2171
2172       if (stats)
2173         {
2174           stats->count++;
2175           stats->secret_read++;
2176         }
2177
2178       /* We ignore stub keys.  The way we handle them in other parts
2179          of the code is by asking the agent whether any secret key is
2180          available for a given keyblock and then concluding that we
2181          have a secret key; all secret (sub)keys of the keyblock the
2182          agent does not know of are then stub keys.  This works also
2183          for card stub keys.  The learn command or the card-status
2184          command may be used to check with the agent whether a card
2185          has been inserted and a stub key is in turn generated by the
2186          agent.  */
2187       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2188         {
2189           stub_key_skipped = 1;
2190           continue;
2191         }
2192
2193       /* Convert our internal secret key object into an S-expression.  */
2194       nskey = pubkey_get_nskey (pk->pubkey_algo);
2195       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
2196         {
2197           err = gpg_error (GPG_ERR_BAD_SECKEY);
2198           log_error ("internal error: %s\n", gpg_strerror (err));
2199           goto leave;
2200         }
2201
2202       init_membuf (&mbuf, 50);
2203       put_membuf_str (&mbuf, "(skey");
2204       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
2205           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
2206           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
2207         {
2208           /* The ECC case.  */
2209           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
2210           if (!curvestr)
2211             err = gpg_error_from_syserror ();
2212           else
2213             {
2214               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
2215               gcry_sexp_release (curve);
2216               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
2217                                      curvename?curvename:curvestr);
2218               xfree (curvestr);
2219               if (!err)
2220                 {
2221                   j = 0;
2222                   /* Append the public key element Q.  */
2223                   put_membuf_str (&mbuf, " _ %m");
2224                   format_args[j++] = pk->pkey + 1;
2225
2226                   /* Append the secret key element D.  For ECDH we
2227                      skip PKEY[2] because this holds the KEK which is
2228                      not needed by gpg-agent.  */
2229                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
2230                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
2231                     put_membuf_str (&mbuf, " e %m");
2232                   else
2233                     put_membuf_str (&mbuf, " _ %m");
2234                   format_args[j++] = pk->pkey + i;
2235                 }
2236             }
2237         }
2238       else
2239         {
2240           /* Standard case for the old (non-ECC) algorithms.  */
2241           for (i=j=0; i < nskey; i++)
2242             {
2243               if (!pk->pkey[i])
2244                 continue; /* Protected keys only have NPKEY+1 elements.  */
2245
2246               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
2247                 put_membuf_str (&mbuf, " e %m");
2248               else
2249                 put_membuf_str (&mbuf, " _ %m");
2250               format_args[j++] = pk->pkey + i;
2251             }
2252         }
2253       put_membuf_str (&mbuf, ")");
2254       put_membuf (&mbuf, "", 1);
2255       if (err)
2256         xfree (get_membuf (&mbuf, NULL));
2257       else
2258         {
2259           char *format = get_membuf (&mbuf, NULL);
2260           if (!format)
2261             err = gpg_error_from_syserror ();
2262           else
2263             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
2264           xfree (format);
2265         }
2266       if (err)
2267         {
2268           log_error ("error building skey array: %s\n", gpg_strerror (err));
2269           goto leave;
2270         }
2271
2272       if (ski->is_protected)
2273         {
2274           char countbuf[35];
2275
2276           /* FIXME: Support AEAD */
2277           /* Note that the IVLEN may be zero if we are working on a
2278              dummy key.  We can't express that in an S-expression and
2279              thus we send dummy data for the IV.  */
2280           snprintf (countbuf, sizeof countbuf, "%lu",
2281                     (unsigned long)ski->s2k.count);
2282           err = gcry_sexp_build
2283             (&prot, NULL,
2284              " (protection %s %s %b %d %s %b %s)\n",
2285              ski->sha1chk? "sha1":"sum",
2286              openpgp_cipher_algo_name (ski->algo),
2287              ski->ivlen? (int)ski->ivlen:1,
2288              ski->ivlen? ski->iv: (const unsigned char*)"X",
2289              ski->s2k.mode,
2290              openpgp_md_algo_name (ski->s2k.hash_algo),
2291              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
2292              countbuf);
2293         }
2294       else
2295         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
2296
2297       tmpsexp = NULL;
2298       xfree (transferkey);
2299       transferkey = NULL;
2300       if (!err)
2301         err = gcry_sexp_build (&tmpsexp, NULL,
2302                                "(openpgp-private-key\n"
2303                                " (version %d)\n"
2304                                " (algo %s)\n"
2305                                " %S%S\n"
2306                                " (csum %d)\n"
2307                                " %S)\n",
2308                                pk->version,
2309                                openpgp_pk_algo_name (pk->pubkey_algo),
2310                                curve, skey,
2311                                (int)(unsigned long)ski->csum, prot);
2312       gcry_sexp_release (skey);
2313       gcry_sexp_release (prot);
2314       if (!err)
2315         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
2316       gcry_sexp_release (tmpsexp);
2317       if (err)
2318         {
2319           log_error ("error building transfer key: %s\n", gpg_strerror (err));
2320           goto leave;
2321         }
2322
2323       /* Wrap the key.  */
2324       wrappedkeylen = transferkeylen + 8;
2325       xfree (wrappedkey);
2326       wrappedkey = xtrymalloc (wrappedkeylen);
2327       if (!wrappedkey)
2328         err = gpg_error_from_syserror ();
2329       else
2330         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
2331                                    transferkey, transferkeylen);
2332       if (err)
2333         goto leave;
2334       xfree (transferkey);
2335       transferkey = NULL;
2336
2337       /* Send the wrapped key to the agent.  */
2338       {
2339         char *desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_IMPORT, 1);
2340         err = agent_import_key (ctrl, desc, &cache_nonce,
2341                                 wrappedkey, wrappedkeylen, batch, force,
2342                                 pk->keyid, pk->main_keyid, pk->pubkey_algo);
2343         xfree (desc);
2344       }
2345       if (!err)
2346         {
2347           if (opt.verbose)
2348             log_info (_("key %s: secret key imported\n"),
2349                       keystr_from_pk_with_sub (main_pk, pk));
2350           if (stats)
2351             stats->secret_imported++;
2352         }
2353       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
2354         {
2355           if (opt.verbose)
2356             log_info (_("key %s: secret key already exists\n"),
2357                       keystr_from_pk_with_sub (main_pk, pk));
2358           err = 0;
2359           if (stats)
2360             stats->secret_dups++;
2361         }
2362       else
2363         {
2364           log_error (_("key %s: error sending to agent: %s\n"),
2365                      keystr_from_pk_with_sub (main_pk, pk),
2366                      gpg_strerror (err));
2367           if (gpg_err_code (err) == GPG_ERR_CANCELED
2368               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
2369             break; /* Don't try the other subkeys.  */
2370         }
2371     }
2372
2373   if (!err && stub_key_skipped)
2374     /* We need to notify user how to migrate stub keys.  */
2375     err = gpg_error (GPG_ERR_NOT_PROCESSED);
2376
2377  leave:
2378   gcry_sexp_release (curve);
2379   xfree (cache_nonce);
2380   xfree (wrappedkey);
2381   xfree (transferkey);
2382   gcry_cipher_close (cipherhd);
2383   xfree (kek);
2384   return err;
2385 }
2386
2387
2388 /* Walk a secret keyblock and produce a public keyblock out of it.
2389    Returns a new node or NULL on error. */
2390 static kbnode_t
2391 sec_to_pub_keyblock (kbnode_t sec_keyblock)
2392 {
2393   kbnode_t pub_keyblock = NULL;
2394   kbnode_t ctx = NULL;
2395   kbnode_t secnode, pubnode;
2396
2397   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
2398     {
2399       if (secnode->pkt->pkttype == PKT_SECRET_KEY
2400           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
2401         {
2402           /* Make a public key.  */
2403           PACKET *pkt;
2404           PKT_public_key *pk;
2405
2406           pkt = xtrycalloc (1, sizeof *pkt);
2407           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
2408           if (!pk)
2409             {
2410               xfree (pkt);
2411               release_kbnode (pub_keyblock);
2412               return NULL;
2413             }
2414           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
2415             pkt->pkttype = PKT_PUBLIC_KEY;
2416           else
2417             pkt->pkttype = PKT_PUBLIC_SUBKEY;
2418           pkt->pkt.public_key = pk;
2419
2420           pubnode = new_kbnode (pkt);
2421         }
2422       else
2423         {
2424           pubnode = clone_kbnode (secnode);
2425         }
2426
2427       if (!pub_keyblock)
2428         pub_keyblock = pubnode;
2429       else
2430         add_kbnode (pub_keyblock, pubnode);
2431     }
2432
2433   return pub_keyblock;
2434 }
2435
2436 /****************
2437  * Ditto for secret keys.  Handling is simpler than for public keys.
2438  * We allow secret key importing only when allow is true, this is so
2439  * that a secret key can not be imported accidentally and thereby tampering
2440  * with the trust calculation.
2441  */
2442 static int
2443 import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
2444                    struct import_stats_s *stats, int batch, unsigned int options,
2445                    int for_migration,
2446                    import_screener_t screener, void *screener_arg)
2447 {
2448   PKT_public_key *pk;
2449   struct seckey_info *ski;
2450   kbnode_t node, uidnode;
2451   u32 keyid[2];
2452   int rc = 0;
2453   int nr_prev;
2454   kbnode_t pub_keyblock;
2455   char pkstrbuf[PUBKEY_STRING_SIZE];
2456
2457   /* Get the key and print some info about it */
2458   node = find_kbnode (keyblock, PKT_SECRET_KEY);
2459   if (!node)
2460     BUG ();
2461
2462   pk = node->pkt->pkt.public_key;
2463
2464   keyid_from_pk (pk, keyid);
2465   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
2466
2467   if (screener && screener (keyblock, screener_arg))
2468     {
2469       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
2470                  _("rejected by import screener"));
2471       return 0;
2472   }
2473
2474   if (opt.verbose && !for_migration)
2475     {
2476       log_info ("sec  %s/%s %s   ",
2477                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2478                 keystr_from_pk (pk), datestr_from_pk (pk));
2479       if (uidnode)
2480         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
2481                            uidnode->pkt->pkt.user_id->len);
2482       log_printf ("\n");
2483     }
2484   stats->secret_read++;
2485
2486   if ((options & IMPORT_NO_SECKEY))
2487     {
2488       if (!for_migration)
2489         log_error (_("importing secret keys not allowed\n"));
2490       return 0;
2491     }
2492
2493   if (!uidnode)
2494     {
2495       if (!for_migration)
2496         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
2497       return 0;
2498     }
2499
2500   ski = pk->seckey_info;
2501   if (!ski)
2502     {
2503       /* Actually an internal error.  */
2504       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
2505       return 0;
2506     }
2507
2508   /* A quick check to not import keys with an invalid protection
2509      cipher algorithm (only checks the primary key, though).  */
2510   if (ski->algo > 110)
2511     {
2512       if (!for_migration)
2513         log_error (_("key %s: secret key with invalid cipher %d"
2514                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
2515       return 0;
2516     }
2517
2518 #ifdef ENABLE_SELINUX_HACKS
2519   if (1)
2520     {
2521       /* We don't allow importing secret keys because that may be used
2522          to put a secret key into the keyring and the user might later
2523          be tricked into signing stuff with that key.  */
2524       log_error (_("importing secret keys not allowed\n"));
2525       return 0;
2526     }
2527 #endif
2528
2529   clear_kbnode_flags (keyblock);
2530
2531   nr_prev = stats->skipped_new_keys;
2532
2533   /* Make a public key out of the key. */
2534   pub_keyblock = sec_to_pub_keyblock (keyblock);
2535   if (!pub_keyblock)
2536     log_error ("key %s: failed to create public key from secret key\n",
2537                    keystr_from_pk (pk));
2538   else
2539     {
2540       /* Note that this outputs an IMPORT_OK status message for the
2541          public key block, and below we will output another one for
2542          the secret keys.  FIXME?  */
2543       import_one (ctrl, pub_keyblock, stats,
2544                   NULL, NULL, options, 1, for_migration,
2545                   screener, screener_arg, 0, NULL);
2546
2547       /* Fixme: We should check for an invalid keyblock and
2548          cancel the secret key import in this case.  */
2549       release_kbnode (pub_keyblock);
2550
2551       /* At least we cancel the secret key import when the public key
2552          import was skipped due to MERGE_ONLY option and a new
2553          key.  */
2554       if (!(opt.dry_run || (options & IMPORT_DRY_RUN))
2555           && stats->skipped_new_keys <= nr_prev)
2556         {
2557           /* Read the keyblock again to get the effects of a merge.  */
2558           /* Fixme: we should do this based on the fingerprint or
2559              even better let import_one return the merged
2560              keyblock.  */
2561           node = get_pubkeyblock (ctrl, keyid);
2562           if (!node)
2563             log_error ("key %s: failed to re-lookup public key\n",
2564                        keystr_from_pk (pk));
2565           else
2566             {
2567               gpg_error_t err;
2568
2569               /* transfer_secret_keys collects subkey stats.  */
2570               struct import_stats_s subkey_stats = {0};
2571
2572               err = transfer_secret_keys (ctrl, &subkey_stats, keyblock,
2573                                           batch, 0);
2574               if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
2575                 {
2576                   /* TRANSLATORS: For smartcard, each private key on
2577                      host has a reference (stub) to a smartcard and
2578                      actual private key data is stored on the card.  A
2579                      single smartcard can have up to three private key
2580                      data.  Importing private key stub is always
2581                      skipped in 2.1, and it returns
2582                      GPG_ERR_NOT_PROCESSED.  Instead, user should be
2583                      suggested to run 'gpg --card-status', then,
2584                      references to a card will be automatically
2585                      created again.  */
2586                   log_info (_("To migrate '%s', with each smartcard, "
2587                               "run: %s\n"), "secring.gpg", "gpg --card-status");
2588                   err = 0;
2589                 }
2590               if (!err)
2591                 {
2592                   int status = 16;
2593                   if (!opt.quiet)
2594                     log_info (_("key %s: secret key imported\n"),
2595                               keystr_from_pk (pk));
2596                   if (subkey_stats.secret_imported)
2597                     {
2598                       status |= 1;
2599                       stats->secret_imported += 1;
2600                     }
2601                   if (subkey_stats.secret_dups)
2602                     stats->secret_dups += 1;
2603
2604                   if (is_status_enabled ())
2605                     print_import_ok (pk, status);
2606                   check_prefs (ctrl, node);
2607                 }
2608               release_kbnode (node);
2609             }
2610         }
2611     }
2612
2613   return rc;
2614 }
2615
2616
2617 /****************
2618  * Import a revocation certificate; this is a single signature packet.
2619  */
2620 static int
2621 import_revoke_cert (ctrl_t ctrl, kbnode_t node, struct import_stats_s *stats)
2622 {
2623   PKT_public_key *pk = NULL;
2624   kbnode_t onode;
2625   kbnode_t keyblock = NULL;
2626   KEYDB_HANDLE hd = NULL;
2627   u32 keyid[2];
2628   int rc = 0;
2629
2630   log_assert (!node->next );
2631   log_assert (node->pkt->pkttype == PKT_SIGNATURE );
2632   log_assert (IS_KEY_REV (node->pkt->pkt.signature));
2633
2634   keyid[0] = node->pkt->pkt.signature->keyid[0];
2635   keyid[1] = node->pkt->pkt.signature->keyid[1];
2636
2637   pk = xmalloc_clear( sizeof *pk );
2638   rc = get_pubkey (ctrl, pk, keyid );
2639   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
2640     {
2641       log_error(_("key %s: no public key -"
2642                   " can't apply revocation certificate\n"), keystr(keyid));
2643       rc = 0;
2644       goto leave;
2645     }
2646   else if (rc )
2647     {
2648       log_error(_("key %s: public key not found: %s\n"),
2649                 keystr(keyid), gpg_strerror (rc));
2650       goto leave;
2651     }
2652
2653   /* Read the original keyblock. */
2654   hd = keydb_new ();
2655   if (!hd)
2656     {
2657       rc = gpg_error_from_syserror ();
2658       goto leave;
2659     }
2660
2661   {
2662     byte afp[MAX_FINGERPRINT_LEN];
2663     size_t an;
2664
2665     fingerprint_from_pk (pk, afp, &an);
2666     while (an < MAX_FINGERPRINT_LEN)
2667       afp[an++] = 0;
2668     rc = keydb_search_fpr (hd, afp);
2669   }
2670   if (rc)
2671     {
2672       log_error (_("key %s: can't locate original keyblock: %s\n"),
2673                  keystr(keyid), gpg_strerror (rc));
2674       goto leave;
2675     }
2676   rc = keydb_get_keyblock (hd, &keyblock );
2677   if (rc)
2678     {
2679       log_error (_("key %s: can't read original keyblock: %s\n"),
2680                  keystr(keyid), gpg_strerror (rc));
2681       goto leave;
2682     }
2683
2684   /* it is okay, that node is not in keyblock because
2685    * check_key_signature works fine for sig_class 0x20 (KEY_REV) in
2686    * this special case. */
2687   rc = check_key_signature (ctrl, keyblock, node, NULL);
2688   if (rc )
2689     {
2690       log_error( _("key %s: invalid revocation certificate"
2691                    ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
2692       goto leave;
2693     }
2694
2695   /* check whether we already have this */
2696   for(onode=keyblock->next; onode; onode=onode->next ) {
2697     if (onode->pkt->pkttype == PKT_USER_ID )
2698       break;
2699     else if (onode->pkt->pkttype == PKT_SIGNATURE
2700              && !cmp_signatures(node->pkt->pkt.signature,
2701                                 onode->pkt->pkt.signature))
2702       {
2703         rc = 0;
2704         goto leave; /* yes, we already know about it */
2705       }
2706   }
2707
2708   /* insert it */
2709   insert_kbnode( keyblock, clone_kbnode(node), 0 );
2710
2711   /* and write the keyblock back */
2712   rc = keydb_update_keyblock (ctrl, hd, keyblock );
2713   if (rc)
2714     log_error (_("error writing keyring '%s': %s\n"),
2715                keydb_get_resource_name (hd), gpg_strerror (rc) );
2716   keydb_release (hd);
2717   hd = NULL;
2718
2719   /* we are ready */
2720   if (!opt.quiet )
2721     {
2722       char *p=get_user_id_native (ctrl, keyid);
2723       log_info( _("key %s: \"%s\" revocation certificate imported\n"),
2724                 keystr(keyid),p);
2725       xfree(p);
2726     }
2727   stats->n_revoc++;
2728
2729   /* If the key we just revoked was ultimately trusted, remove its
2730      ultimate trust.  This doesn't stop the user from putting the
2731      ultimate trust back, but is a reasonable solution for now. */
2732   if (get_ownertrust (ctrl, pk) == TRUST_ULTIMATE)
2733     clear_ownertrusts (ctrl, pk);
2734
2735   revalidation_mark (ctrl);
2736
2737  leave:
2738   keydb_release (hd);
2739   release_kbnode( keyblock );
2740   free_public_key( pk );
2741   return rc;
2742 }
2743
2744
2745 /* Loop over the keyblock and check all self signatures.  On return
2746  * the following bis in the node flags are set:
2747  *
2748  * - NODE_GOOD_SELFSIG  :: User ID or subkey has a self-signature
2749  * - NODE_BAD_SELFSIG   :: Used ID or subkey has an invalid self-signature
2750  * - NODE_DELETION_MARK :: This node shall be deleted
2751  *
2752  * NON_SELF is set to true if there are any sigs other than self-sigs
2753  * in this keyblock.
2754  *
2755  * Returns 0 on success or -1 (but not an error code) if the keyblock
2756  * is invalid.
2757  */
2758 static int
2759 chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid, int *non_self)
2760 {
2761   kbnode_t n, knode = NULL;
2762   PKT_signature *sig;
2763   int rc;
2764   u32 bsdate=0, rsdate=0;
2765   kbnode_t bsnode = NULL, rsnode = NULL;
2766
2767   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
2768     {
2769       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2770         {
2771           knode = n;
2772           bsdate = 0;
2773           rsdate = 0;
2774           bsnode = NULL;
2775           rsnode = NULL;
2776           continue;
2777         }
2778
2779       if ( n->pkt->pkttype != PKT_SIGNATURE )
2780         continue;
2781
2782       sig = n->pkt->pkt.signature;
2783       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
2784         {
2785           *non_self = 1;
2786           continue;
2787         }
2788
2789       /* This just caches the sigs for later use.  That way we
2790          import a fully-cached key which speeds things up. */
2791       if (!opt.no_sig_cache)
2792         check_key_signature (ctrl, keyblock, n, NULL);
2793
2794       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
2795         {
2796           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
2797           if ( !unode )
2798             {
2799               log_error( _("key %s: no user ID for signature\n"),
2800                          keystr(keyid));
2801               return -1;  /* The complete keyblock is invalid.  */
2802             }
2803
2804           /* If it hasn't been marked valid yet, keep trying.  */
2805           if (!(unode->flag & NODE_GOOD_SELFSIG))
2806             {
2807               rc = check_key_signature (ctrl, keyblock, n, NULL);
2808               if ( rc )
2809                 {
2810                   if ( opt.verbose )
2811                     {
2812                       char *p = utf8_to_native
2813                         (unode->pkt->pkt.user_id->name,
2814                          strlen (unode->pkt->pkt.user_id->name),0);
2815                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
2816                                 _("key %s: unsupported public key "
2817                                   "algorithm on user ID \"%s\"\n"):
2818                                 _("key %s: invalid self-signature "
2819                                   "on user ID \"%s\"\n"),
2820                                 keystr (keyid),p);
2821                       xfree (p);
2822                     }
2823                 }
2824               else
2825                 unode->flag |= NODE_GOOD_SELFSIG;
2826             }
2827         }
2828       else if (IS_KEY_SIG (sig))
2829         {
2830           rc = check_key_signature (ctrl, keyblock, n, NULL);
2831           if ( rc )
2832             {
2833               if (opt.verbose)
2834                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2835                           _("key %s: unsupported public key algorithm\n"):
2836                           _("key %s: invalid direct key signature\n"),
2837                           keystr (keyid));
2838               n->flag |= NODE_DELETION_MARK;
2839             }
2840         }
2841       else if ( IS_SUBKEY_SIG (sig) )
2842         {
2843           /* Note that this works based solely on the timestamps like
2844              the rest of gpg.  If the standard gets revocation
2845              targets, this may need to be revised.  */
2846
2847           if ( !knode )
2848             {
2849               if (opt.verbose)
2850                 log_info (_("key %s: no subkey for key binding\n"),
2851                           keystr (keyid));
2852               n->flag |= NODE_DELETION_MARK;
2853             }
2854           else
2855             {
2856               rc = check_key_signature (ctrl, keyblock, n, NULL);
2857               if ( rc )
2858                 {
2859                   if (opt.verbose)
2860                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2861                               _("key %s: unsupported public key"
2862                                 " algorithm\n"):
2863                               _("key %s: invalid subkey binding\n"),
2864                               keystr (keyid));
2865                   n->flag |= NODE_DELETION_MARK;
2866                 }
2867               else
2868                 {
2869                   /* It's valid, so is it newer? */
2870                   if (sig->timestamp >= bsdate)
2871                     {
2872                       knode->flag |= NODE_GOOD_SELFSIG; /* Subkey is valid.  */
2873                       if (bsnode)
2874                         {
2875                           /* Delete the last binding sig since this
2876                              one is newer */
2877                           bsnode->flag |= NODE_DELETION_MARK;
2878                           if (opt.verbose)
2879                             log_info (_("key %s: removed multiple subkey"
2880                                         " binding\n"),keystr(keyid));
2881                         }
2882
2883                       bsnode = n;
2884                       bsdate = sig->timestamp;
2885                     }
2886                   else
2887                     n->flag |= NODE_DELETION_MARK; /* older */
2888                 }
2889             }
2890         }
2891       else if ( IS_SUBKEY_REV (sig) )
2892         {
2893           /* We don't actually mark the subkey as revoked right now,
2894              so just check that the revocation sig is the most recent
2895              valid one.  Note that we don't care if the binding sig is
2896              newer than the revocation sig.  See the comment in
2897              getkey.c:merge_selfsigs_subkey for more.  */
2898           if ( !knode )
2899             {
2900               if (opt.verbose)
2901                 log_info (_("key %s: no subkey for key revocation\n"),
2902                           keystr(keyid));
2903               n->flag |= NODE_DELETION_MARK;
2904             }
2905           else
2906             {
2907               rc = check_key_signature (ctrl, keyblock, n, NULL);
2908               if ( rc )
2909                 {
2910                   if(opt.verbose)
2911                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2912                               _("key %s: unsupported public"
2913                                 " key algorithm\n"):
2914                               _("key %s: invalid subkey revocation\n"),
2915                               keystr(keyid));
2916                   n->flag |= NODE_DELETION_MARK;
2917                 }
2918               else
2919                 {
2920                   /* It's valid, so is it newer? */
2921                   if (sig->timestamp >= rsdate)
2922                     {
2923                       if (rsnode)
2924                         {
2925                           /* Delete the last revocation sig since
2926                              this one is newer.  */
2927                           rsnode->flag |= NODE_DELETION_MARK;
2928                           if (opt.verbose)
2929                             log_info (_("key %s: removed multiple subkey"
2930                                         " revocation\n"),keystr(keyid));
2931                         }
2932
2933                       rsnode = n;
2934                       rsdate = sig->timestamp;
2935                     }
2936                   else
2937                     n->flag |= NODE_DELETION_MARK; /* older */
2938                 }
2939             }
2940         }
2941     }
2942
2943   return 0;
2944 }
2945
2946
2947 /* Delete all parts which are invalid and those signatures whose
2948  * public key algorithm is not available in this implementation; but
2949  * consider RSA as valid, because parse/build_packets knows about it.
2950  *
2951  * Returns: True if at least one valid user-id is left over.
2952  */
2953 static int
2954 delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
2955                   unsigned int options)
2956 {
2957   kbnode_t node;
2958   int nvalid=0, uid_seen=0, subkey_seen=0;
2959
2960   for (node=keyblock->next; node; node = node->next )
2961     {
2962       if (node->pkt->pkttype == PKT_USER_ID)
2963         {
2964           uid_seen = 1;
2965           if ((node->flag & NODE_BAD_SELFSIG)
2966               || !(node->flag & NODE_GOOD_SELFSIG))
2967             {
2968               if (opt.verbose )
2969                 {
2970                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
2971                                          node->pkt->pkt.user_id->len,0);
2972                   log_info( _("key %s: skipped user ID \"%s\"\n"),
2973                             keystr(keyid),p);
2974                   xfree(p);
2975                 }
2976               delete_kbnode( node ); /* the user-id */
2977               /* and all following packets up to the next user-id */
2978               while (node->next
2979                      && node->next->pkt->pkttype != PKT_USER_ID
2980                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
2981                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
2982                 delete_kbnode( node->next );
2983                 node = node->next;
2984               }
2985             }
2986           else
2987             nvalid++;
2988         }
2989       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2990                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
2991         {
2992           if ((node->flag & NODE_BAD_SELFSIG)
2993               || !(node->flag & NODE_GOOD_SELFSIG))
2994             {
2995               if (opt.verbose )
2996                 log_info( _("key %s: skipped subkey\n"),keystr(keyid));
2997
2998               delete_kbnode( node ); /* the subkey */
2999               /* and all following signature packets */
3000               while (node->next
3001                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
3002                 delete_kbnode( node->next );
3003                 node = node->next;
3004               }
3005             }
3006           else
3007             subkey_seen = 1;
3008         }
3009       else if (node->pkt->pkttype == PKT_SIGNATURE
3010                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
3011                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
3012         {
3013           delete_kbnode( node ); /* build_packet() can't handle this */
3014         }
3015       else if (node->pkt->pkttype == PKT_SIGNATURE
3016                && !node->pkt->pkt.signature->flags.exportable
3017                && !(options&IMPORT_LOCAL_SIGS)
3018                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
3019         {
3020           /* here we violate the rfc a bit by still allowing
3021            * to import non-exportable signature when we have the
3022            * the secret key used to create this signature - it
3023            * seems that this makes sense */
3024           if(opt.verbose)
3025             log_info( _("key %s: non exportable signature"
3026                         " (class 0x%02X) - skipped\n"),
3027                       keystr(keyid), node->pkt->pkt.signature->sig_class );
3028           delete_kbnode( node );
3029         }
3030       else if (node->pkt->pkttype == PKT_SIGNATURE
3031                && IS_KEY_REV (node->pkt->pkt.signature))
3032         {
3033           if (uid_seen )
3034             {
3035               if(opt.verbose)
3036                 log_info( _("key %s: revocation certificate"
3037                             " at wrong place - skipped\n"),keystr(keyid));
3038               delete_kbnode( node );
3039             }
3040           else
3041             {
3042               /* If the revocation cert is from a different key than
3043                  the one we're working on don't check it - it's
3044                  probably from a revocation key and won't be
3045                  verifiable with this key anyway. */
3046
3047               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
3048                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
3049                 {
3050                   int rc = check_key_signature (ctrl, keyblock, node, NULL);
3051                   if (rc )
3052                     {
3053                       if(opt.verbose)
3054                         log_info( _("key %s: invalid revocation"
3055                                     " certificate: %s - skipped\n"),
3056                                   keystr(keyid), gpg_strerror (rc));
3057                       delete_kbnode( node );
3058                     }
3059                 }
3060             }
3061         }
3062       else if (node->pkt->pkttype == PKT_SIGNATURE
3063                && (IS_SUBKEY_SIG (node->pkt->pkt.signature)
3064                    || IS_SUBKEY_REV (node->pkt->pkt.signature))
3065                && !subkey_seen )
3066         {
3067           if(opt.verbose)
3068             log_info( _("key %s: subkey signature"
3069                         " in wrong place - skipped\n"), keystr(keyid));
3070           delete_kbnode( node );
3071         }
3072       else if (node->pkt->pkttype == PKT_SIGNATURE
3073                && !IS_CERT(node->pkt->pkt.signature))
3074         {
3075           if(opt.verbose)
3076             log_info(_("key %s: unexpected signature class (0x%02X) -"
3077                        " skipped\n"),keystr(keyid),
3078                      node->pkt->pkt.signature->sig_class);
3079           delete_kbnode(node);
3080           }
3081       else if ((node->flag & NODE_DELETION_MARK))
3082         delete_kbnode( node );
3083     }
3084
3085   /* note: because keyblock is the public key, it is never marked
3086    * for deletion and so keyblock cannot change */
3087   commit_kbnode( &keyblock );
3088   return nvalid;
3089 }
3090
3091 /* This function returns true if any UID is left in the keyring.  */
3092 static int
3093 any_uid_left (kbnode_t keyblock)
3094 {
3095   kbnode_t node;
3096
3097   for (node=keyblock->next; node; node = node->next)
3098     if (node->pkt->pkttype == PKT_USER_ID)
3099       return 1;
3100   return 0;
3101 }
3102
3103
3104
3105 /****************
3106  * It may happen that the imported keyblock has duplicated user IDs.
3107  * We check this here and collapse those user IDs together with their
3108  * sigs into one.
3109  * Returns: True if the keyblock has changed.
3110  */
3111 int
3112 collapse_uids( kbnode_t *keyblock )
3113 {
3114   kbnode_t uid1;
3115   int any=0;
3116
3117   for(uid1=*keyblock;uid1;uid1=uid1->next)
3118     {
3119       kbnode_t uid2;
3120
3121       if(is_deleted_kbnode(uid1))
3122         continue;
3123
3124       if(uid1->pkt->pkttype!=PKT_USER_ID)
3125         continue;
3126
3127       for(uid2=uid1->next;uid2;uid2=uid2->next)
3128         {
3129           if(is_deleted_kbnode(uid2))
3130             continue;
3131
3132           if(uid2->pkt->pkttype!=PKT_USER_ID)
3133             continue;
3134
3135           if(cmp_user_ids(uid1->pkt->pkt.user_id,
3136                           uid2->pkt->pkt.user_id)==0)
3137             {
3138               /* We have a duplicated uid */
3139               kbnode_t sig1,last;
3140
3141               any=1;
3142
3143               /* Now take uid2's signatures, and attach them to
3144                  uid1 */
3145               for(last=uid2;last->next;last=last->next)
3146                 {
3147                   if(is_deleted_kbnode(last))
3148                     continue;
3149
3150                   if(last->next->pkt->pkttype==PKT_USER_ID
3151                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
3152                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
3153                     break;
3154                 }
3155
3156               /* Snip out uid2 */
3157               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
3158
3159               /* Now put uid2 in place as part of uid1 */
3160               last->next=uid1->next;
3161               uid1->next=uid2;
3162               delete_kbnode(uid2);
3163
3164               /* Now dedupe uid1 */
3165               for(sig1=uid1->next;sig1;sig1=sig1->next)
3166                 {
3167                   kbnode_t sig2;
3168
3169                   if(is_deleted_kbnode(sig1))
3170                     continue;
3171
3172                   if(sig1->pkt->pkttype==PKT_USER_ID
3173                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
3174                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
3175                     break;
3176
3177                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
3178                     continue;
3179
3180                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
3181                     {
3182                       if(is_deleted_kbnode(sig2))
3183                         continue;
3184
3185                       if(sig2->pkt->pkttype==PKT_USER_ID
3186                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
3187                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
3188                         break;
3189
3190                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
3191                         continue;
3192
3193                       if(cmp_signatures(sig1->pkt->pkt.signature,
3194                                         sig2->pkt->pkt.signature)==0)
3195                         {
3196                           /* We have a match, so delete the second
3197                              signature */
3198                           delete_kbnode(sig2);
3199                           sig2=last;
3200                         }
3201                     }
3202                 }
3203             }
3204         }
3205     }
3206
3207   commit_kbnode(keyblock);
3208
3209   if(any && !opt.quiet)
3210     {
3211       const char *key="???";
3212
3213       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
3214         key = keystr_from_pk (uid1->pkt->pkt.public_key);
3215       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
3216         key = keystr_from_pk (uid1->pkt->pkt.public_key);
3217
3218       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
3219     }
3220
3221   return any;
3222 }
3223
3224
3225 /* Check for a 0x20 revocation from a revocation key that is not
3226    present.  This may be called without the benefit of merge_xxxx so
3227    you can't rely on pk->revkey and friends. */
3228 static void
3229 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
3230 {
3231   kbnode_t onode, inode;
3232   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
3233
3234   for(onode=keyblock->next;onode;onode=onode->next)
3235     {
3236       /* If we reach user IDs, we're done. */
3237       if(onode->pkt->pkttype==PKT_USER_ID)
3238         break;
3239
3240       if (onode->pkt->pkttype == PKT_SIGNATURE
3241           && IS_KEY_SIG (onode->pkt->pkt.signature)
3242           && onode->pkt->pkt.signature->revkey)
3243         {
3244           int idx;
3245           PKT_signature *sig=onode->pkt->pkt.signature;
3246
3247           for(idx=0;idx<sig->numrevkeys;idx++)
3248             {
3249               u32 keyid[2];
3250
3251               keyid_from_fingerprint (ctrl, sig->revkey[idx].fpr,
3252                                       MAX_FINGERPRINT_LEN, keyid);
3253
3254               for(inode=keyblock->next;inode;inode=inode->next)
3255                 {
3256                   /* If we reach user IDs, we're done. */
3257                   if(inode->pkt->pkttype==PKT_USER_ID)
3258                     break;
3259
3260                   if (inode->pkt->pkttype == PKT_SIGNATURE
3261                       && IS_KEY_REV (inode->pkt->pkt.signature)
3262                       && inode->pkt->pkt.signature->keyid[0]==keyid[0]
3263                       && inode->pkt->pkt.signature->keyid[1]==keyid[1])
3264                     {
3265                       /* Okay, we have a revocation key, and a
3266                        * revocation issued by it.  Do we have the key
3267                        * itself?  */
3268                       gpg_error_t err;
3269
3270                       err = get_pubkey_byfprint_fast (NULL,
3271                                                       sig->revkey[idx].fpr,
3272                                                       MAX_FINGERPRINT_LEN);
3273                       if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
3274                           || gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
3275                         {
3276                           char *tempkeystr = xstrdup (keystr_from_pk (pk));
3277
3278                           /* No, so try and get it */
3279                           if ((opt.keyserver_options.options
3280                                & KEYSERVER_AUTO_KEY_RETRIEVE)
3281                               && keyserver_any_configured (ctrl))
3282                             {
3283                               log_info(_("WARNING: key %s may be revoked:"
3284                                          " fetching revocation key %s\n"),
3285                                        tempkeystr,keystr(keyid));
3286                               keyserver_import_fprint (ctrl,
3287                                                        sig->revkey[idx].fpr,
3288                                                        MAX_FINGERPRINT_LEN,
3289                                                        opt.keyserver, 0);
3290
3291                               /* Do we have it now? */
3292                               err = get_pubkey_byfprint_fast (NULL,
3293                                                      sig->revkey[idx].fpr,
3294                                                      MAX_FINGERPRINT_LEN);
3295                             }
3296
3297                           if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
3298                               || gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
3299                             log_info(_("WARNING: key %s may be revoked:"
3300                                        " revocation key %s not present.\n"),
3301                                      tempkeystr,keystr(keyid));
3302
3303                           xfree(tempkeystr);
3304                         }
3305                     }
3306                 }
3307             }
3308         }
3309     }
3310 }
3311
3312
3313 /*
3314  * compare and merge the blocks
3315  *
3316  * o compare the signatures: If we already have this signature, check
3317  *   that they compare okay; if not, issue a warning and ask the user.
3318  * o Simply add the signature.  Can't verify here because we may not have
3319  *   the signature's public key yet; verification is done when putting it
3320  *   into the trustdb, which is done automagically as soon as this pubkey
3321  *   is used.
3322  * Note: We indicate newly inserted packets with NODE_FLAG_A.
3323  */
3324 static int
3325 merge_blocks (ctrl_t ctrl, unsigned int options,
3326               kbnode_t keyblock_orig, kbnode_t keyblock,
3327               u32 *keyid, u32 curtime, int origin, const char *url,
3328               int *n_uids, int *n_sigs, int *n_subk )
3329 {
3330   kbnode_t onode, node;
3331   int rc, found;
3332
3333   /* 1st: handle revocation certificates */
3334   for (node=keyblock->next; node; node=node->next )
3335     {
3336       if (node->pkt->pkttype == PKT_USER_ID )
3337         break;
3338       else if (node->pkt->pkttype == PKT_SIGNATURE
3339                && IS_KEY_REV (node->pkt->pkt.signature))
3340         {
3341           /* check whether we already have this */
3342           found = 0;
3343           for (onode=keyblock_orig->next; onode; onode=onode->next)
3344             {
3345               if (onode->pkt->pkttype == PKT_USER_ID )
3346                 break;
3347               else if (onode->pkt->pkttype == PKT_SIGNATURE
3348                        && IS_KEY_REV (onode->pkt->pkt.signature)
3349                        && !cmp_signatures(onode->pkt->pkt.signature,
3350                                           node->pkt->pkt.signature))
3351                 {
3352                   found = 1;
3353                   break;
3354                 }
3355             }
3356           if (!found)
3357             {
3358               kbnode_t n2 = clone_kbnode(node);
3359               insert_kbnode( keyblock_orig, n2, 0 );
3360               n2->flag |= NODE_FLAG_A;
3361               ++*n_sigs;
3362               if(!opt.quiet)
3363                 {
3364                   char *p = get_user_id_native (ctrl, keyid);
3365                   log_info(_("key %s: \"%s\" revocation"
3366                              " certificate added\n"), keystr(keyid),p);
3367                   xfree(p);
3368                 }
3369             }
3370         }
3371     }
3372
3373   /* 2nd: merge in any direct key (0x1F) sigs */
3374   for(node=keyblock->next; node; node=node->next)
3375     {
3376       if (node->pkt->pkttype == PKT_USER_ID )
3377         break;
3378       else if (node->pkt->pkttype == PKT_SIGNATURE
3379                && IS_KEY_SIG (node->pkt->pkt.signature))
3380         {
3381           /* check whether we already have this */
3382           found = 0;
3383           for (onode=keyblock_orig->next; onode; onode=onode->next)
3384             {
3385               if (onode->pkt->pkttype == PKT_USER_ID)
3386                 break;
3387               else if (onode->pkt->pkttype == PKT_SIGNATURE
3388                        && IS_KEY_SIG (onode->pkt->pkt.signature)
3389                        && !cmp_signatures(onode->pkt->pkt.signature,
3390                                           node->pkt->pkt.signature))
3391                 {
3392                   found = 1;
3393                   break;
3394                 }
3395             }
3396           if (!found )
3397             {
3398               kbnode_t n2 = clone_kbnode(node);
3399               insert_kbnode( keyblock_orig, n2, 0 );
3400               n2->flag |= NODE_FLAG_A;
3401               ++*n_sigs;
3402               if(!opt.quiet)
3403                 log_info( _("key %s: direct key signature added\n"),
3404                           keystr(keyid));
3405             }
3406         }
3407     }
3408
3409   /* 3rd: try to merge new certificates in */
3410   for (onode=keyblock_orig->next; onode; onode=onode->next)
3411     {
3412       if (!(onode->flag & NODE_FLAG_A) && onode->pkt->pkttype == PKT_USER_ID)
3413         {
3414           /* find the user id in the imported keyblock */
3415           for (node=keyblock->next; node; node=node->next)
3416             if (node->pkt->pkttype == PKT_USER_ID
3417                 && !cmp_user_ids( onode->pkt->pkt.user_id,
3418                                   node->pkt->pkt.user_id ) )
3419               break;
3420           if (node ) /* found: merge */
3421             {
3422               rc = merge_sigs (onode, node, n_sigs);
3423               if (rc )
3424                 return rc;
3425             }
3426         }
3427     }
3428
3429   /* 4th: add new user-ids */
3430   for (node=keyblock->next; node; node=node->next)
3431     {
3432       if (node->pkt->pkttype == PKT_USER_ID)
3433         {
3434           /* do we have this in the original keyblock */
3435           for (onode=keyblock_orig->next; onode; onode=onode->next )
3436             if (onode->pkt->pkttype == PKT_USER_ID
3437                 && !cmp_user_ids( onode->pkt->pkt.user_id,
3438                                   node->pkt->pkt.user_id ) )
3439               break;
3440           if (!onode ) /* this is a new user id: append */
3441             {
3442               rc = append_new_uid (options, keyblock_orig, node,
3443                                    curtime, origin, url, n_sigs);
3444               if (rc )
3445                 return rc;
3446               ++*n_uids;
3447             }
3448         }
3449     }
3450
3451   /* 5th: add new subkeys */
3452   for (node=keyblock->next; node; node=node->next)
3453     {
3454       onode = NULL;
3455       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3456         {
3457           /* do we have this in the original keyblock? */
3458           for(onode=keyblock_orig->next; onode; onode=onode->next)
3459            &nbs