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