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