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