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