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