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