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