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