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