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