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