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