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