Changed keyring handling - saving still does not work.
[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     u32 keyid[2];
365     int rc = 0;
366     int new_key = 0;
367     int mod_key = 0;
368
369     /* get the key and print some info about it */
370     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
371     if( !node )
372         BUG();
373
374     pk = node->pkt->pkt.public_key;
375     keyid_from_pk( pk, keyid );
376     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
377
378     if( opt.verbose ) {
379         log_info( "pub  %4u%c/%08lX %s   ",
380                   nbits_from_pk( pk ),
381                   pubkey_letter( pk->pubkey_algo ),
382                   (ulong)keyid[1], datestr_from_pk(pk) );
383         if( uidnode )
384             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
385                                        uidnode->pkt->pkt.user_id->len );
386         putc('\n', stderr);
387     }
388     if( !uidnode ) {
389         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
390         return 0;
391     }
392
393     clear_kbnode_flags( keyblock );
394     rc = chk_self_sigs( fname, keyblock , pk, keyid );
395     if( rc )
396         return rc== -1? 0:rc;
397
398     if( opt.allow_non_selfsigned_uid )
399         mark_non_selfsigned_uids_valid( keyblock, keyid );
400
401     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
402         if( !opt.quiet ) {
403             log_info( _("key %08lX: no valid user IDs\n"),
404                                                         (ulong)keyid[1]);
405             log_info(_("this may be caused by a missing self-signature\n"));
406         }
407         stats.no_user_id++;
408         return 0;
409     }
410
411
412     /* do we have this key already in one of our pubrings ? */
413     pk_orig = gcry_xcalloc( 1, sizeof *pk_orig );
414     rc = get_pubkey( pk_orig, keyid );
415     if( rc && rc != GPGERR_NO_PUBKEY ) {
416         log_error( _("key %08lX: public key not found: %s\n"),
417                                 (ulong)keyid[1], gpg_errstr(rc));
418     }
419     else if ( rc && opt.merge_only ) {
420         if( opt.verbose )
421             log_info( _("key %08lX: new key - skipped\n"), (ulong)keyid[1] );
422         rc = 0;
423         fast = 1; /* so that we don't get into the trustdb update */
424         stats.skipped_new_keys++;
425     }
426     else if( rc ) { /* insert this key */
427 #if 0 /* we don't know wehre we are going to write */
428         if( opt.verbose > 1 )
429             log_info( _("writing to `%s'\n"),
430                       keyblock_resource_name(kbpos) );
431 #endif
432         if( (rc=insert_keyblock( keyblock )) )
433            log_error( _("error writing key: %s\n"), gpg_errstr(rc) );
434         /* we are ready */
435         if( !opt.quiet )
436             log_info( _("key %08lX: public key imported\n"), (ulong)keyid[1]);
437         if( is_status_enabled() ) {
438             char *us = get_long_user_id_string( keyid );
439             write_status_text( STATUS_IMPORTED, us );
440             gcry_free(us);
441         }
442         stats.imported++;
443         if( is_RSA( pk->pubkey_algo ) )
444             stats.imported_rsa++;
445         new_key = 1;
446     }
447     else { /* merge */
448         int n_uids, n_sigs, n_subk;
449
450         /* Compare the original against the new key; just to be sure nothing
451          * weird is going on */
452         if( cmp_public_keys( pk_orig, pk ) ) {
453             log_error( _("key %08lX: doesn't match our copy\n"),
454                                                           (ulong)keyid[1]);
455             rc = GPGERR_GENERAL;
456             goto leave;
457         }
458
459         /* now read the original keyblock */
460         rc = find_keyblock_bypk( &keyblock_orig, pk_orig );
461         if( rc ) {
462             log_error( _("key %08lX: can't locate original keyblock: %s\n"),
463                                      (ulong)keyid[1], gpg_errstr(rc));
464             goto leave;
465         }
466
467         collapse_uids( &keyblock );
468         /* and try to merge the block */
469         clear_kbnode_flags( keyblock_orig );
470         clear_kbnode_flags( keyblock );
471         n_uids = n_sigs = n_subk = 0;
472         rc = merge_blocks( fname, keyblock_orig, keyblock,
473                                 keyid, &n_uids, &n_sigs, &n_subk );
474         if( rc )
475             goto leave;
476         if( n_uids || n_sigs || n_subk ) {
477             mod_key = 1;
478             /* keyblock_orig has been updated; write */
479             if( (rc=update_keyblock( keyblock_orig )) )
480                 log_error( _("error writing key: %s\n"), gpg_errstr(rc) );
481             /* we are ready */
482             if( !opt.quiet ) {
483                 if( n_uids == 1 )
484                     log_info( _("key %08lX: 1 new user ID\n"),
485                                              (ulong)keyid[1]);
486                 else if( n_uids )
487                     log_info( _("key %08lX: %d new user IDs\n"),
488                                              (ulong)keyid[1], n_uids );
489                 if( n_sigs == 1 )
490                     log_info( _("key %08lX: 1 new signature\n"),
491                                              (ulong)keyid[1]);
492                 else if( n_sigs )
493                     log_info( _("key %08lX: %d new signatures\n"),
494                                              (ulong)keyid[1], n_sigs );
495                 if( n_subk == 1 )
496                     log_info( _("key %08lX: 1 new subkey\n"),
497                                              (ulong)keyid[1]);
498                 else if( n_subk )
499                     log_info( _("key %08lX: %d new subkeys\n"),
500                                              (ulong)keyid[1], n_subk );
501             }
502
503             stats.n_uids +=n_uids;
504             stats.n_sigs +=n_sigs;
505             stats.n_subk +=n_subk;
506         }
507         else {
508             if( !opt.quiet )
509                 log_info( _("key %08lX: not changed\n"), (ulong)keyid[1] );
510             stats.unchanged++;
511         }
512     }
513     if( !rc && !fast ) {
514         rc = query_trust_record( new_key? pk : pk_orig );
515         if( rc && rc != -1 )
516             log_error("trustdb error: %s\n", gpg_errstr(rc) );
517         else if( rc == -1 ) { /* not found trustdb */
518             rc = insert_trust_record( new_key? keyblock : keyblock_orig );
519             if( rc )
520                 log_error("key %08lX: trustdb insert failed: %s\n",
521                                         (ulong)keyid[1], gpg_errstr(rc) );
522         }
523         else if( mod_key )
524             rc = update_trust_record( keyblock_orig, 1, NULL );
525         else
526             rc = clear_trust_checked_flag( new_key? pk : pk_orig );
527     }
528
529   leave:
530     release_kbnode( keyblock_orig );
531     free_public_key( pk_orig );
532     return rc;
533 }
534
535
536 /****************
537  * Ditto for secret keys.  Handling is simpler than for public keys.
538  */
539 static int
540 import_secret_one( const char *fname, KBNODE keyblock )
541 {
542     PKT_secret_key *sk;
543     KBNODE node, uidnode;
544     u32 keyid[2];
545     int rc = 0;
546
547     /* get the key and print some info about it */
548     node = find_kbnode( keyblock, PKT_SECRET_KEY );
549     if( !node )
550         BUG();
551
552     sk = node->pkt->pkt.secret_key;
553     keyid_from_sk( sk, keyid );
554     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
555
556     if( opt.verbose ) {
557         log_info( "sec  %4u%c/%08lX %s   ",
558                   nbits_from_sk( sk ),
559                   pubkey_letter( sk->pubkey_algo ),
560                   (ulong)keyid[1], datestr_from_sk(sk) );
561         if( uidnode )
562             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
563                                        uidnode->pkt->pkt.user_id->len );
564         putc('\n', stderr);
565     }
566     stats.secret_read++;
567     if( !uidnode ) {
568         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
569         return 0;
570     }
571
572     clear_kbnode_flags( keyblock );
573
574     /* do we have this key already in one of our secrings ? */
575     rc = seckey_available( keyid );
576     if( rc == GPGERR_NO_SECKEY && !opt.merge_only ) { /*just insert this key*/
577         if( (rc=insert_keyblock( keyblock )) )
578             log_error( _("error writing key: %s\n"), gpg_errstr(rc) );
579         /* we are ready */
580         if( !opt.quiet )
581             log_info( _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
582         stats.secret_imported++;
583     }
584     else if( !rc ) { /* we can't merge secret keys */
585         log_error( _("key %08lX: already in secret keyring\n"),
586                                                         (ulong)keyid[1]);
587         stats.secret_dups++;
588     }
589     else
590         log_error( _("key %08lX: secret key not found: %s\n"),
591                                 (ulong)keyid[1], gpg_errstr(rc));
592
593     return rc;
594 }
595
596
597 /****************
598  * Import a revocation certificate; this is a single signature packet.
599  */
600 static int
601 import_revoke_cert( const char *fname, KBNODE node )
602 {
603     PKT_public_key *pk=NULL;
604     KBNODE onode, keyblock = NULL;
605     u32 keyid[2];
606     int rc = 0;
607
608     assert( !node->next );
609     assert( node->pkt->pkttype == PKT_SIGNATURE );
610     assert( node->pkt->pkt.signature->sig_class == 0x20 );
611
612     keyid[0] = node->pkt->pkt.signature->keyid[0];
613     keyid[1] = node->pkt->pkt.signature->keyid[1];
614
615     pk = gcry_xcalloc( 1, sizeof *pk );
616     rc = get_pubkey( pk, keyid );
617     if( rc == GPGERR_NO_PUBKEY ) {
618         log_info( _("key %08lX: no public key - "
619                  "can't apply revocation certificate\n"), (ulong)keyid[1]);
620         rc = 0;
621         goto leave;
622     }
623     else if( rc ) {
624         log_error( _("key %08lX: public key not found: %s\n"),
625                                        (ulong)keyid[1], gpg_errstr(rc));
626         goto leave;
627     }
628
629     /* read the original keyblock */
630     rc = find_keyblock_bypk( &keyblock, pk );
631     if( rc ) {
632         log_error( _("key %08lX: can't locate original keyblock: %s\n"),
633                                         (ulong)keyid[1], gpg_errstr(rc));
634         goto leave;
635     }
636
637
638     /* it is okay, that node is not in keyblock because
639      * check_key_signature works fine for sig_class 0x20 in this
640      * special case. */
641     rc = check_key_signature( keyblock, node, NULL);
642     if( rc ) {
643         log_error( _("key %08lX: invalid revocation certificate"
644                   ": %s - rejected\n"), (ulong)keyid[1], gpg_errstr(rc));
645     }
646
647
648     /* check whether we already have this */
649     for(onode=keyblock->next; onode; onode=onode->next ) {
650         if( onode->pkt->pkttype == PKT_USER_ID )
651             break;
652         else if( onode->pkt->pkttype == PKT_SIGNATURE
653                  && onode->pkt->pkt.signature->sig_class == 0x20
654                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
655                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
656             rc = 0;
657             goto leave; /* yes, we already know about it */
658         }
659     }
660
661
662     /* insert it */
663     insert_kbnode( keyblock, clone_kbnode(node), 0 );
664
665     /* and write the keyblock back */
666     if( (rc=update_keyblock( keyblock )) )
667         log_error( _("error writing key: %s\n"), gpg_errstr(rc) );
668     /* we are ready */
669     if( !opt.quiet )
670         log_info( _("key %08lX: revocation certificate imported\n"),
671                                         (ulong)keyid[1]);
672     stats.n_revoc++;
673     if( clear_trust_checked_flag( pk ) ) {
674         /* seems that we have to insert the record first */
675         rc = insert_trust_record( keyblock );
676         if( rc )
677             log_error("key %08lX: trustdb insert failed: %s\n",
678                                         (ulong)keyid[1], gpg_errstr(rc) );
679         else
680             rc = clear_trust_checked_flag( pk );
681     }
682
683   leave:
684     release_kbnode( keyblock );
685     free_public_key( pk );
686     return rc;
687 }
688
689
690 /****************
691  * loop over the keyblock and check all self signatures.
692  * Mark all user-ids with a self-signature by setting flag bit 0.
693  * Mark all user-ids with an invalid self-signature by setting bit 1.
694  * This works also for subkeys, here the subkey is marked.
695  */
696 static int
697 chk_self_sigs( const char *fname, KBNODE keyblock,
698                PKT_public_key *pk, u32 *keyid )
699 {
700     KBNODE n;
701     PKT_signature *sig;
702     int rc;
703
704     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
705         if( n->pkt->pkttype != PKT_SIGNATURE )
706             continue;
707         sig = n->pkt->pkt.signature;
708         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
709             if( (sig->sig_class&~3) == 0x10 ) {
710                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
711                 if( !unode )  {
712                     log_error( _("key %08lX: no user ID for signature\n"),
713                                             (ulong)keyid[1]);
714                     return -1;  /* the complete keyblock is invalid */
715                 }
716                 rc = check_key_signature( keyblock, n, NULL);
717                 if( rc ) {
718                     log_info( rc == GPGERR_PUBKEY_ALGO ?
719                          _("key %08lX: unsupported public key algorithm\n"):
720                          _("key %08lX: invalid self-signature\n"),
721                                      (ulong)keyid[1]);
722
723                     unode->flag |= 2; /* mark as invalid */
724                 }
725                 unode->flag |= 1; /* mark that signature checked */
726             }
727             else if( sig->sig_class == 0x18 ) {
728                 KBNODE knode = find_prev_kbnode( keyblock,
729                                                  n, PKT_PUBLIC_SUBKEY );
730                 if( !knode )
731                     knode = find_prev_kbnode( keyblock,
732                                                  n, PKT_SECRET_SUBKEY );
733
734                 if( !knode ) {
735                     log_info( _("key %08lX: no subkey for key binding\n"),
736                                             (ulong)keyid[1]);
737                     n->flag |= 4; /* delete this */
738                 }
739                 else {
740                     rc = check_key_signature( keyblock, n, NULL);
741                     if( rc ) {
742                         log_info(  rc == GPGERR_PUBKEY_ALGO ?
743                            _("key %08lX: unsupported public key algorithm\n"):
744                            _("key %08lX: invalid subkey binding\n"),
745                                          (ulong)keyid[1]);
746
747                         knode->flag |= 2; /* mark as invalid */
748                     }
749                     knode->flag |= 1; /* mark that signature checked */
750                 }
751             }
752         }
753     }
754     return 0;
755 }
756
757
758
759 /****************
760  * If a user ID has at least one signature, mark it as valid
761  */
762 static void
763 mark_non_selfsigned_uids_valid( KBNODE keyblock, u32 *kid )
764 {
765     KBNODE node;
766     for(node=keyblock->next; node; node = node->next ) {
767         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) ) {
768             if( (node->next && node->next->pkt->pkttype == PKT_SIGNATURE)
769                 || !node->next ) {
770                 node->flag |= 1;
771                 log_info( _("key %08lX: accepted non self-signed user ID '"),
772                                                          (ulong)kid[1]);
773                 print_string( log_stream(), node->pkt->pkt.user_id->name,
774                                             node->pkt->pkt.user_id->len, 0 );
775                 fputs("'\n", log_stream() );
776             }
777         }
778     }
779 }
780
781 /****************
782  * delete all parts which are invalid and those signatures whose
783  * public key algorithm is not available in this implemenation;
784  * but consider RSA as valid, because parse/build_packets knows
785  * about it.
786  * returns: true if at least one valid user-id is left over.
787  */
788 static int
789 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
790 {
791     KBNODE node;
792     int nvalid=0, uid_seen=0;
793     const char *p;
794
795     for(node=keyblock->next; node; node = node->next ) {
796         if( node->pkt->pkttype == PKT_USER_ID ) {
797             uid_seen = 1;
798             if( (node->flag & 2) || !(node->flag & 1) ) {
799                 if( opt.verbose ) {
800                     log_info( _("key %08lX: skipped user ID '"),
801                                                          (ulong)keyid[1]);
802                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
803                                        node->pkt->pkt.user_id->len );
804                     fputs("'\n", stderr );
805                 }
806                 delete_kbnode( node ); /* the user-id */
807                 /* and all following packets up to the next user-id */
808                 while( node->next
809                        && node->next->pkt->pkttype != PKT_USER_ID
810                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
811                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
812                     delete_kbnode( node->next );
813                     node = node->next;
814                 }
815             }
816             else
817                 nvalid++;
818         }
819         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
820                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
821             if( (node->flag & 2) || !(node->flag & 1) ) {
822                 if( opt.verbose ) {
823                     log_info( _("key %08lX: skipped subkey\n"),
824                                                          (ulong)keyid[1]);
825                 }
826                 delete_kbnode( node ); /* the subkey */
827                 /* and all following signature packets */
828                 while( node->next
829                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
830                     delete_kbnode( node->next );
831                     node = node->next;
832                 }
833             }
834         }
835         else if( node->pkt->pkttype == PKT_SIGNATURE
836                  && openpgp_pk_test_algo( node->pkt->pkt.signature->pubkey_algo, 0 )
837                  && node->pkt->pkt.signature->pubkey_algo != GCRY_PK_RSA )
838             delete_kbnode( node ); /* build_packet() can't handle this */
839         else if( node->pkt->pkttype == PKT_SIGNATURE
840                  && (p = parse_sig_subpkt2( node->pkt->pkt.signature,
841                                             SIGSUBPKT_EXPORTABLE, NULL ))
842                  && !*p
843                  && seckey_available( node->pkt->pkt.signature->keyid ) ) {
844             /* here we violate the rfc a bit by still allowing
845              * to import non-exportable signature when we have the
846              * the secret key used to create this signature - it
847              * seems that this makes sense */
848             log_info( _("key %08lX: non exportable signature "
849                                     "(class %02x) - skipped\n"),
850                                     (ulong)keyid[1],
851                                      node->pkt->pkt.signature->sig_class );
852             delete_kbnode( node );
853         }
854         else if( node->pkt->pkttype == PKT_SIGNATURE
855                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
856             if( uid_seen ) {
857                 log_error( _("key %08lX: revocation certificate "
858                                      "at wrong place - skipped\n"),
859                                     (ulong)keyid[1]);
860                 delete_kbnode( node );
861             }
862             else {
863                 int rc = check_key_signature( keyblock, node, NULL);
864                 if( rc ) {
865                     log_error( _("key %08lX: invalid revocation "
866                               "certificate: %s - skipped\n"),
867                               (ulong)keyid[1], gpg_errstr(rc));
868                     delete_kbnode( node );
869                 }
870             }
871         }
872         else if( (node->flag & 4) ) /* marked for deletion */
873             delete_kbnode( node );
874     }
875
876     /* note: because keyblock is the public key, it is never marked
877      * for deletion and so keyblock cannot change */
878     commit_kbnode( &keyblock );
879     return nvalid;
880 }
881
882
883 /****************
884  * It may happen that the imported keyblock has duplicated user IDs.
885  * We check this here and collapse those user IDs together with their
886  * sigs into one.
887  * Returns: True if the keyblock hash changed.
888  */
889 int
890 collapse_uids( KBNODE *keyblock )
891 {
892     KBNODE n, n2;
893     int in_uid;
894     int any=0;
895     u32 kid1;
896
897   restart:
898     for( n = *keyblock; n; n = n->next ) {
899         if( n->pkt->pkttype != PKT_USER_ID )
900             continue;
901         for( n2 = n->next; n2; n2 = n2->next ) {
902             if( n2->pkt->pkttype == PKT_USER_ID
903                 && !cmp_user_ids( n->pkt->pkt.user_id,
904                                   n2->pkt->pkt.user_id ) ) {
905                 /* found a duplicate */
906                 any = 1;
907                 if( !n2->next
908                     || n2->next->pkt->pkttype == PKT_USER_ID
909                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
910                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
911                     /* no more signatures: delete the user ID
912                      * and start over */
913                     remove_kbnode( keyblock, n2 );
914                 }
915                 else {
916                     /* The simple approach: Move one signature and
917                      * then start over to delete the next one :-( */
918                     move_kbnode( keyblock, n2->next, n->next );
919                 }
920                 goto restart;
921             }
922         }
923     }
924     if( !any )
925         return 0;
926
927   restart_sig:
928     /* now we may have duplicate signatures on one user ID: fix this */
929     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
930         if( n->pkt->pkttype == PKT_USER_ID )
931             in_uid = 1;
932         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
933                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
934             in_uid = 0;
935         else if( in_uid ) {
936             n2 = n;
937             do {
938                 KBNODE ncmp = NULL;
939                 for( ; n2; n2 = n2->next ) {
940                     if(    n2->pkt->pkttype == PKT_USER_ID
941                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
942                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
943                         break;
944                     if( n2->pkt->pkttype != PKT_SIGNATURE )
945                         ;
946                     else if( !ncmp )
947                         ncmp = n2;
948                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
949                                                 n2->pkt->pkt.signature )) {
950                         remove_kbnode( keyblock, n2 );
951                         goto restart_sig;
952                     }
953                 }
954                 n2 = ncmp? ncmp->next : NULL;
955             } while( n2 );
956         }
957     }
958
959     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
960         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
961     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
962         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
963     else
964         kid1 = 0;
965     log_info(_("key %08lX: duplicated user ID detected - merged\n"),
966                                                                  (ulong)kid1);
967
968     return 1;
969 }
970
971
972
973 /****************
974  * compare and merge the blocks
975  *
976  * o compare the signatures: If we already have this signature, check
977  *   that they compare okay; if not, issue a warning and ask the user.
978  * o Simply add the signature.  Can't verify here because we may not have
979  *   the signature's public key yet; verification is done when putting it
980  *   into the trustdb, which is done automagically as soon as this pubkey
981  *   is used.
982  * Note: We indicate newly inserted packets with flag bit 0
983  */
984 static int
985 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
986               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
987 {
988     KBNODE onode, node;
989     int rc, found;
990
991     /* 1st: handle revocation certificates */
992     for(node=keyblock->next; node; node=node->next ) {
993         if( node->pkt->pkttype == PKT_USER_ID )
994             break;
995         else if( node->pkt->pkttype == PKT_SIGNATURE
996                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
997             /* check whether we already have this */
998             found = 0;
999             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1000                 if( onode->pkt->pkttype == PKT_USER_ID )
1001                     break;
1002                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1003                          && onode->pkt->pkt.signature->sig_class == 0x20
1004                          && node->pkt->pkt.signature->keyid[0]
1005                             == onode->pkt->pkt.signature->keyid[0]
1006                          && node->pkt->pkt.signature->keyid[1]
1007                             == onode->pkt->pkt.signature->keyid[1] ) {
1008                     found = 1;
1009                     break;
1010                 }
1011             }
1012             if( !found ) {
1013                 KBNODE n2 = clone_kbnode(node);
1014                 insert_kbnode( keyblock_orig, n2, 0 );
1015                 n2->flag |= 1;
1016                 log_info( _("key %08lX: revocation certificate added\n"),
1017                                          (ulong)keyid[1]);
1018             }
1019         }
1020     }
1021
1022     /* 2nd: try to merge new certificates in */
1023     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1024         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1025             /* find the user id in the imported keyblock */
1026             for(node=keyblock->next; node; node=node->next )
1027                 if( node->pkt->pkttype == PKT_USER_ID
1028                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1029                                           node->pkt->pkt.user_id ) )
1030                     break;
1031             if( node ) { /* found: merge */
1032                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1033                 if( rc )
1034                     return rc;
1035             }
1036         }
1037     }
1038
1039     /* 3rd: add new user-ids */
1040     for(node=keyblock->next; node; node=node->next ) {
1041         if( node->pkt->pkttype == PKT_USER_ID) {
1042             /* do we have this in the original keyblock */
1043             for(onode=keyblock_orig->next; onode; onode=onode->next )
1044                 if( onode->pkt->pkttype == PKT_USER_ID
1045                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1046                                       node->pkt->pkt.user_id ) )
1047                     break;
1048             if( !onode ) { /* this is a new user id: append */
1049                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1050                 if( rc )
1051                     return rc;
1052                 ++*n_uids;
1053             }
1054         }
1055     }
1056
1057     /*  add new subkeys */
1058     for(node=keyblock->next; node; node=node->next ) {
1059         onode = NULL;
1060         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1061             /* do we have this in the original keyblock? */
1062             for(onode=keyblock_orig->next; onode; onode=onode->next )
1063                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1064                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1065                                          node->pkt->pkt.public_key ) )
1066                     break;
1067             if( !onode ) { /* this is a new subkey: append */
1068                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1069                 if( rc )
1070                     return rc;
1071                 ++*n_subk;
1072             }
1073         }
1074         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1075             /* do we have this in the original keyblock? */
1076             for(onode=keyblock_orig->next; onode; onode=onode->next )
1077                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1078                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1079                                          node->pkt->pkt.secret_key ) )
1080                     break;
1081             if( !onode ) { /* this is a new subkey: append */
1082                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1083                 if( rc )
1084                     return rc;
1085                 ++*n_subk;
1086             }
1087         }
1088     }
1089
1090     /* merge subkey certificates */
1091     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1092         if( !(onode->flag & 1)
1093             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1094                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1095             /* find the subkey in the imported keyblock */
1096             for(node=keyblock->next; node; node=node->next ) {
1097                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1098                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1099                                           node->pkt->pkt.public_key ) )
1100                     break;
1101                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1102                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1103                                           node->pkt->pkt.secret_key ) )
1104                     break;
1105             }
1106             if( node ) { /* found: merge */
1107                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1108                 if( rc )
1109                     return rc;
1110             }
1111         }
1112     }
1113
1114
1115     return 0;
1116 }
1117
1118
1119 /****************
1120  * append the userid starting with NODE and all signatures to KEYBLOCK.
1121  */
1122 static int
1123 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1124                                           const char *fname, u32 *keyid )
1125 {
1126     KBNODE n, n_where=NULL;
1127
1128     assert(node->pkt->pkttype == PKT_USER_ID );
1129     if( !node->next || node->next->pkt->pkttype == PKT_USER_ID ) {
1130         log_error( _("key %08lX: our copy has no self-signature\n"),
1131                                                   (ulong)keyid[1]);
1132         return GPGERR_GENERAL;
1133     }
1134
1135     /* find the position */
1136     for( n = keyblock; n; n_where = n, n = n->next ) {
1137         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1138             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1139             break;
1140     }
1141     if( !n )
1142         n_where = NULL;
1143
1144     /* and append/insert */
1145     while( node ) {
1146         /* we add a clone to the original keyblock, because this
1147          * one is released first */
1148         n = clone_kbnode(node);
1149         if( n_where ) {
1150             insert_kbnode( n_where, n, 0 );
1151             n_where = n;
1152         }
1153         else
1154             add_kbnode( keyblock, n );
1155         n->flag |= 1;
1156         node->flag |= 1;
1157         if( n->pkt->pkttype == PKT_SIGNATURE )
1158             ++*n_sigs;
1159
1160         node = node->next;
1161         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1162             break;
1163     }
1164
1165     return 0;
1166 }
1167
1168
1169 /****************
1170  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1171  * (how should we handle comment packets here?)
1172  */
1173 static int
1174 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1175                                     const char *fname, u32 *keyid )
1176 {
1177     KBNODE n, n2;
1178     int found=0;
1179
1180     assert(dst->pkt->pkttype == PKT_USER_ID );
1181     assert(src->pkt->pkttype == PKT_USER_ID );
1182     if( !dst->next || dst->next->pkt->pkttype == PKT_USER_ID ) {
1183         log_error( _("key %08lX: our copy has no self-signature\n"),
1184                                                   (ulong)keyid[1]);
1185         return 0;
1186     }
1187
1188
1189     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1190         if( n->pkt->pkttype != PKT_SIGNATURE )
1191             continue;
1192         if( n->pkt->pkt.signature->sig_class == 0x18
1193             || n->pkt->pkt.signature->sig_class == 0x28 )
1194             continue; /* skip signatures which are only valid on subkeys */
1195         found = 0;
1196         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1197             if( n2->pkt->pkttype == PKT_SIGNATURE
1198                 && n->pkt->pkt.signature->keyid[0]
1199                    == n2->pkt->pkt.signature->keyid[0]
1200                 && n->pkt->pkt.signature->keyid[1]
1201                    == n2->pkt->pkt.signature->keyid[1]
1202                 && n->pkt->pkt.signature->timestamp
1203                    <= n2->pkt->pkt.signature->timestamp
1204                 && n->pkt->pkt.signature->sig_class
1205                    == n2->pkt->pkt.signature->sig_class ) {
1206                 found++;
1207                 break;
1208             }
1209         }
1210         if( !found ) {
1211             /* This signature is new or newer, append N to DST.
1212              * We add a clone to the original keyblock, because this
1213              * one is released first */
1214             n2 = clone_kbnode(n);
1215             insert_kbnode( dst, n2, PKT_SIGNATURE );
1216             n2->flag |= 1;
1217             n->flag |= 1;
1218             ++*n_sigs;
1219         }
1220     }
1221
1222     return 0;
1223 }
1224
1225 /****************
1226  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1227  */
1228 static int
1229 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1230                                     const char *fname, u32 *keyid )
1231 {
1232     KBNODE n, n2;
1233     int found=0;
1234
1235     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1236            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1237
1238     for(n=src->next; n ; n = n->next ) {
1239         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1240             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1241             break;
1242         if( n->pkt->pkttype != PKT_SIGNATURE )
1243             continue;
1244         found = 0;
1245         for(n2=dst->next; n2; n2 = n2->next){
1246             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1247                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1248                 break;
1249             if( n2->pkt->pkttype == PKT_SIGNATURE
1250                 && n->pkt->pkt.signature->keyid[0]
1251                    == n2->pkt->pkt.signature->keyid[0]
1252                 && n->pkt->pkt.signature->keyid[1]
1253                    == n2->pkt->pkt.signature->keyid[1]
1254                 && n->pkt->pkt.signature->timestamp
1255                    <= n2->pkt->pkt.signature->timestamp
1256                 && n->pkt->pkt.signature->sig_class
1257                    == n2->pkt->pkt.signature->sig_class ) {
1258                 found++;
1259                 break;
1260             }
1261         }
1262         if( !found ) {
1263             /* This signature is new or newer, append N to DST.
1264              * We add a clone to the original keyblock, because this
1265              * one is released first */
1266             n2 = clone_kbnode(n);
1267             insert_kbnode( dst, n2, PKT_SIGNATURE );
1268             n2->flag |= 1;
1269             n->flag |= 1;
1270             ++*n_sigs;
1271         }
1272     }
1273
1274     return 0;
1275 }
1276
1277 /****************
1278  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1279  * Mark all new and copied packets by setting flag bit 0.
1280  */
1281 static int
1282 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1283                                           const char *fname, u32 *keyid )
1284 {
1285     KBNODE n;
1286
1287     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1288            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1289
1290     while(  node ) {
1291         /* we add a clone to the original keyblock, because this
1292          * one is released first */
1293         n = clone_kbnode(node);
1294         add_kbnode( keyblock, n );
1295         n->flag |= 1;
1296         node->flag |= 1;
1297         if( n->pkt->pkttype == PKT_SIGNATURE )
1298             ++*n_sigs;
1299
1300         node = node->next;
1301         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1302             break;
1303     }
1304
1305     return 0;
1306 }
1307