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