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