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