f54f8d85055dabb70cc82aa29c5c67d01ea0f2a4
[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 inp = 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( inp, fname, stats, options );
203                 iobuf_close(inp);
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     clear_kbnode_flags( keyblock );
854
855     /* do we have this key already in one of our secrings ? */
856     rc = seckey_available( keyid );
857     if( rc == G10ERR_NO_SECKEY && !opt.merge_only ) { /* simply insert this key */
858         KEYDB_HANDLE hd = keydb_new (1);
859
860         /* get default resource */
861         rc = keydb_locate_writable (hd, NULL);
862         if (rc) {
863             log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
864             keydb_release (hd);
865             return G10ERR_GENERAL;
866         }
867         rc = keydb_insert_keyblock (hd, keyblock );
868         if (rc)
869             log_error (_("error writing keyring `%s': %s\n"),
870                        keydb_get_resource_name (hd), g10_errstr(rc) );
871         keydb_release (hd);
872         /* we are ready */
873         if( !opt.quiet )
874             log_info( _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
875         stats->secret_imported++;
876         if (is_status_enabled ()) 
877              print_import_ok (NULL, sk, 1|16);
878     }
879     else if( !rc ) { /* we can't merge secret keys */
880         log_error( _("key %08lX: already in secret keyring\n"),
881                                                         (ulong)keyid[1]);
882         stats->secret_dups++;
883         if (is_status_enabled ()) 
884              print_import_ok (NULL, sk, 16);
885     }
886     else
887         log_error( _("key %08lX: secret key not found: %s\n"),
888                                 (ulong)keyid[1], g10_errstr(rc));
889
890     return rc;
891 }
892
893
894 /****************
895  * Import a revocation certificate; this is a single signature packet.
896  */
897 static int
898 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
899 {
900     PKT_public_key *pk=NULL;
901     KBNODE onode, keyblock = NULL;
902     KEYDB_HANDLE hd = NULL;
903     u32 keyid[2];
904     int rc = 0;
905
906     assert( !node->next );
907     assert( node->pkt->pkttype == PKT_SIGNATURE );
908     assert( node->pkt->pkt.signature->sig_class == 0x20 );
909
910     keyid[0] = node->pkt->pkt.signature->keyid[0];
911     keyid[1] = node->pkt->pkt.signature->keyid[1];
912
913     pk = m_alloc_clear( sizeof *pk );
914     rc = get_pubkey( pk, keyid );
915     if( rc == G10ERR_NO_PUBKEY ) {
916         log_info( _("key %08lX: no public key - "
917                  "can't apply revocation certificate\n"), (ulong)keyid[1]);
918         rc = 0;
919         goto leave;
920     }
921     else if( rc ) {
922         log_error( _("key %08lX: public key not found: %s\n"),
923                                        (ulong)keyid[1], g10_errstr(rc));
924         goto leave;
925     }
926
927     /* read the original keyblock */
928     hd = keydb_new (0);
929     {
930         byte afp[MAX_FINGERPRINT_LEN];
931         size_t an;
932         
933         fingerprint_from_pk (pk, afp, &an);
934         while (an < MAX_FINGERPRINT_LEN) 
935             afp[an++] = 0;
936         rc = keydb_search_fpr (hd, afp);
937     }
938     if (rc) {
939         log_error (_("key %08lX: can't locate original keyblock: %s\n"),
940                    (ulong)keyid[1], g10_errstr(rc));
941         goto leave;
942     }
943     rc = keydb_get_keyblock (hd, &keyblock );
944     if (rc) {
945         log_error (_("key %08lX: can't read original keyblock: %s\n"),
946                    (ulong)keyid[1], g10_errstr(rc));
947         goto leave;
948     }
949
950
951     /* it is okay, that node is not in keyblock because
952      * check_key_signature works fine for sig_class 0x20 in this
953      * special case. */
954     rc = check_key_signature( keyblock, node, NULL);
955     if( rc ) {
956         log_error( _("key %08lX: invalid revocation certificate"
957                   ": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
958         goto leave;
959     }
960
961
962     /* check whether we already have this */
963     for(onode=keyblock->next; onode; onode=onode->next ) {
964         if( onode->pkt->pkttype == PKT_USER_ID )
965             break;
966         else if( onode->pkt->pkttype == PKT_SIGNATURE
967                  && onode->pkt->pkt.signature->sig_class == 0x20
968                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
969                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
970             rc = 0;
971             goto leave; /* yes, we already know about it */
972         }
973     }
974
975
976     /* insert it */
977     insert_kbnode( keyblock, clone_kbnode(node), 0 );
978
979     /* and write the keyblock back */
980     rc = keydb_update_keyblock (hd, keyblock );
981     if (rc)
982         log_error (_("error writing keyring `%s': %s\n"),
983                    keydb_get_resource_name (hd), g10_errstr(rc) );
984     keydb_release (hd); hd = NULL;
985     /* we are ready */
986     if( !opt.quiet ) {
987         char *p=get_user_id_printable (keyid);
988         log_info( _("key %08lX: \"%s\" revocation certificate imported\n"),
989                                         (ulong)keyid[1],p);
990         m_free(p);
991     }
992     stats->n_revoc++;
993     revalidation_mark ();
994
995   leave:
996     keydb_release (hd);
997     release_kbnode( keyblock );
998     free_public_key( pk );
999     return rc;
1000 }
1001
1002
1003 /****************
1004  * loop over the keyblock and check all self signatures.
1005  * Mark all user-ids with a self-signature by setting flag bit 0.
1006  * Mark all user-ids with an invalid self-signature by setting bit 1.
1007  * This works also for subkeys, here the subkey is marked.  Invalid or
1008  * extra subkey sigs (binding or revocation) are marked for deletion.
1009  */
1010 static int
1011 chk_self_sigs( const char *fname, KBNODE keyblock,
1012                PKT_public_key *pk, u32 *keyid )
1013 {
1014     KBNODE n,knode=NULL;
1015     PKT_signature *sig;
1016     int rc;
1017     u32 bsdate=0,rsdate=0;
1018     KBNODE bsnode=NULL,rsnode=NULL;
1019
1020     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1021       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1022         {
1023           knode=n;
1024           bsdate=0;
1025           rsdate=0;
1026           bsnode=NULL;
1027           rsnode=NULL;
1028         }
1029       else if( n->pkt->pkttype != PKT_SIGNATURE )
1030             continue;
1031         sig = n->pkt->pkt.signature;
1032         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1033             if( (sig->sig_class&~3) == 0x10 ) {
1034                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1035                 if( !unode )  {
1036                     log_error( _("key %08lX: no user ID for signature\n"),
1037                                             (ulong)keyid[1]);
1038                     return -1;  /* the complete keyblock is invalid */
1039                 }
1040
1041                 /* If it hasn't been marked valid yet, keep trying */
1042                 if(!(unode->flag&1)) {
1043                   rc = check_key_signature( keyblock, n, NULL);
1044                   if( rc )
1045                     {
1046                       char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1047                                       strlen(unode->pkt->pkt.user_id->name),0);
1048                       log_info( rc == G10ERR_PUBKEY_ALGO ?
1049                                 _("key %08lX: unsupported public key "
1050                                   "algorithm on user id \"%s\"\n"):
1051                                 _("key %08lX: invalid self-signature "
1052                                   "on user id \"%s\"\n"),
1053                                 (ulong)keyid[1],p);
1054                       m_free(p);
1055                     }
1056                   else
1057                     unode->flag |= 1; /* mark that signature checked */
1058                 }
1059             }
1060             else if( sig->sig_class == 0x18 ) {
1061               /* Note that this works based solely on the timestamps
1062                  like the rest of gpg.  If the standard gets
1063                  revocation targets, this may need to be revised. */
1064
1065                 if( !knode ) {
1066                     log_info( _("key %08lX: no subkey for subkey "
1067                                 "binding signature\n"),(ulong)keyid[1]);
1068                     n->flag |= 4; /* delete this */
1069                 }
1070                 else {
1071                   rc = check_key_signature( keyblock, n, NULL);
1072                   if( rc ) {
1073                     log_info(  rc == G10ERR_PUBKEY_ALGO ?
1074                             _("key %08lX: unsupported public key algorithm\n"):
1075                             _("key %08lX: invalid subkey binding\n"),
1076                             (ulong)keyid[1]);
1077                     n->flag|=4;
1078                   }
1079                   else {
1080                     /* It's valid, so is it newer? */
1081                     if(sig->timestamp>=bsdate) {
1082                       knode->flag |= 1;  /* the subkey is valid */
1083                       if(bsnode) {
1084                         bsnode->flag|=4; /* Delete the last binding
1085                                             sig since this one is
1086                                             newer */
1087                         log_info(_("key %08lX: removed multiple subkey "
1088                                    "binding\n"),(ulong)keyid[1]);
1089                       }
1090
1091                       bsnode=n;
1092                       bsdate=sig->timestamp;
1093                     }
1094                     else
1095                       n->flag|=4; /* older */
1096                   }
1097                 }
1098             }
1099             else if( sig->sig_class == 0x28 ) {
1100               /* We don't actually mark the subkey as revoked right
1101                  now, so just check that the revocation sig is the
1102                  most recent valid one.  Note that we don't care if
1103                  the binding sig is newer than the revocation sig.
1104                  See the comment in getkey.c:merge_selfsigs_subkey for
1105                  more */
1106                 if( !knode ) {
1107                     log_info( _("key %08lX: no subkey for subkey "
1108                                 "revocation signature\n"),(ulong)keyid[1]);
1109                     n->flag |= 4; /* delete this */
1110                 }
1111                 else {
1112                   rc = check_key_signature( keyblock, n, NULL);
1113                   if( rc ) {
1114                     log_info(  rc == G10ERR_PUBKEY_ALGO ?
1115                             _("key %08lX: unsupported public key algorithm\n"):
1116                             _("key %08lX: invalid subkey revocation\n"),
1117                                (ulong)keyid[1]);
1118                     n->flag|=4;
1119                   }
1120                   else {
1121                     /* It's valid, so is it newer? */
1122                     if(sig->timestamp>=rsdate) {
1123                       if(rsnode) {
1124                         rsnode->flag|=4; /* Delete the last revocation
1125                                             sig since this one is
1126                                             newer */
1127                         log_info(_("key %08lX: removed multiple subkey "
1128                                    "revocation signatures\n"),(ulong)keyid[1]);
1129                       }
1130
1131                       rsnode=n;
1132                       rsdate=sig->timestamp;
1133                     }
1134                     else
1135                       n->flag|=4; /* older */
1136                   }
1137                 }
1138             }
1139         }
1140     }
1141
1142     return 0;
1143 }
1144
1145 /****************
1146  * delete all parts which are invalid and those signatures whose
1147  * public key algorithm is not available in this implemenation;
1148  * but consider RSA as valid, because parse/build_packets knows
1149  * about it.
1150  * returns: true if at least one valid user-id is left over.
1151  */
1152 static int
1153 delete_inv_parts( const char *fname, KBNODE keyblock,
1154                   u32 *keyid, unsigned int options)
1155 {
1156     KBNODE node;
1157     int nvalid=0, uid_seen=0, subkey_seen=0;
1158
1159     for(node=keyblock->next; node; node = node->next ) {
1160         if( node->pkt->pkttype == PKT_USER_ID ) {
1161             uid_seen = 1;
1162             if( (node->flag & 2) || !(node->flag & 1) ) {
1163                 if( opt.verbose ) {
1164                     log_info( _("key %08lX: skipped user ID '"),
1165                                                          (ulong)keyid[1]);
1166                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
1167                                        node->pkt->pkt.user_id->len );
1168                     fputs("'\n", stderr );
1169                 }
1170                 delete_kbnode( node ); /* the user-id */
1171                 /* and all following packets up to the next user-id */
1172                 while( node->next
1173                        && node->next->pkt->pkttype != PKT_USER_ID
1174                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1175                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1176                     delete_kbnode( node->next );
1177                     node = node->next;
1178                 }
1179             }
1180             else
1181                 nvalid++;
1182         }
1183         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1184                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1185             if( (node->flag & 2) || !(node->flag & 1) ) {
1186                 if( opt.verbose ) {
1187                     log_info( _("key %08lX: skipped subkey\n"),
1188                                                          (ulong)keyid[1]);
1189                 }
1190                 delete_kbnode( node ); /* the subkey */
1191                 /* and all following signature packets */
1192                 while( node->next
1193                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1194                     delete_kbnode( node->next );
1195                     node = node->next;
1196                 }
1197             }
1198             else
1199               subkey_seen = 1;
1200         }
1201         else if( node->pkt->pkttype == PKT_SIGNATURE
1202                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1203                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1204             delete_kbnode( node ); /* build_packet() can't handle this */
1205         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1206                  !node->pkt->pkt.signature->flags.exportable &&
1207                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1208                  seckey_available( node->pkt->pkt.signature->keyid ) ) {
1209             /* here we violate the rfc a bit by still allowing
1210              * to import non-exportable signature when we have the
1211              * the secret key used to create this signature - it
1212              * seems that this makes sense */
1213             log_info( _("key %08lX: non exportable signature "
1214                                     "(class %02x) - skipped\n"),
1215                                     (ulong)keyid[1],
1216                                      node->pkt->pkt.signature->sig_class );
1217             delete_kbnode( node );
1218         }
1219         else if( node->pkt->pkttype == PKT_SIGNATURE
1220                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1221             if( uid_seen ) {
1222                 log_error( _("key %08lX: revocation certificate "
1223                                      "at wrong place - skipped\n"),
1224                                     (ulong)keyid[1]);
1225                 delete_kbnode( node );
1226             }
1227             else {
1228               /* If the revocation cert is from a different key than
1229                  the one we're working on don't check it - it's
1230                  probably from a revocation key and won't be
1231                  verifiable with this key anyway. */
1232
1233               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1234                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1235                 {
1236                   int rc = check_key_signature( keyblock, node, NULL);
1237                   if( rc )
1238                     {
1239                       log_error( _("key %08lX: invalid revocation "
1240                                    "certificate: %s - skipped\n"),
1241                                  (ulong)keyid[1], g10_errstr(rc));
1242                       delete_kbnode( node );
1243                     }
1244                 }
1245             }
1246         }
1247         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1248                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1249                   node->pkt->pkt.signature->sig_class == 0x28) &&
1250                  !subkey_seen ) {
1251             log_error( _("key %08lX: subkey signature "
1252                          "in wrong place - skipped\n"),
1253                        (ulong)keyid[1]);
1254             delete_kbnode( node );
1255         }
1256         else if( (node->flag & 4) ) /* marked for deletion */
1257             delete_kbnode( node );
1258     }
1259
1260     /* note: because keyblock is the public key, it is never marked
1261      * for deletion and so keyblock cannot change */
1262     commit_kbnode( &keyblock );
1263     return nvalid;
1264 }
1265
1266
1267 /****************
1268  * It may happen that the imported keyblock has duplicated user IDs.
1269  * We check this here and collapse those user IDs together with their
1270  * sigs into one.
1271  * Returns: True if the keyblock hash changed.
1272  */
1273 int
1274 collapse_uids( KBNODE *keyblock )
1275 {
1276     KBNODE n, n2;
1277     int in_uid;
1278     int any=0;
1279     u32 kid1;
1280
1281   restart:
1282     for( n = *keyblock; n; n = n->next ) {
1283         if( n->pkt->pkttype != PKT_USER_ID )
1284             continue;
1285         for( n2 = n->next; n2; n2 = n2->next ) {
1286             if( n2->pkt->pkttype == PKT_USER_ID
1287                 && !cmp_user_ids( n->pkt->pkt.user_id,
1288                                   n2->pkt->pkt.user_id ) ) {
1289                 /* found a duplicate */
1290                 any = 1;
1291                 if( !n2->next
1292                     || n2->next->pkt->pkttype == PKT_USER_ID
1293                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1294                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1295                     /* no more signatures: delete the user ID
1296                      * and start over */
1297                     remove_kbnode( keyblock, n2 );
1298                 }
1299                 else {
1300                     /* The simple approach: Move one signature and
1301                      * then start over to delete the next one :-( */
1302                     move_kbnode( keyblock, n2->next, n->next );
1303                 }
1304                 goto restart;
1305             }
1306         }
1307     }
1308     if( !any )
1309         return 0;
1310
1311   restart_sig:
1312     /* now we may have duplicate signatures on one user ID: fix this */
1313     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1314         if( n->pkt->pkttype == PKT_USER_ID )
1315             in_uid = 1;
1316         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1317                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1318             in_uid = 0;
1319         else if( in_uid ) {
1320             n2 = n;
1321             do {
1322                 KBNODE ncmp = NULL;
1323                 for( ; n2; n2 = n2->next ) {
1324                     if(    n2->pkt->pkttype == PKT_USER_ID
1325                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1326                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1327                         break;
1328                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1329                         ;
1330                     else if( !ncmp )
1331                         ncmp = n2;
1332                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1333                                                 n2->pkt->pkt.signature )) {
1334                         remove_kbnode( keyblock, n2 );
1335                         goto restart_sig;
1336                     }
1337                 }
1338                 n2 = ncmp? ncmp->next : NULL;
1339             } while( n2 );
1340         }
1341     }
1342
1343     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1344         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
1345     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1346         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
1347     else
1348         kid1 = 0;
1349     log_info(_("key %08lX: duplicated user ID detected - merged\n"),
1350                                                                  (ulong)kid1);
1351
1352     return 1;
1353 }
1354
1355 /* Check for a 0x20 revocation from a revocation key that is not
1356    present.  This gets called without the benefit of merge_xxxx so you
1357    can't rely on pk->revkey and friends. */
1358 static void
1359 revocation_present(KBNODE keyblock)
1360 {
1361   KBNODE onode,inode;
1362   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1363
1364   for(onode=keyblock->next;onode;onode=onode->next)
1365     {
1366       /* If we reach user IDs, we're done. */
1367       if(onode->pkt->pkttype==PKT_USER_ID)
1368         break;
1369
1370       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1371          onode->pkt->pkt.signature->sig_class==0x1F &&
1372          onode->pkt->pkt.signature->revkey)
1373         {
1374           int idx;
1375           PKT_signature *sig=onode->pkt->pkt.signature;
1376
1377           for(idx=0;idx<sig->numrevkeys;idx++)
1378             {
1379               u32 keyid[2];
1380
1381               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1382                                      MAX_FINGERPRINT_LEN,keyid);
1383
1384               for(inode=keyblock->next;inode;inode=inode->next)
1385                 {
1386                   /* If we reach user IDs, we're done. */
1387                   if(inode->pkt->pkttype==PKT_USER_ID)
1388                     break;
1389
1390                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1391                      inode->pkt->pkt.signature->sig_class==0x20 &&
1392                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1393                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1394                     {
1395                       /* Okay, we have a revocation key, and a
1396                          revocation issued by it.  Do we have the key
1397                          itself? */
1398                       int rc;
1399
1400                       rc=get_pubkey_byfprint(NULL,sig->revkey[idx]->fpr,
1401                                              MAX_FINGERPRINT_LEN);
1402                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1403                         {
1404                           /* No, so try and get it */
1405                           if(opt.keyserver_scheme &&
1406                              opt.keyserver_options.auto_key_retrieve)
1407                             {
1408                               log_info(_("WARNING: key %08lX may be revoked: "
1409                                          "fetching revocation key %08lX\n"),
1410                                        (ulong)keyid_from_pk(pk,NULL),
1411                                        (ulong)keyid[1]);
1412                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1413                                                       MAX_FINGERPRINT_LEN);
1414
1415                               /* Do we have it now? */
1416                               rc=get_pubkey_byfprint(NULL,
1417                                                      sig->revkey[idx]->fpr,
1418                                                      MAX_FINGERPRINT_LEN);
1419                             }
1420
1421                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1422                             log_info(_("WARNING: key %08lX may be revoked: "
1423                                        "revocation key %08lX not present.\n"),
1424                                      (ulong)keyid_from_pk(pk,NULL),
1425                                      (ulong)keyid[1]);
1426                         }
1427                     }
1428                 }
1429             }
1430         }
1431     }
1432 }
1433
1434 /****************
1435  * compare and merge the blocks
1436  *
1437  * o compare the signatures: If we already have this signature, check
1438  *   that they compare okay; if not, issue a warning and ask the user.
1439  * o Simply add the signature.  Can't verify here because we may not have
1440  *   the signature's public key yet; verification is done when putting it
1441  *   into the trustdb, which is done automagically as soon as this pubkey
1442  *   is used.
1443  * Note: We indicate newly inserted packets with flag bit 0
1444  */
1445 static int
1446 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1447               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1448 {
1449     KBNODE onode, node;
1450     int rc, found;
1451
1452     /* 1st: handle revocation certificates */
1453     for(node=keyblock->next; node; node=node->next ) {
1454         if( node->pkt->pkttype == PKT_USER_ID )
1455             break;
1456         else if( node->pkt->pkttype == PKT_SIGNATURE
1457                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1458             /* check whether we already have this */
1459             found = 0;
1460             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1461                 if( onode->pkt->pkttype == PKT_USER_ID )
1462                     break;
1463                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1464                          && onode->pkt->pkt.signature->sig_class == 0x20
1465                          && node->pkt->pkt.signature->keyid[0]
1466                             == onode->pkt->pkt.signature->keyid[0]
1467                          && node->pkt->pkt.signature->keyid[1]
1468                             == onode->pkt->pkt.signature->keyid[1] ) {
1469                     found = 1;
1470                     break;
1471                 }
1472             }
1473             if( !found ) {
1474                 char *p=get_user_id_printable (keyid);
1475                 KBNODE n2 = clone_kbnode(node);
1476                 insert_kbnode( keyblock_orig, n2, 0 );
1477                 n2->flag |= 1;
1478                 ++*n_sigs;
1479                 log_info(_("key %08lX: \"%s\" revocation certificate added\n"),
1480                                          (ulong)keyid[1],p);
1481                 m_free(p);
1482             }
1483         }
1484     }
1485
1486     /* 2nd: merge in any direct key (0x1F) sigs */
1487     for(node=keyblock->next; node; node=node->next ) {
1488         if( node->pkt->pkttype == PKT_USER_ID )
1489             break;
1490         else if( node->pkt->pkttype == PKT_SIGNATURE
1491                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1492             /* check whether we already have this */
1493             found = 0;
1494             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1495                 if( onode->pkt->pkttype == PKT_USER_ID )
1496                     break;
1497                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1498                          && onode->pkt->pkt.signature->sig_class == 0x1F
1499                          && !cmp_signatures(onode->pkt->pkt.signature,
1500                                             node->pkt->pkt.signature)) {
1501                     found = 1;
1502                     break;
1503                 }
1504             }
1505             if( !found ) {
1506                 KBNODE n2 = clone_kbnode(node);
1507                 insert_kbnode( keyblock_orig, n2, 0 );
1508                 n2->flag |= 1;
1509                 ++*n_sigs;
1510                 log_info( _("key %08lX: direct key signature added\n"),
1511                                          (ulong)keyid[1]);
1512             }
1513         }
1514     }
1515
1516     /* 3rd: try to merge new certificates in */
1517     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1518         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1519             /* find the user id in the imported keyblock */
1520             for(node=keyblock->next; node; node=node->next )
1521                 if( node->pkt->pkttype == PKT_USER_ID
1522                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1523                                           node->pkt->pkt.user_id ) )
1524                     break;
1525             if( node ) { /* found: merge */
1526                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1527                 if( rc )
1528                     return rc;
1529             }
1530         }
1531     }
1532
1533     /* 4th: add new user-ids */
1534     for(node=keyblock->next; node; node=node->next ) {
1535         if( node->pkt->pkttype == PKT_USER_ID) {
1536             /* do we have this in the original keyblock */
1537             for(onode=keyblock_orig->next; onode; onode=onode->next )
1538                 if( onode->pkt->pkttype == PKT_USER_ID
1539                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1540                                       node->pkt->pkt.user_id ) )
1541                     break;
1542             if( !onode ) { /* this is a new user id: append */
1543                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1544                 if( rc )
1545                     return rc;
1546                 ++*n_uids;
1547             }
1548         }
1549     }
1550
1551     /* 5th: add new subkeys */
1552     for(node=keyblock->next; node; node=node->next ) {
1553         onode = NULL;
1554         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1555             /* do we have this in the original keyblock? */
1556             for(onode=keyblock_orig->next; onode; onode=onode->next )
1557                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1558                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1559                                          node->pkt->pkt.public_key ) )
1560                     break;
1561             if( !onode ) { /* this is a new subkey: append */
1562                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1563                 if( rc )
1564                     return rc;
1565                 ++*n_subk;
1566             }
1567         }
1568         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1569             /* do we have this in the original keyblock? */
1570             for(onode=keyblock_orig->next; onode; onode=onode->next )
1571                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1572                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1573                                          node->pkt->pkt.secret_key ) )
1574                     break;
1575             if( !onode ) { /* this is a new subkey: append */
1576                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1577                 if( rc )
1578                     return rc;
1579                 ++*n_subk;
1580             }
1581         }
1582     }
1583
1584     /* 6th: merge subkey certificates */
1585     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1586         if( !(onode->flag & 1)
1587             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1588                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1589             /* find the subkey in the imported keyblock */
1590             for(node=keyblock->next; node; node=node->next ) {
1591                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1592                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1593                                           node->pkt->pkt.public_key ) )
1594                     break;
1595                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1596                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1597                                           node->pkt->pkt.secret_key ) )
1598                     break;
1599             }
1600             if( node ) { /* found: merge */
1601                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1602                 if( rc )
1603                     return rc;
1604             }
1605         }
1606     }
1607
1608
1609     return 0;
1610 }
1611
1612
1613 /****************
1614  * append the userid starting with NODE and all signatures to KEYBLOCK.
1615  */
1616 static int
1617 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1618                                           const char *fname, u32 *keyid )
1619 {
1620     KBNODE n, n_where=NULL;
1621
1622     assert(node->pkt->pkttype == PKT_USER_ID );
1623
1624     /* find the position */
1625     for( n = keyblock; n; n_where = n, n = n->next ) {
1626         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1627             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1628             break;
1629     }
1630     if( !n )
1631         n_where = NULL;
1632
1633     /* and append/insert */
1634     while( node ) {
1635         /* we add a clone to the original keyblock, because this
1636          * one is released first */
1637         n = clone_kbnode(node);
1638         if( n_where ) {
1639             insert_kbnode( n_where, n, 0 );
1640             n_where = n;
1641         }
1642         else
1643             add_kbnode( keyblock, n );
1644         n->flag |= 1;
1645         node->flag |= 1;
1646         if( n->pkt->pkttype == PKT_SIGNATURE )
1647             ++*n_sigs;
1648
1649         node = node->next;
1650         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1651             break;
1652     }
1653
1654     return 0;
1655 }
1656
1657
1658 /****************
1659  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1660  * (how should we handle comment packets here?)
1661  */
1662 static int
1663 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1664                                     const char *fname, u32 *keyid )
1665 {
1666     KBNODE n, n2;
1667     int found=0;
1668
1669     assert(dst->pkt->pkttype == PKT_USER_ID );
1670     assert(src->pkt->pkttype == PKT_USER_ID );
1671
1672     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1673         if( n->pkt->pkttype != PKT_SIGNATURE )
1674             continue;
1675         if( n->pkt->pkt.signature->sig_class == 0x18
1676             || n->pkt->pkt.signature->sig_class == 0x28 )
1677             continue; /* skip signatures which are only valid on subkeys */
1678         found = 0;
1679         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1680             if( n2->pkt->pkttype == PKT_SIGNATURE
1681                 && n->pkt->pkt.signature->keyid[0]
1682                    == n2->pkt->pkt.signature->keyid[0]
1683                 && n->pkt->pkt.signature->keyid[1]
1684                    == n2->pkt->pkt.signature->keyid[1]
1685                 && n->pkt->pkt.signature->timestamp
1686                    <= n2->pkt->pkt.signature->timestamp
1687                 && n->pkt->pkt.signature->sig_class
1688                    == n2->pkt->pkt.signature->sig_class ) {
1689                 found++;
1690                 break;
1691             }
1692         }
1693         if( !found ) {
1694             /* This signature is new or newer, append N to DST.
1695              * We add a clone to the original keyblock, because this
1696              * one is released first */
1697             n2 = clone_kbnode(n);
1698             insert_kbnode( dst, n2, PKT_SIGNATURE );
1699             n2->flag |= 1;
1700             n->flag |= 1;
1701             ++*n_sigs;
1702         }
1703     }
1704
1705     return 0;
1706 }
1707
1708 /****************
1709  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1710  */
1711 static int
1712 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1713                                     const char *fname, u32 *keyid )
1714 {
1715     KBNODE n, n2;
1716     int found=0;
1717
1718     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1719            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1720
1721     for(n=src->next; n ; n = n->next ) {
1722         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1723             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1724             break;
1725         if( n->pkt->pkttype != PKT_SIGNATURE )
1726             continue;
1727         found = 0;
1728         for(n2=dst->next; n2; n2 = n2->next){
1729             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1730                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1731                 break;
1732             if( n2->pkt->pkttype == PKT_SIGNATURE
1733                 && n->pkt->pkt.signature->keyid[0]
1734                    == n2->pkt->pkt.signature->keyid[0]
1735                 && n->pkt->pkt.signature->keyid[1]
1736                    == n2->pkt->pkt.signature->keyid[1]
1737                 && n->pkt->pkt.signature->timestamp
1738                    <= n2->pkt->pkt.signature->timestamp
1739                 && n->pkt->pkt.signature->sig_class
1740                    == n2->pkt->pkt.signature->sig_class ) {
1741                 found++;
1742                 break;
1743             }
1744         }
1745         if( !found ) {
1746             /* This signature is new or newer, append N to DST.
1747              * We add a clone to the original keyblock, because this
1748              * one is released first */
1749             n2 = clone_kbnode(n);
1750             insert_kbnode( dst, n2, PKT_SIGNATURE );
1751             n2->flag |= 1;
1752             n->flag |= 1;
1753             ++*n_sigs;
1754         }
1755     }
1756
1757     return 0;
1758 }
1759
1760 /****************
1761  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1762  * Mark all new and copied packets by setting flag bit 0.
1763  */
1764 static int
1765 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1766                                           const char *fname, u32 *keyid )
1767 {
1768     KBNODE n;
1769
1770     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1771            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1772
1773     while(  node ) {
1774         /* we add a clone to the original keyblock, because this
1775          * one is released first */
1776         n = clone_kbnode(node);
1777         add_kbnode( keyblock, n );
1778         n->flag |= 1;
1779         node->flag |= 1;
1780         if( n->pkt->pkttype == PKT_SIGNATURE )
1781             ++*n_sigs;
1782
1783         node = node->next;
1784         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1785             break;
1786     }
1787
1788     return 0;
1789 }