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