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