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