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