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