Make use of the *_NAME etc macros.
[gnupg.git] / g10 / import.c
1 /* import.c - import a key into our key storage.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3  *               2007, 2010, 2011 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "gpg.h"
29 #include "options.h"
30 #include "packet.h"
31 #include "status.h"
32 #include "keydb.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "main.h"
36 #include "i18n.h"
37 #include "ttyio.h"
38 #include "status.h"
39 #include "keyserver-internal.h"
40 #include "call-agent.h"
41 #include "../common/membuf.h"
42
43 struct stats_s {
44     ulong count;
45     ulong no_user_id;
46     ulong imported;
47     ulong imported_rsa;
48     ulong n_uids;
49     ulong n_sigs;
50     ulong n_subk;
51     ulong unchanged;
52     ulong n_revoc;
53     ulong secret_read;
54     ulong secret_imported;
55     ulong secret_dups;
56     ulong skipped_new_keys;
57     ulong not_imported;
58     ulong n_sigs_cleaned;
59     ulong n_uids_cleaned;
60 };
61
62
63 static int import (ctrl_t ctrl,
64                    IOBUF inp, const char* fname, struct stats_s *stats,
65                    unsigned char **fpr, size_t *fpr_len, unsigned int options);
66 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
67 static void revocation_present (ctrl_t ctrl, kbnode_t keyblock);
68 static int import_one (ctrl_t ctrl,
69                        const char *fname, KBNODE keyblock,struct stats_s *stats,
70                        unsigned char **fpr,size_t *fpr_len,
71                        unsigned int options,int from_sk);
72 static int import_secret_one (ctrl_t ctrl, const char *fname, KBNODE keyblock,
73                               struct stats_s *stats, unsigned int options);
74 static int import_revoke_cert( const char *fname, KBNODE node,
75                                struct stats_s *stats);
76 static int chk_self_sigs( const char *fname, KBNODE keyblock,
77                           PKT_public_key *pk, u32 *keyid, int *non_self );
78 static int delete_inv_parts( const char *fname, KBNODE keyblock,
79                              u32 *keyid, unsigned int options );
80 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
81                          KBNODE keyblock, u32 *keyid,
82                          int *n_uids, int *n_sigs, int *n_subk );
83 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
84                              const char *fname, u32 *keyid );
85 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
86                              const char *fname, u32 *keyid );
87 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
88                              const char *fname, u32 *keyid );
89 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
90                              const char *fname, u32 *keyid );
91
92 int
93 parse_import_options(char *str,unsigned int *options,int noisy)
94 {
95   struct parse_options import_opts[]=
96     {
97       {"import-local-sigs",IMPORT_LOCAL_SIGS,NULL,
98        N_("import signatures that are marked as local-only")},
99       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,
100        N_("repair damage from the pks keyserver during import")},
101       {"fast-import",IMPORT_FAST,NULL,
102        N_("do not update the trustdb after import")},
103       {"merge-only",IMPORT_MERGE_ONLY,NULL,
104        N_("only accept updates to existing keys")},
105       {"import-clean",IMPORT_CLEAN,NULL,
106        N_("remove unusable parts from key after import")},
107       {"import-minimal",IMPORT_MINIMAL|IMPORT_CLEAN,NULL,
108        N_("remove as much as possible from key after import")},
109       /* Aliases for backward compatibility */
110       {"allow-local-sigs",IMPORT_LOCAL_SIGS,NULL,NULL},
111       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL,NULL},
112       /* dummy */
113       {"import-unusable-sigs",0,NULL,NULL},
114       {"import-clean-sigs",0,NULL,NULL},
115       {"import-clean-uids",0,NULL,NULL},
116       {"convert-sk-to-pk",0, NULL,NULL}, /* Not anymore needed due to
117                                             the new design.  */
118       {NULL,0,NULL,NULL}
119     };
120
121   return parse_options(str,options,import_opts,noisy);
122 }
123
124 void *
125 import_new_stats_handle (void)
126 {
127     return xmalloc_clear ( sizeof (struct stats_s) );
128 }
129
130 void
131 import_release_stats_handle (void *p)
132 {
133     xfree (p);
134 }
135
136 /****************
137  * Import the public keys from the given filename. Input may be armored.
138  * This function rejects all keys which are not validly self signed on at
139  * least one userid. Only user ids which are self signed will be imported.
140  * Other signatures are not checked.
141  *
142  * Actually this function does a merge. It works like this:
143  *
144  *  - get the keyblock
145  *  - check self-signatures and remove all userids and their signatures
146  *    without/invalid self-signatures.
147  *  - reject the keyblock, if we have no valid userid.
148  *  - See whether we have this key already in one of our pubrings.
149  *    If not, simply add it to the default keyring.
150  *  - Compare the key and the self-signatures of the new and the one in
151  *    our keyring.  If they are different something weird is going on;
152  *    ask what to do.
153  *  - See whether we have only non-self-signature on one user id; if not
154  *    ask the user what to do.
155  *  - compare the signatures: If we already have this signature, check
156  *    that they compare okay; if not, issue a warning and ask the user.
157  *    (consider looking at the timestamp and use the newest?)
158  *  - Simply add the signature.  Can't verify here because we may not have
159  *    the signature's public key yet; verification is done when putting it
160  *    into the trustdb, which is done automagically as soon as this pubkey
161  *    is used.
162  *  - Proceed with next signature.
163  *
164  *  Key revocation certificates have special handling.
165  *
166  */
167 static int
168 import_keys_internal (ctrl_t ctrl, iobuf_t inp, char **fnames, int nnames,
169                       void *stats_handle, unsigned char **fpr, size_t *fpr_len,
170                       unsigned int options )
171 {
172     int i, rc = 0;
173     struct stats_s *stats = stats_handle;
174
175     if (!stats)
176         stats = import_new_stats_handle ();
177
178     if (inp) {
179       rc = import (ctrl, inp, "[stream]", stats, fpr, fpr_len, options);
180     }
181     else {
182         if( !fnames && !nnames )
183             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
184
185         for(i=0; i < nnames; i++ ) {
186             const char *fname = fnames? fnames[i] : NULL;
187             IOBUF inp2 = iobuf_open(fname);
188             if( !fname )
189                 fname = "[stdin]";
190             if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
191               {
192                 iobuf_close (inp2);
193                 inp2 = NULL;
194                 gpg_err_set_errno (EPERM);
195               }
196             if( !inp2 )
197                 log_error(_("can't open '%s': %s\n"), fname, strerror(errno) );
198             else
199               {
200                 rc = import (ctrl, inp2, fname, stats, fpr, fpr_len, options);
201                 iobuf_close(inp2);
202                 /* Must invalidate that ugly cache to actually close it. */
203                 iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
204                              0, (char*)fname);
205                 if( rc )
206                   log_error("import from '%s' failed: %s\n", fname,
207                             g10_errstr(rc) );
208               }
209             if( !fname )
210                 break;
211         }
212     }
213     if (!stats_handle) {
214         import_print_stats (stats);
215         import_release_stats_handle (stats);
216     }
217
218     /* If no fast import and the trustdb is dirty (i.e. we added a key
219        or userID that had something other than a selfsig, a signature
220        that was other than a selfsig, or any revocation), then
221        update/check the trustdb if the user specified by setting
222        interactive or by not setting no-auto-check-trustdb */
223
224     if(!(options&IMPORT_FAST))
225       trustdb_check_or_update();
226
227     return rc;
228 }
229
230 void
231 import_keys (ctrl_t ctrl, char **fnames, int nnames,
232              void *stats_handle, unsigned int options )
233 {
234   import_keys_internal (ctrl, NULL, fnames, nnames, stats_handle,
235                         NULL, NULL, options);
236 }
237
238 int
239 import_keys_stream (ctrl_t ctrl, IOBUF inp, void *stats_handle,
240                     unsigned char **fpr, size_t *fpr_len,unsigned int options)
241 {
242   return import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
243                                fpr, fpr_len, options);
244 }
245
246
247 /* Variant of import_keys_stream reading from an estream_t.  */
248 int
249 import_keys_es_stream (ctrl_t ctrl, estream_t fp, void *stats_handle,
250                        unsigned char **fpr, size_t *fpr_len,
251                        unsigned int options)
252 {
253   int rc;
254   iobuf_t inp;
255
256   inp = iobuf_esopen (fp, "r", 1);
257   if (!inp)
258     {
259       rc = gpg_error_from_syserror ();
260       log_error ("iobuf_esopen failed: %s\n", gpg_strerror (rc));
261       return rc;
262     }
263
264   rc = import_keys_internal (ctrl, inp, NULL, 0, stats_handle,
265                              fpr, fpr_len, options);
266
267   iobuf_close (inp);
268   return rc;
269 }
270
271
272 static int
273 import (ctrl_t ctrl, IOBUF inp, const char* fname,struct stats_s *stats,
274         unsigned char **fpr,size_t *fpr_len,unsigned int options )
275 {
276     PACKET *pending_pkt = NULL;
277     KBNODE keyblock = NULL;  /* Need to initialize because gcc can't
278                                 grasp the return semantics of
279                                 read_block. */
280     int rc = 0;
281
282     getkey_disable_caches();
283
284     if( !opt.no_armor ) { /* armored reading is not disabled */
285         armor_filter_context_t *afx;
286
287         afx = new_armor_context ();
288         afx->only_keyblocks = 1;
289         push_armor_filter (afx, inp);
290         release_armor_context (afx);
291     }
292
293     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
294         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
295           rc = import_one (ctrl, fname, keyblock,
296                            stats, fpr, fpr_len, options, 0);
297         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY )
298           rc = import_secret_one (ctrl, fname, keyblock, stats, options);
299         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
300                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
301             rc = import_revoke_cert( fname, keyblock, stats );
302         else {
303             log_info( _("skipping block of type %d\n"),
304                                             keyblock->pkt->pkttype );
305         }
306         release_kbnode(keyblock);
307         /* fixme: we should increment the not imported counter but this
308            does only make sense if we keep on going despite of errors. */
309         if( rc )
310             break;
311         if( !(++stats->count % 100) && !opt.quiet )
312             log_info(_("%lu keys processed so far\n"), stats->count );
313     }
314     if( rc == -1 )
315         rc = 0;
316     else if( rc && rc != G10ERR_INV_KEYRING )
317         log_error( _("error reading '%s': %s\n"), fname, g10_errstr(rc));
318
319     return rc;
320 }
321
322
323 void
324 import_print_stats (void *hd)
325 {
326     struct stats_s *stats = hd;
327
328     if( !opt.quiet ) {
329         log_info(_("Total number processed: %lu\n"), stats->count );
330         if( stats->skipped_new_keys )
331             log_info(_("      skipped new keys: %lu\n"),
332                                                 stats->skipped_new_keys );
333         if( stats->no_user_id )
334             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
335         if( stats->imported || stats->imported_rsa ) {
336             log_info(_("              imported: %lu"), stats->imported );
337             if (stats->imported_rsa)
338               log_printf ("  (RSA: %lu)", stats->imported_rsa );
339             log_printf ("\n");
340         }
341         if( stats->unchanged )
342             log_info(_("             unchanged: %lu\n"), stats->unchanged );
343         if( stats->n_uids )
344             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
345         if( stats->n_subk )
346             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
347         if( stats->n_sigs )
348             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
349         if( stats->n_revoc )
350             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
351         if( stats->secret_read )
352             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
353         if( stats->secret_imported )
354             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
355         if( stats->secret_dups )
356             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
357         if( stats->not_imported )
358             log_info(_("          not imported: %lu\n"), stats->not_imported );
359         if( stats->n_sigs_cleaned)
360             log_info(_("    signatures cleaned: %lu\n"),stats->n_sigs_cleaned);
361         if( stats->n_uids_cleaned)
362             log_info(_("      user IDs cleaned: %lu\n"),stats->n_uids_cleaned);
363     }
364
365     if( is_status_enabled() ) {
366         char buf[14*20];
367         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
368                 stats->count,
369                 stats->no_user_id,
370                 stats->imported,
371                 stats->imported_rsa,
372                 stats->unchanged,
373                 stats->n_uids,
374                 stats->n_subk,
375                 stats->n_sigs,
376                 stats->n_revoc,
377                 stats->secret_read,
378                 stats->secret_imported,
379                 stats->secret_dups,
380                 stats->skipped_new_keys,
381                 stats->not_imported );
382         write_status_text( STATUS_IMPORT_RES, buf );
383     }
384 }
385
386
387 /* 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
796     /* get the key and print some info about it */
797     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
798     if( !node )
799         BUG();
800
801     pk = node->pkt->pkt.public_key;
802
803     keyid_from_pk( pk, keyid );
804     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
805
806     if( opt.verbose && !opt.interactive )
807       {
808         log_info( "pub  %4u%c/%s %s  ",
809                   nbits_from_pk( pk ),
810                   pubkey_letter( pk->pubkey_algo ),
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_ECDH)
1264         {
1265           /* We need special treatment for ECC algorithms.  OpenPGP
1266              stores only the curve name but the agent expects a full
1267              key.  This is so that we can keep all curve name
1268              validation code out of gpg-agent.  */
1269 #if PUBKEY_MAX_NSKEY < 7
1270 #error  PUBKEY_MAX_NSKEY too low for ECC
1271 #endif
1272           char *curve = openpgp_oid_to_str (pk->pkey[0]);
1273           if (!curve)
1274             err = gpg_error_from_syserror ();
1275           else
1276             {
1277               gcry_sexp_t cparam = gcry_pk_get_param (GCRY_PK_ECDSA, curve);
1278
1279               xfree (curve);
1280               if (!cparam)
1281                 err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1282               else
1283                 {
1284                   const char *s;
1285
1286                   /* Append the curve parameters P, A, B, G and N.  */
1287                   for (i=j=0; !err && *(s = "pabgn"+i); i++)
1288                     {
1289                       ecc_params[i] = one_mpi_from_pkey (cparam, s, 1);
1290                       if (!ecc_params[i])
1291                         err = gpg_error (GPG_ERR_INV_CURVE);
1292                       else
1293                         {
1294                           put_membuf_str (&mbuf, " _ %m");
1295                           format_args[j++] = ecc_params+i;
1296                         }
1297                     }
1298                   gcry_sexp_release (cparam);
1299                   if (!err)
1300                     {
1301                       /* Append the public key element Q.  */
1302                       put_membuf_str (&mbuf, " _ %m");
1303                       format_args[j++] = pk->pkey + 1;
1304
1305                       /* Append the secret key element D.  Note that
1306                          for ECDH we need to skip PKEY[2] because this
1307                          holds the KEK which is not needed.  */
1308                       i = pk->pubkey_algo == PUBKEY_ALGO_ECDH? 3 : 2;
1309                       if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
1310                         {
1311                           put_membuf_str (&mbuf, " e %b");
1312                           format_args_buf_ptr[i]
1313                             = gcry_mpi_get_opaque (pk->pkey[i],&n);
1314                           format_args_buf_int[i] = (n+7)/8;
1315                           format_args[j++] = format_args_buf_int + i;
1316                           format_args[j++] = format_args_buf_ptr + i;
1317                         }
1318                       else
1319                         {
1320                           put_membuf_str (&mbuf, " _ %m");
1321                           format_args[j++] = pk->pkey + i;
1322                         }
1323                     }
1324                 }
1325             }
1326         }
1327       else
1328         {
1329           /* Standard case for the old (non-ECC) algorithms.  */
1330           for (i=j=0; i < nskey; i++)
1331             {
1332               if (!pk->pkey[i])
1333                 ; /* Protected keys only have NPKEY+1 elements.  */
1334               else if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
1335                 {
1336                   put_membuf_str (&mbuf, " e %b");
1337                   format_args_buf_ptr[i] = gcry_mpi_get_opaque (pk->pkey[i],&n);
1338                   format_args_buf_int[i] = (n+7)/8;
1339                   format_args[j++] = format_args_buf_int + i;
1340                   format_args[j++] = format_args_buf_ptr + i;
1341                 }
1342               else
1343                 {
1344                   put_membuf_str (&mbuf, " _ %m");
1345                   format_args[j++] = pk->pkey + i;
1346                 }
1347             }
1348         }
1349       put_membuf_str (&mbuf, ")\n");
1350       put_membuf (&mbuf, "", 1);
1351       if (err)
1352         xfree (get_membuf (&mbuf, NULL));
1353       else
1354         {
1355           char *format = get_membuf (&mbuf, NULL);
1356           if (!format)
1357             err = gpg_error_from_syserror ();
1358           else
1359             err = gcry_sexp_build_array (&skey, NULL, format, format_args);
1360           xfree (format);
1361         }
1362       if (err)
1363         {
1364           log_error ("error building skey array: %s\n", gpg_strerror (err));
1365           goto leave;
1366         }
1367
1368       if (ski->is_protected)
1369         {
1370           char countbuf[35];
1371
1372           /* Note that the IVLEN may be zero if we are working on a
1373              dummy key.  We can't express that in an S-expression and
1374              thus we send dummy data for the IV.  */
1375           snprintf (countbuf, sizeof countbuf, "%lu",
1376                     (unsigned long)ski->s2k.count);
1377           err = gcry_sexp_build
1378             (&prot, NULL,
1379              " (protection %s %s %b %d %s %b %s)\n",
1380              ski->sha1chk? "sha1":"sum",
1381              openpgp_cipher_algo_name (ski->algo),
1382              ski->ivlen? (int)ski->ivlen:1,
1383              ski->ivlen? ski->iv: (const unsigned char*)"X",
1384              ski->s2k.mode,
1385              openpgp_md_algo_name (ski->s2k.hash_algo),
1386              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
1387              countbuf);
1388         }
1389       else
1390         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
1391
1392       tmpsexp = NULL;
1393       xfree (transferkey);
1394       transferkey = NULL;
1395       if (!err)
1396         err = gcry_sexp_build (&tmpsexp, NULL,
1397                                "(openpgp-private-key\n"
1398                                " (version %d)\n"
1399                                " (algo %s)\n"
1400                                " %S\n"
1401                                " (csum %d)\n"
1402                                " %S)\n",
1403                                pk->version,
1404                                openpgp_pk_algo_name (pk->pubkey_algo),
1405                                skey, (int)(unsigned long)ski->csum, prot);
1406       gcry_sexp_release (skey);
1407       gcry_sexp_release (prot);
1408       if (!err)
1409         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
1410       gcry_sexp_release (tmpsexp);
1411       if (err)
1412         {
1413           log_error ("error building transfer key: %s\n", gpg_strerror (err));
1414           goto leave;
1415         }
1416
1417       /* Wrap the key.  */
1418       wrappedkeylen = transferkeylen + 8;
1419       xfree (wrappedkey);
1420       wrappedkey = xtrymalloc (wrappedkeylen);
1421       if (!wrappedkey)
1422         err = gpg_error_from_syserror ();
1423       else
1424         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
1425                                    transferkey, transferkeylen);
1426       if (err)
1427         goto leave;
1428       xfree (transferkey);
1429       transferkey = NULL;
1430
1431       /* Send the wrapped key to the agent.  */
1432       {
1433         char *desc = gpg_format_keydesc (pk, 1, 1);
1434         err = agent_import_key (ctrl, desc, &cache_nonce,
1435                                 wrappedkey, wrappedkeylen, opt.batch);
1436         xfree (desc);
1437       }
1438       if (!err)
1439         {
1440           if (opt.verbose)
1441             log_info (_("key %s: secret key imported\n"),
1442                       keystr_from_pk_with_sub (main_pk, pk));
1443           stats->secret_imported++;
1444         }
1445       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
1446         {
1447           if (opt.verbose)
1448             log_info (_("key %s: secret key already exists\n"),
1449                       keystr_from_pk_with_sub (main_pk, pk));
1450           err = 0;
1451           stats->secret_dups++;
1452         }
1453       else
1454         {
1455           log_error (_("key %s: error sending to agent: %s\n"),
1456                      keystr_from_pk_with_sub (main_pk, pk),
1457                      gpg_strerror (err));
1458           if (gpg_err_code (err) == GPG_ERR_CANCELED
1459               || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1460             break; /* Don't try the other subkeys.  */
1461         }
1462     }
1463
1464  leave:
1465   for (i=0; i < DIM (ecc_params); i++)
1466     gcry_mpi_release (ecc_params[i]);
1467   xfree (cache_nonce);
1468   xfree (wrappedkey);
1469   xfree (transferkey);
1470   gcry_cipher_close (cipherhd);
1471   xfree (kek);
1472   return err;
1473 }
1474
1475
1476 /* Walk a secret keyblock and produce a public keyblock out of it.
1477    Returns a new node or NULL on error. */
1478 static kbnode_t
1479 sec_to_pub_keyblock (kbnode_t sec_keyblock)
1480 {
1481   kbnode_t pub_keyblock = NULL;
1482   kbnode_t ctx = NULL;
1483   kbnode_t secnode, pubnode;
1484
1485   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
1486     {
1487       if (secnode->pkt->pkttype == PKT_SECRET_KEY
1488           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
1489         {
1490           /* Make a public key.  */
1491           PACKET *pkt;
1492           PKT_public_key *pk;
1493
1494           pkt = xtrycalloc (1, sizeof *pkt);
1495           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
1496           if (!pk)
1497             {
1498               xfree (pkt);
1499               release_kbnode (pub_keyblock);
1500               return NULL;
1501             }
1502           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
1503             pkt->pkttype = PKT_PUBLIC_KEY;
1504           else
1505             pkt->pkttype = PKT_PUBLIC_SUBKEY;
1506           pkt->pkt.public_key = pk;
1507
1508           pubnode = new_kbnode (pkt);
1509         }
1510       else
1511         {
1512           pubnode = clone_kbnode (secnode);
1513         }
1514
1515       if (!pub_keyblock)
1516         pub_keyblock = pubnode;
1517       else
1518         add_kbnode (pub_keyblock, pubnode);
1519     }
1520
1521   return pub_keyblock;
1522 }
1523
1524 /****************
1525  * Ditto for secret keys.  Handling is simpler than for public keys.
1526  * We allow secret key importing only when allow is true, this is so
1527  * that a secret key can not be imported accidently and thereby tampering
1528  * with the trust calculation.
1529  */
1530 static int
1531 import_secret_one (ctrl_t ctrl, const char *fname, KBNODE keyblock,
1532                    struct stats_s *stats, unsigned int options)
1533 {
1534   PKT_public_key *pk;
1535   struct seckey_info *ski;
1536   KBNODE node, uidnode;
1537   u32 keyid[2];
1538   int rc = 0;
1539   int nr_prev;
1540   kbnode_t pub_keyblock;
1541
1542   /* Get the key and print some info about it */
1543   node = find_kbnode (keyblock, PKT_SECRET_KEY);
1544   if (!node)
1545     BUG ();
1546
1547   pk = node->pkt->pkt.public_key;
1548
1549   keyid_from_pk (pk, keyid);
1550   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
1551
1552   if (opt.verbose)
1553     {
1554       log_info ("sec  %4u%c/%s %s   ",
1555                 nbits_from_pk (pk),
1556                 pubkey_letter (pk->pubkey_algo),
1557                 keystr_from_pk (pk), datestr_from_pk (pk));
1558       if (uidnode)
1559         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
1560                            uidnode->pkt->pkt.user_id->len);
1561       log_printf ("\n");
1562     }
1563   stats->secret_read++;
1564
1565   if (!uidnode)
1566     {
1567       log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
1568       return 0;
1569     }
1570
1571   ski = pk->seckey_info;
1572   if (!ski)
1573     {
1574       /* Actually an internal error.  */
1575       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
1576       return 0;
1577     }
1578
1579   /* A quick check to not import keys with an invalid protection
1580      cipher algorithm (only checks the primary key, though).  */
1581   if (ski->algo > 110)
1582     {
1583       log_error (_("key %s: secret key with invalid cipher %d"
1584                    " - skipped\n"), keystr_from_pk (pk), ski->algo);
1585       return 0;
1586     }
1587
1588 #ifdef ENABLE_SELINUX_HACKS
1589   if (1)
1590     {
1591       /* We don't allow to import secret keys because that may be used
1592          to put a secret key into the keyring and the user might later
1593          be tricked into signing stuff with that key.  */
1594       log_error (_("importing secret keys not allowed\n"));
1595       return 0;
1596     }
1597 #endif
1598
1599   clear_kbnode_flags (keyblock);
1600
1601   nr_prev = stats->skipped_new_keys;
1602
1603   /* Make a public key out of the key. */
1604   pub_keyblock = sec_to_pub_keyblock (keyblock);
1605   if (!pub_keyblock)
1606     log_error ("key %s: failed to create public key from secret key\n",
1607                    keystr_from_pk (pk));
1608   else
1609     {
1610       /* Note that this outputs an IMPORT_OK status message for the
1611          public key block, and below we will output another one for
1612          the secret keys.  FIXME?  */
1613       import_one (ctrl, fname, pub_keyblock, stats,
1614                   NULL, NULL, options, 1);
1615
1616       /* Fixme: We should check for an invalid keyblock and
1617          cancel the secret key import in this case.  */
1618       release_kbnode (pub_keyblock);
1619
1620       /* At least we cancel the secret key import when the public key
1621          import was skipped due to MERGE_ONLY option and a new
1622          key.  */
1623       if (stats->skipped_new_keys <= nr_prev)
1624         {
1625           /* Read the keyblock again to get the effects of a merge.  */
1626           /* Fixme: we should do this based on the fingerprint or
1627              even better let import_one return the merged
1628              keyblock.  */
1629           node = get_pubkeyblock (keyid);
1630           if (!node)
1631             log_error ("key %s: failed to re-lookup public key\n",
1632                        keystr_from_pk (pk));
1633           else
1634             {
1635               nr_prev = stats->secret_imported;
1636               if (!transfer_secret_keys (ctrl, stats, keyblock))
1637                 {
1638                   int status = 16;
1639                   if (!opt.quiet)
1640                     log_info (_("key %s: secret key imported\n"),
1641                               keystr_from_pk (pk));
1642                   if (stats->secret_imported > nr_prev)
1643                     status |= 1;
1644                   if (is_status_enabled ())
1645                     print_import_ok (pk, status);
1646                   check_prefs (ctrl, node);
1647                 }
1648               release_kbnode (node);
1649             }
1650         }
1651     }
1652
1653   return rc;
1654 }
1655
1656
1657 /****************
1658  * Import a revocation certificate; this is a single signature packet.
1659  */
1660 static int
1661 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1662 {
1663     PKT_public_key *pk=NULL;
1664     KBNODE onode, keyblock = NULL;
1665     KEYDB_HANDLE hd = NULL;
1666     u32 keyid[2];
1667     int rc = 0;
1668
1669     (void)fname;
1670
1671     assert( !node->next );
1672     assert( node->pkt->pkttype == PKT_SIGNATURE );
1673     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1674
1675     keyid[0] = node->pkt->pkt.signature->keyid[0];
1676     keyid[1] = node->pkt->pkt.signature->keyid[1];
1677
1678     pk = xmalloc_clear( sizeof *pk );
1679     rc = get_pubkey( pk, keyid );
1680     if( rc == G10ERR_NO_PUBKEY )
1681       {
1682         log_error(_("key %s: no public key -"
1683                     " can't apply revocation certificate\n"), keystr(keyid));
1684         rc = 0;
1685         goto leave;
1686       }
1687     else if( rc )
1688       {
1689         log_error(_("key %s: public key not found: %s\n"),
1690                   keystr(keyid), g10_errstr(rc));
1691         goto leave;
1692       }
1693
1694     /* read the original keyblock */
1695     hd = keydb_new ();
1696     {
1697         byte afp[MAX_FINGERPRINT_LEN];
1698         size_t an;
1699
1700         fingerprint_from_pk (pk, afp, &an);
1701         while (an < MAX_FINGERPRINT_LEN)
1702             afp[an++] = 0;
1703         rc = keydb_search_fpr (hd, afp);
1704     }
1705     if (rc)
1706       {
1707         log_error (_("key %s: can't locate original keyblock: %s\n"),
1708                    keystr(keyid), g10_errstr(rc));
1709         goto leave;
1710       }
1711     rc = keydb_get_keyblock (hd, &keyblock );
1712     if (rc)
1713       {
1714         log_error (_("key %s: can't read original keyblock: %s\n"),
1715                    keystr(keyid), g10_errstr(rc));
1716         goto leave;
1717       }
1718
1719     /* it is okay, that node is not in keyblock because
1720      * check_key_signature works fine for sig_class 0x20 in this
1721      * special case. */
1722     rc = check_key_signature( keyblock, node, NULL);
1723     if( rc )
1724       {
1725         log_error( _("key %s: invalid revocation certificate"
1726                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1727         goto leave;
1728       }
1729
1730     /* check whether we already have this */
1731     for(onode=keyblock->next; onode; onode=onode->next ) {
1732         if( onode->pkt->pkttype == PKT_USER_ID )
1733             break;
1734         else if( onode->pkt->pkttype == PKT_SIGNATURE
1735                  && !cmp_signatures(node->pkt->pkt.signature,
1736                                     onode->pkt->pkt.signature))
1737           {
1738             rc = 0;
1739             goto leave; /* yes, we already know about it */
1740           }
1741     }
1742
1743
1744     /* insert it */
1745     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1746
1747     /* and write the keyblock back */
1748     rc = keydb_update_keyblock (hd, keyblock );
1749     if (rc)
1750         log_error (_("error writing keyring '%s': %s\n"),
1751                    keydb_get_resource_name (hd), g10_errstr(rc) );
1752     keydb_release (hd); hd = NULL;
1753     /* we are ready */
1754     if( !opt.quiet )
1755       {
1756         char *p=get_user_id_native (keyid);
1757         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1758                   keystr(keyid),p);
1759         xfree(p);
1760       }
1761     stats->n_revoc++;
1762
1763     /* If the key we just revoked was ultimately trusted, remove its
1764        ultimate trust.  This doesn't stop the user from putting the
1765        ultimate trust back, but is a reasonable solution for now. */
1766     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1767       clear_ownertrusts(pk);
1768
1769     revalidation_mark ();
1770
1771   leave:
1772     keydb_release (hd);
1773     release_kbnode( keyblock );
1774     free_public_key( pk );
1775     return rc;
1776 }
1777
1778
1779 /*
1780  * Loop over the keyblock and check all self signatures.
1781  * Mark all user-ids with a self-signature by setting flag bit 0.
1782  * Mark all user-ids with an invalid self-signature by setting bit 1.
1783  * This works also for subkeys, here the subkey is marked.  Invalid or
1784  * extra subkey sigs (binding or revocation) are marked for deletion.
1785  * non_self is set to true if there are any sigs other than self-sigs
1786  * in this keyblock.
1787  */
1788 static int
1789 chk_self_sigs (const char *fname, kbnode_t keyblock,
1790                PKT_public_key *pk, u32 *keyid, int *non_self )
1791 {
1792   kbnode_t n, knode = NULL;
1793   PKT_signature *sig;
1794   int rc;
1795   u32 bsdate=0, rsdate=0;
1796   kbnode_t bsnode = NULL, rsnode = NULL;
1797
1798   (void)fname;
1799   (void)pk;
1800
1801   for (n=keyblock; (n = find_next_kbnode (n, 0)); )
1802     {
1803       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1804         {
1805           knode = n;
1806           bsdate = 0;
1807           rsdate = 0;
1808           bsnode = NULL;
1809           rsnode = NULL;
1810           continue;
1811         }
1812
1813       if ( n->pkt->pkttype != PKT_SIGNATURE )
1814         continue;
1815
1816       sig = n->pkt->pkt.signature;
1817       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
1818         {
1819           *non_self = 1;
1820           continue;
1821         }
1822
1823       /* This just caches the sigs for later use.  That way we
1824          import a fully-cached key which speeds things up. */
1825       if (!opt.no_sig_cache)
1826         check_key_signature (keyblock, n, NULL);
1827
1828       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1829         {
1830           KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1831           if ( !unode )
1832             {
1833               log_error( _("key %s: no user ID for signature\n"),
1834                          keystr(keyid));
1835               return -1;  /* The complete keyblock is invalid.  */
1836             }
1837
1838           /* If it hasn't been marked valid yet, keep trying.  */
1839           if (!(unode->flag&1))
1840             {
1841               rc = check_key_signature (keyblock, n, NULL);
1842               if ( rc )
1843                 {
1844                   if ( opt.verbose )
1845                     {
1846                       char *p = utf8_to_native
1847                         (unode->pkt->pkt.user_id->name,
1848                          strlen (unode->pkt->pkt.user_id->name),0);
1849                       log_info (gpg_err_code(rc) == G10ERR_PUBKEY_ALGO ?
1850                                 _("key %s: unsupported public key "
1851                                   "algorithm on user ID \"%s\"\n"):
1852                                 _("key %s: invalid self-signature "
1853                                   "on user ID \"%s\"\n"),
1854                                 keystr (keyid),p);
1855                       xfree (p);
1856                     }
1857                 }
1858               else
1859                 unode->flag |= 1; /* Mark that signature checked. */
1860             }
1861         }
1862       else if (IS_KEY_SIG (sig))
1863         {
1864           rc = check_key_signature (keyblock, n, NULL);
1865           if ( rc )
1866             {
1867               if (opt.verbose)
1868                 log_info (gpg_err_code (rc) == G10ERR_PUBKEY_ALGO ?
1869                           _("key %s: unsupported public key algorithm\n"):
1870                           _("key %s: invalid direct key signature\n"),
1871                           keystr (keyid));
1872               n->flag |= 4;
1873             }
1874         }
1875       else if ( IS_SUBKEY_SIG (sig) )
1876         {
1877           /* Note that this works based solely on the timestamps like
1878              the rest of gpg.  If the standard gets revocation
1879              targets, this may need to be revised.  */
1880
1881           if ( !knode )
1882             {
1883               if (opt.verbose)
1884                 log_info (_("key %s: no subkey for key binding\n"),
1885                           keystr (keyid));
1886               n->flag |= 4; /* delete this */
1887             }
1888           else
1889             {
1890               rc = check_key_signature (keyblock, n, NULL);
1891               if ( rc )
1892                 {
1893                   if (opt.verbose)
1894                     log_info (gpg_err_code (rc) == G10ERR_PUBKEY_ALGO ?
1895                               _("key %s: unsupported public key"
1896                                 " algorithm\n"):
1897                               _("key %s: invalid subkey binding\n"),
1898                               keystr (keyid));
1899                   n->flag |= 4;
1900                 }
1901               else
1902                 {
1903                   /* It's valid, so is it newer? */
1904                   if (sig->timestamp >= bsdate)
1905                     {
1906                       knode->flag |= 1;  /* The subkey is valid.  */
1907                       if (bsnode)
1908                         {
1909                           /* Delete the last binding sig since this
1910                              one is newer */
1911                           bsnode->flag |= 4;
1912                           if (opt.verbose)
1913                             log_info (_("key %s: removed multiple subkey"
1914                                         " binding\n"),keystr(keyid));
1915                         }
1916
1917                       bsnode = n;
1918                       bsdate = sig->timestamp;
1919                     }
1920                   else
1921                     n->flag |= 4; /* older */
1922                 }
1923             }
1924         }
1925       else if ( IS_SUBKEY_REV (sig) )
1926         {
1927           /* We don't actually mark the subkey as revoked right now,
1928              so just check that the revocation sig is the most recent
1929              valid one.  Note that we don't care if the binding sig is
1930              newer than the revocation sig.  See the comment in
1931              getkey.c:merge_selfsigs_subkey for more.  */
1932           if ( !knode )
1933             {
1934               if (opt.verbose)
1935                 log_info (_("key %s: no subkey for key revocation\n"),
1936                           keystr(keyid));
1937               n->flag |= 4; /* delete this */
1938             }
1939           else
1940             {
1941               rc = check_key_signature (keyblock, n, NULL);
1942               if ( rc )
1943                 {
1944                   if(opt.verbose)
1945                     log_info (gpg_err_code (rc) == G10ERR_PUBKEY_ALGO ?
1946                               _("key %s: unsupported public"
1947                                 " key algorithm\n"):
1948                               _("key %s: invalid subkey revocation\n"),
1949                               keystr(keyid));
1950                   n->flag |= 4;
1951                 }
1952               else
1953                 {
1954                   /* It's valid, so is it newer? */
1955                   if (sig->timestamp >= rsdate)
1956                     {
1957                       if (rsnode)
1958                         {
1959                           /* Delete the last revocation sig since
1960                              this one is newer.  */
1961                           rsnode->flag |= 4;
1962                           if (opt.verbose)
1963                             log_info (_("key %s: removed multiple subkey"
1964                                         " revocation\n"),keystr(keyid));
1965                         }
1966
1967                       rsnode = n;
1968                       rsdate = sig->timestamp;
1969                     }
1970                   else
1971                     n->flag |= 4; /* older */
1972                 }
1973             }
1974         }
1975     }
1976
1977   return 0;
1978 }
1979
1980
1981 /****************
1982  * delete all parts which are invalid and those signatures whose
1983  * public key algorithm is not available in this implemenation;
1984  * but consider RSA as valid, because parse/build_packets knows
1985  * about it.
1986  * returns: true if at least one valid user-id is left over.
1987  */
1988 static int
1989 delete_inv_parts( const char *fname, KBNODE keyblock,
1990                   u32 *keyid, unsigned int options)
1991 {
1992     KBNODE node;
1993     int nvalid=0, uid_seen=0, subkey_seen=0;
1994
1995     (void)fname;
1996
1997     for(node=keyblock->next; node; node = node->next ) {
1998         if( node->pkt->pkttype == PKT_USER_ID ) {
1999             uid_seen = 1;
2000             if( (node->flag & 2) || !(node->flag & 1) ) {
2001                 if( opt.verbose )
2002                   {
2003                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
2004                                            node->pkt->pkt.user_id->len,0);
2005                     log_info( _("key %s: skipped user ID \"%s\"\n"),
2006                               keystr(keyid),p);
2007                     xfree(p);
2008                   }
2009                 delete_kbnode( node ); /* the user-id */
2010                 /* and all following packets up to the next user-id */
2011                 while( node->next
2012                        && node->next->pkt->pkttype != PKT_USER_ID
2013                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
2014                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
2015                     delete_kbnode( node->next );
2016                     node = node->next;
2017                 }
2018             }
2019             else
2020                 nvalid++;
2021         }
2022         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2023                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2024             if( (node->flag & 2) || !(node->flag & 1) ) {
2025                 if( opt.verbose )
2026                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
2027
2028                 delete_kbnode( node ); /* the subkey */
2029                 /* and all following signature packets */
2030                 while( node->next
2031                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
2032                     delete_kbnode( node->next );
2033                     node = node->next;
2034                 }
2035             }
2036             else
2037               subkey_seen = 1;
2038         }
2039         else if (node->pkt->pkttype == PKT_SIGNATURE
2040                 && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
2041                 && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
2042             delete_kbnode( node ); /* build_packet() can't handle this */
2043         else if( node->pkt->pkttype == PKT_SIGNATURE &&
2044                  !node->pkt->pkt.signature->flags.exportable &&
2045                  !(options&IMPORT_LOCAL_SIGS) &&
2046                  !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
2047           {
2048             /* here we violate the rfc a bit by still allowing
2049              * to import non-exportable signature when we have the
2050              * the secret key used to create this signature - it
2051              * seems that this makes sense */
2052             if(opt.verbose)
2053               log_info( _("key %s: non exportable signature"
2054                           " (class 0x%02X) - skipped\n"),
2055                         keystr(keyid), node->pkt->pkt.signature->sig_class );
2056             delete_kbnode( node );
2057           }
2058         else if( node->pkt->pkttype == PKT_SIGNATURE
2059                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
2060             if( uid_seen )
2061               {
2062                 if(opt.verbose)
2063                   log_info( _("key %s: revocation certificate"
2064                               " at wrong place - skipped\n"),keystr(keyid));
2065                 delete_kbnode( node );
2066               }
2067             else {
2068               /* If the revocation cert is from a different key than
2069                  the one we're working on don't check it - it's
2070                  probably from a revocation key and won't be
2071                  verifiable with this key anyway. */
2072
2073               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
2074                  node->pkt->pkt.signature->keyid[1]==keyid[1])
2075                 {
2076                   int rc = check_key_signature( keyblock, node, NULL);
2077                   if( rc )
2078                     {
2079                       if(opt.verbose)
2080                         log_info( _("key %s: invalid revocation"
2081                                     " certificate: %s - skipped\n"),
2082                                   keystr(keyid), g10_errstr(rc));
2083                       delete_kbnode( node );
2084                     }
2085                 }
2086             }
2087         }
2088         else if( node->pkt->pkttype == PKT_SIGNATURE &&
2089                  (node->pkt->pkt.signature->sig_class == 0x18 ||
2090                   node->pkt->pkt.signature->sig_class == 0x28) &&
2091                  !subkey_seen )
2092           {
2093             if(opt.verbose)
2094               log_info( _("key %s: subkey signature"
2095                           " in wrong place - skipped\n"), keystr(keyid));
2096             delete_kbnode( node );
2097           }
2098         else if( node->pkt->pkttype == PKT_SIGNATURE
2099                  && !IS_CERT(node->pkt->pkt.signature))
2100           {
2101             if(opt.verbose)
2102               log_info(_("key %s: unexpected signature class (0x%02X) -"
2103                          " skipped\n"),keystr(keyid),
2104                        node->pkt->pkt.signature->sig_class);
2105             delete_kbnode(node);
2106           }
2107         else if( (node->flag & 4) ) /* marked for deletion */
2108           delete_kbnode( node );
2109     }
2110
2111     /* note: because keyblock is the public key, it is never marked
2112      * for deletion and so keyblock cannot change */
2113     commit_kbnode( &keyblock );
2114     return nvalid;
2115 }
2116
2117
2118 /****************
2119  * It may happen that the imported keyblock has duplicated user IDs.
2120  * We check this here and collapse those user IDs together with their
2121  * sigs into one.
2122  * Returns: True if the keyblock has changed.
2123  */
2124 int
2125 collapse_uids( KBNODE *keyblock )
2126 {
2127   KBNODE uid1;
2128   int any=0;
2129
2130   for(uid1=*keyblock;uid1;uid1=uid1->next)
2131     {
2132       KBNODE uid2;
2133
2134       if(is_deleted_kbnode(uid1))
2135         continue;
2136
2137       if(uid1->pkt->pkttype!=PKT_USER_ID)
2138         continue;
2139
2140       for(uid2=uid1->next;uid2;uid2=uid2->next)
2141         {
2142           if(is_deleted_kbnode(uid2))
2143             continue;
2144
2145           if(uid2->pkt->pkttype!=PKT_USER_ID)
2146             continue;
2147
2148           if(cmp_user_ids(uid1->pkt->pkt.user_id,
2149                           uid2->pkt->pkt.user_id)==0)
2150             {
2151               /* We have a duplicated uid */
2152               KBNODE sig1,last;
2153
2154               any=1;
2155
2156               /* Now take uid2's signatures, and attach them to
2157                  uid1 */
2158               for(last=uid2;last->next;last=last->next)
2159                 {
2160                   if(is_deleted_kbnode(last))
2161                     continue;
2162
2163                   if(last->next->pkt->pkttype==PKT_USER_ID
2164                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
2165                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
2166                     break;
2167                 }
2168
2169               /* Snip out uid2 */
2170               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
2171
2172               /* Now put uid2 in place as part of uid1 */
2173               last->next=uid1->next;
2174               uid1->next=uid2;
2175               delete_kbnode(uid2);
2176
2177               /* Now dedupe uid1 */
2178               for(sig1=uid1->next;sig1;sig1=sig1->next)
2179                 {
2180                   KBNODE sig2;
2181
2182                   if(is_deleted_kbnode(sig1))
2183                     continue;
2184
2185                   if(sig1->pkt->pkttype==PKT_USER_ID
2186                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
2187                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
2188                     break;
2189
2190                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
2191                     continue;
2192
2193                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
2194                     {
2195                       if(is_deleted_kbnode(sig2))
2196                         continue;
2197
2198                       if(sig2->pkt->pkttype==PKT_USER_ID
2199                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
2200                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
2201                         break;
2202
2203                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
2204                         continue;
2205
2206                       if(cmp_signatures(sig1->pkt->pkt.signature,
2207                                         sig2->pkt->pkt.signature)==0)
2208                         {
2209                           /* We have a match, so delete the second
2210                              signature */
2211                           delete_kbnode(sig2);
2212                           sig2=last;
2213                         }
2214                     }
2215                 }
2216             }
2217         }
2218     }
2219
2220   commit_kbnode(keyblock);
2221
2222   if(any && !opt.quiet)
2223     {
2224       const char *key="???";
2225
2226       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
2227         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2228       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
2229         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2230
2231       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
2232     }
2233
2234   return any;
2235 }
2236
2237 /* Check for a 0x20 revocation from a revocation key that is not
2238    present.  This may be called without the benefit of merge_xxxx so
2239    you can't rely on pk->revkey and friends. */
2240 static void
2241 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
2242 {
2243   kbnode_t onode, inode;
2244   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2245
2246   for(onode=keyblock->next;onode;onode=onode->next)
2247     {
2248       /* If we reach user IDs, we're done. */
2249       if(onode->pkt->pkttype==PKT_USER_ID)
2250         break;
2251
2252       if(onode->pkt->pkttype==PKT_SIGNATURE &&
2253          onode->pkt->pkt.signature->sig_class==0x1F &&
2254          onode->pkt->pkt.signature->revkey)
2255         {
2256           int idx;
2257           PKT_signature *sig=onode->pkt->pkt.signature;
2258
2259           for(idx=0;idx<sig->numrevkeys;idx++)
2260             {
2261               u32 keyid[2];
2262
2263               keyid_from_fingerprint(sig->revkey[idx]->fpr,
2264                                      MAX_FINGERPRINT_LEN,keyid);
2265
2266               for(inode=keyblock->next;inode;inode=inode->next)
2267                 {
2268                   /* If we reach user IDs, we're done. */
2269                   if(inode->pkt->pkttype==PKT_USER_ID)
2270                     break;
2271
2272                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
2273                      inode->pkt->pkt.signature->sig_class==0x20 &&
2274                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
2275                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
2276                     {
2277                       /* Okay, we have a revocation key, and a
2278                          revocation issued by it.  Do we have the key
2279                          itself? */
2280                       int rc;
2281
2282                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
2283                                                    MAX_FINGERPRINT_LEN);
2284                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
2285                         {
2286                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
2287
2288                           /* No, so try and get it */
2289                           if(opt.keyserver
2290                              && (opt.keyserver_options.options
2291                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
2292                             {
2293                               log_info(_("WARNING: key %s may be revoked:"
2294                                          " fetching revocation key %s\n"),
2295                                        tempkeystr,keystr(keyid));
2296                               keyserver_import_fprint (ctrl,
2297                                                        sig->revkey[idx]->fpr,
2298                                                        MAX_FINGERPRINT_LEN,
2299                                                        opt.keyserver);
2300
2301                               /* Do we have it now? */
2302                               rc=get_pubkey_byfprint_fast (NULL,
2303                                                      sig->revkey[idx]->fpr,
2304                                                      MAX_FINGERPRINT_LEN);
2305                             }
2306
2307                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
2308                             log_info(_("WARNING: key %s may be revoked:"
2309                                        " revocation key %s not present.\n"),
2310                                      tempkeystr,keystr(keyid));
2311
2312                           xfree(tempkeystr);
2313                         }
2314                     }
2315                 }
2316             }
2317         }
2318     }
2319 }
2320
2321 /****************
2322  * compare and merge the blocks
2323  *
2324  * o compare the signatures: If we already have this signature, check
2325  *   that they compare okay; if not, issue a warning and ask the user.
2326  * o Simply add the signature.  Can't verify here because we may not have
2327  *   the signature's public key yet; verification is done when putting it
2328  *   into the trustdb, which is done automagically as soon as this pubkey
2329  *   is used.
2330  * Note: We indicate newly inserted packets with flag bit 0
2331  */
2332 static int
2333 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
2334               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
2335 {
2336     KBNODE onode, node;
2337     int rc, found;
2338
2339     /* 1st: handle revocation certificates */
2340     for(node=keyblock->next; node; node=node->next ) {
2341         if( node->pkt->pkttype == PKT_USER_ID )
2342             break;
2343         else if( node->pkt->pkttype == PKT_SIGNATURE
2344                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
2345             /* check whether we already have this */
2346             found = 0;
2347             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2348                 if( onode->pkt->pkttype == PKT_USER_ID )
2349                     break;
2350                 else if( onode->pkt->pkttype == PKT_SIGNATURE
2351                          && onode->pkt->pkt.signature->sig_class == 0x20
2352                          && !cmp_signatures(onode->pkt->pkt.signature,
2353                                             node->pkt->pkt.signature))
2354                   {
2355                     found = 1;
2356                     break;
2357                   }
2358             }
2359             if( !found ) {
2360                 KBNODE n2 = clone_kbnode(node);
2361                 insert_kbnode( keyblock_orig, n2, 0 );
2362                 n2->flag |= 1;
2363                 ++*n_sigs;
2364                 if(!opt.quiet)
2365                   {
2366                     char *p=get_user_id_native (keyid);
2367                     log_info(_("key %s: \"%s\" revocation"
2368                                " certificate added\n"), keystr(keyid),p);
2369                     xfree(p);
2370                   }
2371             }
2372         }
2373     }
2374
2375     /* 2nd: merge in any direct key (0x1F) sigs */
2376     for(node=keyblock->next; node; node=node->next ) {
2377         if( node->pkt->pkttype == PKT_USER_ID )
2378             break;
2379         else if( node->pkt->pkttype == PKT_SIGNATURE
2380                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
2381             /* check whether we already have this */
2382             found = 0;
2383             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2384                 if( onode->pkt->pkttype == PKT_USER_ID )
2385                     break;
2386                 else if( onode->pkt->pkttype == PKT_SIGNATURE
2387                          && onode->pkt->pkt.signature->sig_class == 0x1F
2388                          && !cmp_signatures(onode->pkt->pkt.signature,
2389                                             node->pkt->pkt.signature)) {
2390                     found = 1;
2391                     break;
2392                 }
2393             }
2394             if( !found )
2395               {
2396                 KBNODE n2 = clone_kbnode(node);
2397                 insert_kbnode( keyblock_orig, n2, 0 );
2398                 n2->flag |= 1;
2399                 ++*n_sigs;
2400                 if(!opt.quiet)
2401                   log_info( _("key %s: direct key signature added\n"),
2402                             keystr(keyid));
2403               }
2404         }
2405     }
2406
2407     /* 3rd: try to merge new certificates in */
2408     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2409         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
2410             /* find the user id in the imported keyblock */
2411             for(node=keyblock->next; node; node=node->next )
2412                 if( node->pkt->pkttype == PKT_USER_ID
2413                     && !cmp_user_ids( onode->pkt->pkt.user_id,
2414                                           node->pkt->pkt.user_id ) )
2415                     break;
2416             if( node ) { /* found: merge */
2417                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
2418                 if( rc )
2419                     return rc;
2420             }
2421         }
2422     }
2423
2424     /* 4th: add new user-ids */
2425     for(node=keyblock->next; node; node=node->next ) {
2426         if( node->pkt->pkttype == PKT_USER_ID) {
2427             /* do we have this in the original keyblock */
2428             for(onode=keyblock_orig->next; onode; onode=onode->next )
2429                 if( onode->pkt->pkttype == PKT_USER_ID
2430                     && !cmp_user_ids( onode->pkt->pkt.user_id,
2431                                       node->pkt->pkt.user_id ) )
2432                     break;
2433             if( !onode ) { /* this is a new user id: append */
2434                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
2435                 if( rc )
2436                     return rc;
2437                 ++*n_uids;
2438             }
2439         }
2440     }
2441
2442     /* 5th: add new subkeys */
2443     for(node=keyblock->next; node; node=node->next ) {
2444         onode = NULL;
2445         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2446             /* do we have this in the original keyblock? */
2447             for(onode=keyblock_orig->next; onode; onode=onode->next )
2448                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2449                     && !cmp_public_keys( onode->pkt->pkt.public_key,
2450                                          node->pkt->pkt.public_key ) )
2451                     break;
2452             if( !onode ) { /* this is a new subkey: append */
2453                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
2454                 if( rc )
2455                     return rc;
2456                 ++*n_subk;
2457             }
2458         }
2459         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2460             /* do we have this in the original keyblock? */
2461             for(onode=keyblock_orig->next; onode; onode=onode->next )
2462                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
2463                     && !cmp_public_keys (onode->pkt->pkt.public_key,
2464                                          node->pkt->pkt.public_key) )
2465                     break;
2466             if( !onode ) { /* this is a new subkey: append */
2467                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
2468                 if( rc )
2469                     return rc;
2470                 ++*n_subk;
2471             }
2472         }
2473     }
2474
2475     /* 6th: merge subkey certificates */
2476     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2477         if( !(onode->flag & 1)
2478             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2479                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
2480             /* find the subkey in the imported keyblock */
2481             for(node=keyblock->next; node; node=node->next ) {
2482                 if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2483                      || node->pkt->pkttype == PKT_SECRET_SUBKEY)
2484                     && !cmp_public_keys( onode->pkt->pkt.public_key,
2485                                           node->pkt->pkt.public_key ) )
2486                     break;
2487             }
2488             if( node ) { /* found: merge */
2489                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
2490                 if( rc )
2491                     return rc;
2492             }
2493         }
2494     }
2495
2496
2497     return 0;
2498 }
2499
2500
2501 /****************
2502  * append the userid starting with NODE and all signatures to KEYBLOCK.
2503  */
2504 static int
2505 append_uid (KBNODE keyblock, KBNODE node, int *n_sigs,
2506             const char *fname, u32 *keyid )
2507 {
2508     KBNODE n, n_where=NULL;
2509
2510     (void)fname;
2511     (void)keyid;
2512
2513     assert(node->pkt->pkttype == PKT_USER_ID );
2514
2515     /* find the position */
2516     for( n = keyblock; n; n_where = n, n = n->next ) {
2517         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2518             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2519             break;
2520     }
2521     if( !n )
2522         n_where = NULL;
2523
2524     /* and append/insert */
2525     while( node ) {
2526         /* we add a clone to the original keyblock, because this
2527          * one is released first */
2528         n = clone_kbnode(node);
2529         if( n_where ) {
2530             insert_kbnode( n_where, n, 0 );
2531             n_where = n;
2532         }
2533         else
2534             add_kbnode( keyblock, n );
2535         n->flag |= 1;
2536         node->flag |= 1;
2537         if( n->pkt->pkttype == PKT_SIGNATURE )
2538             ++*n_sigs;
2539
2540         node = node->next;
2541         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2542             break;
2543     }
2544
2545     return 0;
2546 }
2547
2548
2549 /****************
2550  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2551  * (how should we handle comment packets here?)
2552  */
2553 static int
2554 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2555                                     const char *fname, u32 *keyid )
2556 {
2557     KBNODE n, n2;
2558     int found=0;
2559
2560     (void)fname;
2561     (void)keyid;
2562
2563     assert(dst->pkt->pkttype == PKT_USER_ID );
2564     assert(src->pkt->pkttype == PKT_USER_ID );
2565
2566     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2567         if( n->pkt->pkttype != PKT_SIGNATURE )
2568             continue;
2569         if( n->pkt->pkt.signature->sig_class == 0x18
2570             || n->pkt->pkt.signature->sig_class == 0x28 )
2571             continue; /* skip signatures which are only valid on subkeys */
2572         found = 0;
2573         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2574           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2575             {
2576               found++;
2577               break;
2578             }
2579         if( !found ) {
2580             /* This signature is new or newer, append N to DST.
2581              * We add a clone to the original keyblock, because this
2582              * one is released first */
2583             n2 = clone_kbnode(n);
2584             insert_kbnode( dst, n2, PKT_SIGNATURE );
2585             n2->flag |= 1;
2586             n->flag |= 1;
2587             ++*n_sigs;
2588         }
2589     }
2590
2591     return 0;
2592 }
2593
2594 /****************
2595  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2596  */
2597 static int
2598 merge_keysigs (KBNODE dst, KBNODE src, int *n_sigs,
2599                const char *fname, u32 *keyid)
2600 {
2601     KBNODE n, n2;
2602     int found=0;
2603
2604     (void)fname;
2605     (void)keyid;
2606
2607     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2608            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2609
2610     for(n=src->next; n ; n = n->next ) {
2611         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2612             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2613             break;
2614         if( n->pkt->pkttype != PKT_SIGNATURE )
2615             continue;
2616         found = 0;
2617         for(n2=dst->next; n2; n2 = n2->next){
2618             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2619                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2620                 break;
2621             if( n2->pkt->pkttype == PKT_SIGNATURE
2622                 && n->pkt->pkt.signature->keyid[0]
2623                    == n2->pkt->pkt.signature->keyid[0]
2624                 && n->pkt->pkt.signature->keyid[1]
2625                    == n2->pkt->pkt.signature->keyid[1]
2626                 && n->pkt->pkt.signature->timestamp
2627                    <= n2->pkt->pkt.signature->timestamp
2628                 && n->pkt->pkt.signature->sig_class
2629                    == n2->pkt->pkt.signature->sig_class ) {
2630                 found++;
2631                 break;
2632             }
2633         }
2634         if( !found ) {
2635             /* This signature is new or newer, append N to DST.
2636              * We add a clone to the original keyblock, because this
2637              * one is released first */
2638             n2 = clone_kbnode(n);
2639             insert_kbnode( dst, n2, PKT_SIGNATURE );
2640             n2->flag |= 1;
2641             n->flag |= 1;
2642             ++*n_sigs;
2643         }
2644     }
2645
2646     return 0;
2647 }
2648
2649
2650 /*
2651  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
2652  * Mark all new and copied packets by setting flag bit 0.
2653  */
2654 static int
2655 append_key (KBNODE keyblock, KBNODE node, int *n_sigs,
2656             const char *fname, u32 *keyid)
2657 {
2658     KBNODE n;
2659
2660     (void)fname;
2661     (void)keyid;
2662
2663     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2664            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2665
2666     while(  node ) {
2667         /* we add a clone to the original keyblock, because this
2668          * one is released first */
2669         n = clone_kbnode(node);
2670         add_kbnode( keyblock, n );
2671         n->flag |= 1;
2672         node->flag |= 1;
2673         if( n->pkt->pkttype == PKT_SIGNATURE )
2674             ++*n_sigs;
2675
2676         node = node->next;
2677         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2678             break;
2679     }
2680
2681     return 0;
2682 }