gpg: Do not import revocations with --show-keys.
[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, kbnode_t node, unsigned int options,
117                                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, options, 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 if (!strcmp (propname, "usage"))
1318         {
1319           snprintf (numbuf, sizeof numbuf, "%s%s%s%s%s",
1320                     (pk->pubkey_usage & PUBKEY_USAGE_ENC)?"e":"",
1321                     (pk->pubkey_usage & PUBKEY_USAGE_SIG)?"s":"",
1322                     (pk->pubkey_usage & PUBKEY_USAGE_CERT)?"c":"",
1323                     (pk->pubkey_usage & PUBKEY_USAGE_AUTH)?"a":"",
1324                     (pk->pubkey_usage & PUBKEY_USAGE_UNKNOWN)?"?":"");
1325           result = numbuf;
1326         }
1327       else
1328         result = NULL;
1329     }
1330   else
1331     result = NULL;
1332
1333   return result;
1334 }
1335
1336
1337 /*
1338  * Apply the keep-uid filter to the keyblock.  The deleted nodes are
1339  * marked and thus the caller should call commit_kbnode afterwards.
1340  * KEYBLOCK must not have any blocks marked as deleted.
1341  */
1342 static void
1343 apply_keep_uid_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
1344 {
1345   kbnode_t node;
1346   struct impex_filter_parm_s parm;
1347
1348   parm.ctrl = ctrl;
1349
1350   for (node = keyblock->next; node; node = node->next )
1351     {
1352       if (node->pkt->pkttype == PKT_USER_ID)
1353         {
1354           parm.node = node;
1355           if (!recsel_select (selector, impex_filter_getval, &parm))
1356             {
1357
1358               /* log_debug ("keep-uid: deleting '%s'\n", */
1359               /*            node->pkt->pkt.user_id->name); */
1360               /* The UID packet and all following packets up to the
1361                * next UID or a subkey.  */
1362               delete_kbnode (node);
1363               for (; node->next
1364                      && node->next->pkt->pkttype != PKT_USER_ID
1365                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1366                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
1367                    node = node->next)
1368                 delete_kbnode (node->next);
1369             }
1370           /* else */
1371           /*   log_debug ("keep-uid: keeping '%s'\n", */
1372           /*              node->pkt->pkt.user_id->name); */
1373         }
1374     }
1375 }
1376
1377
1378 /*
1379  * Apply the drop-sig filter to the keyblock.  The deleted nodes are
1380  * marked and thus the caller should call commit_kbnode afterwards.
1381  * KEYBLOCK must not have any blocks marked as deleted.
1382  */
1383 static void
1384 apply_drop_sig_filter (ctrl_t ctrl, kbnode_t keyblock, recsel_expr_t selector)
1385 {
1386   kbnode_t node;
1387   int active = 0;
1388   u32 main_keyid[2];
1389   PKT_signature *sig;
1390   struct impex_filter_parm_s parm;
1391
1392   parm.ctrl = ctrl;
1393
1394   keyid_from_pk (keyblock->pkt->pkt.public_key, main_keyid);
1395
1396   /* Loop over all signatures for user id and attribute packets which
1397    * are not self signatures.  */
1398   for (node = keyblock->next; node; node = node->next )
1399     {
1400       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1401           || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1402         break; /* ready.  */
1403       if (node->pkt->pkttype == PKT_USER_ID
1404           || node->pkt->pkttype == PKT_ATTRIBUTE)
1405         active = 1;
1406       if (!active)
1407         continue;
1408       if (node->pkt->pkttype != PKT_SIGNATURE)
1409         continue;
1410
1411       sig = node->pkt->pkt.signature;
1412       if (main_keyid[0] == sig->keyid[0] || main_keyid[1] == sig->keyid[1])
1413         continue;  /* Skip self-signatures.  */
1414
1415       if (IS_UID_SIG(sig) || IS_UID_REV(sig))
1416         {
1417           parm.node = node;
1418           if (recsel_select (selector, impex_filter_getval, &parm))
1419             delete_kbnode (node);
1420         }
1421     }
1422 }
1423
1424
1425 /* Insert a key origin into a public key packet.  */
1426 static gpg_error_t
1427 insert_key_origin_pk (PKT_public_key *pk, u32 curtime,
1428                       int origin, const char *url)
1429 {
1430   if (origin == KEYORG_WKD || origin == KEYORG_DANE)
1431     {
1432       /* For WKD and DANE we insert origin information also for the
1433        * key but we don't record the URL because we have have no use
1434        * for that: An update using a keyserver has higher precedence
1435        * and will thus update this origin info.  For refresh using WKD
1436        * or DANE we need to go via the User ID anyway.  Recall that we
1437        * are only inserting a new key. */
1438       pk->keyorg = origin;
1439       pk->keyupdate = curtime;
1440     }
1441   else if (origin == KEYORG_KS && url)
1442     {
1443       /* If the key was retrieved from a keyserver using a fingerprint
1444        * request we add the meta information.  Note that the use of a
1445        * fingerprint needs to be enforced by the caller of the import
1446        * function.  This is commonly triggered by verifying a modern
1447        * signature which has an Issuer Fingerprint signature
1448        * subpacket.  */
1449       pk->keyorg = origin;
1450       pk->keyupdate = curtime;
1451       xfree (pk->updateurl);
1452       pk->updateurl = xtrystrdup (url);
1453       if (!pk->updateurl)
1454         return gpg_error_from_syserror ();
1455     }
1456   else if (origin == KEYORG_FILE)
1457     {
1458       pk->keyorg = origin;
1459       pk->keyupdate = curtime;
1460     }
1461   else if (origin == KEYORG_URL)
1462     {
1463       pk->keyorg = origin;
1464       pk->keyupdate = curtime;
1465       if (url)
1466         {
1467           xfree (pk->updateurl);
1468           pk->updateurl = xtrystrdup (url);
1469           if (!pk->updateurl)
1470             return gpg_error_from_syserror ();
1471         }
1472     }
1473
1474   return 0;
1475 }
1476
1477
1478 /* Insert a key origin into a user id packet.  */
1479 static gpg_error_t
1480 insert_key_origin_uid (PKT_user_id *uid, u32 curtime,
1481                        int origin, const char *url)
1482
1483 {
1484   if (origin == KEYORG_WKD || origin == KEYORG_DANE)
1485     {
1486       /* We insert origin information on a UID only when we received
1487        * them via the Web Key Directory or a DANE record.  The key we
1488        * receive here from the WKD has been filtered to contain only
1489        * the user ID as looked up in the WKD.  For a DANE origin we
1490        * this should also be the case.  Thus we will see here only one
1491        * user id.  */
1492       uid->keyorg = origin;
1493       uid->keyupdate = curtime;
1494       if (url)
1495         {
1496           xfree (uid->updateurl);
1497           uid->updateurl = xtrystrdup (url);
1498           if (!uid->updateurl)
1499             return gpg_error_from_syserror ();
1500         }
1501     }
1502   else if (origin == KEYORG_KS && url)
1503     {
1504       /* If the key was retrieved from a keyserver using a fingerprint
1505        * request we mark that also in the user ID.  However we do not
1506        * store the keyserver URL in the UID.  A later update (merge)
1507        * from a more trusted source will replace this info.  */
1508       uid->keyorg = origin;
1509       uid->keyupdate = curtime;
1510     }
1511   else if (origin == KEYORG_FILE)
1512     {
1513       uid->keyorg = origin;
1514       uid->keyupdate = curtime;
1515     }
1516   else if (origin == KEYORG_URL)
1517     {
1518       uid->keyorg = origin;
1519       uid->keyupdate = curtime;
1520     }
1521
1522   return 0;
1523 }
1524
1525
1526 /* Apply meta data to KEYBLOCK.  This sets the origin of the key to
1527  * ORIGIN and the updateurl to URL.  Note that this function is only
1528  * used for a new key, that is not when we are merging keys.  */
1529 static gpg_error_t
1530 insert_key_origin (kbnode_t keyblock, int origin, const char *url)
1531 {
1532   gpg_error_t err;
1533   kbnode_t node;
1534   u32 curtime = make_timestamp ();
1535
1536   for (node = keyblock; node; node = node->next)
1537     {
1538       if (is_deleted_kbnode (node))
1539         ;
1540       else if (node->pkt->pkttype == PKT_PUBLIC_KEY)
1541         {
1542           err = insert_key_origin_pk (node->pkt->pkt.public_key, curtime,
1543                                       origin, url);
1544           if (err)
1545             return err;
1546         }
1547       else if (node->pkt->pkttype == PKT_USER_ID)
1548         {
1549           err = insert_key_origin_uid (node->pkt->pkt.user_id, curtime,
1550                                        origin, url);
1551           if (err)
1552             return err;
1553         }
1554     }
1555
1556   return 0;
1557 }
1558
1559
1560 /* Update meta data on KEYBLOCK.  This updates the key origin on the
1561  * public key according to ORIGIN and URL.  The UIDs are already
1562  * updated when this function is called.  */
1563 static gpg_error_t
1564 update_key_origin (kbnode_t keyblock, u32 curtime, int origin, const char *url)
1565 {
1566   PKT_public_key *pk;
1567
1568   log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
1569   pk = keyblock->pkt->pkt.public_key;
1570
1571   if (pk->keyupdate > curtime)
1572     ; /* Don't do it for a time warp.  */
1573   else if (origin == KEYORG_WKD || origin == KEYORG_DANE)
1574     {
1575       /* We only update the origin info if they either have never been
1576        * set or are the origin was the same as the new one.  If this
1577        * is WKD we also update the UID to show from which user id this
1578        * was updated.  */
1579       if (!pk->keyorg || pk->keyorg == KEYORG_WKD || pk->keyorg == KEYORG_DANE)
1580         {
1581           pk->keyorg = origin;
1582           pk->keyupdate = curtime;
1583           xfree (pk->updateurl);
1584           pk->updateurl = NULL;
1585           if (origin == KEYORG_WKD && url)
1586             {
1587               pk->updateurl = xtrystrdup (url);
1588               if (!pk->updateurl)
1589                 return gpg_error_from_syserror ();
1590             }
1591         }
1592     }
1593   else if (origin == KEYORG_KS)
1594     {
1595       /* All updates from a keyserver are considered to have the
1596        * freshed key.  Thus we always set the new key origin.  */
1597       pk->keyorg = origin;
1598       pk->keyupdate = curtime;
1599       xfree (pk->updateurl);
1600       pk->updateurl = NULL;
1601       if (url)
1602         {
1603           pk->updateurl = xtrystrdup (url);
1604           if (!pk->updateurl)
1605             return gpg_error_from_syserror ();
1606         }
1607     }
1608   else if (origin == KEYORG_FILE)
1609     {
1610       /* Updates from a file are considered to be fresh.  */
1611       pk->keyorg = origin;
1612       pk->keyupdate = curtime;
1613       xfree (pk->updateurl);
1614       pk->updateurl = NULL;
1615     }
1616   else if (origin == KEYORG_URL)
1617     {
1618       /* Updates from a URL are considered to be fresh.  */
1619       pk->keyorg = origin;
1620       pk->keyupdate = curtime;
1621       xfree (pk->updateurl);
1622       pk->updateurl = NULL;
1623       if (url)
1624         {
1625           pk->updateurl = xtrystrdup (url);
1626           if (!pk->updateurl)
1627             return gpg_error_from_syserror ();
1628         }
1629     }
1630
1631   return 0;
1632 }
1633
1634
1635 /*
1636  * Try to import one keyblock. Return an error only in serious cases,
1637  * but never for an invalid keyblock.  It uses log_error to increase
1638  * the internal errorcount, so that invalid input can be detected by
1639  * programs which called gpg.  If SILENT is no messages are printed -
1640  * even most error messages are suppressed.  ORIGIN is the origin of
1641  * the key (0 for unknown) and URL the corresponding URL.
1642  */
1643 static gpg_error_t
1644 import_one (ctrl_t ctrl,
1645             kbnode_t keyblock, struct import_stats_s *stats,
1646             unsigned char **fpr, size_t *fpr_len, unsigned int options,
1647             int from_sk, int silent,
1648             import_screener_t screener, void *screener_arg,
1649             int origin, const char *url)
1650 {
1651   gpg_error_t err = 0;
1652   PKT_public_key *pk;
1653   kbnode_t node, uidnode;
1654   kbnode_t keyblock_orig = NULL;
1655   byte fpr2[MAX_FINGERPRINT_LEN];
1656   size_t fpr2len;
1657   u32 keyid[2];
1658   int new_key = 0;
1659   int mod_key = 0;
1660   int same_key = 0;
1661   int non_self = 0;
1662   size_t an;
1663   char pkstrbuf[PUBKEY_STRING_SIZE];
1664   int merge_keys_done = 0;
1665   int any_filter = 0;
1666   KEYDB_HANDLE hd = NULL;
1667
1668   /* If show-only is active we don't won't any extra output.  */
1669   if ((options & (IMPORT_SHOW | IMPORT_DRY_RUN)))
1670     silent = 1;
1671
1672   /* Get the key and print some info about it. */
1673   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1674   if (!node )
1675     BUG();
1676
1677   pk = node->pkt->pkt.public_key;
1678
1679   fingerprint_from_pk (pk, fpr2, &fpr2len);
1680   for (an = fpr2len; an < MAX_FINGERPRINT_LEN; an++)
1681     fpr2[an] = 0;
1682   keyid_from_pk( pk, keyid );
1683   uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1684
1685   if (opt.verbose && !opt.interactive && !silent)
1686     {
1687       log_info( "pub  %s/%s %s  ",
1688                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
1689                 keystr_from_pk(pk), datestr_from_pk(pk) );
1690       if (uidnode)
1691         print_utf8_buffer (log_get_stream (),
1692                            uidnode->pkt->pkt.user_id->name,
1693                            uidnode->pkt->pkt.user_id->len );
1694       log_printf ("\n");
1695     }
1696
1697
1698   if (!uidnode )
1699     {
1700       if (!silent)
1701         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
1702       return 0;
1703     }
1704
1705   if (screener && screener (keyblock, screener_arg))
1706     {
1707       log_error (_("key %s: %s\n"), keystr_from_pk (pk),
1708                  _("rejected by import screener"));
1709       return 0;
1710     }
1711
1712   if (opt.interactive && !silent)
1713     {
1714       if (is_status_enabled())
1715         print_import_check (pk, uidnode->pkt->pkt.user_id);
1716       merge_keys_and_selfsig (ctrl, keyblock);
1717       tty_printf ("\n");
1718       show_basic_key_info (ctrl, keyblock);
1719       tty_printf ("\n");
1720       if (!cpr_get_answer_is_yes ("import.okay",
1721                                   "Do you want to import this key? (y/N) "))
1722         return 0;
1723     }
1724
1725   collapse_uids(&keyblock);
1726
1727   /* Clean the key that we're about to import, to cut down on things
1728      that we have to clean later.  This has no practical impact on the
1729      end result, but does result in less logging which might confuse
1730      the user. */
1731   if (options&IMPORT_CLEAN)
1732     clean_key (ctrl, keyblock,
1733                opt.verbose, (options&IMPORT_MINIMAL), NULL, NULL);
1734
1735   clear_kbnode_flags( keyblock );
1736
1737   if ((options&IMPORT_REPAIR_PKS_SUBKEY_BUG)
1738       && fix_pks_corruption (ctrl, keyblock)
1739       && opt.verbose)
1740     log_info (_("key %s: PKS subkey corruption repaired\n"),
1741               keystr_from_pk(pk));
1742
1743   if ((options & IMPORT_REPAIR_KEYS))
1744     key_check_all_keysigs (ctrl, 1, keyblock, 0, 0);
1745
1746   if (chk_self_sigs (ctrl, keyblock, keyid, &non_self))
1747     return 0;  /* Invalid keyblock - error already printed.  */
1748
1749   /* If we allow such a thing, mark unsigned uids as valid */
1750   if (opt.allow_non_selfsigned_uid)
1751     {
1752       for (node=keyblock; node; node = node->next )
1753         if (node->pkt->pkttype == PKT_USER_ID
1754             && !(node->flag & NODE_GOOD_SELFSIG)
1755             && !(node->flag & NODE_BAD_SELFSIG) )
1756           {
1757             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
1758                                       node->pkt->pkt.user_id->len,0);
1759             /* Fake a good signature status for the user id.  */
1760             node->flag |= NODE_GOOD_SELFSIG;
1761             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
1762                       keystr_from_pk(pk),user);
1763             xfree(user);
1764           }
1765     }
1766
1767   if (!delete_inv_parts (ctrl, keyblock, keyid, options ) )
1768     {
1769       if (!silent)
1770         {
1771           log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
1772           if (!opt.quiet )
1773             log_info(_("this may be caused by a missing self-signature\n"));
1774         }
1775       stats->no_user_id++;
1776       return 0;
1777     }
1778
1779   /* Get rid of deleted nodes.  */
1780   commit_kbnode (&keyblock);
1781
1782   /* Apply import filter.  */
1783   if (import_filter.keep_uid)
1784     {
1785       apply_keep_uid_filter (ctrl, keyblock, import_filter.keep_uid);
1786       commit_kbnode (&keyblock);
1787       any_filter = 1;
1788     }
1789   if (import_filter.drop_sig)
1790     {
1791       apply_drop_sig_filter (ctrl, keyblock, import_filter.drop_sig);
1792       commit_kbnode (&keyblock);
1793       any_filter = 1;
1794     }
1795
1796   /* If we ran any filter we need to check that at least one user id
1797    * is left in the keyring.  Note that we do not use log_error in
1798    * this case. */
1799   if (any_filter && !any_uid_left (keyblock))
1800     {
1801       if (!opt.quiet )
1802         log_info ( _("key %s: no valid user IDs\n"), keystr_from_pk (pk));
1803       stats->no_user_id++;
1804       return 0;
1805     }
1806
1807   /* Show the key in the form it is merged or inserted.  We skip this
1808    * if "import-export" is also active without --armor or the output
1809    * file has explicily been given. */
1810   if ((options & IMPORT_SHOW)
1811       && !((options & IMPORT_EXPORT) && !opt.armor && !opt.outfile))
1812     {
1813       merge_keys_and_selfsig (ctrl, keyblock);
1814       merge_keys_done = 1;
1815       /* Note that we do not want to show the validity because the key
1816        * has not yet imported.  */
1817       list_keyblock_direct (ctrl, keyblock, from_sk, 0,
1818                             opt.fingerprint || opt.with_fingerprint, 1);
1819       es_fflush (es_stdout);
1820     }
1821
1822   /* Write the keyblock to the output and do not actually import.  */
1823   if ((options & IMPORT_EXPORT))
1824     {
1825       if (!merge_keys_done)
1826         {
1827           merge_keys_and_selfsig (ctrl, keyblock);
1828           merge_keys_done = 1;
1829         }
1830       err = write_keyblock_to_output (keyblock, opt.armor, opt.export_options);
1831       goto leave;
1832     }
1833
1834   if (opt.dry_run || (options & IMPORT_DRY_RUN))
1835     goto leave;
1836
1837   /* Do we have this key already in one of our pubrings ? */
1838   err = get_keyblock_byfprint_fast (&keyblock_orig, &hd,
1839                                     fpr2, fpr2len, 1/*locked*/);
1840   if ((err
1841        && gpg_err_code (err) != GPG_ERR_NO_PUBKEY
1842        && gpg_err_code (err) != GPG_ERR_UNUSABLE_PUBKEY)
1843       || !hd)
1844     {
1845       /* The !hd above is to catch a misbehaving function which
1846        * returns NO_PUBKEY for failing to allocate a handle.  */
1847       if (!silent)
1848         log_error (_("key %s: public key not found: %s\n"),
1849                    keystr(keyid), gpg_strerror (err));
1850     }
1851   else if (err && (opt.import_options&IMPORT_MERGE_ONLY) )
1852     {
1853       if (opt.verbose && !silent )
1854         log_info( _("key %s: new key - skipped\n"), keystr(keyid));
1855       err = 0;
1856       stats->skipped_new_keys++;
1857     }
1858   else if (err)  /* Insert this key. */
1859     {
1860       /* Note: ERR can only be NO_PUBKEY or UNUSABLE_PUBKEY.  */
1861       int n_sigs_cleaned, n_uids_cleaned;
1862
1863       err = keydb_locate_writable (hd);
1864       if (err)
1865         {
1866           log_error (_("no writable keyring found: %s\n"), gpg_strerror (err));
1867           err = gpg_error (GPG_ERR_GENERAL);
1868           goto leave;
1869         }
1870       if (opt.verbose > 1 )
1871         log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );
1872
1873       if ((options & IMPORT_CLEAN))
1874         clean_key (ctrl, keyblock, opt.verbose, (options&IMPORT_MINIMAL),
1875                    &n_uids_cleaned,&n_sigs_cleaned);
1876
1877       /* Unless we are in restore mode apply meta data to the
1878        * keyblock.  Note that this will never change the first packet
1879        * and thus the address of KEYBLOCK won't change.  */
1880       if ( !(options & IMPORT_RESTORE) )
1881         {
1882           err = insert_key_origin (keyblock, origin, url);
1883           if (err)
1884             {
1885               log_error ("insert_key_origin failed: %s\n", gpg_strerror (err));
1886               err = gpg_error (GPG_ERR_GENERAL);
1887               goto leave;
1888             }
1889         }
1890
1891       err = keydb_insert_keyblock (hd, keyblock );
1892       if (err)
1893         log_error (_("error writing keyring '%s': %s\n"),
1894                    keydb_get_resource_name (hd), gpg_strerror (err));
1895       else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
1896         {
1897           /* This should not be possible since we delete the
1898              ownertrust when a key is deleted, but it can happen if
1899              the keyring and trustdb are out of sync.  It can also
1900              be made to happen with the trusted-key command and by
1901              importing and locally exported key. */
1902
1903           clear_ownertrusts (ctrl, pk);
1904           if (non_self)
1905             revalidation_mark (ctrl);
1906         }
1907
1908       /* Release the handle and thus unlock the keyring asap.  */
1909       keydb_release (hd);
1910       hd = NULL;
1911
1912       /* We are ready.  */
1913       if (!opt.quiet && !silent)
1914         {
1915           char *p = get_user_id_byfpr_native (ctrl, fpr2);
1916           log_info (_("key %s: public key \"%s\" imported\n"),
1917                     keystr(keyid), p);
1918           xfree(p);
1919         }
1920       if (is_status_enabled())
1921         {
1922           char *us = get_long_user_id_string (ctrl, keyid);
1923           write_status_text( STATUS_IMPORTED, us );
1924           xfree(us);
1925           print_import_ok (pk, 1);
1926         }
1927       stats->imported++;
1928       new_key = 1;
1929     }
1930   else /* Key already exists - merge.  */
1931     {
1932       int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
1933       u32 curtime = make_timestamp ();
1934
1935       /* Compare the original against the new key; just to be sure nothing
1936        * weird is going on */
1937       if (cmp_public_keys (keyblock_orig->pkt->pkt.public_key, pk))
1938         {
1939           if (!silent)
1940             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
1941           goto leave;
1942         }
1943
1944       /* Make sure the original direct key sigs are all sane.  */
1945       n_sigs_cleaned = fix_bad_direct_key_sigs (ctrl, keyblock_orig, keyid);
1946       if (n_sigs_cleaned)
1947         commit_kbnode (&keyblock_orig);
1948
1949       /* Try to merge KEYBLOCK into KEYBLOCK_ORIG.  */
1950       clear_kbnode_flags( keyblock_orig );
1951       clear_kbnode_flags( keyblock );
1952       n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
1953       err = merge_blocks (ctrl, options, keyblock_orig, keyblock, keyid,
1954                           curtime, origin, url,
1955                           &n_uids, &n_sigs, &n_subk );
1956       if (err)
1957         goto leave;
1958
1959       if ((options & IMPORT_CLEAN))
1960         clean_key (ctrl, keyblock_orig, opt.verbose, (options&IMPORT_MINIMAL),
1961                    &n_uids_cleaned,&n_sigs_cleaned);
1962
1963       if (n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned)
1964         {
1965           /* Unless we are in restore mode apply meta data to the
1966            * keyblock.  Note that this will never change the first packet
1967            * and thus the address of KEYBLOCK won't change.  */
1968           if ( !(options & IMPORT_RESTORE) )
1969             {
1970               err = update_key_origin (keyblock_orig, curtime, origin, url);
1971               if (err)
1972                 {
1973                   log_error ("update_key_origin failed: %s\n",
1974                              gpg_strerror (err));
1975                   goto leave;
1976                 }
1977             }
1978
1979           mod_key = 1;
1980           /* KEYBLOCK_ORIG has been updated; write */
1981           err = keydb_update_keyblock (ctrl, hd, keyblock_orig);
1982           if (err)
1983             log_error (_("error writing keyring '%s': %s\n"),
1984                        keydb_get_resource_name (hd), gpg_strerror (err));
1985           else if (non_self)
1986             revalidation_mark (ctrl);
1987
1988           /* Release the handle and thus unlock the keyring asap.  */
1989           keydb_release (hd);
1990           hd = NULL;
1991
1992           /* We are ready.  */
1993           if (!opt.quiet && !silent)
1994             {
1995               char *p = get_user_id_byfpr_native (ctrl, fpr2);
1996               if (n_uids == 1 )
1997                 log_info( _("key %s: \"%s\" 1 new user ID\n"),
1998                           keystr(keyid),p);
1999               else if (n_uids )
2000                 log_info( _("key %s: \"%s\" %d new user IDs\n"),
2001                           keystr(keyid),p,n_uids);
2002               if (n_sigs == 1 )
2003                 log_info( _("key %s: \"%s\" 1 new signature\n"),
2004                           keystr(keyid), p);
2005               else if (n_sigs )
2006                 log_info( _("key %s: \"%s\" %d new signatures\n"),
2007                           keystr(keyid), p, n_sigs );
2008               if (n_subk == 1 )
2009                 log_info( _("key %s: \"%s\" 1 new subkey\n"),
2010                           keystr(keyid), p);
2011               else if (n_subk )
2012                 log_info( _("key %s: \"%s\" %d new subkeys\n"),
2013                           keystr(keyid), p, n_subk );
2014               if (n_sigs_cleaned==1)
2015                 log_info(_("key %s: \"%s\" %d signature cleaned\n"),
2016                          keystr(keyid),p,n_sigs_cleaned);
2017               else if (n_sigs_cleaned)
2018                 log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
2019                          keystr(keyid),p,n_sigs_cleaned);
2020               if (n_uids_cleaned==1)
2021                 log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
2022                          keystr(keyid),p,n_uids_cleaned);
2023               else if (n_uids_cleaned)
2024                 log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
2025                          keystr(keyid),p,n_uids_cleaned);
2026               xfree(p);
2027             }
2028
2029           stats->n_uids +=n_uids;
2030           stats->n_sigs +=n_sigs;
2031           stats->n_subk +=n_subk;
2032           stats->n_sigs_cleaned +=n_sigs_cleaned;
2033           stats->n_uids_cleaned +=n_uids_cleaned;
2034
2035           if (is_status_enabled () && !silent)
2036             print_import_ok (pk, ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
2037         }
2038       else
2039         {
2040           /* Release the handle and thus unlock the keyring asap.  */
2041           keydb_release (hd);
2042           hd = NULL;
2043
2044           /* Fixme: we do not track the time we last checked a key for
2045            * updates.  To do this we would need to rewrite even the
2046            * keys which have no changes.  */
2047           same_key = 1;
2048           if (is_status_enabled ())
2049             print_import_ok (pk, 0);
2050
2051           if (!opt.quiet && !silent)
2052             {
2053               char *p = get_user_id_byfpr_native (ctrl, fpr2);
2054               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
2055               xfree(p);
2056             }
2057
2058           stats->unchanged++;
2059         }
2060     }
2061
2062  leave:
2063   keydb_release (hd);
2064   if (mod_key || new_key || same_key)
2065     {
2066       /* A little explanation for this: we fill in the fingerprint
2067          when importing keys as it can be useful to know the
2068          fingerprint in certain keyserver-related cases (a keyserver
2069          asked for a particular name, but the key doesn't have that
2070          name).  However, in cases where we're importing more than
2071          one key at a time, we cannot know which key to fingerprint.
2072          In these cases, rather than guessing, we do not
2073          fingerprinting at all, and we must hope the user ID on the
2074          keys are useful.  Note that we need to do this for new
2075          keys, merged keys and even for unchanged keys.  This is
2076          required because for example the --auto-key-locate feature
2077          may import an already imported key and needs to know the
2078          fingerprint of the key in all cases.  */
2079       if (fpr)
2080         {
2081           xfree (*fpr);
2082           /* Note that we need to compare against 0 here because
2083              COUNT gets only incremented after returning from this
2084              function.  */
2085           if (!stats->count)
2086             *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
2087           else
2088             *fpr = NULL;
2089         }
2090     }
2091
2092   /* Now that the key is definitely incorporated into the keydb, we
2093      need to check if a designated revocation is present or if the
2094      prefs are not rational so we can warn the user. */
2095
2096   if (mod_key)
2097     {
2098       revocation_present (ctrl, keyblock_orig);
2099       if (!from_sk && have_secret_key_with_kid (keyid))
2100         check_prefs (ctrl, keyblock_orig);
2101     }
2102   else if (new_key)
2103     {
2104       revocation_present (ctrl, keyblock);
2105       if (!from_sk && have_secret_key_with_kid (keyid))
2106         check_prefs (ctrl, keyblock);
2107     }
2108
2109   release_kbnode( keyblock_orig );
2110
2111   return err;
2112 }
2113
2114
2115 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
2116    function prints diagnostics and returns an error code.  If BATCH is
2117    true the secret keys are stored by gpg-agent in the transfer format
2118    (i.e. no re-protection and aksing for passphrases). */
2119 gpg_error_t
2120 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
2121                       kbnode_t sec_keyblock, int batch, int force)
2122 {
2123   gpg_error_t err = 0;
2124   void *kek = NULL;
2125   size_t keklen;
2126   kbnode_t ctx = NULL;
2127   kbnode_t node;
2128   PKT_public_key *main_pk, *pk;
2129   struct seckey_info *ski;
2130   int nskey;
2131   membuf_t mbuf;
2132   int i, j;
2133   void *format_args[2*PUBKEY_MAX_NSKEY];
2134   gcry_sexp_t skey, prot, tmpsexp;
2135   gcry_sexp_t curve = NULL;
2136   unsigned char *transferkey = NULL;
2137   size_t transferkeylen;
2138   gcry_cipher_hd_t cipherhd = NULL;
2139   unsigned char *wrappedkey = NULL;
2140   size_t wrappedkeylen;
2141   char *cache_nonce = NULL;
2142   int stub_key_skipped = 0;
2143
2144   /* Get the current KEK.  */
2145   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
2146   if (err)
2147     {
2148       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
2149       goto leave;
2150     }
2151
2152   /* Prepare a cipher context.  */
2153   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2154                           GCRY_CIPHER_MODE_AESWRAP, 0);
2155   if (!err)
2156     err = gcry_cipher_setkey (cipherhd, kek, keklen);
2157   if (err)
2158     goto leave;
2159   xfree (kek);
2160   kek = NULL;
2161
2162   main_pk = NULL;
2163   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
2164     {
2165       if (node->pkt->pkttype != PKT_SECRET_KEY
2166           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2167         continue;
2168       pk = node->pkt->pkt.public_key;
2169       if (!main_pk)
2170         main_pk = pk;
2171
2172       /* Make sure the keyids are available.  */
2173       keyid_from_pk (pk, NULL);
2174       if (node->pkt->pkttype == PKT_SECRET_KEY)
2175         {
2176           pk->main_keyid[0] = pk->keyid[0];
2177           pk->main_keyid[1] = pk->keyid[1];
2178         }
2179       else
2180         {
2181           pk->main_keyid[0] = main_pk->keyid[0];
2182           pk->main_keyid[1] = main_pk->keyid[1];
2183         }
2184
2185
2186       ski = pk->seckey_info;
2187       if (!ski)
2188         BUG ();
2189
2190       if (stats)
2191         {
2192           stats->count++;
2193           stats->secret_read++;
2194         }
2195
2196       /* We ignore stub keys.  The way we handle them in other parts
2197          of the code is by asking the agent whether any secret key is
2198          available for a given keyblock and then concluding that we
2199          have a secret key; all secret (sub)keys of the keyblock the
2200          agent does not know of are then stub keys.  This works also
2201          for card stub keys.  The learn command or the card-status
2202          command may be used to check with the agent whether a card
2203          has been inserted and a stub key is in turn generated by the
2204          agent.  */
2205       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2206         {
2207           stub_key_skipped = 1;
2208           continue;
2209         }
2210
2211       /* Convert our internal secret key object into an S-expression.  */
2212       nskey = pubkey_get_nskey (pk->pubkey_algo);
2213       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
2214         {
2215           err = gpg_error (GPG_ERR_BAD_SECKEY);
2216           log_error ("internal error: %s\n", gpg_strerror (err));
2217           goto leave;
2218         }
2219
2220       init_membuf (&mbuf, 50);
2221       put_membuf_str (&mbuf, "(skey");
2222       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
2223           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
2224           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
2225         {
2226           /* The ECC case.  */
2227           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
2228           if (!curvestr)
2229             err = gpg_error_from_syserror ();
2230           else
2231             {
2232               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
2233               gcry_sexp_release (curve);
2234               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
2235                                      curvename?curvename:curvestr);
2236               xfree (curvestr);
2237               if (!err)
2238                 {
2239                   j = 0;
2240                   /* Append the public key element Q.  */
2241                   put_membuf_str (&mbuf, " _ %m");
2242                   format_args[j++] = pk->pkey + 1;
2243
2244                   /* Append the secret key element D.  For ECDH we
2245                      skip PKEY[2] because this holds the KEK which is
2246                      not needed by gpg-agent.  */
2247                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
2248                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
2249                     put_membuf_str (&mbuf, " e %m");
2250                   else
2251                     put_membuf_str (&mbuf, " _ %m");
2252                   format_args[j++] = pk->pkey + i;
2253                 }
2254             }
2255         }
2256       else
2257         {
2258           /* Standard case for the old (non-ECC) algorithms.  */
2259           for (i=j=0; i < nskey; i++)
2260             {
2261               if (!pk->pkey[i])
2262                 continue; /* Protected keys only have NPKEY+1 elements.  */
2263
2264               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
2265                 put_membuf_str (&mbuf, " e %m");
2266               else
2267                 put_membuf_str (&mbuf, " _ %m");
2268               format_args[j++] = pk->pkey + i;
2269             }
2270         }
2271       put_membuf_str (&mbuf, ")");
2272       put_membuf (&mbuf, "", 1);
2273       if (err)
2274         xfree (get_membuf (&mbuf, NULL));
2275       else
2276         {
2277           char *format = get_membuf (&mbuf, NULL);
2278           if (!format)
2279             err = gpg_error_from_syserror ();
2280           else
2281             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
2282           xfree (format);
2283         }
2284       if (err)
2285         {
2286           log_error ("error building skey array: %s\n", gpg_strerror (err));
2287           goto leave;
2288         }
2289
2290       if (ski->is_protected)
2291         {
2292           char countbuf[35];
2293
2294           /* FIXME: Support AEAD */
2295           /* Note that the IVLEN may be zero if we are working on a
2296              dummy key.  We can't express that in an S-expression and
2297              thus we send dummy data for the IV.  */
2298           snprintf (countbuf, sizeof countbuf, "%lu",
2299                     (unsigned long)ski->s2k.count);
2300           err = gcry_sexp_build
2301             (&prot, NULL,
2302              " (protection %s %s %b %d %s %b %s)\n",
2303              ski->sha1chk? "sha1":"sum",
2304              openpgp_cipher_algo_name (ski->algo),
2305              ski->ivlen? (int)ski->ivlen:1,
2306              ski->ivlen? ski->iv: (const unsigned char*)"X",
2307              ski->s2k.mode,
2308              openpgp_md_algo_name (ski->s2k.hash_algo),
2309              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
2310              countbuf);
2311         }
2312       else
2313         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
2314
2315       tmpsexp = NULL;
2316       xfree (transferkey);
2317       transferkey = NULL;
2318       if (!err)
2319         err = gcry_sexp_build (&tmpsexp, NULL,
2320                                "(openpgp-private-key\n"
2321                                " (version %d)\n"
2322                                " (algo %s)\n"
2323                                " %S%S\n"
2324                                " (csum %d)\n"
2325                                " %S)\n",
2326                                pk->version,
2327                                openpgp_pk_algo_name (pk->pubkey_algo),
2328                                curve, skey,
2329                                (int)(unsigned long)ski->csum, prot);
2330       gcry_sexp_release (skey);
2331       gcry_sexp_release (prot);
2332       if (!err)
2333         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
2334       gcry_sexp_release (tmpsexp);
2335       if (err)
2336         {
2337           log_error ("error building transfer key: %s\n", gpg_strerror (err));
2338           goto leave;
2339         }
2340
2341       /* Wrap the key.  */
2342       wrappedkeylen = transferkeylen + 8;
2343       xfree (wrappedkey);
2344       wrappedkey = xtrymalloc (wrappedkeylen);
2345       if (!wrappedkey)
2346         err = gpg_error_from_syserror ();
2347       else
2348         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
2349                                    transferkey, transferkeylen);
2350       if (err)
2351         goto leave;
2352       xfree (transferkey);
2353       transferkey = NULL;
2354
2355       /* Send the wrapped key to the agent.  */
2356       {
2357         char *desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_IMPORT, 1);
2358         err = agent_import_key (ctrl, desc, &cache_nonce,
2359                                 wrappedkey, wrappedkeylen, batch, force,
2360                                 pk->keyid, pk->main_keyid, pk->pubkey_algo);
2361         xfree (desc);
2362       }
2363       if (!err)
2364         {
2365           if (opt.verbose)
2366             log_info (_("key %s: secret key imported\n"),
2367                       keystr_from_pk_with_sub (main_pk, pk));
2368           if (stats)
2369             stats->secret_imported++;
2370         }
2371       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
2372         {
2373           if (opt.verbose)
2374             log_info (_("key %s: secret key already exists\n"),
2375                       keystr_from_pk_with_sub (main_pk, pk));
2376           err = 0;
2377           if (stats)
2378             stats->secret_dups++;
2379         }
2380       else
2381         {
2382           log_error (_("key %s: error sending to agent: %s\n"),
2383                      keystr_from_pk_with_sub (main_pk, pk),
2384                      gpg_strerror (err));
2385           if (gpg_err_code (err) == GPG_ERR_CANCELED
2386               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
2387             break; /* Don't try the other subkeys.  */
2388         }
2389     }
2390
2391   if (!err && stub_key_skipped)
2392     /* We need to notify user how to migrate stub keys.  */
2393     err = gpg_error (GPG_ERR_NOT_PROCESSED);
2394
2395  leave:
2396   gcry_sexp_release (curve);
2397   xfree (cache_nonce);
2398   xfree (wrappedkey);
2399   xfree (transferkey);
2400   gcry_cipher_close (cipherhd);
2401   xfree (kek);
2402   return err;
2403 }
2404
2405
2406 /* Walk a secret keyblock and produce a public keyblock out of it.
2407    Returns a new node or NULL on error. */
2408 static kbnode_t
2409 sec_to_pub_keyblock (kbnode_t sec_keyblock)
2410 {
2411   kbnode_t pub_keyblock = NULL;
2412   kbnode_t ctx = NULL;
2413   kbnode_t secnode, pubnode;
2414
2415   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
2416     {
2417       if (secnode->pkt->pkttype == PKT_SECRET_KEY
2418           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
2419         {
2420           /* Make a public key.  */
2421           PACKET *pkt;
2422           PKT_public_key *pk;
2423
2424           pkt = xtrycalloc (1, sizeof *pkt);
2425           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
2426           if (!pk)
2427             {
2428               xfree (pkt);
2429               release_kbnode (pub_keyblock);
2430               return NULL;
2431             }
2432           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
2433             pkt->pkttype = PKT_PUBLIC_KEY;
2434           else
2435             pkt->pkttype = PKT_PUBLIC_SUBKEY;
2436           pkt->pkt.public_key = pk;
2437
2438           pubnode = new_kbnode (pkt);
2439         }
2440       else
2441         {
2442           pubnode = clone_kbnode (secnode);
2443         }
2444
2445       if (!pub_keyblock)
2446         pub_keyblock = pubnode;
2447       else
2448         add_kbnode (pub_keyblock, pubnode);
2449     }
2450
2451   return pub_keyblock;
2452 }
2453
2454 /****************
2455  * Ditto for secret keys.  Handling is simpler than for public keys.
2456  * We allow secret key importing only when allow is true, this is so
2457  * that a secret key can not be imported accidentally and thereby tampering
2458  * with the trust calculation.
2459  */
2460 static int
2461 import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
2462                    struct import_stats_s *stats, int batch, unsigned int options,
2463                    int for_migration,
2464                    import_screener_t screener, void *screener_arg)
2465 {
2466   PKT_public_key *pk;
2467   struct seckey_info *ski;
2468   kbnode_t node, uidnode;
2469   u32 keyid[2];
2470   int rc = 0;
2471   int nr_prev;
2472   kbnode_t pub_keyblock;
2473   char pkstrbuf[PUBKEY_STRING_SIZE];
2474
2475   /* Get the key and print some info about it */
2476   node = find_kbnode (keyblock, PKT_SECRET_KEY);
2477   if (!node)
2478     BUG ();
2479
2480   pk = node->pkt->pkt.public_key;
2481
2482   keyid_from_pk (pk, keyid);
2483   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
2484
2485   if (screener && screener (keyblock, screener_arg))
2486     {
2487       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
2488                  _("rejected by import screener"));
2489       return 0;
2490   }
2491
2492   if (opt.verbose && !for_migration)
2493     {
2494       log_info ("sec  %s/%s %s   ",
2495                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2496                 keystr_from_pk (pk), datestr_from_pk (pk));
2497       if (uidnode)
2498         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
2499                            uidnode->pkt->pkt.user_id->len);
2500       log_printf ("\n");
2501     }
2502   stats->secret_read++;
2503
2504   if ((options & IMPORT_NO_SECKEY))
2505     {
2506       if (!for_migration)
2507         log_error (_("importing secret keys not allowed\n"));
2508       return 0;
2509     }
2510
2511   if (!uidnode)
2512     {
2513       if (!for_migration)
2514         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
2515       return 0;
2516     }
2517
2518   ski = pk->seckey_info;
2519   if (!ski)
2520     {
2521       /* Actually an internal error.  */
2522       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
2523       return 0;
2524     }
2525
2526   /* A quick check to not import keys with an invalid protection
2527      cipher algorithm (only checks the primary key, though).  */
2528   if (ski->algo > 110)
2529     {
2530       if (!for_migration)
2531         log_error (_("key %s: secret key with invalid cipher %d"
2532                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
2533       return 0;
2534     }
2535
2536 #ifdef ENABLE_SELINUX_HACKS
2537   if (1)
2538     {
2539       /* We don't allow importing secret keys because that may be used
2540          to put a secret key into the keyring and the user might later
2541          be tricked into signing stuff with that key.  */
2542       log_error (_("importing secret keys not allowed\n"));
2543       return 0;
2544     }
2545 #endif
2546
2547   clear_kbnode_flags (keyblock);
2548
2549   nr_prev = stats->skipped_new_keys;
2550
2551   /* Make a public key out of the key. */
2552   pub_keyblock = sec_to_pub_keyblock (keyblock);
2553   if (!pub_keyblock)
2554     log_error ("key %s: failed to create public key from secret key\n",
2555                    keystr_from_pk (pk));
2556   else
2557     {
2558       /* Note that this outputs an IMPORT_OK status message for the
2559          public key block, and below we will output another one for
2560          the secret keys.  FIXME?  */
2561       import_one (ctrl, pub_keyblock, stats,
2562                   NULL, NULL, options, 1, for_migration,
2563                   screener, screener_arg, 0, NULL);
2564
2565       /* Fixme: We should check for an invalid keyblock and
2566          cancel the secret key import in this case.  */
2567       release_kbnode (pub_keyblock);
2568
2569       /* At least we cancel the secret key import when the public key
2570          import was skipped due to MERGE_ONLY option and a new
2571          key.  */
2572       if (!(opt.dry_run || (options & IMPORT_DRY_RUN))
2573           && stats->skipped_new_keys <= nr_prev)
2574         {
2575           /* Read the keyblock again to get the effects of a merge.  */
2576           /* Fixme: we should do this based on the fingerprint or
2577              even better let import_one return the merged
2578              keyblock.  */
2579           node = get_pubkeyblock (ctrl, keyid);
2580           if (!node)
2581             log_error ("key %s: failed to re-lookup public key\n",
2582                        keystr_from_pk (pk));
2583           else
2584             {
2585               gpg_error_t err;
2586
2587               /* transfer_secret_keys collects subkey stats.  */
2588               struct import_stats_s subkey_stats = {0};
2589
2590               err = transfer_secret_keys (ctrl, &subkey_stats, keyblock,
2591                                           batch, 0);
2592               if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
2593                 {
2594                   /* TRANSLATORS: For smartcard, each private key on
2595                      host has a reference (stub) to a smartcard and
2596                      actual private key data is stored on the card.  A
2597                      single smartcard can have up to three private key
2598                      data.  Importing private key stub is always
2599                      skipped in 2.1, and it returns
2600                      GPG_ERR_NOT_PROCESSED.  Instead, user should be
2601                      suggested to run 'gpg --card-status', then,
2602                      references to a card will be automatically
2603                      created again.  */
2604                   log_info (_("To migrate '%s', with each smartcard, "
2605                               "run: %s\n"), "secring.gpg", "gpg --card-status");
2606                   err = 0;
2607                 }
2608               if (!err)
2609                 {
2610                   int status = 16;
2611                   if (!opt.quiet)
2612                     log_info (_("key %s: secret key imported\n"),
2613                               keystr_from_pk (pk));
2614                   if (subkey_stats.secret_imported)
2615                     {
2616                       status |= 1;
2617                       stats->secret_imported += 1;
2618                     }
2619                   if (subkey_stats.secret_dups)
2620                     stats->secret_dups += 1;
2621
2622                   if (is_status_enabled ())
2623                     print_import_ok (pk, status);
2624                   check_prefs (ctrl, node);
2625                 }
2626               release_kbnode (node);
2627             }
2628         }
2629     }
2630
2631   return rc;
2632 }
2633
2634
2635 /****************
2636  * Import a revocation certificate; this is a single signature packet.
2637  */
2638 static int
2639 import_revoke_cert (ctrl_t ctrl, kbnode_t node, unsigned int options,
2640                     struct import_stats_s *stats)
2641 {
2642   PKT_public_key *pk = NULL;
2643   kbnode_t onode;
2644   kbnode_t keyblock = NULL;
2645   KEYDB_HANDLE hd = NULL;
2646   u32 keyid[2];
2647   int rc = 0;
2648
2649   log_assert (!node->next );
2650   log_assert (node->pkt->pkttype == PKT_SIGNATURE );
2651   log_assert (IS_KEY_REV (node->pkt->pkt.signature));
2652
2653   keyid[0] = node->pkt->pkt.signature->keyid[0];
2654   keyid[1] = node->pkt->pkt.signature->keyid[1];
2655
2656   pk = xmalloc_clear( sizeof *pk );
2657   rc = get_pubkey (ctrl, pk, keyid );
2658   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
2659     {
2660       log_error(_("key %s: no public key -"
2661                   " can't apply revocation certificate\n"), keystr(keyid));
2662       rc = 0;
2663       goto leave;
2664     }
2665   else if (rc )
2666     {
2667       log_error(_("key %s: public key not found: %s\n"),
2668                 keystr(keyid), gpg_strerror (rc));
2669       goto leave;
2670     }
2671
2672   /* Read the original keyblock. */
2673   hd = keydb_new ();
2674   if (!hd)
2675     {
2676       rc = gpg_error_from_syserror ();
2677       goto leave;
2678     }
2679
2680   {
2681     byte afp[MAX_FINGERPRINT_LEN];
2682     size_t an;
2683
2684     fingerprint_from_pk (pk, afp, &an);
2685     while (an < MAX_FINGERPRINT_LEN)
2686       afp[an++] = 0;
2687     rc = keydb_search_fpr (hd, afp);
2688   }
2689   if (rc)
2690     {
2691       log_error (_("key %s: can't locate original keyblock: %s\n"),
2692                  keystr(keyid), gpg_strerror (rc));
2693       goto leave;
2694     }
2695   rc = keydb_get_keyblock (hd, &keyblock );
2696   if (rc)
2697     {
2698       log_error (_("key %s: can't read original keyblock: %s\n"),
2699                  keystr(keyid), gpg_strerror (rc));
2700       goto leave;
2701     }
2702
2703   /* it is okay, that node is not in keyblock because
2704    * check_key_signature works fine for sig_class 0x20 (KEY_REV) in
2705    * this special case. */
2706   rc = check_key_signature (ctrl, keyblock, node, NULL);
2707   if (rc )
2708     {
2709       log_error( _("key %s: invalid revocation certificate"
2710                    ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
2711       goto leave;
2712     }
2713
2714   /* check whether we already have this */
2715   for(onode=keyblock->next; onode; onode=onode->next ) {
2716     if (onode->pkt->pkttype == PKT_USER_ID )
2717       break;
2718     else if (onode->pkt->pkttype == PKT_SIGNATURE
2719              && !cmp_signatures(node->pkt->pkt.signature,
2720                                 onode->pkt->pkt.signature))
2721       {
2722         rc = 0;
2723         goto leave; /* yes, we already know about it */
2724       }
2725   }
2726
2727   /* insert it */
2728   insert_kbnode( keyblock, clone_kbnode(node), 0 );
2729
2730   /* and write the keyblock back unless in dry run mode.  */
2731   if (!(opt.dry_run || (options & IMPORT_DRY_RUN)))
2732     {
2733       rc = keydb_update_keyblock (ctrl, hd, keyblock );
2734       if (rc)
2735         log_error (_("error writing keyring '%s': %s\n"),
2736                    keydb_get_resource_name (hd), gpg_strerror (rc) );
2737       keydb_release (hd);
2738       hd = NULL;
2739
2740       /* we are ready */
2741       if (!opt.quiet )
2742         {
2743           char *p=get_user_id_native (ctrl, keyid);
2744           log_info( _("key %s: \"%s\" revocation certificate imported\n"),
2745                     keystr(keyid),p);
2746           xfree(p);
2747         }
2748
2749       /* If the key we just revoked was ultimately trusted, remove its
2750        * ultimate trust.  This doesn't stop the user from putting the
2751        * ultimate trust back, but is a reasonable solution for now. */
2752       if (get_ownertrust (ctrl, pk) == TRUST_ULTIMATE)
2753         clear_ownertrusts (ctrl, pk);
2754
2755       revalidation_mark (ctrl);
2756     }
2757   stats->n_revoc++;
2758
2759  leave:
2760   keydb_release (hd);
2761   release_kbnode( keyblock );
2762   free_public_key( pk );
2763   return rc;
2764 }
2765
2766
2767 /* Loop over the KEYBLOCK and check all self signatures.  KEYID is the
2768  * keyid of the primary key for reporting purposes. On return the
2769  * following bits in the node flags are set:
2770  *
2771  * - NODE_GOOD_SELFSIG  :: User ID or subkey has a self-signature
2772  * - NODE_BAD_SELFSIG   :: Used ID or subkey has an invalid self-signature
2773  * - NODE_DELETION_MARK :: This node shall be deleted
2774  *
2775  * NON_SELF is set to true if there are any sigs other than self-sigs
2776  * in this keyblock.
2777  *
2778  * Returns 0 on success or -1 (but not an error code) if the keyblock
2779  * is invalid.
2780  */
2781 static int
2782 chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid, int *non_self)
2783 {
2784   kbnode_t knode = NULL;   /* The node of the current subkey.  */
2785   PKT_public_key *subpk = NULL; /* and its packet. */
2786   kbnode_t bsnode = NULL;  /* Subkey binding signature node.  */
2787   u32 bsdate = 0;          /* Timestamp of that node.   */
2788   kbnode_t rsnode = NULL;  /* Subkey recocation signature node.  */
2789   u32 rsdate = 0;          /* Timestamp of tha node.  */
2790   PKT_signature *sig;
2791   int rc;
2792   kbnode_t n;
2793
2794   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
2795     {
2796       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2797         {
2798           knode = n;
2799           subpk = knode->pkt->pkt.public_key;
2800           bsdate = 0;
2801           rsdate = 0;
2802           bsnode = NULL;
2803           rsnode = NULL;
2804           continue;
2805         }
2806
2807       if ( n->pkt->pkttype != PKT_SIGNATURE )
2808         continue;
2809
2810       sig = n->pkt->pkt.signature;
2811       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
2812         {
2813           *non_self = 1;
2814           continue;
2815         }
2816
2817       /* This just caches the sigs for later use.  That way we
2818          import a fully-cached key which speeds things up. */
2819       if (!opt.no_sig_cache)
2820         check_key_signature (ctrl, keyblock, n, NULL);
2821
2822       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
2823         {
2824           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
2825           if ( !unode )
2826             {
2827               log_error( _("key %s: no user ID for signature\n"),
2828                          keystr(keyid));
2829               return -1;  /* The complete keyblock is invalid.  */
2830             }
2831
2832           /* If it hasn't been marked valid yet, keep trying.  */
2833           if (!(unode->flag & NODE_GOOD_SELFSIG))
2834             {
2835               rc = check_key_signature (ctrl, keyblock, n, NULL);
2836               if ( rc )
2837                 {
2838                   if ( opt.verbose )
2839                     {
2840                       char *p = utf8_to_native
2841                         (unode->pkt->pkt.user_id->name,
2842                          strlen (unode->pkt->pkt.user_id->name),0);
2843                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
2844                                 _("key %s: unsupported public key "
2845                                   "algorithm on user ID \"%s\"\n"):
2846                                 _("key %s: invalid self-signature "
2847                                   "on user ID \"%s\"\n"),
2848                                 keystr (keyid),p);
2849                       xfree (p);
2850                     }
2851                 }
2852               else
2853                 unode->flag |= NODE_GOOD_SELFSIG;
2854             }
2855         }
2856       else if (IS_KEY_SIG (sig))
2857         {
2858           rc = check_key_signature (ctrl, keyblock, n, NULL);
2859           if ( rc )
2860             {
2861               if (opt.verbose)
2862                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2863                           _("key %s: unsupported public key algorithm\n"):
2864                           _("key %s: invalid direct key signature\n"),
2865                           keystr (keyid));
2866               n->flag |= NODE_DELETION_MARK;
2867             }
2868         }
2869       else if ( IS_SUBKEY_SIG (sig) )
2870         {
2871           /* Note that this works based solely on the timestamps like
2872              the rest of gpg.  If the standard gets revocation
2873              targets, this may need to be revised.  */
2874
2875           if ( !knode )
2876             {
2877               if (opt.verbose)
2878                 log_info (_("key %s: no subkey for key binding\n"),
2879                           keystr (keyid));
2880               n->flag |= NODE_DELETION_MARK;
2881             }
2882           else
2883             {
2884               rc = check_key_signature (ctrl, keyblock, n, NULL);
2885               if ( rc )
2886                 {
2887                   if (opt.verbose)
2888                     {
2889                       keyid_from_pk (subpk, NULL);
2890                       log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2891                                 _("key %s: unsupported public key"
2892                                   " algorithm\n"):
2893                                 _("key %s: invalid subkey binding\n"),
2894                                 keystr_with_sub (keyid, subpk->keyid));
2895                     }
2896                   n->flag |= NODE_DELETION_MARK;
2897                 }
2898               else
2899                 {
2900                   /* It's valid, so is it newer? */
2901                   if (sig->timestamp >= bsdate)
2902                     {
2903                       knode->flag |= NODE_GOOD_SELFSIG; /* Subkey is valid.  */
2904                       if (bsnode)
2905                         {
2906                           /* Delete the last binding sig since this
2907                              one is newer */
2908                           bsnode->flag |= NODE_DELETION_MARK;
2909                           if (opt.verbose)
2910                             {
2911                               keyid_from_pk (subpk, NULL);
2912                               log_info (_("key %s: removed multiple subkey"
2913                                           " binding\n"),
2914                                         keystr_with_sub (keyid, subpk->keyid));
2915                             }
2916                         }
2917
2918                       bsnode = n;
2919                       bsdate = sig->timestamp;
2920                     }
2921                   else
2922                     n->flag |= NODE_DELETION_MARK; /* older */
2923                 }
2924             }
2925         }
2926       else if ( IS_SUBKEY_REV (sig) )
2927         {
2928           /* We don't actually mark the subkey as revoked right now,
2929              so just check that the revocation sig is the most recent
2930              valid one.  Note that we don't care if the binding sig is
2931              newer than the revocation sig.  See the comment in
2932              getkey.c:merge_selfsigs_subkey for more.  */
2933           if ( !knode )
2934             {
2935               if (opt.verbose)
2936                 log_info (_("key %s: no subkey for key revocation\n"),
2937                           keystr(keyid));
2938               n->flag |= NODE_DELETION_MARK;
2939             }
2940           else
2941             {
2942               rc = check_key_signature (ctrl, keyblock, n, NULL);
2943               if ( rc )
2944                 {
2945                   if(opt.verbose)
2946                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2947                               _("key %s: unsupported public"
2948                                 " key algorithm\n"):
2949                               _("key %s: invalid subkey revocation\n"),
2950                               keystr(keyid));
2951                   n->flag |= NODE_DELETION_MARK;
2952                 }
2953               else
2954                 {
2955                   /* It's valid, so is it newer? */
2956                   if (sig->timestamp >= rsdate)
2957                     {
2958                       if (rsnode)
2959                         {
2960                           /* Delete the last revocation sig since
2961                              this one is newer.  */
2962                           rsnode->flag |= NODE_DELETION_MARK;
2963                           if (opt.verbose)
2964                             log_info (_("key %s: removed multiple subkey"
2965                                         " revocation\n"),keystr(keyid));
2966                         }
2967
2968                       rsnode = n;
2969                       rsdate = sig->timestamp;
2970                     }
2971                   else
2972                     n->flag |= NODE_DELETION_MARK; /* older */
2973                 }
2974             }
2975         }
2976     }
2977
2978   return 0;
2979 }
2980
2981
2982 /* Delete all parts which are invalid and those signatures whose
2983  * public key algorithm is not available in this implementation; but
2984  * consider RSA as valid, because parse/build_packets knows about it.
2985  *
2986  * Returns: True if at least one valid user-id is left over.
2987  */
2988 static int
2989 delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
2990                   unsigned int options)
2991 {
2992   kbnode_t node;
2993   int nvalid=0, uid_seen=0, subkey_seen=0;
2994   PKT_public_key *pk;
2995
2996   for (node=keyblock->next; node; node = node->next )
2997     {
2998       if (node->pkt->pkttype == PKT_USER_ID)
2999         {
3000           uid_seen = 1;
3001           if ((node->flag & NODE_BAD_SELFSIG)
3002               || !(node->flag & NODE_GOOD_SELFSIG))
3003             {
3004               if (opt.verbose )
3005                 {
3006                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
3007                                          node->pkt->pkt.user_id->len,0);
3008                   log_info( _("key %s: skipped user ID \"%s\"\n"),
3009                             keystr(keyid),p);
3010                   xfree(p);
3011                 }
3012               delete_kbnode( node ); /* the user-id */
3013               /* and all following packets up to the next user-id */
3014               while (node->next
3015                      && node->next->pkt->pkttype != PKT_USER_ID
3016                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
3017                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
3018                 delete_kbnode( node->next );
3019                 node = node->next;
3020               }
3021             }
3022           else
3023             nvalid++;
3024         }
3025       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3026                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
3027         {
3028           if ((node->flag & NODE_BAD_SELFSIG)
3029               || !(node->flag & NODE_GOOD_SELFSIG))
3030             {
3031               if (opt.verbose )
3032                 {
3033                   pk = node->pkt->pkt.public_key;
3034                   keyid_from_pk (pk, NULL);
3035                   log_info (_("key %s: skipped subkey\n"),
3036                             keystr_with_sub (keyid, pk->keyid));
3037                 }
3038
3039               delete_kbnode( node ); /* the subkey */
3040               /* and all following signature packets */
3041               while (node->next
3042                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
3043                 delete_kbnode( node->next );
3044                 node = node->next;
3045               }
3046             }
3047           else
3048             subkey_seen = 1;
3049         }
3050       else if (node->pkt->pkttype == PKT_SIGNATURE
3051                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
3052                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
3053         {
3054           delete_kbnode( node ); /* build_packet() can't handle this */
3055         }
3056       else if (node->pkt->pkttype == PKT_SIGNATURE
3057                && !node->pkt->pkt.signature->flags.exportable
3058                && !(options&IMPORT_LOCAL_SIGS)
3059                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
3060         {
3061           /* here we violate the rfc a bit by still allowing
3062            * to import non-exportable signature when we have the
3063            * the secret key used to create this signature - it
3064            * seems that this makes sense */
3065           if(opt.verbose)
3066             log_info( _("key %s: non exportable signature"
3067                         " (class 0x%02X) - skipped\n"),
3068                       keystr(keyid), node->pkt->pkt.signature->sig_class );
3069           delete_kbnode( node );
3070         }
3071       else if (node->pkt->pkttype == PKT_SIGNATURE
3072                && IS_KEY_REV (node->pkt->pkt.signature))
3073         {
3074           if (uid_seen )
3075             {
3076               if(opt.verbose)
3077                 log_info( _("key %s: revocation certificate"
3078                             " at wrong place - skipped\n"),keystr(keyid));
3079               delete_kbnode( node );
3080             }
3081           else
3082             {
3083               /* If the revocation cert is from a different key than
3084                  the one we're working on don't check it - it's
3085                  probably from a revocation key and won't be
3086                  verifiable with this key anyway. */
3087
3088               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
3089                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
3090                 {
3091                   int rc = check_key_signature (ctrl, keyblock, node, NULL);
3092                   if (rc )
3093                     {
3094                       if(opt.verbose)
3095                         log_info( _("key %s: invalid revocation"
3096                                     " certificate: %s - skipped\n"),
3097                                   keystr(keyid), gpg_strerror (rc));
3098                       delete_kbnode( node );
3099                     }
3100                 }
3101             }
3102         }
3103       else if (node->pkt->pkttype == PKT_SIGNATURE
3104                && (IS_SUBKEY_SIG (node->pkt->pkt.signature)
3105                    || IS_SUBKEY_REV (node->pkt->pkt.signature))
3106                && !subkey_seen )
3107         {
3108           if(opt.verbose)
3109             log_info( _("key %s: subkey signature"
3110                         " in wrong place - skipped\n"), keystr(keyid));
3111           delete_kbnode( node );
3112         }
3113       else if (node->pkt->pkttype == PKT_SIGNATURE
3114                && !IS_CERT(node->pkt->pkt.signature))
3115         {
3116           if(opt.verbose)
3117             log_info(_("key %s: unexpected signature class (0x%02X) -"
3118                        " skipped\n"),keystr(keyid),
3119                      node->pkt->pkt.signature->sig_class);
3120           delete_kbnode(node);
3121           }
3122       else if ((node->flag & NODE_DELETION_MARK))
3123         delete_kbnode( node );
3124     }
3125
3126   /* note: because keyblock is the public key, it is never marked
3127    * for deletion and so keyblock cannot change */
3128   commit_kbnode( &keyblock );
3129   return nvalid;
3130 }
3131
3132 /* This function returns true if any UID is left in the keyring.  */
3133 static int
3134 any_uid_left (kbnode_t keyblock)
3135 {
3136   kbnode_t node;
3137
3138   for (node=keyblock->next; node; node = node->next)
3139     if (node->pkt->pkttype == PKT_USER_ID)
3140       return 1;
3141   return 0;
3142 }
3143
3144
3145
3146 /****************
3147  * It may happen that the imported keyblock has duplicated user IDs.
3148  * We check this here and collapse those user IDs together with their
3149  * sigs into one.
3150  * Returns: True if the keyblock has changed.
3151  */
3152 int
3153 collapse_uids( kbnode_t *keyblock )
3154 {
3155   kbnode_t uid1;
3156   int any=0;
3157
3158   for(uid1=*keyblock;uid1;uid1=uid1->next)
3159     {
3160       kbnode_t uid2;
3161
3162       if(is_deleted_kbnode(uid1))
3163         continue;
3164
3165       if(uid1->pkt->pkttype!=PKT_USER_ID)
3166         continue;
3167
3168       for(uid2=uid1->next;uid2;uid2=uid2->next)
3169         {
3170           if(is_deleted_kbnode(uid2))
3171             continue;
3172
3173           if(uid2->pkt->pkttype!=PKT_USER_ID)
3174             continue;
3175
3176           if(cmp_user_ids(uid1->pkt->pkt.user_id,
3177                           uid2->pkt->pkt.user_id)==0)
3178             {
3179               /* We have a duplicated uid */
3180               kbnode_t sig1,last;
3181
3182               any=1;
3183
3184               /* Now take uid2's signatures, and attach them to
3185                  uid1 */
3186               for(last=uid2;last->next;last=last->next)
3187                 {
3188                   if(is_deleted_kbnode(last))
3189                     continue;
3190
3191                   if(last->next->pkt->pkttype==PKT_USER_ID
3192                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
3193                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
3194                     break;
3195                 }
3196
3197               /* Snip out uid2 */
3198               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
3199
3200               /* Now put uid2 in place as part of uid1 */
3201               last->next=uid1->next;
3202               uid1->next=uid2;
3203               delete_kbnode(uid2);
3204
3205               /* Now dedupe uid1 */
3206               for(sig1=uid1->next;sig1;sig1=sig1->next)
3207                 {
3208                   kbnode_t sig2;
3209
3210                   if(is_deleted_kbnode(sig1))
3211                     continue;
3212
3213                   if(sig1->pkt->pkttype==PKT_USER_ID
3214                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
3215                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
3216                     break;
3217
3218                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
3219                     continue;
3220
3221                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
3222                     {
3223                       if(is_deleted_kbnode(sig2))
3224                         continue;
3225
3226                       if(sig2->pkt->pkttype==PKT_USER_ID
3227                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
3228                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
3229                         break;
3230
3231                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
3232                         continue;
3233
3234                       if(cmp_signatures(sig1->pkt->pkt.signature,
3235                                         sig2->pkt->pkt.signature)==0)
3236                         {
3237                           /* We have a match, so delete the second
3238                              signature */
3239                           delete_kbnode(sig2);
3240                           sig2=last;
3241                         }
3242                     }
3243                 }
3244             }
3245         }
3246     }
3247
3248   commit_kbnode(keyblock);
3249
3250   if(any && !opt.quiet)
3251     {
3252       const char *key="???";
3253
3254       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
3255         key = keystr_from_pk (uid1->pkt->pkt.public_key);
3256       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
3257         key = keystr_from_pk (uid1->pkt->pkt.public_key);
3258
3259       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
3260     }
3261
3262   return any;
3263 }
3264
3265
3266 /* Check for a 0x20 revocation from a revocation key that is not
3267    present.  This may be called without the benefit of merge_xxxx so
3268    you can't rely on pk->revkey and friends. */
3269 static void
3270 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
3271 {
3272   kbnode_t onode, inode;
3273   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
3274
3275   for(onode=keyblock->next;onode;onode=onode->next)
3276     {
3277       /* If we reach user IDs, we're done. */
3278       if(onode->pkt->pkttype==PKT_USER_ID)
3279         break;
3280
3281       if (onode->pkt->pkttype == PKT_SIGNATURE
3282           && IS_KEY_SIG (onode->pkt->pkt.signature)
3283           && onode->pkt->pkt.signature->revkey)
3284         {
3285           int idx;
3286           PKT_signature *sig=onode->pkt->pkt.signature;
3287
3288           for(idx=0;idx<sig->numrevkeys;idx++)
3289             {
3290               u32 keyid[2];
3291
3292               keyid_from_fingerprint (ctrl, sig->revkey[idx].fpr,
3293                                       MAX_FINGERPRINT_LEN, keyid);
3294
3295               for(inode=keyblock->next;inode;inode=inode->next)
3296                 {
3297                   /* If we reach user IDs, we're done. */
3298                   if(inode->pkt->pkttype==PKT_USER_ID)
3299                     break;
3300
3301                   if (inode->pkt->pkttype == PKT_SIGNATURE
3302                       && IS_KEY_REV (inode->pkt->pkt.signature)
3303                       && inode->pkt->pkt.signature->keyid[0]==keyid[0]
3304                       && inode->pkt->pkt.signature->keyid[1]==keyid[1])
3305                     {
3306                       /* Okay, we have a revocation key, and a
3307                        * revocation issued by it.  Do we have the key
3308                        * itself?  */
3309                       gpg_error_t err;
3310
3311                       err = get_pubkey_byfprint_fast (NULL,
3312                                                       sig->revkey[idx].fpr,
3313                                                       MAX_FINGERPRINT_LEN);
3314                       if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
3315                           || gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
3316                         {
3317                           char *tempkeystr = xstrdup (keystr_from_pk (pk));
3318
3319                           /* No, so try and get it */
3320                           if ((opt.keyserver_options.options
3321                                & KEYSERVER_AUTO_KEY_RETRIEVE)
3322                               && keyserver_any_configured (ctrl))
3323                             {
3324                               log_info(_("WARNING: key %s may be revoked:"
3325                                          " fetching revocation key %s\n"),
3326                                        tempkeystr,keystr(keyid));
3327                               keyserver_import_fprint (ctrl,
3328                                                        sig->revkey[idx].fpr,
3329                                                        MAX_FINGERPRINT_LEN,
3330                                                        opt.keyserver, 0);
3331
3332                               /* Do we have it now? */
3333                               err = get_pubkey_byfprint_fast (NULL,
3334                                                      sig->revkey[idx].fpr,
3335                                                      MAX_FINGERPRINT_LEN);
3336                             }
3337
3338                           if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY
3339                               || gpg_err_code (err) == GPG_ERR_UNUSABLE_PUBKEY)
3340                             log_info(_("WARNING: key %s may be revoked:"
3341                                        " revocation key %s not present.\n"),
3342                                      tempkeystr,keystr(keyid));
3343
3344                           xfree(tempkeystr);
3345                         }
3346                     }
3347                 }
3348             }
3349         }
3350     }
3351 }
3352
3353
3354 /*
3355  * compare and merge the blocks
3356  *
3357  * o compare the signatures: If we already have this signature, check
3358  *   that they compare okay; if not, issue a warning and ask the user.
3359  * o Simply add the signature.  Can't verify here because we may not have
3360  *   the signature's public key yet; verification is done when putting it
3361  *   into the trustdb, which is done automagically as soon as this pubkey
3362  *   is used.
3363  * Note: We indicate newly inserted packets with NODE_FLAG_A.
3364  */
3365 static int
3366 merge_blocks (ctrl_t ctrl, unsigned int options,
3367               kbnode_t keyblock_orig, kbnode_t keyblock,
3368               u32 *keyid, u32 curtime, int origin, const char *url,
3369               int *n_uids, int *n_sigs, int *n_subk )
3370 {
3371   kbnode_t onode, node;
3372   int rc, found;
3373
3374   /* 1st: handle revocation certificates */
3375   for (node=keyblock->next; node; node=node->next )
3376     {
3377       if (node->pkt->pkttype == PKT_USER_ID )
3378         break;
3379       else if (node->pkt->pkttype == PKT_SIGNATURE
3380                && IS_KEY_REV (node->pkt->pkt.signature))
3381         {
3382           /* check whether we already have this */
3383           found = 0;
3384           for (onode=keyblock_orig->next; onode; onode=onode->next)
3385             {
3386               if (onode->pkt->pkttype == PKT_USER_ID )
3387                 break;
3388               else if (onode->pkt->pkttype == PKT_SIGNATURE
3389                        && IS_KEY_REV (onode->pkt->pkt.signature)
3390                        && !cmp_signatures(onode->pkt->pkt.signature,
3391                                           node->pkt->pkt.signature))
3392                 {
3393                   found = 1;
3394                   break;
3395                 }
3396             }
3397           if (!found)
3398             {
3399               kbnode_t n2 = clone_kbnode(node);
3400               insert_kbnode( keyblock_orig, n2, 0 );
3401               n2->flag |= NODE_FLAG_A;
3402               ++*n_sigs;
3403               if(!opt.quiet)
3404                 {
3405                   char *p = get_user_id_native (ctrl, keyid);
3406                   log_info(_("key %s: \"%s\" revocation"
3407                              " certificate added\n"), keystr(keyid),p);
3408                   xfree(p);
3409                 }
3410             }
3411         }
3412     }
3413
3414   /* 2nd: merge in any direct key (0x1F) sigs */
3415   for(node=keyblock->next; node; node=node->next)
3416     {
3417       if (node->pkt->pkttype == PKT_USER_ID )
3418         break;
3419       else if (node->pkt->pkttype == PKT_SIGNATURE
3420                && IS_KEY_SIG (node->pkt->pkt.signature))
3421         {
3422           /* check whether we already have this */
3423           found = 0;
3424           for (onode=keyblock_orig->next; onode; onode=onode->next)
3425             {
3426               if (onode->pkt->pkttype == PKT_USER_ID)
3427                 break;
3428               else if (onode->pkt->pkttype == PKT_SIGNATURE
3429                        && IS_KEY_SIG (onode->pkt->pkt.signature)
3430                        && !cmp_signatures(onode->pkt->pkt.signature,
3431                                           node->pkt->pkt.signature))
3432                 {
3433                   found = 1;
3434                   break;
3435                 }
3436             }
3437           if (!found )
3438             {
3439               kbnode_t n2 = clone_kbnode(node);
3440               insert_kbnode( keyblock_orig, n2, 0 );
3441               n2->flag |= NODE_FLAG_A;
3442               ++*n_sigs;
3443               if(!opt.quiet)
3444                 log_info( _("key %s: direct key signature added\n"),
3445                           keystr(keyid));
3446             }
3447         }
3448     }
3449
3450   /* 3rd: try to merge new certificates in */
3451   for (onode=keyblock_orig->next; onode; onode=onode->next)
3452     {