* export.c (do_export_stream) [ENABLE_SELINUX_HACKS]: Don't allow
[gnupg.git] / g10 / import.c
1 /* import.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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 2 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28
29 #include "options.h"
30 #include "packet.h"
31 #include "errors.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "trustdb.h"
36 #include "main.h"
37 #include "i18n.h"
38 #include "ttyio.h"
39 #include "status.h"
40 #include "keyserver-internal.h"
41
42 struct stats_s {
43     ulong count;
44     ulong no_user_id;
45     ulong imported;
46     ulong imported_rsa;
47     ulong n_uids;
48     ulong n_sigs;
49     ulong n_subk;
50     ulong unchanged;
51     ulong n_revoc;
52     ulong secret_read;
53     ulong secret_imported;
54     ulong secret_dups;
55     ulong skipped_new_keys;
56     ulong not_imported;
57 };
58
59
60 static int import( IOBUF inp, const char* fname,
61                    struct stats_s *stats, unsigned int options );
62 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
63 static void revocation_present(KBNODE keyblock);
64 static int import_one( const char *fname, KBNODE keyblock,
65                        struct stats_s *stats, unsigned int options);
66 static int import_secret_one( const char *fname, KBNODE keyblock,
67                               struct stats_s *stats, unsigned int options);
68 static int import_revoke_cert( const char *fname, KBNODE node,
69                                struct stats_s *stats);
70 static int chk_self_sigs( const char *fname, KBNODE keyblock,
71                           PKT_public_key *pk, u32 *keyid, int *non_self );
72 static int delete_inv_parts( const char *fname, KBNODE keyblock,
73                              u32 *keyid, unsigned int options );
74 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
75                          KBNODE keyblock, u32 *keyid,
76                          int *n_uids, int *n_sigs, int *n_subk );
77 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
78                              const char *fname, u32 *keyid );
79 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
80                              const char *fname, u32 *keyid );
81 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
82                              const char *fname, u32 *keyid );
83 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
84                              const char *fname, u32 *keyid );
85
86 int
87 parse_import_options(char *str,unsigned int *options,int noisy)
88 {
89   struct parse_options import_opts[]=
90     {
91       {"allow-local-sigs",IMPORT_ALLOW_LOCAL_SIGS,NULL},
92       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
93       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
94       {"fast-import",IMPORT_FAST_IMPORT,NULL},
95       {"convert-sk-to-pk",IMPORT_SK2PK,NULL},
96       {"merge-only",IMPORT_MERGE_ONLY,NULL},
97       {NULL,0,NULL}
98     };
99
100   return parse_options(str,options,import_opts,noisy);
101 }
102
103 void *
104 import_new_stats_handle (void)
105 {
106     return m_alloc_clear ( sizeof (struct stats_s) );
107 }
108
109 void
110 import_release_stats_handle (void *p)
111 {
112     m_free (p);
113 }
114
115 /****************
116  * Import the public keys from the given filename. Input may be armored.
117  * This function rejects all keys which are not validly self signed on at
118  * least one userid. Only user ids which are self signed will be imported.
119  * Other signatures are not checked.
120  *
121  * Actually this function does a merge. It works like this:
122  *
123  *  - get the keyblock
124  *  - check self-signatures and remove all userids and their signatures
125  *    without/invalid self-signatures.
126  *  - reject the keyblock, if we have no valid userid.
127  *  - See whether we have this key already in one of our pubrings.
128  *    If not, simply add it to the default keyring.
129  *  - Compare the key and the self-signatures of the new and the one in
130  *    our keyring.  If they are different something weird is going on;
131  *    ask what to do.
132  *  - See whether we have only non-self-signature on one user id; if not
133  *    ask the user what to do.
134  *  - compare the signatures: If we already have this signature, check
135  *    that they compare okay; if not, issue a warning and ask the user.
136  *    (consider looking at the timestamp and use the newest?)
137  *  - Simply add the signature.  Can't verify here because we may not have
138  *    the signature's public key yet; verification is done when putting it
139  *    into the trustdb, which is done automagically as soon as this pubkey
140  *    is used.
141  *  - Proceed with next signature.
142  *
143  *  Key revocation certificates have special handling.
144  *
145  */
146 static int
147 import_keys_internal( IOBUF inp, char **fnames, int nnames,
148                       void *stats_handle, unsigned int options )
149 {
150     int i, rc = 0;
151     struct stats_s *stats = stats_handle;
152
153     if (!stats)
154         stats = import_new_stats_handle ();
155
156     if (inp) {
157         rc = import( inp, "[stream]", stats, options);
158     }
159     else {
160         if( !fnames && !nnames )
161             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
162
163         for(i=0; i < nnames; i++ ) {
164             const char *fname = fnames? fnames[i] : NULL;
165             IOBUF inp2 = iobuf_open(fname);
166             if( !fname )
167                 fname = "[stdin]";
168             if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
169               {
170                 iobuf_close (inp2);
171                 inp2 = NULL;
172                 errno = EPERM;
173               }
174             if( !inp2 )
175                 log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
176             else {
177                 rc = import( inp2, fname, stats, options );
178                 iobuf_close(inp2);
179                 /* Must invalidate that ugly cache to actually close it. */
180                 iobuf_ioctl (NULL, 2, 0, (char*)fname);
181                 if( rc )
182                     log_error("import from `%s' failed: %s\n", fname,
183                               g10_errstr(rc) );
184             }
185             if( !fname )
186                 break;
187         }
188     }
189     if (!stats_handle) {
190         import_print_stats (stats);
191         import_release_stats_handle (stats);
192     }
193     /* If no fast import and the trustdb is dirty (i.e. we added a key
194        or userID that had something other than a selfsig, a signature
195        that was other than a selfsig, or any revocation), then
196        update/check the trustdb if the user specified by setting
197        interactive or by not setting no-auto-check-trustdb */
198     if (!(options&IMPORT_FAST_IMPORT) && trustdb_pending_check())
199       {
200         if (opt.interactive)
201           update_trustdb();
202         else if (!opt.no_auto_check_trustdb)
203           check_trustdb();
204       }
205
206     return rc;
207 }
208
209 void
210 import_keys( char **fnames, int nnames,
211              void *stats_handle, unsigned int options )
212 {
213     import_keys_internal( NULL, fnames, nnames, stats_handle, options);
214 }
215
216 int
217 import_keys_stream( IOBUF inp, void *stats_handle, unsigned int options )
218 {
219     return import_keys_internal( inp, NULL, 0, stats_handle, options);
220 }
221
222 static int
223 import( IOBUF inp, const char* fname,
224         struct stats_s *stats, unsigned int options )
225 {
226     PACKET *pending_pkt = NULL;
227     KBNODE keyblock;
228     int rc = 0;
229
230     getkey_disable_caches();
231
232     if( !opt.no_armor ) { /* armored reading is not disabled */
233         armor_filter_context_t *afx = m_alloc_clear( sizeof *afx );
234         afx->only_keyblocks = 1;
235         iobuf_push_filter2( inp, armor_filter, afx, 1 );
236     }
237
238     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
239         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
240             rc = import_one( fname, keyblock, stats, options );
241         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
242                 rc = import_secret_one( fname, keyblock, stats, options );
243         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
244                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
245             rc = import_revoke_cert( fname, keyblock, stats );
246         else {
247             log_info( _("skipping block of type %d\n"),
248                                             keyblock->pkt->pkttype );
249         }
250         release_kbnode(keyblock);
251         /* fixme: we should increment the not imported counter but this
252            does only make sense if we keep on going despite of errors. */
253         if( rc )
254             break;
255         if( !(++stats->count % 100) && !opt.quiet )
256             log_info(_("%lu keys processed so far\n"), stats->count );
257     }
258     if( rc == -1 )
259         rc = 0;
260     else if( rc && rc != G10ERR_INV_KEYRING )
261         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
262
263     return rc;
264 }
265
266
267 void
268 import_print_stats (void *hd)
269 {
270     struct stats_s *stats = hd;
271
272     if( !opt.quiet ) {
273         log_info(_("Total number processed: %lu\n"), stats->count );
274         if( stats->skipped_new_keys )
275             log_info(_("      skipped new keys: %lu\n"),
276                                                 stats->skipped_new_keys );
277         if( stats->no_user_id )
278             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
279         if( stats->imported || stats->imported_rsa ) {
280             log_info(_("              imported: %lu"), stats->imported );
281             if( stats->imported_rsa )
282                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
283             putc('\n', stderr);
284         }
285         if( stats->unchanged )
286             log_info(_("             unchanged: %lu\n"), stats->unchanged );
287         if( stats->n_uids )
288             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
289         if( stats->n_subk )
290             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
291         if( stats->n_sigs )
292             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
293         if( stats->n_revoc )
294             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
295         if( stats->secret_read )
296             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
297         if( stats->secret_imported )
298             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
299         if( stats->secret_dups )
300             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
301         if( stats->not_imported )
302             log_info(_("          not imported: %lu\n"), stats->not_imported );
303     }
304
305     if( is_status_enabled() ) {
306         char buf[14*20];
307         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
308                 stats->count,
309                 stats->no_user_id,
310                 stats->imported,
311                 stats->imported_rsa,
312                 stats->unchanged,
313                 stats->n_uids,
314                 stats->n_subk,
315                 stats->n_sigs,
316                 stats->n_revoc,
317                 stats->secret_read,
318                 stats->secret_imported,
319                 stats->secret_dups,
320                 stats->skipped_new_keys,
321                 stats->not_imported );
322         write_status_text( STATUS_IMPORT_RES, buf );
323     }
324 }
325
326
327 /****************
328  * Read the next keyblock from stream A.
329  * PENDING_PKT should be initialzed to NULL
330  * and not chnaged form the caller.
331  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
332  */
333 static int
334 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
335 {
336     int rc;
337     PACKET *pkt;
338     KBNODE root = NULL;
339     int in_cert;
340
341     if( *pending_pkt ) {
342         root = new_kbnode( *pending_pkt );
343         *pending_pkt = NULL;
344         in_cert = 1;
345     }
346     else
347         in_cert = 0;
348     pkt = m_alloc( sizeof *pkt );
349     init_packet(pkt);
350     while( (rc=parse_packet(a, pkt)) != -1 ) {
351         if( rc ) {  /* ignore errors */
352             if( rc != G10ERR_UNKNOWN_PACKET ) {
353                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
354                 rc = G10ERR_INV_KEYRING;
355                 goto ready;
356             }
357             free_packet( pkt );
358             init_packet(pkt);
359             continue;
360         }
361
362         if( !root && pkt->pkttype == PKT_SIGNATURE
363                   && pkt->pkt.signature->sig_class == 0x20 ) {
364             /* this is a revocation certificate which is handled
365              * in a special way */
366             root = new_kbnode( pkt );
367             pkt = NULL;
368             goto ready;
369         }
370
371         /* make a linked list of all packets */
372         switch( pkt->pkttype ) {
373           case PKT_COMPRESSED:
374             if(check_compress_algo(pkt->pkt.compressed->algorithm))
375               {
376                 rc = G10ERR_COMPR_ALGO;
377                 goto ready;
378               }
379             else
380               {
381                 compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
382                 pkt->pkt.compressed->buf = NULL;
383                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
384               }
385             free_packet( pkt );
386             init_packet(pkt);
387             break;
388
389           case PKT_RING_TRUST:
390             /* skip those packets */
391             free_packet( pkt );
392             init_packet(pkt);
393             break;
394
395           case PKT_PUBLIC_KEY:
396           case PKT_SECRET_KEY:
397             if( in_cert ) { /* store this packet */
398                 *pending_pkt = pkt;
399                 pkt = NULL;
400                 goto ready;
401             }
402             in_cert = 1;
403           default:
404             if( in_cert ) {
405                 if( !root )
406                     root = new_kbnode( pkt );
407                 else
408                     add_kbnode( root, new_kbnode( pkt ) );
409                 pkt = m_alloc( sizeof *pkt );
410             }
411             init_packet(pkt);
412             break;
413         }
414     }
415   ready:
416     if( rc == -1 && root )
417         rc = 0;
418
419     if( rc )
420         release_kbnode( root );
421     else
422         *ret_root = root;
423     free_packet( pkt );
424     m_free( pkt );
425     return rc;
426 }
427
428 /* Walk through the subkeys on a pk to find if we have the PKS
429    disease: multiple subkeys with their binding sigs stripped, and the
430    sig for the first subkey placed after the last subkey.  That is,
431    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
432    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
433    and sub3, as they are already lost, but we can try and rescue sub1
434    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
435    sub2 sub3".  Returns TRUE if the keyblock was modified. */
436
437 static int
438 fix_pks_corruption(KBNODE keyblock)
439 {
440   int changed=0,keycount=0;
441   KBNODE node,last=NULL,sknode=NULL;
442
443   /* First determine if we have the problem at all.  Look for 2 or
444      more subkeys in a row, followed by a single binding sig. */
445   for(node=keyblock;node;last=node,node=node->next)
446     {
447       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
448         {
449           keycount++;
450           if(!sknode)
451             sknode=node;
452         }
453       else if(node->pkt->pkttype==PKT_SIGNATURE &&
454               node->pkt->pkt.signature->sig_class==0x18 &&
455               keycount>=2 && node->next==NULL)
456         {
457           /* We might have the problem, as this key has two subkeys in
458              a row without any intervening packets. */
459
460           /* Sanity check */
461           if(last==NULL)
462             break;
463
464           /* Temporarily attach node to sknode. */
465           node->next=sknode->next;
466           sknode->next=node;
467           last->next=NULL;
468
469           /* Note we aren't checking whether this binding sig is a
470              selfsig.  This is not necessary here as the subkey and
471              binding sig will be rejected later if that is the
472              case. */
473           if(check_key_signature(keyblock,node,NULL))
474             {
475               /* Not a match, so undo the changes. */
476               sknode->next=node->next;
477               last->next=node;
478               node->next=NULL;
479               break;
480             }
481           else
482             {
483               sknode->flag |= 1; /* Mark it good so we don't need to
484                                     check it again */
485               changed=1;
486               break;
487             }
488         }
489       else
490         keycount=0;
491     }
492
493   return changed;
494 }
495
496
497 static void
498 print_import_ok (PKT_public_key *pk, PKT_secret_key *sk, unsigned int reason)
499 {
500   byte array[MAX_FINGERPRINT_LEN], *s;
501   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
502   size_t i, n;
503
504   sprintf (buf, "%u ", reason);
505   p = buf + strlen (buf);
506
507   if (pk)
508     fingerprint_from_pk (pk, array, &n);
509   else
510     fingerprint_from_sk (sk, array, &n);
511   s = array;
512   for (i=0; i < n ; i++, s++, p += 2)
513     sprintf (p, "%02X", *s);
514
515   write_status_text (STATUS_IMPORT_OK, buf);
516 }
517
518 static void
519 print_import_check (PKT_public_key * pk, PKT_user_id * id)
520 {
521     char * buf;
522     byte fpr[24];
523     u32 keyid[2];
524     size_t i, pos = 0, n;
525
526     buf = m_alloc (17+41+id->len+32);
527     keyid_from_pk (pk, keyid);
528     sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
529     pos = 17;
530     fingerprint_from_pk (pk, fpr, &n);
531     for (i = 0; i < n; i++, pos += 2)
532         sprintf (buf+pos, "%02X", fpr[i]);
533     strcat (buf, " ");
534     pos += 1;
535     strcat (buf, id->name);
536     write_status_text (STATUS_IMPORT_CHECK, buf);
537     m_free (buf);
538 }
539
540 static void
541 check_prefs_warning(PKT_public_key *pk)
542 {
543   log_info(_("WARNING: key %s contains preferences for unavailable\n"),
544            keystr_from_pk(pk));
545   log_info(_("algorithms on these user IDs:\n"));
546 }
547
548 static void
549 check_prefs(KBNODE keyblock)
550 {
551   KBNODE node;
552   PKT_public_key *pk;
553   int problem=0;
554   
555   merge_keys_and_selfsig(keyblock);
556   pk=keyblock->pkt->pkt.public_key;
557
558   for(node=keyblock;node;node=node->next)
559     {
560       if(node->pkt->pkttype==PKT_USER_ID
561          && node->pkt->pkt.user_id->created
562          && node->pkt->pkt.user_id->prefs)
563         {
564           PKT_user_id *uid=node->pkt->pkt.user_id;
565           prefitem_t *prefs=uid->prefs;
566           char *user=utf8_to_native(uid->name,strlen(uid->name),0);
567
568           for(;prefs->type;prefs++)
569             {
570               char num[10]; /* prefs->value is a byte, so we're over
571                                safe here */
572
573               sprintf(num,"%u",prefs->value);
574
575               if(prefs->type==PREFTYPE_SYM)
576                 {
577                   if(check_cipher_algo(prefs->value))
578                     {
579                       const char *algo=cipher_algo_to_string(prefs->value);
580                       if(!problem)
581                         check_prefs_warning(pk);
582                       log_info(_("         \"%s\": preference for cipher"
583                                  " algorithm %s\n"),user,algo?algo:num);
584                       problem=1;
585                     }
586                 }
587               else if(prefs->type==PREFTYPE_HASH)
588                 {
589                   if(check_digest_algo(prefs->value))
590                     {
591                       const char *algo=digest_algo_to_string(prefs->value);
592                       if(!problem)
593                         check_prefs_warning(pk);
594                       log_info(_("         \"%s\": preference for digest"
595                                  " algorithm %s\n"),user,algo?algo:num);
596                       problem=1;
597                     }
598                 }
599               else if(prefs->type==PREFTYPE_ZIP)
600                 {
601                   if(check_compress_algo(prefs->value))
602                     {
603                       const char *algo=compress_algo_to_string(prefs->value);
604                       if(!problem)
605                         check_prefs_warning(pk);
606                       log_info(_("         \"%s\": preference for compression"
607                                  " algorithm %s\n"),user,algo?algo:num);
608                       problem=1;
609                     }
610                 }
611             }
612
613           m_free(user);
614         }
615     }
616
617   if(problem)
618     {
619       log_info(_("it is strongly suggested that you update"
620                  " your preferences and\n"));
621       log_info(_("re-distribute this key to avoid potential algorithm"
622                  " mismatch problems\n"));
623
624       if(!opt.batch)
625         {
626           STRLIST sl=NULL,locusr=NULL;
627           size_t fprlen=0;
628           byte fpr[MAX_FINGERPRINT_LEN],*p;
629           char username[(MAX_FINGERPRINT_LEN*2)+1];
630           unsigned int i;
631
632           p=fingerprint_from_pk(pk,fpr,&fprlen);
633           for(i=0;i<fprlen;i++,p++)
634             sprintf(username+2*i,"%02X",*p);
635           add_to_strlist(&locusr,username);
636
637           append_to_strlist(&sl,"updpref");
638           append_to_strlist(&sl,"save");
639
640           keyedit_menu( username, locusr, sl, 1, 1 );
641           free_strlist(sl);
642           free_strlist(locusr);
643         }
644       else if(!opt.quiet)
645         log_info(_("you can update your preferences with:"
646                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
647     }
648 }
649
650 /****************
651  * Try to import one keyblock.  Return an error only in serious cases, but
652  * never for an invalid keyblock.  It uses log_error to increase the
653  * internal errorcount, so that invalid input can be detected by programs
654  * which called g10.
655  */
656 static int
657 import_one( const char *fname, KBNODE keyblock,
658             struct stats_s *stats, unsigned int options )
659 {
660     PKT_public_key *pk;
661     PKT_public_key *pk_orig;
662     KBNODE node, uidnode;
663     KBNODE keyblock_orig = NULL;
664     u32 keyid[2];
665     int rc = 0;
666     int new_key = 0;
667     int mod_key = 0;
668     int non_self = 0;
669
670     /* get the key and print some info about it */
671     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
672     if( !node )
673         BUG();
674
675     pk = node->pkt->pkt.public_key;
676     keyid_from_pk( pk, keyid );
677     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
678
679     if( opt.verbose && !opt.interactive )
680       {
681         log_info( "pub  %4u%c/%s %s  ",
682                   nbits_from_pk( pk ),
683                   pubkey_letter( pk->pubkey_algo ),
684                   keystr_from_pk(pk), datestr_from_pk(pk) );
685         if( uidnode )
686           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
687                              uidnode->pkt->pkt.user_id->len );
688         putc('\n', stderr);
689       }
690
691     if( !uidnode )
692       {
693         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
694         return 0;
695       }
696     
697     if (opt.interactive) {
698         if(is_status_enabled())
699           print_import_check (pk, uidnode->pkt->pkt.user_id);
700         merge_keys_and_selfsig (keyblock);
701         tty_printf ("\n");
702         show_basic_key_info (keyblock);
703         tty_printf ("\n");
704         if (!cpr_get_answer_is_yes ("import.okay",
705                                     "Do you want to import this key? (y/N) "))
706             return 0;
707     }
708
709     clear_kbnode_flags( keyblock );
710
711     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
712        && opt.verbose)
713       log_info(_("key %s: PKS subkey corruption repaired\n"),
714                keystr_from_pk(pk));
715
716     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
717     if( rc )
718         return rc== -1? 0:rc;
719
720     /* If we allow such a thing, mark unsigned uids as valid */
721     if( opt.allow_non_selfsigned_uid )
722       for( node=keyblock; node; node = node->next )
723         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
724           {
725             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
726                                       node->pkt->pkt.user_id->len,0);
727             node->flag |= 1;
728             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
729                       keystr_from_pk(pk),user);
730             m_free(user);
731           }
732
733     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
734         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
735         if( !opt.quiet )
736           log_info(_("this may be caused by a missing self-signature\n"));
737         stats->no_user_id++;
738         return 0;
739     }
740
741     /* do we have this key already in one of our pubrings ? */
742     pk_orig = m_alloc_clear( sizeof *pk_orig );
743     rc = get_pubkey_fast ( pk_orig, keyid );
744     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
745       {
746         log_error( _("key %s: public key not found: %s\n"),
747                    keystr(keyid), g10_errstr(rc));
748       }
749     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
750       {
751         if( opt.verbose )
752           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
753         rc = 0;
754         stats->skipped_new_keys++;
755       }
756     else if( rc ) { /* insert this key */
757         KEYDB_HANDLE hd = keydb_new (0);
758
759         rc = keydb_locate_writable (hd, NULL);
760         if (rc) {
761             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
762             keydb_release (hd);
763             return G10ERR_GENERAL;
764         }
765         if( opt.verbose > 1 )
766             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
767
768         collapse_uids(&keyblock);
769
770         rc = keydb_insert_keyblock (hd, keyblock );
771         if (rc)
772            log_error (_("error writing keyring `%s': %s\n"),
773                        keydb_get_resource_name (hd), g10_errstr(rc));
774         else
775           {
776             /* This should not be possible since we delete the
777                ownertrust when a key is deleted, but it can happen if
778                the keyring and trustdb are out of sync.  It can also
779                be made to happen with the trusted-key command. */
780
781             clear_ownertrusts (pk);
782             if(non_self)
783               revalidation_mark ();
784           }
785         keydb_release (hd);
786
787         /* we are ready */
788         if( !opt.quiet )
789           {
790             char *p=get_user_id_native (keyid);
791             log_info( _("key %s: public key \"%s\" imported\n"),
792                       keystr(keyid),p);
793             m_free(p);
794           }
795         if( is_status_enabled() )
796           {
797             char *us = get_long_user_id_string( keyid );
798             write_status_text( STATUS_IMPORTED, us );
799             m_free(us);
800             print_import_ok (pk,NULL, 1);
801           }
802         stats->imported++;
803         if( is_RSA( pk->pubkey_algo ) )
804             stats->imported_rsa++;
805         new_key = 1;
806     }
807     else { /* merge */
808         KEYDB_HANDLE hd;
809         int n_uids, n_sigs, n_subk;
810
811         /* Compare the original against the new key; just to be sure nothing
812          * weird is going on */
813         if( cmp_public_keys( pk_orig, pk ) )
814           {
815             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
816             goto leave;
817           }
818
819         /* now read the original keyblock */
820         hd = keydb_new (0);
821         {
822             byte afp[MAX_FINGERPRINT_LEN];
823             size_t an;
824
825             fingerprint_from_pk (pk_orig, afp, &an);
826             while (an < MAX_FINGERPRINT_LEN) 
827                 afp[an++] = 0;
828             rc = keydb_search_fpr (hd, afp);
829         }
830         if( rc )
831           {
832             log_error (_("key %s: can't locate original keyblock: %s\n"),
833                        keystr(keyid), g10_errstr(rc));
834             keydb_release (hd);
835             goto leave;
836           }
837         rc = keydb_get_keyblock (hd, &keyblock_orig );
838         if (rc)
839           {
840             log_error (_("key %s: can't read original keyblock: %s\n"),
841                        keystr(keyid), g10_errstr(rc));
842             keydb_release (hd);
843             goto leave;
844           }
845
846         collapse_uids( &keyblock );
847         /* and try to merge the block */
848         clear_kbnode_flags( keyblock_orig );
849         clear_kbnode_flags( keyblock );
850         n_uids = n_sigs = n_subk = 0;
851         rc = merge_blocks( fname, keyblock_orig, keyblock,
852                                 keyid, &n_uids, &n_sigs, &n_subk );
853         if( rc ) {
854             keydb_release (hd);
855             goto leave;
856         }
857         if( n_uids || n_sigs || n_subk ) {
858             mod_key = 1;
859             /* keyblock_orig has been updated; write */
860             rc = keydb_update_keyblock (hd, keyblock_orig);
861             if (rc)
862                 log_error (_("error writing keyring `%s': %s\n"),
863                              keydb_get_resource_name (hd), g10_errstr(rc) );
864             else if(non_self)
865               revalidation_mark ();
866
867             /* we are ready */
868             if( !opt.quiet )
869               {
870                 char *p=get_user_id_native(keyid);
871                 if( n_uids == 1 )
872                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
873                            keystr(keyid),p);
874                 else if( n_uids )
875                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
876                             keystr(keyid),p,n_uids);
877                 if( n_sigs == 1 )
878                   log_info( _("key %s: \"%s\" 1 new signature\n"),
879                             keystr(keyid), p);
880                 else if( n_sigs )
881                   log_info( _("key %s: \"%s\" %d new signatures\n"),
882                             keystr(keyid), p, n_sigs );
883                 if( n_subk == 1 )
884                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
885                             keystr(keyid), p);
886                 else if( n_subk )
887                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
888                             keystr(keyid), p, n_subk );
889                 m_free(p);
890               }
891
892             stats->n_uids +=n_uids;
893             stats->n_sigs +=n_sigs;
894             stats->n_subk +=n_subk;
895
896             if (is_status_enabled ()) 
897                  print_import_ok (pk, NULL,
898                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
899         }
900         else
901           {
902             if (is_status_enabled ()) 
903               print_import_ok (pk, NULL, 0);
904
905             if( !opt.quiet )
906               {
907                 char *p=get_user_id_native(keyid);
908                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
909                 m_free(p);
910               }
911
912             stats->unchanged++;
913           }
914
915         keydb_release (hd); hd = NULL;
916     }
917
918   leave:
919
920     /* Now that the key is definitely incorporated into the keydb, we
921        need to check if a designated revocation is present or if the
922        prefs are not rational so we can warn the user. */
923
924     if(mod_key)
925       {
926         revocation_present(keyblock_orig);
927         if(seckey_available(keyid)==0)
928           check_prefs(keyblock_orig);
929       }
930     else if(new_key)
931       {
932         revocation_present(keyblock);
933         if(seckey_available(keyid)==0)
934           check_prefs(keyblock);
935       }
936
937     release_kbnode( keyblock_orig );
938     free_public_key( pk_orig );
939
940     return rc;
941 }
942
943 /* Walk a secret keyblock and produce a public keyblock out of it. */
944 static KBNODE
945 sec_to_pub_keyblock(KBNODE sec_keyblock)
946 {
947   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
948
949   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
950     {
951       KBNODE pubnode;
952
953       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
954          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
955         {
956           /* Make a public key.  We only need to convert enough to
957              write the keyblock out. */
958
959           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
960           PACKET *pkt=m_alloc_clear(sizeof(PACKET));
961           PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
962           int n;
963
964           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
965             pkt->pkttype=PKT_PUBLIC_KEY;
966           else
967             pkt->pkttype=PKT_PUBLIC_SUBKEY;
968
969           pkt->pkt.public_key=pk;
970
971           pk->version=sk->version;
972           pk->timestamp=sk->timestamp;
973           pk->expiredate=sk->expiredate;
974           pk->pubkey_algo=sk->pubkey_algo;
975
976           n=pubkey_get_npkey(pk->pubkey_algo);
977           if(n==0)
978             {
979               /* we can't properly extract the pubkey without knowing
980                  the number of MPIs */
981               release_kbnode(pub_keyblock);
982               return NULL;
983             }
984           else
985             {
986               int i;
987
988               for(i=0;i<n;i++)
989                 pk->pkey[i]=mpi_copy(sk->skey[i]);
990             }
991
992           pubnode=new_kbnode(pkt);
993         }
994       else
995         {
996           pubnode=clone_kbnode(secnode);
997         }
998
999       if(pub_keyblock==NULL)
1000         pub_keyblock=pubnode;
1001       else
1002         add_kbnode(pub_keyblock,pubnode);
1003     }
1004
1005   return pub_keyblock;
1006 }
1007
1008 /****************
1009  * Ditto for secret keys.  Handling is simpler than for public keys.
1010  * We allow secret key importing only when allow is true, this is so
1011  * that a secret key can not be imported accidently and thereby tampering
1012  * with the trust calculation.
1013  */
1014 static int
1015 import_secret_one( const char *fname, KBNODE keyblock, 
1016                    struct stats_s *stats, unsigned int options)
1017 {
1018     PKT_secret_key *sk;
1019     KBNODE node, uidnode;
1020     u32 keyid[2];
1021     int rc = 0;
1022
1023     /* get the key and print some info about it */
1024     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1025     if( !node )
1026         BUG();
1027
1028     sk = node->pkt->pkt.secret_key;
1029     keyid_from_sk( sk, keyid );
1030     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1031
1032     if( opt.verbose )
1033       {
1034         log_info( "sec  %4u%c/%s %s   ",
1035                   nbits_from_sk( sk ),
1036                   pubkey_letter( sk->pubkey_algo ),
1037                   keystr_from_sk(sk), datestr_from_sk(sk) );
1038         if( uidnode )
1039           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1040                              uidnode->pkt->pkt.user_id->len );
1041         putc('\n', stderr);
1042       }
1043     stats->secret_read++;
1044
1045     if( !uidnode )
1046       {
1047         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1048         return 0;
1049       }
1050
1051     if(sk->protect.algo>110)
1052       {
1053         log_error(_("key %s: secret key with invalid cipher %d"
1054                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1055         return 0;
1056       }
1057
1058 #ifdef ENABLE_SELINUX_HACKS
1059     if (1)
1060       {
1061         /* We don't allow to import secret keys because that may be used
1062            to put a secret key into the keyring and the user might later
1063            be tricked into signing stuff with that key.  */
1064         log_error (_("importing secret keys not allowed\n"));
1065         return 0;
1066       }
1067 #endif 
1068     
1069     clear_kbnode_flags( keyblock );
1070
1071     /* do we have this key already in one of our secrings ? */
1072     rc = seckey_available( keyid );
1073     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1074       {
1075         /* simply insert this key */
1076         KEYDB_HANDLE hd = keydb_new (1);
1077
1078         /* get default resource */
1079         rc = keydb_locate_writable (hd, NULL);
1080         if (rc) {
1081           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1082           keydb_release (hd);
1083           return G10ERR_GENERAL;
1084         }
1085         rc = keydb_insert_keyblock (hd, keyblock );
1086         if (rc)
1087           log_error (_("error writing keyring `%s': %s\n"),
1088                      keydb_get_resource_name (hd), g10_errstr(rc) );
1089         keydb_release (hd);
1090         /* we are ready */
1091         if( !opt.quiet )
1092           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1093         stats->secret_imported++;
1094         if (is_status_enabled ()) 
1095           print_import_ok (NULL, sk, 1|16);
1096
1097         if(options&IMPORT_SK2PK)
1098           {
1099             /* Try and make a public key out of this. */
1100
1101             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1102             if(pub_keyblock)
1103               {
1104                 import_one(fname,pub_keyblock,stats,opt.import_options);
1105                 release_kbnode(pub_keyblock);
1106               }
1107           }
1108
1109         /* Now that the key is definitely incorporated into the keydb,
1110            if we have the public part of this key, we need to check if
1111            the prefs are rational. */
1112         node=get_pubkeyblock(keyid);
1113         if(node)
1114           {
1115             check_prefs(node);
1116             release_kbnode(node);
1117           }
1118       }
1119     else if( !rc )
1120       { /* we can't merge secret keys */
1121         log_error( _("key %s: already in secret keyring\n"),
1122                    keystr_from_sk(sk));
1123         stats->secret_dups++;
1124         if (is_status_enabled ()) 
1125           print_import_ok (NULL, sk, 16);
1126
1127         /* TODO: if we ever do merge secret keys, make sure to handle
1128            the sec_to_pub_keyblock feature as well. */
1129       }
1130     else
1131       log_error( _("key %s: secret key not found: %s\n"),
1132                  keystr_from_sk(sk), g10_errstr(rc));
1133
1134     return rc;
1135 }
1136
1137
1138 /****************
1139  * Import a revocation certificate; this is a single signature packet.
1140  */
1141 static int
1142 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1143 {
1144     PKT_public_key *pk=NULL;
1145     KBNODE onode, keyblock = NULL;
1146     KEYDB_HANDLE hd = NULL;
1147     u32 keyid[2];
1148     int rc = 0;
1149
1150     assert( !node->next );
1151     assert( node->pkt->pkttype == PKT_SIGNATURE );
1152     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1153
1154     keyid[0] = node->pkt->pkt.signature->keyid[0];
1155     keyid[1] = node->pkt->pkt.signature->keyid[1];
1156
1157     pk = m_alloc_clear( sizeof *pk );
1158     rc = get_pubkey( pk, keyid );
1159     if( rc == G10ERR_NO_PUBKEY )
1160       {
1161         log_error(_("key %s: no public key -"
1162                     " can't apply revocation certificate\n"), keystr(keyid));
1163         rc = 0;
1164         goto leave;
1165       }
1166     else if( rc )
1167       {
1168         log_error(_("key %s: public key not found: %s\n"),
1169                   keystr(keyid), g10_errstr(rc));
1170         goto leave;
1171       }
1172
1173     /* read the original keyblock */
1174     hd = keydb_new (0);
1175     {
1176         byte afp[MAX_FINGERPRINT_LEN];
1177         size_t an;
1178         
1179         fingerprint_from_pk (pk, afp, &an);
1180         while (an < MAX_FINGERPRINT_LEN) 
1181             afp[an++] = 0;
1182         rc = keydb_search_fpr (hd, afp);
1183     }
1184     if (rc)
1185       {
1186         log_error (_("key %s: can't locate original keyblock: %s\n"),
1187                    keystr(keyid), g10_errstr(rc));
1188         goto leave;
1189       }
1190     rc = keydb_get_keyblock (hd, &keyblock );
1191     if (rc)
1192       {
1193         log_error (_("key %s: can't read original keyblock: %s\n"),
1194                    keystr(keyid), g10_errstr(rc));
1195         goto leave;
1196       }
1197
1198     /* it is okay, that node is not in keyblock because
1199      * check_key_signature works fine for sig_class 0x20 in this
1200      * special case. */
1201     rc = check_key_signature( keyblock, node, NULL);
1202     if( rc )
1203       {
1204         log_error( _("key %s: invalid revocation certificate"
1205                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1206         goto leave;
1207       }
1208
1209     /* check whether we already have this */
1210     for(onode=keyblock->next; onode; onode=onode->next ) {
1211         if( onode->pkt->pkttype == PKT_USER_ID )
1212             break;
1213         else if( onode->pkt->pkttype == PKT_SIGNATURE
1214                  && !cmp_signatures(node->pkt->pkt.signature,
1215                                     onode->pkt->pkt.signature))
1216           {
1217             rc = 0;
1218             goto leave; /* yes, we already know about it */
1219           }
1220     }
1221
1222
1223     /* insert it */
1224     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1225
1226     /* and write the keyblock back */
1227     rc = keydb_update_keyblock (hd, keyblock );
1228     if (rc)
1229         log_error (_("error writing keyring `%s': %s\n"),
1230                    keydb_get_resource_name (hd), g10_errstr(rc) );
1231     keydb_release (hd); hd = NULL;
1232     /* we are ready */
1233     if( !opt.quiet )
1234       {
1235         char *p=get_user_id_native (keyid);
1236         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1237                   keystr(keyid),p);
1238         m_free(p);
1239       }
1240     stats->n_revoc++;
1241
1242     /* If the key we just revoked was ultimately trusted, remove its
1243        ultimate trust.  This doesn't stop the user from putting the
1244        ultimate trust back, but is a reasonable solution for now. */
1245     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1246       clear_ownertrusts(pk);
1247
1248     revalidation_mark ();
1249
1250   leave:
1251     keydb_release (hd);
1252     release_kbnode( keyblock );
1253     free_public_key( pk );
1254     return rc;
1255 }
1256
1257
1258 /****************
1259  * loop over the keyblock and check all self signatures.
1260  * Mark all user-ids with a self-signature by setting flag bit 0.
1261  * Mark all user-ids with an invalid self-signature by setting bit 1.
1262  * This works also for subkeys, here the subkey is marked.  Invalid or
1263  * extra subkey sigs (binding or revocation) are marked for deletion.
1264  * non_self is set to true if there are any sigs other than self-sigs
1265  * in this keyblock.
1266  */
1267 static int
1268 chk_self_sigs( const char *fname, KBNODE keyblock,
1269                PKT_public_key *pk, u32 *keyid, int *non_self )
1270 {
1271     KBNODE n,knode=NULL;
1272     PKT_signature *sig;
1273     int rc;
1274     u32 bsdate=0,rsdate=0;
1275     KBNODE bsnode=NULL,rsnode=NULL;
1276
1277     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1278       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1279         {
1280           knode=n;
1281           bsdate=0;
1282           rsdate=0;
1283           bsnode=NULL;
1284           rsnode=NULL;
1285           continue;
1286         }
1287       else if( n->pkt->pkttype != PKT_SIGNATURE )
1288             continue;
1289         sig = n->pkt->pkt.signature;
1290         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1291
1292           /* This just caches the sigs for later use.  That way we
1293              import a fully-cached key which speeds things up. */
1294           if(!opt.no_sig_cache)
1295             check_key_signature(keyblock,n,NULL);
1296
1297             if( (sig->sig_class&~3) == 0x10 ) {
1298                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1299                 if( !unode )
1300                   {
1301                     log_error( _("key %s: no user ID for signature\n"),
1302                                keystr(keyid));
1303                     return -1;  /* the complete keyblock is invalid */
1304                   }
1305
1306                 /* If it hasn't been marked valid yet, keep trying */
1307                 if(!(unode->flag&1)) {
1308                   rc = check_key_signature( keyblock, n, NULL);
1309                   if( rc )
1310                     {
1311                       if( opt.verbose )
1312                         {
1313                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1314                                       strlen(unode->pkt->pkt.user_id->name),0);
1315                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1316                                     _("key %s: unsupported public key "
1317                                       "algorithm on user ID \"%s\"\n"):
1318                                     _("key %s: invalid self-signature "
1319                                       "on user ID \"%s\"\n"),
1320                                     keystr(keyid),p);
1321                           m_free(p);
1322                         }
1323                     }
1324                   else
1325                     unode->flag |= 1; /* mark that signature checked */
1326                 }
1327             }
1328             else if( sig->sig_class == 0x18 ) {
1329               /* Note that this works based solely on the timestamps
1330                  like the rest of gpg.  If the standard gets
1331                  revocation targets, this may need to be revised. */
1332
1333                 if( !knode )
1334                   {
1335                     if(opt.verbose)
1336                       log_info( _("key %s: no subkey for key binding\n"),
1337                                 keystr(keyid));
1338                     n->flag |= 4; /* delete this */
1339                   }
1340                 else
1341                   {
1342                     rc = check_key_signature( keyblock, n, NULL);
1343                     if( rc )
1344                       {
1345                         if(opt.verbose)
1346                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1347                                    _("key %s: unsupported public key"
1348                                      " algorithm\n"):
1349                                    _("key %s: invalid subkey binding\n"),
1350                                    keystr(keyid));
1351                         n->flag|=4;
1352                       }
1353                     else
1354                       {
1355                         /* It's valid, so is it newer? */
1356                         if(sig->timestamp>=bsdate) {
1357                           knode->flag |= 1;  /* the subkey is valid */
1358                           if(bsnode)
1359                             {
1360                               bsnode->flag|=4; /* Delete the last binding
1361                                                   sig since this one is
1362                                                   newer */
1363                               if(opt.verbose)
1364                                 log_info(_("key %s: removed multiple subkey"
1365                                            " binding\n"),keystr(keyid));
1366                             }
1367
1368                           bsnode=n;
1369                           bsdate=sig->timestamp;
1370                         }
1371                         else
1372                           n->flag|=4; /* older */
1373                       }
1374                   }
1375             }
1376             else if( sig->sig_class == 0x28 ) {
1377               /* We don't actually mark the subkey as revoked right
1378                  now, so just check that the revocation sig is the
1379                  most recent valid one.  Note that we don't care if
1380                  the binding sig is newer than the revocation sig.
1381                  See the comment in getkey.c:merge_selfsigs_subkey for
1382                  more */
1383                 if( !knode )
1384                   {
1385                     if(opt.verbose)
1386                       log_info( _("key %s: no subkey for key revocation\n"),
1387                                 keystr(keyid));
1388                     n->flag |= 4; /* delete this */
1389                   }
1390                 else
1391                   {
1392                     rc = check_key_signature( keyblock, n, NULL);
1393                     if( rc )
1394                       {
1395                         if(opt.verbose)
1396                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1397                                    _("key %s: unsupported public"
1398                                      " key algorithm\n"):
1399                                    _("key %s: invalid subkey revocation\n"),
1400                                    keystr(keyid));
1401                         n->flag|=4;
1402                       }
1403                     else
1404                       {
1405                         /* It's valid, so is it newer? */
1406                         if(sig->timestamp>=rsdate)
1407                           {
1408                             if(rsnode)
1409                               {
1410                                 rsnode->flag|=4; /* Delete the last revocation
1411                                                     sig since this one is
1412                                                     newer */
1413                                 if(opt.verbose)
1414                                   log_info(_("key %s: removed multiple subkey"
1415                                              " revocation\n"),keystr(keyid));
1416                               }
1417
1418                             rsnode=n;
1419                             rsdate=sig->timestamp;
1420                           }
1421                         else
1422                           n->flag|=4; /* older */
1423                       }
1424                   }
1425             }
1426         }
1427         else
1428           *non_self=1;
1429     }
1430
1431     return 0;
1432 }
1433
1434 /****************
1435  * delete all parts which are invalid and those signatures whose
1436  * public key algorithm is not available in this implemenation;
1437  * but consider RSA as valid, because parse/build_packets knows
1438  * about it.
1439  * returns: true if at least one valid user-id is left over.
1440  */
1441 static int
1442 delete_inv_parts( const char *fname, KBNODE keyblock,
1443                   u32 *keyid, unsigned int options)
1444 {
1445     KBNODE node;
1446     int nvalid=0, uid_seen=0, subkey_seen=0;
1447
1448     for(node=keyblock->next; node; node = node->next ) {
1449         if( node->pkt->pkttype == PKT_USER_ID ) {
1450             uid_seen = 1;
1451             if( (node->flag & 2) || !(node->flag & 1) ) {
1452                 if( opt.verbose )
1453                   {
1454                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1455                                            node->pkt->pkt.user_id->len,0);
1456                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1457                               keystr(keyid),p);
1458                     m_free(p);
1459                   }
1460                 delete_kbnode( node ); /* the user-id */
1461                 /* and all following packets up to the next user-id */
1462                 while( node->next
1463                        && node->next->pkt->pkttype != PKT_USER_ID
1464                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1465                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1466                     delete_kbnode( node->next );
1467                     node = node->next;
1468                 }
1469             }
1470             else
1471                 nvalid++;
1472         }
1473         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1474                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1475             if( (node->flag & 2) || !(node->flag & 1) ) {
1476                 if( opt.verbose )
1477                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1478
1479                 delete_kbnode( node ); /* the subkey */
1480                 /* and all following signature packets */
1481                 while( node->next
1482                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1483                     delete_kbnode( node->next );
1484                     node = node->next;
1485                 }
1486             }
1487             else
1488               subkey_seen = 1;
1489         }
1490         else if( node->pkt->pkttype == PKT_SIGNATURE
1491                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1492                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1493             delete_kbnode( node ); /* build_packet() can't handle this */
1494         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1495                  !node->pkt->pkt.signature->flags.exportable &&
1496                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1497                  seckey_available( node->pkt->pkt.signature->keyid ) )
1498           {
1499             /* here we violate the rfc a bit by still allowing
1500              * to import non-exportable signature when we have the
1501              * the secret key used to create this signature - it
1502              * seems that this makes sense */
1503             if(opt.verbose)
1504               log_info( _("key %s: non exportable signature"
1505                           " (class 0x%02X) - skipped\n"),
1506                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1507             delete_kbnode( node );
1508           }
1509         else if( node->pkt->pkttype == PKT_SIGNATURE
1510                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1511             if( uid_seen )
1512               {
1513                 if(opt.verbose)
1514                   log_info( _("key %s: revocation certificate"
1515                               " at wrong place - skipped\n"),keystr(keyid));
1516                 delete_kbnode( node );
1517               }
1518             else {
1519               /* If the revocation cert is from a different key than
1520                  the one we're working on don't check it - it's
1521                  probably from a revocation key and won't be
1522                  verifiable with this key anyway. */
1523
1524               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1525                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1526                 {
1527                   int rc = check_key_signature( keyblock, node, NULL);
1528                   if( rc )
1529                     {
1530                       if(opt.verbose)
1531                         log_info( _("key %s: invalid revocation"
1532                                     " certificate: %s - skipped\n"),
1533                                   keystr(keyid), g10_errstr(rc));
1534                       delete_kbnode( node );
1535                     }
1536                 }
1537             }
1538         }
1539         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1540                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1541                   node->pkt->pkt.signature->sig_class == 0x28) &&
1542                  !subkey_seen )
1543           {
1544             if(opt.verbose)
1545               log_info( _("key %s: subkey signature"
1546                           " in wrong place - skipped\n"), keystr(keyid));
1547             delete_kbnode( node );
1548           }
1549         else if( node->pkt->pkttype == PKT_SIGNATURE
1550                  && !IS_CERT(node->pkt->pkt.signature))
1551           {
1552             if(opt.verbose)
1553               log_info(_("key %s: unexpected signature class (0x%02X) -"
1554                          " skipped\n"),keystr(keyid),
1555                        node->pkt->pkt.signature->sig_class);
1556             delete_kbnode(node);
1557           }
1558         else if( (node->flag & 4) ) /* marked for deletion */
1559             delete_kbnode( node );
1560     }
1561
1562     /* note: because keyblock is the public key, it is never marked
1563      * for deletion and so keyblock cannot change */
1564     commit_kbnode( &keyblock );
1565     return nvalid;
1566 }
1567
1568
1569 /****************
1570  * It may happen that the imported keyblock has duplicated user IDs.
1571  * We check this here and collapse those user IDs together with their
1572  * sigs into one.
1573  * Returns: True if the keyblock hash changed.
1574  */
1575 int
1576 collapse_uids( KBNODE *keyblock )
1577 {
1578     KBNODE n, n2;
1579     int in_uid;
1580     int any=0;
1581
1582   restart:
1583     for( n = *keyblock; n; n = n->next ) {
1584         if( n->pkt->pkttype != PKT_USER_ID )
1585             continue;
1586         for( n2 = n->next; n2; n2 = n2->next ) {
1587             if( n2->pkt->pkttype == PKT_USER_ID
1588                 && !cmp_user_ids( n->pkt->pkt.user_id,
1589                                   n2->pkt->pkt.user_id ) ) {
1590                 /* found a duplicate */
1591                 any = 1;
1592                 if( !n2->next
1593                     || n2->next->pkt->pkttype == PKT_USER_ID
1594                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1595                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1596                     /* no more signatures: delete the user ID
1597                      * and start over */
1598                     remove_kbnode( keyblock, n2 );
1599                 }
1600                 else {
1601                     /* The simple approach: Move one signature and
1602                      * then start over to delete the next one :-( */
1603                     move_kbnode( keyblock, n2->next, n->next );
1604                 }
1605                 goto restart;
1606             }
1607         }
1608     }
1609     if( !any )
1610         return 0;
1611
1612   restart_sig:
1613     /* now we may have duplicate signatures on one user ID: fix this */
1614     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1615         if( n->pkt->pkttype == PKT_USER_ID )
1616             in_uid = 1;
1617         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1618                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1619             in_uid = 0;
1620         else if( in_uid ) {
1621             n2 = n;
1622             do {
1623                 KBNODE ncmp = NULL;
1624                 for( ; n2; n2 = n2->next ) {
1625                     if(    n2->pkt->pkttype == PKT_USER_ID
1626                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1627                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1628                         break;
1629                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1630                         ;
1631                     else if( !ncmp )
1632                         ncmp = n2;
1633                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1634                                                 n2->pkt->pkt.signature )) {
1635                         remove_kbnode( keyblock, n2 );
1636                         goto restart_sig;
1637                     }
1638                 }
1639                 n2 = ncmp? ncmp->next : NULL;
1640             } while( n2 );
1641         }
1642     }
1643
1644     if(!opt.quiet)
1645       {
1646         const char *key="???";
1647
1648         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1649           key=keystr_from_pk(n->pkt->pkt.public_key);
1650         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1651           key=keystr_from_sk(n->pkt->pkt.secret_key);
1652
1653         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1654       }
1655
1656     return 1;
1657 }
1658
1659 /* Check for a 0x20 revocation from a revocation key that is not
1660    present.  This may be called without the benefit of merge_xxxx so
1661    you can't rely on pk->revkey and friends. */
1662 static void
1663 revocation_present(KBNODE keyblock)
1664 {
1665   KBNODE onode,inode;
1666   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1667
1668   for(onode=keyblock->next;onode;onode=onode->next)
1669     {
1670       /* If we reach user IDs, we're done. */
1671       if(onode->pkt->pkttype==PKT_USER_ID)
1672         break;
1673
1674       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1675          onode->pkt->pkt.signature->sig_class==0x1F &&
1676          onode->pkt->pkt.signature->revkey)
1677         {
1678           int idx;
1679           PKT_signature *sig=onode->pkt->pkt.signature;
1680
1681           for(idx=0;idx<sig->numrevkeys;idx++)
1682             {
1683               u32 keyid[2];
1684
1685               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1686                                      MAX_FINGERPRINT_LEN,keyid);
1687
1688               for(inode=keyblock->next;inode;inode=inode->next)
1689                 {
1690                   /* If we reach user IDs, we're done. */
1691                   if(inode->pkt->pkttype==PKT_USER_ID)
1692                     break;
1693
1694                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1695                      inode->pkt->pkt.signature->sig_class==0x20 &&
1696                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1697                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1698                     {
1699                       /* Okay, we have a revocation key, and a
1700                          revocation issued by it.  Do we have the key
1701                          itself? */
1702                       int rc;
1703
1704                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1705                                                    MAX_FINGERPRINT_LEN);
1706                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1707                         {
1708                           char *tempkeystr=m_strdup(keystr_from_pk(pk));
1709
1710                           /* No, so try and get it */
1711                           if(opt.keyserver
1712                              && (opt.keyserver_options.options
1713                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1714                             {
1715                               log_info(_("WARNING: key %s may be revoked:"
1716                                          " fetching revocation key %s\n"),
1717                                        tempkeystr,keystr(keyid));
1718                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1719                                                       MAX_FINGERPRINT_LEN,
1720                                                       opt.keyserver);
1721
1722                               /* Do we have it now? */
1723                               rc=get_pubkey_byfprint_fast (NULL,
1724                                                      sig->revkey[idx]->fpr,
1725                                                      MAX_FINGERPRINT_LEN);
1726                             }
1727
1728                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1729                             log_info(_("WARNING: key %s may be revoked:"
1730                                        " revocation key %s not present.\n"),
1731                                      tempkeystr,keystr(keyid));
1732
1733                           m_free(tempkeystr);
1734                         }
1735                     }
1736                 }
1737             }
1738         }
1739     }
1740 }
1741
1742 /****************
1743  * compare and merge the blocks
1744  *
1745  * o compare the signatures: If we already have this signature, check
1746  *   that they compare okay; if not, issue a warning and ask the user.
1747  * o Simply add the signature.  Can't verify here because we may not have
1748  *   the signature's public key yet; verification is done when putting it
1749  *   into the trustdb, which is done automagically as soon as this pubkey
1750  *   is used.
1751  * Note: We indicate newly inserted packets with flag bit 0
1752  */
1753 static int
1754 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1755               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1756 {
1757     KBNODE onode, node;
1758     int rc, found;
1759
1760     /* 1st: handle revocation certificates */
1761     for(node=keyblock->next; node; node=node->next ) {
1762         if( node->pkt->pkttype == PKT_USER_ID )
1763             break;
1764         else if( node->pkt->pkttype == PKT_SIGNATURE
1765                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1766             /* check whether we already have this */
1767             found = 0;
1768             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1769                 if( onode->pkt->pkttype == PKT_USER_ID )
1770                     break;
1771                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1772                          && onode->pkt->pkt.signature->sig_class == 0x20
1773                          && !cmp_signatures(onode->pkt->pkt.signature,
1774                                             node->pkt->pkt.signature))
1775                   {
1776                     found = 1;
1777                     break;
1778                   }
1779             }
1780             if( !found ) {
1781                 KBNODE n2 = clone_kbnode(node);
1782                 insert_kbnode( keyblock_orig, n2, 0 );
1783                 n2->flag |= 1;
1784                 ++*n_sigs;
1785                 if(!opt.quiet)
1786                   {
1787                     char *p=get_user_id_native (keyid);
1788                     log_info(_("key %s: \"%s\" revocation"
1789                                " certificate added\n"), keystr(keyid),p);
1790                     m_free(p);
1791                   }
1792             }
1793         }
1794     }
1795
1796     /* 2nd: merge in any direct key (0x1F) sigs */
1797     for(node=keyblock->next; node; node=node->next ) {
1798         if( node->pkt->pkttype == PKT_USER_ID )
1799             break;
1800         else if( node->pkt->pkttype == PKT_SIGNATURE
1801                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1802             /* check whether we already have this */
1803             found = 0;
1804             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1805                 if( onode->pkt->pkttype == PKT_USER_ID )
1806                     break;
1807                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1808                          && onode->pkt->pkt.signature->sig_class == 0x1F
1809                          && !cmp_signatures(onode->pkt->pkt.signature,
1810                                             node->pkt->pkt.signature)) {
1811                     found = 1;
1812                     break;
1813                 }
1814             }
1815             if( !found )
1816               {
1817                 KBNODE n2 = clone_kbnode(node);
1818                 insert_kbnode( keyblock_orig, n2, 0 );
1819                 n2->flag |= 1;
1820                 ++*n_sigs;
1821                 if(!opt.quiet)
1822                   log_info( _("key %s: direct key signature added\n"),
1823                             keystr(keyid));
1824               }
1825         }
1826     }
1827
1828     /* 3rd: try to merge new certificates in */
1829     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1830         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1831             /* find the user id in the imported keyblock */
1832             for(node=keyblock->next; node; node=node->next )
1833                 if( node->pkt->pkttype == PKT_USER_ID
1834                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1835                                           node->pkt->pkt.user_id ) )
1836                     break;
1837             if( node ) { /* found: merge */
1838                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1839                 if( rc )
1840                     return rc;
1841             }
1842         }
1843     }
1844
1845     /* 4th: add new user-ids */
1846     for(node=keyblock->next; node; node=node->next ) {
1847         if( node->pkt->pkttype == PKT_USER_ID) {
1848             /* do we have this in the original keyblock */
1849             for(onode=keyblock_orig->next; onode; onode=onode->next )
1850                 if( onode->pkt->pkttype == PKT_USER_ID
1851                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1852                                       node->pkt->pkt.user_id ) )
1853                     break;
1854             if( !onode ) { /* this is a new user id: append */
1855                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1856                 if( rc )
1857                     return rc;
1858                 ++*n_uids;
1859             }
1860         }
1861     }
1862
1863     /* 5th: add new subkeys */
1864     for(node=keyblock->next; node; node=node->next ) {
1865         onode = NULL;
1866         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1867             /* do we have this in the original keyblock? */
1868             for(onode=keyblock_orig->next; onode; onode=onode->next )
1869                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1870                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1871                                          node->pkt->pkt.public_key ) )
1872                     break;
1873             if( !onode ) { /* this is a new subkey: append */
1874                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1875                 if( rc )
1876                     return rc;
1877                 ++*n_subk;
1878             }
1879         }
1880         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1881             /* do we have this in the original keyblock? */
1882             for(onode=keyblock_orig->next; onode; onode=onode->next )
1883                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1884                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1885                                          node->pkt->pkt.secret_key ) )
1886                     break;
1887             if( !onode ) { /* this is a new subkey: append */
1888                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1889                 if( rc )
1890                     return rc;
1891                 ++*n_subk;
1892             }
1893         }
1894     }
1895
1896     /* 6th: merge subkey certificates */
1897     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1898         if( !(onode->flag & 1)
1899             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1900                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1901             /* find the subkey in the imported keyblock */
1902             for(node=keyblock->next; node; node=node->next ) {
1903                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1904                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1905                                           node->pkt->pkt.public_key ) )
1906                     break;
1907                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1908                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1909                                           node->pkt->pkt.secret_key ) )
1910                     break;
1911             }
1912             if( node ) { /* found: merge */
1913                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1914                 if( rc )
1915                     return rc;
1916             }
1917         }
1918     }
1919
1920
1921     return 0;
1922 }
1923
1924
1925 /****************
1926  * append the userid starting with NODE and all signatures to KEYBLOCK.
1927  */
1928 static int
1929 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1930                                           const char *fname, u32 *keyid )
1931 {
1932     KBNODE n, n_where=NULL;
1933
1934     assert(node->pkt->pkttype == PKT_USER_ID );
1935
1936     /* find the position */
1937     for( n = keyblock; n; n_where = n, n = n->next ) {
1938         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1939             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1940             break;
1941     }
1942     if( !n )
1943         n_where = NULL;
1944
1945     /* and append/insert */
1946     while( node ) {
1947         /* we add a clone to the original keyblock, because this
1948          * one is released first */
1949         n = clone_kbnode(node);
1950         if( n_where ) {
1951             insert_kbnode( n_where, n, 0 );
1952             n_where = n;
1953         }
1954         else
1955             add_kbnode( keyblock, n );
1956         n->flag |= 1;
1957         node->flag |= 1;
1958         if( n->pkt->pkttype == PKT_SIGNATURE )
1959             ++*n_sigs;
1960
1961         node = node->next;
1962         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1963             break;
1964     }
1965
1966     return 0;
1967 }
1968
1969
1970 /****************
1971  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1972  * (how should we handle comment packets here?)
1973  */
1974 static int
1975 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1976                                     const char *fname, u32 *keyid )
1977 {
1978     KBNODE n, n2;
1979     int found=0;
1980
1981     assert(dst->pkt->pkttype == PKT_USER_ID );
1982     assert(src->pkt->pkttype == PKT_USER_ID );
1983
1984     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1985         if( n->pkt->pkttype != PKT_SIGNATURE )
1986             continue;
1987         if( n->pkt->pkt.signature->sig_class == 0x18
1988             || n->pkt->pkt.signature->sig_class == 0x28 )
1989             continue; /* skip signatures which are only valid on subkeys */
1990         found = 0;
1991         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
1992           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
1993             {
1994               found++;
1995               break;
1996             }
1997         if( !found ) {
1998             /* This signature is new or newer, append N to DST.
1999              * We add a clone to the original keyblock, because this
2000              * one is released first */
2001             n2 = clone_kbnode(n);
2002             insert_kbnode( dst, n2, PKT_SIGNATURE );
2003             n2->flag |= 1;
2004             n->flag |= 1;
2005             ++*n_sigs;
2006         }
2007     }
2008
2009     return 0;
2010 }
2011
2012 /****************
2013  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2014  */
2015 static int
2016 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2017                                     const char *fname, u32 *keyid )
2018 {
2019     KBNODE n, n2;
2020     int found=0;
2021
2022     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2023            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2024
2025     for(n=src->next; n ; n = n->next ) {
2026         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2027             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2028             break;
2029         if( n->pkt->pkttype != PKT_SIGNATURE )
2030             continue;
2031         found = 0;
2032         for(n2=dst->next; n2; n2 = n2->next){
2033             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2034                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2035                 break;
2036             if( n2->pkt->pkttype == PKT_SIGNATURE
2037                 && n->pkt->pkt.signature->keyid[0]
2038                    == n2->pkt->pkt.signature->keyid[0]
2039                 && n->pkt->pkt.signature->keyid[1]
2040                    == n2->pkt->pkt.signature->keyid[1]
2041                 && n->pkt->pkt.signature->timestamp
2042                    <= n2->pkt->pkt.signature->timestamp
2043                 && n->pkt->pkt.signature->sig_class
2044                    == n2->pkt->pkt.signature->sig_class ) {
2045                 found++;
2046                 break;
2047             }
2048         }
2049         if( !found ) {
2050             /* This signature is new or newer, append N to DST.
2051              * We add a clone to the original keyblock, because this
2052              * one is released first */
2053             n2 = clone_kbnode(n);
2054             insert_kbnode( dst, n2, PKT_SIGNATURE );
2055             n2->flag |= 1;
2056             n->flag |= 1;
2057             ++*n_sigs;
2058         }
2059     }
2060
2061     return 0;
2062 }
2063
2064 /****************
2065  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2066  * Mark all new and copied packets by setting flag bit 0.
2067  */
2068 static int
2069 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2070                                           const char *fname, u32 *keyid )
2071 {
2072     KBNODE n;
2073
2074     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2075            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2076
2077     while(  node ) {
2078         /* we add a clone to the original keyblock, because this
2079          * one is released first */
2080         n = clone_kbnode(node);
2081         add_kbnode( keyblock, n );
2082         n->flag |= 1;
2083         node->flag |= 1;
2084         if( n->pkt->pkttype == PKT_SIGNATURE )
2085             ++*n_sigs;
2086
2087         node = node->next;
2088         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2089             break;
2090     }
2091
2092     return 0;
2093 }