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