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