gpg: Use a regular type instead of a void* for import stats.
[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 static gpg_error_t
1322 transfer_secret_keys (ctrl_t ctrl, struct import_stats_s *stats, kbnode_t sec_keyblock,
1323                       int batch)
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       stats->count++;
1393       stats->secret_read++;
1394
1395       /* We ignore stub keys.  The way we handle them in other parts
1396          of the code is by asking the agent whether any secret key is
1397          available for a given keyblock and then concluding that we
1398          have a secret key; all secret (sub)keys of the keyblock the
1399          agent does not know of are then stub keys.  This works also
1400          for card stub keys.  The learn command or the card-status
1401          command may be used to check with the agent whether a card
1402          has been inserted and a stub key is in turn generated by the
1403          agent.  */
1404       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
1405         {
1406           stub_key_skipped = 1;
1407           continue;
1408         }
1409
1410       /* Convert our internal secret key object into an S-expression.  */
1411       nskey = pubkey_get_nskey (pk->pubkey_algo);
1412       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
1413         {
1414           err = gpg_error (GPG_ERR_BAD_SECKEY);
1415           log_error ("internal error: %s\n", gpg_strerror (err));
1416           goto leave;
1417         }
1418
1419       init_membuf (&mbuf, 50);
1420       put_membuf_str (&mbuf, "(skey");
1421       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA
1422           || pk->pubkey_algo == PUBKEY_ALGO_EDDSA
1423           || pk->pubkey_algo == PUBKEY_ALGO_ECDH)
1424         {
1425           /* The ECC case.  */
1426           char *curvestr = openpgp_oid_to_str (pk->pkey[0]);
1427           if (!curvestr)
1428             err = gpg_error_from_syserror ();
1429           else
1430             {
1431               const char *curvename = openpgp_oid_to_curve (curvestr, 1);
1432               err = gcry_sexp_build (&curve, NULL, "(curve %s)",
1433                                      curvename?curvename:curvestr);
1434               xfree (curvestr);
1435               if (!err)
1436                 {
1437                   j = 0;
1438                   /* Append the public key element Q.  */
1439                   put_membuf_str (&mbuf, " _ %m");
1440                   format_args[j++] = pk->pkey + 1;
1441
1442                   /* Append the secret key element D.  For ECDH we
1443                      skip PKEY[2] because this holds the KEK which is
1444                      not needed by gpg-agent.  */
1445                   i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
1446                   if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1447                     put_membuf_str (&mbuf, " e %m");
1448                   else
1449                     put_membuf_str (&mbuf, " _ %m");
1450                   format_args[j++] = pk->pkey + i;
1451                 }
1452             }
1453         }
1454       else
1455         {
1456           /* Standard case for the old (non-ECC) algorithms.  */
1457           for (i=j=0; i < nskey; i++)
1458             {
1459               if (!pk->pkey[i])
1460                 continue; /* Protected keys only have NPKEY+1 elements.  */
1461
1462               if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_USER1))
1463                 put_membuf_str (&mbuf, " e %m");
1464               else
1465                 put_membuf_str (&mbuf, " _ %m");
1466               format_args[j++] = pk->pkey + i;
1467             }
1468         }
1469       put_membuf_str (&mbuf, ")");
1470       put_membuf (&mbuf, "", 1);
1471       if (err)
1472         xfree (get_membuf (&mbuf, NULL));
1473       else
1474         {
1475           char *format = get_membuf (&mbuf, NULL);
1476           if (!format)
1477             err = gpg_error_from_syserror ();
1478           else
1479             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
1480           xfree (format);
1481         }
1482       if (err)
1483         {
1484           log_error ("error building skey array: %s\n", gpg_strerror (err));
1485           goto leave;
1486         }
1487
1488       if (ski->is_protected)
1489         {
1490           char countbuf[35];
1491
1492           /* Note that the IVLEN may be zero if we are working on a
1493              dummy key.  We can't express that in an S-expression and
1494              thus we send dummy data for the IV.  */
1495           snprintf (countbuf, sizeof countbuf, "%lu",
1496                     (unsigned long)ski->s2k.count);
1497           err = gcry_sexp_build
1498             (&prot, NULL,
1499              " (protection %s %s %b %d %s %b %s)\n",
1500              ski->sha1chk? "sha1":"sum",
1501              openpgp_cipher_algo_name (ski->algo),
1502              ski->ivlen? (int)ski->ivlen:1,
1503              ski->ivlen? ski->iv: (const unsigned char*)"X",
1504              ski->s2k.mode,
1505              openpgp_md_algo_name (ski->s2k.hash_algo),
1506              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
1507              countbuf);
1508         }
1509       else
1510         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
1511
1512       tmpsexp = NULL;
1513       xfree (transferkey);
1514       transferkey = NULL;
1515       if (!err)
1516         err = gcry_sexp_build (&tmpsexp, NULL,
1517                                "(openpgp-private-key\n"
1518                                " (version %d)\n"
1519                                " (algo %s)\n"
1520                                " %S%S\n"
1521                                " (csum %d)\n"
1522                                " %S)\n",
1523                                pk->version,
1524                                openpgp_pk_algo_name (pk->pubkey_algo),
1525                                curve, skey,
1526                                (int)(unsigned long)ski->csum, prot);
1527       gcry_sexp_release (skey);
1528       gcry_sexp_release (prot);
1529       if (!err)
1530         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
1531       gcry_sexp_release (tmpsexp);
1532       if (err)
1533         {
1534           log_error ("error building transfer key: %s\n", gpg_strerror (err));
1535           goto leave;
1536         }
1537
1538       /* Wrap the key.  */
1539       wrappedkeylen = transferkeylen + 8;
1540       xfree (wrappedkey);
1541       wrappedkey = xtrymalloc (wrappedkeylen);
1542       if (!wrappedkey)
1543         err = gpg_error_from_syserror ();
1544       else
1545         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
1546                                    transferkey, transferkeylen);
1547       if (err)
1548         goto leave;
1549       xfree (transferkey);
1550       transferkey = NULL;
1551
1552       /* Send the wrapped key to the agent.  */
1553       {
1554         char *desc = gpg_format_keydesc (pk, FORMAT_KEYDESC_IMPORT, 1);
1555         err = agent_import_key (ctrl, desc, &cache_nonce,
1556                                 wrappedkey, wrappedkeylen, batch);
1557         xfree (desc);
1558       }
1559       if (!err)
1560         {
1561           if (opt.verbose)
1562             log_info (_("key %s: secret key imported\n"),
1563                       keystr_from_pk_with_sub (main_pk, pk));
1564           stats->secret_imported++;
1565         }
1566       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
1567         {
1568           if (opt.verbose)
1569             log_info (_("key %s: secret key already exists\n"),
1570                       keystr_from_pk_with_sub (main_pk, pk));
1571           err = 0;
1572           stats->secret_dups++;
1573         }
1574       else
1575         {
1576           log_error (_("key %s: error sending to agent: %s\n"),
1577                      keystr_from_pk_with_sub (main_pk, pk),
1578                      gpg_strerror (err));
1579           if (gpg_err_code (err) == GPG_ERR_CANCELED
1580               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1581             break; /* Don't try the other subkeys.  */
1582         }
1583     }
1584
1585   if (!err && stub_key_skipped)
1586     /* We need to notify user how to migrate stub keys.  */
1587     err = gpg_error (GPG_ERR_NOT_PROCESSED);
1588
1589  leave:
1590   gcry_sexp_release (curve);
1591   xfree (cache_nonce);
1592   xfree (wrappedkey);
1593   xfree (transferkey);
1594   gcry_cipher_close (cipherhd);
1595   xfree (kek);
1596   return err;
1597 }
1598
1599
1600 /* Walk a secret keyblock and produce a public keyblock out of it.
1601    Returns a new node or NULL on error. */
1602 static kbnode_t
1603 sec_to_pub_keyblock (kbnode_t sec_keyblock)
1604 {
1605   kbnode_t pub_keyblock = NULL;
1606   kbnode_t ctx = NULL;
1607   kbnode_t secnode, pubnode;
1608
1609   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
1610     {
1611       if (secnode->pkt->pkttype == PKT_SECRET_KEY
1612           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
1613         {
1614           /* Make a public key.  */
1615           PACKET *pkt;
1616           PKT_public_key *pk;
1617
1618           pkt = xtrycalloc (1, sizeof *pkt);
1619           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
1620           if (!pk)
1621             {
1622               xfree (pkt);
1623               release_kbnode (pub_keyblock);
1624               return NULL;
1625             }
1626           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
1627             pkt->pkttype = PKT_PUBLIC_KEY;
1628           else
1629             pkt->pkttype = PKT_PUBLIC_SUBKEY;
1630           pkt->pkt.public_key = pk;
1631
1632           pubnode = new_kbnode (pkt);
1633         }
1634       else
1635         {
1636           pubnode = clone_kbnode (secnode);
1637         }
1638
1639       if (!pub_keyblock)
1640         pub_keyblock = pubnode;
1641       else
1642         add_kbnode (pub_keyblock, pubnode);
1643     }
1644
1645   return pub_keyblock;
1646 }
1647
1648 /****************
1649  * Ditto for secret keys.  Handling is simpler than for public keys.
1650  * We allow secret key importing only when allow is true, this is so
1651  * that a secret key can not be imported accidentally and thereby tampering
1652  * with the trust calculation.
1653  */
1654 static int
1655 import_secret_one (ctrl_t ctrl, const char *fname, kbnode_t keyblock,
1656                    struct import_stats_s *stats, int batch, unsigned int options,
1657                    int for_migration,
1658                    import_screener_t screener, void *screener_arg)
1659 {
1660   PKT_public_key *pk;
1661   struct seckey_info *ski;
1662   kbnode_t node, uidnode;
1663   u32 keyid[2];
1664   int rc = 0;
1665   int nr_prev;
1666   kbnode_t pub_keyblock;
1667   char pkstrbuf[PUBKEY_STRING_SIZE];
1668
1669   /* Get the key and print some info about it */
1670   node = find_kbnode (keyblock, PKT_SECRET_KEY);
1671   if (!node)
1672     BUG ();
1673
1674   pk = node->pkt->pkt.public_key;
1675
1676   keyid_from_pk (pk, keyid);
1677   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
1678
1679   if (screener && screener (keyblock, screener_arg))
1680     {
1681       log_error (_("secret key %s: %s\n"), keystr_from_pk (pk),
1682                  _("rejected by import screener"));
1683       return 0;
1684   }
1685
1686   if (opt.verbose && !for_migration)
1687     {
1688       log_info ("sec  %s/%s %s   ",
1689                 pubkey_string (pk, pkstrbuf, sizeof pkstrbuf),
1690                 keystr_from_pk (pk), datestr_from_pk (pk));
1691       if (uidnode)
1692         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
1693                            uidnode->pkt->pkt.user_id->len);
1694       log_printf ("\n");
1695     }
1696   stats->secret_read++;
1697
1698   if ((options & IMPORT_NO_SECKEY))
1699     {
1700       if (!for_migration)
1701         log_error (_("importing secret keys not allowed\n"));
1702       return 0;
1703     }
1704
1705   if (!uidnode)
1706     {
1707       if (!for_migration)
1708         log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
1709       return 0;
1710     }
1711
1712   ski = pk->seckey_info;
1713   if (!ski)
1714     {
1715       /* Actually an internal error.  */
1716       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
1717       return 0;
1718     }
1719
1720   /* A quick check to not import keys with an invalid protection
1721      cipher algorithm (only checks the primary key, though).  */
1722   if (ski->algo > 110)
1723     {
1724       if (!for_migration)
1725         log_error (_("key %s: secret key with invalid cipher %d"
1726                      " - skipped\n"), keystr_from_pk (pk), ski->algo);
1727       return 0;
1728     }
1729
1730 #ifdef ENABLE_SELINUX_HACKS
1731   if (1)
1732     {
1733       /* We don't allow to import secret keys because that may be used
1734          to put a secret key into the keyring and the user might later
1735          be tricked into signing stuff with that key.  */
1736       log_error (_("importing secret keys not allowed\n"));
1737       return 0;
1738     }
1739 #endif
1740
1741   clear_kbnode_flags (keyblock);
1742
1743   nr_prev = stats->skipped_new_keys;
1744
1745   /* Make a public key out of the key. */
1746   pub_keyblock = sec_to_pub_keyblock (keyblock);
1747   if (!pub_keyblock)
1748     log_error ("key %s: failed to create public key from secret key\n",
1749                    keystr_from_pk (pk));
1750   else
1751     {
1752       /* Note that this outputs an IMPORT_OK status message for the
1753          public key block, and below we will output another one for
1754          the secret keys.  FIXME?  */
1755       import_one (ctrl, fname, pub_keyblock, stats,
1756                   NULL, NULL, options, 1, for_migration,
1757                   screener, screener_arg);
1758
1759       /* Fixme: We should check for an invalid keyblock and
1760          cancel the secret key import in this case.  */
1761       release_kbnode (pub_keyblock);
1762
1763       /* At least we cancel the secret key import when the public key
1764          import was skipped due to MERGE_ONLY option and a new
1765          key.  */
1766       if (stats->skipped_new_keys <= nr_prev)
1767         {
1768           /* Read the keyblock again to get the effects of a merge.  */
1769           /* Fixme: we should do this based on the fingerprint or
1770              even better let import_one return the merged
1771              keyblock.  */
1772           node = get_pubkeyblock (keyid);
1773           if (!node)
1774             log_error ("key %s: failed to re-lookup public key\n",
1775                        keystr_from_pk (pk));
1776           else
1777             {
1778               gpg_error_t err;
1779
1780               nr_prev = stats->secret_imported;
1781               err = transfer_secret_keys (ctrl, stats, keyblock, batch);
1782               if (gpg_err_code (err) == GPG_ERR_NOT_PROCESSED)
1783                 {
1784                   /* TRANSLATORS: For smartcard, each private key on
1785                      host has a reference (stub) to a smartcard and
1786                      actual private key data is stored on the card.  A
1787                      single smartcard can have up to three private key
1788                      data.  Importing private key stub is always
1789                      skipped in 2.1, and it returns
1790                      GPG_ERR_NOT_PROCESSED.  Instead, user should be
1791                      suggested to run 'gpg --card-status', then,
1792                      references to a card will be automatically
1793                      created again.  */
1794                   log_info (_("To migrate '%s', with each smartcard, "
1795                               "run: %s\n"), "secring.gpg", "gpg --card-status");
1796                   err = 0;
1797                 }
1798               if (!err)
1799                 {
1800                   int status = 16;
1801                   if (!opt.quiet)
1802                     log_info (_("key %s: secret key imported\n"),
1803                               keystr_from_pk (pk));
1804                   if (stats->secret_imported > nr_prev)
1805                     status |= 1;
1806                   if (is_status_enabled ())
1807                     print_import_ok (pk, status);
1808                   check_prefs (ctrl, node);
1809                 }
1810               release_kbnode (node);
1811             }
1812         }
1813     }
1814
1815   return rc;
1816 }
1817
1818
1819 /****************
1820  * Import a revocation certificate; this is a single signature packet.
1821  */
1822 static int
1823 import_revoke_cert (const char *fname, kbnode_t node,
1824                     struct import_stats_s *stats)
1825 {
1826   PKT_public_key *pk = NULL;
1827   kbnode_t onode;
1828   kbnode_t keyblock = NULL;
1829   KEYDB_HANDLE hd = NULL;
1830   u32 keyid[2];
1831   int rc = 0;
1832
1833   (void)fname;
1834
1835   assert( !node->next );
1836   assert( node->pkt->pkttype == PKT_SIGNATURE );
1837   assert( node->pkt->pkt.signature->sig_class == 0x20 );
1838
1839   keyid[0] = node->pkt->pkt.signature->keyid[0];
1840   keyid[1] = node->pkt->pkt.signature->keyid[1];
1841
1842   pk = xmalloc_clear( sizeof *pk );
1843   rc = get_pubkey( pk, keyid );
1844   if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY )
1845     {
1846       log_error(_("key %s: no public key -"
1847                   " can't apply revocation certificate\n"), keystr(keyid));
1848       rc = 0;
1849       goto leave;
1850     }
1851   else if (rc )
1852     {
1853       log_error(_("key %s: public key not found: %s\n"),
1854                 keystr(keyid), gpg_strerror (rc));
1855       goto leave;
1856     }
1857
1858   /* Read the original keyblock. */
1859   hd = keydb_new ();
1860   if (!hd)
1861     {
1862       rc = gpg_error_from_syserror ();
1863       goto leave;
1864     }
1865
1866   {
1867     byte afp[MAX_FINGERPRINT_LEN];
1868     size_t an;
1869
1870     fingerprint_from_pk (pk, afp, &an);
1871     while (an < MAX_FINGERPRINT_LEN)
1872       afp[an++] = 0;
1873     rc = keydb_search_fpr (hd, afp);
1874   }
1875   if (rc)
1876     {
1877       log_error (_("key %s: can't locate original keyblock: %s\n"),
1878                  keystr(keyid), gpg_strerror (rc));
1879       goto leave;
1880     }
1881   rc = keydb_get_keyblock (hd, &keyblock );
1882   if (rc)
1883     {
1884       log_error (_("key %s: can't read original keyblock: %s\n"),
1885                  keystr(keyid), gpg_strerror (rc));
1886       goto leave;
1887     }
1888
1889   /* it is okay, that node is not in keyblock because
1890    * check_key_signature works fine for sig_class 0x20 in this
1891    * special case. */
1892   rc = check_key_signature( keyblock, node, NULL);
1893   if (rc )
1894     {
1895       log_error( _("key %s: invalid revocation certificate"
1896                    ": %s - rejected\n"), keystr(keyid), gpg_strerror (rc));
1897       goto leave;
1898     }
1899
1900   /* check whether we already have this */
1901   for(onode=keyblock->next; onode; onode=onode->next ) {
1902     if (onode->pkt->pkttype == PKT_USER_ID )
1903       break;
1904     else if (onode->pkt->pkttype == PKT_SIGNATURE
1905              && !cmp_signatures(node->pkt->pkt.signature,
1906                                 onode->pkt->pkt.signature))
1907       {
1908         rc = 0;
1909         goto leave; /* yes, we already know about it */
1910       }
1911   }
1912
1913   /* insert it */
1914   insert_kbnode( keyblock, clone_kbnode(node), 0 );
1915
1916   /* and write the keyblock back */
1917   rc = keydb_update_keyblock (hd, keyblock );
1918   if (rc)
1919     log_error (_("error writing keyring '%s': %s\n"),
1920                keydb_get_resource_name (hd), gpg_strerror (rc) );
1921   keydb_release (hd);
1922   hd = NULL;
1923
1924   /* we are ready */
1925   if (!opt.quiet )
1926     {
1927       char *p=get_user_id_native (keyid);
1928       log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1929                 keystr(keyid),p);
1930       xfree(p);
1931     }
1932   stats->n_revoc++;
1933
1934   /* If the key we just revoked was ultimately trusted, remove its
1935      ultimate trust.  This doesn't stop the user from putting the
1936      ultimate trust back, but is a reasonable solution for now. */
1937   if(get_ownertrust(pk)==TRUST_ULTIMATE)
1938     clear_ownertrusts(pk);
1939
1940   revalidation_mark ();
1941
1942  leave:
1943   keydb_release (hd);
1944   release_kbnode( keyblock );
1945   free_public_key( pk );
1946   return rc;
1947 }
1948
1949
1950 /*
1951  * Loop over the keyblock and check all self signatures.
1952  * Mark all user-ids with a self-signature by setting flag bit 0.
1953  * Mark all user-ids with an invalid self-signature by setting bit 1.
1954  * This works also for subkeys, here the subkey is marked.  Invalid or
1955  * extra subkey sigs (binding or revocation) are marked for deletion.
1956  * non_self is set to true if there are any sigs other than self-sigs
1957  * in this keyblock.
1958  */
1959 static int
1960 chk_self_sigs (const char *fname, kbnode_t keyblock,
1961                PKT_public_key *pk, u32 *keyid, int *non_self )
1962 {
1963   kbnode_t n, knode = NULL;
1964   PKT_signature *sig;
1965   int rc;
1966   u32 bsdate=0, rsdate=0;
1967   kbnode_t bsnode = NULL, rsnode = NULL;
1968
1969   (void)fname;
1970   (void)pk;
1971
1972   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
1973     {
1974       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1975         {
1976           knode = n;
1977           bsdate = 0;
1978           rsdate = 0;
1979           bsnode = NULL;
1980           rsnode = NULL;
1981           continue;
1982         }
1983
1984       if ( n->pkt->pkttype != PKT_SIGNATURE )
1985         continue;
1986
1987       sig = n->pkt->pkt.signature;
1988       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
1989         {
1990           *non_self = 1;
1991           continue;
1992         }
1993
1994       /* This just caches the sigs for later use.  That way we
1995          import a fully-cached key which speeds things up. */
1996       if (!opt.no_sig_cache)
1997         check_key_signature (keyblock, n, NULL);
1998
1999       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
2000         {
2001           kbnode_t unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
2002           if ( !unode )
2003             {
2004               log_error( _("key %s: no user ID for signature\n"),
2005                          keystr(keyid));
2006               return -1;  /* The complete keyblock is invalid.  */
2007             }
2008
2009           /* If it hasn't been marked valid yet, keep trying.  */
2010           if (!(unode->flag&1))
2011             {
2012               rc = check_key_signature (keyblock, n, NULL);
2013               if ( rc )
2014                 {
2015                   if ( opt.verbose )
2016                     {
2017                       char *p = utf8_to_native
2018                         (unode->pkt->pkt.user_id->name,
2019                          strlen (unode->pkt->pkt.user_id->name),0);
2020                       log_info (gpg_err_code(rc) == GPG_ERR_PUBKEY_ALGO ?
2021                                 _("key %s: unsupported public key "
2022                                   "algorithm on user ID \"%s\"\n"):
2023                                 _("key %s: invalid self-signature "
2024                                   "on user ID \"%s\"\n"),
2025                                 keystr (keyid),p);
2026                       xfree (p);
2027                     }
2028                 }
2029               else
2030                 unode->flag |= 1; /* Mark that signature checked. */
2031             }
2032         }
2033       else if (IS_KEY_SIG (sig))
2034         {
2035           rc = check_key_signature (keyblock, n, NULL);
2036           if ( rc )
2037             {
2038               if (opt.verbose)
2039                 log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2040                           _("key %s: unsupported public key algorithm\n"):
2041                           _("key %s: invalid direct key signature\n"),
2042                           keystr (keyid));
2043               n->flag |= 4;
2044             }
2045         }
2046       else if ( IS_SUBKEY_SIG (sig) )
2047         {
2048           /* Note that this works based solely on the timestamps like
2049              the rest of gpg.  If the standard gets revocation
2050              targets, this may need to be revised.  */
2051
2052           if ( !knode )
2053             {
2054               if (opt.verbose)
2055                 log_info (_("key %s: no subkey for key binding\n"),
2056                           keystr (keyid));
2057               n->flag |= 4; /* delete this */
2058             }
2059           else
2060             {
2061               rc = check_key_signature (keyblock, n, NULL);
2062               if ( rc )
2063                 {
2064                   if (opt.verbose)
2065                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2066                               _("key %s: unsupported public key"
2067                                 " algorithm\n"):
2068                               _("key %s: invalid subkey binding\n"),
2069                               keystr (keyid));
2070                   n->flag |= 4;
2071                 }
2072               else
2073                 {
2074                   /* It's valid, so is it newer? */
2075                   if (sig->timestamp >= bsdate)
2076                     {
2077                       knode->flag |= 1;  /* The subkey is valid.  */
2078                       if (bsnode)
2079                         {
2080                           /* Delete the last binding sig since this
2081                              one is newer */
2082                           bsnode->flag |= 4;
2083                           if (opt.verbose)
2084                             log_info (_("key %s: removed multiple subkey"
2085                                         " binding\n"),keystr(keyid));
2086                         }
2087
2088                       bsnode = n;
2089                       bsdate = sig->timestamp;
2090                     }
2091                   else
2092                     n->flag |= 4; /* older */
2093                 }
2094             }
2095         }
2096       else if ( IS_SUBKEY_REV (sig) )
2097         {
2098           /* We don't actually mark the subkey as revoked right now,
2099              so just check that the revocation sig is the most recent
2100              valid one.  Note that we don't care if the binding sig is
2101              newer than the revocation sig.  See the comment in
2102              getkey.c:merge_selfsigs_subkey for more.  */
2103           if ( !knode )
2104             {
2105               if (opt.verbose)
2106                 log_info (_("key %s: no subkey for key revocation\n"),
2107                           keystr(keyid));
2108               n->flag |= 4; /* delete this */
2109             }
2110           else
2111             {
2112               rc = check_key_signature (keyblock, n, NULL);
2113               if ( rc )
2114                 {
2115                   if(opt.verbose)
2116                     log_info (gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
2117                               _("key %s: unsupported public"
2118                                 " key algorithm\n"):
2119                               _("key %s: invalid subkey revocation\n"),
2120                               keystr(keyid));
2121                   n->flag |= 4;
2122                 }
2123               else
2124                 {
2125                   /* It's valid, so is it newer? */
2126                   if (sig->timestamp >= rsdate)
2127                     {
2128                       if (rsnode)
2129                         {
2130                           /* Delete the last revocation sig since
2131                              this one is newer.  */
2132                           rsnode->flag |= 4;
2133                           if (opt.verbose)
2134                             log_info (_("key %s: removed multiple subkey"
2135                                         " revocation\n"),keystr(keyid));
2136                         }
2137
2138                       rsnode = n;
2139                       rsdate = sig->timestamp;
2140                     }
2141                   else
2142                     n->flag |= 4; /* older */
2143                 }
2144             }
2145         }
2146     }
2147
2148   return 0;
2149 }
2150
2151
2152 /****************
2153  * delete all parts which are invalid and those signatures whose
2154  * public key algorithm is not available in this implemenation;
2155  * but consider RSA as valid, because parse/build_packets knows
2156  * about it.
2157  * returns: true if at least one valid user-id is left over.
2158  */
2159 static int
2160 delete_inv_parts( const char *fname, kbnode_t keyblock,
2161                   u32 *keyid, unsigned int options)
2162 {
2163   kbnode_t node;
2164   int nvalid=0, uid_seen=0, subkey_seen=0;
2165
2166   (void)fname;
2167
2168   for (node=keyblock->next; node; node = node->next )
2169     {
2170       if (node->pkt->pkttype == PKT_USER_ID)
2171         {
2172           uid_seen = 1;
2173           if ((node->flag & 2) || !(node->flag & 1) )
2174             {
2175               if (opt.verbose )
2176                 {
2177                   char *p=utf8_to_native(node->pkt->pkt.user_id->name,
2178                                          node->pkt->pkt.user_id->len,0);
2179                   log_info( _("key %s: skipped user ID \"%s\"\n"),
2180                             keystr(keyid),p);
2181                   xfree(p);
2182                 }
2183               delete_kbnode( node ); /* the user-id */
2184               /* and all following packets up to the next user-id */
2185               while (node->next
2186                      && node->next->pkt->pkttype != PKT_USER_ID
2187                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
2188                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
2189                 delete_kbnode( node->next );
2190                 node = node->next;
2191               }
2192             }
2193           else
2194             nvalid++;
2195         }
2196       else if (   node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2197                || node->pkt->pkttype == PKT_SECRET_SUBKEY )
2198         {
2199           if ((node->flag & 2) || !(node->flag & 1) )
2200             {
2201               if (opt.verbose )
2202                 log_info( _("key %s: skipped subkey\n"),keystr(keyid));
2203
2204               delete_kbnode( node ); /* the subkey */
2205               /* and all following signature packets */
2206               while (node->next
2207                      && node->next->pkt->pkttype == PKT_SIGNATURE ) {
2208                 delete_kbnode( node->next );
2209                 node = node->next;
2210               }
2211             }
2212           else
2213             subkey_seen = 1;
2214         }
2215       else if (node->pkt->pkttype == PKT_SIGNATURE
2216                && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
2217                && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
2218         {
2219           delete_kbnode( node ); /* build_packet() can't handle this */
2220         }
2221       else if (node->pkt->pkttype == PKT_SIGNATURE
2222                && !node->pkt->pkt.signature->flags.exportable
2223                && !(options&IMPORT_LOCAL_SIGS)
2224                && !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
2225         {
2226           /* here we violate the rfc a bit by still allowing
2227            * to import non-exportable signature when we have the
2228            * the secret key used to create this signature - it
2229            * seems that this makes sense */
2230           if(opt.verbose)
2231             log_info( _("key %s: non exportable signature"
2232                         " (class 0x%02X) - skipped\n"),
2233                       keystr(keyid), node->pkt->pkt.signature->sig_class );
2234           delete_kbnode( node );
2235         }
2236       else if (node->pkt->pkttype == PKT_SIGNATURE
2237                && node->pkt->pkt.signature->sig_class == 0x20)
2238         {
2239           if (uid_seen )
2240             {
2241               if(opt.verbose)
2242                 log_info( _("key %s: revocation certificate"
2243                             " at wrong place - skipped\n"),keystr(keyid));
2244               delete_kbnode( node );
2245             }
2246           else
2247             {
2248               /* If the revocation cert is from a different key than
2249                  the one we're working on don't check it - it's
2250                  probably from a revocation key and won't be
2251                  verifiable with this key anyway. */
2252
2253               if(node->pkt->pkt.signature->keyid[0]==keyid[0]
2254                  && node->pkt->pkt.signature->keyid[1]==keyid[1])
2255                 {
2256                   int rc = check_key_signature( keyblock, node, NULL);
2257                   if (rc )
2258                     {
2259                       if(opt.verbose)
2260                         log_info( _("key %s: invalid revocation"
2261                                     " certificate: %s - skipped\n"),
2262                                   keystr(keyid), gpg_strerror (rc));
2263                       delete_kbnode( node );
2264                     }
2265                 }
2266             }
2267         }
2268       else if (node->pkt->pkttype == PKT_SIGNATURE
2269                && (node->pkt->pkt.signature->sig_class == 0x18
2270                    || node->pkt->pkt.signature->sig_class == 0x28)
2271                && !subkey_seen )
2272         {
2273           if(opt.verbose)
2274             log_info( _("key %s: subkey signature"
2275                         " in wrong place - skipped\n"), keystr(keyid));
2276           delete_kbnode( node );
2277         }
2278       else if (node->pkt->pkttype == PKT_SIGNATURE
2279                && !IS_CERT(node->pkt->pkt.signature))
2280         {
2281           if(opt.verbose)
2282             log_info(_("key %s: unexpected signature class (0x%02X) -"
2283                        " skipped\n"),keystr(keyid),
2284                      node->pkt->pkt.signature->sig_class);
2285           delete_kbnode(node);
2286           }
2287       else if ((node->flag & 4) ) /* marked for deletion */
2288         delete_kbnode( node );
2289     }
2290
2291   /* note: because keyblock is the public key, it is never marked
2292    * for deletion and so keyblock cannot change */
2293   commit_kbnode( &keyblock );
2294   return nvalid;
2295 }
2296
2297
2298 /****************
2299  * It may happen that the imported keyblock has duplicated user IDs.
2300  * We check this here and collapse those user IDs together with their
2301  * sigs into one.
2302  * Returns: True if the keyblock has changed.
2303  */
2304 int
2305 collapse_uids( kbnode_t *keyblock )
2306 {
2307   kbnode_t uid1;
2308   int any=0;
2309
2310   for(uid1=*keyblock;uid1;uid1=uid1->next)
2311     {
2312       kbnode_t uid2;
2313
2314       if(is_deleted_kbnode(uid1))
2315         continue;
2316
2317       if(uid1->pkt->pkttype!=PKT_USER_ID)
2318         continue;
2319
2320       for(uid2=uid1->next;uid2;uid2=uid2->next)
2321         {
2322           if(is_deleted_kbnode(uid2))
2323             continue;
2324
2325           if(uid2->pkt->pkttype!=PKT_USER_ID)
2326             continue;
2327
2328           if(cmp_user_ids(uid1->pkt->pkt.user_id,
2329                           uid2->pkt->pkt.user_id)==0)
2330             {
2331               /* We have a duplicated uid */
2332               kbnode_t sig1,last;
2333
2334               any=1;
2335
2336               /* Now take uid2's signatures, and attach them to
2337                  uid1 */
2338               for(last=uid2;last->next;last=last->next)
2339                 {
2340                   if(is_deleted_kbnode(last))
2341                     continue;
2342
2343                   if(last->next->pkt->pkttype==PKT_USER_ID
2344                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
2345                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
2346                     break;
2347                 }
2348
2349               /* Snip out uid2 */
2350               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
2351
2352               /* Now put uid2 in place as part of uid1 */
2353               last->next=uid1->next;
2354               uid1->next=uid2;
2355               delete_kbnode(uid2);
2356
2357               /* Now dedupe uid1 */
2358               for(sig1=uid1->next;sig1;sig1=sig1->next)
2359                 {
2360                   kbnode_t sig2;
2361
2362                   if(is_deleted_kbnode(sig1))
2363                     continue;
2364
2365                   if(sig1->pkt->pkttype==PKT_USER_ID
2366                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
2367                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
2368                     break;
2369
2370                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
2371                     continue;
2372
2373                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
2374                     {
2375                       if(is_deleted_kbnode(sig2))
2376                         continue;
2377
2378                       if(sig2->pkt->pkttype==PKT_USER_ID
2379                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
2380                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
2381                         break;
2382
2383                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
2384                         continue;
2385
2386                       if(cmp_signatures(sig1->pkt->pkt.signature,
2387                                         sig2->pkt->pkt.signature)==0)
2388                         {
2389                           /* We have a match, so delete the second
2390                              signature */
2391                           delete_kbnode(sig2);
2392                           sig2=last;
2393                         }
2394                     }
2395                 }
2396             }
2397         }
2398     }
2399
2400   commit_kbnode(keyblock);
2401
2402   if(any && !opt.quiet)
2403     {
2404       const char *key="???";
2405
2406       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
2407         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2408       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
2409         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2410
2411       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
2412     }
2413
2414   return any;
2415 }
2416
2417
2418 /* Check for a 0x20 revocation from a revocation key that is not
2419    present.  This may be called without the benefit of merge_xxxx so
2420    you can't rely on pk->revkey and friends. */
2421 static void
2422 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
2423 {
2424   kbnode_t onode, inode;
2425   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2426
2427   for(onode=keyblock->next;onode;onode=onode->next)
2428     {
2429       /* If we reach user IDs, we're done. */
2430       if(onode->pkt->pkttype==PKT_USER_ID)
2431         break;
2432
2433       if(onode->pkt->pkttype==PKT_SIGNATURE &&
2434          onode->pkt->pkt.signature->sig_class==0x1F &&
2435          onode->pkt->pkt.signature->revkey)
2436         {
2437           int idx;
2438           PKT_signature *sig=onode->pkt->pkt.signature;
2439
2440           for(idx=0;idx<sig->numrevkeys;idx++)
2441             {
2442               u32 keyid[2];
2443
2444               keyid_from_fingerprint(sig->revkey[idx].fpr,
2445                                      MAX_FINGERPRINT_LEN,keyid);
2446
2447               for(inode=keyblock->next;inode;inode=inode->next)
2448                 {
2449                   /* If we reach user IDs, we're done. */
2450                   if(inode->pkt->pkttype==PKT_USER_ID)
2451                     break;
2452
2453                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
2454                      inode->pkt->pkt.signature->sig_class==0x20 &&
2455                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
2456                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
2457                     {
2458                       /* Okay, we have a revocation key, and a
2459                          revocation issued by it.  Do we have the key
2460                          itself? */
2461                       int rc;
2462
2463                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx].fpr,
2464                                                    MAX_FINGERPRINT_LEN);
2465                       if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2466                           || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2467                         {
2468                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
2469
2470                           /* No, so try and get it */
2471                           if(opt.keyserver
2472                              && (opt.keyserver_options.options
2473                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
2474                             {
2475                               log_info(_("WARNING: key %s may be revoked:"
2476                                          " fetching revocation key %s\n"),
2477                                        tempkeystr,keystr(keyid));
2478                               keyserver_import_fprint (ctrl,
2479                                                        sig->revkey[idx].fpr,
2480                                                        MAX_FINGERPRINT_LEN,
2481                                                        opt.keyserver);
2482
2483                               /* Do we have it now? */
2484                               rc=get_pubkey_byfprint_fast (NULL,
2485                                                      sig->revkey[idx].fpr,
2486                                                      MAX_FINGERPRINT_LEN);
2487                             }
2488
2489                           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
2490                               || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
2491                             log_info(_("WARNING: key %s may be revoked:"
2492                                        " revocation key %s not present.\n"),
2493                                      tempkeystr,keystr(keyid));
2494
2495                           xfree(tempkeystr);
2496                         }
2497                     }
2498                 }
2499             }
2500         }
2501     }
2502 }
2503
2504
2505 /*
2506  * compare and merge the blocks
2507  *
2508  * o compare the signatures: If we already have this signature, check
2509  *   that they compare okay; if not, issue a warning and ask the user.
2510  * o Simply add the signature.  Can't verify here because we may not have
2511  *   the signature's public key yet; verification is done when putting it
2512  *   into the trustdb, which is done automagically as soon as this pubkey
2513  *   is used.
2514  * Note: We indicate newly inserted packets with flag bit 0
2515  */
2516 static int
2517 merge_blocks (const char *fname, kbnode_t keyblock_orig, kbnode_t keyblock,
2518               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
2519 {
2520   kbnode_t onode, node;
2521   int rc, found;
2522
2523   /* 1st: handle revocation certificates */
2524   for (node=keyblock->next; node; node=node->next )
2525     {
2526       if (node->pkt->pkttype == PKT_USER_ID )
2527         break;
2528       else if (node->pkt->pkttype == PKT_SIGNATURE
2529                && node->pkt->pkt.signature->sig_class == 0x20)
2530         {
2531           /* check whether we already have this */
2532           found = 0;
2533           for (onode=keyblock_orig->next; onode; onode=onode->next)
2534             {
2535               if (onode->pkt->pkttype == PKT_USER_ID )
2536                 break;
2537               else if (onode->pkt->pkttype == PKT_SIGNATURE
2538                        && onode->pkt->pkt.signature->sig_class == 0x20
2539                        && !cmp_signatures(onode->pkt->pkt.signature,
2540                                           node->pkt->pkt.signature))
2541                 {
2542                   found = 1;
2543                   break;
2544                 }
2545             }
2546           if (!found)
2547             {
2548               kbnode_t n2 = clone_kbnode(node);
2549               insert_kbnode( keyblock_orig, n2, 0 );
2550               n2->flag |= 1;
2551               ++*n_sigs;
2552               if(!opt.quiet)
2553                 {
2554                   char *p=get_user_id_native (keyid);
2555                   log_info(_("key %s: \"%s\" revocation"
2556                              " certificate added\n"), keystr(keyid),p);
2557                   xfree(p);
2558                 }
2559             }
2560         }
2561     }
2562
2563   /* 2nd: merge in any direct key (0x1F) sigs */
2564   for(node=keyblock->next; node; node=node->next)
2565     {
2566       if (node->pkt->pkttype == PKT_USER_ID )
2567         break;
2568       else if (node->pkt->pkttype == PKT_SIGNATURE
2569                && node->pkt->pkt.signature->sig_class == 0x1F)
2570         {
2571           /* check whether we already have this */
2572           found = 0;
2573           for (onode=keyblock_orig->next; onode; onode=onode->next)
2574             {
2575               if (onode->pkt->pkttype == PKT_USER_ID)
2576                 break;
2577               else if (onode->pkt->pkttype == PKT_SIGNATURE
2578                        && onode->pkt->pkt.signature->sig_class == 0x1F
2579                        && !cmp_signatures(onode->pkt->pkt.signature,
2580                                           node->pkt->pkt.signature))
2581                 {
2582                   found = 1;
2583                   break;
2584                 }
2585             }
2586           if (!found )
2587             {
2588               kbnode_t n2 = clone_kbnode(node);
2589               insert_kbnode( keyblock_orig, n2, 0 );
2590               n2->flag |= 1;
2591               ++*n_sigs;
2592               if(!opt.quiet)
2593                 log_info( _("key %s: direct key signature added\n"),
2594                           keystr(keyid));
2595             }
2596         }
2597     }
2598
2599   /* 3rd: try to merge new certificates in */
2600   for (onode=keyblock_orig->next; onode; onode=onode->next)
2601     {
2602       if (!(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID)
2603         {
2604           /* find the user id in the imported keyblock */
2605           for (node=keyblock->next; node; node=node->next)
2606             if (node->pkt->pkttype == PKT_USER_ID
2607                 && !cmp_user_ids( onode->pkt->pkt.user_id,
2608                                   node->pkt->pkt.user_id ) )
2609               break;
2610           if (node ) /* found: merge */
2611             {
2612               rc = merge_sigs( onode, node, n_sigs, fname, keyid );
2613               if (rc )
2614                 return rc;
2615             }
2616         }
2617     }
2618
2619   /* 4th: add new user-ids */
2620   for (node=keyblock->next; node; node=node->next)
2621     {
2622       if (node->pkt->pkttype == PKT_USER_ID)
2623         {
2624           /* do we have this in the original keyblock */
2625           for (onode=keyblock_orig->next; onode; onode=onode->next )
2626             if (onode->pkt->pkttype == PKT_USER_ID
2627                 && !cmp_user_ids( onode->pkt->pkt.user_id,
2628                                   node->pkt->pkt.user_id ) )
2629               break;
2630           if (!onode ) /* this is a new user id: append */
2631             {
2632               rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
2633               if (rc )
2634                 return rc;
2635               ++*n_uids;
2636             }
2637         }
2638     }
2639
2640   /* 5th: add new subkeys */
2641   for (node=keyblock->next; node; node=node->next)
2642     {
2643       onode = NULL;
2644       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2645         {
2646           /* do we have this in the original keyblock? */
2647           for(onode=keyblock_orig->next; onode; onode=onode->next)
2648             if (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2649                 && !cmp_public_keys( onode->pkt->pkt.public_key,
2650                                      node->pkt->pkt.public_key))
2651               break;
2652           if (!onode ) /* This is a new subkey: append.  */
2653             {
2654               rc = append_key (keyblock_orig, node, n_sigs, fname, keyid);
2655               if (rc)
2656                 return rc;
2657               ++*n_subk;
2658             }
2659         }
2660       else if (node->pkt->pkttype == PKT_SECRET_SUBKEY)
2661         {
2662           /* do we have this in the original keyblock? */
2663           for (onode=keyblock_orig->next; onode; onode=onode->next )
2664             if (onode->pkt->pkttype == PKT_SECRET_SUBKEY
2665                 && !cmp_public_keys (onode->pkt->pkt.public_key,
2666                                      node->pkt->pkt.public_key) )
2667               break;
2668           if (!onode ) /* This is a new subkey: append.  */
2669             {
2670               rc = append_key (keyblock_orig, node, n_sigs, fname, keyid);
2671               if (rc )
2672                 return rc;
2673               ++*n_subk;
2674             }
2675         }
2676     }
2677
2678   /* 6th: merge subkey certificates */
2679   for (onode=keyblock_orig->next; onode; onode=onode->next)
2680     {
2681       if (!(onode->flag & 1)
2682           && (onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2683               || onode->pkt->pkttype == PKT_SECRET_SUBKEY))
2684         {
2685           /* find the subkey in the imported keyblock */
2686           for(node=keyblock->next; node; node=node->next)
2687             {
2688               if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2689                    || node->pkt->pkttype == PKT_SECRET_SUBKEY)
2690                   && !cmp_public_keys( onode->pkt->pkt.public_key,
2691                                        node->pkt->pkt.public_key ) )
2692                 break;
2693             }
2694           if (node) /* Found: merge.  */
2695             {
2696               rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
2697               if (rc )
2698                 return rc;
2699             }
2700         }
2701     }
2702
2703   return 0;
2704 }
2705
2706
2707 /*
2708  * Append the userid starting with NODE and all signatures to KEYBLOCK.
2709  */
2710 static int
2711 append_uid (kbnode_t keyblock, kbnode_t node, int *n_sigs,
2712             const char *fname, u32 *keyid )
2713 {
2714   kbnode_t n;
2715   kbnode_t n_where = NULL;
2716
2717   (void)fname;
2718   (void)keyid;
2719
2720   assert(node->pkt->pkttype == PKT_USER_ID );
2721
2722   /* find the position */
2723   for (n = keyblock; n; n_where = n, n = n->next)
2724     {
2725       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2726           || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2727         break;
2728     }
2729   if (!n)
2730     n_where = NULL;
2731
2732   /* and append/insert */
2733   while (node)
2734     {
2735       /* we add a clone to the original keyblock, because this
2736        * one is released first */
2737       n = clone_kbnode(node);
2738       if (n_where)
2739         {
2740           insert_kbnode( n_where, n, 0 );
2741           n_where = n;
2742         }
2743       else
2744         add_kbnode( keyblock, n );
2745       n->flag |= 1;
2746       node->flag |= 1;
2747       if (n->pkt->pkttype == PKT_SIGNATURE )
2748         ++*n_sigs;
2749
2750       node = node->next;
2751       if (node && node->pkt->pkttype != PKT_SIGNATURE )
2752         break;
2753     }
2754
2755   return 0;
2756 }
2757
2758
2759 /*
2760  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2761  * (how should we handle comment packets here?)
2762  */
2763 static int
2764 merge_sigs (kbnode_t dst, kbnode_t src, int *n_sigs,
2765             const char *fname, u32 *keyid)
2766 {
2767   kbnode_t n, n2;
2768   int found = 0;
2769
2770   (void)fname;
2771   (void)keyid;
2772
2773   assert(dst->pkt->pkttype == PKT_USER_ID );
2774   assert(src->pkt->pkttype == PKT_USER_ID );
2775
2776   for (n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next)
2777     {
2778       if (n->pkt->pkttype != PKT_SIGNATURE )
2779         continue;
2780       if (n->pkt->pkt.signature->sig_class == 0x18
2781           || n->pkt->pkt.signature->sig_class == 0x28 )
2782         continue; /* skip signatures which are only valid on subkeys */
2783
2784       found = 0;
2785       for (n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2786         if (!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2787           {
2788             found++;
2789             break;
2790           }
2791       if (!found )
2792         {
2793           /* This signature is new or newer, append N to DST.
2794            * We add a clone to the original keyblock, because this
2795            * one is released first */
2796           n2 = clone_kbnode(n);
2797           insert_kbnode( dst, n2, PKT_SIGNATURE );
2798           n2->flag |= 1;
2799           n->flag |= 1;
2800           ++*n_sigs;
2801         }
2802     }
2803
2804   return 0;
2805 }
2806
2807
2808 /*
2809  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2810  */
2811 static int
2812 merge_keysigs (kbnode_t dst, kbnode_t src, int *n_sigs,
2813                const char *fname, u32 *keyid)
2814 {
2815   kbnode_t n, n2;
2816   int found = 0;
2817
2818   (void)fname;
2819   (void)keyid;
2820
2821   assert (dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2822           || dst->pkt->pkttype == PKT_SECRET_SUBKEY);
2823
2824   for (n=src->next; n ; n = n->next)
2825     {
2826       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2827           || n->pkt->pkttype == PKT_PUBLIC_KEY )
2828         break;
2829       if (n->pkt->pkttype != PKT_SIGNATURE )
2830         continue;
2831
2832       found = 0;
2833       for (n2=dst->next; n2; n2 = n2->next)
2834         {
2835           if (n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2836               || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2837             break;
2838           if (n2->pkt->pkttype == PKT_SIGNATURE
2839               && (n->pkt->pkt.signature->keyid[0]
2840                   == n2->pkt->pkt.signature->keyid[0])
2841               && (n->pkt->pkt.signature->keyid[1]
2842                   == n2->pkt->pkt.signature->keyid[1])
2843               && (n->pkt->pkt.signature->timestamp
2844                   <= n2->pkt->pkt.signature->timestamp)
2845               && (n->pkt->pkt.signature->sig_class
2846                   == n2->pkt->pkt.signature->sig_class))
2847             {
2848               found++;
2849               break;
2850             }
2851         }
2852       if (!found )
2853         {
2854           /* This signature is new or newer, append N to DST.
2855            * We add a clone to the original keyblock, because this
2856            * one is released first */
2857           n2 = clone_kbnode(n);
2858           insert_kbnode( dst, n2, PKT_SIGNATURE );
2859           n2->flag |= 1;
2860           n->flag |= 1;
2861           ++*n_sigs;
2862         }
2863     }
2864
2865   return 0;
2866 }
2867
2868
2869 /*
2870  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
2871  * Mark all new and copied packets by setting flag bit 0.
2872  */
2873 static int
2874 append_key (kbnode_t keyblock, kbnode_t node, int *n_sigs,
2875             const char *fname, u32 *keyid)
2876 {
2877   kbnode_t n;
2878
2879   (void)fname;
2880   (void)keyid;
2881
2882   assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2883           || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2884
2885   while (node)
2886     {
2887       /* we add a clone to the original keyblock, because this
2888        * one is released first */
2889       n = clone_kbnode(node);
2890       add_kbnode( keyblock, n );
2891       n->flag |= 1;
2892       node->flag |= 1;
2893       if (n->pkt->pkttype == PKT_SIGNATURE )
2894         ++*n_sigs;
2895
2896       node = node->next;
2897       if (node && node->pkt->pkttype != PKT_SIGNATURE )
2898         break;
2899     }
2900
2901   return 0;
2902 }