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