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