gpg: Avoid spurious failures on keyblocks with no or only deleted nodes.
[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   err = 0;
873
874  leave:
875   if (err)
876     iobuf_cancel (out);
877   else
878     iobuf_close (out);
879   release_armor_context (afx);
880   return err;
881 }
882
883
884 static void
885 print_import_ok (PKT_public_key *pk, unsigned int reason)
886 {
887   byte array[MAX_FINGERPRINT_LEN], *s;
888   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
889   size_t i, n;
890
891   snprintf (buf, sizeof buf, "%u ", reason);
892   p = buf + strlen (buf);
893
894   fingerprint_from_pk (pk, array, &n);
895   s = array;
896   for (i=0; i < n ; i++, s++, p += 2)
897     sprintf (p, "%02X", *s);
898
899   write_status_text (STATUS_IMPORT_OK, buf);
900 }
901
902
903 static void
904 print_import_check (PKT_public_key * pk, PKT_user_id * id)
905 {
906   char * buf;
907   byte fpr[24];
908   u32 keyid[2];
909   size_t i, n;
910   size_t pos = 0;
911
912   buf = xmalloc (17+41+id->len+32);
913   keyid_from_pk (pk, keyid);
914   sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
915   pos = 17;
916   fingerprint_from_pk (pk, fpr, &n);
917   for (i = 0; i < n; i++, pos += 2)
918     sprintf (buf+pos, "%02X", fpr[i]);
919   strcat (buf, " ");
920   strcat (buf, id->name);
921   write_status_text (STATUS_IMPORT_CHECK, buf);
922   xfree (buf);
923 }
924
925
926 static void
927 check_prefs_warning(PKT_public_key *pk)
928 {
929   log_info(_("WARNING: key %s contains preferences for unavailable\n"
930              "algorithms on these user IDs:\n"), keystr_from_pk(pk));
931 }
932
933
934 static void
935 check_prefs (ctrl_t ctrl, kbnode_t keyblock)
936 {
937   kbnode_t node;
938   PKT_public_key *pk;
939   int problem=0;
940
941   merge_keys_and_selfsig(keyblock);
942   pk=keyblock->pkt->pkt.public_key;
943
944   for(node=keyblock;node;node=node->next)
945     {
946       if(node->pkt->pkttype==PKT_USER_ID
947          && node->pkt->pkt.user_id->created
948          && node->pkt->pkt.user_id->prefs)
949         {
950           PKT_user_id *uid = node->pkt->pkt.user_id;
951           prefitem_t *prefs = uid->prefs;
952           char *user = utf8_to_native(uid->name,strlen(uid->name),0);
953
954           for(;prefs->type;prefs++)
955             {
956               char num[10]; /* prefs->value is a byte, so we're over
957                                safe here */
958
959               sprintf(num,"%u",prefs->value);
960
961               if(prefs->type==PREFTYPE_SYM)
962                 {
963                   if (openpgp_cipher_test_algo (prefs->value))
964                     {
965                       const char *algo =
966                         (openpgp_cipher_test_algo (prefs->value)
967                          ? num
968                          : openpgp_cipher_algo_name (prefs->value));
969                       if(!problem)
970                         check_prefs_warning(pk);
971                       log_info(_("         \"%s\": preference for cipher"
972                                  " algorithm %s\n"), user, algo);
973                       problem=1;
974                     }
975                 }
976               else if(prefs->type==PREFTYPE_HASH)
977                 {
978                   if(openpgp_md_test_algo(prefs->value))
979                     {
980                       const char *algo =
981                         (gcry_md_test_algo (prefs->value)
982                          ? num
983                          : gcry_md_algo_name (prefs->value));
984                       if(!problem)
985                         check_prefs_warning(pk);
986                       log_info(_("         \"%s\": preference for digest"
987                                  " algorithm %s\n"), user, algo);
988                       problem=1;
989                     }
990                 }
991               else if(prefs->type==PREFTYPE_ZIP)
992                 {
993                   if(check_compress_algo (prefs->value))
994                     {
995                       const char *algo=compress_algo_to_string(prefs->value);
996                       if(!problem)
997                         check_prefs_warning(pk);
998                       log_info(_("         \"%s\": preference for compression"
999                                  " algorithm %s\n"),user,algo?algo:num);
1000                       problem=1;
1001                     }
1002                 }
1003             }
1004
1005           xfree(user);
1006         }
1007     }
1008
1009   if(problem)
1010     {
1011       log_info(_("it is strongly suggested that you update"
1012                  " your preferences and\n"));
1013       log_info(_("re-distribute this key to avoid potential algorithm"
1014                  " mismatch problems\n"));
1015
1016       if(!opt.batch)
1017         {
1018           strlist_t sl = NULL;
1019           strlist_t locusr = NULL;
1020           size_t fprlen=0;
1021           byte fpr[MAX_FINGERPRINT_LEN], *p;
1022           char username[(MAX_FINGERPRINT_LEN*2)+1];
1023           unsigned int i;
1024
1025           p = fingerprint_from_pk (pk,fpr,&fprlen);
1026           for(i=0;i<fprlen;i++,p++)
1027             sprintf(username+2*i,"%02X",*p);
1028           add_to_strlist(&locusr,username);
1029
1030           append_to_strlist(&sl,"updpref");
1031           append_to_strlist(&sl,"save");
1032
1033           keyedit_menu (ctrl, username, locusr, sl, 1, 1 );
1034           free_strlist(sl);
1035           free_strlist(locusr);
1036         }
1037       else if(!opt.quiet)
1038         log_info(_("you can update your preferences with:"
1039                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
1040     }
1041 }
1042
1043
1044 /* Helper for apply_keep_uid_filter.  */
1045 static const char *
1046 filter_getval (void *cookie, const char *propname)
1047 {
1048   kbnode_t node = cookie;
1049   const char *result;
1050
1051   if (node->pkt->pkttype == PKT_USER_ID)
1052     {
1053       if (!strcmp (propname, "uid"))
1054         result = node->pkt->pkt.user_id->name;
1055       else if (!strcmp (propname, "mbox"))
1056         {
1057           if (!node->pkt->pkt.user_id->mbox)
1058             {
1059               node->pkt->pkt.user_id->mbox
1060                 = mailbox_from_userid (node->pkt->pkt.user_id->name);
1061             }
1062           return node->pkt->pkt.user_id->mbox;
1063         }
1064       else if (!strcmp (propname, "primary"))
1065         result = node->pkt->pkt.user_id->is_primary? "1":"0";
1066       else
1067         result = NULL;
1068     }
1069   else
1070     result = NULL;
1071
1072   return result;
1073 }
1074
1075 /*
1076  * Apply the keep-uid filter to the keyblock.  The deleted nodes are
1077  * marked and thus the caller should call commit_kbnode afterwards.
1078  * KEYBLOCK must not have any blocks marked as deleted.
1079  */
1080 static void
1081 apply_keep_uid_filter (kbnode_t keyblock, recsel_expr_t selector)
1082 {
1083   kbnode_t node;
1084
1085   for (node = keyblock->next; node; node = node->next )
1086     {
1087       if (node->pkt->pkttype == PKT_USER_ID)
1088         {
1089           if (!recsel_select (selector, filter_getval, node))
1090             {
1091
1092               /* log_debug ("keep-uid: deleting '%s'\n", */
1093               /*            node->pkt->pkt.user_id->name); */
1094               /* The UID packet and all following packets up to the
1095                * next UID or a subkey.  */
1096               delete_kbnode (node);
1097               for (; node->next
1098                      && node->next->pkt->pkttype != PKT_USER_ID
1099                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1100                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ;
1101                    node = node->next)
1102                 delete_kbnode (node->next);
1103             }
1104           /* else */
1105           /*   log_debug ("keep-uid: keeping '%s'\n", */
1106           /*              node->pkt->pkt.user_id->name); */
1107         }
1108     }
1109 }
1110
1111
1112 /*
1113  * Try to import one keyblock. Return an error only in serious cases,
1114  * but never for an invalid keyblock.  It uses log_error to increase
1115  * the internal errorcount, so that invalid input can be detected by
1116  * programs which called gpg.  If SILENT is no messages are printed -
1117  * even most error messages are suppressed.
1118  */
1119 static int
1120 import_one (ctrl_t ctrl,
1121             const char *fname, kbnode_t keyblock, struct import_stats_s *stats,
1122             unsigned char **fpr, size_t *fpr_len, unsigned int options,
1123             int from_sk, int silent,
1124             import_screener_t screener, void *screener_arg)
1125 {
1126   PKT_public_key *pk;
1127   PKT_public_key *pk_orig = NULL;
1128   kbnode_t node, uidnode;
1129   kbnode_t keyblock_orig = NULL;
1130   byte fpr2[MAX_FINGERPRINT_LEN];
1131   size_t fpr2len;
1132   u32 keyid[2];
1133   int rc = 0;
1134   int new_key = 0;
1135   int mod_key = 0;
1136   int same_key = 0;
1137   int non_self = 0;
1138   size_t an;
1139   char pkstrbuf[PUBKEY_STRING_SIZE];
1140   int merge_keys_done = 0;
1141
1142   /* Get the key and print some info about it. */
1143   node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
1144   if (!node )
1145     BUG();
1146
1147   pk = node->pkt->pkt.public_key;
1148
1149   fingerprint_from_pk (pk, fpr2, &fpr2len);
1150   for (an = fpr2len; an < MAX_FINGERPRINT_LEN; an++)
1151     fpr2[an] = 0;
1152   keyid_from_pk( pk, keyid );
1153   uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1154
1155   if (opt.verbose && !opt.interactive && !silent)
1156     {
1157       log_info( "pub  %s/%s %s  ",
1158                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
1159                 keystr_from_pk(pk), datestr_from_pk(pk) );
1160       if (uidnode)
1161         print_utf8_buffer (log_get_stream (),
1162                            uidnode->pkt->pkt.user_id->name,
1163                            uidnode->pkt->pkt.user_id->len );
1164       log_printf ("\n");
1165     }
1166
1167
1168   if (!uidnode )
1169     {
1170       if (!silent)
1171         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
1172       return 0;
1173     }
1174
1175   if (screener && screener (keyblock, screener_arg))
1176     {
1177       log_error (_("key %s: %s\n"), keystr_from_pk (pk),
1178                  _("rejected by import screener"));
1179       return 0;
1180     }
1181
1182   if (opt.interactive && !silent)
1183     {
1184       if (is_status_enabled())
1185         print_import_check (pk, uidnode->pkt->pkt.user_id);
1186       merge_keys_and_selfsig (keyblock);
1187       tty_printf ("\n");
1188       show_basic_key_info (keyblock);
1189       tty_printf ("\n");
1190       if (!cpr_get_answer_is_yes ("import.okay",
1191                                   "Do you want to import this key? (y/N) "))
1192         return 0;
1193     }
1194
1195   collapse_uids(&keyblock);
1196
1197   /* Clean the key that we're about to import, to cut down on things
1198      that we have to clean later.  This has no practical impact on the
1199      end result, but does result in less logging which might confuse
1200      the user. */
1201   if (options&IMPORT_CLEAN)
1202     clean_key (keyblock,opt.verbose,options&IMPORT_MINIMAL,NULL,NULL);
1203
1204   clear_kbnode_flags( keyblock );
1205
1206   if ((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
1207       && opt.verbose)
1208     log_info (_("key %s: PKS subkey corruption repaired\n"),
1209               keystr_from_pk(pk));
1210
1211   rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
1212   if (rc )
1213     return rc== -1? 0:rc;
1214
1215   /* If we allow such a thing, mark unsigned uids as valid */
1216   if (opt.allow_non_selfsigned_uid)
1217     {
1218       for (node=keyblock; node; node = node->next )
1219         if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
1220           {
1221             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
1222                                       node->pkt->pkt.user_id->len,0);
1223             node->flag |= 1;
1224             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
1225                       keystr_from_pk(pk),user);
1226             xfree(user);
1227           }
1228     }
1229
1230   if (!delete_inv_parts( fname, keyblock, keyid, options ) )
1231     {
1232       if (!silent)
1233         {
1234           log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
1235           if (!opt.quiet )
1236             log_info(_("this may be caused by a missing self-signature\n"));
1237         }
1238       stats->no_user_id++;
1239       return 0;
1240     }
1241
1242   /* Get rid of deleted nodes.  */
1243   commit_kbnode (&keyblock);
1244
1245   /* Apply import filter.  */
1246   if (import_keep_uid)
1247     {
1248       apply_keep_uid_filter (keyblock, import_keep_uid);
1249       commit_kbnode (&keyblock);
1250     }
1251
1252
1253   /* Show the key in the form it is merged or inserted.  We skip this
1254    * if "import-export" is also active without --armor or the output
1255    * file has explicily been given. */
1256   if ((options & IMPORT_SHOW)
1257       && !((options & IMPORT_EXPORT) && !opt.armor && !opt.outfile))
1258     {
1259       merge_keys_and_selfsig (keyblock);
1260       merge_keys_done = 1;
1261       /* Note that we do not want to show the validity because the key
1262        * has not yet imported.  */
1263       list_keyblock_direct (ctrl, keyblock, 0, 0, 1, 1);
1264       es_fflush (es_stdout);
1265     }
1266
1267   /* Write the keyblock to the output and do not actually import.  */
1268   if ((options & IMPORT_EXPORT))
1269     {
1270       if (!merge_keys_done)
1271         {
1272           merge_keys_and_selfsig (keyblock);
1273           merge_keys_done = 1;
1274         }
1275       rc = write_keyblock_to_output (keyblock);
1276       goto leave;
1277     }
1278
1279   if (opt.dry_run)
1280     goto leave;
1281
1282   /* Do we have this key already in one of our pubrings ? */
1283   pk_orig = xmalloc_clear( sizeof *pk_orig );
1284   rc = get_pubkey_byfprint_fast (pk_orig, fpr2, fpr2len);
1285   if (rc && gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
1286       && gpg_err_code (rc) != GPG_ERR_UNUSABLE_PUBKEY )
1287     {
1288       if (!silent)
1289         log_error (_("key %s: public key not found: %s\n"),
1290                    keystr(keyid), gpg_strerror (rc));
1291     }
1292   else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
1293     {
1294       if (opt.verbose && !silent )
1295         log_info( _("key %s: new key - skipped\n"), keystr(keyid));
1296       rc = 0;
1297       stats->skipped_new_keys++;
1298     }
1299   else if (rc )  /* Insert this key. */
1300     {
1301       KEYDB_HANDLE hd;
1302
1303       hd = keydb_new ();
1304       if (!hd)
1305         return gpg_error_from_syserror ();
1306
1307       rc = keydb_locate_writable (hd);
1308       if (rc)
1309         {
1310           log_error (_("no writable keyring found: %s\n"), gpg_strerror (rc));
1311           keydb_release (hd);
1312           return GPG_ERR_GENERAL;
1313         }
1314       if (opt.verbose > 1 )
1315         log_info (_("writing to '%s'\n"), keydb_get_resource_name (hd) );
1316
1317       rc = keydb_insert_keyblock (hd, keyblock );
1318       if (rc)
1319         log_error (_("error writing keyring '%s': %s\n"),
1320                    keydb_get_resource_name (hd), gpg_strerror (rc));
1321       else if (!(opt.import_options & IMPORT_KEEP_OWNERTTRUST))
1322         {
1323           /* This should not be possible since we delete the
1324              ownertrust when a key is deleted, but it can happen if
1325              the keyring and trustdb are out of sync.  It can also
1326              be made to happen with the trusted-key command and by
1327              importing and locally exported key. */
1328
1329           clear_ownertrusts (pk);
1330           if (non_self)
1331             revalidation_mark ();
1332         }
1333       keydb_release (hd);
1334
1335       /* We are ready.  */
1336       if (!opt.quiet && !silent)
1337         {
1338           char *p = get_user_id_byfpr_native (fpr2);
1339           log_info (_("key %s: public key \"%s\" imported\n"),
1340                     keystr(keyid), p);
1341           xfree(p);
1342         }
1343       if (is_status_enabled())
1344         {
1345           char *us = get_long_user_id_string( keyid );
1346           write_status_text( STATUS_IMPORTED, us );
1347           xfree(us);
1348           print_import_ok (pk, 1);
1349         }
1350       stats->imported++;
1351       new_key = 1;
1352     }
1353   else /* merge */
1354     {
1355       KEYDB_HANDLE hd;
1356       int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
1357
1358       /* Compare the original against the new key; just to be sure nothing
1359        * weird is going on */
1360       if (cmp_public_keys( pk_orig, pk ) )
1361         {
1362           if (!silent)
1363             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
1364           goto leave;
1365         }
1366
1367       /* Now read the original keyblock again so that we can use
1368          that handle for updating the keyblock.  */
1369       hd = keydb_new ();
1370       if (!hd)
1371         {
1372           rc = gpg_error_from_syserror ();
1373           goto leave;
1374         }
1375       keydb_disable_caching (hd);
1376       rc = keydb_search_fpr (hd, fpr2);
1377       if (rc )
1378         {
1379           log_error (_("key %s: can't locate original keyblock: %s\n"),
1380                      keystr(keyid), gpg_strerror (rc));
1381           keydb_release (hd);
1382           goto leave;
1383         }
1384       rc = keydb_get_keyblock (hd, &keyblock_orig);
1385       if (rc)
1386         {
1387           log_error (_("key %s: can't read original keyblock: %s\n"),
1388                      keystr(keyid), gpg_strerror (rc));
1389           keydb_release (hd);
1390           goto leave;
1391         }
1392
1393       /* Make sure the original direct key sigs are all sane.  */
1394       n_sigs_cleaned = fix_bad_direct_key_sigs (keyblock_orig, keyid);
1395       if (n_sigs_cleaned)
1396         commit_kbnode (&keyblock_orig);
1397
1398       /* and try to merge the block */
1399       clear_kbnode_flags( keyblock_orig );
1400       clear_kbnode_flags( keyblock );
1401       n_uids = n_sigs = n_subk = n_uids_cleaned = 0;
1402       rc = merge_blocks( fname, keyblock_orig, keyblock,
1403                          keyid, &n_uids, &n_sigs, &n_subk );
1404       if (rc )
1405         {
1406           keydb_release (hd);
1407           goto leave;
1408         }
1409
1410       if ((options & IMPORT_CLEAN))
1411         clean_key (keyblock_orig,opt.verbose,options&IMPORT_MINIMAL,
1412                    &n_uids_cleaned,&n_sigs_cleaned);
1413
1414       if (n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned)
1415         {
1416           mod_key = 1;
1417           /* KEYBLOCK_ORIG has been updated; write */
1418           rc = keydb_update_keyblock (hd, keyblock_orig);
1419           if (rc)
1420             log_error (_("error writing keyring '%s': %s\n"),
1421                        keydb_get_resource_name (hd), gpg_strerror (rc) );
1422           else if (non_self)
1423             revalidation_mark ();
1424
1425           /* We are ready.  */
1426           if (!opt.quiet && !silent)
1427             {
1428               char *p = get_user_id_byfpr_native (fpr2);
1429               if (n_uids == 1 )
1430                 log_info( _("key %s: \"%s\" 1 new user ID\n"),
1431                           keystr(keyid),p);
1432               else if (n_uids )
1433                 log_info( _("key %s: \"%s\" %d new user IDs\n"),
1434                           keystr(keyid),p,n_uids);
1435               if (n_sigs == 1 )
1436                 log_info( _("key %s: \"%s\" 1 new signature\n"),
1437                           keystr(keyid), p);
1438               else if (n_sigs )
1439                 log_info( _("key %s: \"%s\" %d new signatures\n"),
1440                           keystr(keyid), p, n_sigs );
1441               if (n_subk == 1 )
1442                 log_info( _("key %s: \"%s\" 1 new subkey\n"),
1443                           keystr(keyid), p);
1444               else if (n_subk )
1445                 log_info( _("key %s: \"%s\" %d new subkeys\n"),
1446                           keystr(keyid), p, n_subk );
1447               if (n_sigs_cleaned==1)
1448                 log_info(_("key %s: \"%s\" %d signature cleaned\n"),
1449                          keystr(keyid),p,n_sigs_cleaned);
1450               else if (n_sigs_cleaned)
1451                 log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
1452                          keystr(keyid),p,n_sigs_cleaned);
1453               if (n_uids_cleaned==1)
1454                 log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
1455                          keystr(keyid),p,n_uids_cleaned);
1456               else if (n_uids_cleaned)
1457                 log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
1458                          keystr(keyid),p,n_uids_cleaned);
1459               xfree(p);
1460             }
1461
1462           stats->n_uids +=n_uids;
1463           stats->n_sigs +=n_sigs;
1464           stats->n_subk +=n_subk;
1465           stats->n_sigs_cleaned +=n_sigs_cleaned;
1466           stats->n_uids_cleaned +=n_uids_cleaned;
1467
1468           if (is_status_enabled () && !silent)
1469             print_import_ok (pk, ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
1470         }
1471       else
1472         {
1473           same_key = 1;
1474           if (is_status_enabled ())
1475             print_import_ok (pk, 0);
1476
1477           if (!opt.quiet && !silent)
1478             {
1479               char *p = get_user_id_byfpr_native (fpr2);
1480               log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
1481               xfree(p);
1482             }
1483
1484           stats->unchanged++;
1485         }
1486
1487       keydb_release (hd); hd = NULL;
1488     }
1489
1490  leave:
1491   if (mod_key || new_key || same_key)
1492     {
1493       /* A little explanation for this: we fill in the fingerprint
1494          when importing keys as it can be useful to know the
1495          fingerprint in certain keyserver-related cases (a keyserver
1496          asked for a particular name, but the key doesn't have that
1497          name).  However, in cases where we're importing more than
1498          one key at a time, we cannot know which key to fingerprint.
1499          In these cases, rather than guessing, we do not
1500          fingerprinting at all, and we must hope the user ID on the
1501          keys are useful.  Note that we need to do this for new
1502          keys, merged keys and even for unchanged keys.  This is
1503          required because for example the --auto-key-locate feature
1504          may import an already imported key and needs to know the
1505          fingerprint of the key in all cases.  */
1506       if (fpr)
1507         {
1508           xfree (*fpr);
1509           /* Note that we need to compare against 0 here because
1510              COUNT gets only incremented after returning from this
1511              function.  */
1512           if (!stats->count)
1513             *fpr = fingerprint_from_pk (pk, NULL, fpr_len);
1514           else
1515             *fpr = NULL;
1516         }
1517     }
1518
1519   /* Now that the key is definitely incorporated into the keydb, we
1520      need to check if a designated revocation is present or if the
1521      prefs are not rational so we can warn the user. */
1522
1523   if (mod_key)
1524     {
1525       revocation_present (ctrl, keyblock_orig);
1526       if (!from_sk && have_secret_key_with_kid (keyid))
1527         check_prefs (ctrl, keyblock_orig);
1528     }
1529   else if (new_key)
1530     {
1531       revocation_present (ctrl, keyblock);
1532       if (!from_sk && have_secret_key_with_kid (keyid))
1533         check_prefs (ctrl, keyblock);
1534     }
1535
1536   release_kbnode( keyblock_orig );
1537   free_public_key( pk_orig );
1538
1539   return rc;
1540 }
1541
1542
1543 /* Transfer all the secret keys in SEC_KEYBLOCK to the gpg-agent.  The
1544    function prints diagnostics and returns an error code.  If BATCH is
1545    true the secret keys are stored by gpg-agent in the transfer format
1546    (i.e. no re-protection and aksing for passphrases). */
1547 gpg_error_t
1548 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats,
1549                       kbnode_t sec_keyblock, int batch, int force)
1550 {
1551   gpg_error_t err = 0;
1552   void *kek = NULL;
1553   size_t keklen;
1554   kbnode_t ctx = NULL;
1555   kbnode_t node;
1556   PKT_public_key *main_pk, *pk;
1557   struct seckey_info *ski;
1558   int nskey;
1559   membuf_t mbuf;
1560   int i, j;
1561   void *format_args[2*PUBKEY_MAX_NSKEY];
1562   gcry_sexp_t skey, prot, tmpsexp;
1563   gcry_sexp_t curve = NULL;
1564   unsigned char *transferkey = NULL;
1565   size_t transferkeylen;
1566   gcry_cipher_hd_t cipherhd = NULL;
1567   unsigned char *wrappedkey = NULL;
1568   size_t wrappedkeylen;
1569   char *cache_nonce = NULL;
1570   int stub_key_skipped = 0;
1571
1572   /* Get the current KEK.  */
1573   err = agent_keywrap_key (ctrl, 0, &kek, &keklen);
1574   if (err)
1575     {
1576       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
1577       goto leave;
1578     }
1579
1580   /* Prepare a cipher context.  */
1581   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
1582                           GCRY_CIPHER_MODE_AESWRAP, 0);
1583   if (!err)
1584     err = gcry_cipher_setkey (cipherhd, kek, keklen);
1585   if (err)
1586     goto leave;
1587   xfree (kek);
1588   kek = NULL;
1589
1590   main_pk = NULL;
1591   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
1592     {
1593       if (node->pkt->pkttype != PKT_SECRET_KEY
1594           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
1595         continue;
1596       pk = node->pkt->pkt.public_key;
1597       if (!main_pk)
1598         main_pk = pk;
1599
1600       /* Make sure the keyids are available.  */
1601       keyid_from_pk (pk, NULL);
1602       if (node->pkt->pkttype == PKT_SECRET_KEY)
1603         {
1604           pk->main_keyid[0] = pk->keyid[0];
1605           pk->main_keyid[1] = pk->keyid[1];
1606         }
1607       else
1608         {
1609           pk->main_keyid[0] = main_pk->keyid[0];
1610           pk->main_keyid[1] = main_pk->keyid[1];
1611         }
1612
1613
1614       ski = pk->seckey_info;
1615       if (!ski)
1616         BUG ();
1617
1618       if (stats)
1619         {
1620           stats->count++;
1621           stats->secret_read++;
1622         }
1623
1624       /* We ignore stub keys.  The way we handle them in other parts
1625          of the code is by asking the agent whether any secret key is
1626          available for a given keyblock and then concluding that we
1627          have a secret key; all secret (sub)keys of the keyblock the
1628          agent does not know of are then stub keys.  This works also
1629          for card stub keys.  The learn command or the card-status
1630          command may be used to check with the agent whether a card
1631          has been inserted and a stub key is in turn generated by the
1632          agent.  */
1633       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
1634         {
1635           stub_key_skipped = 1;
1636           continue;
1637         }
1638
1639       /* Convert our internal secret key object into an S-expression.  */
1640       nskey = pubkey_get_nskey (pk->pubkey_algo);
1641       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
1642         {
1643           err = gpg_error (GPG_ERR_BAD_SECKEY);
1644           log_error ("internal error: %s\n", gpg_strerror (err));
1645           goto leave;
1646         }
1647
1648       init_membuf (&mbuf, 50);
1649       put_membuf_str (&mbuf, "(skey");
1650       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1651           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1652           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1653         {
1654           /* The ECC case.  */
1655           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
1656           if (!curvestr)
1657             err = gpg_error_from_syserror ();
1658           else
1659             {
1660               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
1661               gcry_sexp_release (curve);
1662               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
1663                                      curvename?curvename:curvestr);
1664               xfree (curvestr);
1665               if (!err)
1666                 {
1667                   j = 0;
1668                   /* Append the public key element Q.  */
1669                   put_membuf_str (&mbuf, " _ %m");
1670                   format_args[j++] = pk->pkey + 1;
1671
1672                   /* Append the secret key element D.  For ECDH we
1673                      skip PKEY[2] because this holds the KEK which is
1674                      not needed by gpg-agent.  */
1675                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
1676                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1677                     put_membuf_str (&mbuf, " e %m");
1678                   else
1679                     put_membuf_str (&mbuf, " _ %m");
1680                   format_args[j++] = pk->pkey + i;
1681                 }
1682             }
1683         }
1684       else
1685         {
1686           /* Standard case for the old (non-ECC) algorithms.  */
1687           for (i=j=0; i < nskey; i++)
1688             {
1689               if (!pk->pkey[i])
1690                 continue; /* Protected keys only have NPKEY+1 elements.  */
1691
1692               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1693                 put_membuf_str (&mbuf, " e %m");
1694               else
1695                 put_membuf_str (&mbuf, " _ %m");
1696               format_args[j++] = pk->pkey + i;
1697             }
1698         }
1699       put_membuf_str (&mbuf, ")");
1700       put_membuf (&mbuf, "", 1);
1701       if (err)
1702         xfree (get_membuf (&mbuf, NULL));
1703       else
1704         {
1705           char *format = get_membuf (&mbuf, NULL);
1706           if (!format)
1707             err = gpg_error_from_syserror ();
1708           else
1709             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
1710           xfree (format);
1711         }
1712       if (err)
1713         {
1714           log_error ("error building skey array: %s\n", gpg_strerror (err));
1715           goto leave;
1716         }
1717
1718       if (ski->is_protected)
1719         {
1720           char countbuf[35];
1721
1722           /* Note that the IVLEN may be zero if we are working on a
1723              dummy key.  We can't express that in an S-expression and
1724              thus we send dummy data for the IV.  */
1725           snprintf (countbuf, sizeof countbuf, "%lu",
1726                     (unsigned long)ski->s2k.count);
1727           err = gcry_sexp_build
1728             (&prot, NULL,
1729              " (protection %s %s %b %d %s %b %s)\n",
1730              ski->sha1chk? "sha1":"sum",
1731              openpgp_cipher_algo_name (ski->algo),
1732              ski->ivlen? (int)ski->ivlen:1,
1733              ski->ivlen? ski->iv: (const unsigned char*)"X",
1734              ski->s2k.mode,
1735              openpgp_md_algo_name (ski->s2k.hash_algo),
1736              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
1737              countbuf);
1738         }
1739       else
1740         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
1741
1742       tmpsexp = NULL;
1743       xfree (transferkey);
1744       transferkey = NULL;
1745       if (!err)
1746         err = gcry_sexp_build (&tmpsexp, NULL,
1747                                "(openpgp-private-key\n"
1748                                " (version %d)\n"
1749                                " (algo %s)\n"
1750                                " %S%S\n"
1751                                " (csum %d)\n"
1752                                " %S)\n",
1753                                pk->version,
1754                                openpgp_pk_algo_name (pk->pubkey_algo),
1755                                curve, skey,
1756                                (int)(unsigned long)ski->csum, prot);
1757       gcry_sexp_release (skey);
1758       gcry_sexp_release (prot);
1759       if (!err)
1760         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
1761       gcry_sexp_release (tmpsexp);
1762       if (err)
1763         {
1764           log_error ("error building transfer key: %s\n", gpg_strerror (err));
1765           goto leave;
1766         }
1767
1768       /* Wrap the key.  */
1769       wrappedkeylen = transferkeylen + 8;
1770       xfree (wrappedkey);
1771       wrappedkey = xtrymalloc (wrappedkeylen);
1772       if (!wrappedkey)
1773         err = gpg_error_from_syserror ();
1774       else
1775         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
1776                                    transferkey, transferkeylen);
1777       if (err)
1778         goto leave;
1779       xfree (transferkey);
1780       transferkey = NULL;
1781
1782       /* Send the wrapped key to the agent.  */
1783       {
1784         char *desc = gpg_format_keydesc (pk, FORMAT_KEYDESC_IMPORT, 1);
1785         err = agent_import_key (ctrl, desc, &cache_nonce,
1786                                 wrappedkey, wrappedkeylen, batch, force);
1787         xfree (desc);
1788       }
1789       if (!err)
1790         {
1791           if (opt.verbose)
1792             log_info (_("key %s: secret key imported\n"),
1793                       keystr_from_pk_with_sub (main_pk, pk));
1794           if (stats)
1795             stats->secret_imported++;
1796         }
1797       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
1798         {
1799           if (opt.verbose)
1800             log_info (_("key %s: secret key already exists\n"),
1801                       keystr_from_pk_with_sub (main_pk, pk));
1802           err = 0;
1803           if (stats)
1804             stats->secret_dups++;
1805         }
1806       else
1807         {
1808           log_error (_("key %s: error sending to agent: %s\n"),
1809                      keystr_from_pk_with_sub (main_pk, pk),
1810                      gpg_strerror (err));
1811           if (gpg_err_code (err) == GPG_ERR_CANCELED
1812               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1813             break; /* Don't try the other subkeys.  */
1814         }
1815     }
1816
1817   if (!err && stub_key_skipped)
1818     /* We need to notify user how to migrate stub keys.  */
1819     err = gpg_error (GPG_ERR_NOT_PROCESSED);
1820
1821  leave:
1822   gcry_sexp_release (curve);
1823   xfree (cache_nonce);
1824   xfree (wrappedkey);
1825   xfree (transferkey);
1826   gcry_cipher_close (cipherhd);
1827   xfree (kek);
1828   return err;
1829 }
1830
1831
1832 /* Walk a secret keyblock and produce a public keyblock out of it.
1833    Returns a new node or NULL on error. */
1834 static kbnode_t
1835 sec_to_pub_keyblock (kbnode_t sec_keyblock)
1836 {
1837   kbnode_t pub_keyblock = NULL;
1838   kbnode_t ctx = NULL;
1839   kbnode_t secnode, pubnode;
1840
1841   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
1842     {
1843       if (secnode->pkt->pkttype == PKT_SECRET_KEY
1844           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
1845         {
1846           /* Make a public key.  */
1847           PACKET *pkt;
1848           PKT_public_key *pk;
1849
1850           pkt = xtrycalloc (1, sizeof *pkt);
1851           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
1852           if (!pk)
1853             {
1854               xfree (pkt);
1855               release_kbnode (pub_keyblock);
1856               return NULL;
1857             }
1858           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
1859             pkt->pkttype = PKT_PUBLIC_KEY;
1860           else
1861             pkt->pkttype = PKT_PUBLIC_SUBKEY;
1862           pkt->pkt.public_key = pk;
1863
1864           pubnode = new_kbnode (pkt);
1865         }
1866       else
1867         {
1868           pubnode = clone_kbnode (secnode);
1869         }
1870
1871       if (!pub_keyblock)
1872         pub_keyblock = pubnode;
1873       else
1874         add_kbnode (pub_keyblock, pubnode);
1875     }
1876
1877   return pub_keyblock;
1878 }
1879
1880 /****************
1881  * Ditto for secret keys.  Handling is simpler than for public keys.
1882  * We allow secret key importing only when allow is true, this is so
1883  * that a secret key can not be imported accidentally and thereby tampering
1884  * with the trust calculation.
1885  */
1886 static int
1887 import_secret_one (ctrl_t ctrl, const char *fname, kbnode_t keyblock,
1888                    struct import_stats_s *stats, int batch, unsigned int options,
1889                    int for_migration,
1890                    import_screener_t screener, void *screener_arg)
1891 {
1892   PKT_public_key *pk;
1893   struct seckey_info *ski;
1894   kbnode_t node, uidnode;
1895   u32 keyid[2];
1896   int rc = 0;
1897   int nr_prev;
1898   kbnode_t pub_keyblock;
1899   char pkstrbuf[PUBKEY_STRING_SIZE];
1900
1901   /* Get the key and print some info about it */
1902   node = find_kbnode (keyblock, PKT_SECRET_KEY);
1903   if (!node)
1904     BUG ();
1905
1906   pk = node->pkt->pkt.public_key;
1907
1908   keyid_from_pk (pk, keyid);
1909   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
1910
1911   if (screener && screener (keyblock, screener_arg))
1912     {
1913       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
1914                  _("rejected by import screener"));
1915       return 0;
1916   }
1917
1918   if (opt.verbose && !for_migration)
1919     {
1920       log_info ("sec  %s/%s %s   ",
1921                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
1922                 keystr_from_pk (pk), datestr_from_pk (pk));
1923       if (uidnode)
1924         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
1925                            uidnode->pkt->pkt.user_id->len);
1926       log_printf ("\n");
1927     }
1928   stats->secret_read++;
1929
1930   if ((options & IMPORT_NO_SECKEY))
1931     {
1932       if (!for_migration)
1933         log_error (_("importing secret keys not allowed\n"));
1934       return 0;
1935     }
1936
1937   if (!uidnode)
1938     {
1939       if (!for_migration)
1940         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
1941       return 0;
1942     }
1943
1944   ski = pk->seckey_info;
1945   if (!ski)
1946     {
1947       /* Actually an internal error.  */
1948       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
1949       return 0;
1950     }
1951
1952   /* A quick check to not import keys with an invalid protection
1953      cipher algorithm (only checks the primary key, though).  */
1954   if (ski->algo > 110)
1955     {
1956       if (!for_migration)
1957         log_error (_("key %s: secret key with invalid cipher %d"
1958                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
1959       return 0;
1960     }
1961
1962 #ifdef ENABLE_SELINUX_HACKS
1963   if (1)
1964     {
1965       /* We don't allow to import secret keys because that may be used
1966          to put a secret key into the keyring and the user might later
1967          be tricked into signing stuff with that key.  */
1968       log_error (_("importing secret keys not allowed\n"));
1969       return 0;
1970     }
1971 #endif
1972
1973   clear_kbnode_flags (keyblock);
1974
1975   nr_prev = stats->skipped_new_keys;
1976
1977   /* Make a public key out of the key. */
1978   pub_keyblock = sec_to_pub_keyblock (keyblock);
1979   if (!pub_keyblock)
1980     log_error ("key %s: failed to create public key from secret key\n",
1981                    keystr_from_pk (pk));
1982   else
1983     {
1984       /* Note that this outputs an IMPORT_OK status message for the
1985          public key block, and below we will output another one for
1986          the secret keys.  FIXME?  */
1987       import_one (ctrl, fname, pub_keyblock, stats,
1988                   NULL, NULL, options, 1, for_migration,
1989                   screener, screener_arg);
1990
1991       /* Fixme: We should check for an invalid keyblock and
1992          cancel the secret key import in this case.  */
1993       release_kbnode (pub_keyblock);
1994
1995       /* At least we cancel the secret key import when the public key
1996          import was skipped due to MERGE_ONLY option and a new
1997          key.  */
1998       if (stats->skipped_new_keys <= nr_prev)
1999         {
2000           /* Read the keyblock again to get the effects of a merge.  */
2001           /* Fixme: we should do this based on the fingerprint or
2002              even better let import_one return the merged
2003              keyblock.  */
2004           node = get_pubkeyblock (keyid);
2005           if (!node)
2006             log_error ("key %s: failed to re-lookup public key\n",
2007                        keystr_from_pk (pk));
2008           else
2009             {
2010               gpg_error_t err;
2011
2012               nr_prev = stats->secret_imported;
2013               err = transfer_secret_keys (ctrl, stats, keyblock, batch, 0);
2014               if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
2015                 {
2016                   /* TRANSLATORS: For smartcard, each private key on
2017                      host has a reference (stub) to a smartcard and
2018                      actual private key data is stored on the card.  A
2019                      single smartcard can have up to three private key
2020                      data.  Importing private key stub is always
2021                      skipped in 2.1, and it returns
2022                      GPG_ERR_NOT_PROCESSED.  Instead, user should be
2023                      suggested to run 'gpg --card-status', then,
2024                      references to a card will be automatically
2025                      created again.  */
2026                   log_info (_("To migrate '%s', with each smartcard, "
2027                               "run: %s\n"), "secring.gpg", "gpg --card-status");
2028                   err = 0;
2029                 }
2030               if (!err)
2031                 {
2032                   int status = 16;
2033                   if (!opt.quiet)
2034                     log_info (_("key %s: secret key imported\n"),
2035                               keystr_from_pk (pk));
2036                   if (stats->secret_imported > nr_prev)
2037                     status |= 1;
2038                   if (is_status_enabled ())
2039                     print_import_ok (pk, status);
2040                   check_prefs (ctrl, node);
2041                 }
2042               release_kbnode (node);
2043             }
2044         }
2045     }
2046
2047   return rc;
2048 }
2049
2050
2051 /****************
2052  * Import a revocation certificate; this is a single signature packet.
2053  */
2054 static int
2055 import_revoke_cert (const char *fname, kbnode_t node,
2056                     struct import_stats_s *stats)
2057 {
2058   PKT_public_key *pk = NULL;
2059   kbnode_t onode;
2060   kbnode_t keyblock = NULL;
2061   KEYDB_HANDLE hd = NULL;
2062   u32 keyid[2];
2063   int rc = 0;
2064
2065   (void)fname;
2066
2067   log_assert (!node->next );
2068   log_assert (node->pkt->pkttype == PKT_SIGNATURE );
2069   log_assert (node->pkt->pkt.signature->sig_class == 0x20 );
2070
2071   keyid[0] = node->pkt->pkt.signature->keyid[0];
2072   keyid[1] = node->pkt->pkt.signature->keyid[1];
2073
2074   pk = xmalloc_clear( sizeof *pk );
2075   rc = get_pubkey( pk, keyid );
2076   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
2077     {
2078       log_error(_("key %s: no public key -"
2079                   " can't apply revocation certificate\n"), keystr(keyid));
2080       rc = 0;
2081       goto leave;
2082     }
2083   else if (rc )
2084     {
2085       log_error(_("key %s: public key not found: %s\n"),
2086                 keystr(keyid), gpg_strerror (rc));
2087       goto leave;
2088     }
2089
2090   /* Read the original keyblock. */
2091   hd = keydb_new ();
2092   if (!hd)
2093     {
2094       rc = gpg_error_from_syserror ();
2095       goto leave;
2096     }
2097
2098   {
2099     byte afp[MAX_FINGERPRINT_LEN];
2100     size_t an;
2101
2102     fingerprint_from_pk (pk, afp, &an);
2103     while (an < MAX_FINGERPRINT_LEN)
2104       afp[an++] = 0;
2105     rc = keydb_search_fpr (hd, afp);
2106   }
2107   if (rc)
2108     {
2109       log_error (_("key %s: can't locate original keyblock: %s\n"),
2110                  keystr(keyid), gpg_strerror (rc));
2111       goto leave;
2112     }
2113   rc = keydb_get_keyblock (hd, &keyblock );
2114   if (rc)
2115     {
2116       log_error (_("key %s: can't read original keyblock: %s\n"),
2117                  keystr(keyid), gpg_strerror (rc));
2118       goto leave;
2119     }
2120
2121   /* it is okay, that node is not in keyblock because
2122    * check_key_signature works fine for sig_class 0x20 in this
2123    * special case. */
2124   rc = check_key_signature( keyblock, node, NULL);
2125   if (rc )
2126     {
2127       log_error( _("key %s: invalid revocation certificate"
2128                    ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
2129       goto leave;
2130     }
2131
2132   /* check whether we already have this */
2133   for(onode=keyblock->next; onode; onode=onode->next ) {
2134     if (onode->pkt->pkttype == PKT_USER_ID )
2135       break;
2136     else if (onode->pkt->pkttype == PKT_SIGNATURE
2137              && !cmp_signatures(node->pkt->pkt.signature,
2138                                 onode->pkt->pkt.signature))
2139       {
2140         rc = 0;
2141         goto leave; /* yes, we already know about it */
2142       }
2143   }
2144
2145   /* insert it */
2146   insert_kbnode( keyblock, clone_kbnode(node), 0 );
2147
2148   /* and write the keyblock back */
2149   rc = keydb_update_keyblock (hd, keyblock );
2150   if (rc)
2151     log_error (_("error writing keyring '%s': %s\n"),
2152                keydb_get_resource_name (hd), gpg_strerror (rc) );
2153   keydb_release (hd);
2154   hd = NULL;
2155
2156   /* we are ready */
2157   if (!opt.quiet )
2158     {
2159       char *p=get_user_id_native (keyid);
2160       log_info( _("key %s: \"%s\" revocation certificate imported\n"),
2161                 keystr(keyid),p);
2162       xfree(p);
2163     }
2164   stats->n_revoc++;
2165
2166   /* If the key we just revoked was ultimately trusted, remove its
2167      ultimate trust.  This doesn't stop the user from putting the
2168      ultimate trust back, but is a reasonable solution for now. */
2169   if(get_ownertrust(pk)==TRUST_ULTIMATE)
2170     clear_ownertrusts(pk);
2171
2172   revalidation_mark ();
2173
2174  leave:
2175   keydb_release (hd);
2176   release_kbnode( keyblock );
2177   free_public_key( pk );
2178   return rc;
2179 }
2180
2181
2182 /*
2183  * Loop over the keyblock and check all self signatures.
2184  * Mark all user-ids with a self-signature by setting flag bit 0.
2185  * Mark all user-ids with an invalid self-signature by setting bit 1.
2186  * This works also for subkeys, here the subkey is marked.  Invalid or
2187  * extra subkey sigs (binding or revocation) are marked for deletion.
2188  * non_self is set to true if there are any sigs other than self-sigs
2189  * in this keyblock.
2190  */
2191 static int
2192 chk_self_sigs (const char *fname, kbnode_t keyblock,
2193                PKT_public_key *pk, u32 *keyid, int *non_self )
2194 {
2195   kbnode_t n, knode = NULL;
2196   PKT_signature *sig;
2197   int rc;
2198   u32 bsdate=0, rsdate=0;
2199   kbnode_t bsnode = NULL, rsnode = NULL;
2200
2201   (void)fname;
2202   (void)pk;
2203
2204   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
2205     {
2206       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2207         {
2208           knode = n;
2209           bsdate = 0;
2210           rsdate = 0;
2211           bsnode = NULL;
2212           rsnode = NULL;
2213           continue;
2214         }
2215
2216       if ( n->pkt->pkttype != PKT_SIGNATURE )
2217         continue;
2218
2219       sig = n->pkt->pkt.signature;
2220       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
2221         {
2222           *non_self = 1;
2223           continue;
2224         }
2225
2226       /* This just caches the sigs for later use.  That way we
2227          import a fully-cached key which speeds things up. */
2228       if (!opt.no_sig_cache)
2229         check_key_signature (keyblock, n, NULL);
2230
2231       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
2232         {
2233           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
2234           if ( !unode )
2235             {
2236               log_error( _("key %s: no user ID for signature\n"),
2237                          keystr(keyid));
2238               return -1;  /* The complete keyblock is invalid.  */
2239             }
2240
2241           /* If it hasn't been marked valid yet, keep trying.  */
2242           if (!(unode->flag&1))
2243             {
2244               rc = check_key_signature (keyblock, n, NULL);
2245               if ( rc )
2246                 {
2247                   if ( opt.verbose )
2248                     {
2249                       char *p = utf8_to_native
2250                         (unode->pkt->pkt.user_id->name,
2251                          strlen (unode->pkt->pkt.user_id->name),0);
2252                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
2253                                 _("key %s: unsupported public key "
2254                                   "algorithm on user ID \"%s\"\n"):
2255                                 _("key %s: invalid self-signature "
2256                                   "on user ID \"%s\"\n"),
2257                                 keystr (keyid),p);
2258                       xfree (p);
2259                     }
2260                 }
2261               else
2262                 unode->flag |= 1; /* Mark that signature checked. */
2263             }
2264         }
2265       else if (IS_KEY_SIG (sig))
2266         {
2267           rc = check_key_signature (keyblock, n, NULL);
2268           if ( rc )
2269             {
2270               if (opt.verbose)
2271                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2272                           _("key %s: unsupported public key algorithm\n"):
2273                           _("key %s: invalid direct key signature\n"),
2274                           keystr (keyid));
2275               n->flag |= 4;
2276             }
2277         }
2278       else if ( IS_SUBKEY_SIG (sig) )
2279         {
2280           /* Note that this works based solely on the timestamps like
2281              the rest of gpg.  If the standard gets revocation
2282              targets, this may need to be revised.  */
2283
2284           if ( !knode )
2285             {
2286               if (opt.verbose)
2287                 log_info (_("key %s: no subkey for key binding\n"),
2288                           keystr (keyid));
2289               n->flag |= 4; /* delete this */
2290             }
2291           else
2292             {
2293               rc = check_key_signature (keyblock, n, NULL);
2294               if ( rc )
2295                 {
2296                   if (opt.verbose)
2297                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2298                               _("key %s: unsupported public key"
2299                                 " algorithm\n"):
2300                               _("key %s: invalid subkey binding\n"),
2301                               keystr (keyid));
2302                   n->flag |= 4;
2303                 }
2304               else
2305                 {
2306                   /* It's valid, so is it newer? */
2307                   if (sig->timestamp >= bsdate)
2308                     {
2309                       knode->flag |= 1;  /* The subkey is valid.  */
2310                       if (bsnode)
2311                         {
2312                           /* Delete the last binding sig since this
2313                              one is newer */
2314                           bsnode->flag |= 4;
2315                           if (opt.verbose)
2316                             log_info (_("key %s: removed multiple subkey"
2317                                         " binding\n"),keystr(keyid));
2318                         }
2319
2320                       bsnode = n;
2321                       bsdate = sig->timestamp;
2322                     }
2323                   else
2324                     n->flag |= 4; /* older */
2325                 }
2326             }
2327         }
2328       else if ( IS_SUBKEY_REV (sig) )
2329         {
2330           /* We don't actually mark the subkey as revoked right now,
2331              so just check that the revocation sig is the most recent
2332              valid one.  Note that we don't care if the binding sig is
2333              newer than the revocation sig.  See the comment in
2334              getkey.c:merge_selfsigs_subkey for more.  */
2335           if ( !knode )
2336             {
2337               if (opt.verbose)
2338                 log_info (_("key %s: no subkey for key revocation\n"),
2339                           keystr(keyid));
2340               n->flag |= 4; /* delete this */
2341             }
2342           else
2343             {
2344               rc = check_key_signature (keyblock, n, NULL);
2345               if ( rc )
2346                 {
2347                   if(opt.verbose)
2348                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2349                               _("key %s: unsupported public"
2350                                 " key algorithm\n"):
2351                               _("key %s: invalid subkey revocation\n"),
2352                               keystr(keyid));
2353                   n->flag |= 4;
2354                 }
2355               else
2356                 {
2357                   /* It's valid, so is it newer? */
2358                   if (sig->timestamp >= rsdate)
2359                     {
2360                       if (rsnode)
2361                         {
2362                           /* Delete the last revocation sig since
2363                              this one is newer.  */
2364                           rsnode->flag |= 4;
2365                           if (opt.verbose)
2366                             log_info (_("key %s: removed multiple subkey"
2367                                         " revocation\n"),keystr(keyid));
2368                         }
2369
2370                       rsnode = n;
2371                       rsdate = sig->timestamp;
2372                     }
2373                   else
2374                     n->flag |= 4; /* older */
2375                 }
2376             }
2377         }
2378     }
2379
2380   return 0;
2381 }
2382
2383
2384 /****************
2385  * delete all parts which are invalid and those signatures whose
2386  * public key algorithm is not available in this implemenation;
2387  * but consider RSA as valid, because parse/build_packets knows
2388  * about it.
2389  * returns: true if at least one valid user-id is left over.
2390  */
2391 static int
2392 delete_inv_parts( const char *fname, kbnode_t keyblock,
2393                   u32 *keyid, unsigned int options)
2394 {
2395   kbnode_t node;
2396   int nvalid=0, uid_seen=0, subkey_seen=0;
2397
2398   (void)fname;
2399
2400   for (node=keyblock->next; node; node = node->next )
2401     {
2402       if (node->pkt->pkttype == PKT_USER_ID)
2403         {
2404           uid_seen = 1;
2405           if ((node->flag & 2) || !(node->flag & 1) )
2406             {
2407               if (opt.verbose )
2408                 {
2409                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
2410                                          node->pkt->pkt.user_id->len,0);
2411                   log_info( _("key %s: skipped user ID \"%s\"\n"),
2412                             keystr(keyid),p);
2413                   xfree(p);
2414                 }
2415               delete_kbnode( node ); /* the user-id */
2416               /* and all following packets up to the next user-id */
2417               while (node->next
2418                      && node->next->pkt->pkttype != PKT_USER_ID
2419                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
2420                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
2421                 delete_kbnode( node->next );
2422                 node = node->next;
2423               }
2424             }
2425           else
2426             nvalid++;
2427         }
2428       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2429                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
2430         {
2431           if ((node->flag & 2) || !(node->flag & 1) )
2432             {
2433               if (opt.verbose )
2434                 log_info( _("key %s: skipped subkey\n"),keystr(keyid));
2435
2436               delete_kbnode( node ); /* the subkey */
2437               /* and all following signature packets */
2438               while (node->next
2439                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
2440                 delete_kbnode( node->next );
2441                 node = node->next;
2442               }
2443             }
2444           else
2445             subkey_seen = 1;
2446         }
2447       else if (node->pkt->pkttype == PKT_SIGNATURE
2448                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
2449                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
2450         {
2451           delete_kbnode( node ); /* build_packet() can't handle this */
2452         }
2453       else if (node->pkt->pkttype == PKT_SIGNATURE
2454                && !node->pkt->pkt.signature->flags.exportable
2455                && !(options&IMPORT_LOCAL_SIGS)
2456                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
2457         {
2458           /* here we violate the rfc a bit by still allowing
2459            * to import non-exportable signature when we have the
2460            * the secret key used to create this signature - it
2461            * seems that this makes sense */
2462           if(opt.verbose)
2463             log_info( _("key %s: non exportable signature"
2464                         " (class 0x%02X) - skipped\n"),
2465                       keystr(keyid), node->pkt->pkt.signature->sig_class );
2466           delete_kbnode( node );
2467         }
2468       else if (node->pkt->pkttype == PKT_SIGNATURE
2469                && node->pkt->pkt.signature->sig_class == 0x20)
2470         {
2471           if (uid_seen )
2472             {
2473               if(opt.verbose)
2474                 log_info( _("key %s: revocation certificate"
2475                             " at wrong place - skipped\n"),keystr(keyid));
2476               delete_kbnode( node );
2477             }
2478           else
2479             {
2480               /* If the revocation cert is from a different key than
2481                  the one we're working on don't check it - it's
2482                  probably from a revocation key and won't be
2483                  verifiable with this key anyway. */
2484
2485               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
2486                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
2487                 {
2488                   int rc = check_key_signature( keyblock, node, NULL);
2489                   if (rc )
2490                     {
2491                       if(opt.verbose)
2492                         log_info( _("key %s: invalid revocation"
2493                                     " certificate: %s - skipped\n"),
2494                                   keystr(keyid), gpg_strerror (rc));
2495                       delete_kbnode( node );
2496                     }
2497                 }
2498             }
2499         }
2500       else if (node->pkt->pkttype == PKT_SIGNATURE
2501                && (node->pkt->pkt.signature->sig_class == 0x18
2502                    || node->pkt->pkt.signature->sig_class == 0x28)
2503                && !subkey_seen )
2504         {
2505           if(opt.verbose)
2506             log_info( _("key %s: subkey signature"
2507                         " in wrong place - skipped\n"), keystr(keyid));
2508           delete_kbnode( node );
2509         }
2510       else if (node->pkt->pkttype == PKT_SIGNATURE
2511                && !IS_CERT(node->pkt->pkt.signature))
2512         {
2513           if(opt.verbose)
2514             log_info(_("key %s: unexpected signature class (0x%02X) -"
2515                        " skipped\n"),keystr(keyid),
2516                      node->pkt->pkt.signature->sig_class);
2517           delete_kbnode(node);
2518           }
2519       else if ((node->flag & 4) ) /* marked for deletion */
2520         delete_kbnode( node );
2521     }
2522
2523   /* note: because keyblock is the public key, it is never marked
2524    * for deletion and so keyblock cannot change */
2525   commit_kbnode( &keyblock );
2526   return nvalid;
2527 }
2528
2529
2530 /****************
2531  * It may happen that the imported keyblock has duplicated user IDs.
2532  * We check this here and collapse those user IDs together with their
2533  * sigs into one.
2534  * Returns: True if the keyblock has changed.
2535  */
2536 int
2537 collapse_uids( kbnode_t *keyblock )
2538 {
2539   kbnode_t uid1;
2540   int any=0;
2541
2542   for(uid1=*keyblock;uid1;uid1=uid1->next)
2543     {
2544       kbnode_t uid2;
2545
2546       if(is_deleted_kbnode(uid1))
2547         continue;
2548
2549       if(uid1->pkt->pkttype!=PKT_USER_ID)
2550         continue;
2551
2552       for(uid2=uid1->next;uid2;uid2=uid2->next)
2553         {
2554           if(is_deleted_kbnode(uid2))
2555             continue;
2556
2557           if(uid2->pkt->pkttype!=PKT_USER_ID)
2558             continue;
2559
2560           if(cmp_user_ids(uid1->pkt->pkt.user_id,
2561                           uid2->pkt->pkt.user_id)==0)
2562             {
2563               /* We have a duplicated uid */
2564               kbnode_t sig1,last;
2565
2566               any=1;
2567
2568               /* Now take uid2's signatures, and attach them to
2569                  uid1 */
2570               for(last=uid2;last->next;last=last->next)
2571                 {
2572                   if(is_deleted_kbnode(last))
2573                     continue;
2574
2575                   if(last->next->pkt->pkttype==PKT_USER_ID
2576                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
2577                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
2578                     break;
2579                 }
2580
2581               /* Snip out uid2 */
2582               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
2583
2584               /* Now put uid2 in place as part of uid1 */
2585               last->next=uid1->next;
2586               uid1->next=uid2;
2587               delete_kbnode(uid2);
2588
2589               /* Now dedupe uid1 */
2590               for(sig1=uid1->next;sig1;sig1=sig1->next)
2591                 {
2592                   kbnode_t sig2;
2593
2594                   if(is_deleted_kbnode(sig1))
2595                     continue;
2596
2597                   if(sig1->pkt->pkttype==PKT_USER_ID
2598                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
2599                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
2600                     break;
2601
2602                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
2603                     continue;
2604
2605                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
2606                     {
2607                       if(is_deleted_kbnode(sig2))
2608                         continue;
2609
2610                       if(sig2->pkt->pkttype==PKT_USER_ID
2611                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
2612                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
2613                         break;
2614
2615                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
2616                         continue;
2617
2618                       if(cmp_signatures(sig1->pkt->pkt.signature,
2619                                         sig2->pkt->pkt.signature)==0)
2620                         {
2621                           /* We have a match, so delete the second
2622                              signature */
2623                           delete_kbnode(sig2);
2624                           sig2=last;
2625                         }
2626                     }
2627                 }
2628             }
2629         }
2630     }
2631
2632   commit_kbnode(keyblock);
2633
2634   if(any && !opt.quiet)
2635     {
2636       const char *key="???";
2637
2638       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
2639         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2640       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
2641         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2642
2643       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
2644     }
2645
2646   return any;
2647 }
2648
2649
2650 /* Check for a 0x20 revocation from a revocation key that is not
2651    present.  This may be called without the benefit of merge_xxxx so
2652    you can't rely on pk->revkey and friends. */
2653 static void
2654 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
2655 {
2656   kbnode_t onode, inode;
2657   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2658
2659   for(onode=keyblock->next;onode;onode=onode->next)
2660     {
2661       /* If we reach user IDs, we're done. */
2662       if(onode->pkt->pkttype==PKT_USER_ID)
2663         break;
2664
2665       if(onode->pkt->pkttype==PKT_SIGNATURE &&
2666          onode->pkt->pkt.signature->sig_class==0x1F &&
2667          onode->pkt->pkt.signature->revkey)
2668         {
2669           int idx;
2670           PKT_signature *sig=onode->pkt->pkt.signature;
2671
2672           for(idx=0;idx<sig->numrevkeys;idx++)
2673             {
2674               u32 keyid[2];
2675
2676               keyid_from_fingerprint(sig->revkey[idx].fpr,
2677                                      MAX_FINGERPRINT_LEN,keyid);
2678
2679               for(inode=keyblock->next;inode;inode=inode->next)
2680                 {
2681                   /* If we reach user IDs, we're done. */
2682                   if(inode->pkt->pkttype==PKT_USER_ID)
2683                     break;
2684
2685                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
2686                      inode->pkt->pkt.signature->sig_class==0x20 &&
2687                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
2688                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
2689                     {
2690                       /* Okay, we have a revocation key, and a
2691                          revocation issued by it.  Do we have the key
2692                          itself? */
2693                       int rc;
2694
2695                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx].fpr,
2696                                                    MAX_FINGERPRINT_LEN);
2697                       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2698                           || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2699                         {
2700                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
2701
2702                           /* No, so try and get it */
2703                           if ((opt.keyserver_options.options
2704                                & KEYSERVER_AUTO_KEY_RETRIEVE)
2705                               && keyserver_any_configured (ctrl))
2706                             {
2707                               log_info(_("WARNING: key %s may be revoked:"
2708                                          " fetching revocation key %s\n"),
2709                                        tempkeystr,keystr(keyid));
2710                               keyserver_import_fprint (ctrl,
2711                                                        sig->revkey[idx].fpr,
2712                                                        MAX_FINGERPRINT_LEN,
2713                                                        opt.keyserver);
2714
2715                               /* Do we have it now? */
2716                               rc=get_pubkey_byfprint_fast (NULL,
2717                                                      sig->revkey[idx].fpr,
2718                                                      MAX_FINGERPRINT_LEN);
2719                             }
2720
2721                           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2722                               || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2723                             log_info(_("WARNING: key %s may be revoked:"
2724                                        " revocation key %s not present.\n"),
2725                                      tempkeystr,keystr(keyid));
2726
2727                           xfree(tempkeystr);
2728                         }
2729                     }
2730                 }
2731             }
2732         }
2733     }
2734 }
2735
2736
2737 /*
2738  * compare and merge the blocks
2739  *
2740  * o compare the signatures: If we already have this signature, check
2741  *   that they compare okay; if not, issue a warning and ask the user.
2742  * o Simply add the signature.  Can't verify here because we may not have
2743  *   the signature's public key yet; verification is done when putting it
2744  *   into the trustdb, which is done automagically as soon as this pubkey
2745  *   is used.
2746  * Note: We indicate newly inserted packets with flag bit 0
2747  */
2748 static int
2749 merge_blocks (const char *fname, kbnode_t keyblock_orig, kbnode_t keyblock,
2750               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
2751 {
2752   kbnode_t onode, node;
2753   int rc, found;
2754
2755   /* 1st: handle revocation certificates */
2756   for (node=keyblock->next; node; node=node->next )
2757     {
2758       if (node->pkt->pkttype == PKT_USER_ID )
2759         break;
2760       else if (node->pkt->pkttype == PKT_SIGNATURE
2761                && node->pkt->pkt.signature->sig_class == 0x20)
2762         {
2763           /* check whether we already have this */
2764           found = 0;
2765           for (onode=keyblock_orig->next; onode; onode=onode->next)
2766             {
2767               if (onode->pkt->pkttype == PKT_USER_ID )
2768                 break;
2769               else if (onode->pkt->pkttype == PKT_SIGNATURE
2770                        && onode->pkt->pkt.signature->sig_class == 0x20
2771                        && !cmp_signatures(onode->pkt->pkt.signature,
2772                                           node->pkt->pkt.signature))
2773                 {
2774                   found = 1;
2775                   break;
2776                 }
2777             }
2778           if (!found)
2779             {
2780               kbnode_t n2 = clone_kbnode(node);
2781               insert_kbnode( keyblock_orig, n2, 0 );
2782               n2->flag |= 1;
2783               ++*n_sigs;
2784               if(!opt.quiet)
2785                 {
2786                   char *p=get_user_id_native (keyid);
2787                   log_info(_("key %s: \"%s\" revocation"
2788                              " certificate added\n"), keystr(keyid),p);
2789                   xfree(p);
2790                 }
2791             }
2792         }
2793     }
2794
2795   /* 2nd: merge in any direct key (0x1F) sigs */
2796   for(node=keyblock->next; node; node=node->next)
2797     {
2798       if (node->pkt->pkttype == PKT_USER_ID )
2799         break;
2800       else if (node->pkt->pkttype == PKT_SIGNATURE
2801                && node->pkt->pkt.signature->sig_class == 0x1F)
2802         {
2803           /* check whether we already have this */
2804           found = 0;
2805           for (onode=keyblock_orig->next; onode; onode=onode->next)
2806             {
2807               if (onode->pkt->pkttype == PKT_USER_ID)
2808                 break;
2809               else if (onode->pkt->pkttype == PKT_SIGNATURE
2810                        && onode->pkt->pkt.signature->sig_class == 0x1F
2811                        && !cmp_signatures(onode->pkt->pkt.signature,
2812                                           node->pkt->pkt.signature))
2813                 {
2814                   found = 1;
2815                   break;
2816                 }
2817             }
2818           if (!found )
2819             {
2820               kbnode_t n2 = clone_kbnode(node);
2821               insert_kbnode( keyblock_orig, n2, 0 );
2822               n2->flag |= 1;
2823               ++*n_sigs;
2824               if(!opt.quiet)
2825                 log_info( _("key %s: direct key signature added\n"),
2826                           keystr(keyid));
2827             }
2828         }
2829     }
2830
2831   /* 3rd: try to merge new certificates in */
2832   for (onode=keyblock_orig->next; onode; onode=onode->next)
2833     {
2834       if (!(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID)
2835         {
2836           /* find the user id in the imported keyblock */
2837           for (node=keyblock->next; node; node=node->next)
2838             if (node->pkt->pkttype == PKT_USER_ID
2839                 && !cmp_user_ids( onode->pkt->pkt.user_id,
2840                                   node->pkt->pkt.user_id ) )
2841               break;
2842           if (node ) /* found: merge */
2843             {
2844               rc = merge_sigs( onode, node, n_sigs, fname, keyid );
2845               if (rc )
2846                 return rc;
2847             }
2848         }
2849     }
2850
2851   /* 4th: add new user-ids */
2852   for (node=keyblock->next; node; node=node->next)
2853     {
2854       if (node->pkt->pkttype == PKT_USER_ID)
2855         {
2856           /* do we have this in the original keyblock */
2857           for (onode=keyblock_orig->next; onode; onode=onode->next )
2858             if (onode->pkt->pkttype == PKT_USER_ID
2859                 && !cmp_user_ids( onode->pkt->pkt.user_id,
2860                                   node->pkt->pkt.user_id ) )
2861               break;
2862           if (!onode ) /* this is a new user id: append */
2863             {
2864               rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
2865               if (rc )
2866                 return rc;
2867               ++*n_uids;
2868             }
2869         }
2870     }
2871
2872   /* 5th: add new subkeys */
2873   for (node=keyblock->next; node; node=node->next)
2874     {
2875       onode = NULL;
2876       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2877         {
2878           /* do we have this in the original keyblock? */
2879           for(onode=keyblock_orig->next; onode; onode=onode->next)
2880             if (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2881                 && !cmp_public_keys( onode->pkt->pkt.public_key,
2882                                      node->pkt->pkt.public_key))
2883               break;
2884           if (!onode ) /* This is a new subkey: append.  */
2885             {
2886               rc = append_key (keyblock_orig, node, n_sigs, fname, keyid);
2887               if (rc)
2888                 return rc;
2889               ++*n_subk;
2890             }
2891         }
2892       else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
2893         {
2894           /* do we have this in the original keyblock? */
2895           for (onode=keyblock_orig->next; onode; onode=onode->next )
2896             if (onode->pkt->pkttype == PKT_SECRET_SUBKEY
2897                 && !cmp_public_keys (onode->pkt->pkt.public_key,
2898                                      node->pkt->pkt.public_key) )
2899               break;
2900           if (!onode ) /* This is a new subkey: append.  */
2901             {
2902               rc = append_key (keyblock_orig, node, n_sigs, fname, keyid);
2903               if (rc )
2904                 return rc;
2905               ++*n_subk;
2906             }
2907         }
2908     }
2909
2910   /* 6th: merge subkey certificates */
2911   for (onode=keyblock_orig->next; onode; onode=onode->next)
2912     {
2913       if (!(onode->flag & 1)
2914           && (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2915               || onode->pkt->pkttype == PKT_SECRET_SUBKEY))
2916         {
2917           /* find the subkey in the imported keyblock */
2918           for(node=keyblock->next; node; node=node->next)
2919             {
2920               if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2921                    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
2922                   && !cmp_public_keys( onode->pkt->pkt.public_key,
2923                                        node->pkt->pkt.public_key ) )
2924                 break;
2925             }
2926           if (node) /* Found: merge.  */
2927             {
2928               rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
2929               if (rc )
2930                 return rc;
2931             }
2932         }
2933     }
2934
2935   return 0;
2936 }
2937
2938
2939 /*
2940  * Append the userid starting with NODE and all signatures to KEYBLOCK.
2941  */
2942 static int
2943 append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs,
2944             const char *fname, u32 *keyid )
2945 {
2946   kbnode_t n;
2947   kbnode_t n_where = NULL;
2948
2949   (void)fname;
2950   (void)keyid;
2951
2952   log_assert (node->pkt->pkttype == PKT_USER_ID );
2953
2954   /* find the position */
2955   for (n = keyblock; n; n_where = n, n = n->next)
2956     {
2957       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2958           || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2959         break;
2960     }
2961   if (!n)
2962     n_where = NULL;
2963
2964   /* and append/insert */
2965   while (node)
2966     {
2967       /* we add a clone to the original keyblock, because this
2968        * one is released first */
2969       n = clone_kbnode(node);
2970       if (n_where)
2971         {
2972           insert_kbnode( n_where, n, 0 );
2973           n_where = n;
2974         }
2975       else
2976         add_kbnode( keyblock, n );
2977       n->flag |= 1;
2978       node->flag |= 1;
2979       if (n->pkt->pkttype == PKT_SIGNATURE )
2980         ++*n_sigs;
2981
2982       node = node->next;
2983       if (node && node->pkt->pkttype != PKT_SIGNATURE )
2984         break;
2985     }
2986
2987   return 0;
2988 }
2989
2990
2991 /*
2992  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2993  * (how should we handle comment packets here?)
2994  */
2995 static int
2996 merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs,
2997             const char *fname, u32 *keyid)
2998 {
2999   kbnode_t n, n2;
3000   int found = 0;
3001
3002   (void)fname;
3003   (void)keyid;
3004
3005   log_assert (dst->pkt->pkttype == PKT_USER_ID);
3006   log_assert (src->pkt->pkttype == PKT_USER_ID);
3007
3008   for (n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next)
3009     {
3010       if (n->pkt->pkttype != PKT_SIGNATURE )
3011         continue;
3012       if (n->pkt->pkt.signature->sig_class == 0x18
3013           || n->pkt->pkt.signature->sig_class == 0x28 )
3014         continue; /* skip signatures which are only valid on subkeys */
3015
3016       found = 0;
3017       for (n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
3018         if (!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
3019           {
3020             found++;
3021             break;
3022           }
3023       if (!found )
3024         {
3025           /* This signature is new or newer, append N to DST.
3026            * We add a clone to the original keyblock, because this
3027            * one is released first */
3028           n2 = clone_kbnode(n);
3029           insert_kbnode( dst, n2, PKT_SIGNATURE );
3030           n2->flag |= 1;
3031           n->flag |= 1;
3032           ++*n_sigs;
3033         }
3034     }
3035
3036   return 0;
3037 }
3038
3039
3040 /*
3041  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
3042  */
3043 static int
3044 merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs,
3045                const char *fname, u32 *keyid)
3046 {
3047   kbnode_t n, n2;
3048   int found = 0;
3049
3050   (void)fname;
3051   (void)keyid;
3052
3053   log_assert (dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
3054               || dst->pkt->pkttype == PKT_SECRET_SUBKEY);
3055
3056   for (n=src->next; n ; n = n->next)
3057     {
3058       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
3059           || n->pkt->pkttype == PKT_PUBLIC_KEY )
3060         break;
3061       if (n->pkt->pkttype != PKT_SIGNATURE )
3062         continue;
3063
3064       found = 0;
3065       for (n2=dst->next; n2; n2 = n2->next)
3066         {
3067           if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
3068               || n2->pkt->pkttype == PKT_PUBLIC_KEY )
3069             break;
3070           if (n2->pkt->pkttype == PKT_SIGNATURE
3071               && (n->pkt->pkt.signature->keyid[0]
3072                   == n2->pkt->pkt.signature->keyid[0])
3073               && (n->pkt->pkt.signature->keyid[1]
3074                   == n2->pkt->pkt.signature->keyid[1])
3075               && (n->pkt->pkt.signature->timestamp
3076                   <= n2->pkt->pkt.signature->timestamp)
3077               && (n->pkt->pkt.signature->sig_class
3078                   == n2->pkt->pkt.signature->sig_class))
3079             {
3080               found++;
3081               break;
3082             }
3083         }
3084       if (!found )
3085         {
3086           /* This signature is new or newer, append N to DST.
3087            * We add a clone to the original keyblock, because this
3088            * one is released first */
3089           n2 = clone_kbnode(n);
3090           insert_kbnode( dst, n2, PKT_SIGNATURE );
3091           n2->flag |= 1;
3092           n->flag |= 1;
3093           ++*n_sigs;
3094         }
3095     }
3096
3097   return 0;
3098 }
3099
3100
3101 /*
3102  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
3103  * Mark all new and copied packets by setting flag bit 0.
3104  */
3105 static int
3106 append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs,
3107             const char *fname, u32 *keyid)
3108 {
3109   kbnode_t n;
3110
3111   (void)fname;
3112   (void)keyid;
3113
3114   log_assert (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
3115               || node->pkt->pkttype == PKT_SECRET_SUBKEY);
3116
3117   while (node)
3118     {
3119       /* we add a clone to the original keyblock, because this
3120        * one is released first */
3121       n = clone_kbnode(node);
3122       add_kbnode( keyblock, n );
3123       n->flag |= 1;
3124       node->flag |= 1;
3125       if (n->pkt->pkttype == PKT_SIGNATURE )
3126         ++*n_sigs;
3127
3128       node = node->next;
3129       if (node && node->pkt->pkttype != PKT_SIGNATURE )
3130         break;
3131     }
3132
3133   return 0;
3134 }