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