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