* import.c (clean_subkeys, chk_self_sigs): Merge clean_subkeys into
[gnupg.git] / g10 / import.c
1 /* import.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 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 #include "ttyio.h"
38 #include "status.h"
39 #include "keyserver-internal.h"
40
41 struct stats_s {
42     ulong count;
43     ulong no_user_id;
44     ulong imported;
45     ulong imported_rsa;
46     ulong n_uids;
47     ulong n_sigs;
48     ulong n_subk;
49     ulong unchanged;
50     ulong n_revoc;
51     ulong secret_read;
52     ulong secret_imported;
53     ulong secret_dups;
54     ulong skipped_new_keys;
55     ulong not_imported;
56 };
57
58
59 static int import( IOBUF inp, int fast, const char* fname,
60                    struct stats_s *stats, unsigned int options );
61 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
62 static void revocation_present(KBNODE keyblock);
63 static void remove_bad_stuff (KBNODE keyblock);
64 static int import_one( const char *fname, KBNODE keyblock, int fast,
65                        struct stats_s *stats, unsigned int options);
66 static int import_secret_one( const char *fname, KBNODE keyblock,
67                               struct stats_s *stats );
68 static int import_revoke_cert( const char *fname, KBNODE node,
69                                struct stats_s *stats);
70 static int chk_self_sigs( const char *fname, KBNODE keyblock,
71                           PKT_public_key *pk, u32 *keyid );
72 static int delete_inv_parts( const char *fname, KBNODE keyblock,
73                              u32 *keyid, unsigned int options );
74 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
75                          KBNODE keyblock, u32 *keyid,
76                          int *n_uids, int *n_sigs, int *n_subk );
77 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
78                              const char *fname, u32 *keyid );
79 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
80                              const char *fname, u32 *keyid );
81 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
82                              const char *fname, u32 *keyid );
83 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
84                              const char *fname, u32 *keyid );
85
86
87 int
88 parse_import_options(char *str,unsigned int *options)
89 {
90   char *tok;
91   int hit=0;
92   struct
93   {
94     char *name;
95     unsigned int bit;
96   } import_opts[]=
97     {
98       {"allow-local-sigs",IMPORT_ALLOW_LOCAL_SIGS},
99       {"repair-hkp-subkey-bug",IMPORT_REPAIR_HKP_SUBKEY_BUG},
100       {NULL,0}
101     };
102
103   while((tok=strsep(&str," ,")))
104     {
105       int i,rev=0;
106
107       if(ascii_memcasecmp("no-",tok,3)==0)
108         {
109           rev=1;
110           tok+=3;
111         }
112
113       for(i=0;import_opts[i].name;i++)
114         {
115           if(ascii_strcasecmp(import_opts[i].name,tok)==0)
116             {
117               if(rev)
118                 *options&=~import_opts[i].bit;
119               else
120                 *options|=import_opts[i].bit;
121               hit=1;
122               break;
123             }
124         }
125
126       if(!hit && !import_opts[i].name)
127         return 0;
128     }
129
130   return hit;
131 }
132
133 void *
134 import_new_stats_handle (void)
135 {
136     return m_alloc_clear ( sizeof (struct stats_s) );
137 }
138
139 void
140 import_release_stats_handle (void *p)
141 {
142     m_free (p);
143 }
144
145 /****************
146  * Import the public keys from the given filename. Input may be armored.
147  * This function rejects all keys which are not validly self signed on at
148  * least one userid. Only user ids which are self signed will be imported.
149  * Other signatures are not checked.
150  *
151  * Actually this function does a merge. It works like this:
152  *
153  *  - get the keyblock
154  *  - check self-signatures and remove all userids and their signatures
155  *    without/invalid self-signatures.
156  *  - reject the keyblock, if we have no valid userid.
157  *  - See whether we have this key already in one of our pubrings.
158  *    If not, simply add it to the default keyring.
159  *  - Compare the key and the self-signatures of the new and the one in
160  *    our keyring.  If they are different something weird is going on;
161  *    ask what to do.
162  *  - See whether we have only non-self-signature on one user id; if not
163  *    ask the user what to do.
164  *  - compare the signatures: If we already have this signature, check
165  *    that they compare okay; if not, issue a warning and ask the user.
166  *    (consider looking at the timestamp and use the newest?)
167  *  - Simply add the signature.  Can't verify here because we may not have
168  *    the signature's public key yet; verification is done when putting it
169  *    into the trustdb, which is done automagically as soon as this pubkey
170  *    is used.
171  *  - Proceed with next signature.
172  *
173  *  Key revocation certificates have special handling.
174  *
175  */
176 void
177 import_keys( char **fnames, int nnames, int fast,
178              void *stats_handle, unsigned int options )
179 {
180     int i;
181     struct stats_s *stats = stats_handle;
182
183     if (!stats)
184         stats = import_new_stats_handle ();
185
186     if( !fnames && !nnames )
187         nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
188
189     for(i=0; i < nnames; i++ ) {
190         const char *fname = fnames? fnames[i] : NULL;
191         IOBUF inp = iobuf_open(fname);
192         if( !fname )
193             fname = "[stdin]";
194         if( !inp )
195             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
196         else {
197             int rc = import( inp, fast, fname, stats, options );
198             iobuf_close(inp);
199             if( rc )
200                 log_error("import from `%s' failed: %s\n", fname,
201                                                            g10_errstr(rc) );
202         }
203         if( !fname )
204             break;
205     }
206     if (!stats_handle) {
207         import_print_stats (stats);
208         import_release_stats_handle (stats);
209     }
210
211 }
212
213 int
214 import_keys_stream( IOBUF inp, int fast,
215                     void *stats_handle, unsigned int options )
216 {
217     int rc = 0;
218     struct stats_s *stats = stats_handle;
219
220     if (!stats)
221         stats = import_new_stats_handle ();
222
223     rc = import( inp, fast, "[stream]", stats, options);
224     if (!stats_handle) {
225         import_print_stats (stats);
226         import_release_stats_handle (stats);
227     }
228
229     return rc;
230 }
231
232 static int
233 import( IOBUF inp, int fast, const char* fname,
234         struct stats_s *stats, unsigned int options )
235 {
236     PACKET *pending_pkt = NULL;
237     KBNODE keyblock;
238     int rc = 0;
239
240     getkey_disable_caches();
241
242     if( !opt.no_armor ) { /* armored reading is not disabled */
243         armor_filter_context_t *afx = m_alloc_clear( sizeof *afx );
244         afx->only_keyblocks = 1;
245         iobuf_push_filter2( inp, armor_filter, afx, 1 );
246     }
247
248     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
249         remove_bad_stuff (keyblock);
250         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
251             rc = import_one( fname, keyblock, fast, stats, options );
252         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
253                 rc = import_secret_one( fname, keyblock, stats );
254         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
255                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
256             rc = import_revoke_cert( fname, keyblock, stats );
257         else {
258             log_info( _("skipping block of type %d\n"),
259                                             keyblock->pkt->pkttype );
260         }
261         release_kbnode(keyblock);
262         /* fixme: we should increment the not imported counter but this
263            does only make sense if we keep on going despite of errors. */
264         if( rc )
265             break;
266         if( !(++stats->count % 100) && !opt.quiet )
267             log_info(_("%lu keys so far processed\n"), stats->count );
268     }
269     if( rc == -1 )
270         rc = 0;
271     else if( rc && rc != G10ERR_INV_KEYRING )
272         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
273
274     return rc;
275 }
276
277
278 void
279 import_print_stats (void *hd)
280 {
281     struct stats_s *stats = hd;
282
283     if( !opt.quiet ) {
284         log_info(_("Total number processed: %lu\n"), stats->count );
285         if( stats->skipped_new_keys )
286             log_info(_("      skipped new keys: %lu\n"),
287                                                 stats->skipped_new_keys );
288         if( stats->no_user_id )
289             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
290         if( stats->imported || stats->imported_rsa ) {
291             log_info(_("              imported: %lu"), stats->imported );
292             if( stats->imported_rsa )
293                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
294             putc('\n', stderr);
295         }
296         if( stats->unchanged )
297             log_info(_("             unchanged: %lu\n"), stats->unchanged );
298         if( stats->n_uids )
299             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
300         if( stats->n_subk )
301             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
302         if( stats->n_sigs )
303             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
304         if( stats->n_revoc )
305             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
306         if( stats->secret_read )
307             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
308         if( stats->secret_imported )
309             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
310         if( stats->secret_dups )
311             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
312         if( stats->not_imported )
313             log_info(_("          not imported: %lu\n"), stats->not_imported );
314     }
315
316     if( is_status_enabled() ) {
317         char buf[14*20];
318         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
319                 stats->count,
320                 stats->no_user_id,
321                 stats->imported,
322                 stats->imported_rsa,
323                 stats->unchanged,
324                 stats->n_uids,
325                 stats->n_subk,
326                 stats->n_sigs,
327                 stats->n_revoc,
328                 stats->secret_read,
329                 stats->secret_imported,
330                 stats->secret_dups,
331                 stats->skipped_new_keys,
332                 stats->not_imported );
333         write_status_text( STATUS_IMPORT_RES, buf );
334     }
335 }
336
337
338 /****************
339  * Read the next keyblock from stream A.
340  * PENDING_PKT should be initialzed to NULL
341  * and not chnaged form the caller.
342  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
343  */
344 static int
345 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
346 {
347     int rc;
348     PACKET *pkt;
349     KBNODE root = NULL;
350     int in_cert;
351
352     if( *pending_pkt ) {
353         root = new_kbnode( *pending_pkt );
354         *pending_pkt = NULL;
355         in_cert = 1;
356     }
357     else
358         in_cert = 0;
359     pkt = m_alloc( sizeof *pkt );
360     init_packet(pkt);
361     while( (rc=parse_packet(a, pkt)) != -1 ) {
362         if( rc ) {  /* ignore errors */
363             if( rc != G10ERR_UNKNOWN_PACKET ) {
364                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
365                 rc = G10ERR_INV_KEYRING;
366                 goto ready;
367             }
368             free_packet( pkt );
369             init_packet(pkt);
370             continue;
371         }
372
373         if( !root && pkt->pkttype == PKT_SIGNATURE
374                   && pkt->pkt.signature->sig_class == 0x20 ) {
375             /* this is a revocation certificate which is handled
376              * in a special way */
377             root = new_kbnode( pkt );
378             pkt = NULL;
379             goto ready;
380         }
381
382         /* make a linked list of all packets */
383         switch( pkt->pkttype ) {
384           case PKT_COMPRESSED:
385             if( pkt->pkt.compressed->algorithm < 1
386                 || pkt->pkt.compressed->algorithm > 2 ) {
387                 rc = G10ERR_COMPR_ALGO;
388                 goto ready;
389             }
390             {
391                 compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
392                 cfx->algo = pkt->pkt.compressed->algorithm;
393                 pkt->pkt.compressed->buf = NULL;
394                 iobuf_push_filter2( a, compress_filter, cfx, 1 );
395             }
396             free_packet( pkt );
397             init_packet(pkt);
398             break;
399
400           case PKT_RING_TRUST:
401             /* skip those packets */
402             free_packet( pkt );
403             init_packet(pkt);
404             break;
405
406           case PKT_PUBLIC_KEY:
407           case PKT_SECRET_KEY:
408             if( in_cert ) { /* store this packet */
409                 *pending_pkt = pkt;
410                 pkt = NULL;
411                 goto ready;
412             }
413             in_cert = 1;
414           default:
415             if( in_cert ) {
416                 if( !root )
417                     root = new_kbnode( pkt );
418                 else
419                     add_kbnode( root, new_kbnode( pkt ) );
420                 pkt = m_alloc( sizeof *pkt );
421             }
422             init_packet(pkt);
423             break;
424         }
425     }
426   ready:
427     if( rc == -1 && root )
428         rc = 0;
429
430     if( rc )
431         release_kbnode( root );
432     else
433         *ret_root = root;
434     free_packet( pkt );
435     m_free( pkt );
436     return rc;
437 }
438
439
440 static void
441 remove_bad_stuff (KBNODE keyblock)
442 {
443     KBNODE node;
444
445     for (node=keyblock; node; node = node->next ) {
446         if( node->pkt->pkttype == PKT_SIGNATURE ) {
447             /* delete the subpackets we used to use for the
448                verification cache */
449             delete_sig_subpkt (node->pkt->pkt.signature->unhashed,
450                                SIGSUBPKT_PRIV_VERIFY_CACHE);
451         }
452     }
453 }
454
455 /* Walk through the subkeys on a pk to find if we have the HKP
456    disease: multiple subkeys with their binding sigs stripped, and the
457    sig for the first subkey placed after the last subkey.  That is,
458    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
459    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
460    and sub3, as they are already lost, but we can try and rescue sub1
461    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
462    sub2 sub3".  Returns TRUE if the keyblock was modified. */
463
464 static int
465 fix_hkp_corruption(KBNODE keyblock)
466 {
467   int changed=0,keycount=0;
468   KBNODE node,last=NULL,sknode=NULL;
469
470   /* First determine if we have the problem at all.  Look for 2 or
471      more subkeys in a row, followed by a single binding sig. */
472   for(node=keyblock;node;last=node,node=node->next)
473     {
474       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
475         {
476           keycount++;
477           if(!sknode)
478             sknode=node;
479         }
480       else if(node->pkt->pkttype==PKT_SIGNATURE &&
481               node->pkt->pkt.signature->sig_class==0x18 &&
482               keycount>=2 && node->next==NULL)
483         {
484           /* We might have the problem, as this key has two subkeys in
485              a row without any intervening packets. */
486
487           /* Sanity check */
488           if(last==NULL)
489             break;
490
491           /* Temporarily attach node to sknode. */
492           node->next=sknode->next;
493           sknode->next=node;
494           last->next=NULL;
495
496           if(check_key_signature(keyblock,node,NULL))
497             {
498               /* Not a match, so undo the changes. */
499               sknode->next=node->next;
500               last->next=node;
501               node->next=NULL;
502               break;
503             }
504           else
505             {
506               sknode->flag |= 1; /* Mark it good so we don't need to
507                                     check it again */
508               changed=1;
509               break;
510             }
511         }
512       else
513         keycount=0;
514     }
515
516   return changed;
517 }
518
519 /****************
520  * Try to import one keyblock.  Return an error only in serious cases, but
521  * never for an invalid keyblock.  It uses log_error to increase the
522  * internal errorcount, so that invalid input can be detected by programs
523  * which called g10.
524  */
525 static int
526 import_one( const char *fname, KBNODE keyblock, int fast,
527             struct stats_s *stats, unsigned int options )
528 {
529     PKT_public_key *pk;
530     PKT_public_key *pk_orig;
531     KBNODE node, uidnode;
532     KBNODE keyblock_orig = NULL;
533     u32 keyid[2];
534     int rc = 0;
535     int new_key = 0;
536     int mod_key = 0;
537
538     /* get the key and print some info about it */
539     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
540     if( !node )
541         BUG();
542
543     pk = node->pkt->pkt.public_key;
544     keyid_from_pk( pk, keyid );
545     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
546
547     if( opt.verbose ) {
548         log_info( "pub  %4u%c/%08lX %s   ",
549                   nbits_from_pk( pk ),
550                   pubkey_letter( pk->pubkey_algo ),
551                   (ulong)keyid[1], datestr_from_pk(pk) );
552         if( uidnode )
553             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
554                                        uidnode->pkt->pkt.user_id->len );
555         putc('\n', stderr);
556     }
557     if( !uidnode ) {
558         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
559         return 0;
560     }
561     
562     if (opt.interactive) {
563         tty_printf ("\n");
564         show_basic_key_info (keyblock);
565         tty_printf ("\n");
566         if (!cpr_get_answer_is_yes ("import.okay",
567                                     "Do you want to import this key? (y/N) "))
568             return 0;
569     }
570
571     clear_kbnode_flags( keyblock );
572
573     if((options&IMPORT_REPAIR_HKP_SUBKEY_BUG) && fix_hkp_corruption(keyblock))
574       log_info(_("key %08lX: HKP subkey corruption repaired\n"),
575                (ulong)keyid[1]);
576
577     rc = chk_self_sigs( fname, keyblock , pk, keyid );
578     if( rc )
579         return rc== -1? 0:rc;
580
581     /* If we allow such a thing, mark unsigned uids as valid */
582     if( opt.allow_non_selfsigned_uid )
583       for( node=keyblock; node; node = node->next )
584         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
585           {
586             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
587                                       node->pkt->pkt.user_id->len,0);
588             node->flag |= 1;
589             log_info( _("key %08lX: accepted non self-signed user ID '%s'\n"),
590                       (ulong)keyid[1],user);
591             m_free(user);
592           }
593
594     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
595         if( !opt.quiet ) {
596             log_info( _("key %08lX: no valid user IDs\n"),
597                                                         (ulong)keyid[1]);
598             log_info(_("this may be caused by a missing self-signature\n"));
599         }
600         stats->no_user_id++;
601         return 0;
602     }
603
604     /* do we have this key already in one of our pubrings ? */
605     pk_orig = m_alloc_clear( sizeof *pk_orig );
606     rc = get_pubkey( pk_orig, keyid );
607     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY ) {
608         log_error( _("key %08lX: public key not found: %s\n"),
609                                 (ulong)keyid[1], g10_errstr(rc));
610     }
611     else if ( rc && opt.merge_only ) {
612         if( opt.verbose )
613             log_info( _("key %08lX: new key - skipped\n"), (ulong)keyid[1] );
614         rc = 0;
615         fast = 1; /* so that we don't get into the trustdb update */
616         stats->skipped_new_keys++;
617     }
618     else if( rc ) { /* insert this key */
619         KEYDB_HANDLE hd = keydb_new (0);
620
621         rc = keydb_locate_writable (hd, NULL);
622         if (rc) {
623             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
624             keydb_release (hd);
625             return G10ERR_GENERAL;
626         }
627         if( opt.verbose > 1 )
628             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
629         rc = keydb_insert_keyblock (hd, keyblock );
630         if (rc)
631            log_error (_("error writing keyring `%s': %s\n"),
632                        keydb_get_resource_name (hd), g10_errstr(rc));
633         else
634            revalidation_mark ();
635         keydb_release (hd);
636
637         /* we are ready */
638         if( !opt.quiet ) {
639             char *p=get_user_id_printable (keyid);
640             log_info( _("key %08lX: public key \"%s\" imported\n"),
641                       (ulong)keyid[1],p);
642             m_free(p);
643         }
644         if( is_status_enabled() ) {
645             char *us = get_long_user_id_string( keyid );
646             write_status_text( STATUS_IMPORTED, us );
647             m_free(us);
648         }
649         stats->imported++;
650         if( is_RSA( pk->pubkey_algo ) )
651             stats->imported_rsa++;
652         new_key = 1;
653     }
654     else { /* merge */
655         KEYDB_HANDLE hd;
656         int n_uids, n_sigs, n_subk;
657
658         /* Compare the original against the new key; just to be sure nothing
659          * weird is going on */
660         if( cmp_public_keys( pk_orig, pk ) ) {
661             log_error( _("key %08lX: doesn't match our copy\n"),
662                                                           (ulong)keyid[1]);
663             goto leave;
664         }
665
666         /* now read the original keyblock */
667         hd = keydb_new (0);
668         {
669             byte afp[MAX_FINGERPRINT_LEN];
670             size_t an;
671
672             fingerprint_from_pk (pk_orig, afp, &an);
673             while (an < MAX_FINGERPRINT_LEN) 
674                 afp[an++] = 0;
675             rc = keydb_search_fpr (hd, afp);
676         }
677         if( rc ) {
678             log_error (_("key %08lX: can't locate original keyblock: %s\n"),
679                                      (ulong)keyid[1], g10_errstr(rc));
680             keydb_release (hd);
681             goto leave;
682         }
683         rc = keydb_get_keyblock (hd, &keyblock_orig );
684         if (rc) {
685             log_error (_("key %08lX: can't read original keyblock: %s\n"),
686                                             (ulong)keyid[1], g10_errstr(rc));
687             keydb_release (hd);
688             goto leave;
689         }
690
691         collapse_uids( &keyblock );
692         /* and try to merge the block */
693         clear_kbnode_flags( keyblock_orig );
694         clear_kbnode_flags( keyblock );
695         n_uids = n_sigs = n_subk = 0;
696         rc = merge_blocks( fname, keyblock_orig, keyblock,
697                                 keyid, &n_uids, &n_sigs, &n_subk );
698         if( rc ) {
699             keydb_release (hd);
700             goto leave;
701         }
702         if( n_uids || n_sigs || n_subk ) {
703             mod_key = 1;
704             /* keyblock_orig has been updated; write */
705             rc = keydb_update_keyblock (hd, keyblock_orig);
706             if (rc)
707                 log_error (_("error writing keyring `%s': %s\n"),
708                              keydb_get_resource_name (hd), g10_errstr(rc) );
709             else
710               revalidation_mark ();
711
712             /* we are ready */
713             if( !opt.quiet ) {
714                 char *p=get_user_id_printable(keyid);
715                 if( n_uids == 1 )
716                     log_info( _("key %08lX: \"%s\" 1 new user ID\n"),
717                                              (ulong)keyid[1], p);
718                 else if( n_uids )
719                     log_info( _("key %08lX: \"%s\" %d new user IDs\n"),
720                                              (ulong)keyid[1], p, n_uids );
721                 if( n_sigs == 1 )
722                     log_info( _("key %08lX: \"%s\" 1 new signature\n"),
723                                              (ulong)keyid[1], p);
724                 else if( n_sigs )
725                     log_info( _("key %08lX: \"%s\" %d new signatures\n"),
726                                              (ulong)keyid[1], p, n_sigs );
727                 if( n_subk == 1 )
728                     log_info( _("key %08lX: \"%s\" 1 new subkey\n"),
729                                              (ulong)keyid[1], p);
730                 else if( n_subk )
731                     log_info( _("key %08lX: \"%s\" %d new subkeys\n"),
732                                              (ulong)keyid[1], p, n_subk );
733                 m_free(p);
734             }
735
736             stats->n_uids +=n_uids;
737             stats->n_sigs +=n_sigs;
738             stats->n_subk +=n_subk;
739         }
740         else {
741             if( !opt.quiet ) {
742                 char *p=get_user_id_printable(keyid);
743                 log_info( _("key %08lX: \"%s\" not changed\n"),
744                           (ulong)keyid[1],p);
745                 m_free(p);
746             }
747             stats->unchanged++;
748         }
749         keydb_release (hd); hd = NULL;
750     }
751
752   leave:
753     release_kbnode( keyblock_orig );
754     free_public_key( pk_orig );
755
756     revocation_present(keyblock);
757
758     return rc;
759 }
760
761
762 /****************
763  * Ditto for secret keys.  Handling is simpler than for public keys.
764  * We allow secret key importing only when allow is true, this is so
765  * that a secret key can not be imported accidently and thereby tampering
766  * with the trust calculation.
767  */
768 static int
769 import_secret_one( const char *fname, KBNODE keyblock, 
770                    struct stats_s *stats)
771 {
772     PKT_secret_key *sk;
773     KBNODE node, uidnode;
774     u32 keyid[2];
775     int rc = 0;
776
777     /* get the key and print some info about it */
778     node = find_kbnode( keyblock, PKT_SECRET_KEY );
779     if( !node )
780         BUG();
781
782     sk = node->pkt->pkt.secret_key;
783     keyid_from_sk( sk, keyid );
784     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
785
786     if( opt.verbose ) {
787         log_info( "sec  %4u%c/%08lX %s   ",
788                   nbits_from_sk( sk ),
789                   pubkey_letter( sk->pubkey_algo ),
790                   (ulong)keyid[1], datestr_from_sk(sk) );
791         if( uidnode )
792             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
793                                        uidnode->pkt->pkt.user_id->len );
794         putc('\n', stderr);
795     }
796     stats->secret_read++;
797
798     if( !uidnode ) {
799         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
800         return 0;
801     }
802
803     clear_kbnode_flags( keyblock );
804
805     /* do we have this key already in one of our secrings ? */
806     rc = seckey_available( keyid );
807     if( rc == G10ERR_NO_SECKEY && !opt.merge_only ) { /* simply insert this key */
808         KEYDB_HANDLE hd = keydb_new (1);
809
810         /* get default resource */
811         rc = keydb_locate_writable (hd, NULL);
812         if (rc) {
813             log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
814             keydb_release (hd);
815             return G10ERR_GENERAL;
816         }
817         rc = keydb_insert_keyblock (hd, keyblock );
818         if (rc)
819             log_error (_("error writing keyring `%s': %s\n"),
820                        keydb_get_resource_name (hd), g10_errstr(rc) );
821         keydb_release (hd);
822         /* we are ready */
823         if( !opt.quiet )
824             log_info( _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
825         stats->secret_imported++;
826     }
827     else if( !rc ) { /* we can't merge secret keys */
828         log_error( _("key %08lX: already in secret keyring\n"),
829                                                         (ulong)keyid[1]);
830         stats->secret_dups++;
831     }
832     else
833         log_error( _("key %08lX: secret key not found: %s\n"),
834                                 (ulong)keyid[1], g10_errstr(rc));
835
836     return rc;
837 }
838
839
840 /****************
841  * Import a revocation certificate; this is a single signature packet.
842  */
843 static int
844 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
845 {
846     PKT_public_key *pk=NULL;
847     KBNODE onode, keyblock = NULL;
848     KEYDB_HANDLE hd = NULL;
849     u32 keyid[2];
850     int rc = 0;
851
852     assert( !node->next );
853     assert( node->pkt->pkttype == PKT_SIGNATURE );
854     assert( node->pkt->pkt.signature->sig_class == 0x20 );
855
856     keyid[0] = node->pkt->pkt.signature->keyid[0];
857     keyid[1] = node->pkt->pkt.signature->keyid[1];
858
859     pk = m_alloc_clear( sizeof *pk );
860     rc = get_pubkey( pk, keyid );
861     if( rc == G10ERR_NO_PUBKEY ) {
862         log_info( _("key %08lX: no public key - "
863                  "can't apply revocation certificate\n"), (ulong)keyid[1]);
864         rc = 0;
865         goto leave;
866     }
867     else if( rc ) {
868         log_error( _("key %08lX: public key not found: %s\n"),
869                                        (ulong)keyid[1], g10_errstr(rc));
870         goto leave;
871     }
872
873     /* read the original keyblock */
874     hd = keydb_new (0);
875     {
876         byte afp[MAX_FINGERPRINT_LEN];
877         size_t an;
878         
879         fingerprint_from_pk (pk, afp, &an);
880         while (an < MAX_FINGERPRINT_LEN) 
881             afp[an++] = 0;
882         rc = keydb_search_fpr (hd, afp);
883     }
884     if (rc) {
885         log_error (_("key %08lX: can't locate original keyblock: %s\n"),
886                    (ulong)keyid[1], g10_errstr(rc));
887         goto leave;
888     }
889     rc = keydb_get_keyblock (hd, &keyblock );
890     if (rc) {
891         log_error (_("key %08lX: can't read original keyblock: %s\n"),
892                    (ulong)keyid[1], g10_errstr(rc));
893         goto leave;
894     }
895
896
897     /* it is okay, that node is not in keyblock because
898      * check_key_signature works fine for sig_class 0x20 in this
899      * special case. */
900     rc = check_key_signature( keyblock, node, NULL);
901     if( rc ) {
902         log_error( _("key %08lX: invalid revocation certificate"
903                   ": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
904         goto leave;
905     }
906
907
908     /* check whether we already have this */
909     for(onode=keyblock->next; onode; onode=onode->next ) {
910         if( onode->pkt->pkttype == PKT_USER_ID )
911             break;
912         else if( onode->pkt->pkttype == PKT_SIGNATURE
913                  && onode->pkt->pkt.signature->sig_class == 0x20
914                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
915                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
916             rc = 0;
917             goto leave; /* yes, we already know about it */
918         }
919     }
920
921
922     /* insert it */
923     insert_kbnode( keyblock, clone_kbnode(node), 0 );
924
925     /* and write the keyblock back */
926     rc = keydb_update_keyblock (hd, keyblock );
927     if (rc)
928         log_error (_("error writing keyring `%s': %s\n"),
929                    keydb_get_resource_name (hd), g10_errstr(rc) );
930     keydb_release (hd); hd = NULL;
931     /* we are ready */
932     if( !opt.quiet ) {
933         char *p=get_user_id_printable (keyid);
934         log_info( _("key %08lX: \"%s\" revocation certificate imported\n"),
935                                         (ulong)keyid[1],p);
936         m_free(p);
937     }
938     stats->n_revoc++;
939     revalidation_mark ();
940
941   leave:
942     keydb_release (hd);
943     release_kbnode( keyblock );
944     free_public_key( pk );
945     return rc;
946 }
947
948
949 /****************
950  * loop over the keyblock and check all self signatures.
951  * Mark all user-ids with a self-signature by setting flag bit 0.
952  * Mark all user-ids with an invalid self-signature by setting bit 1.
953  * This works also for subkeys, here the subkey is marked.  Invalid or
954  * extra subkey sigs (binding or revocation) are marked for deletion.
955  */
956 static int
957 chk_self_sigs( const char *fname, KBNODE keyblock,
958                PKT_public_key *pk, u32 *keyid )
959 {
960     KBNODE n,knode=NULL;
961     PKT_signature *sig;
962     int rc;
963     u32 bsdate=0,rsdate=0;
964     KBNODE bsnode=NULL,rsnode=NULL;
965
966     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
967       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
968         {
969           knode=n;
970           bsdate=0;
971           rsdate=0;
972           bsnode=NULL;
973           rsnode=NULL;
974         }
975       else if( n->pkt->pkttype != PKT_SIGNATURE )
976             continue;
977         sig = n->pkt->pkt.signature;
978         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
979             if( (sig->sig_class&~3) == 0x10 ) {
980                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
981                 if( !unode )  {
982                     log_error( _("key %08lX: no user ID for signature\n"),
983                                             (ulong)keyid[1]);
984                     return -1;  /* the complete keyblock is invalid */
985                 }
986
987                 /* If it hasn't been marked valid yet, keep trying */
988                 if(!(unode->flag&1)) {
989                   rc = check_key_signature( keyblock, n, NULL);
990                   if( rc )
991                     {
992                       char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
993                                       strlen(unode->pkt->pkt.user_id->name),0);
994                       log_info( rc == G10ERR_PUBKEY_ALGO ?
995                                 _("key %08lX: unsupported public key "
996                                   "algorithm on user id \"%s\"\n"):
997                                 _("key %08lX: invalid self-signature "
998                                   "on user id \"%s\"\n"),
999                                 (ulong)keyid[1],p);
1000                       m_free(p);
1001                     }
1002                   else
1003                     unode->flag |= 1; /* mark that signature checked */
1004                 }
1005             }
1006             else if( sig->sig_class == 0x18 ) {
1007               /* Note that this works based solely on the timestamps
1008                  like the rest of gpg.  If the standard gets
1009                  revocation targets, this may need to be revised. */
1010
1011                 if( !knode ) {
1012                     log_info( _("key %08lX: no subkey for key binding\n"),
1013                                             (ulong)keyid[1]);
1014                     n->flag |= 4; /* delete this */
1015                 }
1016                 else {
1017                   rc = check_key_signature( keyblock, n, NULL);
1018                   if( rc ) {
1019                     log_info(  rc == G10ERR_PUBKEY_ALGO ?
1020                             _("key %08lX: unsupported public key algorithm\n"):
1021                             _("key %08lX: invalid subkey binding\n"),
1022                             (ulong)keyid[1]);
1023                     n->flag|=4;
1024                   }
1025                   else {
1026                     /* It's valid, so is it newer? */
1027                     if(sig->timestamp>=bsdate) {
1028                       knode->flag |= 1;  /* the subkey is valid */
1029                       if(bsnode) {
1030                         bsnode->flag|=4; /* Delete the last binding
1031                                             sig since this one is
1032                                             newer */
1033                         log_info(_("key %08lX: removed multiple subkey "
1034                                    "binding\n"),(ulong)keyid[1]);
1035                       }
1036
1037                       bsnode=n;
1038                       bsdate=sig->timestamp;
1039                     }
1040                     else
1041                       n->flag|=4; /* older */
1042                   }
1043                 }
1044             }
1045             else if( sig->sig_class == 0x28 ) {
1046               /* We don't actually mark the subkey as revoked right
1047                  now, so just check that the revocation sig is the
1048                  most recent valid one.  Note that we don't care if
1049                  the binding sig is newer than the revocation sig.
1050                  See the comment in getkey.c:merge_selfsigs_subkey for
1051                  more */
1052                 if( !knode ) {
1053                     log_info( _("key %08lX: no subkey for key revocation\n"),
1054                                             (ulong)keyid[1]);
1055                     n->flag |= 4; /* delete this */
1056                 }
1057                 else {
1058                   rc = check_key_signature( keyblock, n, NULL);
1059                   if( rc ) {
1060                     log_info(  rc == G10ERR_PUBKEY_ALGO ?
1061                             _("key %08lX: unsupported public key algorithm\n"):
1062                             _("key %08lX: invalid subkey revocation\n"),
1063                                (ulong)keyid[1]);
1064                     n->flag|=4;
1065                   }
1066                   else {
1067                     /* It's valid, so is it newer? */
1068                     if(sig->timestamp>=rsdate) {
1069                       if(rsnode) {
1070                         rsnode->flag|=4; /* Delete the last revocation
1071                                             sig since this one is
1072                                             newer */
1073                         log_info(_("key %08lX: removed multiple subkey "
1074                                    "revocation\n"),(ulong)keyid[1]);
1075                       }
1076
1077                       rsnode=n;
1078                       rsdate=sig->timestamp;
1079                     }
1080                     else
1081                       n->flag|=4; /* older */
1082                   }
1083                 }
1084             }
1085         }
1086     }
1087
1088     return 0;
1089 }
1090
1091 /****************
1092  * delete all parts which are invalid and those signatures whose
1093  * public key algorithm is not available in this implemenation;
1094  * but consider RSA as valid, because parse/build_packets knows
1095  * about it.
1096  * returns: true if at least one valid user-id is left over.
1097  */
1098 static int
1099 delete_inv_parts( const char *fname, KBNODE keyblock,
1100                   u32 *keyid, unsigned int options)
1101 {
1102     KBNODE node;
1103     int nvalid=0, uid_seen=0, subkey_seen=0;
1104
1105     for(node=keyblock->next; node; node = node->next ) {
1106         if( node->pkt->pkttype == PKT_USER_ID ) {
1107             uid_seen = 1;
1108             if( (node->flag & 2) || !(node->flag & 1) ) {
1109                 if( opt.verbose ) {
1110                     log_info( _("key %08lX: skipped user ID '"),
1111                                                          (ulong)keyid[1]);
1112                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
1113                                        node->pkt->pkt.user_id->len );
1114                     fputs("'\n", stderr );
1115                 }
1116                 delete_kbnode( node ); /* the user-id */
1117                 /* and all following packets up to the next user-id */
1118                 while( node->next
1119                        && node->next->pkt->pkttype != PKT_USER_ID
1120                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1121                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1122                     delete_kbnode( node->next );
1123                     node = node->next;
1124                 }
1125             }
1126             else
1127                 nvalid++;
1128         }
1129         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1130                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1131             if( (node->flag & 2) || !(node->flag & 1) ) {
1132                 if( opt.verbose ) {
1133                     log_info( _("key %08lX: skipped subkey\n"),
1134                                                          (ulong)keyid[1]);
1135                 }
1136                 delete_kbnode( node ); /* the subkey */
1137                 /* and all following signature packets */
1138                 while( node->next
1139                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1140                     delete_kbnode( node->next );
1141                     node = node->next;
1142                 }
1143             }
1144             else
1145               subkey_seen = 1;
1146         }
1147         else if( node->pkt->pkttype == PKT_SIGNATURE
1148                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1149                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1150             delete_kbnode( node ); /* build_packet() can't handle this */
1151         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1152                  !node->pkt->pkt.signature->flags.exportable &&
1153                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1154                  seckey_available( node->pkt->pkt.signature->keyid ) ) {
1155             /* here we violate the rfc a bit by still allowing
1156              * to import non-exportable signature when we have the
1157              * the secret key used to create this signature - it
1158              * seems that this makes sense */
1159             log_info( _("key %08lX: non exportable signature "
1160                                     "(class %02x) - skipped\n"),
1161                                     (ulong)keyid[1],
1162                                      node->pkt->pkt.signature->sig_class );
1163             delete_kbnode( node );
1164         }
1165         else if( node->pkt->pkttype == PKT_SIGNATURE
1166                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1167             if( uid_seen ) {
1168                 log_error( _("key %08lX: revocation certificate "
1169                                      "at wrong place - skipped\n"),
1170                                     (ulong)keyid[1]);
1171                 delete_kbnode( node );
1172             }
1173             else {
1174               /* If the revocation cert is from a different key than
1175                  the one we're working on don't check it - it's
1176                  probably from a revocation key and won't be
1177                  verifiable with this key anyway. */
1178
1179               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1180                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1181                 {
1182                   int rc = check_key_signature( keyblock, node, NULL);
1183                   if( rc )
1184                     {
1185                       log_error( _("key %08lX: invalid revocation "
1186                                    "certificate: %s - skipped\n"),
1187                                  (ulong)keyid[1], g10_errstr(rc));
1188                       delete_kbnode( node );
1189                     }
1190                 }
1191             }
1192         }
1193         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1194                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1195                   node->pkt->pkt.signature->sig_class == 0x28) &&
1196                  !subkey_seen ) {
1197             log_error( _("key %08lX: subkey signature "
1198                          "in wrong place - skipped\n"),
1199                        (ulong)keyid[1]);
1200             delete_kbnode( node );
1201         }
1202         else if( (node->flag & 4) ) /* marked for deletion */
1203             delete_kbnode( node );
1204     }
1205
1206     /* note: because keyblock is the public key, it is never marked
1207      * for deletion and so keyblock cannot change */
1208     commit_kbnode( &keyblock );
1209     return nvalid;
1210 }
1211
1212
1213 /****************
1214  * It may happen that the imported keyblock has duplicated user IDs.
1215  * We check this here and collapse those user IDs together with their
1216  * sigs into one.
1217  * Returns: True if the keyblock hash changed.
1218  */
1219 int
1220 collapse_uids( KBNODE *keyblock )
1221 {
1222     KBNODE n, n2;
1223     int in_uid;
1224     int any=0;
1225     u32 kid1;
1226
1227   restart:
1228     for( n = *keyblock; n; n = n->next ) {
1229         if( n->pkt->pkttype != PKT_USER_ID )
1230             continue;
1231         for( n2 = n->next; n2; n2 = n2->next ) {
1232             if( n2->pkt->pkttype == PKT_USER_ID
1233                 && !cmp_user_ids( n->pkt->pkt.user_id,
1234                                   n2->pkt->pkt.user_id ) ) {
1235                 /* found a duplicate */
1236                 any = 1;
1237                 if( !n2->next
1238                     || n2->next->pkt->pkttype == PKT_USER_ID
1239                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1240                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1241                     /* no more signatures: delete the user ID
1242                      * and start over */
1243                     remove_kbnode( keyblock, n2 );
1244                 }
1245                 else {
1246                     /* The simple approach: Move one signature and
1247                      * then start over to delete the next one :-( */
1248                     move_kbnode( keyblock, n2->next, n->next );
1249                 }
1250                 goto restart;
1251             }
1252         }
1253     }
1254     if( !any )
1255         return 0;
1256
1257   restart_sig:
1258     /* now we may have duplicate signatures on one user ID: fix this */
1259     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1260         if( n->pkt->pkttype == PKT_USER_ID )
1261             in_uid = 1;
1262         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1263                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1264             in_uid = 0;
1265         else if( in_uid ) {
1266             n2 = n;
1267             do {
1268                 KBNODE ncmp = NULL;
1269                 for( ; n2; n2 = n2->next ) {
1270                     if(    n2->pkt->pkttype == PKT_USER_ID
1271                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1272                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1273                         break;
1274                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1275                         ;
1276                     else if( !ncmp )
1277                         ncmp = n2;
1278                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1279                                                 n2->pkt->pkt.signature )) {
1280                         remove_kbnode( keyblock, n2 );
1281                         goto restart_sig;
1282                     }
1283                 }
1284                 n2 = ncmp? ncmp->next : NULL;
1285             } while( n2 );
1286         }
1287     }
1288
1289     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1290         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
1291     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1292         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
1293     else
1294         kid1 = 0;
1295     log_info(_("key %08lX: duplicated user ID detected - merged\n"),
1296                                                                  (ulong)kid1);
1297
1298     return 1;
1299 }
1300
1301 /* Check for a 0x20 revocation from a revocation key that is not
1302    present.  This gets called without the benefit of merge_xxxx so you
1303    can't rely on pk->revkey and friends. */
1304 static void
1305 revocation_present(KBNODE keyblock)
1306 {
1307   KBNODE onode,inode;
1308   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1309
1310   for(onode=keyblock->next;onode;onode=onode->next)
1311     {
1312       /* If we reach user IDs, we're done. */
1313       if(onode->pkt->pkttype==PKT_USER_ID)
1314         break;
1315
1316       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1317          onode->pkt->pkt.signature->sig_class==0x1F &&
1318          onode->pkt->pkt.signature->revkey)
1319         {
1320           int idx;
1321           PKT_signature *sig=onode->pkt->pkt.signature;
1322
1323           for(idx=0;idx<sig->numrevkeys;idx++)
1324             {
1325               u32 keyid[2];
1326
1327               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1328                                      MAX_FINGERPRINT_LEN,keyid);
1329
1330               for(inode=keyblock->next;inode;inode=inode->next)
1331                 {
1332                   /* If we reach user IDs, we're done. */
1333                   if(inode->pkt->pkttype==PKT_USER_ID)
1334                     break;
1335
1336                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1337                      inode->pkt->pkt.signature->sig_class==0x20 &&
1338                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1339                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1340                     {
1341                       /* Okay, we have a revocation key, and a
1342                          revocation issued by it.  Do we have the key
1343                          itself? */
1344                       int rc;
1345
1346                       rc=get_pubkey_byfprint(NULL,sig->revkey[idx]->fpr,
1347                                              MAX_FINGERPRINT_LEN);
1348                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1349                         {
1350                           /* No, so try and get it */
1351                           if(opt.keyserver_scheme &&
1352                              opt.keyserver_options.auto_key_retrieve)
1353                             {
1354                               log_info(_("WARNING: key %08lX may be revoked: "
1355                                          "fetching revocation key %08lX\n"),
1356                                        (ulong)keyid_from_pk(pk,NULL),
1357                                        (ulong)keyid[1]);
1358                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1359                                                       MAX_FINGERPRINT_LEN);
1360
1361                               /* Do we have it now? */
1362                               rc=get_pubkey_byfprint(NULL,
1363                                                      sig->revkey[idx]->fpr,
1364                                                      MAX_FINGERPRINT_LEN);
1365                             }
1366
1367                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1368                             log_info(_("WARNING: key %08lX may be revoked: "
1369                                        "revocation key %08lX not present.\n"),
1370                                      (ulong)keyid_from_pk(pk,NULL),
1371                                      (ulong)keyid[1]);
1372                         }
1373                     }
1374                 }
1375             }
1376         }
1377     }
1378 }
1379
1380 /****************
1381  * compare and merge the blocks
1382  *
1383  * o compare the signatures: If we already have this signature, check
1384  *   that they compare okay; if not, issue a warning and ask the user.
1385  * o Simply add the signature.  Can't verify here because we may not have
1386  *   the signature's public key yet; verification is done when putting it
1387  *   into the trustdb, which is done automagically as soon as this pubkey
1388  *   is used.
1389  * Note: We indicate newly inserted packets with flag bit 0
1390  */
1391 static int
1392 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1393               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1394 {
1395     KBNODE onode, node;
1396     int rc, found;
1397
1398     /* 1st: handle revocation certificates */
1399     for(node=keyblock->next; node; node=node->next ) {
1400         if( node->pkt->pkttype == PKT_USER_ID )
1401             break;
1402         else if( node->pkt->pkttype == PKT_SIGNATURE
1403                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1404             /* check whether we already have this */
1405             found = 0;
1406             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1407                 if( onode->pkt->pkttype == PKT_USER_ID )
1408                     break;
1409                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1410                          && onode->pkt->pkt.signature->sig_class == 0x20
1411                          && node->pkt->pkt.signature->keyid[0]
1412                             == onode->pkt->pkt.signature->keyid[0]
1413                          && node->pkt->pkt.signature->keyid[1]
1414                             == onode->pkt->pkt.signature->keyid[1] ) {
1415                     found = 1;
1416                     break;
1417                 }
1418             }
1419             if( !found ) {
1420                 char *p=get_user_id_printable (keyid);
1421                 KBNODE n2 = clone_kbnode(node);
1422                 insert_kbnode( keyblock_orig, n2, 0 );
1423                 n2->flag |= 1;
1424                 ++*n_sigs;
1425                 log_info(_("key %08lX: \"%s\" revocation certificate added\n"),
1426                                          (ulong)keyid[1],p);
1427                 m_free(p);
1428             }
1429         }
1430     }
1431
1432     /* 2nd: merge in any direct key (0x1F) sigs */
1433     for(node=keyblock->next; node; node=node->next ) {
1434         if( node->pkt->pkttype == PKT_USER_ID )
1435             break;
1436         else if( node->pkt->pkttype == PKT_SIGNATURE
1437                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1438             /* check whether we already have this */
1439             found = 0;
1440             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1441                 if( onode->pkt->pkttype == PKT_USER_ID )
1442                     break;
1443                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1444                          && onode->pkt->pkt.signature->sig_class == 0x1F
1445                          && !cmp_signatures(onode->pkt->pkt.signature,
1446                                             node->pkt->pkt.signature)) {
1447                     found = 1;
1448                     break;
1449                 }
1450             }
1451             if( !found ) {
1452                 KBNODE n2 = clone_kbnode(node);
1453                 insert_kbnode( keyblock_orig, n2, 0 );
1454                 n2->flag |= 1;
1455                 ++*n_sigs;
1456                 log_info( _("key %08lX: direct key signature added\n"),
1457                                          (ulong)keyid[1]);
1458             }
1459         }
1460     }
1461
1462     /* 3rd: try to merge new certificates in */
1463     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1464         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1465             /* find the user id in the imported keyblock */
1466             for(node=keyblock->next; node; node=node->next )
1467                 if( node->pkt->pkttype == PKT_USER_ID
1468                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1469                                           node->pkt->pkt.user_id ) )
1470                     break;
1471             if( node ) { /* found: merge */
1472                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1473                 if( rc )
1474                     return rc;
1475             }
1476         }
1477     }
1478
1479     /* 4th: add new user-ids */
1480     for(node=keyblock->next; node; node=node->next ) {
1481         if( node->pkt->pkttype == PKT_USER_ID) {
1482             /* do we have this in the original keyblock */
1483             for(onode=keyblock_orig->next; onode; onode=onode->next )
1484                 if( onode->pkt->pkttype == PKT_USER_ID
1485                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1486                                       node->pkt->pkt.user_id ) )
1487                     break;
1488             if( !onode ) { /* this is a new user id: append */
1489                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1490                 if( rc )
1491                     return rc;
1492                 ++*n_uids;
1493             }
1494         }
1495     }
1496
1497     /* 5th: add new subkeys */
1498     for(node=keyblock->next; node; node=node->next ) {
1499         onode = NULL;
1500         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1501             /* do we have this in the original keyblock? */
1502             for(onode=keyblock_orig->next; onode; onode=onode->next )
1503                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1504                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1505                                          node->pkt->pkt.public_key ) )
1506                     break;
1507             if( !onode ) { /* this is a new subkey: append */
1508                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1509                 if( rc )
1510                     return rc;
1511                 ++*n_subk;
1512             }
1513         }
1514         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1515             /* do we have this in the original keyblock? */
1516             for(onode=keyblock_orig->next; onode; onode=onode->next )
1517                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1518                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1519                                          node->pkt->pkt.secret_key ) )
1520                     break;
1521             if( !onode ) { /* this is a new subkey: append */
1522                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1523                 if( rc )
1524                     return rc;
1525                 ++*n_subk;
1526             }
1527         }
1528     }
1529
1530     /* 6th: merge subkey certificates */
1531     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1532         if( !(onode->flag & 1)
1533             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1534                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1535             /* find the subkey in the imported keyblock */
1536             for(node=keyblock->next; node; node=node->next ) {
1537                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1538                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1539                                           node->pkt->pkt.public_key ) )
1540                     break;
1541                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1542                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1543                                           node->pkt->pkt.secret_key ) )
1544                     break;
1545             }
1546             if( node ) { /* found: merge */
1547                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1548                 if( rc )
1549                     return rc;
1550             }
1551         }
1552     }
1553
1554
1555     return 0;
1556 }
1557
1558
1559 /****************
1560  * append the userid starting with NODE and all signatures to KEYBLOCK.
1561  */
1562 static int
1563 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1564                                           const char *fname, u32 *keyid )
1565 {
1566     KBNODE n, n_where=NULL;
1567
1568     assert(node->pkt->pkttype == PKT_USER_ID );
1569
1570     /* find the position */
1571     for( n = keyblock; n; n_where = n, n = n->next ) {
1572         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1573             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1574             break;
1575     }
1576     if( !n )
1577         n_where = NULL;
1578
1579     /* and append/insert */
1580     while( node ) {
1581         /* we add a clone to the original keyblock, because this
1582          * one is released first */
1583         n = clone_kbnode(node);
1584         if( n_where ) {
1585             insert_kbnode( n_where, n, 0 );
1586             n_where = n;
1587         }
1588         else
1589             add_kbnode( keyblock, n );
1590         n->flag |= 1;
1591         node->flag |= 1;
1592         if( n->pkt->pkttype == PKT_SIGNATURE )
1593             ++*n_sigs;
1594
1595         node = node->next;
1596         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1597             break;
1598     }
1599
1600     return 0;
1601 }
1602
1603
1604 /****************
1605  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1606  * (how should we handle comment packets here?)
1607  */
1608 static int
1609 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1610                                     const char *fname, u32 *keyid )
1611 {
1612     KBNODE n, n2;
1613     int found=0;
1614
1615     assert(dst->pkt->pkttype == PKT_USER_ID );
1616     assert(src->pkt->pkttype == PKT_USER_ID );
1617
1618     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1619         if( n->pkt->pkttype != PKT_SIGNATURE )
1620             continue;
1621         if( n->pkt->pkt.signature->sig_class == 0x18
1622             || n->pkt->pkt.signature->sig_class == 0x28 )
1623             continue; /* skip signatures which are only valid on subkeys */
1624         found = 0;
1625         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1626             if( n2->pkt->pkttype == PKT_SIGNATURE
1627                 && n->pkt->pkt.signature->keyid[0]
1628                    == n2->pkt->pkt.signature->keyid[0]
1629                 && n->pkt->pkt.signature->keyid[1]
1630                    == n2->pkt->pkt.signature->keyid[1]
1631                 && n->pkt->pkt.signature->timestamp
1632                    <= n2->pkt->pkt.signature->timestamp
1633                 && n->pkt->pkt.signature->sig_class
1634                    == n2->pkt->pkt.signature->sig_class ) {
1635                 found++;
1636                 break;
1637             }
1638         }
1639         if( !found ) {
1640             /* This signature is new or newer, append N to DST.
1641              * We add a clone to the original keyblock, because this
1642              * one is released first */
1643             n2 = clone_kbnode(n);
1644             insert_kbnode( dst, n2, PKT_SIGNATURE );
1645             n2->flag |= 1;
1646             n->flag |= 1;
1647             ++*n_sigs;
1648         }
1649     }
1650
1651     return 0;
1652 }
1653
1654 /****************
1655  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1656  */
1657 static int
1658 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1659                                     const char *fname, u32 *keyid )
1660 {
1661     KBNODE n, n2;
1662     int found=0;
1663
1664     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1665            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1666
1667     for(n=src->next; n ; n = n->next ) {
1668         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1669             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1670             break;
1671         if( n->pkt->pkttype != PKT_SIGNATURE )
1672             continue;
1673         found = 0;
1674         for(n2=dst->next; n2; n2 = n2->next){
1675             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1676                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1677                 break;
1678             if( n2->pkt->pkttype == PKT_SIGNATURE
1679                 && n->pkt->pkt.signature->keyid[0]
1680                    == n2->pkt->pkt.signature->keyid[0]
1681                 && n->pkt->pkt.signature->keyid[1]
1682                    == n2->pkt->pkt.signature->keyid[1]
1683                 && n->pkt->pkt.signature->timestamp
1684                    <= n2->pkt->pkt.signature->timestamp
1685                 && n->pkt->pkt.signature->sig_class
1686                    == n2->pkt->pkt.signature->sig_class ) {
1687                 found++;
1688                 break;
1689             }
1690         }
1691         if( !found ) {
1692             /* This signature is new or newer, append N to DST.
1693              * We add a clone to the original keyblock, because this
1694              * one is released first */
1695             n2 = clone_kbnode(n);
1696             insert_kbnode( dst, n2, PKT_SIGNATURE );
1697             n2->flag |= 1;
1698             n->flag |= 1;
1699             ++*n_sigs;
1700         }
1701     }
1702
1703     return 0;
1704 }
1705
1706 /****************
1707  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1708  * Mark all new and copied packets by setting flag bit 0.
1709  */
1710 static int
1711 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1712                                           const char *fname, u32 *keyid )
1713 {
1714     KBNODE n;
1715
1716     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1717            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1718
1719     while(  node ) {
1720         /* we add a clone to the original keyblock, because this
1721          * one is released first */
1722         n = clone_kbnode(node);
1723         add_kbnode( keyblock, n );
1724         n->flag |= 1;
1725         node->flag |= 1;
1726         if( n->pkt->pkttype == PKT_SIGNATURE )
1727             ++*n_sigs;
1728
1729         node = node->next;
1730         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1731             break;
1732     }
1733
1734     return 0;
1735 }