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