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