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