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