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