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