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