See ChangeLog: Wed May 19 16:04:30 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         n_uids = n_sigs = n_subk = 0;
427         rc = collapse_uids( fname, keyblock, keyid );
428         if( rc )
429             goto leave;
430         clear_kbnode_flags( keyblock );
431         rc = merge_blocks( fname, keyblock_orig, keyblock,
432                                 keyid, &n_uids, &n_sigs, &n_subk );
433         if( rc )
434             goto leave;
435         if( n_uids || n_sigs || n_subk ) {
436             mod_key = 1;
437             /* keyblock_orig has been updated; write */
438             if( opt.verbose > 1 )
439                 log_info_f(keyblock_resource_name(&kbpos),
440                                       _("writing keyblock\n"));
441             if( (rc=lock_keyblock( &kbpos )) )
442                 log_error_f(keyblock_resource_name(&kbpos),
443                          _("can't lock public keyring: %s\n"), g10_errstr(rc) );
444             else if( (rc=update_keyblock( &kbpos, keyblock_orig )) )
445                 log_error_f( keyblock_resource_name(&kbpos),
446                             _("can't write keyblock: %s\n"), g10_errstr(rc) );
447             unlock_keyblock( &kbpos );
448             /* we are ready */
449             if( !opt.quiet ) {
450                 if( n_uids == 1 )
451                     log_info_f(fname, _("key %08lX: 1 new user-id\n"),
452                                              (ulong)keyid[1]);
453                 else if( n_uids )
454                     log_info_f(fname, _("key %08lX: %d new user-ids\n"),
455                                              (ulong)keyid[1], n_uids );
456                 if( n_sigs == 1 )
457                     log_info_f(fname, _("key %08lX: 1 new signature\n"),
458                                              (ulong)keyid[1]);
459                 else if( n_sigs )
460                     log_info_f(fname, _("key %08lX: %d new signatures\n"),
461                                              (ulong)keyid[1], n_sigs );
462                 if( n_subk == 1 )
463                     log_info_f(fname, _("key %08lX: 1 new subkey\n"),
464                                              (ulong)keyid[1]);
465                 else if( n_subk )
466                     log_info_f(fname, _("key %08lX: %d new subkeys\n"),
467                                              (ulong)keyid[1], n_subk );
468             }
469
470             stats.n_uids +=n_uids;
471             stats.n_sigs +=n_sigs;
472             stats.n_subk +=n_subk;
473         }
474         else {
475             if( !opt.quiet )
476                 log_info_f(fname, _("key %08lX: not changed\n"),
477                                                     (ulong)keyid[1] );
478             stats.unchanged++;
479         }
480     }
481     if( !rc && !fast ) {
482         rc = query_trust_record( new_key? pk : pk_orig );
483         if( rc && rc != -1 )
484             log_error("trustdb error: %s\n", g10_errstr(rc) );
485         else if( rc == -1 ) { /* not found trustdb */
486             rc = insert_trust_record( new_key? pk : pk_orig );
487             if( rc )
488                 log_error("key %08lX: trustdb insert failed: %s\n",
489                                         (ulong)keyid[1], g10_errstr(rc) );
490         }
491         else if( mod_key )
492             rc = update_trust_record( keyblock_orig, 1, NULL );
493         else
494             rc = clear_trust_checked_flag( new_key? pk : pk_orig );
495     }
496
497   leave:
498     release_kbnode( keyblock_orig );
499     free_public_key( pk_orig );
500     return rc;
501 }
502
503
504 /****************
505  * Ditto for secret keys.  Handling is simpler than for public keys.
506  */
507 static int
508 import_secret_one( const char *fname, KBNODE keyblock )
509 {
510     PKT_secret_key *sk;
511     KBNODE node, uidnode;
512     KBPOS kbpos;
513     u32 keyid[2];
514     int rc = 0;
515
516     /* get the key and print some info about it */
517     node = find_kbnode( keyblock, PKT_SECRET_KEY );
518     if( !node )
519         BUG();
520
521     sk = node->pkt->pkt.secret_key;
522     keyid_from_sk( sk, keyid );
523     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
524
525     if( opt.verbose ) {
526         log_info_f(fname, "sec  %4u%c/%08lX %s   ",
527                   nbits_from_sk( sk ),
528                   pubkey_letter( sk->pubkey_algo ),
529                   (ulong)keyid[1], datestr_from_sk(sk) );
530         if( uidnode )
531             print_string( stderr, uidnode->pkt->pkt.user_id->name,
532                                   uidnode->pkt->pkt.user_id->len, 0 );
533         putc('\n', stderr);
534     }
535     stats.secret_read++;
536     if( !uidnode ) {
537         log_error_f(fname, _("key %08lX: no user id\n"), (ulong)keyid[1]);
538         return 0;
539     }
540
541     clear_kbnode_flags( keyblock );
542
543     /* do we have this key already in one of our secrings ? */
544     rc = seckey_available( keyid );
545     if( rc == G10ERR_NO_SECKEY ) { /* simply insert this key */
546         /* get default resource */
547         if( get_keyblock_handle( NULL, 1, &kbpos ) ) {
548             log_error("no default secret keyring\n");
549             return G10ERR_GENERAL;
550         }
551         if( opt.verbose > 1 )
552             log_info_f(keyblock_resource_name(&kbpos), _("writing keyblock\n"));
553         if( (rc=lock_keyblock( &kbpos )) )
554             log_error_f( keyblock_resource_name(&kbpos),
555                       _("can't lock secret keyring: %s\n"), g10_errstr(rc) );
556         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
557             log_error_f(keyblock_resource_name(&kbpos),
558                       _("can't write keyring: %s\n"), g10_errstr(rc) );
559         unlock_keyblock( &kbpos );
560         /* we are ready */
561         if( !opt.quiet )
562             log_info_f(fname, _("key %08lX: secret key imported\n"),
563                                                       (ulong)keyid[1]);
564         stats.secret_imported++;
565     }
566     else if( !rc ) { /* we can't merge secret keys */
567         log_error_f(fname, _("key %08lX: already in secret keyring\n"),
568                                                 (ulong)keyid[1]);
569         stats.secret_dups++;
570     }
571     else
572         log_error_f(fname, _("key %08lX: secret key not found: %s\n"),
573                                 (ulong)keyid[1], g10_errstr(rc));
574
575     return rc;
576 }
577
578
579 /****************
580  * Import a revocation certificate; this is a single signature packet.
581  */
582 static int
583 import_revoke_cert( const char *fname, KBNODE node )
584 {
585     PKT_public_key *pk=NULL;
586     KBNODE onode, keyblock = NULL;
587     KBPOS kbpos;
588     u32 keyid[2];
589     int rc = 0;
590
591     assert( !node->next );
592     assert( node->pkt->pkttype == PKT_SIGNATURE );
593     assert( node->pkt->pkt.signature->sig_class == 0x20 );
594
595     keyid[0] = node->pkt->pkt.signature->keyid[0];
596     keyid[1] = node->pkt->pkt.signature->keyid[1];
597
598     pk = m_alloc_clear( sizeof *pk );
599     rc = get_pubkey( pk, keyid );
600     if( rc == G10ERR_NO_PUBKEY ) {
601         log_info_f(fname, _("key %08lX: no public key - "
602                  "can't apply revocation certificate\n"), (ulong)keyid[1]);
603         rc = 0;
604         goto leave;
605     }
606     else if( rc ) {
607         log_error_f(fname, _("key %08lX: public key not found: %s\n"),
608                                        (ulong)keyid[1], g10_errstr(rc));
609         goto leave;
610     }
611
612     /* read the original keyblock */
613     rc = find_keyblock_bypk( &kbpos, pk );
614     if( rc ) {
615         log_error_f(fname,
616                 _("key %08lX: can't locate original keyblock: %s\n"),
617                                         (ulong)keyid[1], g10_errstr(rc));
618         goto leave;
619     }
620     rc = read_keyblock( &kbpos, &keyblock );
621     if( rc ) {
622         log_error_f(fname,
623                 _("key %08lX: can't read original keyblock: %s\n"),
624                                         (ulong)keyid[1], g10_errstr(rc));
625         goto leave;
626     }
627
628
629     /* it is okay, that node is not in keyblock because
630      * check_key_signature works fine for sig_class 0x20 in this
631      * special case. */
632     rc = check_key_signature( keyblock, node, NULL);
633     if( rc ) {
634         log_error_f(fname, _("key %08lX: invalid revocation certificate"
635                   ": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
636     }
637
638
639     /* check whether we already have this */
640     for(onode=keyblock->next; onode; onode=onode->next ) {
641         if( onode->pkt->pkttype == PKT_USER_ID )
642             break;
643         else if( onode->pkt->pkttype == PKT_SIGNATURE
644                  && onode->pkt->pkt.signature->sig_class == 0x20
645                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
646                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
647             rc = 0;
648             goto leave; /* yes, we already know about it */
649         }
650     }
651
652
653     /* insert it */
654     insert_kbnode( keyblock, clone_kbnode(node), 0 );
655
656     /* and write the keyblock back */
657     if( opt.verbose > 1 )
658         log_info_f( keyblock_resource_name(&kbpos), _("writing keyblock\n"));
659     if( (rc=lock_keyblock( &kbpos )) )
660         log_error_f( keyblock_resource_name(&kbpos),
661                     _("can't lock public keyring: %s\n"), g10_errstr(rc) );
662     else if( (rc=update_keyblock( &kbpos, keyblock )) )
663         log_error_f(keyblock_resource_name(&kbpos),
664                     _("can't write keyblock: %s\n"), g10_errstr(rc) );
665     unlock_keyblock( &kbpos );
666     /* we are ready */
667     if( !opt.quiet )
668         log_info_f(fname, _("key %08lX: revocation certificate imported\n"),
669                                         (ulong)keyid[1]);
670     stats.n_revoc++;
671
672   leave:
673     release_kbnode( keyblock );
674     free_public_key( pk );
675     return rc;
676 }
677
678
679 /****************
680  * loop over the keyblock and check all self signatures.
681  * Mark all user-ids with a self-signature by setting flag bit 0.
682  * Mark all user-ids with an invalid self-signature by setting bit 1.
683  * This works allso for subkeys, here the subkey is marked.
684  */
685 static int
686 chk_self_sigs( const char *fname, KBNODE keyblock,
687                PKT_public_key *pk, u32 *keyid )
688 {
689     KBNODE n;
690     PKT_signature *sig;
691     int rc;
692
693     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
694         if( n->pkt->pkttype != PKT_SIGNATURE )
695             continue;
696         sig = n->pkt->pkt.signature;
697         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
698             if( (sig->sig_class&~3) == 0x10 ) {
699                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
700                 if( !unode )  {
701                     log_error_f(fname,
702                                 _("key %08lX: no user-id for signature\n"),
703                                             (ulong)keyid[1]);
704                     return -1;  /* the complete keyblock is invalid */
705                 }
706                 rc = check_key_signature( keyblock, n, NULL);
707                 if( rc ) {
708                     log_error_f( fname,  rc == G10ERR_PUBKEY_ALGO ?
709                          _("key %08lX: unsupported public key algorithm\n"):
710                          _("key %08lX: invalid self-signature\n"),
711                                      (ulong)keyid[1]);
712
713                     unode->flag |= 2; /* mark as invalid */
714                 }
715                 unode->flag |= 1; /* mark that signature checked */
716             }
717             else if( sig->sig_class == 0x18 ) {
718                 KBNODE knode = find_prev_kbnode( keyblock,
719                                                  n, PKT_PUBLIC_SUBKEY );
720                 if( !knode )
721                     knode = find_prev_kbnode( keyblock,
722                                                  n, PKT_SECRET_SUBKEY );
723
724                 if( !knode )  {
725                     log_error_f(fname,
726                               _("key %08lX: no subkey for key binding\n"),
727                                             (ulong)keyid[1]);
728                     n->flag |= 4; /* delete this */
729                 }
730                 else {
731                     rc = check_key_signature( keyblock, n, NULL);
732                     if( rc ) {
733                         log_error_f( fname,  rc == G10ERR_PUBKEY_ALGO ?
734                            _("key %08lX: unsupported public key algorithm\n"):
735                            _("key %08lX: invalid subkey binding\n"),
736                                          (ulong)keyid[1]);
737
738                         knode->flag |= 2; /* mark as invalid */
739                     }
740                     knode->flag |= 1; /* mark that signature checked */
741                 }
742             }
743         }
744     }
745     return 0;
746 }
747
748 /****************
749  * delete all parts which are invalid and those signatures whose
750  * public key algorithm is not available in this implemenation;
751  * but consider RSA as valid, because parse/build_packets knows
752  * about it.
753  * returns: true if at least one valid user-id is left over.
754  */
755 static int
756 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
757 {
758     KBNODE node;
759     int nvalid=0, uid_seen=0;
760     const char *p;
761
762     for(node=keyblock->next; node; node = node->next ) {
763         if( node->pkt->pkttype == PKT_USER_ID ) {
764             uid_seen = 1;
765             if( (node->flag & 2) || !(node->flag & 1) ) {
766                 if( opt.verbose ) {
767                     log_info_f(fname, _("key %08lX: skipped userid '"),
768                                                          (ulong)keyid[1]);
769                     print_string( stderr, node->pkt->pkt.user_id->name,
770                                       node->pkt->pkt.user_id->len, 0 );
771                     fputs("'\n", stderr );
772                 }
773                 delete_kbnode( node ); /* the user-id */
774                 /* and all following packets up to the next user-id */
775                 while( node->next
776                        && node->next->pkt->pkttype != PKT_USER_ID
777                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
778                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
779                     delete_kbnode( node->next );
780                     node = node->next;
781                 }
782             }
783             else
784                 nvalid++;
785         }
786         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
787                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
788             if( (node->flag & 2) || !(node->flag & 1) ) {
789                 if( opt.verbose ) {
790                     log_info_f(fname, _("key %08lX: skipped subkey\n"),
791                                                          (ulong)keyid[1]);
792                 }
793                 delete_kbnode( node ); /* the subkey */
794                 /* and all following signature packets */
795                 while( node->next
796                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
797                     delete_kbnode( node->next );
798                     node = node->next;
799                 }
800             }
801         }
802         else if( node->pkt->pkttype == PKT_SIGNATURE
803                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
804                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
805             delete_kbnode( node ); /* build_packet() can't handle this */
806         else if( node->pkt->pkttype == PKT_SIGNATURE
807                  && (p = parse_sig_subpkt2( node->pkt->pkt.signature,
808                                             SIGSUBPKT_EXPORTABLE, NULL ))
809                  && !*p
810                  && seckey_available( node->pkt->pkt.signature->keyid ) ) {
811             /* here we violate the rfc a bit by still allowing
812              * to import non-exportable signature when we have the
813              * the secret key used to create this signature - it
814              * seems that this makes sense */
815             log_info_f(fname, _("key %08lX: non exportable signature "
816                                     "(class %02x) - skipped\n"),
817                                     (ulong)keyid[1],
818                                      node->pkt->pkt.signature->sig_class );
819             delete_kbnode( node );
820         }
821         else if( node->pkt->pkttype == PKT_SIGNATURE
822                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
823             if( uid_seen ) {
824                 log_error_f(fname, _("key %08lX: revocation certificate "
825                                      "at wrong place - skipped\n"),
826                                     (ulong)keyid[1]);
827                 delete_kbnode( node );
828             }
829             else {
830                 int rc = check_key_signature( keyblock, node, NULL);
831                 if( rc ) {
832                     log_error_f(fname, _("key %08lX: invalid revocation "
833                               "certificate: %s - skipped\n"),
834                               (ulong)keyid[1], g10_errstr(rc));
835                     delete_kbnode( node );
836                 }
837             }
838         }
839         else if( (node->flag & 4) ) /* marked for deletion */
840             delete_kbnode( node );
841     }
842
843     /* note: because keyblock is the public key, it is never marked
844      * for deletion and so keyblock cannot change */
845     commit_kbnode( &keyblock );
846     return nvalid;
847 }
848
849
850 /****************
851  * It may happen that the imported keyblock has duplicated user IDs.
852  * We check this here and collapse those user IDs together with their
853  * sigs into one.
854  * This function modifies the node flags!
855  */
856 static int
857 collapse_uids( const char *fname, KBNODE keyblock, u32 *keyid )
858 {
859     KBNODE n, n2, n3;
860     int rc, found;
861
862     for(found = 0, n=keyblock; n && !found ; n = n->next ) {
863         if( n->pkt->pkttype == PKT_USER_ID ) {
864             for( n2 = n->next; n2; n2 = n2->next ) {
865                 if( n2->pkt->pkttype == PKT_USER_ID
866                     && !cmp_user_ids( n->pkt->pkt.user_id,
867                                       n2->pkt->pkt.user_id ) ) {
868                     found = 1;
869                     break;
870                 }
871             }
872         }
873     }
874     if( !found )
875         return 0; /* nothing to do */
876
877     clear_kbnode_flags( keyblock );
878
879     /* now transfer the cloned nodes to the original ones */
880     #warning We are working HERE!!!
881
882     return 0;
883 }
884
885
886
887 /****************
888  * compare and merge the blocks
889  *
890  * o compare the signatures: If we already have this signature, check
891  *   that they compare okay; if not, issue a warning and ask the user.
892  * o Simply add the signature.  Can't verify here because we may not have
893  *   the signature's public key yet; verification is done when putting it
894  *   into the trustdb, which is done automagically as soon as this pubkey
895  *   is used.
896  * Note: We indicate newly inserted packets with flag bit 0
897  */
898 static int
899 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
900               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
901 {
902     KBNODE onode, node;
903     int rc, found;
904
905     /* 1st: handle revocation certificates */
906     for(node=keyblock->next; node; node=node->next ) {
907         if( node->pkt->pkttype == PKT_USER_ID )
908             break;
909         else if( node->pkt->pkttype == PKT_SIGNATURE
910                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
911             /* check whether we already have this */
912             found = 0;
913             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
914                 if( onode->pkt->pkttype == PKT_USER_ID )
915                     break;
916                 else if( onode->pkt->pkttype == PKT_SIGNATURE
917                          && onode->pkt->pkt.signature->sig_class == 0x20
918                          && node->pkt->pkt.signature->keyid[0]
919                             == onode->pkt->pkt.signature->keyid[0]
920                          && node->pkt->pkt.signature->keyid[1]
921                             == onode->pkt->pkt.signature->keyid[1] ) {
922                     found = 1;
923                     break;
924                 }
925             }
926             if( !found ) {
927                 KBNODE n2 = clone_kbnode(node);
928                 insert_kbnode( keyblock_orig, n2, 0 );
929                 n2->flag |= 1;
930                 log_info_f(fname, _("key %08lX: revocation certificate added\n"),
931                                          (ulong)keyid[1]);
932             }
933         }
934     }
935
936     /* 2nd: try to merge new certificates in */
937     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
938         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
939             /* find the user id in the imported keyblock */
940             for(node=keyblock->next; node; node=node->next )
941                 if( node->pkt->pkttype == PKT_USER_ID
942                     && !cmp_user_ids( onode->pkt->pkt.user_id,
943                                           node->pkt->pkt.user_id ) )
944                     break;
945             if( node ) { /* found: merge */
946                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
947                 if( rc )
948                     return rc;
949             }
950         }
951     }
952
953     /* 3rd: add new user-ids */
954     for(node=keyblock->next; node; node=node->next ) {
955         if( node->pkt->pkttype == PKT_USER_ID) {
956             /* do we have this in the original keyblock */
957             for(onode=keyblock_orig->next; onode; onode=onode->next )
958                 if( onode->pkt->pkttype == PKT_USER_ID
959                     && !cmp_user_ids( onode->pkt->pkt.user_id,
960                                       node->pkt->pkt.user_id ) )
961                     break;
962             if( !onode ) { /* this is a new user id: append */
963                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
964                 if( rc )
965                     return rc;
966                 ++*n_uids;
967             }
968         }
969     }
970
971     /* merge subkey certificates */
972     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
973         if( !(onode->flag & 1)
974             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
975                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
976             /* find the subkey in the imported keyblock */
977             for(node=keyblock->next; node; node=node->next ) {
978                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
979                     && !cmp_public_keys( onode->pkt->pkt.public_key,
980                                           node->pkt->pkt.public_key ) )
981                     break;
982                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
983                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
984                                           node->pkt->pkt.secret_key ) )
985                     break;
986             }
987             if( node ) { /* found: merge */
988                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
989                 if( rc )
990                     return rc;
991             }
992         }
993     }
994
995     /*  add new subkeys */
996     for(node=keyblock->next; node; node=node->next ) {
997         onode = NULL;
998         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
999             /* do we have this in the original keyblock? */
1000             for(onode=keyblock_orig->next; onode; onode=onode->next )
1001                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1002                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1003                                          node->pkt->pkt.public_key ) )
1004                     break;
1005             if( !onode ) { /* this is a new subkey: append */
1006                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1007                 if( rc )
1008                     return rc;
1009                 ++*n_subk;
1010             }
1011         }
1012         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1013             /* do we have this in the original keyblock? */
1014             for(onode=keyblock_orig->next; onode; onode=onode->next )
1015                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1016                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1017                                          node->pkt->pkt.secret_key ) )
1018                     break;
1019             if( !onode ) { /* this is a new subkey: append */
1020                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1021                 if( rc )
1022                     return rc;
1023                 ++*n_subk;
1024             }
1025         }
1026     }
1027
1028     return 0;
1029 }
1030
1031
1032 /****************
1033  * append the userid starting with NODE and all signatures to KEYBLOCK.
1034  */
1035 static int
1036 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1037                                           const char *fname, u32 *keyid )
1038 {
1039     KBNODE n, n_where=NULL;
1040
1041     assert(node->pkt->pkttype == PKT_USER_ID );
1042     if( node->next->pkt->pkttype == PKT_USER_ID ) {
1043         log_error_f(fname, _("key %08lX: our copy has no self-signature\n"),
1044                                                   (ulong)keyid[1]);
1045         return G10ERR_GENERAL;
1046     }
1047
1048     /* find the position */
1049     for( n = keyblock; n; n_where = n, n = n->next ) {
1050         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1051             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1052             break;
1053     }
1054     if( !n )
1055         n_where = NULL;
1056
1057     /* and append/insert */
1058     while( node ) {
1059         /* we add a clone to the original keyblock, because this
1060          * one is released first */
1061         n = clone_kbnode(node);
1062         if( n_where ) {
1063             insert_kbnode( n_where, n, 0 );
1064             n_where = n;
1065         }
1066         else
1067             add_kbnode( keyblock, n );
1068         n->flag |= 1;
1069         node->flag |= 1;
1070         if( n->pkt->pkttype == PKT_SIGNATURE )
1071             ++*n_sigs;
1072
1073         node = node->next;
1074         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1075             break;
1076     }
1077
1078     return 0;
1079 }
1080
1081
1082 /****************
1083  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1084  * (how should we handle comment packets here?)
1085  */
1086 static int
1087 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1088                                     const char *fname, u32 *keyid )
1089 {
1090     KBNODE n, n2;
1091     int found=0;
1092
1093     assert(dst->pkt->pkttype == PKT_USER_ID );
1094     assert(src->pkt->pkttype == PKT_USER_ID );
1095     /* at least a self signature comes next to the user-ids */
1096     assert(src->next->pkt->pkttype != PKT_USER_ID );
1097     if( dst->next->pkt->pkttype == PKT_USER_ID ) {
1098         log_error_f(fname, _("key %08lX: our copy has no self-signature\n"),
1099                                                   (ulong)keyid[1]);
1100         return 0;
1101     }
1102
1103
1104     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1105         if( n->pkt->pkttype != PKT_SIGNATURE )
1106             continue;
1107         found = 0;
1108         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1109             if( n2->pkt->pkttype == PKT_SIGNATURE
1110                 && n->pkt->pkt.signature->keyid[0]
1111                    == n2->pkt->pkt.signature->keyid[0]
1112                 && n->pkt->pkt.signature->keyid[1]
1113                    == n2->pkt->pkt.signature->keyid[1]
1114                 && n->pkt->pkt.signature->timestamp
1115                    <= n2->pkt->pkt.signature->timestamp
1116                 && n->pkt->pkt.signature->sig_class
1117                    == n2->pkt->pkt.signature->sig_class ) {
1118                 found++;
1119                 break;
1120             }
1121         }
1122         if( !found ) {
1123             /* This signature is new or newer, append N to DST.
1124              * We add a clone to the original keyblock, because this
1125              * one is released first */
1126             n2 = clone_kbnode(n);
1127             insert_kbnode( dst, n2, PKT_SIGNATURE );
1128             n2->flag |= 1;
1129             n->flag |= 1;
1130             ++*n_sigs;
1131         }
1132     }
1133
1134     return 0;
1135 }
1136
1137 /****************
1138  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1139  */
1140 static int
1141 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1142                                     const char *fname, u32 *keyid )
1143 {
1144     KBNODE n, n2;
1145     int found=0;
1146
1147     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1148            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1149
1150     for(n=src->next; n ; n = n->next ) {
1151         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1152             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1153             break;
1154         if( n->pkt->pkttype != PKT_SIGNATURE )
1155             continue;
1156         found = 0;
1157         for(n2=dst->next; n2; n2 = n2->next){
1158             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1159                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1160                 break;
1161             if( n2->pkt->pkttype == PKT_SIGNATURE
1162                 && n->pkt->pkt.signature->keyid[0]
1163                    == n2->pkt->pkt.signature->keyid[0]
1164                 && n->pkt->pkt.signature->keyid[1]
1165                    == n2->pkt->pkt.signature->keyid[1]
1166                 && n->pkt->pkt.signature->timestamp
1167                    <= n2->pkt->pkt.signature->timestamp
1168                 && n->pkt->pkt.signature->sig_class
1169                    == n2->pkt->pkt.signature->sig_class ) {
1170                 found++;
1171                 break;
1172             }
1173         }
1174         if( !found ) {
1175             /* This signature is new or newer, append N to DST.
1176              * We add a clone to the original keyblock, because this
1177              * one is released first */
1178             n2 = clone_kbnode(n);
1179             insert_kbnode( dst, n2, PKT_SIGNATURE );
1180             n2->flag |= 1;
1181             n->flag |= 1;
1182             ++*n_sigs;
1183         }
1184     }
1185
1186     return 0;
1187 }
1188
1189 /****************
1190  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1191  * Mark all new and copied packets by setting flag bit 0.
1192  */
1193 static int
1194 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1195                                           const char *fname, u32 *keyid )
1196 {
1197     KBNODE n;
1198
1199     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1200            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1201
1202     while(  node ) {
1203         /* we add a clone to the original keyblock, because this
1204          * one is released first */
1205         n = clone_kbnode(node);
1206         add_kbnode( keyblock, n );
1207         n->flag |= 1;
1208         node->flag |= 1;
1209         if( n->pkt->pkttype == PKT_SIGNATURE )
1210             ++*n_sigs;
1211
1212         node = node->next;
1213         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1214             break;
1215     }
1216
1217     return 0;
1218 }
1219