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