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