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