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