See ChangeLog: Fri Oct 6 14:29:16 CEST 2000 Werner Koch
[gnupg.git] / g10 / import.c
1 /* import.c
2  *      Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "keydb.h"
32 #include <gcrypt.h>
33 #include "util.h"
34 #include "trustdb.h"
35 #include "main.h"
36 #include "i18n.h"
37 #include "status.h"
38
39
40 static struct {
41     ulong count;
42     ulong no_user_id;
43     ulong imported;
44     ulong imported_rsa;
45     ulong n_uids;
46     ulong n_sigs;
47     ulong n_subk;
48     ulong unchanged;
49     ulong n_revoc;
50     ulong secret_read;
51     ulong secret_imported;
52     ulong secret_dups;
53     ulong skipped_new_keys;
54 } stats;
55
56
57 static int import( IOBUF inp, int fast, const char* fname );
58 static void print_stats(void);
59 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
60 static int import_one( const char *fname, KBNODE keyblock, int fast );
61 static int import_secret_one( const char *fname, KBNODE keyblock );
62 static int import_revoke_cert( const char *fname, KBNODE node );
63 static int chk_self_sigs( const char *fname, KBNODE keyblock,
64                           PKT_public_key *pk, u32 *keyid );
65 static void mark_non_selfsigned_uids_valid( KBNODE keyblock, u32 *kid );
66 static int delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid );
67 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
68                          KBNODE keyblock, u32 *keyid,
69                          int *n_uids, int *n_sigs, int *n_subk );
70 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
71                              const char *fname, u32 *keyid );
72 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
73                              const char *fname, u32 *keyid );
74 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
75                              const char *fname, u32 *keyid );
76 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
77                              const char *fname, u32 *keyid );
78
79
80 /****************
81  * Import the public keys from the given filename. Input may be armored.
82  * This function rejects all keys which are not validly self signed on at
83  * least one userid. Only user ids which are self signed will be imported.
84  * Other signatures are not checked.
85  *
86  * Actually this function does a merge. It works like this:
87  *
88  *  - get the keyblock
89  *  - check self-signatures and remove all userids and their signatures
90  *    without/invalid self-signatures.
91  *  - reject the keyblock, if we have no valid userid.
92  *  - See whether we have this key already in one of our pubrings.
93  *    If not, simply add it to the default keyring.
94  *  - Compare the key and the self-signatures of the new and the one in
95  *    our keyring.  If they are different something weird is going on;
96  *    ask what to do.
97  *  - See whether we have only non-self-signature on one user id; if not
98  *    ask the user what to do.
99  *  - compare the signatures: If we already have this signature, check
100  *    that they compare okay; if not, issue a warning and ask the user.
101  *    (consider looking at the timestamp and use the newest?)
102  *  - Simply add the signature.  Can't verify here because we may not have
103  *    the signature's public key yet; verification is done when putting it
104  *    into the trustdb, which is done automagically as soon as this pubkey
105  *    is used.
106  *  - Proceed with next signature.
107  *
108  *  Key revocation certificates have special handling.
109  *
110  */
111 void
112 import_keys( char **fnames, int nnames, int fast )
113 {
114     int i;
115
116     /* fixme: don't use static variables */
117     memset( &stats, 0, sizeof( stats ) );
118
119     if( !fnames && !nnames )
120         nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
121
122     for(i=0; i < nnames; i++ ) {
123         const char *fname = fnames? fnames[i] : NULL;
124         IOBUF inp = iobuf_open(fname);
125         if( !fname )
126             fname = "[stdin]";
127         if( !inp )
128             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
129         else {
130             int rc = import( inp, fast, fname );
131             iobuf_close(inp);
132             if( rc )
133                 log_error("import from `%s' failed: %s\n", fname,
134                                                            gpg_errstr(rc) );
135         }
136         if( !fname )
137             break;
138     }
139     print_stats();
140     if( !fast )
141         sync_trustdb();
142 }
143
144 int
145 import_keys_stream( IOBUF inp, int fast )
146 {
147     int rc = 0;
148
149     /* fixme: don't use static variables */
150     memset( &stats, 0, sizeof( stats ) );
151     rc = import( inp, fast, "[stream]" );
152     print_stats();
153     if( !fast )
154         sync_trustdb();
155     return rc;
156 }
157
158 static int
159 import( IOBUF inp, int fast, const char* fname )
160 {
161     PACKET *pending_pkt = NULL;
162     KBNODE keyblock;
163     int rc = 0;
164
165     getkey_disable_caches();
166
167     if( !opt.no_armor ) { /* armored reading is not disabled */
168         armor_filter_context_t *afx = gcry_xcalloc( 1, sizeof *afx );
169         afx->only_keyblocks = 1;
170         iobuf_push_filter2( inp, armor_filter, afx, 1 );
171     }
172
173     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
174         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
175             rc = import_one( fname, keyblock, fast );
176         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY )
177             rc = import_secret_one( fname, keyblock );
178         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
179                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
180             rc = import_revoke_cert( fname, keyblock );
181         else {
182             log_info( _("skipping block of type %d\n"),
183                                             keyblock->pkt->pkttype );
184         }
185         release_kbnode(keyblock);
186         if( rc )
187             break;
188         if( !(++stats.count % 100) && !opt.quiet )
189             log_info(_("%lu keys so far processed\n"), stats.count );
190     }
191     if( rc == -1 )
192         rc = 0;
193     else if( rc && rc != GPGERR_INV_KEYRING )
194         log_error( _("error reading `%s': %s\n"), fname, gpg_errstr(rc));
195
196     return rc;
197 }
198
199
200 static void
201 print_stats()
202 {
203     if( !opt.quiet ) {
204         log_info(_("Total number processed: %lu\n"), stats.count );
205         if( stats.skipped_new_keys )
206             log_info(_("      skipped new keys: %lu\n"),
207                                                 stats.skipped_new_keys );
208         if( stats.no_user_id )
209             log_info(_("          w/o user IDs: %lu\n"), stats.no_user_id );
210         if( stats.imported || stats.imported_rsa ) {
211             log_info(_("              imported: %lu"), stats.imported );
212             if( stats.imported_rsa )
213                 fprintf(stderr, "  (RSA: %lu)", stats.imported_rsa );
214             putc('\n', stderr);
215         }
216         if( stats.unchanged )
217             log_info(_("             unchanged: %lu\n"), stats.unchanged );
218         if( stats.n_uids )
219             log_info(_("          new user IDs: %lu\n"), stats.n_uids );
220         if( stats.n_subk )
221             log_info(_("           new subkeys: %lu\n"), stats.n_subk );
222         if( stats.n_sigs )
223             log_info(_("        new signatures: %lu\n"), stats.n_sigs );
224         if( stats.n_revoc )
225             log_info(_("   new key revocations: %lu\n"), stats.n_revoc );
226         if( stats.secret_read )
227             log_info(_("      secret keys read: %lu\n"), stats.secret_read );
228         if( stats.secret_imported )
229             log_info(_("  secret keys imported: %lu\n"), stats.secret_imported );
230         if( stats.secret_dups )
231             log_info(_(" secret keys unchanged: %lu\n"), stats.secret_dups );
232     }
233
234     if( is_status_enabled() ) {
235         char buf[12*20];
236         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
237                 stats.count,
238                 stats.no_user_id,
239                 stats.imported,
240                 stats.imported_rsa,
241                 stats.unchanged,
242                 stats.n_uids,
243                 stats.n_subk,
244                 stats.n_sigs,
245                 stats.n_revoc,
246                 stats.secret_read,
247                 stats.secret_imported,
248                 stats.secret_dups);
249         write_status_text( STATUS_IMPORT_RES, buf );
250     }
251 }
252
253
254 /****************
255  * Read the next keyblock from stream A.
256  * PENDING_PKT should be initialzed to NULL
257  * and not chnaged form the caller.
258  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
259  */
260 static int
261 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
262 {
263     int rc;
264     PACKET *pkt;
265     KBNODE root = NULL;
266     int in_cert;
267
268     if( *pending_pkt ) {
269         root = new_kbnode( *pending_pkt );
270         *pending_pkt = NULL;
271         in_cert = 1;
272     }
273     else
274         in_cert = 0;
275     pkt = gcry_xmalloc( sizeof *pkt );
276     init_packet(pkt);
277     while( (rc=parse_packet(a, pkt, NULL)) != -1 ) {
278         if( rc ) {  /* ignore errors */
279             if( rc != GPGERR_UNKNOWN_PACKET ) {
280                 log_error("read_block: read error: %s\n", gpg_errstr(rc) );
281                 rc = GPGERR_INV_KEYRING;
282                 goto ready;
283             }
284             free_packet( pkt );
285             init_packet(pkt);
286             continue;
287         }
288
289         if( !root && pkt->pkttype == PKT_SIGNATURE
290                   && pkt->pkt.signature->sig_class == 0x20 ) {
291             /* this is a revocation certificate which is handled
292              * in a special way */
293             root = new_kbnode( pkt );
294             pkt = NULL;
295             goto ready;
296         }
297
298         /* make a linked list of all packets */
299         switch( pkt->pkttype ) {
300           case PKT_COMPRESSED:
301             if( pkt->pkt.compressed->algorithm < 1
302                 || pkt->pkt.compressed->algorithm > 2 ) {
303                 rc = GPGERR_COMPR_ALGO;
304                 goto ready;
305             }
306             {
307                 compress_filter_context_t *cfx = gcry_xcalloc( 1, sizeof *cfx );
308                 cfx->algo = pkt->pkt.compressed->algorithm;
309                 pkt->pkt.compressed->buf = NULL;
310                 iobuf_push_filter2( a, compress_filter, cfx, 1 );
311             }
312             free_packet( pkt );
313             init_packet(pkt);
314             break;
315
316
317           case PKT_PUBLIC_KEY:
318           case PKT_SECRET_KEY:
319             if( in_cert ) { /* store this packet */
320                 *pending_pkt = pkt;
321                 pkt = NULL;
322                 goto ready;
323             }
324             in_cert = 1;
325           default:
326             if( in_cert ) {
327                 if( !root )
328                     root = new_kbnode( pkt );
329                 else
330                     add_kbnode( root, new_kbnode( pkt ) );
331                 pkt = gcry_xmalloc( sizeof *pkt );
332             }
333             init_packet(pkt);
334             break;
335         }
336     }
337   ready:
338     if( rc == -1 && root )
339         rc = 0;
340
341     if( rc )
342         release_kbnode( root );
343     else
344         *ret_root = root;
345     free_packet( pkt );
346     gcry_free( pkt );
347     return rc;
348 }
349
350
351 /****************
352  * Try to import one keyblock.  Return an error only in serious cases, but
353  * never for an invalid keyblock.  It uses log_error to increase the
354  * internal errorcount, so that invalid input can be detected by programs
355  * which called gpg.
356  */
357 static int
358 import_one( const char *fname, KBNODE keyblock, int fast )
359 {
360     PKT_public_key *pk;
361     PKT_public_key *pk_orig;
362     KBNODE node, uidnode;
363     KBNODE keyblock_orig = NULL;
364     KBPOS kbpos;
365     u32 keyid[2];
366     int rc = 0;
367     int new_key = 0;
368     int mod_key = 0;
369
370     /* get the key and print some info about it */
371     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
372     if( !node )
373         BUG();
374
375     pk = node->pkt->pkt.public_key;
376     keyid_from_pk( pk, keyid );
377     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
378
379     if( opt.verbose ) {
380         log_info( "pub  %4u%c/%08lX %s   ",
381                   nbits_from_pk( pk ),
382                   pubkey_letter( pk->pubkey_algo ),
383                   (ulong)keyid[1], datestr_from_pk(pk) );
384         if( uidnode )
385             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
386                                        uidnode->pkt->pkt.user_id->len );
387         putc('\n', stderr);
388     }
389     if( !uidnode ) {
390         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
391         return 0;
392     }
393
394     clear_kbnode_flags( keyblock );
395     rc = chk_self_sigs( fname, keyblock , pk, keyid );
396     if( rc )
397         return rc== -1? 0:rc;
398
399     if( opt.allow_non_selfsigned_uid )
400         mark_non_selfsigned_uids_valid( keyblock, keyid );
401
402     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
403         if( !opt.quiet ) {
404             log_info( _("key %08lX: no valid user IDs\n"),
405                                                         (ulong)keyid[1]);
406             log_info(_("this may be caused by a missing self-signature\n"));
407         }
408         stats.no_user_id++;
409         return 0;
410     }
411
412
413     /* do we have this key already in one of our pubrings ? */
414     pk_orig = gcry_xcalloc( 1, sizeof *pk_orig );
415     rc = get_pubkey( pk_orig, keyid );
416     if( rc && rc != GPGERR_NO_PUBKEY ) {
417         log_error( _("key %08lX: public key not found: %s\n"),
418                                 (ulong)keyid[1], gpg_errstr(rc));
419     }
420     else if ( rc && opt.merge_only ) {
421         if( opt.verbose )
422             log_info( _("key %08lX: new key - skipped\n"), (ulong)keyid[1] );
423         rc = 0;
424         fast = 1; /* so that we don't get into the trustdb update */
425         stats.skipped_new_keys++;
426     }
427     else if( rc ) { /* insert this key */
428         /* get default resource */
429         if( get_keyblock_handle( NULL, 0, &kbpos ) ) {
430             log_error(_("no default public keyring\n"));
431             return GPGERR_GENERAL;
432         }
433         if( opt.verbose > 1 )
434             log_info( _("writing to `%s'\n"),
435                                 keyblock_resource_name(&kbpos) );
436         if( (rc=lock_keyblock( &kbpos )) )
437            log_error(_("can't lock keyring `%s': %s\n"),
438                        keyblock_resource_name(&kbpos), gpg_errstr(rc) );
439         else if( (rc=insert_keyblock( keyblock )) )
440            log_error( _("error writing keyring `%s': %s\n"),
441                        keyblock_resource_name(&kbpos), gpg_errstr(rc) );
442         unlock_keyblock( &kbpos );
443         /* we are ready */
444         if( !opt.quiet )
445             log_info( _("key %08lX: public key imported\n"), (ulong)keyid[1]);
446         if( is_status_enabled() ) {
447             char *us = get_long_user_id_string( keyid );
448             write_status_text( STATUS_IMPORTED, us );
449             gcry_free(us);
450         }
451         stats.imported++;
452         if( is_RSA( pk->pubkey_algo ) )
453             stats.imported_rsa++;
454         new_key = 1;
455     }
456     else { /* merge */
457         int n_uids, n_sigs, n_subk;
458
459         /* Compare the original against the new key; just to be sure nothing
460          * weird is going on */
461         if( cmp_public_keys( pk_orig, pk ) ) {
462             log_error( _("key %08lX: doesn't match our copy\n"),
463                                                           (ulong)keyid[1]);
464             rc = GPGERR_GENERAL;
465             goto leave;
466         }
467
468         /* now read the original keyblock */
469         rc = find_keyblock_bypk( &keyblock_orig, pk_orig );
470         if( rc ) {
471             log_error( _("key %08lX: can't locate original keyblock: %s\n"),
472                                      (ulong)keyid[1], gpg_errstr(rc));
473             goto leave;
474         }
475
476         collapse_uids( &keyblock );
477         /* and try to merge the block */
478         clear_kbnode_flags( keyblock_orig );
479         clear_kbnode_flags( keyblock );
480         n_uids = n_sigs = n_subk = 0;
481         rc = merge_blocks( fname, keyblock_orig, keyblock,
482                                 keyid, &n_uids, &n_sigs, &n_subk );
483         if( rc )
484             goto leave;
485         if( n_uids || n_sigs || n_subk ) {
486             mod_key = 1;
487             /* keyblock_orig has been updated; write */
488             if( (rc=lock_keyblock( &kbpos )) )
489                log_error( _("can't lock keyring `%s': %s\n"),
490                           keyblock_resource_name(&kbpos), gpg_errstr(rc) );
491             else if( (rc=update_keyblock( keyblock_orig )) )
492                 log_error( _("error writing keyring `%s': %s\n"),
493                              keyblock_resource_name(&kbpos), gpg_errstr(rc) );
494             unlock_keyblock( &kbpos );
495             /* we are ready */
496             if( !opt.quiet ) {
497                 if( n_uids == 1 )
498                     log_info( _("key %08lX: 1 new user ID\n"),
499                                              (ulong)keyid[1]);
500                 else if( n_uids )
501                     log_info( _("key %08lX: %d new user IDs\n"),
502                                              (ulong)keyid[1], n_uids );
503                 if( n_sigs == 1 )
504                     log_info( _("key %08lX: 1 new signature\n"),
505                                              (ulong)keyid[1]);
506                 else if( n_sigs )
507                     log_info( _("key %08lX: %d new signatures\n"),
508                                              (ulong)keyid[1], n_sigs );
509                 if( n_subk == 1 )
510                     log_info( _("key %08lX: 1 new subkey\n"),
511                                              (ulong)keyid[1]);
512                 else if( n_subk )
513                     log_info( _("key %08lX: %d new subkeys\n"),
514                                              (ulong)keyid[1], n_subk );
515             }
516
517             stats.n_uids +=n_uids;
518             stats.n_sigs +=n_sigs;
519             stats.n_subk +=n_subk;
520         }
521         else {
522             if( !opt.quiet )
523                 log_info( _("key %08lX: not changed\n"), (ulong)keyid[1] );
524             stats.unchanged++;
525         }
526     }
527     if( !rc && !fast ) {
528         rc = query_trust_record( new_key? pk : pk_orig );
529         if( rc && rc != -1 )
530             log_error("trustdb error: %s\n", gpg_errstr(rc) );
531         else if( rc == -1 ) { /* not found trustdb */
532             rc = insert_trust_record( new_key? keyblock : keyblock_orig );
533             if( rc )
534                 log_error("key %08lX: trustdb insert failed: %s\n",
535                                         (ulong)keyid[1], gpg_errstr(rc) );
536         }
537         else if( mod_key )
538             rc = update_trust_record( keyblock_orig, 1, NULL );
539         else
540             rc = clear_trust_checked_flag( new_key? pk : pk_orig );
541     }
542
543   leave:
544     release_kbnode( keyblock_orig );
545     free_public_key( pk_orig );
546     return rc;
547 }
548
549
550 /****************
551  * Ditto for secret keys.  Handling is simpler than for public keys.
552  */
553 static int
554 import_secret_one( const char *fname, KBNODE keyblock )
555 {
556     PKT_secret_key *sk;
557     KBNODE node, uidnode;
558     KBPOS kbpos;
559     u32 keyid[2];
560     int rc = 0;
561
562     /* get the key and print some info about it */
563     node = find_kbnode( keyblock, PKT_SECRET_KEY );
564     if( !node )
565         BUG();
566
567     sk = node->pkt->pkt.secret_key;
568     keyid_from_sk( sk, keyid );
569     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
570
571     if( opt.verbose ) {
572         log_info( "sec  %4u%c/%08lX %s   ",
573                   nbits_from_sk( sk ),
574                   pubkey_letter( sk->pubkey_algo ),
575                   (ulong)keyid[1], datestr_from_sk(sk) );
576         if( uidnode )
577             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
578                                        uidnode->pkt->pkt.user_id->len );
579         putc('\n', stderr);
580     }
581     stats.secret_read++;
582     if( !uidnode ) {
583         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
584         return 0;
585     }
586
587     clear_kbnode_flags( keyblock );
588
589     /* do we have this key already in one of our secrings ? */
590     rc = seckey_available( keyid );
591     if( rc == GPGERR_NO_SECKEY && !opt.merge_only ) { /* simply insert this key */
592         /* get default resource */
593         if( get_keyblock_handle( NULL, 1, &kbpos ) ) {
594             log_error("no default secret keyring\n");
595             return GPGERR_GENERAL;
596         }
597         if( (rc=lock_keyblock( &kbpos )) )
598             log_error( _("can't lock keyring `%s': %s\n"),
599                          keyblock_resource_name(&kbpos), gpg_errstr(rc) );
600         else if( (rc=insert_keyblock( keyblock )) )
601             log_error( _("error writing keyring `%s': %s\n"),
602                       keyblock_resource_name(&kbpos), gpg_errstr(rc) );
603         unlock_keyblock( &kbpos );
604         /* we are ready */
605         if( !opt.quiet )
606             log_info( _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
607         stats.secret_imported++;
608     }
609     else if( !rc ) { /* we can't merge secret keys */
610         log_error( _("key %08lX: already in secret keyring\n"),
611                                                         (ulong)keyid[1]);
612         stats.secret_dups++;
613     }
614     else
615         log_error( _("key %08lX: secret key not found: %s\n"),
616                                 (ulong)keyid[1], gpg_errstr(rc));
617
618     return rc;
619 }
620
621
622 /****************
623  * Import a revocation certificate; this is a single signature packet.
624  */
625 static int
626 import_revoke_cert( const char *fname, KBNODE node )
627 {
628     PKT_public_key *pk=NULL;
629     KBNODE onode, keyblock = NULL;
630     KBPOS kbpos;
631     u32 keyid[2];
632     int rc = 0;
633
634     assert( !node->next );
635     assert( node->pkt->pkttype == PKT_SIGNATURE );
636     assert( node->pkt->pkt.signature->sig_class == 0x20 );
637
638     keyid[0] = node->pkt->pkt.signature->keyid[0];
639     keyid[1] = node->pkt->pkt.signature->keyid[1];
640
641     pk = gcry_xcalloc( 1, sizeof *pk );
642     rc = get_pubkey( pk, keyid );
643     if( rc == GPGERR_NO_PUBKEY ) {
644         log_info( _("key %08lX: no public key - "
645                  "can't apply revocation certificate\n"), (ulong)keyid[1]);
646         rc = 0;
647         goto leave;
648     }
649     else if( rc ) {
650         log_error( _("key %08lX: public key not found: %s\n"),
651                                        (ulong)keyid[1], gpg_errstr(rc));
652         goto leave;
653     }
654
655     /* read the original keyblock */
656     rc = find_keyblock_bypk( &keyblock, pk );
657     if( rc ) {
658         log_error( _("key %08lX: can't locate original keyblock: %s\n"),
659                                         (ulong)keyid[1], gpg_errstr(rc));
660         goto leave;
661     }
662
663
664     /* it is okay, that node is not in keyblock because
665      * check_key_signature works fine for sig_class 0x20 in this
666      * special case. */
667     rc = check_key_signature( keyblock, node, NULL);
668     if( rc ) {
669         log_error( _("key %08lX: invalid revocation certificate"
670                   ": %s - rejected\n"), (ulong)keyid[1], gpg_errstr(rc));
671     }
672
673
674     /* check whether we already have this */
675     for(onode=keyblock->next; onode; onode=onode->next ) {
676         if( onode->pkt->pkttype == PKT_USER_ID )
677             break;
678         else if( onode->pkt->pkttype == PKT_SIGNATURE
679                  && onode->pkt->pkt.signature->sig_class == 0x20
680                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
681                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
682             rc = 0;
683             goto leave; /* yes, we already know about it */
684         }
685     }
686
687
688     /* insert it */
689     insert_kbnode( keyblock, clone_kbnode(node), 0 );
690
691     /* and write the keyblock back */
692     if( (rc=lock_keyblock( &kbpos )) )
693         log_error( _("can't lock keyring `%s': %s\n"),
694                    keyblock_resource_name(&kbpos), gpg_errstr(rc) );
695     else if( (rc=update_keyblock( keyblock )) )
696         log_error( _("error writing keyring `%s': %s\n"),
697                     keyblock_resource_name(&kbpos), gpg_errstr(rc) );
698     unlock_keyblock( &kbpos );
699     /* we are ready */
700     if( !opt.quiet )
701         log_info( _("key %08lX: revocation certificate imported\n"),
702                                         (ulong)keyid[1]);
703     stats.n_revoc++;
704     if( clear_trust_checked_flag( pk ) ) {
705         /* seems that we have to insert the record first */
706         rc = insert_trust_record( keyblock );
707         if( rc )
708             log_error("key %08lX: trustdb insert failed: %s\n",
709                                         (ulong)keyid[1], gpg_errstr(rc) );
710         else
711             rc = clear_trust_checked_flag( pk );
712     }
713
714   leave:
715     release_kbnode( keyblock );
716     free_public_key( pk );
717     return rc;
718 }
719
720
721 /****************
722  * loop over the keyblock and check all self signatures.
723  * Mark all user-ids with a self-signature by setting flag bit 0.
724  * Mark all user-ids with an invalid self-signature by setting bit 1.
725  * This works also for subkeys, here the subkey is marked.
726  */
727 static int
728 chk_self_sigs( const char *fname, KBNODE keyblock,
729                PKT_public_key *pk, u32 *keyid )
730 {
731     KBNODE n;
732     PKT_signature *sig;
733     int rc;
734
735     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
736         if( n->pkt->pkttype != PKT_SIGNATURE )
737             continue;
738         sig = n->pkt->pkt.signature;
739         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
740             if( (sig->sig_class&~3) == 0x10 ) {
741                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
742                 if( !unode )  {
743                     log_error( _("key %08lX: no user ID for signature\n"),
744                                             (ulong)keyid[1]);
745                     return -1;  /* the complete keyblock is invalid */
746                 }
747                 rc = check_key_signature( keyblock, n, NULL);
748                 if( rc ) {
749                     log_info( rc == GPGERR_PUBKEY_ALGO ?
750                          _("key %08lX: unsupported public key algorithm\n"):
751                          _("key %08lX: invalid self-signature\n"),
752                                      (ulong)keyid[1]);
753
754                     unode->flag |= 2; /* mark as invalid */
755                 }
756                 unode->flag |= 1; /* mark that signature checked */
757             }
758             else if( sig->sig_class == 0x18 ) {
759                 KBNODE knode = find_prev_kbnode( keyblock,
760                                                  n, PKT_PUBLIC_SUBKEY );
761                 if( !knode )
762                     knode = find_prev_kbnode( keyblock,
763                                                  n, PKT_SECRET_SUBKEY );
764
765                 if( !knode ) {
766                     log_info( _("key %08lX: no subkey for key binding\n"),
767                                             (ulong)keyid[1]);
768                     n->flag |= 4; /* delete this */
769                 }
770                 else {
771                     rc = check_key_signature( keyblock, n, NULL);
772                     if( rc ) {
773                         log_info(  rc == GPGERR_PUBKEY_ALGO ?
774                            _("key %08lX: unsupported public key algorithm\n"):
775                            _("key %08lX: invalid subkey binding\n"),
776                                          (ulong)keyid[1]);
777
778                         knode->flag |= 2; /* mark as invalid */
779                     }
780                     knode->flag |= 1; /* mark that signature checked */
781                 }
782             }
783         }
784     }
785     return 0;
786 }
787
788
789
790 /****************
791  * If a user ID has at least one signature, mark it as valid
792  */
793 static void
794 mark_non_selfsigned_uids_valid( KBNODE keyblock, u32 *kid )
795 {
796     KBNODE node;
797     for(node=keyblock->next; node; node = node->next ) {
798         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) ) {
799             if( (node->next && node->next->pkt->pkttype == PKT_SIGNATURE)
800                 || !node->next ) {
801                 node->flag |= 1;
802                 log_info( _("key %08lX: accepted non self-signed user ID '"),
803                                                          (ulong)kid[1]);
804                 print_string( log_stream(), node->pkt->pkt.user_id->name,
805                                             node->pkt->pkt.user_id->len, 0 );
806                 fputs("'\n", log_stream() );
807             }
808         }
809     }
810 }
811
812 /****************
813  * delete all parts which are invalid and those signatures whose
814  * public key algorithm is not available in this implemenation;
815  * but consider RSA as valid, because parse/build_packets knows
816  * about it.
817  * returns: true if at least one valid user-id is left over.
818  */
819 static int
820 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
821 {
822     KBNODE node;
823     int nvalid=0, uid_seen=0;
824     const char *p;
825
826     for(node=keyblock->next; node; node = node->next ) {
827         if( node->pkt->pkttype == PKT_USER_ID ) {
828             uid_seen = 1;
829             if( (node->flag & 2) || !(node->flag & 1) ) {
830                 if( opt.verbose ) {
831                     log_info( _("key %08lX: skipped user ID '"),
832                                                          (ulong)keyid[1]);
833                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
834                                        node->pkt->pkt.user_id->len );
835                     fputs("'\n", stderr );
836                 }
837                 delete_kbnode( node ); /* the user-id */
838                 /* and all following packets up to the next user-id */
839                 while( node->next
840                        && node->next->pkt->pkttype != PKT_USER_ID
841                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
842                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
843                     delete_kbnode( node->next );
844                     node = node->next;
845                 }
846             }
847             else
848                 nvalid++;
849         }
850         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
851                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
852             if( (node->flag & 2) || !(node->flag & 1) ) {
853                 if( opt.verbose ) {
854                     log_info( _("key %08lX: skipped subkey\n"),
855                                                          (ulong)keyid[1]);
856                 }
857                 delete_kbnode( node ); /* the subkey */
858                 /* and all following signature packets */
859                 while( node->next
860                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
861                     delete_kbnode( node->next );
862                     node = node->next;
863                 }
864             }
865         }
866         else if( node->pkt->pkttype == PKT_SIGNATURE
867                  && openpgp_pk_test_algo( node->pkt->pkt.signature->pubkey_algo, 0 )
868                  && node->pkt->pkt.signature->pubkey_algo != GCRY_PK_RSA )
869             delete_kbnode( node ); /* build_packet() can't handle this */
870         else if( node->pkt->pkttype == PKT_SIGNATURE
871                  && (p = parse_sig_subpkt2( node->pkt->pkt.signature,
872                                             SIGSUBPKT_EXPORTABLE, NULL ))
873                  && !*p
874                  && seckey_available( node->pkt->pkt.signature->keyid ) ) {
875             /* here we violate the rfc a bit by still allowing
876              * to import non-exportable signature when we have the
877              * the secret key used to create this signature - it
878              * seems that this makes sense */
879             log_info( _("key %08lX: non exportable signature "
880                                     "(class %02x) - skipped\n"),
881                                     (ulong)keyid[1],
882                                      node->pkt->pkt.signature->sig_class );
883             delete_kbnode( node );
884         }
885         else if( node->pkt->pkttype == PKT_SIGNATURE
886                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
887             if( uid_seen ) {
888                 log_error( _("key %08lX: revocation certificate "
889                                      "at wrong place - skipped\n"),
890                                     (ulong)keyid[1]);
891                 delete_kbnode( node );
892             }
893             else {
894                 int rc = check_key_signature( keyblock, node, NULL);
895                 if( rc ) {
896                     log_error( _("key %08lX: invalid revocation "
897                               "certificate: %s - skipped\n"),
898                               (ulong)keyid[1], gpg_errstr(rc));
899                     delete_kbnode( node );
900                 }
901             }
902         }
903         else if( (node->flag & 4) ) /* marked for deletion */
904             delete_kbnode( node );
905     }
906
907     /* note: because keyblock is the public key, it is never marked
908      * for deletion and so keyblock cannot change */
909     commit_kbnode( &keyblock );
910     return nvalid;
911 }
912
913
914 /****************
915  * It may happen that the imported keyblock has duplicated user IDs.
916  * We check this here and collapse those user IDs together with their
917  * sigs into one.
918  * Returns: True if the keyblock hash changed.
919  */
920 int
921 collapse_uids( KBNODE *keyblock )
922 {
923     KBNODE n, n2;
924     int in_uid;
925     int any=0;
926     u32 kid1;
927
928   restart:
929     for( n = *keyblock; n; n = n->next ) {
930         if( n->pkt->pkttype != PKT_USER_ID )
931             continue;
932         for( n2 = n->next; n2; n2 = n2->next ) {
933             if( n2->pkt->pkttype == PKT_USER_ID
934                 && !cmp_user_ids( n->pkt->pkt.user_id,
935                                   n2->pkt->pkt.user_id ) ) {
936                 /* found a duplicate */
937                 any = 1;
938                 if( !n2->next
939                     || n2->next->pkt->pkttype == PKT_USER_ID
940                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
941                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
942                     /* no more signatures: delete the user ID
943                      * and start over */
944                     remove_kbnode( keyblock, n2 );
945                 }
946                 else {
947                     /* The simple approach: Move one signature and
948                      * then start over to delete the next one :-( */
949                     move_kbnode( keyblock, n2->next, n->next );
950                 }
951                 goto restart;
952             }
953         }
954     }
955     if( !any )
956         return 0;
957
958   restart_sig:
959     /* now we may have duplicate signatures on one user ID: fix this */
960     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
961         if( n->pkt->pkttype == PKT_USER_ID )
962             in_uid = 1;
963         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
964                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
965             in_uid = 0;
966         else if( in_uid ) {
967             n2 = n;
968             do {
969                 KBNODE ncmp = NULL;
970                 for( ; n2; n2 = n2->next ) {
971                     if(    n2->pkt->pkttype == PKT_USER_ID
972                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
973                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
974                         break;
975                     if( n2->pkt->pkttype != PKT_SIGNATURE )
976                         ;
977                     else if( !ncmp )
978                         ncmp = n2;
979                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
980                                                 n2->pkt->pkt.signature )) {
981                         remove_kbnode( keyblock, n2 );
982                         goto restart_sig;
983                     }
984                 }
985                 n2 = ncmp? ncmp->next : NULL;
986             } while( n2 );
987         }
988     }
989
990     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
991         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
992     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
993         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
994     else
995         kid1 = 0;
996     log_info(_("key %08lX: duplicated user ID detected - merged\n"),
997                                                                  (ulong)kid1);
998
999     return 1;
1000 }
1001
1002
1003
1004 /****************
1005  * compare and merge the blocks
1006  *
1007  * o compare the signatures: If we already have this signature, check
1008  *   that they compare okay; if not, issue a warning and ask the user.
1009  * o Simply add the signature.  Can't verify here because we may not have
1010  *   the signature's public key yet; verification is done when putting it
1011  *   into the trustdb, which is done automagically as soon as this pubkey
1012  *   is used.
1013  * Note: We indicate newly inserted packets with flag bit 0
1014  */
1015 static int
1016 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1017               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1018 {
1019     KBNODE onode, node;
1020     int rc, found;
1021
1022     /* 1st: handle revocation certificates */
1023     for(node=keyblock->next; node; node=node->next ) {
1024         if( node->pkt->pkttype == PKT_USER_ID )
1025             break;
1026         else if( node->pkt->pkttype == PKT_SIGNATURE
1027                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1028             /* check whether we already have this */
1029             found = 0;
1030             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1031                 if( onode->pkt->pkttype == PKT_USER_ID )
1032                     break;
1033                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1034                          && onode->pkt->pkt.signature->sig_class == 0x20
1035                          && node->pkt->pkt.signature->keyid[0]
1036                             == onode->pkt->pkt.signature->keyid[0]
1037                          && node->pkt->pkt.signature->keyid[1]
1038                             == onode->pkt->pkt.signature->keyid[1] ) {
1039                     found = 1;
1040                     break;
1041                 }
1042             }
1043             if( !found ) {
1044                 KBNODE n2 = clone_kbnode(node);
1045                 insert_kbnode( keyblock_orig, n2, 0 );
1046                 n2->flag |= 1;
1047                 log_info( _("key %08lX: revocation certificate added\n"),
1048                                          (ulong)keyid[1]);
1049             }
1050         }
1051     }
1052
1053     /* 2nd: try to merge new certificates in */
1054     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1055         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1056             /* find the user id in the imported keyblock */
1057             for(node=keyblock->next; node; node=node->next )
1058                 if( node->pkt->pkttype == PKT_USER_ID
1059                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1060                                           node->pkt->pkt.user_id ) )
1061                     break;
1062             if( node ) { /* found: merge */
1063                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1064                 if( rc )
1065                     return rc;
1066             }
1067         }
1068     }
1069
1070     /* 3rd: add new user-ids */
1071     for(node=keyblock->next; node; node=node->next ) {
1072         if( node->pkt->pkttype == PKT_USER_ID) {
1073             /* do we have this in the original keyblock */
1074             for(onode=keyblock_orig->next; onode; onode=onode->next )
1075                 if( onode->pkt->pkttype == PKT_USER_ID
1076                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1077                                       node->pkt->pkt.user_id ) )
1078                     break;
1079             if( !onode ) { /* this is a new user id: append */
1080                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1081                 if( rc )
1082                     return rc;
1083                 ++*n_uids;
1084             }
1085         }
1086     }
1087
1088     /*  add new subkeys */
1089     for(node=keyblock->next; node; node=node->next ) {
1090         onode = NULL;
1091         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1092             /* do we have this in the original keyblock? */
1093             for(onode=keyblock_orig->next; onode; onode=onode->next )
1094                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1095                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1096                                          node->pkt->pkt.public_key ) )
1097                     break;
1098             if( !onode ) { /* this is a new subkey: append */
1099                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1100                 if( rc )
1101                     return rc;
1102                 ++*n_subk;
1103             }
1104         }
1105         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1106             /* do we have this in the original keyblock? */
1107             for(onode=keyblock_orig->next; onode; onode=onode->next )
1108                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1109                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1110                                          node->pkt->pkt.secret_key ) )
1111                     break;
1112             if( !onode ) { /* this is a new subkey: append */
1113                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1114                 if( rc )
1115                     return rc;
1116                 ++*n_subk;
1117             }
1118         }
1119     }
1120
1121     /* merge subkey certificates */
1122     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1123         if( !(onode->flag & 1)
1124             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1125                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1126             /* find the subkey in the imported keyblock */
1127             for(node=keyblock->next; node; node=node->next ) {
1128                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1129                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1130                                           node->pkt->pkt.public_key ) )
1131                     break;
1132                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1133                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1134                                           node->pkt->pkt.secret_key ) )
1135                     break;
1136             }
1137             if( node ) { /* found: merge */
1138                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1139                 if( rc )
1140                     return rc;
1141             }
1142         }
1143     }
1144
1145
1146     return 0;
1147 }
1148
1149
1150 /****************
1151  * append the userid starting with NODE and all signatures to KEYBLOCK.
1152  */
1153 static int
1154 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1155                                           const char *fname, u32 *keyid )
1156 {
1157     KBNODE n, n_where=NULL;
1158
1159     assert(node->pkt->pkttype == PKT_USER_ID );
1160     if( !node->next || node->next->pkt->pkttype == PKT_USER_ID ) {
1161         log_error( _("key %08lX: our copy has no self-signature\n"),
1162                                                   (ulong)keyid[1]);
1163         return GPGERR_GENERAL;
1164     }
1165
1166     /* find the position */
1167     for( n = keyblock; n; n_where = n, n = n->next ) {
1168         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1169             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1170             break;
1171     }
1172     if( !n )
1173         n_where = NULL;
1174
1175     /* and append/insert */
1176     while( node ) {
1177         /* we add a clone to the original keyblock, because this
1178          * one is released first */
1179         n = clone_kbnode(node);
1180         if( n_where ) {
1181             insert_kbnode( n_where, n, 0 );
1182             n_where = n;
1183         }
1184         else
1185             add_kbnode( keyblock, n );
1186         n->flag |= 1;
1187         node->flag |= 1;
1188         if( n->pkt->pkttype == PKT_SIGNATURE )
1189             ++*n_sigs;
1190
1191         node = node->next;
1192         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1193             break;
1194     }
1195
1196     return 0;
1197 }
1198
1199
1200 /****************
1201  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1202  * (how should we handle comment packets here?)
1203  */
1204 static int
1205 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1206                                     const char *fname, u32 *keyid )
1207 {
1208     KBNODE n, n2;
1209     int found=0;
1210
1211     assert(dst->pkt->pkttype == PKT_USER_ID );
1212     assert(src->pkt->pkttype == PKT_USER_ID );
1213     if( !dst->next || dst->next->pkt->pkttype == PKT_USER_ID ) {
1214         log_error( _("key %08lX: our copy has no self-signature\n"),
1215                                                   (ulong)keyid[1]);
1216         return 0;
1217     }
1218
1219
1220     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1221         if( n->pkt->pkttype != PKT_SIGNATURE )
1222             continue;
1223         if( n->pkt->pkt.signature->sig_class == 0x18
1224             || n->pkt->pkt.signature->sig_class == 0x28 )
1225             continue; /* skip signatures which are only valid on subkeys */
1226         found = 0;
1227         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1228             if( n2->pkt->pkttype == PKT_SIGNATURE
1229                 && n->pkt->pkt.signature->keyid[0]
1230                    == n2->pkt->pkt.signature->keyid[0]
1231                 && n->pkt->pkt.signature->keyid[1]
1232                    == n2->pkt->pkt.signature->keyid[1]
1233                 && n->pkt->pkt.signature->timestamp
1234                    <= n2->pkt->pkt.signature->timestamp
1235                 && n->pkt->pkt.signature->sig_class
1236                    == n2->pkt->pkt.signature->sig_class ) {
1237                 found++;
1238                 break;
1239             }
1240         }
1241         if( !found ) {
1242             /* This signature is new or newer, append N to DST.
1243              * We add a clone to the original keyblock, because this
1244              * one is released first */
1245             n2 = clone_kbnode(n);
1246             insert_kbnode( dst, n2, PKT_SIGNATURE );
1247             n2->flag |= 1;
1248             n->flag |= 1;
1249             ++*n_sigs;
1250         }
1251     }
1252
1253     return 0;
1254 }
1255
1256 /****************
1257  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1258  */
1259 static int
1260 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1261                                     const char *fname, u32 *keyid )
1262 {
1263     KBNODE n, n2;
1264     int found=0;
1265
1266     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1267            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1268
1269     for(n=src->next; n ; n = n->next ) {
1270         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1271             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1272             break;
1273         if( n->pkt->pkttype != PKT_SIGNATURE )
1274             continue;
1275         found = 0;
1276         for(n2=dst->next; n2; n2 = n2->next){
1277             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1278                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1279                 break;
1280             if( n2->pkt->pkttype == PKT_SIGNATURE
1281                 && n->pkt->pkt.signature->keyid[0]
1282                    == n2->pkt->pkt.signature->keyid[0]
1283                 && n->pkt->pkt.signature->keyid[1]
1284                    == n2->pkt->pkt.signature->keyid[1]
1285                 && n->pkt->pkt.signature->timestamp
1286                    <= n2->pkt->pkt.signature->timestamp
1287                 && n->pkt->pkt.signature->sig_class
1288                    == n2->pkt->pkt.signature->sig_class ) {
1289                 found++;
1290                 break;
1291             }
1292         }
1293         if( !found ) {
1294             /* This signature is new or newer, append N to DST.
1295              * We add a clone to the original keyblock, because this
1296              * one is released first */
1297             n2 = clone_kbnode(n);
1298             insert_kbnode( dst, n2, PKT_SIGNATURE );
1299             n2->flag |= 1;
1300             n->flag |= 1;
1301             ++*n_sigs;
1302         }
1303     }
1304
1305     return 0;
1306 }
1307
1308 /****************
1309  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1310  * Mark all new and copied packets by setting flag bit 0.
1311  */
1312 static int
1313 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1314                                           const char *fname, u32 *keyid )
1315 {
1316     KBNODE n;
1317
1318     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1319            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1320
1321     while(  node ) {
1322         /* we add a clone to the original keyblock, because this
1323          * one is released first */
1324         n = clone_kbnode(node);
1325         add_kbnode( keyblock, n );
1326         n->flag |= 1;
1327         node->flag |= 1;
1328         if( n->pkt->pkttype == PKT_SIGNATURE )
1329             ++*n_sigs;
1330
1331         node = node->next;
1332         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1333             break;
1334     }
1335
1336     return 0;
1337 }
1338