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