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