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