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