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