gpg: Pass key origin values to import functions.
[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                && keyblock->pkt->pkt.signature->sig_class == 0x20 )
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                   && pkt->pkt.signature->sig_class == 0x20 )
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                && node->pkt->pkt.signature->sig_class == 0x18
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
1610       hd = keydb_new ();
1611       if (!hd)
1612         return gpg_error_from_syserror ();
1613
1614       rc = keydb_locate_writable (hd);
1615       if (rc)
1616         {
1617           log_error (_("no writable keyring found: %s\n"), gpg_strerror (rc));
1618           keydb_release (hd);
1619           return GPG_ERR_GENERAL;
1620         }
1621       if (opt.verbose > 1 )
1622         log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );
1623
1624       /* Unless we are in restore mode apply meta data to the
1625        * keyblock.  Note that this will never change the first packet
1626        * and thus the address of KEYBLOCK won't change.  */
1627       if ( !(options & IMPORT_RESTORE) )
1628         {
1629           rc = apply_meta_data (keyblock, 0, origin);
1630           log_error ("apply_meta_data failed: %s\n", gpg_strerror (rc));
1631           keydb_release (hd);
1632           return GPG_ERR_GENERAL;
1633         }
1634
1635       rc = keydb_insert_keyblock (hd, keyblock );
1636       if (rc)
1637         log_error (_("error writing keyring '%s': %s\n"),
1638                    keydb_get_resource_name (hd), gpg_strerror (rc));
1639       else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
1640         {
1641           /* This should not be possible since we delete the
1642              ownertrust when a key is deleted, but it can happen if
1643              the keyring and trustdb are out of sync.  It can also
1644              be made to happen with the trusted-key command and by
1645              importing and locally exported key. */
1646
1647           clear_ownertrusts (ctrl, pk);
1648           if (non_self)
1649             revalidation_mark (ctrl);
1650         }
1651       keydb_release (hd);
1652
1653       /* We are ready.  */
1654       if (!opt.quiet && !silent)
1655         {
1656           char *p = get_user_id_byfpr_native (ctrl, fpr2);
1657           log_info (_("key %s: public key \"%s\" imported\n"),
1658                     keystr(keyid), p);
1659           xfree(p);
1660         }
1661       if (is_status_enabled())
1662         {
1663           char *us = get_long_user_id_string (ctrl, keyid);
1664           write_status_text( STATUS_IMPORTED, us );
1665           xfree(us);
1666           print_import_ok (pk, 1);
1667         }
1668       stats->imported++;
1669       new_key = 1;
1670     }
1671   else /* merge */
1672     {
1673       KEYDB_HANDLE hd;
1674       int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
1675
1676       /* Compare the original against the new key; just to be sure nothing
1677        * weird is going on */
1678       if (cmp_public_keys( pk_orig, pk ) )
1679         {
1680           if (!silent)
1681             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
1682           goto leave;
1683         }
1684
1685       /* Now read the original keyblock again so that we can use
1686          that handle for updating the keyblock.  */
1687       hd = keydb_new ();
1688       if (!hd)
1689         {
1690           rc = gpg_error_from_syserror ();
1691           goto leave;
1692         }
1693       keydb_disable_caching (hd);
1694       rc = keydb_search_fpr (hd, fpr2);
1695       if (rc )
1696         {
1697           log_error (_("key %s: can't locate original keyblock: %s\n"),
1698                      keystr(keyid), gpg_strerror (rc));
1699           keydb_release (hd);
1700           goto leave;
1701         }
1702       rc = keydb_get_keyblock (hd, &keyblock_orig);
1703       if (rc)
1704         {
1705           log_error (_("key %s: can't read original keyblock: %s\n"),
1706                      keystr(keyid), gpg_strerror (rc));
1707           keydb_release (hd);
1708           goto leave;
1709         }
1710
1711       /* Make sure the original direct key sigs are all sane.  */
1712       n_sigs_cleaned = fix_bad_direct_key_sigs (ctrl, keyblock_orig, keyid);
1713       if (n_sigs_cleaned)
1714         commit_kbnode (&keyblock_orig);
1715
1716       /* and try to merge the block */
1717       clear_kbnode_flags( keyblock_orig );
1718       clear_kbnode_flags( keyblock );
1719       n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
1720       rc = merge_blocks (ctrl, keyblock_orig, keyblock,
1721                          keyid, &n_uids, &n_sigs, &n_subk );
1722       if (rc )
1723         {
1724           keydb_release (hd);
1725           goto leave;
1726         }
1727
1728       if ((options & IMPORT_CLEAN))
1729         clean_key (ctrl, keyblock_orig, opt.verbose, (options&IMPORT_MINIMAL),
1730                    &n_uids_cleaned,&n_sigs_cleaned);
1731
1732       if (n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned)
1733         {
1734           mod_key = 1;
1735           /* KEYBLOCK_ORIG has been updated; write */
1736           rc = keydb_update_keyblock (ctrl, hd, keyblock_orig);
1737           if (rc)
1738             log_error (_("error writing keyring '%s': %s\n"),
1739                        keydb_get_resource_name (hd), gpg_strerror (rc) );
1740           else if (non_self)
1741             revalidation_mark (ctrl);
1742
1743           /* We are ready.  */
1744           if (!opt.quiet && !silent)
1745             {
1746               char *p = get_user_id_byfpr_native (ctrl, fpr2);
1747               if (n_uids == 1 )
1748                 log_info( _("key %s: \"%s\" 1 new user ID\n"),
1749                           keystr(keyid),p);
1750               else if (n_uids )
1751                 log_info( _("key %s: \"%s\" %d new user IDs\n"),
1752                           keystr(keyid),p,n_uids);
1753               if (n_sigs == 1 )
1754                 log_info( _("key %s: \"%s\" 1 new signature\n"),
1755                           keystr(keyid), p);
1756               else if (n_sigs )
1757                 log_info( _("key %s: \"%s\" %d new signatures\n"),
1758                           keystr(keyid), p, n_sigs );
1759               if (n_subk == 1 )
1760                 log_info( _("key %s: \"%s\" 1 new subkey\n"),
1761                           keystr(keyid), p);
1762               else if (n_subk )
1763                 log_info( _("key %s: \"%s\" %d new subkeys\n"),
1764                           keystr(keyid), p, n_subk );
1765               if (n_sigs_cleaned==1)
1766                 log_info(_("key %s: \"%s\" %d signature cleaned\n"),
1767                          keystr(keyid),p,n_sigs_cleaned);
1768               else if (n_sigs_cleaned)
1769                 log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
1770                          keystr(keyid),p,n_sigs_cleaned);
1771               if (n_uids_cleaned==1)
1772                 log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
1773                          keystr(keyid),p,n_uids_cleaned);
1774               else if (n_uids_cleaned)
1775                 log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
1776                          keystr(keyid),p,n_uids_cleaned);
1777               xfree(p);
1778             }
1779
1780           stats->n_uids +=n_uids;
1781           stats->n_sigs +=n_sigs;
1782           stats->n_subk +=n_subk;
1783           stats->n_sigs_cleaned +=n_sigs_cleaned;
1784           stats->n_uids_cleaned +=n_uids_cleaned;
1785
1786           if (is_status_enabled () && !silent)
1787             print_import_ok (pk, ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
1788         }
1789       else
1790         {
1791           same_key = 1;
1792           if (is_status_enabled ())
1793             print_import_ok (pk, 0);
1794
1795           if (!opt.quiet && !silent)
1796             {
1797               char *p = get_user_id_byfpr_native (ctrl, fpr2);
1798               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
1799               xfree(p);
1800             }
1801
1802           stats->unchanged++;
1803         }
1804
1805       keydb_release (hd); hd = NULL;
1806     }
1807
1808  leave:
1809   if (mod_key || new_key || same_key)
1810     {
1811       /* A little explanation for this: we fill in the fingerprint
1812          when importing keys as it can be useful to know the
1813          fingerprint in certain keyserver-related cases (a keyserver
1814          asked for a particular name, but the key doesn't have that
1815          name).  However, in cases where we're importing more than
1816          one key at a time, we cannot know which key to fingerprint.
1817          In these cases, rather than guessing, we do not
1818          fingerprinting at all, and we must hope the user ID on the
1819          keys are useful.  Note that we need to do this for new
1820          keys, merged keys and even for unchanged keys.  This is
1821          required because for example the --auto-key-locate feature
1822          may import an already imported key and needs to know the
1823          fingerprint of the key in all cases.  */
1824       if (fpr)
1825         {
1826           xfree (*fpr);
1827           /* Note that we need to compare against 0 here because
1828              COUNT gets only incremented after returning from this
1829              function.  */
1830           if (!stats->count)
1831             *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
1832           else
1833             *fpr = NULL;
1834         }
1835     }
1836
1837   /* Now that the key is definitely incorporated into the keydb, we
1838      need to check if a designated revocation is present or if the
1839      prefs are not rational so we can warn the user. */
1840
1841   if (mod_key)
1842     {
1843       revocation_present (ctrl, keyblock_orig);
1844       if (!from_sk && have_secret_key_with_kid (keyid))
1845         check_prefs (ctrl, keyblock_orig);
1846     }
1847   else if (new_key)
1848     {
1849       revocation_present (ctrl, keyblock);
1850       if (!from_sk && have_secret_key_with_kid (keyid))
1851         check_prefs (ctrl, keyblock);
1852     }
1853
1854   release_kbnode( keyblock_orig );
1855   free_public_key( pk_orig );
1856
1857   return rc;
1858 }
1859
1860
1861 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
1862    function prints diagnostics and returns an error code.  If BATCH is
1863    true the secret keys are stored by gpg-agent in the transfer format
1864    (i.e. no re-protection and aksing for passphrases). */
1865 gpg_error_t
1866 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
1867                       kbnode_t sec_keyblock, int batch, int force)
1868 {
1869   gpg_error_t err = 0;
1870   void *kek = NULL;
1871   size_t keklen;
1872   kbnode_t ctx = NULL;
1873   kbnode_t node;
1874   PKT_public_key *main_pk, *pk;
1875   struct seckey_info *ski;
1876   int nskey;
1877   membuf_t mbuf;
1878   int i, j;
1879   void *format_args[2*PUBKEY_MAX_NSKEY];
1880   gcry_sexp_t skey, prot, tmpsexp;
1881   gcry_sexp_t curve = NULL;
1882   unsigned char *transferkey = NULL;
1883   size_t transferkeylen;
1884   gcry_cipher_hd_t cipherhd = NULL;
1885   unsigned char *wrappedkey = NULL;
1886   size_t wrappedkeylen;
1887   char *cache_nonce = NULL;
1888   int stub_key_skipped = 0;
1889
1890   /* Get the current KEK.  */
1891   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
1892   if (err)
1893     {
1894       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
1895       goto leave;
1896     }
1897
1898   /* Prepare a cipher context.  */
1899   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
1900                           GCRY_CIPHER_MODE_AESWRAP, 0);
1901   if (!err)
1902     err = gcry_cipher_setkey (cipherhd, kek, keklen);
1903   if (err)
1904     goto leave;
1905   xfree (kek);
1906   kek = NULL;
1907
1908   main_pk = NULL;
1909   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
1910     {
1911       if (node->pkt->pkttype != PKT_SECRET_KEY
1912           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
1913         continue;
1914       pk = node->pkt->pkt.public_key;
1915       if (!main_pk)
1916         main_pk = pk;
1917
1918       /* Make sure the keyids are available.  */
1919       keyid_from_pk (pk, NULL);
1920       if (node->pkt->pkttype == PKT_SECRET_KEY)
1921         {
1922           pk->main_keyid[0] = pk->keyid[0];
1923           pk->main_keyid[1] = pk->keyid[1];
1924         }
1925       else
1926         {
1927           pk->main_keyid[0] = main_pk->keyid[0];
1928           pk->main_keyid[1] = main_pk->keyid[1];
1929         }
1930
1931
1932       ski = pk->seckey_info;
1933       if (!ski)
1934         BUG ();
1935
1936       if (stats)
1937         {
1938           stats->count++;
1939           stats->secret_read++;
1940         }
1941
1942       /* We ignore stub keys.  The way we handle them in other parts
1943          of the code is by asking the agent whether any secret key is
1944          available for a given keyblock and then concluding that we
1945          have a secret key; all secret (sub)keys of the keyblock the
1946          agent does not know of are then stub keys.  This works also
1947          for card stub keys.  The learn command or the card-status
1948          command may be used to check with the agent whether a card
1949          has been inserted and a stub key is in turn generated by the
1950          agent.  */
1951       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
1952         {
1953           stub_key_skipped = 1;
1954           continue;
1955         }
1956
1957       /* Convert our internal secret key object into an S-expression.  */
1958       nskey = pubkey_get_nskey (pk->pubkey_algo);
1959       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
1960         {
1961           err = gpg_error (GPG_ERR_BAD_SECKEY);
1962           log_error ("internal error: %s\n", gpg_strerror (err));
1963           goto leave;
1964         }
1965
1966       init_membuf (&mbuf, 50);
1967       put_membuf_str (&mbuf, "(skey");
1968       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1969           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1970           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1971         {
1972           /* The ECC case.  */
1973           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
1974           if (!curvestr)
1975             err = gpg_error_from_syserror ();
1976           else
1977             {
1978               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
1979               gcry_sexp_release (curve);
1980               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
1981                                      curvename?curvename:curvestr);
1982               xfree (curvestr);
1983               if (!err)
1984                 {
1985                   j = 0;
1986                   /* Append the public key element Q.  */
1987                   put_membuf_str (&mbuf, " _ %m");
1988                   format_args[j++] = pk->pkey + 1;
1989
1990                   /* Append the secret key element D.  For ECDH we
1991                      skip PKEY[2] because this holds the KEK which is
1992                      not needed by gpg-agent.  */
1993                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
1994                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1995                     put_membuf_str (&mbuf, " e %m");
1996                   else
1997                     put_membuf_str (&mbuf, " _ %m");
1998                   format_args[j++] = pk->pkey + i;
1999                 }
2000             }
2001         }
2002       else
2003         {
2004           /* Standard case for the old (non-ECC) algorithms.  */
2005           for (i=j=0; i < nskey; i++)
2006             {
2007               if (!pk->pkey[i])
2008                 continue; /* Protected keys only have NPKEY+1 elements.  */
2009
2010               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
2011                 put_membuf_str (&mbuf, " e %m");
2012               else
2013                 put_membuf_str (&mbuf, " _ %m");
2014               format_args[j++] = pk->pkey + i;
2015             }
2016         }
2017       put_membuf_str (&mbuf, ")");
2018       put_membuf (&mbuf, "", 1);
2019       if (err)
2020         xfree (get_membuf (&mbuf, NULL));
2021       else
2022         {
2023           char *format = get_membuf (&mbuf, NULL);
2024           if (!format)
2025             err = gpg_error_from_syserror ();
2026           else
2027             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
2028           xfree (format);
2029         }
2030       if (err)
2031         {
2032           log_error ("error building skey array: %s\n", gpg_strerror (err));
2033           goto leave;
2034         }
2035
2036       if (ski->is_protected)
2037         {
2038           char countbuf[35];
2039
2040           /* Note that the IVLEN may be zero if we are working on a
2041              dummy key.  We can't express that in an S-expression and
2042              thus we send dummy data for the IV.  */
2043           snprintf (countbuf, sizeof countbuf, "%lu",
2044                     (unsigned long)ski->s2k.count);
2045           err = gcry_sexp_build
2046             (&prot, NULL,
2047              " (protection %s %s %b %d %s %b %s)\n",
2048              ski->sha1chk? "sha1":"sum",
2049              openpgp_cipher_algo_name (ski->algo),
2050              ski->ivlen? (int)ski->ivlen:1,
2051              ski->ivlen? ski->iv: (const unsigned char*)"X",
2052              ski->s2k.mode,
2053              openpgp_md_algo_name (ski->s2k.hash_algo),
2054              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
2055              countbuf);
2056         }
2057       else
2058         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
2059
2060       tmpsexp = NULL;
2061       xfree (transferkey);
2062       transferkey = NULL;
2063       if (!err)
2064         err = gcry_sexp_build (&tmpsexp, NULL,
2065                                "(openpgp-private-key\n"
2066                                " (version %d)\n"
2067                                " (algo %s)\n"
2068                                " %S%S\n"
2069                                " (csum %d)\n"
2070                                " %S)\n",
2071                                pk->version,
2072                                openpgp_pk_algo_name (pk->pubkey_algo),
2073                                curve, skey,
2074                                (int)(unsigned long)ski->csum, prot);
2075       gcry_sexp_release (skey);
2076       gcry_sexp_release (prot);
2077       if (!err)
2078         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
2079       gcry_sexp_release (tmpsexp);
2080       if (err)
2081         {
2082           log_error ("error building transfer key: %s\n", gpg_strerror (err));
2083           goto leave;
2084         }
2085
2086       /* Wrap the key.  */
2087       wrappedkeylen = transferkeylen + 8;
2088       xfree (wrappedkey);
2089       wrappedkey = xtrymalloc (wrappedkeylen);
2090       if (!wrappedkey)
2091         err = gpg_error_from_syserror ();
2092       else
2093         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
2094                                    transferkey, transferkeylen);
2095       if (err)
2096         goto leave;
2097       xfree (transferkey);
2098       transferkey = NULL;
2099
2100       /* Send the wrapped key to the agent.  */
2101       {
2102         char *desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_IMPORT, 1);
2103         err = agent_import_key (ctrl, desc, &cache_nonce,
2104                                 wrappedkey, wrappedkeylen, batch, force);
2105         xfree (desc);
2106       }
2107       if (!err)
2108         {
2109           if (opt.verbose)
2110             log_info (_("key %s: secret key imported\n"),
2111                       keystr_from_pk_with_sub (main_pk, pk));
2112           if (stats)
2113             stats->secret_imported++;
2114         }
2115       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
2116         {
2117           if (opt.verbose)
2118             log_info (_("key %s: secret key already exists\n"),
2119                       keystr_from_pk_with_sub (main_pk, pk));
2120           err = 0;
2121           if (stats)
2122             stats->secret_dups++;
2123         }
2124       else
2125         {
2126           log_error (_("key %s: error sending to agent: %s\n"),
2127                      keystr_from_pk_with_sub (main_pk, pk),
2128                      gpg_strerror (err));
2129           if (gpg_err_code (err) == GPG_ERR_CANCELED
2130               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
2131             break; /* Don't try the other subkeys.  */
2132         }
2133     }
2134
2135   if (!err && stub_key_skipped)
2136     /* We need to notify user how to migrate stub keys.  */
2137     err = gpg_error (GPG_ERR_NOT_PROCESSED);
2138
2139  leave:
2140   gcry_sexp_release (curve);
2141   xfree (cache_nonce);
2142   xfree (wrappedkey);
2143   xfree (transferkey);
2144   gcry_cipher_close (cipherhd);
2145   xfree (kek);
2146   return err;
2147 }
2148
2149
2150 /* Walk a secret keyblock and produce a public keyblock out of it.
2151    Returns a new node or NULL on error. */
2152 static kbnode_t
2153 sec_to_pub_keyblock (kbnode_t sec_keyblock)
2154 {
2155   kbnode_t pub_keyblock = NULL;
2156   kbnode_t ctx = NULL;
2157   kbnode_t secnode, pubnode;
2158
2159   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
2160     {
2161       if (secnode->pkt->pkttype == PKT_SECRET_KEY
2162           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
2163         {
2164           /* Make a public key.  */
2165           PACKET *pkt;
2166           PKT_public_key *pk;
2167
2168           pkt = xtrycalloc (1, sizeof *pkt);
2169           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
2170           if (!pk)
2171             {
2172               xfree (pkt);
2173               release_kbnode (pub_keyblock);
2174               return NULL;
2175             }
2176           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
2177             pkt->pkttype = PKT_PUBLIC_KEY;
2178           else
2179             pkt->pkttype = PKT_PUBLIC_SUBKEY;
2180           pkt->pkt.public_key = pk;
2181
2182           pubnode = new_kbnode (pkt);
2183         }
2184       else
2185         {
2186           pubnode = clone_kbnode (secnode);
2187         }
2188
2189       if (!pub_keyblock)
2190         pub_keyblock = pubnode;
2191       else
2192         add_kbnode (pub_keyblock, pubnode);
2193     }
2194
2195   return pub_keyblock;
2196 }
2197
2198 /****************
2199  * Ditto for secret keys.  Handling is simpler than for public keys.
2200  * We allow secret key importing only when allow is true, this is so
2201  * that a secret key can not be imported accidentally and thereby tampering
2202  * with the trust calculation.
2203  */
2204 static int
2205 import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
2206                    struct import_stats_s *stats, int batch, unsigned int options,
2207                    int for_migration,
2208                    import_screener_t screener, void *screener_arg)
2209 {
2210   PKT_public_key *pk;
2211   struct seckey_info *ski;
2212   kbnode_t node, uidnode;
2213   u32 keyid[2];
2214   int rc = 0;
2215   int nr_prev;
2216   kbnode_t pub_keyblock;
2217   char pkstrbuf[PUBKEY_STRING_SIZE];
2218
2219   /* Get the key and print some info about it */
2220   node = find_kbnode (keyblock, PKT_SECRET_KEY);
2221   if (!node)
2222     BUG ();
2223
2224   pk = node->pkt->pkt.public_key;
2225
2226   keyid_from_pk (pk, keyid);
2227   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
2228
2229   if (screener && screener (keyblock, screener_arg))
2230     {
2231       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
2232                  _("rejected by import screener"));
2233       return 0;
2234   }
2235
2236   if (opt.verbose && !for_migration)
2237     {
2238       log_info ("sec  %s/%s %s   ",
2239                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2240                 keystr_from_pk (pk), datestr_from_pk (pk));
2241       if (uidnode)
2242         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
2243                            uidnode->pkt->pkt.user_id->len);
2244       log_printf ("\n");
2245     }
2246   stats->secret_read++;
2247
2248   if ((options & IMPORT_NO_SECKEY))
2249     {
2250       if (!for_migration)
2251         log_error (_("importing secret keys not allowed\n"));
2252       return 0;
2253     }
2254
2255   if (!uidnode)
2256     {
2257       if (!for_migration)
2258         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
2259       return 0;
2260     }
2261
2262   ski = pk->seckey_info;
2263   if (!ski)
2264     {
2265       /* Actually an internal error.  */
2266       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
2267       return 0;
2268     }
2269
2270   /* A quick check to not import keys with an invalid protection
2271      cipher algorithm (only checks the primary key, though).  */
2272   if (ski->algo > 110)
2273     {
2274       if (!for_migration)
2275         log_error (_("key %s: secret key with invalid cipher %d"
2276                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
2277       return 0;
2278     }
2279
2280 #ifdef ENABLE_SELINUX_HACKS
2281   if (1)
2282     {
2283       /* We don't allow importing secret keys because that may be used
2284          to put a secret key into the keyring and the user might later
2285          be tricked into signing stuff with that key.  */
2286       log_error (_("importing secret keys not allowed\n"));
2287       return 0;
2288     }
2289 #endif
2290
2291   clear_kbnode_flags (keyblock);
2292
2293   nr_prev = stats->skipped_new_keys;
2294
2295   /* Make a public key out of the key. */
2296   pub_keyblock = sec_to_pub_keyblock (keyblock);
2297   if (!pub_keyblock)
2298     log_error ("key %s: failed to create public key from secret key\n",
2299                    keystr_from_pk (pk));
2300   else
2301     {
2302       /* Note that this outputs an IMPORT_OK status message for the
2303          public key block, and below we will output another one for
2304          the secret keys.  FIXME?  */
2305       import_one (ctrl, pub_keyblock, stats,
2306                   NULL, NULL, options, 1, for_migration,
2307                   screener, screener_arg, 0);
2308
2309       /* Fixme: We should check for an invalid keyblock and
2310          cancel the secret key import in this case.  */
2311       release_kbnode (pub_keyblock);
2312
2313       /* At least we cancel the secret key import when the public key
2314          import was skipped due to MERGE_ONLY option and a new
2315          key.  */
2316       if (stats->skipped_new_keys <= nr_prev)
2317         {
2318           /* Read the keyblock again to get the effects of a merge.  */
2319           /* Fixme: we should do this based on the fingerprint or
2320              even better let import_one return the merged
2321              keyblock.  */
2322           node = get_pubkeyblock (ctrl, keyid);
2323           if (!node)
2324             log_error ("key %s: failed to re-lookup public key\n",
2325                        keystr_from_pk (pk));
2326           else
2327             {
2328               gpg_error_t err;
2329
2330               /* transfer_secret_keys collects subkey stats.  */
2331               struct import_stats_s subkey_stats = {0};
2332
2333               err = transfer_secret_keys (ctrl, &subkey_stats, keyblock,
2334                                           batch, 0);
2335               if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
2336                 {
2337                   /* TRANSLATORS: For smartcard, each private key on
2338                      host has a reference (stub) to a smartcard and
2339                      actual private key data is stored on the card.  A
2340                      single smartcard can have up to three private key
2341                      data.  Importing private key stub is always
2342                      skipped in 2.1, and it returns
2343                      GPG_ERR_NOT_PROCESSED.  Instead, user should be
2344                      suggested to run 'gpg --card-status', then,
2345                      references to a card will be automatically
2346                      created again.  */
2347                   log_info (_("To migrate '%s', with each smartcard, "
2348                               "run: %s\n"), "secring.gpg", "gpg --card-status");
2349                   err = 0;
2350                 }
2351               if (!err)
2352                 {
2353                   int status = 16;
2354                   if (!opt.quiet)
2355                     log_info (_("key %s: secret key imported\n"),
2356                               keystr_from_pk (pk));
2357                   if (subkey_stats.secret_imported)
2358                     {
2359                       status |= 1;
2360                       stats->secret_imported += 1;
2361                     }
2362                   if (subkey_stats.secret_dups)
2363                     stats->secret_dups += 1;
2364
2365                   if (is_status_enabled ())
2366                     print_import_ok (pk, status);
2367                   check_prefs (ctrl, node);
2368                 }
2369               release_kbnode (node);
2370             }
2371         }
2372     }
2373
2374   return rc;
2375 }
2376
2377
2378 /****************
2379  * Import a revocation certificate; this is a single signature packet.
2380  */
2381 static int
2382 import_revoke_cert (ctrl_t ctrl, kbnode_t node, struct import_stats_s *stats)
2383 {
2384   PKT_public_key *pk = NULL;
2385   kbnode_t onode;
2386   kbnode_t keyblock = NULL;
2387   KEYDB_HANDLE hd = NULL;
2388   u32 keyid[2];
2389   int rc = 0;
2390
2391   log_assert (!node->next );
2392   log_assert (node->pkt->pkttype == PKT_SIGNATURE );
2393   log_assert (node->pkt->pkt.signature->sig_class == 0x20 );
2394
2395   keyid[0] = node->pkt->pkt.signature->keyid[0];
2396   keyid[1] = node->pkt->pkt.signature->keyid[1];
2397
2398   pk = xmalloc_clear( sizeof *pk );
2399   rc = get_pubkey (ctrl, pk, keyid );
2400   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
2401     {
2402       log_error(_("key %s: no public key -"
2403                   " can't apply revocation certificate\n"), keystr(keyid));
2404       rc = 0;
2405       goto leave;
2406     }
2407   else if (rc )
2408     {
2409       log_error(_("key %s: public key not found: %s\n"),
2410                 keystr(keyid), gpg_strerror (rc));
2411       goto leave;
2412     }
2413
2414   /* Read the original keyblock. */
2415   hd = keydb_new ();
2416   if (!hd)
2417     {
2418       rc = gpg_error_from_syserror ();
2419       goto leave;
2420     }
2421
2422   {
2423     byte afp[MAX_FINGERPRINT_LEN];
2424     size_t an;
2425
2426     fingerprint_from_pk (pk, afp, &an);
2427     while (an < MAX_FINGERPRINT_LEN)
2428       afp[an++] = 0;
2429     rc = keydb_search_fpr (hd, afp);
2430   }
2431   if (rc)
2432     {
2433       log_error (_("key %s: can't locate original keyblock: %s\n"),
2434                  keystr(keyid), gpg_strerror (rc));
2435       goto leave;
2436     }
2437   rc = keydb_get_keyblock (hd, &keyblock );
2438   if (rc)
2439     {
2440       log_error (_("key %s: can't read original keyblock: %s\n"),
2441                  keystr(keyid), gpg_strerror (rc));
2442       goto leave;
2443     }
2444
2445   /* it is okay, that node is not in keyblock because
2446    * check_key_signature works fine for sig_class 0x20 in this
2447    * special case. */
2448   rc = check_key_signature (ctrl, keyblock, node, NULL);
2449   if (rc )
2450     {
2451       log_error( _("key %s: invalid revocation certificate"
2452                    ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
2453       goto leave;
2454     }
2455
2456   /* check whether we already have this */
2457   for(onode=keyblock->next; onode; onode=onode->next ) {
2458     if (onode->pkt->pkttype == PKT_USER_ID )
2459       break;
2460     else if (onode->pkt->pkttype == PKT_SIGNATURE
2461              && !cmp_signatures(node->pkt->pkt.signature,
2462                                 onode->pkt->pkt.signature))
2463       {
2464         rc = 0;
2465         goto leave; /* yes, we already know about it */
2466       }
2467   }
2468
2469   /* insert it */
2470   insert_kbnode( keyblock, clone_kbnode(node), 0 );
2471
2472   /* and write the keyblock back */
2473   rc = keydb_update_keyblock (ctrl, hd, keyblock );
2474   if (rc)
2475     log_error (_("error writing keyring '%s': %s\n"),
2476                keydb_get_resource_name (hd), gpg_strerror (rc) );
2477   keydb_release (hd);
2478   hd = NULL;
2479
2480   /* we are ready */
2481   if (!opt.quiet )
2482     {
2483       char *p=get_user_id_native (ctrl, keyid);
2484       log_info( _("key %s: \"%s\" revocation certificate imported\n"),
2485                 keystr(keyid),p);
2486       xfree(p);
2487     }
2488   stats->n_revoc++;
2489
2490   /* If the key we just revoked was ultimately trusted, remove its
2491      ultimate trust.  This doesn't stop the user from putting the
2492      ultimate trust back, but is a reasonable solution for now. */
2493   if (get_ownertrust (ctrl, pk) == TRUST_ULTIMATE)
2494     clear_ownertrusts (ctrl, pk);
2495
2496   revalidation_mark (ctrl);
2497
2498  leave:
2499   keydb_release (hd);
2500   release_kbnode( keyblock );
2501   free_public_key( pk );
2502   return rc;
2503 }
2504
2505
2506 /* Loop over the keyblock and check all self signatures.  On return
2507  * the following bis in the node flags are set:
2508  *
2509  * - NODE_GOOD_SELFSIG  :: User ID or subkey has a self-signature
2510  * - NODE_BAD_SELFSIG   :: Used ID or subkey has an invalid self-signature
2511  * - NODE_DELETION_MARK :: This node shall be deleted
2512  *
2513  * NON_SELF is set to true if there are any sigs other than self-sigs
2514  * in this keyblock.
2515  *
2516  * Returns 0 on success or -1 (but not an error code) if the keyblock
2517  * is invalid.
2518  */
2519 static int
2520 chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid, int *non_self)
2521 {
2522   kbnode_t n, knode = NULL;
2523   PKT_signature *sig;
2524   int rc;
2525   u32 bsdate=0, rsdate=0;
2526   kbnode_t bsnode = NULL, rsnode = NULL;
2527
2528   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
2529     {
2530       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2531         {
2532           knode = n;
2533           bsdate = 0;
2534           rsdate = 0;
2535           bsnode = NULL;
2536           rsnode = NULL;
2537           continue;
2538         }
2539
2540       if ( n->pkt->pkttype != PKT_SIGNATURE )
2541         continue;
2542
2543       sig = n->pkt->pkt.signature;
2544       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
2545         {
2546           *non_self = 1;
2547           continue;
2548         }
2549
2550       /* This just caches the sigs for later use.  That way we
2551          import a fully-cached key which speeds things up. */
2552       if (!opt.no_sig_cache)
2553         check_key_signature (ctrl, keyblock, n, NULL);
2554
2555       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
2556         {
2557           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
2558           if ( !unode )
2559             {
2560               log_error( _("key %s: no user ID for signature\n"),
2561                          keystr(keyid));
2562               return -1;  /* The complete keyblock is invalid.  */
2563             }
2564
2565           /* If it hasn't been marked valid yet, keep trying.  */
2566           if (!(unode->flag & NODE_GOOD_SELFSIG))
2567             {
2568               rc = check_key_signature (ctrl, keyblock, n, NULL);
2569               if ( rc )
2570                 {
2571                   if ( opt.verbose )
2572                     {
2573                       char *p = utf8_to_native
2574                         (unode->pkt->pkt.user_id->name,
2575                          strlen (unode->pkt->pkt.user_id->name),0);
2576                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
2577                                 _("key %s: unsupported public key "
2578                                   "algorithm on user ID \"%s\"\n"):
2579                                 _("key %s: invalid self-signature "
2580                                   "on user ID \"%s\"\n"),
2581                                 keystr (keyid),p);
2582                       xfree (p);
2583                     }
2584                 }
2585               else
2586                 unode->flag |= NODE_GOOD_SELFSIG;
2587             }
2588         }
2589       else if (IS_KEY_SIG (sig))
2590         {
2591           rc = check_key_signature (ctrl, keyblock, n, NULL);
2592           if ( rc )
2593             {
2594               if (opt.verbose)
2595                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2596                           _("key %s: unsupported public key algorithm\n"):
2597                           _("key %s: invalid direct key signature\n"),
2598                           keystr (keyid));
2599               n->flag |= NODE_DELETION_MARK;
2600             }
2601         }
2602       else if ( IS_SUBKEY_SIG (sig) )
2603         {
2604           /* Note that this works based solely on the timestamps like
2605              the rest of gpg.  If the standard gets revocation
2606              targets, this may need to be revised.  */
2607
2608           if ( !knode )
2609             {
2610               if (opt.verbose)
2611                 log_info (_("key %s: no subkey for key binding\n"),
2612                           keystr (keyid));
2613               n->flag |= NODE_DELETION_MARK;
2614             }
2615           else
2616             {
2617               rc = check_key_signature (ctrl, keyblock, n, NULL);
2618               if ( rc )
2619                 {
2620                   if (opt.verbose)
2621                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2622                               _("key %s: unsupported public key"
2623                                 " algorithm\n"):
2624                               _("key %s: invalid subkey binding\n"),
2625                               keystr (keyid));
2626                   n->flag |= NODE_DELETION_MARK;
2627                 }
2628               else
2629                 {
2630                   /* It's valid, so is it newer? */
2631                   if (sig->timestamp >= bsdate)
2632                     {
2633                       knode->flag |= NODE_GOOD_SELFSIG; /* Subkey is valid.  */
2634                       if (bsnode)
2635                         {
2636                           /* Delete the last binding sig since this
2637                              one is newer */
2638                           bsnode->flag |= NODE_DELETION_MARK;
2639                           if (opt.verbose)
2640                             log_info (_("key %s: removed multiple subkey"
2641                                         " binding\n"),keystr(keyid));
2642                         }
2643
2644                       bsnode = n;
2645                       bsdate = sig->timestamp;
2646                     }
2647                   else
2648                     n->flag |= NODE_DELETION_MARK; /* older */
2649                 }
2650             }
2651         }
2652       else if ( IS_SUBKEY_REV (sig) )
2653         {
2654           /* We don't actually mark the subkey as revoked right now,
2655              so just check that the revocation sig is the most recent
2656              valid one.  Note that we don't care if the binding sig is
2657              newer than the revocation sig.  See the comment in
2658              getkey.c:merge_selfsigs_subkey for more.  */
2659           if ( !knode )
2660             {
2661               if (opt.verbose)
2662                 log_info (_("key %s: no subkey for key revocation\n"),
2663                           keystr(keyid));
2664               n->flag |= NODE_DELETION_MARK;
2665             }
2666           else
2667             {
2668               rc = check_key_signature (ctrl, keyblock, n, NULL);
2669               if ( rc )
2670                 {
2671                   if(opt.verbose)
2672                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2673                               _("key %s: unsupported public"
2674                                 " key algorithm\n"):
2675                               _("key %s: invalid subkey revocation\n"),
2676                               keystr(keyid));
2677                   n->flag |= NODE_DELETION_MARK;
2678                 }
2679               else
2680                 {
2681                   /* It's valid, so is it newer? */
2682                   if (sig->timestamp >= rsdate)
2683                     {
2684                       if (rsnode)
2685                         {
2686                           /* Delete the last revocation sig since
2687                              this one is newer.  */
2688                           rsnode->flag |= NODE_DELETION_MARK;
2689                           if (opt.verbose)
2690                             log_info (_("key %s: removed multiple subkey"
2691                                         " revocation\n"),keystr(keyid));
2692                         }
2693
2694                       rsnode = n;
2695                       rsdate = sig->timestamp;
2696                     }
2697                   else
2698                     n->flag |= NODE_DELETION_MARK; /* older */
2699                 }
2700             }
2701         }
2702     }
2703
2704   return 0;
2705 }
2706
2707
2708 /* Delete all parts which are invalid and those signatures whose
2709  * public key algorithm is not available in this implementation; but
2710  * consider RSA as valid, because parse/build_packets knows about it.
2711  *
2712  * Returns: True if at least one valid user-id is left over.
2713  */
2714 static int
2715 delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
2716                   unsigned int options)
2717 {
2718   kbnode_t node;
2719   int nvalid=0, uid_seen=0, subkey_seen=0;
2720
2721   for (node=keyblock->next; node; node = node->next )
2722     {
2723       if (node->pkt->pkttype == PKT_USER_ID)
2724         {
2725           uid_seen = 1;
2726           if ((node->flag & NODE_BAD_SELFSIG)
2727               || !(node->flag & NODE_GOOD_SELFSIG))
2728             {
2729               if (opt.verbose )
2730                 {
2731                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
2732                                          node->pkt->pkt.user_id->len,0);
2733                   log_info( _("key %s: skipped user ID \"%s\"\n"),
2734                             keystr(keyid),p);
2735                   xfree(p);
2736                 }
2737               delete_kbnode( node ); /* the user-id */
2738               /* and all following packets up to the next user-id */
2739               while (node->next
2740                      && node->next->pkt->pkttype != PKT_USER_ID
2741                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
2742                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
2743                 delete_kbnode( node->next );
2744                 node = node->next;
2745               }
2746             }
2747           else
2748             nvalid++;
2749         }
2750       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2751                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
2752         {
2753           if ((node->flag & NODE_BAD_SELFSIG)
2754               || !(node->flag & NODE_GOOD_SELFSIG))
2755             {
2756               if (opt.verbose )
2757                 log_info( _("key %s: skipped subkey\n"),keystr(keyid));
2758
2759               delete_kbnode( node ); /* the subkey */
2760               /* and all following signature packets */
2761               while (node->next
2762                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
2763                 delete_kbnode( node->next );
2764                 node = node->next;
2765               }
2766             }
2767           else
2768             subkey_seen = 1;
2769         }
2770       else if (node->pkt->pkttype == PKT_SIGNATURE
2771                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
2772                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
2773         {
2774           delete_kbnode( node ); /* build_packet() can't handle this */
2775         }
2776       else if (node->pkt->pkttype == PKT_SIGNATURE
2777                && !node->pkt->pkt.signature->flags.exportable
2778                && !(options&IMPORT_LOCAL_SIGS)
2779                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
2780         {
2781           /* here we violate the rfc a bit by still allowing
2782            * to import non-exportable signature when we have the
2783            * the secret key used to create this signature - it
2784            * seems that this makes sense */
2785           if(opt.verbose)
2786             log_info( _("key %s: non exportable signature"
2787                         " (class 0x%02X) - skipped\n"),
2788                       keystr(keyid), node->pkt->pkt.signature->sig_class );
2789           delete_kbnode( node );
2790         }
2791       else if (node->pkt->pkttype == PKT_SIGNATURE
2792                && node->pkt->pkt.signature->sig_class == 0x20)
2793         {
2794           if (uid_seen )
2795             {
2796               if(opt.verbose)
2797                 log_info( _("key %s: revocation certificate"
2798                             " at wrong place - skipped\n"),keystr(keyid));
2799               delete_kbnode( node );
2800             }
2801           else
2802             {
2803               /* If the revocation cert is from a different key than
2804                  the one we're working on don't check it - it's
2805                  probably from a revocation key and won't be
2806                  verifiable with this key anyway. */
2807
2808               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
2809                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
2810                 {
2811                   int rc = check_key_signature (ctrl, keyblock, node, NULL);
2812                   if (rc )
2813                     {
2814                       if(opt.verbose)
2815                         log_info( _("key %s: invalid revocation"
2816                                     " certificate: %s - skipped\n"),
2817                                   keystr(keyid), gpg_strerror (rc));
2818                       delete_kbnode( node );
2819                     }
2820                 }
2821             }
2822         }
2823       else if (node->pkt->pkttype == PKT_SIGNATURE
2824                && (node->pkt->pkt.signature->sig_class == 0x18
2825                    || node->pkt->pkt.signature->sig_class == 0x28)
2826                && !subkey_seen )
2827         {
2828           if(opt.verbose)
2829             log_info( _("key %s: subkey signature"
2830                         " in wrong place - skipped\n"), keystr(keyid));
2831           delete_kbnode( node );
2832         }
2833       else if (node->pkt->pkttype == PKT_SIGNATURE
2834                && !IS_CERT(node->pkt->pkt.signature))
2835         {
2836           if(opt.verbose)
2837             log_info(_("key %s: unexpected signature class (0x%02X) -"
2838                        " skipped\n"),keystr(keyid),
2839                      node->pkt->pkt.signature->sig_class);
2840           delete_kbnode(node);
2841           }
2842       else if ((node->flag & NODE_DELETION_MARK))
2843         delete_kbnode( node );
2844     }
2845
2846   /* note: because keyblock is the public key, it is never marked
2847    * for deletion and so keyblock cannot change */
2848   commit_kbnode( &keyblock );
2849   return nvalid;
2850 }
2851
2852 /* This function returns true if any UID is left in the keyring.  */
2853 static int
2854 any_uid_left (kbnode_t keyblock)
2855 {
2856   kbnode_t node;
2857
2858   for (node=keyblock->next; node; node = node->next)
2859     if (node->pkt->pkttype == PKT_USER_ID)
2860       return 1;
2861   return 0;
2862 }
2863
2864
2865
2866 /****************
2867  * It may happen that the imported keyblock has duplicated user IDs.
2868  * We check this here and collapse those user IDs together with their
2869  * sigs into one.
2870  * Returns: True if the keyblock has changed.
2871  */
2872 int
2873 collapse_uids( kbnode_t *keyblock )
2874 {
2875   kbnode_t uid1;
2876   int any=0;
2877
2878   for(uid1=*keyblock;uid1;uid1=uid1->next)
2879     {
2880       kbnode_t uid2;
2881
2882       if(is_deleted_kbnode(uid1))
2883         continue;
2884
2885       if(uid1->pkt->pkttype!=PKT_USER_ID)
2886         continue;
2887
2888       for(uid2=uid1->next;uid2;uid2=uid2->next)
2889         {
2890           if(is_deleted_kbnode(uid2))
2891             continue;
2892
2893           if(uid2->pkt->pkttype!=PKT_USER_ID)
2894             continue;
2895
2896           if(cmp_user_ids(uid1->pkt->pkt.user_id,
2897                           uid2->pkt->pkt.user_id)==0)
2898             {
2899               /* We have a duplicated uid */
2900               kbnode_t sig1,last;
2901
2902               any=1;
2903
2904               /* Now take uid2's signatures, and attach them to
2905                  uid1 */
2906               for(last=uid2;last->next;last=last->next)
2907                 {
2908                   if(is_deleted_kbnode(last))
2909                     continue;
2910
2911                   if(last->next->pkt->pkttype==PKT_USER_ID
2912                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
2913                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
2914                     break;
2915                 }
2916
2917               /* Snip out uid2 */
2918               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
2919
2920               /* Now put uid2 in place as part of uid1 */
2921               last->next=uid1->next;
2922               uid1->next=uid2;
2923               delete_kbnode(uid2);
2924
2925               /* Now dedupe uid1 */
2926               for(sig1=uid1->next;sig1;sig1=sig1->next)
2927                 {
2928                   kbnode_t sig2;
2929
2930                   if(is_deleted_kbnode(sig1))
2931                     continue;
2932
2933                   if(sig1->pkt->pkttype==PKT_USER_ID
2934                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
2935                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
2936                     break;
2937
2938                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
2939                     continue;
2940
2941                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
2942                     {
2943                       if(is_deleted_kbnode(sig2))
2944                         continue;
2945
2946                       if(sig2->pkt->pkttype==PKT_USER_ID
2947                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
2948                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
2949                         break;
2950
2951                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
2952                         continue;
2953
2954                       if(cmp_signatures(sig1->pkt->pkt.signature,
2955                                         sig2->pkt->pkt.signature)==0)
2956                         {
2957                           /* We have a match, so delete the second
2958                              signature */
2959                           delete_kbnode(sig2);
2960                           sig2=last;
2961                         }
2962                     }
2963                 }
2964             }
2965         }
2966     }
2967
2968   commit_kbnode(keyblock);
2969
2970   if(any && !opt.quiet)
2971     {
2972       const char *key="???";
2973
2974       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
2975         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2976       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
2977         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2978
2979       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
2980     }
2981
2982   return any;
2983 }
2984
2985
2986 /* Check for a 0x20 revocation from a revocation key that is not
2987    present.  This may be called without the benefit of merge_xxxx so
2988    you can't rely on pk->revkey and friends. */
2989 static void
2990 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
2991 {
2992   kbnode_t onode, inode;
2993   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2994
2995   for(onode=keyblock->next;onode;onode=onode->next)
2996     {
2997       /* If we reach user IDs, we're done. */
2998       if(onode->pkt->pkttype==PKT_USER_ID)
2999         break;
3000
3001       if(onode->pkt->pkttype==PKT_SIGNATURE &&
3002          onode->pkt->pkt.signature->sig_class==0x1F &&
3003          onode->pkt->pkt.signature->revkey)
3004         {
3005           int idx;
3006           PKT_signature *sig=onode->pkt->pkt.signature;
3007
3008           for(idx=0;idx<sig->numrevkeys;idx++)
3009             {
3010               u32 keyid[2];
3011
3012               keyid_from_fingerprint (ctrl, sig->revkey[idx].fpr,
3013                                       MAX_FINGERPRINT_LEN, keyid);
3014
3015               for(inode=keyblock->next;inode;inode=inode->next)
3016                 {
3017                   /* If we reach user IDs, we're done. */
3018                   if(inode->pkt->pkttype==PKT_USER_ID)
3019                     break;
3020
3021                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
3022                      inode->pkt->pkt.signature->sig_class==0x20 &&
3023                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
3024                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
3025                     {
3026                       /* Okay, we have a revocation key, and a
3027                          revocation issued by it.  Do we have the key
3028                          itself? */
3029                       int rc;
3030
3031                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx].fpr,
3032                                                    MAX_FINGERPRINT_LEN);
3033                       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
3034                           || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
3035                         {
3036                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
3037
3038                           /* No, so try and get it */
3039                           if ((opt.keyserver_options.options
3040                                & KEYSERVER_AUTO_KEY_RETRIEVE)
3041                               && keyserver_any_configured (ctrl))
3042                             {
3043                               log_info(_("WARNING: key %s may be revoked:"
3044                                          " fetching revocation key %s\n"),
3045                                        tempkeystr,keystr(keyid));
3046                               keyserver_import_fprint (ctrl,
3047                                                        sig->revkey[idx].fpr,
3048                                                        MAX_FINGERPRINT_LEN,
3049                                                        opt.keyserver, 0);
3050
3051                               /* Do we have it now? */
3052                               rc=get_pubkey_byfprint_fast (NULL,
3053                                                      sig->revkey[idx].fpr,
3054                                                      MAX_FINGERPRINT_LEN);
3055                             }
3056
3057                           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
3058                               || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
3059                             log_info(_("WARNING: key %s may be revoked:"
3060                                        " revocation key %s not present.\n"),
3061                                      tempkeystr,keystr(keyid));
3062
3063                           xfree(tempkeystr);
3064                         }
3065                     }
3066                 }
3067             }
3068         }
3069     }
3070 }
3071
3072
3073 /*
3074  * compare and merge the blocks
3075  *
3076  * o compare the signatures: If we already have this signature, check
3077  *   that they compare okay; if not, issue a warning and ask the user.
3078  * o Simply add the signature.  Can't verify here because we may not have
3079  *   the signature's public key yet; verification is done when putting it
3080  *   into the trustdb, which is done automagically as soon as this pubkey
3081  *   is used.
3082  * Note: We indicate newly inserted packets with NODE_FLAG_A.
3083  */
3084 static int
3085 merge_blocks (ctrl_t ctrl, kbnode_t keyblock_orig, kbnode_t keyblock,
3086               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
3087 {
3088   kbnode_t onode, node;
3089   int rc, found;
3090
3091   /* 1st: handle revocation certificates */
3092   for (node=keyblock->next; node; node=node->next )
3093     {
3094       if (node->pkt->pkttype == PKT_USER_ID )
3095         break;
3096       else if (node->pkt->pkttype == PKT_SIGNATURE
3097                && node->pkt->pkt.signature->sig_class == 0x20)
3098         {
3099           /* check whether we already have this */
3100           found = 0;
3101           for (onode=keyblock_orig->next; onode; onode=onode->next)
3102             {
3103               if (onode->pkt->pkttype == PKT_USER_ID )
3104                 break;
3105               else if (onode->pkt->pkttype == PKT_SIGNATURE
3106                        && onode->pkt->pkt.signature->sig_class == 0x20
3107                        && !cmp_signatures(onode->pkt->pkt.signature,
3108                                           node->pkt->pkt.signature))
3109                 {
3110                   found = 1;
3111                   break;
3112                 }
3113             }
3114           if (!found)
3115             {
3116               kbnode_t n2 = clone_kbnode(node);
3117               insert_kbnode( keyblock_orig, n2, 0 );
3118               n2->flag |= NODE_FLAG_A;
3119               ++*n_sigs;
3120               if(!opt.quiet)
3121                 {
3122                   char *p = get_user_id_native (ctrl, keyid);
3123                   log_info(_("key %s: \"%s\" revocation"
3124                              " certificate added\n"), keystr(keyid),p);
3125                   xfree(p);
3126                 }
3127             }
3128         }
3129     }
3130
3131   /* 2nd: merge in any direct key (0x1F) sigs */
3132   for(node=keyblock->next; node; node=node->next)
3133     {
3134       if (node->pkt->pkttype == PKT_USER_ID )
3135         break;
3136       else if (node->pkt->pkttype == PKT_SIGNATURE
3137                && node->pkt->pkt.signature->sig_class == 0x1F)
3138         {
3139           /* check whether we already have this */
3140           found = 0;
3141           for (onode=keyblock_orig->next; onode; onode=onode->next)
3142             {
3143               if (onode->pkt->pkttype == PKT_USER_ID)
3144                 break;
3145               else if (onode->pkt->pkttype == PKT_SIGNATURE
3146                        && onode->pkt->pkt.signature->sig_class == 0x1F
3147                        && !cmp_signatures(onode->pkt->pkt.signature,
3148                                           node->pkt->pkt.signature))
3149                 {
3150                   found = 1;
3151                   break;
3152                 }
3153             }
3154           if (!found )
3155             {
3156               kbnode_t n2 = clone_kbnode(node);
3157               insert_kbnode( keyblock_orig, n2, 0 );
3158               n2->flag |= NODE_FLAG_A;
3159               ++*n_sigs;
3160               if(!opt.quiet)
3161                 log_info( _("key %s: direct key signature added\n"),
3162                           keystr(keyid));
3163             }
3164         }
3165     }
3166
3167   /* 3rd: try to merge new certificates in */
3168   for (onode=keyblock_orig->next; onode; onode=onode->next)
3169     {
3170       if (!(onode->flag & NODE_FLAG_A) && onode->pkt->pkttype == PKT_USER_ID)
3171         {
3172           /* find the user id in the imported keyblock */
3173           for (node=keyblock->next; node; node=node->next)
3174             if (node->pkt->pkttype == PKT_USER_ID
3175                 && !cmp_user_ids( onode->pkt->pkt.user_id,
3176                                   node->pkt->pkt.user_id ) )
3177               break;
3178           if (node ) /* found: merge */
3179             {
3180               rc = merge_sigs (onode, node, n_sigs);
3181               if (rc )
3182                 return rc;
3183             }
3184         }
3185     }
3186
3187   /* 4th: add new user-ids */
3188   for (node=keyblock->next; node; node=node->next)
3189     {
3190       if (node->pkt->pkttype == PKT_USER_ID)
3191         {
3192           /* do we have this in the original keyblock */
3193           for (onode=keyblock_orig->next; onode; onode=onode->next )
3194             if (onode->pkt->pkttype == PKT_USER_ID
3195                 && !cmp_user_ids( onode->pkt->pkt.user_id,
3196                                   node->pkt->pkt.user_id ) )
3197               break;
3198           if (!onode ) /* this is a new user id: append */
3199             {
3200               rc = append_uid (keyblock_orig, node, n_sigs);
3201               if (rc )
3202                 return rc;
3203               ++*n_uids;
3204             }
3205         }
3206     }
3207
3208   /* 5th: add new subkeys */
3209   for (node=keyblock->next; node; node=node->next)
3210     {
3211       onode = NULL;
3212       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3213         {
3214           /* do we have this in the original keyblock? */
3215           for(onode=keyblock_orig->next; onode; onode=onode->next)
3216             if (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
3217                 && !cmp_public_keys( onode->pkt->pkt.public_key,
3218                                      node->pkt->pkt.public_key))
3219               break;
3220           if (!onode ) /* This is a new subkey: append.  */
3221             {
3222               rc = append_key (keyblock_orig, node, n_sigs);
3223               if (rc)
3224                 return rc;
3225               ++*n_subk;
3226             }
3227         }
3228       else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
3229         {
3230           /* do we have this in the original keyblock? */
3231           for (onode=keyblock_orig->next; onode; onode=onode->next )
3232             if (onode->pkt->pkttype == PKT_SECRET_SUBKEY
3233                 && !cmp_public_keys (onode->pkt->pkt.public_key,
3234                                      node->pkt->pkt.public_key) )
3235               break;
3236           if (!onode ) /* This is a new subkey: append.  */
3237             {
3238               rc = append_key (keyblock_orig, node, n_sigs);
3239               if (rc )
3240                 return rc;
3241               ++*n_subk;
3242             }
3243         }
3244     }
3245
3246   /* 6th: merge subkey certificates */
3247   for (onode=keyblock_orig->next; onode; onode=onode->next)
3248     {
3249       if (!(onode->flag & NODE_FLAG_A)
3250           && (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
3251               || onode->pkt->pkttype == PKT_SECRET_SUBKEY))
3252         {
3253           /* find the subkey in the imported keyblock */
3254           for(node=keyblock->next; node; node=node->next)
3255             {
3256               if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3257                    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
3258                   && !cmp_public_keys( onode->pkt->pkt.public_key,
3259                                        node->pkt->pkt.public_key ) )
3260                 break;
3261             }
3262           if (node) /* Found: merge.  */
3263             {
3264               rc = merge_keysigs( onode, node, n_sigs);
3265               if (rc )
3266                 return rc;
3267             }
3268         }
3269     }
3270
3271   return 0;
3272 }
3273
3274
3275 /* Helper function for merge_blocks.
3276  * Append the userid starting with NODE and all signatures to KEYBLOCK.
3277  */
3278 static int
3279 append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs)
3280 {
3281   kbnode_t n;
3282   kbnode_t n_where = NULL;
3283
3284   log_assert (node->pkt->pkttype == PKT_USER_ID );
3285
3286   /* find the position */
3287   for (n = keyblock; n; n_where = n, n = n->next)
3288     {
3289       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
3290           || n->pkt->pkttype == PKT_SECRET_SUBKEY )
3291         break;
3292     }
3293   if (!n)
3294     n_where = NULL;
3295
3296   /* and append/insert */
3297   while (node)
3298     {
3299       /* we add a clone to the original keyblock, because this
3300        * one is released first */
3301       n = clone_kbnode(node);
3302       if (n_where)
3303         {
3304           insert_kbnode( n_where, n, 0 );
3305           n_where = n;
3306         }
3307       else
3308         add_kbnode( keyblock, n );
3309       n->flag |= NODE_FLAG_A;
3310       node->flag |= NODE_FLAG_A;
3311       if (n->pkt->pkttype == PKT_SIGNATURE )
3312         ++*n_sigs;
3313
3314       node = node->next;
3315       if (node && node->pkt->pkttype != PKT_SIGNATURE )
3316         break;
3317     }
3318
3319   return 0;
3320 }
3321
3322
3323 /* Helper function for merge_blocks
3324  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
3325  * (how should we handle comment packets here?)
3326  */
3327 static int
3328 merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs)
3329 {
3330   kbnode_t n, n2;
3331   int found = 0;
3332
3333   log_assert (dst->pkt->pkttype == PKT_USER_ID);
3334   log_assert (src->pkt->pkttype == PKT_USER_ID);
3335
3336   for (n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next)
3337     {
3338       if (n->pkt->pkttype != PKT_SIGNATURE )
3339         continue;
3340       if (n->pkt->pkt.signature->sig_class == 0x18
3341           || n->pkt->pkt.signature->sig_class == 0x28 )
3342         continue; /* skip signatures which are only valid on subkeys */
3343
3344       found = 0;
3345       for (n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
3346         if (!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
3347           {
3348             found++;
3349             break;
3350           }
3351       if (!found )
3352         {
3353           /* This signature is new or newer, append N to DST.
3354            * We add a clone to the original keyblock, because this
3355            * one is released first */
3356           n2 = clone_kbnode(n);
3357           insert_kbnode( dst, n2, PKT_SIGNATURE );
3358           n2->flag |= NODE_FLAG_A;
3359           n->flag |= NODE_FLAG_A;
3360           ++*n_sigs;
3361         }
3362     }
3363
3364   return 0;
3365 }
3366
3367
3368 /* Helper function for merge_blocks
3369  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
3370  */
3371 static int
3372 merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs)
3373 {
3374   kbnode_t n, n2;
3375   int found = 0;
3376
3377   log_assert (dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
3378               || dst->pkt->pkttype == PKT_SECRET_SUBKEY);
3379
3380   for (n=src->next; n ; n = n->next)
3381     {
3382       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
3383           || n->pkt->pkttype == PKT_PUBLIC_KEY )
3384         break;
3385       if (n->pkt->pkttype != PKT_SIGNATURE )
3386         continue;
3387
3388       found = 0;
3389       for (n2=dst->next; n2; n2 = n2->next)
3390         {
3391           if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
3392               || n2->pkt->pkttype == PKT_PUBLIC_KEY )
3393             break;
3394           if (n2->pkt->pkttype == PKT_SIGNATURE
3395               && (n->pkt->pkt.signature->keyid[0]
3396                   == n2->pkt->pkt.signature->keyid[0])
3397               && (n->pkt->pkt.signature->keyid[1]
3398                   == n2->pkt->pkt.signature->keyid[1])
3399               && (n->pkt->pkt.signature->timestamp
3400                   <= n2->pkt->pkt.signature->timestamp)
3401               && (n->pkt->pkt.signature->sig_class
3402                   == n2->pkt->pkt.signature->sig_class))
3403             {
3404               found++;
3405               break;
3406             }
3407         }
3408       if (!found )
3409         {
3410           /* This signature is new or newer, append N to DST.
3411            * We add a clone to the original keyblock, because this
3412            * one is released first */
3413           n2 = clone_kbnode(n);
3414           insert_kbnode( dst, n2, PKT_SIGNATURE );
3415           n2->flag |= NODE_FLAG_A;
3416           n->flag |= NODE_FLAG_A;
3417           ++*n_sigs;
3418         }
3419     }
3420
3421   return 0;
3422 }
3423
3424
3425 /* Helper function for merge_blocks.
3426  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
3427  * Mark all new and copied packets by setting flag bit 0.
3428  */
3429 static int
3430 append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs)
3431 {
3432   kbnode_t n;
3433
3434   log_assert (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3435               || node->pkt->pkttype == PKT_SECRET_SUBKEY);
3436
3437   while (node)
3438     {
3439       /* we add a clone to the original keyblock, because this
3440        * one is released first */
3441       n = clone_kbnode(node);
3442       add_kbnode( keyblock, n );
3443       n->flag |= NODE_FLAG_A;
3444       node->flag |= NODE_FLAG_A;
3445       if (n->pkt->pkttype == PKT_SIGNATURE )
3446         ++*n_sigs;
3447
3448       node = node->next;
3449       if (node && node->pkt->pkttype != PKT_SIGNATURE )
3450         break;
3451     }
3452
3453   return 0;
3454 }