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