gpg: Refresh expired keys originating from the WKD.
[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.  Adding this would be useful
2094            * for the automatic update of expired keys via the WKD in
2095            * case the WKD still carries the expired key.  See
2096            * get_best_pubkey_byname.  */
2097           same_key = 1;
2098           if (is_status_enabled ())
2099             print_import_ok (pk, 0);
2100
2101           if (!opt.quiet && !silent)
2102             {
2103               char *p = get_user_id_byfpr_native (ctrl, fpr2);
2104               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
2105               xfree(p);
2106             }
2107
2108           stats->unchanged++;
2109         }
2110     }
2111
2112  leave:
2113   keydb_release (hd);
2114   if (mod_key || new_key || same_key)
2115     {
2116       /* A little explanation for this: we fill in the fingerprint
2117          when importing keys as it can be useful to know the
2118          fingerprint in certain keyserver-related cases (a keyserver
2119          asked for a particular name, but the key doesn't have that
2120          name).  However, in cases where we're importing more than
2121          one key at a time, we cannot know which key to fingerprint.
2122          In these cases, rather than guessing, we do not
2123          fingerprinting at all, and we must hope the user ID on the
2124          keys are useful.  Note that we need to do this for new
2125          keys, merged keys and even for unchanged keys.  This is
2126          required because for example the --auto-key-locate feature
2127          may import an already imported key and needs to know the
2128          fingerprint of the key in all cases.  */
2129       if (fpr)
2130         {
2131           xfree (*fpr);
2132           /* Note that we need to compare against 0 here because
2133              COUNT gets only incremented after returning from this
2134              function.  */
2135           if (!stats->count)
2136             *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
2137           else
2138             *fpr = NULL;
2139         }
2140     }
2141
2142   /* Now that the key is definitely incorporated into the keydb, we
2143      need to check if a designated revocation is present or if the
2144      prefs are not rational so we can warn the user. */
2145
2146   if (mod_key)
2147     {
2148       revocation_present (ctrl, keyblock_orig);
2149       if (!from_sk && have_secret_key_with_kid (keyid))
2150         check_prefs (ctrl, keyblock_orig);
2151     }
2152   else if (new_key)
2153     {
2154       revocation_present (ctrl, keyblock);
2155       if (!from_sk && have_secret_key_with_kid (keyid))
2156         check_prefs (ctrl, keyblock);
2157     }
2158
2159   release_kbnode( keyblock_orig );
2160
2161   return err;
2162 }
2163
2164
2165 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
2166    function prints diagnostics and returns an error code.  If BATCH is
2167    true the secret keys are stored by gpg-agent in the transfer format
2168    (i.e. no re-protection and aksing for passphrases). */
2169 gpg_error_t
2170 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
2171                       kbnode_t sec_keyblock, int batch, int force)
2172 {
2173   gpg_error_t err = 0;
2174   void *kek = NULL;
2175   size_t keklen;
2176   kbnode_t ctx = NULL;
2177   kbnode_t node;
2178   PKT_public_key *main_pk, *pk;
2179   struct seckey_info *ski;
2180   int nskey;
2181   membuf_t mbuf;
2182   int i, j;
2183   void *format_args[2*PUBKEY_MAX_NSKEY];
2184   gcry_sexp_t skey, prot, tmpsexp;
2185   gcry_sexp_t curve = NULL;
2186   unsigned char *transferkey = NULL;
2187   size_t transferkeylen;
2188   gcry_cipher_hd_t cipherhd = NULL;
2189   unsigned char *wrappedkey = NULL;
2190   size_t wrappedkeylen;
2191   char *cache_nonce = NULL;
2192   int stub_key_skipped = 0;
2193
2194   /* Get the current KEK.  */
2195   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
2196   if (err)
2197     {
2198       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
2199       goto leave;
2200     }
2201
2202   /* Prepare a cipher context.  */
2203   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2204                           GCRY_CIPHER_MODE_AESWRAP, 0);
2205   if (!err)
2206     err = gcry_cipher_setkey (cipherhd, kek, keklen);
2207   if (err)
2208     goto leave;
2209   xfree (kek);
2210   kek = NULL;
2211
2212   main_pk = NULL;
2213   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
2214     {
2215       if (node->pkt->pkttype != PKT_SECRET_KEY
2216           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2217         continue;
2218       pk = node->pkt->pkt.public_key;
2219       if (!main_pk)
2220         main_pk = pk;
2221
2222       /* Make sure the keyids are available.  */
2223       keyid_from_pk (pk, NULL);
2224       if (node->pkt->pkttype == PKT_SECRET_KEY)
2225         {
2226           pk->main_keyid[0] = pk->keyid[0];
2227           pk->main_keyid[1] = pk->keyid[1];
2228         }
2229       else
2230         {
2231           pk->main_keyid[0] = main_pk->keyid[0];
2232           pk->main_keyid[1] = main_pk->keyid[1];
2233         }
2234
2235
2236       ski = pk->seckey_info;
2237       if (!ski)
2238         BUG ();
2239
2240       if (stats)
2241         {
2242           stats->count++;
2243           stats->secret_read++;
2244         }
2245
2246       /* We ignore stub keys.  The way we handle them in other parts
2247          of the code is by asking the agent whether any secret key is
2248          available for a given keyblock and then concluding that we
2249          have a secret key; all secret (sub)keys of the keyblock the
2250          agent does not know of are then stub keys.  This works also
2251          for card stub keys.  The learn command or the card-status
2252          command may be used to check with the agent whether a card
2253          has been inserted and a stub key is in turn generated by the
2254          agent.  */
2255       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
2256         {
2257           stub_key_skipped = 1;
2258           continue;
2259         }
2260
2261       /* Convert our internal secret key object into an S-expression.  */
2262       nskey = pubkey_get_nskey (pk->pubkey_algo);
2263       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
2264         {
2265           err = gpg_error (GPG_ERR_BAD_SECKEY);
2266           log_error ("internal error: %s\n", gpg_strerror (err));
2267           goto leave;
2268         }
2269
2270       init_membuf (&mbuf, 50);
2271       put_membuf_str (&mbuf, "(skey");
2272       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
2273           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
2274           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
2275         {
2276           /* The ECC case.  */
2277           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
2278           if (!curvestr)
2279             err = gpg_error_from_syserror ();
2280           else
2281             {
2282               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
2283               gcry_sexp_release (curve);
2284               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
2285                                      curvename?curvename:curvestr);
2286               xfree (curvestr);
2287               if (!err)
2288                 {
2289                   j = 0;
2290                   /* Append the public key element Q.  */
2291                   put_membuf_str (&mbuf, " _ %m");
2292                   format_args[j++] = pk->pkey + 1;
2293
2294                   /* Append the secret key element D.  For ECDH we
2295                      skip PKEY[2] because this holds the KEK which is
2296                      not needed by gpg-agent.  */
2297                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
2298                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
2299                     put_membuf_str (&mbuf, " e %m");
2300                   else
2301                     put_membuf_str (&mbuf, " _ %m");
2302                   format_args[j++] = pk->pkey + i;
2303                 }
2304             }
2305         }
2306       else
2307         {
2308           /* Standard case for the old (non-ECC) algorithms.  */
2309           for (i=j=0; i < nskey; i++)
2310             {
2311               if (!pk->pkey[i])
2312                 continue; /* Protected keys only have NPKEY+1 elements.  */
2313
2314               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
2315                 put_membuf_str (&mbuf, " e %m");
2316               else
2317                 put_membuf_str (&mbuf, " _ %m");
2318               format_args[j++] = pk->pkey + i;
2319             }
2320         }
2321       put_membuf_str (&mbuf, ")");
2322       put_membuf (&mbuf, "", 1);
2323       if (err)
2324         xfree (get_membuf (&mbuf, NULL));
2325       else
2326         {
2327           char *format = get_membuf (&mbuf, NULL);
2328           if (!format)
2329             err = gpg_error_from_syserror ();
2330           else
2331             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
2332           xfree (format);
2333         }
2334       if (err)
2335         {
2336           log_error ("error building skey array: %s\n", gpg_strerror (err));
2337           goto leave;
2338         }
2339
2340       if (ski->is_protected)
2341         {
2342           char countbuf[35];
2343
2344           /* FIXME: Support AEAD */
2345           /* Note that the IVLEN may be zero if we are working on a
2346              dummy key.  We can't express that in an S-expression and
2347              thus we send dummy data for the IV.  */
2348           snprintf (countbuf, sizeof countbuf, "%lu",
2349                     (unsigned long)ski->s2k.count);
2350           err = gcry_sexp_build
2351             (&prot, NULL,
2352              " (protection %s %s %b %d %s %b %s)\n",
2353              ski->sha1chk? "sha1":"sum",
2354              openpgp_cipher_algo_name (ski->algo),
2355              ski->ivlen? (int)ski->ivlen:1,
2356              ski->ivlen? ski->iv: (const unsigned char*)"X",
2357              ski->s2k.mode,
2358              openpgp_md_algo_name (ski->s2k.hash_algo),
2359              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
2360              countbuf);
2361         }
2362       else
2363         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
2364
2365       tmpsexp = NULL;
2366       xfree (transferkey);
2367       transferkey = NULL;
2368       if (!err)
2369         err = gcry_sexp_build (&tmpsexp, NULL,
2370                                "(openpgp-private-key\n"
2371                                " (version %d)\n"
2372                                " (algo %s)\n"
2373                                " %S%S\n"
2374                                " (csum %d)\n"
2375                                " %S)\n",
2376                                pk->version,
2377                                openpgp_pk_algo_name (pk->pubkey_algo),
2378                                curve, skey,
2379                                (int)(unsigned long)ski->csum, prot);
2380       gcry_sexp_release (skey);
2381       gcry_sexp_release (prot);
2382       if (!err)
2383         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
2384       gcry_sexp_release (tmpsexp);
2385       if (err)
2386         {
2387           log_error ("error building transfer key: %s\n", gpg_strerror (err));
2388           goto leave;
2389         }
2390
2391       /* Wrap the key.  */
2392       wrappedkeylen = transferkeylen + 8;
2393       xfree (wrappedkey);
2394       wrappedkey = xtrymalloc (wrappedkeylen);
2395       if (!wrappedkey)
2396         err = gpg_error_from_syserror ();
2397       else
2398         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
2399                                    transferkey, transferkeylen);
2400       if (err)
2401         goto leave;
2402       xfree (transferkey);
2403       transferkey = NULL;
2404
2405       /* Send the wrapped key to the agent.  */
2406       {
2407         char *desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_IMPORT, 1);
2408         err = agent_import_key (ctrl, desc, &cache_nonce,
2409                                 wrappedkey, wrappedkeylen, batch, force,
2410                                 pk->keyid, pk->main_keyid, pk->pubkey_algo);
2411         xfree (desc);
2412       }
2413       if (!err)
2414         {
2415           if (opt.verbose)
2416             log_info (_("key %s: secret key imported\n"),
2417                       keystr_from_pk_with_sub (main_pk, pk));
2418           if (stats)
2419             stats->secret_imported++;
2420         }
2421       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
2422         {
2423           if (opt.verbose)
2424             log_info (_("key %s: secret key already exists\n"),
2425                       keystr_from_pk_with_sub (main_pk, pk));
2426           err = 0;
2427           if (stats)
2428             stats->secret_dups++;
2429         }
2430       else
2431         {
2432           log_error (_("key %s: error sending to agent: %s\n"),
2433                      keystr_from_pk_with_sub (main_pk, pk),
2434                      gpg_strerror (err));
2435           if (gpg_err_code (err) == GPG_ERR_CANCELED
2436               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
2437             break; /* Don't try the other subkeys.  */
2438         }
2439     }
2440
2441   if (!err && stub_key_skipped)
2442     /* We need to notify user how to migrate stub keys.  */
2443     err = gpg_error (GPG_ERR_NOT_PROCESSED);
2444
2445  leave:
2446   gcry_sexp_release (curve);
2447   xfree (cache_nonce);
2448   xfree (wrappedkey);
2449   xfree (transferkey);
2450   gcry_cipher_close (cipherhd);
2451   xfree (kek);
2452   return err;
2453 }
2454
2455
2456 /* Walk a secret keyblock and produce a public keyblock out of it.
2457    Returns a new node or NULL on error. */
2458 static kbnode_t
2459 sec_to_pub_keyblock (kbnode_t sec_keyblock)
2460 {
2461   kbnode_t pub_keyblock = NULL;
2462   kbnode_t ctx = NULL;
2463   kbnode_t secnode, pubnode;
2464
2465   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
2466     {
2467       if (secnode->pkt->pkttype == PKT_SECRET_KEY
2468           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
2469         {
2470           /* Make a public key.  */
2471           PACKET *pkt;
2472           PKT_public_key *pk;
2473
2474           pkt = xtrycalloc (1, sizeof *pkt);
2475           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
2476           if (!pk)
2477             {
2478               xfree (pkt);
2479               release_kbnode (pub_keyblock);
2480               return NULL;
2481             }
2482           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
2483             pkt->pkttype = PKT_PUBLIC_KEY;
2484           else
2485             pkt->pkttype = PKT_PUBLIC_SUBKEY;
2486           pkt->pkt.public_key = pk;
2487
2488           pubnode = new_kbnode (pkt);
2489         }
2490       else
2491         {
2492           pubnode = clone_kbnode (secnode);
2493         }
2494
2495       if (!pub_keyblock)
2496         pub_keyblock = pubnode;
2497       else
2498         add_kbnode (pub_keyblock, pubnode);
2499     }
2500
2501   return pub_keyblock;
2502 }
2503
2504 /****************
2505  * Ditto for secret keys.  Handling is simpler than for public keys.
2506  * We allow secret key importing only when allow is true, this is so
2507  * that a secret key can not be imported accidentally and thereby tampering
2508  * with the trust calculation.
2509  */
2510 static int
2511 import_secret_one (ctrl_t ctrl, kbnode_t keyblock,
2512                    struct import_stats_s *stats, int batch, unsigned int options,
2513                    int for_migration,
2514                    import_screener_t screener, void *screener_arg)
2515 {
2516   PKT_public_key *pk;
2517   struct seckey_info *ski;
2518   kbnode_t node, uidnode;
2519   u32 keyid[2];
2520   int rc = 0;
2521   int nr_prev;
2522   kbnode_t pub_keyblock;
2523   char pkstrbuf[PUBKEY_STRING_SIZE];
2524
2525   /* Get the key and print some info about it */
2526   node = find_kbnode (keyblock, PKT_SECRET_KEY);
2527   if (!node)
2528     BUG ();
2529
2530   pk = node->pkt->pkt.public_key;
2531
2532   keyid_from_pk (pk, keyid);
2533   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
2534
2535   if (screener && screener (keyblock, screener_arg))
2536     {
2537       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
2538                  _("rejected by import screener"));
2539       return 0;
2540   }
2541
2542   if (opt.verbose && !for_migration)
2543     {
2544       log_info ("sec  %s/%s %s   ",
2545                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
2546                 keystr_from_pk (pk), datestr_from_pk (pk));
2547       if (uidnode)
2548         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
2549                            uidnode->pkt->pkt.user_id->len);
2550       log_printf ("\n");
2551     }
2552   stats->secret_read++;
2553
2554   if ((options & IMPORT_NO_SECKEY))
2555     {
2556       if (!for_migration)
2557         log_error (_("importing secret keys not allowed\n"));
2558       return 0;
2559     }
2560
2561   if (!uidnode)
2562     {
2563       if (!for_migration)
2564         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
2565       return 0;
2566     }
2567
2568   ski = pk->seckey_info;
2569   if (!ski)
2570     {
2571       /* Actually an internal error.  */
2572       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
2573       return 0;
2574     }
2575
2576   /* A quick check to not import keys with an invalid protection
2577      cipher algorithm (only checks the primary key, though).  */
2578   if (ski->algo > 110)
2579     {
2580       if (!for_migration)
2581         log_error (_("key %s: secret key with invalid cipher %d"
2582                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
2583       return 0;
2584     }
2585
2586 #ifdef ENABLE_SELINUX_HACKS
2587   if (1)
2588     {
2589       /* We don't allow importing secret keys because that may be used
2590          to put a secret key into the keyring and the user might later
2591          be tricked into signing stuff with that key.  */
2592       log_error (_("importing secret keys not allowed\n"));
2593       return 0;
2594     }
2595 #endif
2596
2597   clear_kbnode_flags (keyblock);
2598
2599   nr_prev = stats->skipped_new_keys;
2600
2601   /* Make a public key out of the key. */
2602   pub_keyblock = sec_to_pub_keyblock (keyblock);
2603   if (!pub_keyblock)
2604     log_error ("key %s: failed to create public key from secret key\n",
2605                    keystr_from_pk (pk));
2606   else
2607     {
2608       /* Note that this outputs an IMPORT_OK status message for the
2609          public key block, and below we will output another one for
2610          the secret keys.  FIXME?  */
2611       import_one (ctrl, pub_keyblock, stats,
2612                   NULL, NULL, options, 1, for_migration,
2613                   screener, screener_arg, 0, NULL);
2614
2615       /* Fixme: We should check for an invalid keyblock and
2616          cancel the secret key import in this case.  */
2617       release_kbnode (pub_keyblock);
2618
2619       /* At least we cancel the secret key import when the public key
2620          import was skipped due to MERGE_ONLY option and a new
2621          key.  */
2622       if (!(opt.dry_run || (options & IMPORT_DRY_RUN))
2623           && stats->skipped_new_keys <= nr_prev)
2624         {
2625           /* Read the keyblock again to get the effects of a merge.  */
2626           /* Fixme: we should do this based on the fingerprint or
2627              even better let import_one return the merged
2628              keyblock.  */
2629           node = get_pubkeyblock (ctrl, keyid);
2630           if (!node)
2631             log_error ("key %s: failed to re-lookup public key\n",
2632                        keystr_from_pk (pk));
2633           else
2634             {
2635               gpg_error_t err;
2636
2637               /* transfer_secret_keys collects subkey stats.  */
2638               struct import_stats_s subkey_stats = {0};
2639
2640               err = transfer_secret_keys (ctrl, &subkey_stats, keyblock,
2641                                           batch, 0);
2642               if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
2643                 {
2644                   /* TRANSLATORS: For smartcard, each private key on
2645                      host has a reference (stub) to a smartcard and
2646                      actual private key data is stored on the card.  A
2647                      single smartcard can have up to three private key
2648                      data.  Importing private key stub is always
2649                      skipped in 2.1, and it returns
2650                      GPG_ERR_NOT_PROCESSED.  Instead, user should be
2651                      suggested to run 'gpg --card-status', then,
2652                      references to a card will be automatically
2653                      created again.  */
2654                   log_info (_("To migrate '%s', with each smartcard, "
2655                               "run: %s\n"), "secring.gpg", "gpg --card-status");
2656                   err = 0;
2657                 }
2658               if (!err)
2659                 {
2660                   int status = 16;
2661                   if (!opt.quiet)
2662                     log_info (_("key %s: secret key imported\n"),
2663                               keystr_from_pk (pk));
2664                   if (subkey_stats.secret_imported)
2665                     {
2666                       status |= 1;
2667                       stats->secret_imported += 1;
2668                     }
2669                   if (subkey_stats.secret_dups)
2670                     stats->secret_dups += 1;
2671
2672                   if (is_status_enabled ())
2673                     print_import_ok (pk, status);
2674                   check_prefs (ctrl, node);
2675                 }
2676               release_kbnode (node);
2677             }
2678         }
2679     }
2680
2681   return rc;
2682 }
2683
2684
2685
2686 /* Return the recocation reason from signature SIG.  If no revocation
2687  * reason is availabale 0 is returned, in other cases the reason
2688  * (0..255).  If R_REASON is not NULL a malloced textual
2689  * representation of the code is stored there.  If R_COMMENT is not
2690  * NULL the comment from the reason is stored there and its length at
2691  * R_COMMENTLEN.  Note that the value at R_COMMENT is not filtered but
2692  * user supplied data in UTF8; thus it needs to be escaped for display
2693  * purposes.  Both return values are either NULL or a malloced
2694  * string/buffer.  */
2695 int
2696 get_revocation_reason (PKT_signature *sig, char **r_reason,
2697                        char **r_comment, size_t *r_commentlen)
2698 {
2699   int reason_seq = 0;
2700   size_t reason_n;
2701   const byte *reason_p;
2702   char reason_code_buf[20];
2703   const char *reason_text = NULL;
2704   int reason_code = 0;
2705
2706   if (r_reason)
2707     *r_reason = NULL;
2708   if (r_comment)
2709     *r_comment = NULL;
2710
2711   /* Skip over empty reason packets.  */
2712   while ((reason_p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REVOC_REASON,
2713                                       &reason_n, &reason_seq, NULL))
2714          && !reason_n)
2715     ;
2716   if (reason_p)
2717     {
2718       reason_code = *reason_p;
2719       reason_n--; reason_p++;
2720       switch (reason_code)
2721         {
2722         case 0x00: reason_text = _("No reason specified"); break;
2723         case 0x01: reason_text = _("Key is superseded");   break;
2724         case 0x02: reason_text = _("Key has been compromised"); break;
2725         case 0x03: reason_text = _("Key is no longer used"); break;
2726         case 0x20: reason_text = _("User ID is no longer valid"); break;
2727         default:
2728           snprintf (reason_code_buf, sizeof reason_code_buf,
2729                     "code=%02x", reason_code);
2730           reason_text = reason_code_buf;
2731           break;
2732         }
2733
2734       if (r_reason)
2735         *r_reason = xstrdup (reason_text);
2736
2737       if (r_comment && reason_n)
2738         {
2739           *r_comment = xmalloc (reason_n);
2740           memcpy (*r_comment, reason_p, reason_n);
2741           *r_commentlen = reason_n;
2742         }
2743     }
2744
2745   return reason_code;
2746 }
2747
2748
2749 /* List the recocation signature as a "rvs" record.  SIGRC shows the
2750  * character from the signature verification or 0 if no public key was
2751  * found.  */
2752 static void
2753 list_standalone_revocation (ctrl_t ctrl, PKT_signature *sig, int sigrc)
2754 {
2755   char *siguid = NULL;
2756   size_t siguidlen = 0;
2757   char *issuer_fpr = NULL;
2758   int reason_code = 0;
2759   char *reason_text = NULL;
2760   char *reason_comment = NULL;
2761   size_t reason_commentlen;
2762
2763   if (sigrc != '%' && sigrc != '?' && !opt.fast_list_mode)
2764     {
2765       int nouid;
2766       siguid = get_user_id (ctrl, sig->keyid, &siguidlen, &nouid);
2767       if (nouid)
2768         sigrc = '?';
2769     }
2770
2771   reason_code = get_revocation_reason (sig, &reason_text,
2772                                        &reason_comment, &reason_commentlen);
2773
2774   if (opt.with_colons)
2775     {
2776       es_fputs ("rvs:", es_stdout);
2777       if (sigrc)
2778         es_putc (sigrc, es_stdout);
2779       es_fprintf (es_stdout, "::%d:%08lX%08lX:%s:%s:::",
2780                   sig->pubkey_algo,
2781                   (ulong) sig->keyid[0], (ulong) sig->keyid[1],
2782                   colon_datestr_from_sig (sig),
2783                   colon_expirestr_from_sig (sig));
2784
2785       if (siguid)
2786         es_write_sanitized (es_stdout, siguid, siguidlen, ":", NULL);
2787
2788       es_fprintf (es_stdout, ":%02x%c", sig->sig_class,
2789                   sig->flags.exportable ? 'x' : 'l');
2790       if (reason_text)
2791         es_fprintf (es_stdout, ",%02x", reason_code);
2792       es_fputs ("::", es_stdout);
2793
2794       if ((issuer_fpr = issuer_fpr_string (sig)))
2795         es_fputs (issuer_fpr, es_stdout);
2796
2797       es_fprintf (es_stdout, ":::%d:", sig->digest_algo);
2798
2799       if (reason_comment)
2800         {
2801           es_fputs ("::::", es_stdout);
2802           es_write_sanitized (es_stdout, reason_comment, reason_commentlen,
2803                               ":", NULL);
2804           es_putc (':', es_stdout);
2805         }
2806       es_putc ('\n', es_stdout);
2807
2808       if (opt.show_subpackets)
2809         print_subpackets_colon (sig);
2810     }
2811   else /* Human readable. */
2812     {
2813       es_fputs ("rvs", es_stdout);
2814       es_fprintf (es_stdout, "%c%c %c%c%c%c%c%c %s %s",
2815                   sigrc, (sig->sig_class - 0x10 > 0 &&
2816                           sig->sig_class - 0x10 <
2817                           4) ? '0' + sig->sig_class - 0x10 : ' ',
2818                   sig->flags.exportable ? ' ' : 'L',
2819                   sig->flags.revocable ? ' ' : 'R',
2820                   sig->flags.policy_url ? 'P' : ' ',
2821                   sig->flags.notation ? 'N' : ' ',
2822                   sig->flags.expired ? 'X' : ' ',
2823                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
2824                                                   0) ? '0' +
2825                   sig->trust_depth : ' ', keystr (sig->keyid),
2826                   datestr_from_sig (sig));
2827       if (siguid)
2828         {
2829           es_fprintf (es_stdout, "  ");
2830           print_utf8_buffer (es_stdout, siguid, siguidlen);
2831         }
2832       es_putc ('\n', es_stdout);
2833
2834       if (sig->flags.policy_url
2835           && (opt.list_options & LIST_SHOW_POLICY_URLS))
2836         show_policy_url (sig, 3, 0);
2837
2838       if (sig->flags.notation && (opt.list_options & LIST_SHOW_NOTATIONS))
2839         show_notation (sig, 3, 0,
2840                        ((opt.list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0)
2841                        +
2842                        ((opt.list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));
2843
2844       if (sig->flags.pref_ks
2845           && (opt.list_options & LIST_SHOW_KEYSERVER_URLS))
2846         show_keyserver_url (sig, 3, 0);
2847
2848       if (reason_text)
2849         {
2850           es_fprintf (es_stdout, "      %s%s\n",
2851                       _("reason for revocation: "), reason_text);
2852           if (reason_comment)
2853             {
2854               const byte *s, *s_lf;
2855               size_t n, n_lf;
2856
2857               s = reason_comment;
2858               n = reason_commentlen;
2859               s_lf = NULL;
2860               do
2861                 {
2862                   /* We don't want any empty lines, so we skip them.  */
2863                   for (;n && *s == '\n'; s++, n--)
2864                     ;
2865                   if (n)
2866                     {
2867                       s_lf = memchr (s, '\n', n);
2868                       n_lf = s_lf? s_lf - s : n;
2869                       es_fprintf (es_stdout, "         %s",
2870                                   _("revocation comment: "));
2871                       es_write_sanitized (es_stdout, s, n_lf, NULL, NULL);
2872                       es_putc ('\n', es_stdout);
2873                       s += n_lf; n -= n_lf;
2874                     }
2875                 } while (s_lf);
2876             }
2877         }
2878     }
2879
2880   es_fflush (es_stdout);
2881
2882   xfree (reason_text);
2883   xfree (reason_comment);
2884   xfree (siguid);
2885   xfree (issuer_fpr);
2886 }
2887
2888
2889 /****************
2890  * Import a revocation certificate; this is a single signature packet.
2891  */
2892 static int
2893 import_revoke_cert (ctrl_t ctrl, kbnode_t node, unsigned int options,
2894                     struct import_stats_s *stats)
2895 {
2896   PKT_public_key *pk = NULL;
2897   kbnode_t onode;
2898   kbnode_t keyblock = NULL;
2899   KEYDB_HANDLE hd = NULL;
2900   u32 keyid[2];
2901   int rc = 0;
2902   int sigrc = 0;
2903   int silent;
2904
2905   /* No error output for --show-keys.  */
2906   silent = (options & (IMPORT_SHOW | IMPORT_DRY_RUN));
2907
2908   log_assert (!node->next );
2909   log_assert (node->pkt->pkttype == PKT_SIGNATURE );
2910   log_assert (IS_KEY_REV (node->pkt->pkt.signature));
2911
2912   keyid[0] = node->pkt->pkt.signature->keyid[0];
2913   keyid[1] = node->pkt->pkt.signature->keyid[1];
2914
2915   pk = xmalloc_clear( sizeof *pk );
2916   rc = get_pubkey (ctrl, pk, keyid );
2917   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
2918     {
2919       if (!silent)
2920         log_error (_("key %s: no public key -"
2921                      " can't apply revocation certificate\n"), keystr(keyid));
2922       rc = 0;
2923       goto leave;
2924     }
2925   else if (rc )
2926     {
2927       log_error (_("key %s: public key not found: %s\n"),
2928                  keystr(keyid), gpg_strerror (rc));
2929       goto leave;
2930     }
2931
2932   /* Read the original keyblock. */
2933   hd = keydb_new ();
2934   if (!hd)
2935     {
2936       rc = gpg_error_from_syserror ();
2937       goto leave;
2938     }
2939
2940   {
2941     byte afp[MAX_FINGERPRINT_LEN];
2942     size_t an;
2943
2944     fingerprint_from_pk (pk, afp, &an);
2945     while (an < MAX_FINGERPRINT_LEN)
2946       afp[an++] = 0;
2947     rc = keydb_search_fpr (hd, afp);
2948   }
2949   if (rc)
2950     {
2951       log_error (_("key %s: can't locate original keyblock: %s\n"),
2952                  keystr(keyid), gpg_strerror (rc));
2953       goto leave;
2954     }
2955   rc = keydb_get_keyblock (hd, &keyblock );
2956   if (rc)
2957     {
2958       log_error (_("key %s: can't read original keyblock: %s\n"),
2959                  keystr(keyid), gpg_strerror (rc));
2960       goto leave;
2961     }
2962
2963   /* it is okay, that node is not in keyblock because
2964    * check_key_signature works fine for sig_class 0x20 (KEY_REV) in
2965    * this special case.  SIGRC is only used for IMPORT_SHOW.  */
2966   rc = check_key_signature (ctrl, keyblock, node, NULL);
2967   switch (gpg_err_code (rc))
2968     {
2969     case 0:                       sigrc = '!'; break;
2970     case GPG_ERR_BAD_SIGNATURE:   sigrc = '-'; break;
2971     case GPG_ERR_NO_PUBKEY:       sigrc = '?'; break;
2972     case GPG_ERR_UNUSABLE_PUBKEY: sigrc = '?'; break;
2973     default:                      sigrc = '%'; break;
2974     }
2975   if (rc )
2976     {
2977       if (!silent)
2978         log_error (_("key %s: invalid revocation certificate"
2979                      ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
2980       goto leave;
2981     }
2982
2983   /* check whether we already have this */
2984   for(onode=keyblock->next; onode; onode=onode->next ) {
2985     if (onode->pkt->pkttype == PKT_USER_ID )
2986       break;
2987     else if (onode->pkt->pkttype == PKT_SIGNATURE
2988              && !cmp_signatures(node->pkt->pkt.signature,
2989                                 onode->pkt->pkt.signature))
2990       {
2991         rc = 0;
2992         goto leave; /* yes, we already know about it */
2993       }
2994   }
2995
2996   /* insert it */
2997   insert_kbnode( keyblock, clone_kbnode(node), 0 );
2998
2999   /* and write the keyblock back unless in dry run mode.  */
3000   if (!(opt.dry_run || (options & IMPORT_DRY_RUN)))
3001     {
3002       rc = keydb_update_keyblock (ctrl, hd, keyblock );
3003       if (rc)
3004         log_error (_("error writing keyring '%s': %s\n"),
3005                    keydb_get_resource_name (hd), gpg_strerror (rc) );
3006       keydb_release (hd);
3007       hd = NULL;
3008
3009       /* we are ready */
3010       if (!opt.quiet )
3011         {
3012           char *p=get_user_id_native (ctrl, keyid);
3013           log_info( _("key %s: \"%s\" revocation certificate imported\n"),
3014                     keystr(keyid),p);
3015           xfree(p);
3016         }
3017
3018       /* If the key we just revoked was ultimately trusted, remove its
3019        * ultimate trust.  This doesn't stop the user from putting the
3020        * ultimate trust back, but is a reasonable solution for now. */
3021       if (get_ownertrust (ctrl, pk) == TRUST_ULTIMATE)
3022         clear_ownertrusts (ctrl, pk);
3023
3024       revalidation_mark (ctrl);
3025     }
3026   stats->n_revoc++;
3027
3028  leave:
3029   if ((options & IMPORT_SHOW))
3030     list_standalone_revocation (ctrl, node->pkt->pkt.signature, sigrc);
3031
3032   keydb_release (hd);
3033   release_kbnode( keyblock );
3034   free_public_key( pk );
3035   return rc;
3036 }
3037
3038
3039 /* Loop over the KEYBLOCK and check all self signatures.  KEYID is the
3040  * keyid of the primary key for reporting purposes. On return the
3041  * following bits in the node flags are set:
3042  *
3043  * - NODE_GOOD_SELFSIG  :: User ID or subkey has a self-signature
3044  * - NODE_BAD_SELFSIG   :: Used ID or subkey has an invalid self-signature
3045  * - NODE_DELETION_MARK :: This node shall be deleted
3046  *
3047  * NON_SELF is set to true if there are any sigs other than self-sigs
3048  * in this keyblock.
3049  *
3050  * Returns 0 on success or -1 (but not an error code) if the keyblock
3051  * is invalid.
3052  */
3053 static int
3054 chk_self_sigs (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid, int *non_self)
3055 {
3056   kbnode_t knode = NULL;   /* The node of the current subkey.  */
3057   PKT_public_key *subpk = NULL; /* and its packet. */
3058   kbnode_t bsnode = NULL;  /* Subkey binding signature node.  */
3059   u32 bsdate = 0;          /* Timestamp of that node.   */
3060   kbnode_t rsnode = NULL;  /* Subkey recocation signature node.  */
3061   u32 rsdate = 0;          /* Timestamp of tha node.  */
3062   PKT_signature *sig;
3063   int rc;
3064   kbnode_t n;
3065
3066   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
3067     {
3068       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
3069         {
3070           knode = n;
3071           subpk = knode->pkt->pkt.public_key;
3072           bsdate = 0;
3073           rsdate = 0;
3074           bsnode = NULL;
3075           rsnode = NULL;
3076           continue;
3077         }
3078
3079       if ( n->pkt->pkttype != PKT_SIGNATURE )
3080         continue;
3081
3082       sig = n->pkt->pkt.signature;
3083       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
3084         {
3085           *non_self = 1;
3086           continue;
3087         }
3088
3089       /* This just caches the sigs for later use.  That way we
3090          import a fully-cached key which speeds things up. */
3091       if (!opt.no_sig_cache)
3092         check_key_signature (ctrl, keyblock, n, NULL);
3093
3094       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
3095         {
3096           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
3097           if ( !unode )
3098             {
3099               log_error( _("key %s: no user ID for signature\n"),
3100                          keystr(keyid));
3101               return -1;  /* The complete keyblock is invalid.  */
3102             }
3103
3104           /* If it hasn't been marked valid yet, keep trying.  */
3105           if (!(unode->flag & NODE_GOOD_SELFSIG))
3106             {
3107               rc = check_key_signature (ctrl, keyblock, n, NULL);
3108               if ( rc )
3109                 {
3110                   if ( opt.verbose )
3111                     {
3112                       char *p = utf8_to_native
3113                         (unode->pkt->pkt.user_id->name,
3114                          strlen (unode->pkt->pkt.user_id->name),0);
3115                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
3116                                 _("key %s: unsupported public key "
3117                                   "algorithm on user ID \"%s\"\n"):
3118                                 _("key %s: invalid self-signature "
3119                                   "on user ID \"%s\"\n"),
3120                                 keystr (keyid),p);
3121                       xfree (p);
3122                     }
3123                 }
3124               else
3125                 unode->flag |= NODE_GOOD_SELFSIG;
3126             }
3127         }
3128       else if (IS_KEY_SIG (sig))
3129         {
3130           rc = check_key_signature (ctrl, keyblock, n, NULL);
3131           if ( rc )
3132             {
3133               if (opt.verbose)
3134                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
3135                           _("key %s: unsupported public key algorithm\n"):
3136                           _("key %s: invalid direct key signature\n"),
3137                           keystr (keyid));
3138               n->flag |= NODE_DELETION_MARK;
3139             }
3140         }
3141       else if ( IS_SUBKEY_SIG (sig) )
3142         {
3143           /* Note that this works based solely on the timestamps like
3144              the rest of gpg.  If the standard gets revocation
3145              targets, this may need to be revised.  */
3146
3147           if ( !knode )
3148             {
3149               if (opt.verbose)
3150                 log_info (_("key %s: no subkey for key binding\n"),
3151                           keystr (keyid));
3152               n->flag |= NODE_DELETION_MARK;
3153             }
3154           else
3155             {
3156               rc = check_key_signature (ctrl, keyblock, n, NULL);
3157               if ( rc )
3158                 {
3159                   if (opt.verbose)
3160                     {
3161                       keyid_from_pk (subpk, NULL);
3162                       log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
3163                                 _("key %s: unsupported public key"
3164                                   " algorithm\n"):
3165                                 _("key %s: invalid subkey binding\n"),
3166                                 keystr_with_sub (keyid, subpk->keyid));
3167                     }
3168                   n->flag |= NODE_DELETION_MARK;
3169                 }
3170               else
3171                 {
3172                   /* It's valid, so is it newer? */
3173                   if (sig->timestamp >= bsdate)
3174                     {
3175                       knode->flag |= NODE_GOOD_SELFSIG; /* Subkey is valid.  */
3176                       if (bsnode)
3177                         {
3178                           /* Delete the last binding sig since this
3179                              one is newer */
3180                           bsnode->flag |= NODE_DELETION_MARK;
3181                           if (opt.verbose)
3182                             {
3183                               keyid_from_pk (subpk, NULL);
3184                               log_info (_("key %s: removed multiple subkey"
3185                                           " binding\n"),
3186                                         keystr_with_sub (keyid, subpk->keyid));
3187                             }
3188                         }
3189
3190                       bsnode = n;
3191                       bsdate = sig->timestamp;
3192                     }
3193                   else
3194                     n->flag |= NODE_DELETION_MARK; /* older */
3195                 }
3196             }
3197         }
3198       else if ( IS_SUBKEY_REV (sig) )
3199         {
3200           /* We don't actually mark the subkey as revoked right now,
3201              so just check that the revocation sig is the most recent
3202              valid one.  Note that we don't care if the binding sig is
3203              newer than the revocation sig.  See the comment in
3204              getkey.c:merge_selfsigs_subkey for more.  */
3205           if ( !knode )
3206             {
3207               if (opt.verbose)
3208                 log_info (_("key %s: no subkey for key revocation\n"),
3209                           keystr(keyid));
3210               n->flag |= NODE_DELETION_MARK;
3211             }
3212           else
3213             {
3214               rc = check_key_signature (ctrl, keyblock, n, NULL);
3215               if ( rc )
3216                 {
3217                   if(opt.verbose)
3218                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
3219                               _("key %s: unsupported public"
3220                                 " key algorithm\n"):
3221                               _("key %s: invalid subkey revocation\n"),
3222                               keystr(keyid));
3223                   n->flag |= NODE_DELETION_MARK;
3224                 }
3225               else
3226                 {
3227                   /* It's valid, so is it newer? */
3228                   if (sig->timestamp >= rsdate)
3229                     {
3230                       if (rsnode)
3231                         {
3232                           /* Delete the last revocation sig since
3233                              this one is newer.  */
3234                           rsnode->flag |= NODE_DELETION_MARK;
3235                           if (opt.verbose)
3236                             log_info (_("key %s: removed multiple subkey"
3237                                         " revocation\n"),keystr(keyid));
3238                         }
3239
3240                       rsnode = n;
3241                       rsdate = sig->timestamp;
3242                     }
3243                   else
3244                     n->flag |= NODE_DELETION_MARK; /* older */
3245                 }
3246             }
3247         }
3248     }
3249
3250   return 0;
3251 }
3252
3253
3254 /* Delete all parts which are invalid and those signatures whose
3255  * public key algorithm is not available in this implementation; but
3256  * consider RSA as valid, because parse/build_packets knows about it.
3257  *
3258  * Returns: True if at least one valid user-id is left over.
3259  */
3260 static int
3261 delete_inv_parts (ctrl_t ctrl, kbnode_t keyblock, u32 *keyid,
3262                   unsigned int options)
3263 {
3264   kbnode_t node;
3265   int nvalid=0, uid_seen=0, subkey_seen=0;
3266   PKT_public_key *pk;
3267
3268   for (node=keyblock->next; node; node = node->next )
3269     {
3270       if (node->pkt->pkttype == PKT_USER_ID)
3271         {
3272           uid_seen = 1;
3273           if ((node->flag & NODE_BAD_SELFSIG)
3274               || !(node->flag & NODE_GOOD_SELFSIG))
3275             {
3276               if (opt.verbose )
3277                 {
3278                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
3279                                          node->pkt->pkt.user_id->len,0);
3280                   log_info( _("key %s: skipped user ID \"%s\"\n"),
3281                             keystr(keyid),p);
3282                   xfree(p);
3283                 }
3284               delete_kbnode( node ); /* the user-id */
3285               /* and all following packets up to the next user-id */
3286               while (node->next
3287                      && node->next->pkt->pkttype != PKT_USER_ID
3288                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
3289                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
3290                 delete_kbnode( node->next );
3291                 node = node->next;
3292               }
3293             }
3294           else
3295             nvalid++;
3296         }
3297       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3298                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
3299         {
3300           if ((node->flag & NODE_BAD_SELFSIG)
3301               || !(node->flag & NODE_GOOD_SELFSIG))
3302             {
3303               if (opt.verbose )
3304                 {
3305                   pk = node->pkt->pkt.public_key;
3306                   keyid_from_pk (pk, NULL);
3307                   log_info (_("key %s: skipped subkey\n"),
3308                             keystr_with_sub (keyid, pk->keyid));
3309                 }
3310
3311               delete_kbnode( node ); /* the subkey */
3312               /* and all following signature packets */
3313               while (node->next
3314                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
3315                 delete_kbnode( node->next );
3316                 node = node->next;
3317               }
3318             }
3319           else
3320             subkey_seen = 1;
3321         }
3322       else if (node->pkt->pkttype == PKT_SIGNATURE
3323                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
3324                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
3325         {
3326           delete_kbnode( node ); /* build_packet() can't handle this */
3327         }
3328       else if (node->pkt->pkttype == PKT_SIGNATURE
3329                && !node->pkt->pkt.signature->flags.exportable
3330                && !(options&IMPORT_LOCAL_SIGS)
3331                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
3332         {
3333           /* here we violate the rfc a bit by still allowing
3334            * to import non-exportable signature when we have the
3335            * the secret key used to create this signature - it
3336            * seems that this makes sense */
3337           if(opt.verbose)
3338             log_info( _("key %s: non exportable signature"
3339                         " (class 0x%02X) - skipped\n"),
3340                       keystr(keyid), node->pkt->pkt.signature->sig_class );
3341           delete_kbnode( node );
3342         }
3343       else if (node->pkt->pkttype == PKT_SIGNATURE
3344                && IS_KEY_REV (node->pkt->pkt.signature))
3345         {
3346           if (uid_seen )
3347             {
3348               if(opt.verbose)
3349                 log_info( _("key %s: revocation certificate"
3350                             " at wrong place - skipped\n"),keystr(keyid));
3351               delete_kbnode( node );
3352             }
3353           else
3354             {
3355               /* If the revocation cert is from a different key than
3356                  the one we're working on don't check it - it's
3357                  probably from a revocation key and won't be
3358                  verifiable with this key anyway. */
3359
3360               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
3361                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
3362                 {
3363                   int rc = check_key_signature (ctrl, keyblock, node, NULL);
3364                   if (rc )
3365                     {
3366                       if(opt.verbose)
3367                         log_info( _("key %s: invalid revocation"
3368                                     " certificate: %s - skipped\n"),
3369                                   keystr(keyid), gpg_strerror (rc));
3370                       delete_kbnode( node );
3371                     }
3372                 }
3373             }
3374         }
3375       else if (node->pkt->pkttype == PKT_SIGNATURE
3376                && (IS_SUBKEY_SIG (node->pkt->pkt.signature)
3377                    || IS_SUBKEY_REV (node->pkt->pkt.signature))
3378                && !subkey_seen )
3379         {
3380           if(opt.verbose)
3381             log_info( _("key %s: subkey signature"
3382                         " in wrong place - skipped\n"), keystr(keyid));
3383           delete_kbnode( node );
3384         }
3385       else if (node->pkt->pkttype == PKT_SIGNATURE
3386                && !IS_CERT(node->pkt->pkt.signature))
3387         {
3388           if(opt.verbose)
3389             log_info(_("key %s: unexpected signature class (0x%02X) -"
3390                        " skipped\n"),keystr(keyid),
3391                      node->pkt->pkt.signature->sig_class);
3392           delete_kbnode(node);
3393           }
3394       else if ((node->flag & NODE_DELETION_MARK))
3395         delete_kbnode( node );
3396     }
3397
3398   /* note: because keyblock is the public key, it is never marked
3399    * for deletion and so keyblock cannot change */
3400   commit_kbnode( &keyblock );
3401   return nvalid;
3402 }
3403
3404 /* This function returns true if any UID is left in the keyring.  */
3405 static int
3406 any_uid_left (kbnode_t keyblock)
3407 {
3408   kbnode_t node;
3409
3410   for (node=keyblock->next; node; node = node->next)
3411     if (node->pkt->pkttype == PKT_USER_ID)
3412       return 1;
3413   return 0;
3414 }
3415
3416
3417
3418 /****************
3419  * It may happen that the imported keyblock has duplicated user IDs.
3420  * We check this here and collapse those user IDs together with their
3421  * sigs into one.
3422  * Returns: True if the keyblock has changed.
3423  */
3424 int
3425 collapse_uids( kbnode_t *keyblock )
3426 {
3427   kbnode_t uid1;
3428   int any=0;
3429
3430   for(uid1=*keyblock;uid1;uid1=uid1->next)
3431     {
3432       kbnode_t uid2;
3433
3434       if(is_deleted_kbnode(uid1))
3435         continue;
3436
3437       if(uid1->pkt->pkttype!=PKT_USER_ID)
3438         continue;
3439
3440       for(uid2=uid1->next;uid2;uid2=uid2->next)
3441         {
3442           if(is_deleted_kbnode(uid2))
3443             continue;
3444
3445           if(uid2->pkt->pkttype!=PKT_USER_ID)
3446             continue;
3447
3448           if(cmp_user_ids(uid1->pkt->pkt.user_id,
3449                           uid2->pkt->pkt.user_id)==0)
3450             {
3451               /* We have a duplicated uid */
3452               kbnode_t sig1,last;
3453
3454               any=1;
3455
3456               /* Now take uid2's signatures, and attach them to
3457                  uid1 */
3458               for(last=uid2;last->next;last=last->next)
3459                 {
3460                   if(is_deleted_kbnode(last))
3461                     continue;
3462
3463                   if(last->next->pkt->pkttype==PKT_USER_ID
3464                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
3465                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
3466                     break;
3467                 }
3468
3469               /* Snip out uid2 */
3470               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
3471
3472               /* Now put uid2 in place as part of uid1 */
3473 &