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