Some bug fixes of the last release
[gnupg.git] / g10 / import.c
1 /* import.c
2  *      Copyright (C) 1998 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
38
39 static struct {
40     ulong no_user_id;
41     ulong imported;
42     ulong imported_rsa;
43     ulong n_uids;
44     ulong n_sigs;
45     ulong n_subk;
46     ulong unchanged;
47     ulong n_revoc;
48     ulong secret_read;
49     ulong secret_imported;
50     ulong secret_dups;
51 } stats;
52
53
54 static int read_block( IOBUF a, compress_filter_context_t *cfx,
55                              PACKET **pending_pkt, KBNODE *ret_root );
56 static int import_one( const char *fname, KBNODE keyblock, int fast );
57 static int import_secret_one( const char *fname, KBNODE keyblock );
58 static int import_revoke_cert( const char *fname, KBNODE node );
59 static int chk_self_sigs( const char *fname, KBNODE keyblock,
60                           PKT_public_key *pk, u32 *keyid );
61 static int delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid );
62 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
63                          KBNODE keyblock, u32 *keyid,
64                          int *n_uids, int *n_sigs, int *n_subk );
65 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
66                              const char *fname, u32 *keyid );
67 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
68                              const char *fname, u32 *keyid );
69
70
71 /****************
72  * Import the public keys from the given filename. Input may be armored.
73  * This function rejects all keys which are not validly self signed on at
74  * least one userid. Only user ids which are self signed will be imported.
75  * Other signatures are not checked.
76  *
77  * Actually this function does a merge. It works like this:
78  *
79  *  - get the keyblock
80  *  - check self-signatures and remove all userids and their signatures
81  *    without/invalid self-signatures.
82  *  - reject the keyblock, if we have no valid userid.
83  *  - See whether we have this key already in one of our pubrings.
84  *    If not, simply add it to the default keyring.
85  *  - Compare the key and the self-signatures of the new and the one in
86  *    our keyring.  If they are different something weird is going on;
87  *    ask what to do.
88  *  - See whether we have only non-self-signature on one user id; if not
89  *    ask the user what to do.
90  *  - compare the signatures: If we already have this signature, check
91  *    that they compare okay; if not, issue a warning and ask the user.
92  *    (consider looking at the timestamp and use the newest?)
93  *  - Simply add the signature.  Can't verify here because we may not have
94  *    the signature's public key yet; verification is done when putting it
95  *    into the trustdb, which is done automagically as soon as this pubkey
96  *    is used.
97  *  - Proceed with next signature.
98  *
99  *  Key revocation certificates have special handling.
100  *
101  */
102 int
103 import_keys( const char *fname, int fast )
104 {
105     armor_filter_context_t afx;
106     compress_filter_context_t cfx;
107     PACKET *pending_pkt = NULL;
108     IOBUF inp = NULL;
109     KBNODE keyblock;
110     int rc = 0;
111     ulong count=0;
112
113     memset( &afx, 0, sizeof afx);
114     memset( &cfx, 0, sizeof cfx);
115     afx.only_keyblocks = 1;
116
117     /* fixme: don't use static variables */
118     memset( &stats, 0, sizeof( stats ) );
119
120     /* open file */
121     inp = iobuf_open(fname);
122     if( !fname )
123         fname = "[stdin]";
124     if( !inp ) {
125         log_error_f(fname, _("can't open file: %s\n"), strerror(errno) );
126         return G10ERR_OPEN_FILE;
127     }
128
129     if( !opt.no_armor ) /* armored reading is not disabled */
130         iobuf_push_filter( inp, armor_filter, &afx );
131
132     while( !(rc = read_block( inp, &cfx, &pending_pkt, &keyblock) )) {
133         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
134             rc = import_one( fname, keyblock, fast );
135         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY )
136             rc = import_secret_one( fname, keyblock );
137         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
138                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
139             rc = import_revoke_cert( fname, keyblock );
140         else {
141             log_info_f(fname, _("skipping block of type %d\n"),
142                                             keyblock->pkt->pkttype );
143         }
144         release_kbnode(keyblock);
145         if( rc )
146             break;
147         if( !(++count % 100) )
148             log_info(_("%lu keys so far processed\n"), count );
149     }
150     if( rc == -1 )
151         rc = 0;
152     else if( rc && rc != G10ERR_INV_KEYRING )
153         log_error_f( fname, _("read error: %s\n"), g10_errstr(rc));
154
155     log_info(_("Total number processed: %lu\n"), count );
156     if( stats.no_user_id )
157         log_info(_("          w/o user IDs: %lu\n"), stats.no_user_id );
158     if( stats.imported || stats.imported_rsa ) {
159         log_info(_("              imported: %lu"), stats.imported );
160         if( stats.imported_rsa )
161             fprintf(stderr, "  (RSA: %lu)", stats.imported_rsa );
162         putc('\n', stderr);
163     }
164     if( stats.unchanged )
165         log_info(_("             unchanged: %lu\n"), stats.unchanged );
166     if( stats.n_uids )
167         log_info(_("          new user IDs: %lu\n"), stats.n_uids );
168     if( stats.n_subk )
169         log_info(_("           new subkeys: %lu\n"), stats.n_subk );
170     if( stats.n_sigs )
171         log_info(_("        new signatures: %lu\n"), stats.n_sigs );
172     if( stats.n_revoc )
173         log_info(_("   new key revocations: %lu\n"), stats.n_revoc );
174     if( stats.secret_read )
175         log_info(_("      secret keys read: %lu\n"), stats.secret_read );
176     if( stats.secret_imported )
177         log_info(_("  secret keys imported: %lu\n"), stats.secret_imported );
178     if( stats.secret_dups )
179         log_info(_(" secret keys unchanged: %lu\n"), stats.secret_dups );
180
181
182     iobuf_close(inp);
183     return rc;
184 }
185
186
187 /****************
188  * Read the next keyblock from stream A, CFX is used to handle
189  * compressed keyblocks. PENDING_PKT should be initialzed to NULL
190  * and not chnaged form the caller.
191  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
192  */
193 static int
194 read_block( IOBUF a, compress_filter_context_t *cfx,
195             PACKET **pending_pkt, KBNODE *ret_root )
196 {
197     int rc;
198     PACKET *pkt;
199     KBNODE root = NULL;
200     int in_cert;
201
202     if( *pending_pkt ) {
203         root = new_kbnode( *pending_pkt );
204         *pending_pkt = NULL;
205         in_cert = 1;
206     }
207     else
208         in_cert = 0;
209     pkt = m_alloc( sizeof *pkt );
210     init_packet(pkt);
211     while( (rc=parse_packet(a, pkt)) != -1 ) {
212         if( rc ) {  /* ignore errors */
213             if( rc != G10ERR_UNKNOWN_PACKET ) {
214                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
215                 rc = G10ERR_INV_KEYRING;
216                 goto ready;
217             }
218             free_packet( pkt );
219             init_packet(pkt);
220             continue;
221         }
222
223         if( !root && pkt->pkttype == PKT_SIGNATURE
224                   && pkt->pkt.signature->sig_class == 0x20 ) {
225             /* this is a revocation certificate which is handled
226              * in a special way */
227             root = new_kbnode( pkt );
228             pkt = NULL;
229             goto ready;
230         }
231
232         /* make a linked list of all packets */
233         switch( pkt->pkttype ) {
234           case PKT_COMPRESSED:
235             if( pkt->pkt.compressed->algorithm < 1
236                 || pkt->pkt.compressed->algorithm > 2 ) {
237                 rc = G10ERR_COMPR_ALGO;
238                 goto ready;
239             }
240             cfx->algo = pkt->pkt.compressed->algorithm;
241             pkt->pkt.compressed->buf = NULL;
242             iobuf_push_filter( a, compress_filter, cfx );
243             free_packet( pkt );
244             init_packet(pkt);
245             break;
246
247
248           case PKT_PUBLIC_KEY:
249           case PKT_SECRET_KEY:
250             if( in_cert ) { /* store this packet */
251                 *pending_pkt = pkt;
252                 pkt = NULL;
253                 goto ready;
254             }
255             in_cert = 1;
256           default:
257             if( in_cert ) {
258                 if( !root )
259                     root = new_kbnode( pkt );
260                 else
261                     add_kbnode( root, new_kbnode( pkt ) );
262                 pkt = m_alloc( sizeof *pkt );
263             }
264             init_packet(pkt);
265             break;
266         }
267     }
268   ready:
269     if( rc == -1 && root )
270         rc = 0;
271
272     if( rc )
273         release_kbnode( root );
274     else
275         *ret_root = root;
276     free_packet( pkt );
277     m_free( pkt );
278     return rc;
279 }
280
281
282 /****************
283  * Try to import one keyblock.  Return an error only in serious cases, but
284  * never for an invalid keyblock.  It uses log_error to increase the
285  * internal errorcount, so that invalid input can be detected by programs
286  * which called g10.
287  */
288 static int
289 import_one( const char *fname, KBNODE keyblock, int fast )
290 {
291     PKT_public_key *pk;
292     PKT_public_key *pk_orig;
293     KBNODE node, uidnode;
294     KBNODE keyblock_orig = NULL;
295     KBPOS kbpos;
296     u32 keyid[2];
297     int rc = 0;
298     int new_key = 0;
299     int mod_key = 0;
300
301     /* get the key and print some info about it */
302     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
303     if( !node )
304         BUG();
305
306     pk = node->pkt->pkt.public_key;
307     keyid_from_pk( pk, keyid );
308     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
309
310     if( opt.verbose ) {
311         log_info_f( fname, "pub  %4u%c/%08lX %s   ",
312                   nbits_from_pk( pk ),
313                   pubkey_letter( pk->pubkey_algo ),
314                   (ulong)keyid[1], datestr_from_pk(pk) );
315         if( uidnode )
316             print_string( stderr, uidnode->pkt->pkt.user_id->name,
317                                   uidnode->pkt->pkt.user_id->len, 0 );
318         putc('\n', stderr);
319     }
320     if( !uidnode ) {
321         log_error_f(fname, _("key %08lX: no user id\n"), (ulong)keyid[1]);
322         return 0;
323     }
324
325     clear_kbnode_flags( keyblock );
326     rc = chk_self_sigs( fname, keyblock , pk, keyid );
327     if( rc )
328         return rc== -1? 0:rc;
329
330     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
331         if( !opt.quiet ) {
332             log_info_f( fname, _("key %08lX: no valid user ids\n"),
333                                                         (ulong)keyid[1]);
334             log_info(_("this may be caused by a missing self-signature\n"));
335         }
336         stats.no_user_id++;
337         return 0;
338     }
339
340
341     /* do we have this key already in one of our pubrings ? */
342     pk_orig = m_alloc_clear( sizeof *pk_orig );
343     rc = get_pubkey( pk_orig, keyid );
344     if( rc && rc != G10ERR_NO_PUBKEY ) {
345         log_error_f( fname, _("key %08lX: public key not found: %s\n"),
346                                 (ulong)keyid[1], g10_errstr(rc));
347     }
348     else if( rc ) { /* insert this key */
349         /* get default resource */
350         if( get_keyblock_handle( NULL, 0, &kbpos ) ) {
351             log_error(_("no default public keyring\n"));
352             return G10ERR_GENERAL;
353         }
354         if( opt.verbose > 1 )
355             log_info_f( fname, _("writing to '%s'\n"),
356                                 keyblock_resource_name(&kbpos) );
357         if( (rc=lock_keyblock( &kbpos )) )
358             log_error_f( keyblock_resource_name(&kbpos),
359                         _("can't lock public keyring: %s\n"), g10_errstr(rc) );
360         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
361             log_error_f( keyblock_resource_name(&kbpos),
362                         _("can't write to keyring: %s\n"), g10_errstr(rc) );
363         unlock_keyblock( &kbpos );
364         /* we are ready */
365         if( !opt.quiet )
366             log_info_f( fname, _("key %08lX: public key imported\n"),
367                                                       (ulong)keyid[1]);
368         stats.imported++;
369         if( is_RSA( pk->pubkey_algo ) )
370             stats.imported_rsa++;
371         new_key = 1;
372     }
373     else { /* merge */
374         int n_uids, n_sigs, n_subk;
375
376         /* Compare the original against the new key; just to be sure nothing
377          * weird is going on */
378         if( cmp_public_keys( pk_orig, pk ) ) {
379             log_error_f( fname, _("key %08lX: doesn't match our copy\n"),
380                                                           (ulong)keyid[1]);
381             rc = G10ERR_GENERAL;
382             goto leave;
383         }
384
385         /* See whether we have only non-self-signature on one user id; if not
386          * ask the user what to do. <--- fixme */
387
388         /* now read the original keyblock */
389         rc = find_keyblock_bypk( &kbpos, pk_orig );
390         if( rc ) {
391             log_error_f(fname,
392                         _("key %08lX: can't locate original keyblock: %s\n"),
393                                      (ulong)keyid[1], g10_errstr(rc));
394             goto leave;
395         }
396         rc = read_keyblock( &kbpos, &keyblock_orig );
397         if( rc ) {
398             log_error_f(fname,
399                         _("key %08lX: can't read original keyblock: %s\n"),
400                                             (ulong)keyid[1], g10_errstr(rc));
401             goto leave;
402         }
403         /* and try to merge the block */
404         clear_kbnode_flags( keyblock_orig );
405         clear_kbnode_flags( keyblock );
406         n_uids = n_sigs = n_subk = 0;
407         rc = merge_blocks( fname, keyblock_orig, keyblock,
408                                 keyid, &n_uids, &n_sigs, &n_subk );
409         if( rc )
410             goto leave;
411         if( n_uids || n_sigs || n_subk ) {
412             mod_key = 1;
413             /* keyblock_orig has been updated; write */
414             if( opt.verbose > 1 )
415                 log_info_f(keyblock_resource_name(&kbpos),
416                                       _("writing keyblock\n"));
417             if( (rc=lock_keyblock( &kbpos )) )
418                 log_error_f(keyblock_resource_name(&kbpos),
419                          _("can't lock public keyring: %s\n"), g10_errstr(rc) );
420             else if( (rc=update_keyblock( &kbpos, keyblock_orig )) )
421                 log_error_f( keyblock_resource_name(&kbpos),
422                             _("can't write keyblock: %s\n"), g10_errstr(rc) );
423             unlock_keyblock( &kbpos );
424             /* we are ready */
425             if( !opt.quiet ) {
426                 if( n_uids == 1 )
427                     log_info_f(fname, _("key %08lX: 1 new user-id\n"),
428                                              (ulong)keyid[1]);
429                 else if( n_uids )
430                     log_info_f(fname, _("key %08lX: %d new user-ids\n"),
431                                              (ulong)keyid[1], n_uids );
432                 if( n_sigs == 1 )
433                     log_info_f(fname, _("key %08lX: 1 new signature\n"),
434                                              (ulong)keyid[1]);
435                 else if( n_sigs )
436                     log_info_f(fname, _("key %08lX: %d new signatures\n"),
437                                              (ulong)keyid[1], n_sigs );
438                 if( n_subk == 1 )
439                     log_info_f(fname, _("key %08lX: 1 new subkey\n"),
440                                              (ulong)keyid[1]);
441                 else if( n_subk )
442                     log_info_f(fname, _("key %08lX: %d new subkeys\n"),
443                                              (ulong)keyid[1], n_subk );
444             }
445
446             stats.n_uids +=n_uids;
447             stats.n_sigs +=n_sigs;
448             stats.n_subk +=n_subk;
449         }
450         else {
451             if( !opt.quiet )
452                 log_info_f(fname, _("key %08lX: not changed\n"),
453                                                     (ulong)keyid[1] );
454             stats.unchanged++;
455         }
456     }
457     if( !rc && !fast ) {
458         rc = query_trust_record( new_key? pk : pk_orig );
459         if( rc && rc != -1 )
460             log_error("trustdb error: %s\n", g10_errstr(rc) );
461         else if( rc == -1 ) { /* not found trustdb */
462             rc = insert_trust_record( new_key? pk : pk_orig );
463             if( rc )
464                 log_error("key %08lX: trustdb insert failed: %s\n",
465                                         (ulong)keyid[1], g10_errstr(rc) );
466         }
467         else if( mod_key )
468             rc = update_trust_record( keyblock_orig, 1, NULL );
469         else
470             rc = clear_trust_checked_flag( new_key? pk : pk_orig );
471     }
472
473   leave:
474     release_kbnode( keyblock_orig );
475     free_public_key( pk_orig );
476     return rc;
477 }
478
479
480 /****************
481  * Ditto for secret keys.  Handling is simpler than for public keys.
482  */
483 static int
484 import_secret_one( const char *fname, KBNODE keyblock )
485 {
486     PKT_secret_key *sk;
487     KBNODE node, uidnode;
488     KBPOS kbpos;
489     u32 keyid[2];
490     int rc = 0;
491
492     /* get the key and print some info about it */
493     node = find_kbnode( keyblock, PKT_SECRET_KEY );
494     if( !node )
495         BUG();
496
497     sk = node->pkt->pkt.secret_key;
498     keyid_from_sk( sk, keyid );
499     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
500
501     if( opt.verbose ) {
502         log_info_f(fname, "sec  %4u%c/%08lX %s   ",
503                   nbits_from_sk( sk ),
504                   pubkey_letter( sk->pubkey_algo ),
505                   (ulong)keyid[1], datestr_from_sk(sk) );
506         if( uidnode )
507             print_string( stderr, uidnode->pkt->pkt.user_id->name,
508                                   uidnode->pkt->pkt.user_id->len, 0 );
509         putc('\n', stderr);
510     }
511     stats.secret_read++;
512     if( !uidnode ) {
513         log_error_f(fname, _("key %08lX: no user id\n"), (ulong)keyid[1]);
514         return 0;
515     }
516
517     clear_kbnode_flags( keyblock );
518
519     /* do we have this key already in one of our secrings ? */
520     rc = seckey_available( keyid );
521     if( rc == G10ERR_NO_SECKEY ) { /* simply insert this key */
522         /* get default resource */
523         if( get_keyblock_handle( NULL, 1, &kbpos ) ) {
524             log_error("no default secret keyring\n");
525             return G10ERR_GENERAL;
526         }
527         if( opt.verbose > 1 )
528             log_info_f(keyblock_resource_name(&kbpos), _("writing keyblock\n"));
529         if( (rc=lock_keyblock( &kbpos )) )
530             log_error_f( keyblock_resource_name(&kbpos),
531                       _("can't lock secret keyring: %s\n"), g10_errstr(rc) );
532         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
533             log_error_f(keyblock_resource_name(&kbpos),
534                       _("can't write keyring: %s\n"), g10_errstr(rc) );
535         unlock_keyblock( &kbpos );
536         /* we are ready */
537         log_info_f(fname, _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
538         stats.secret_imported++;
539     }
540     else if( !rc ) { /* we can't merge secret keys */
541         log_error_f(fname, _("key %08lX: already in secret keyring\n"),
542                                                 (ulong)keyid[1]);
543         stats.secret_dups++;
544     }
545     else
546         log_error_f(fname, _("key %08lX: secret key not found: %s\n"),
547                                 (ulong)keyid[1], g10_errstr(rc));
548
549     return rc;
550 }
551
552
553 /****************
554  * Import a revocation certificate; this is a single signature packet.
555  */
556 static int
557 import_revoke_cert( const char *fname, KBNODE node )
558 {
559     PKT_public_key *pk=NULL;
560     KBNODE onode, keyblock = NULL;
561     KBPOS kbpos;
562     u32 keyid[2];
563     int rc = 0;
564
565     assert( !node->next );
566     assert( node->pkt->pkttype == PKT_SIGNATURE );
567     assert( node->pkt->pkt.signature->sig_class == 0x20 );
568
569     keyid[0] = node->pkt->pkt.signature->keyid[0];
570     keyid[1] = node->pkt->pkt.signature->keyid[1];
571
572     pk = m_alloc_clear( sizeof *pk );
573     rc = get_pubkey( pk, keyid );
574     if( rc == G10ERR_NO_PUBKEY ) {
575         log_info_f(fname, _("key %08lX: no public key - "
576                  "can't apply revocation certificate\n"), (ulong)keyid[1]);
577         rc = 0;
578         goto leave;
579     }
580     else if( rc ) {
581         log_error_f(fname, _("key %08lX: public key not found: %s\n"),
582                                        (ulong)keyid[1], g10_errstr(rc));
583         goto leave;
584     }
585
586     /* read the original keyblock */
587     rc = find_keyblock_bypk( &kbpos, pk );
588     if( rc ) {
589         log_error_f(fname,
590                 _("key %08lX: can't locate original keyblock: %s\n"),
591                                         (ulong)keyid[1], g10_errstr(rc));
592         goto leave;
593     }
594     rc = read_keyblock( &kbpos, &keyblock );
595     if( rc ) {
596         log_error_f(fname,
597                 _("key %08lX: can't read original keyblock: %s\n"),
598                                         (ulong)keyid[1], g10_errstr(rc));
599         goto leave;
600     }
601
602
603     /* it is okay, that node is not in keyblock because
604      * check_key_signature works fine for sig_class 0x20 in this
605      * special case. */
606     rc = check_key_signature( keyblock, node, NULL);
607     if( rc ) {
608         log_error_f(fname, _("key %08lX: invalid revocation certificate"
609                   ": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
610     }
611
612
613     /* check whether we already have this */
614     for(onode=keyblock->next; onode; onode=onode->next ) {
615         if( onode->pkt->pkttype == PKT_USER_ID )
616             break;
617         else if( onode->pkt->pkttype == PKT_SIGNATURE
618                  && onode->pkt->pkt.signature->sig_class == 0x20
619                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
620                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
621             rc = 0;
622             goto leave; /* yes, we already know about it */
623         }
624     }
625
626
627     /* insert it */
628     insert_kbnode( keyblock, clone_kbnode(node), 0 );
629
630     /* and write the keyblock back */
631     if( opt.verbose > 1 )
632         log_info_f( keyblock_resource_name(&kbpos), _("writing keyblock\n"));
633     if( (rc=lock_keyblock( &kbpos )) )
634         log_error_f( keyblock_resource_name(&kbpos),
635                     _("can't lock public keyring: %s\n"), g10_errstr(rc) );
636     else if( (rc=update_keyblock( &kbpos, keyblock )) )
637         log_error_f(keyblock_resource_name(&kbpos),
638                     _("can't write keyblock: %s\n"), g10_errstr(rc) );
639     unlock_keyblock( &kbpos );
640     /* we are ready */
641     if( !opt.quiet )
642         log_info_f(fname, _("key %08lX: revocation certificate imported\n"),
643                                         (ulong)keyid[1]);
644     stats.n_revoc++;
645
646   leave:
647     release_kbnode( keyblock );
648     free_public_key( pk );
649     return rc;
650 }
651
652
653 /****************
654  * loop over the keyblock and check all self signatures.
655  * Mark all user-ids with a self-signature by setting flag bit 0.
656  * Mark all user-ids with an invalid self-signature by setting bit 1.
657  */
658 static int
659 chk_self_sigs( const char *fname, KBNODE keyblock,
660                PKT_public_key *pk, u32 *keyid )
661 {
662     KBNODE n, unode;
663     PKT_signature *sig;
664     int rc;
665
666     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
667         if( n->pkt->pkttype != PKT_SIGNATURE )
668             continue;
669         sig = n->pkt->pkt.signature;
670         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
671             unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
672             if( !unode )  {
673                 log_error_f(fname, _("key %08lX: no user-id for signature\n"),
674                                         (ulong)keyid[1]);
675                 return -1;  /* the complete keyblock is invalid */
676             }
677             rc = check_key_signature( keyblock, n, NULL);
678             if( rc ) {
679                 log_error_f( fname,  rc == G10ERR_PUBKEY_ALGO ?
680                           _("key %08lX: unsupported public key algorithm\n"):
681                           _("key %08lX: invalid self-signature\n"),
682                                  (ulong)keyid[1]);
683
684                 unode->flag |= 2; /* mark as invalid */
685             }
686             unode->flag |= 1; /* mark that user-id checked */
687         }
688     }
689     return 0;
690 }
691
692 /****************
693  * delete all parts which are invalid and those signatures whose
694  * public key algorithm is not available in this implemenation;
695  * but consider RSA as valid, because parse/build_packets knows
696  * about it.
697  * returns: true if at least one valid user-id is left over.
698  */
699 static int
700 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
701 {
702     KBNODE node;
703     int nvalid=0, uid_seen=0;
704
705     for(node=keyblock->next; node; node = node->next ) {
706         if( node->pkt->pkttype == PKT_USER_ID ) {
707             uid_seen = 1;
708             if( (node->flag & 2) || !(node->flag & 1) ) {
709                 if( opt.verbose ) {
710                     log_info_f(fname, _("key %08lX: skipped userid '"),
711                                                          (ulong)keyid[1]);
712                     print_string( stderr, node->pkt->pkt.user_id->name,
713                                       node->pkt->pkt.user_id->len, 0 );
714                     fputs("'\n", stderr );
715                 }
716                 delete_kbnode( node ); /* the user-id */
717                 /* and all following packets up to the next user-id */
718                 while( node->next && node->next->pkt->pkttype != PKT_USER_ID ){
719                     delete_kbnode( node->next );
720                     node = node->next;
721                 }
722             }
723             else
724                 nvalid++;
725         }
726         else if( node->pkt->pkttype == PKT_SIGNATURE
727                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
728                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
729             delete_kbnode( node ); /* build_packet() can't handle this */
730         else if( node->pkt->pkttype == PKT_SIGNATURE
731                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
732             if( uid_seen ) {
733                 log_error_f(fname, _("key %08lX: revocation certificate "
734                                      "at wrong place - skipped\n"),
735                                     (ulong)keyid[1]);
736                 delete_kbnode( node );
737             }
738             else {
739                 int rc = check_key_signature( keyblock, node, NULL);
740                 if( rc ) {
741                     log_error_f(fname, _("key %08lX: invalid revocation "
742                               "certificate: %s - skipped\n"),
743                               (ulong)keyid[1], g10_errstr(rc));
744                     delete_kbnode( node );
745                 }
746             }
747         }
748     }
749
750     /* note: because keyblock is the public key, it is never marked
751      * for deletion and so keyblock cannot change */
752     commit_kbnode( &keyblock );
753     return nvalid;
754 }
755
756
757 /****************
758  * compare and merge the blocks
759  *
760  * o compare the signatures: If we already have this signature, check
761  *   that they compare okay; if not, issue a warning and ask the user.
762  *   FIXME: add the check that we don't have duplicate signatures and the
763  *   warning in cases where the old/new signatures don't match.
764  * o Simply add the signature.  Can't verify here because we may not have
765  *   the signature's public key yet; verification is done when putting it
766  *   into the trustdb, which is done automagically as soon as this pubkey
767  *   is used.
768  * Note: We indicate newly inserted packets with flag bit 0
769  */
770 static int
771 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
772               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
773 {
774     KBNODE onode, node;
775     int rc, found;
776
777     /* 1st: handle revocation certificates */
778     for(node=keyblock->next; node; node=node->next ) {
779         if( node->pkt->pkttype == PKT_USER_ID )
780             break;
781         else if( node->pkt->pkttype == PKT_SIGNATURE
782                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
783             /* check whether we already have this */
784             found = 0;
785             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
786                 if( onode->pkt->pkttype == PKT_USER_ID )
787                     break;
788                 else if( onode->pkt->pkttype == PKT_SIGNATURE
789                          && onode->pkt->pkt.signature->sig_class == 0x20
790                          && node->pkt->pkt.signature->keyid[0]
791                             == onode->pkt->pkt.signature->keyid[0]
792                          && node->pkt->pkt.signature->keyid[1]
793                             == onode->pkt->pkt.signature->keyid[1] ) {
794                     found = 1;
795                     break;
796                 }
797             }
798             if( !found ) {
799                 KBNODE n2 = clone_kbnode(node);
800                 insert_kbnode( keyblock_orig, n2, 0 );
801                 n2->flag |= 1;
802                 node->flag |= 1;
803                 log_info_f(fname, _("key %08lX: revocation certificate added\n"),
804                                          (ulong)keyid[1]);
805             }
806         }
807     }
808
809     /* 2nd: try to merge new ones in */
810     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
811         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
812             /* find the user id in the imported keyblock */
813             for(node=keyblock->next; node; node=node->next )
814                 if( !(node->flag & 1)
815                     && node->pkt->pkttype == PKT_USER_ID
816                     && !cmp_user_ids( onode->pkt->pkt.user_id,
817                                           node->pkt->pkt.user_id ) )
818                     break;
819             if( node ) { /* found: merge */
820                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
821                 if( rc )
822                     return rc;
823             }
824         }
825     }
826
827     /* 3rd: add new user-ids */
828     for(node=keyblock->next; node; node=node->next ) {
829         if( !(node->flag & 1) && node->pkt->pkttype == PKT_USER_ID) {
830             /* do we have this in the original keyblock */
831             for(onode=keyblock_orig->next; onode; onode=onode->next )
832                 if( !(onode->flag & 1)
833                     && onode->pkt->pkttype == PKT_USER_ID
834                     && cmp_user_ids( onode->pkt->pkt.user_id,
835                                      node->pkt->pkt.user_id ) )
836                     break;
837             if( !node ) { /* this is a new user id: append */
838                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
839                 if( rc )
840                     return rc;
841                 ++*n_uids;
842             }
843         }
844     }
845
846     /* 4th: add new subkeys */
847     /* FIXME */
848
849     return 0;
850 }
851
852
853 /****************
854  * append the userid starting with NODE and all signatures to KEYBLOCK.
855  * Mark all new and copied packets by setting flag bit 0.
856  */
857 static int
858 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
859                                           const char *fname, u32 *keyid )
860 {
861     KBNODE n;
862
863     assert(node->pkt->pkttype == PKT_USER_ID );
864     /* at lease a self signature comes next to the user-id */
865     if( node->next->pkt->pkttype == PKT_USER_ID ) {
866         log_error_f(fname, _("key %08lX: our copy has no self-signature\n"),
867                                                   (ulong)keyid[1]);
868         return G10ERR_GENERAL;
869     }
870
871     for( ;node && node->pkt->pkttype != PKT_USER_ID; node = node->next ) {
872         /* we add a clone to the original keyblock, because this
873          * one is released first */
874         n = clone_kbnode(node);
875         add_kbnode( keyblock, n );
876         node->flag |= 1;
877         n->flag |= 1;
878         if( n->pkt->pkttype == PKT_SIGNATURE )
879             ++*n_sigs;
880     }
881
882     return 0;
883 }
884
885
886 /****************
887  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
888  * (how should we handle comment packets here?)
889  */
890 static int
891 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
892                                     const char *fname, u32 *keyid )
893 {
894     KBNODE n, n2;
895     int found=0;
896
897     assert(dst->pkt->pkttype == PKT_USER_ID );
898     assert(src->pkt->pkttype == PKT_USER_ID );
899     /* at least a self signature comes next to the user-ids */
900     assert(src->next->pkt->pkttype != PKT_USER_ID );
901     if( dst->next->pkt->pkttype == PKT_USER_ID ) {
902         log_error_f(fname, _("key %08lX: our copy has no self-signature\n"),
903                                                   (ulong)keyid[1]);
904         return 0;
905     }
906
907
908     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
909         if( n->pkt->pkttype != PKT_SIGNATURE )
910             continue;
911         found = 0;
912         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
913             if( n2->pkt->pkttype == PKT_SIGNATURE
914                 && n->pkt->pkt.signature->keyid[0]
915                    == n2->pkt->pkt.signature->keyid[0]
916                 && n->pkt->pkt.signature->keyid[1]
917                    == n2->pkt->pkt.signature->keyid[1] ) {
918             found++;
919             break;
920         }
921
922         if( found ) { /* we already have this signature */
923             /* Hmmm: should we compare the timestamp etc?
924              * but then we have first to see whether this signature is valid
925              * - or simply add it in such a case and let trustdb logic
926              * decide whether to remove the old one
927              */
928             continue;
929         }
930
931         /* This signature is new, append N to DST it.
932          * We add a clone to the original keyblock, because this
933          * one is released first */
934         n2 = clone_kbnode(n);
935         insert_kbnode( dst, n2, PKT_SIGNATURE );
936         n2->flag |= 1;
937         n->flag |= 1;
938         ++*n_sigs;
939     }
940
941     return 0;
942 }
943