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