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