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