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