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