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