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