textual changes
[gnupg.git] / g10 / import.c
1 /* import.c
2  *      Copyright (C) 1998 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
37
38 static int read_block( IOBUF a, compress_filter_context_t *cfx,
39                              PACKET **pending_pkt, KBNODE *ret_root );
40 static int import_one( const char *fname, KBNODE keyblock );
41 static int import_secret_one( const char *fname, KBNODE keyblock );
42 static int import_revoke_cert( const char *fname, KBNODE node );
43 static int chk_self_sigs( const char *fname, KBNODE keyblock,
44                           PKT_public_key *pk, u32 *keyid );
45 static int delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid );
46 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
47                          KBNODE keyblock, u32 *keyid,
48                          int *n_uids, int *n_sigs, int *n_subk );
49 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
50                              const char *fname, u32 *keyid );
51 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
52                              const char *fname, u32 *keyid );
53
54
55 /****************
56  * Import the public keys from the given filename. Input may be armored.
57  * This function rejects all keys which are not validly self signed on at
58  * least one userid. Only user ids which are self signed will be imported.
59  * Other signatures are not checked.
60  *
61  * Actually this functtion does a merge. It works like this:
62  *
63  *  - get the keyblock
64  *  - check self-signatures and remove all userids and their signatures
65  *    without/invalid self-signatures.
66  *  - reject the keyblock, if we have no valid userid.
67  *  - See whether we have this key already in one of our pubrings.
68  *    If not, simply add it to the default keyring.
69  *  - Compare the key and the self-signatures of the new and the one in
70  *    our keyring.  If they are different something weird is going on;
71  *    ask what to do.
72  *  - See whether we have only non-self-signature on one user id; if not
73  *    ask the user what to do.
74  *  - compare the signatures: If we already have this signature, check
75  *    that they compare okay; if not, issue a warning and ask the user.
76  *    (consider looking at the timestamp and use the newest?)
77  *  - Simply add the signature.  Can't verify here because we may not have
78  *    the signature's public key yet; verification is done when putting it
79  *    into the trustdb, which is done automagically as soon as this pubkey
80  *    is used.
81  *  - Proceed with next signature.
82  *
83  *  Key revocation certificates have special handling.
84  *
85  */
86 int
87 import_keys( const char *fname )
88 {
89     armor_filter_context_t afx;
90     compress_filter_context_t cfx;
91     PACKET *pending_pkt = NULL;
92     IOBUF inp = NULL;
93     KBNODE keyblock;
94     int rc = 0;
95
96     memset( &afx, 0, sizeof afx);
97     memset( &cfx, 0, sizeof cfx);
98
99     /* open file */
100     inp = iobuf_open(fname);
101     if( !fname )
102         fname = "[stdin]";
103     if( !inp ) {
104         log_error("%s: can't open file: %s\n", fname, strerror(errno) );
105         return G10ERR_OPEN_FILE;
106     }
107
108     if( !opt.no_armor ) /* armored reading is not disabled */
109         iobuf_push_filter( inp, armor_filter, &afx );
110
111     while( !(rc = read_block( inp, &cfx, &pending_pkt, &keyblock) )) {
112         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
113             rc = import_one( fname, keyblock );
114         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY )
115             rc = import_secret_one( fname, keyblock );
116         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
117                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
118             rc = import_revoke_cert( fname, keyblock );
119         else
120             log_info("%s: skipping block of type %d\n",
121                                             fname, keyblock->pkt->pkttype );
122         release_kbnode(keyblock);
123         if( rc )
124             break;
125     }
126     if( rc == -1 )
127         rc = 0;
128     else if( rc )
129         log_error("%s: read error: %s\n", fname, g10_errstr(rc));
130
131     iobuf_close(inp);
132     return rc;
133 }
134
135
136 /****************
137  * Read the next keyblock from stream A, CFX is used to handle
138  * compressed keyblocks. PENDING_PKT should be initialzed to NULL
139  * and not chnaged form the caller.
140  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
141  */
142 static int
143 read_block( IOBUF a, compress_filter_context_t *cfx,
144             PACKET **pending_pkt, KBNODE *ret_root )
145 {
146     int rc;
147     PACKET *pkt;
148     KBNODE root = NULL;
149     int in_cert;
150
151     if( *pending_pkt ) {
152         root = new_kbnode( *pending_pkt );
153         *pending_pkt = NULL;
154         in_cert = 1;
155     }
156     else
157         in_cert = 0;
158     pkt = m_alloc( sizeof *pkt );
159     init_packet(pkt);
160     while( (rc=parse_packet(a, pkt)) != -1 ) {
161         if( rc ) {  /* ignore errors */
162             if( rc == G10ERR_PUBKEY_ALGO )
163                 parse_pubkey_warning( pkt );
164             else if( rc != G10ERR_UNKNOWN_PACKET ) {
165                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
166                 rc = G10ERR_INV_KEYRING;
167                 goto ready;
168             }
169             free_packet( pkt );
170             init_packet(pkt);
171             continue;
172         }
173
174         if( !root && pkt->pkttype == PKT_SIGNATURE
175                   && pkt->pkt.signature->sig_class == 0x20 ) {
176             /* this is a revocation certificate which is handled
177              * in a special way */
178             root = new_kbnode( pkt );
179             pkt = NULL;
180             goto ready;
181         }
182
183         /* make a linked list of all packets */
184         switch( pkt->pkttype ) {
185           case PKT_COMPRESSED:
186             if( pkt->pkt.compressed->algorithm < 1
187                 || pkt->pkt.compressed->algorithm > 2 ) {
188                 rc = G10ERR_COMPR_ALGO;
189                 goto ready;
190             }
191             cfx->algo = pkt->pkt.compressed->algorithm;
192             pkt->pkt.compressed->buf = NULL;
193             iobuf_push_filter( a, compress_filter, cfx );
194             free_packet( pkt );
195             init_packet(pkt);
196             break;
197
198
199           case PKT_PUBLIC_KEY:
200           case PKT_SECRET_KEY:
201             if( in_cert ) { /* store this packet */
202                 *pending_pkt = pkt;
203                 pkt = NULL;
204                 goto ready;
205             }
206             in_cert = 1;
207           default:
208             if( in_cert ) {
209                 if( !root )
210                     root = new_kbnode( pkt );
211                 else
212                     add_kbnode( root, new_kbnode( pkt ) );
213                 pkt = m_alloc( sizeof *pkt );
214             }
215             init_packet(pkt);
216             break;
217         }
218     }
219   ready:
220     if( rc == -1 && root )
221         rc = 0;
222
223     if( rc )
224         release_kbnode( root );
225     else
226         *ret_root = root;
227     free_packet( pkt );
228     m_free( pkt );
229     return rc;
230 }
231
232
233 /****************
234  * Try to import one keyblock.  Return an error only in serious cases, but
235  * never for an invalid keyblock.  It uses log_error to increase the
236  * internal errorcount, so that invalid input can be detected by programs
237  * which called g10.
238  */
239 static int
240 import_one( const char *fname, KBNODE keyblock )
241 {
242     PKT_public_key *pk;
243     PKT_public_key *pk_orig;
244     KBNODE node, uidnode;
245     KBNODE keyblock_orig = NULL;
246     KBPOS kbpos;
247     u32 keyid[2];
248     int rc = 0;
249
250     /* get the key and print some info about it */
251     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
252     if( !node )
253         BUG();
254
255     pk = node->pkt->pkt.public_key;
256     keyid_from_pk( pk, keyid );
257     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
258
259     if( opt.verbose ) {
260         log_info("%s: pub  %4u%c/%08lX %s   ", fname,
261                   nbits_from_pk( pk ),
262                   pubkey_letter( pk->pubkey_algo ),
263                   (ulong)keyid[1], datestr_from_pk(pk) );
264         if( uidnode )
265             print_string( stderr, uidnode->pkt->pkt.user_id->name,
266                                   uidnode->pkt->pkt.user_id->len, 0 );
267         putc('\n', stderr);
268     }
269     if( !uidnode ) {
270         log_error("%s: No user id for key %08lX\n", fname, (ulong)keyid[1]);
271         return 0;
272     }
273
274     clear_kbnode_flags( keyblock );
275     rc = chk_self_sigs( fname, keyblock , pk, keyid );
276     if( rc )
277         return rc== -1? 0:rc;
278
279     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
280         log_info("%s: key %08lX, no valid user ids\n",
281                                                     fname, (ulong)keyid[1]);
282         return 0;
283     }
284
285     /* do we have this key already in one of our pubrings ? */
286     pk_orig = m_alloc_clear( sizeof *pk_orig );
287     rc = get_pubkey( pk_orig, keyid );
288     if( rc && rc != G10ERR_NO_PUBKEY ) {
289         log_error("%s: key %08lX, public key not found: %s\n",
290                                 fname, (ulong)keyid[1], g10_errstr(rc));
291     }
292     else if( rc ) { /* insert this key */
293         /* get default resource */
294         if( get_keyblock_handle( NULL, 0, &kbpos ) ) {
295             log_error("no default public keyring\n");
296             return G10ERR_GENERAL;
297         }
298         if( opt.verbose > 1 )
299             log_info("%s: writing to '%s'\n",
300                                 fname, keyblock_resource_name(&kbpos) );
301         if( (rc=lock_keyblock( &kbpos )) )
302             log_error("can't lock public keyring '%s': %s\n",
303                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
304         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
305             log_error("%s: can't write to '%s': %s\n", fname,
306                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
307         unlock_keyblock( &kbpos );
308         /* we are ready */
309         log_info("%s: key %08lX imported\n", fname, (ulong)keyid[1]);
310     }
311     else { /* merge */
312         int n_uids, n_sigs, n_subk;
313
314         /* Compare the original against the new key; just to be sure nothing
315          * weird is going on */
316         if( cmp_public_keys( pk_orig, pk ) ) {
317             log_error("%s: key %08lX, doesn't match our copy\n",
318                                                     fname, (ulong)keyid[1]);
319             rc = G10ERR_GENERAL;
320             goto leave;
321         }
322
323         /* See whether we have only non-self-signature on one user id; if not
324          * ask the user what to do. <--- fixme */
325
326         /* now read the original keyblock */
327         rc = find_keyblock_bypk( &kbpos, pk_orig );
328         if( rc ) {
329             log_error("%s: key %08lX, can't locate original keyblock: %s\n",
330                                      fname, (ulong)keyid[1], g10_errstr(rc));
331             goto leave;
332         }
333         rc = read_keyblock( &kbpos, &keyblock_orig );
334         if( rc ) {
335             log_error("%s: key %08lX, can't read original keyblock: %s\n",
336                                      fname, (ulong)keyid[1], g10_errstr(rc));
337             goto leave;
338         }
339         /* and try to merge the block */
340         clear_kbnode_flags( keyblock_orig );
341         clear_kbnode_flags( keyblock );
342         n_uids = n_sigs = n_subk = 0;
343         rc = merge_blocks( fname, keyblock_orig, keyblock,
344                                 keyid, &n_uids, &n_sigs, &n_subk );
345         if( rc )
346             goto leave;
347         if( n_uids || n_sigs || n_subk ) {
348             /* keyblock_orig has been updated; write */
349             if( opt.verbose > 1 )
350                 log_info("%s: writing to '%s'\n",
351                                     fname, keyblock_resource_name(&kbpos) );
352             if( (rc=lock_keyblock( &kbpos )) )
353                 log_error("can't lock public keyring '%s': %s\n",
354                                  keyblock_resource_name(&kbpos), g10_errstr(rc) );
355             else if( (rc=update_keyblock( &kbpos, keyblock )) )
356                 log_error("%s: can't write to '%s': %s\n", fname,
357                                  keyblock_resource_name(&kbpos), g10_errstr(rc) );
358             unlock_keyblock( &kbpos );
359             /* we are ready */
360             if( n_uids == 1 )
361                 log_info("%s: key %08lX, 1 new user-id\n",
362                                          fname, (ulong)keyid[1]);
363             else if( n_uids )
364                 log_info("%s: key %08lX, %d new user-ids\n",
365                                          fname, (ulong)keyid[1], n_uids );
366             if( n_sigs == 1 )
367                 log_info("%s: key %08lX, 1 new signature\n",
368                                          fname, (ulong)keyid[1]);
369             else if( n_sigs )
370                 log_info("%s: key %08lX, %d new signatures\n",
371                                          fname, (ulong)keyid[1], n_sigs );
372             if( n_subk == 1 )
373                 log_info("%s: key %08lX, 1 new subkey\n",
374                                          fname, (ulong)keyid[1]);
375             else if( n_subk )
376                 log_info("%s: key %08lX, %d new subkeys\n",
377                                          fname, (ulong)keyid[1], n_subk );
378         }
379         else
380             log_info("%s: key %08lX, not changed\n", fname, (ulong)keyid[1] );
381     }
382
383   leave:
384     release_kbnode( keyblock_orig );
385     free_public_key( pk_orig );
386     return rc;
387 }
388
389
390 /****************
391  * Ditto for secret keys.  Handling is simpler than for public keys.
392  */
393 static int
394 import_secret_one( const char *fname, KBNODE keyblock )
395 {
396     PKT_secret_key *sk;
397     KBNODE node, uidnode;
398     KBNODE keyblock_orig = NULL;
399     KBPOS kbpos;
400     u32 keyid[2];
401     int rc = 0;
402
403     /* get the key and print some info about it */
404     node = find_kbnode( keyblock, PKT_SECRET_KEY );
405     if( !node )
406         BUG();
407
408     sk = node->pkt->pkt.secret_key;
409     keyid_from_sk( sk, keyid );
410     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
411
412     if( opt.verbose ) {
413         log_info("%s: sec  %4u%c/%08lX %s   ", fname,
414                   nbits_from_sk( sk ),
415                   pubkey_letter( sk->pubkey_algo ),
416                   (ulong)keyid[1], datestr_from_sk(sk) );
417         if( uidnode )
418             print_string( stderr, uidnode->pkt->pkt.user_id->name,
419                                   uidnode->pkt->pkt.user_id->len, 0 );
420         putc('\n', stderr);
421     }
422     if( !uidnode ) {
423         log_error("%s: No user id for key %08lX\n", fname, (ulong)keyid[1]);
424         return 0;
425     }
426
427     clear_kbnode_flags( keyblock );
428
429     /* do we have this key already in one of our secrings ? */
430     rc = seckey_available( keyid );
431     if( rc == G10ERR_NO_SECKEY ) { /* simply insert this key */
432         /* get default resource */
433         if( get_keyblock_handle( NULL, 1, &kbpos ) ) {
434             log_error("no default secret keyring\n");
435             return G10ERR_GENERAL;
436         }
437         if( opt.verbose > 1 )
438             log_info("%s: writing to '%s'\n",
439                                 fname, keyblock_resource_name(&kbpos) );
440         if( (rc=lock_keyblock( &kbpos )) )
441             log_error("can't lock secret keyring '%s': %s\n",
442                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
443         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
444             log_error("%s: can't write to '%s': %s\n", fname,
445                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
446         unlock_keyblock( &kbpos );
447         /* we are ready */
448         log_info("%s: key %08lX imported\n", fname, (ulong)keyid[1]);
449     }
450     else if( !rc ) { /* we can't merge secret keys */
451         log_error("%s: key %08lX already in secret keyring\n",
452                                                 fname, (ulong)keyid[1]);
453     }
454     else
455         log_error("%s: key %08lX, secret key not found: %s\n",
456                                 fname, (ulong)keyid[1], g10_errstr(rc));
457
458     release_kbnode( keyblock_orig );
459     return rc;
460 }
461
462
463 /****************
464  * Import a revocation certificate; this is a single signature packet.
465  */
466 static int
467 import_revoke_cert( const char *fname, KBNODE node )
468 {
469     PKT_public_key *pk=NULL;
470     KBNODE onode, keyblock = NULL;
471     KBPOS kbpos;
472     u32 keyid[2];
473     int rc = 0;
474
475     assert( !node->next );
476     assert( node->pkt->pkttype == PKT_SIGNATURE );
477     assert( node->pkt->pkt.signature->sig_class == 0x20 );
478
479     keyid[0] = node->pkt->pkt.signature->keyid[0];
480     keyid[1] = node->pkt->pkt.signature->keyid[1];
481
482     pk = m_alloc_clear( sizeof *pk );
483     rc = get_pubkey( pk, keyid );
484     if( rc == G10ERR_NO_PUBKEY ) {
485         log_info("%s: key %08lX, no public key - "
486                  "can't apply revocation certificate\n",
487                                 fname, (ulong)keyid[1]);
488         rc = 0;
489         goto leave;
490     }
491     else if( rc ) {
492         log_error("%s: key %08lX, public key not found: %s\n",
493                                 fname, (ulong)keyid[1], g10_errstr(rc));
494         goto leave;
495     }
496
497     /* read the original keyblock */
498     rc = find_keyblock_bypk( &kbpos, pk );
499     if( rc ) {
500         log_error("%s: key %08lX, can't locate original keyblock: %s\n",
501                                  fname, (ulong)keyid[1], g10_errstr(rc));
502         goto leave;
503     }
504     rc = read_keyblock( &kbpos, &keyblock );
505     if( rc ) {
506         log_error("%s: key %08lX, can't read original keyblock: %s\n",
507                                  fname, (ulong)keyid[1], g10_errstr(rc));
508         goto leave;
509     }
510
511
512     /* it is okay, that node is not in keyblock because
513      * check_key_signature works fine for sig_class 0x20 in this
514      * special case. */
515     rc = check_key_signature( keyblock, node, NULL);
516     if( rc ) {
517         log_error("%s: key %08lX, invalid revocation certificate"
518                   ": %s - rejected\n",
519                   fname, (ulong)keyid[1], g10_errstr(rc));
520     }
521
522
523     /* check whether we already have this */
524     for(onode=keyblock->next; onode; onode=onode->next ) {
525         if( onode->pkt->pkttype == PKT_USER_ID )
526             break;
527         else if( onode->pkt->pkttype == PKT_SIGNATURE
528                  && onode->pkt->pkt.signature->sig_class == 0x20
529                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
530                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
531             rc = 0;
532             goto leave; /* yes, we already know about it */
533         }
534     }
535
536
537     /* insert it */
538     insert_kbnode( keyblock, clone_kbnode(node), 0 );
539
540     /* and write the keyblock back */
541     if( opt.verbose > 1 )
542         log_info("%s: writing to '%s'\n",
543                             fname, keyblock_resource_name(&kbpos) );
544     if( (rc=lock_keyblock( &kbpos )) )
545         log_error("can't lock public keyring '%s': %s\n",
546                          keyblock_resource_name(&kbpos), g10_errstr(rc) );
547     else if( (rc=update_keyblock( &kbpos, keyblock )) )
548         log_error("%s: can't write to '%s': %s\n", fname,
549                          keyblock_resource_name(&kbpos), g10_errstr(rc) );
550     unlock_keyblock( &kbpos );
551     /* we are ready */
552     log_info("%s: key %08lX, added revocation certificate\n",
553                                  fname, (ulong)keyid[1]);
554
555   leave:
556     release_kbnode( keyblock );
557     free_public_key( pk );
558     return rc;
559 }
560
561
562 /****************
563  * loop over the keyblock and check all self signatures.
564  * Mark all user-ids with a self-signature by setting flag bit 0.
565  * Mark all user-ids with an invalid self-signature by setting bit 1.
566  */
567 static int
568 chk_self_sigs( const char *fname, KBNODE keyblock,
569                PKT_public_key *pk, u32 *keyid )
570 {
571     KBNODE n, unode;
572     PKT_signature *sig;
573     int rc;
574
575     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
576         if( n->pkt->pkttype != PKT_SIGNATURE )
577             continue;
578         sig = n->pkt->pkt.signature;
579         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
580             unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
581             if( !unode )  {
582                 log_error("%s: key %08lX, no user-id for signature\n",
583                                         fname, (ulong)keyid[1]);
584                 return -1;  /* the complete keyblock is invalid */
585             }
586             rc = check_key_signature( keyblock, n, NULL);
587             if( rc ) {
588                 log_error( rc == G10ERR_PUBKEY_ALGO ?
589                           "%s: key %08lX, unsupported public key algorithm\n":
590                           "%s: key %08lX, invalid self-signature\n",
591                           fname, (ulong)keyid[1]);
592
593                 unode->flag |= 2; /* mark as invalid */
594             }
595             unode->flag |= 1; /* mark that user-id checked */
596         }
597     }
598     return 0;
599 }
600
601 /****************
602  * delete all parts which are invalid and those signatures whose
603  * public key algorithm is not available in this implemenation;
604  * but consider RSA as valid, because parse/build_packets knows
605  * about it.
606  * returns: true if at least one valid user-id is left over.
607  */
608 static int
609 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
610 {
611     KBNODE node;
612     int nvalid=0, uid_seen=0;
613
614     for(node=keyblock->next; node; node = node->next ) {
615         if( node->pkt->pkttype == PKT_USER_ID ) {
616             uid_seen = 1;
617             if( (node->flag & 2) || !(node->flag & 1) ) {
618                 if( opt.verbose ) {
619                     log_info("%s: key %08lX, removed userid '",
620                                                   fname, (ulong)keyid[1]);
621                     print_string( stderr, node->pkt->pkt.user_id->name,
622                                       node->pkt->pkt.user_id->len, 0 );
623                     fputs("'\n", stderr );
624                 }
625                 delete_kbnode( node ); /* the user-id */
626                 /* and all following packets up to the next user-id */
627                 while( node->next && node->next->pkt->pkttype != PKT_USER_ID ){
628                     delete_kbnode( node->next );
629                     node = node->next;
630                 }
631             }
632             else
633                 nvalid++;
634         }
635         else if( node->pkt->pkttype == PKT_SIGNATURE
636                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
637                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
638             delete_kbnode( node ); /* build_packet() can't handle this */
639         else if( node->pkt->pkttype == PKT_SIGNATURE
640                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
641             if( uid_seen ) {
642                 log_error("%s: key %08lX, revocation certificate at wrong "
643                            "place - removed\n", fname, (ulong)keyid[1]);
644                 delete_kbnode( node );
645             }
646             else {
647                 int rc = check_key_signature( keyblock, node, NULL);
648                 if( rc ) {
649                     log_error("%s: key %08lX, invalid revocation certificate"
650                               ": %s - removed\n",
651                               fname, (ulong)keyid[1], g10_errstr(rc));
652                     delete_kbnode( node );
653                 }
654             }
655         }
656     }
657
658     /* note: because keyblock is the public key, it is never marked
659      * for deletion and so keyblock cannot change */
660     commit_kbnode( &keyblock );
661     return nvalid;
662 }
663
664
665 /****************
666  * compare and merge the blocks
667  *
668  * o compare the signatures: If we already have this signature, check
669  *   that they compare okay; if not, issue a warning and ask the user.
670  *   FIXME: add the check that we don't have duplicate signatures and the
671  *   warning in cases where the old/new signatures don't match.
672  * o Simply add the signature.  Can't verify here because we may not have
673  *   the signature's public key yet; verification is done when putting it
674  *   into the trustdb, which is done automagically as soon as this pubkey
675  *   is used.
676  * Note: We indicate newly inserted packets with flag bit 0
677  */
678 static int
679 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
680               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
681 {
682     KBNODE onode, node;
683     int rc, found;
684
685     /* 1st: handle revocation certificates */
686     for(node=keyblock->next; node; node=node->next ) {
687         if( node->pkt->pkttype == PKT_USER_ID )
688             break;
689         else if( node->pkt->pkttype == PKT_SIGNATURE
690                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
691             /* check whether we already have this */
692             found = 0;
693             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
694                 if( onode->pkt->pkttype == PKT_USER_ID )
695                     break;
696                 else if( onode->pkt->pkttype == PKT_SIGNATURE
697                          && onode->pkt->pkt.signature->sig_class == 0x20
698                          && node->pkt->pkt.signature->keyid[0]
699                             == onode->pkt->pkt.signature->keyid[0]
700                          && node->pkt->pkt.signature->keyid[1]
701                             == onode->pkt->pkt.signature->keyid[1] ) {
702                     found = 1;
703                     break;
704                 }
705             }
706             if( !found ) {
707                 KBNODE n2 = clone_kbnode(node);
708                 insert_kbnode( keyblock_orig, n2, 0 );
709                 n2->flag |= 1;
710                 node->flag |= 1;
711                 log_info("%s: key %08lX, added revocation certificate\n",
712                                          fname, (ulong)keyid[1]);
713             }
714         }
715     }
716
717     /* 2nd: try to merge new ones in */
718     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
719         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
720             /* find the user id in the imported keyblock */
721             for(node=keyblock->next; node; node=node->next )
722                 if( !(node->flag & 1)
723                     && node->pkt->pkttype == PKT_USER_ID
724                     && !cmp_user_ids( onode->pkt->pkt.user_id,
725                                           node->pkt->pkt.user_id ) )
726                     break;
727             if( node ) { /* found: merge */
728                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
729                 if( rc )
730                     return rc;
731             }
732         }
733     }
734
735     /* 3rd: add new user-ids */
736     for(node=keyblock->next; node; node=node->next ) {
737         if( !(node->flag & 1) && node->pkt->pkttype == PKT_USER_ID) {
738             /* do we have this in the original keyblock */
739             for(onode=keyblock_orig->next; onode; onode=onode->next )
740                 if( !(onode->flag & 1)
741                     && onode->pkt->pkttype == PKT_USER_ID
742                     && cmp_user_ids( onode->pkt->pkt.user_id,
743                                      node->pkt->pkt.user_id ) )
744                     break;
745             if( !node ) { /* this is a new user id: append */
746                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
747                 if( rc )
748                     return rc;
749                 ++*n_uids;
750             }
751         }
752     }
753
754     /* 4th: add new subkeys */
755     /* FIXME */
756
757     return 0;
758 }
759
760
761 /****************
762  * append the userid starting with NODE and all signatures to KEYBLOCK.
763  * Mark all new and copied packets by setting flag bit 0.
764  */
765 static int
766 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
767                                           const char *fname, u32 *keyid )
768 {
769     KBNODE n;
770
771     assert(node->pkt->pkttype == PKT_USER_ID );
772     /* at lease a self signature comes next to the user-id */
773     if( node->next->pkt->pkttype == PKT_USER_ID ) {
774         log_error("%s: key %08lX, our copy has no self-signature\n",
775                                                   fname, (ulong)keyid[1]);
776         return G10ERR_GENERAL;
777     }
778
779     for( ;node && node->pkt->pkttype != PKT_USER_ID; node = node->next ) {
780         /* we add a clone to the original keyblock, because this
781          * one is released first */
782         n = clone_kbnode(node);
783         add_kbnode( keyblock, n );
784         node->flag |= 1;
785         n->flag |= 1;
786         if( n->pkt->pkttype == PKT_SIGNATURE )
787             ++*n_sigs;
788     }
789
790     return 0;
791 }
792
793
794 /****************
795  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
796  * (how should we handle comment packets here?)
797  */
798 static int
799 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
800                                     const char *fname, u32 *keyid )
801 {
802     KBNODE n, n2;
803     int found=0;
804
805     assert(dst->pkt->pkttype == PKT_USER_ID );
806     assert(src->pkt->pkttype == PKT_USER_ID );
807     /* at least a self signature comes next to the user-ids */
808     assert(src->next->pkt->pkttype != PKT_USER_ID );
809     if( dst->next->pkt->pkttype == PKT_USER_ID ) {
810         log_error("%s: key %08lX, our copy has no self-signature\n",
811                                                   fname, (ulong)keyid[1]);
812         return 0;
813     }
814
815
816     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
817         if( n->pkt->pkttype != PKT_SIGNATURE )
818             continue;
819         found = 0;
820         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
821             if( n2->pkt->pkttype == PKT_SIGNATURE
822                 && n->pkt->pkt.signature->keyid[0]
823                    == n2->pkt->pkt.signature->keyid[0]
824                 && n->pkt->pkt.signature->keyid[1]
825                    == n2->pkt->pkt.signature->keyid[1] ) {
826             found++;
827             break;
828         }
829
830         if( found ) { /* we already have this signature */
831             /* Hmmm: should we compare the timestamp etc?
832              * but then we have first to see whether this signature is valid
833              * - or simply add it in such a case and let trustdb logic
834              * decide whether to remove the old one
835              */
836             continue;
837         }
838
839         /* This signature is new, append N to DST it.
840          * We add a clone to the original keyblock, because this
841          * one is released first */
842         n2 = clone_kbnode(n);
843         insert_kbnode( dst, n2, PKT_USER_ID );
844         n2->flag |= 1;
845         n->flag |= 1;
846         ++*n_sigs;
847     }
848
849     return 0;
850 }
851