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