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