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