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