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