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