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