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