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