(pk_sign): Fix last change.
[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_t inp, const char* fname,
60                    struct stats_s *stats, unsigned int options );
61 static int read_block( iobuf_t a, PACKET **pending_pkt, KBNODE *ret_root );
62 static void revocation_present(KBNODE keyblock);
63 static int import_one( const char *fname, KBNODE keyblock,
64                        struct stats_s *stats, unsigned int options);
65 static int import_secret_one( const char *fname, KBNODE keyblock,
66                               struct stats_s *stats, unsigned int options);
67 static int import_revoke_cert( const char *fname, KBNODE node,
68                                struct stats_s *stats);
69 static int chk_self_sigs( const char *fname, KBNODE keyblock,
70                           PKT_public_key *pk, u32 *keyid, int *non_self );
71 static int delete_inv_parts( const char *fname, KBNODE keyblock,
72                              u32 *keyid, unsigned int options );
73 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
74                          KBNODE keyblock, u32 *keyid,
75                          int *n_uids, int *n_sigs, int *n_subk );
76 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
77                              const char *fname, u32 *keyid );
78 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
79                              const char *fname, u32 *keyid );
80 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
81                              const char *fname, u32 *keyid );
82 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
83                              const char *fname, u32 *keyid );
84
85 int
86 parse_import_options(char *str,unsigned int *options)
87 {
88   struct parse_options import_opts[]=
89     {
90       {"allow-local-sigs",IMPORT_ALLOW_LOCAL_SIGS},
91       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG},
92       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG},
93       {"fast-import",IMPORT_FAST_IMPORT},
94       {"convert-sk-to-pk",IMPORT_SK2PK},
95       {NULL,0}
96     };
97
98   return parse_options(str,options,import_opts);
99 }
100
101 void *
102 import_new_stats_handle (void)
103 {
104     return xcalloc (1, sizeof (struct stats_s) );
105 }
106
107 void
108 import_release_stats_handle (void *p)
109 {
110     xfree (p);
111 }
112
113 /****************
114  * Import the public keys from the given filename. Input may be armored.
115  * This function rejects all keys which are not validly self signed on at
116  * least one userid. Only user ids which are self signed will be imported.
117  * Other signatures are not checked.
118  *
119  * Actually this function does a merge. It works like this:
120  *
121  *  - get the keyblock
122  *  - check self-signatures and remove all userids and their signatures
123  *    without/invalid self-signatures.
124  *  - reject the keyblock, if we have no valid userid.
125  *  - See whether we have this key already in one of our pubrings.
126  *    If not, simply add it to the default keyring.
127  *  - Compare the key and the self-signatures of the new and the one in
128  *    our keyring.  If they are different something weird is going on;
129  *    ask what to do.
130  *  - See whether we have only non-self-signature on one user id; if not
131  *    ask the user what to do.
132  *  - compare the signatures: If we already have this signature, check
133  *    that they compare okay; if not, issue a warning and ask the user.
134  *    (consider looking at the timestamp and use the newest?)
135  *  - Simply add the signature.  Can't verify here because we may not have
136  *    the signature's public key yet; verification is done when putting it
137  *    into the trustdb, which is done automagically as soon as this pubkey
138  *    is used.
139  *  - Proceed with next signature.
140  *
141  *  Key revocation certificates have special handling.
142  *
143  */
144 static int
145 import_keys_internal( iobuf_t inp, char **fnames, int nnames,
146                       void *stats_handle, unsigned int options )
147 {
148     int i, rc = 0;
149     struct stats_s *stats = stats_handle;
150
151     if (!stats)
152         stats = import_new_stats_handle ();
153
154     if (inp) {
155         rc = import( inp, "[stream]", stats, options);
156     }
157     else {
158         if( !fnames && !nnames )
159             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
160
161         for(i=0; i < nnames; i++ ) {
162             const char *fname = fnames? fnames[i] : NULL;
163             iobuf_t inp2 = iobuf_open(fname);
164             if( !fname )
165                 fname = "[stdin]";
166             if( !inp2 )
167                 log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
168             else {
169                 rc = import( inp2, fname, stats, options );
170                 iobuf_close(inp2);
171                 if( rc )
172                     log_error("import from `%s' failed: %s\n", fname,
173                               gpg_strerror (rc) );
174             }
175             if( !fname )
176                 break;
177         }
178     }
179     if (!stats_handle) {
180         import_print_stats (stats);
181         import_release_stats_handle (stats);
182     }
183     /* If no fast import and the trustdb is dirty (i.e. we added a key
184        or userID that had something other than a selfsig, a signature
185        that was other than a selfsig, or any revocation), then
186        update/check the trustdb if the user specified by setting
187        interactive or by not setting no-auto-check-trustdb */
188     if (!(options&IMPORT_FAST_IMPORT) && trustdb_pending_check())
189       {
190         if (opt.interactive)
191           update_trustdb();
192         else if (!opt.no_auto_check_trustdb)
193           check_trustdb();
194       }
195
196     return rc;
197 }
198
199 void
200 import_keys( char **fnames, int nnames,
201              void *stats_handle, unsigned int options )
202 {
203     import_keys_internal( NULL, fnames, nnames, stats_handle, options);
204 }
205
206 int
207 import_keys_stream( iobuf_t inp, void *stats_handle, unsigned int options )
208 {
209     return import_keys_internal( inp, NULL, 0, stats_handle, options);
210 }
211
212 static int
213 import( iobuf_t inp, const char* fname,
214         struct stats_s *stats, unsigned int options )
215 {
216     PACKET *pending_pkt = NULL;
217     KBNODE keyblock;
218     int rc = 0;
219
220     getkey_disable_caches();
221
222     if( !opt.no_armor ) { /* armored reading is not disabled */
223         armor_filter_context_t *afx = xcalloc (1, sizeof *afx );
224         afx->only_keyblocks = 1;
225         iobuf_push_filter2( inp, armor_filter, afx, 1 );
226     }
227
228     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
229         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
230             rc = import_one( fname, keyblock, stats, options );
231         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
232                 rc = import_secret_one( fname, keyblock, stats, options );
233         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
234                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
235             rc = import_revoke_cert( fname, keyblock, stats );
236         else {
237             log_info( _("skipping block of type %d\n"),
238                                             keyblock->pkt->pkttype );
239         }
240         release_kbnode(keyblock);
241         /* fixme: we should increment the not imported counter but this
242            does only make sense if we keep on going despite of errors. */
243         if( rc )
244             break;
245         if( !(++stats->count % 100) && !opt.quiet )
246             log_info(_("%lu keys processed so far\n"), stats->count );
247     }
248     if( rc == -1 )
249         rc = 0;
250     else if( rc && rc != GPG_ERR_INV_KEYRING )
251         log_error( _("error reading `%s': %s\n"), fname, gpg_strerror (rc));
252
253     return rc;
254 }
255
256
257 void
258 import_print_stats (void *hd)
259 {
260     struct stats_s *stats = hd;
261
262     if( !opt.quiet ) {
263         log_info(_("Total number processed: %lu\n"), stats->count );
264         if( stats->skipped_new_keys )
265             log_info(_("      skipped new keys: %lu\n"),
266                                                 stats->skipped_new_keys );
267         if( stats->no_user_id )
268             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
269         if( stats->imported || stats->imported_rsa ) {
270             log_info(_("              imported: %lu"), stats->imported );
271             if( stats->imported_rsa )
272                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
273             putc('\n', stderr);
274         }
275         if( stats->unchanged )
276             log_info(_("             unchanged: %lu\n"), stats->unchanged );
277         if( stats->n_uids )
278             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
279         if( stats->n_subk )
280             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
281         if( stats->n_sigs )
282             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
283         if( stats->n_revoc )
284             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
285         if( stats->secret_read )
286             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
287         if( stats->secret_imported )
288             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
289         if( stats->secret_dups )
290             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
291         if( stats->not_imported )
292             log_info(_("          not imported: %lu\n"), stats->not_imported );
293     }
294
295     if( is_status_enabled() ) {
296         char buf[14*20];
297         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
298                 stats->count,
299                 stats->no_user_id,
300                 stats->imported,
301                 stats->imported_rsa,
302                 stats->unchanged,
303                 stats->n_uids,
304                 stats->n_subk,
305                 stats->n_sigs,
306                 stats->n_revoc,
307                 stats->secret_read,
308                 stats->secret_imported,
309                 stats->secret_dups,
310                 stats->skipped_new_keys,
311                 stats->not_imported );
312         write_status_text( STATUS_IMPORT_RES, buf );
313     }
314 }
315
316
317 /****************
318  * Read the next keyblock from stream A.
319  * PENDING_PKT should be initialzed to NULL
320  * and not chnaged form the caller.
321  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
322  */
323 static int
324 read_block( iobuf_t a, PACKET **pending_pkt, KBNODE *ret_root )
325 {
326     int rc;
327     PACKET *pkt;
328     KBNODE root = NULL;
329     int in_cert;
330
331     if( *pending_pkt ) {
332         root = new_kbnode( *pending_pkt );
333         *pending_pkt = NULL;
334         in_cert = 1;
335     }
336     else
337         in_cert = 0;
338     pkt = xmalloc ( sizeof *pkt );
339     init_packet(pkt);
340     while( (rc=parse_packet(a, pkt)) != -1 ) {
341         if( rc ) {  /* ignore errors */
342             if( rc != GPG_ERR_UNKNOWN_PACKET ) {
343                 log_error("read_block: read error: %s\n", gpg_strerror (rc) );
344                 rc = GPG_ERR_INV_KEYRING;
345                 goto ready;
346             }
347             free_packet( pkt );
348             init_packet(pkt);
349             continue;
350         }
351
352         if( !root && pkt->pkttype == PKT_SIGNATURE
353                   && pkt->pkt.signature->sig_class == 0x20 ) {
354             /* this is a revocation certificate which is handled
355              * in a special way */
356             root = new_kbnode( pkt );
357             pkt = NULL;
358             goto ready;
359         }
360
361         /* make a linked list of all packets */
362         switch( pkt->pkttype ) {
363           case PKT_COMPRESSED:
364             if( pkt->pkt.compressed->algorithm < 1
365                 || pkt->pkt.compressed->algorithm > 2 ) {
366                 rc = GPG_ERR_COMPR_ALGO;
367                 goto ready;
368             }
369             {
370                 compress_filter_context_t *cfx = xcalloc (1, sizeof *cfx );
371                 cfx->algo = pkt->pkt.compressed->algorithm;
372                 pkt->pkt.compressed->buf = NULL;
373                 iobuf_push_filter2( a, compress_filter, cfx, 1 );
374             }
375             free_packet( pkt );
376             init_packet(pkt);
377             break;
378
379           case PKT_RING_TRUST:
380             /* skip those packets */
381             free_packet( pkt );
382             init_packet(pkt);
383             break;
384
385           case PKT_PUBLIC_KEY:
386           case PKT_SECRET_KEY:
387             if( in_cert ) { /* store this packet */
388                 *pending_pkt = pkt;
389                 pkt = NULL;
390                 goto ready;
391             }
392             in_cert = 1;
393           default:
394             if( in_cert ) {
395                 if( !root )
396                     root = new_kbnode( pkt );
397                 else
398                     add_kbnode( root, new_kbnode( pkt ) );
399                 pkt = xmalloc ( sizeof *pkt );
400             }
401             init_packet(pkt);
402             break;
403         }
404     }
405   ready:
406     if( rc == -1 && root )
407         rc = 0;
408
409     if( rc )
410         release_kbnode( root );
411     else
412         *ret_root = root;
413     free_packet( pkt );
414     xfree ( pkt );
415     return rc;
416 }
417
418 /* Walk through the subkeys on a pk to find if we have the PKS
419    disease: multiple subkeys with their binding sigs stripped, and the
420    sig for the first subkey placed after the last subkey.  That is,
421    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
422    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
423    and sub3, as they are already lost, but we can try and rescue sub1
424    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
425    sub2 sub3".  Returns TRUE if the keyblock was modified. */
426
427 static int
428 fix_pks_corruption(KBNODE keyblock)
429 {
430   int changed=0,keycount=0;
431   KBNODE node,last=NULL,sknode=NULL;
432
433   /* First determine if we have the problem at all.  Look for 2 or
434      more subkeys in a row, followed by a single binding sig. */
435   for(node=keyblock;node;last=node,node=node->next)
436     {
437       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
438         {
439           keycount++;
440           if(!sknode)
441             sknode=node;
442         }
443       else if(node->pkt->pkttype==PKT_SIGNATURE &&
444               node->pkt->pkt.signature->sig_class==0x18 &&
445               keycount>=2 && node->next==NULL)
446         {
447           /* We might have the problem, as this key has two subkeys in
448              a row without any intervening packets. */
449
450           /* Sanity check */
451           if(last==NULL)
452             break;
453
454           /* Temporarily attach node to sknode. */
455           node->next=sknode->next;
456           sknode->next=node;
457           last->next=NULL;
458
459           /* Note we aren't checking whether this binding sig is a
460              selfsig.  This is not necessary here as the subkey and
461              binding sig will be rejected later if that is the
462              case. */
463           if(check_key_signature(keyblock,node,NULL))
464             {
465               /* Not a match, so undo the changes. */
466               sknode->next=node->next;
467               last->next=node;
468               node->next=NULL;
469               break;
470             }
471           else
472             {
473               sknode->flag |= 1; /* Mark it good so we don't need to
474                                     check it again */
475               changed=1;
476               break;
477             }
478         }
479       else
480         keycount=0;
481     }
482
483   return changed;
484 }
485
486
487 static void
488 print_import_ok (PKT_public_key *pk, PKT_secret_key *sk, unsigned int reason)
489 {
490   byte array[MAX_FINGERPRINT_LEN], *s;
491   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
492   size_t i, n;
493
494   sprintf (buf, "%u ", reason);
495   p = buf + strlen (buf);
496
497   if (pk)
498     fingerprint_from_pk (pk, array, &n);
499   else
500     fingerprint_from_sk (sk, array, &n);
501   s = array;
502   for (i=0; i < n ; i++, s++, p += 2)
503     sprintf (p, "%02X", *s);
504
505   write_status_text (STATUS_IMPORT_OK, buf);
506 }
507
508 void
509 print_import_check (PKT_public_key * pk, PKT_user_id * id)
510 {
511     char * buf;
512     byte fpr[24];
513     u32 keyid[2];
514     size_t i, pos = 0, n;
515
516     buf = xmalloc (17+41+id->len+32);
517     keyid_from_pk (pk, keyid);
518     sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
519     pos = 17;
520     fingerprint_from_pk (pk, fpr, &n);
521     for (i = 0; i < n; i++, pos += 2)
522         sprintf (buf+pos, "%02X", fpr[i]);
523     strcat (buf, " ");
524     pos += 1;
525     strcat (buf, id->name);
526     write_status_text (STATUS_IMPORT_CHECK, buf);
527     xfree (buf);
528 }
529
530 /****************
531  * Try to import one keyblock.  Return an error only in serious cases, but
532  * never for an invalid keyblock.  It uses log_error to increase the
533  * internal errorcount, so that invalid input can be detected by programs
534  * which called g10.
535  */
536 static int
537 import_one( const char *fname, KBNODE keyblock,
538             struct stats_s *stats, unsigned int options )
539 {
540     PKT_public_key *pk;
541     PKT_public_key *pk_orig;
542     KBNODE node, uidnode;
543     KBNODE keyblock_orig = NULL;
544     u32 keyid[2];
545     int rc = 0;
546     int new_key = 0;
547     int mod_key = 0;
548     int non_self = 0;
549
550     /* get the key and print some info about it */
551     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
552     if( !node )
553         BUG();
554
555     pk = node->pkt->pkt.public_key;
556     keyid_from_pk( pk, keyid );
557     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
558
559     if(pk->pubkey_algo==PUBKEY_ALGO_ELGAMAL)
560       log_info(_("NOTE: Elgamal primary key detected - "
561                  "this may take some time to import\n"));
562
563     if( opt.verbose && !opt.interactive ) {
564         log_info( "pub  %4u%c/%08lX %s   ",
565                   nbits_from_pk( pk ),
566                   pubkey_letter( pk->pubkey_algo ),
567                   (ulong)keyid[1], datestr_from_pk(pk) );
568         if( uidnode )
569             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
570                                        uidnode->pkt->pkt.user_id->len );
571         putc('\n', stderr);
572     }
573     if( !uidnode ) {
574         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
575         return 0;
576     }
577     
578     if (opt.interactive) {
579         if(is_status_enabled())
580           print_import_check (pk, uidnode->pkt->pkt.user_id);
581         merge_keys_and_selfsig (keyblock);
582         tty_printf ("\n");
583         show_basic_key_info (keyblock);
584         tty_printf ("\n");
585         if (!cpr_get_answer_is_yes ("import.okay",
586                                     "Do you want to import this key? (y/N) "))
587             return 0;
588     }
589
590     clear_kbnode_flags( keyblock );
591
592     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock))
593       log_info(_("key %08lX: PKS subkey corruption repaired\n"),
594                (ulong)keyid[1]);
595
596     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
597     if( rc )
598         return rc== -1? 0:rc;
599
600     /* If we allow such a thing, mark unsigned uids as valid */
601     if( opt.allow_non_selfsigned_uid )
602       for( node=keyblock; node; node = node->next )
603         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
604           {
605             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
606                                       node->pkt->pkt.user_id->len,0);
607             node->flag |= 1;
608             log_info( _("key %08lX: accepted non self-signed user ID '%s'\n"),
609                       (ulong)keyid[1],user);
610             xfree (user);
611           }
612
613     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
614         if( !opt.quiet ) {
615             log_info( _("key %08lX: no valid user IDs\n"),
616                                                         (ulong)keyid[1]);
617             log_info(_("this may be caused by a missing self-signature\n"));
618         }
619         stats->no_user_id++;
620         return 0;
621     }
622
623     /* do we have this key already in one of our pubrings ? */
624     pk_orig = xcalloc (1, sizeof *pk_orig );
625     rc = get_pubkey_fast ( pk_orig, keyid );
626     if( rc && gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
627         && gpg_err_code (rc) != GPG_ERR_UNUSABLE_PUBKEY ) {
628         log_error( _("key %08lX: public key not found: %s\n"),
629                                 (ulong)keyid[1], gpg_strerror (rc));
630     }
631     else if ( rc && opt.merge_only ) {
632         if( opt.verbose )
633             log_info( _("key %08lX: new key - skipped\n"), (ulong)keyid[1] );
634         rc = 0;
635         stats->skipped_new_keys++;
636     }
637     else if( rc ) { /* insert this key */
638         KEYDB_HANDLE hd = keydb_new (0);
639
640         rc = keydb_locate_writable (hd, NULL);
641         if (rc) {
642             log_error (_("no writable keyring found: %s\n"), gpg_strerror (rc));
643             keydb_release (hd);
644             return GPG_ERR_GENERAL;
645         }
646         if( opt.verbose > 1 )
647             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
648         rc = keydb_insert_keyblock (hd, keyblock );
649         if (rc)
650            log_error (_("error writing keyring `%s': %s\n"),
651                        keydb_get_resource_name (hd), gpg_strerror (rc));
652         else
653           {
654             /* This should not be possible since we delete the
655                ownertrust when a key is deleted, but it can happen if
656                the keyring and trustdb are out of sync.  It can also
657                be made to happen with the trusted-key command. */
658
659             clear_ownertrusts (pk);
660             if(non_self)
661               revalidation_mark ();
662           }
663         keydb_release (hd);
664
665         /* we are ready */
666         if( !opt.quiet ) {
667             char *p=get_user_id_printable (keyid);
668             log_info( _("key %08lX: public key \"%s\" imported\n"),
669                       (ulong)keyid[1],p);
670             xfree (p);
671         }
672         if( is_status_enabled() ) {
673             char *us = get_long_user_id_string( keyid );
674             write_status_text( STATUS_IMPORTED, us );
675             xfree (us);
676             print_import_ok (pk,NULL, 1);
677         }
678         stats->imported++;
679         if( is_RSA( pk->pubkey_algo ) )
680             stats->imported_rsa++;
681         new_key = 1;
682     }
683     else { /* merge */
684         KEYDB_HANDLE hd;
685         int n_uids, n_sigs, n_subk;
686
687         /* Compare the original against the new key; just to be sure nothing
688          * weird is going on */
689         if( cmp_public_keys( pk_orig, pk ) ) {
690             log_error( _("key %08lX: doesn't match our copy\n"),
691                                                           (ulong)keyid[1]);
692             goto leave;
693         }
694
695         /* now read the original keyblock */
696         hd = keydb_new (0);
697         {
698             byte afp[MAX_FINGERPRINT_LEN];
699             size_t an;
700
701             fingerprint_from_pk (pk_orig, afp, &an);
702             while (an < MAX_FINGERPRINT_LEN) 
703                 afp[an++] = 0;
704             rc = keydb_search_fpr (hd, afp);
705         }
706         if( rc ) {
707             log_error (_("key %08lX: can't locate original keyblock: %s\n"),
708                                      (ulong)keyid[1], gpg_strerror (rc));
709             keydb_release (hd);
710             goto leave;
711         }
712         rc = keydb_get_keyblock (hd, &keyblock_orig );
713         if (rc) {
714             log_error (_("key %08lX: can't read original keyblock: %s\n"),
715                                             (ulong)keyid[1], gpg_strerror (rc));
716             keydb_release (hd);
717             goto leave;
718         }
719
720         collapse_uids( &keyblock );
721         /* and try to merge the block */
722         clear_kbnode_flags( keyblock_orig );
723         clear_kbnode_flags( keyblock );
724         n_uids = n_sigs = n_subk = 0;
725         rc = merge_blocks( fname, keyblock_orig, keyblock,
726                                 keyid, &n_uids, &n_sigs, &n_subk );
727         if( rc ) {
728             keydb_release (hd);
729             goto leave;
730         }
731         if( n_uids || n_sigs || n_subk ) {
732             mod_key = 1;
733             /* keyblock_orig has been updated; write */
734             rc = keydb_update_keyblock (hd, keyblock_orig);
735             if (rc)
736                 log_error (_("error writing keyring `%s': %s\n"),
737                              keydb_get_resource_name (hd), gpg_strerror (rc) );
738             else if(non_self)
739               revalidation_mark ();
740
741             /* we are ready */
742             if( !opt.quiet ) {
743                 char *p=get_user_id_printable(keyid);
744                 if( n_uids == 1 )
745                     log_info( _("key %08lX: \"%s\" 1 new user ID\n"),
746                                              (ulong)keyid[1], p);
747                 else if( n_uids )
748                     log_info( _("key %08lX: \"%s\" %d new user IDs\n"),
749                                              (ulong)keyid[1], p, n_uids );
750                 if( n_sigs == 1 )
751                     log_info( _("key %08lX: \"%s\" 1 new signature\n"),
752                                              (ulong)keyid[1], p);
753                 else if( n_sigs )
754                     log_info( _("key %08lX: \"%s\" %d new signatures\n"),
755                                              (ulong)keyid[1], p, n_sigs );
756                 if( n_subk == 1 )
757                     log_info( _("key %08lX: \"%s\" 1 new subkey\n"),
758                                              (ulong)keyid[1], p);
759                 else if( n_subk )
760                     log_info( _("key %08lX: \"%s\" %d new subkeys\n"),
761                                              (ulong)keyid[1], p, n_subk );
762                 xfree (p);
763             }
764
765             stats->n_uids +=n_uids;
766             stats->n_sigs +=n_sigs;
767             stats->n_subk +=n_subk;
768
769             if (is_status_enabled ()) 
770                  print_import_ok (pk, NULL,
771                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
772         }
773         else {
774              if (is_status_enabled ()) 
775                   print_import_ok (pk, NULL, 0);
776         
777             if( !opt.quiet ) {
778                 char *p=get_user_id_printable(keyid);
779                 log_info( _("key %08lX: \"%s\" not changed\n"),
780                           (ulong)keyid[1],p);
781                 xfree (p);
782             }
783             stats->unchanged++;
784         }
785         keydb_release (hd); hd = NULL;
786     }
787
788   leave:
789     release_kbnode( keyblock_orig );
790     free_public_key( pk_orig );
791
792     revocation_present(keyblock);
793
794     return rc;
795 }
796
797 /* Walk a secret keyblock and produce a public keyblock out of it. */
798 static KBNODE
799 sec_to_pub_keyblock(KBNODE sec_keyblock)
800 {
801   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
802
803   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
804     {
805       KBNODE pubnode;
806
807       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
808          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
809         {
810           /* Make a public key.  We only need to convert enough to
811              write the keyblock out. */
812
813           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
814           PACKET *pkt=xcalloc (1,sizeof(PACKET));
815           PKT_public_key *pk=xcalloc (1,sizeof(PKT_public_key));
816           int n;
817
818           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
819             pkt->pkttype=PKT_PUBLIC_KEY;
820           else
821             pkt->pkttype=PKT_PUBLIC_SUBKEY;
822
823           pkt->pkt.public_key=pk;
824
825           pk->version=sk->version;
826           pk->timestamp=sk->timestamp;
827           pk->expiredate=sk->expiredate;
828           pk->pubkey_algo=sk->pubkey_algo;
829
830           n=pubkey_get_npkey(pk->pubkey_algo);
831           if(n==0)
832             pk->pkey[0]=mpi_copy(sk->skey[0]);
833           else
834             {
835               int i;
836
837               for(i=0;i<n;i++)
838                 pk->pkey[i]=mpi_copy(sk->skey[i]);
839             }
840
841           pubnode=new_kbnode(pkt);
842         }
843       else
844         {
845           pubnode=clone_kbnode(secnode);
846         }
847
848       if(pub_keyblock==NULL)
849         pub_keyblock=pubnode;
850       else
851         add_kbnode(pub_keyblock,pubnode);
852     }
853
854   return pub_keyblock;
855 }
856
857 /****************
858  * Ditto for secret keys.  Handling is simpler than for public keys.
859  * We allow secret key importing only when allow is true, this is so
860  * that a secret key can not be imported accidently and thereby tampering
861  * with the trust calculation.
862  */
863 static int
864 import_secret_one( const char *fname, KBNODE keyblock, 
865                    struct stats_s *stats, unsigned int options)
866 {
867     PKT_secret_key *sk;
868     KBNODE node, uidnode;
869     u32 keyid[2];
870     int rc = 0;
871
872     /* get the key and print some info about it */
873     node = find_kbnode( keyblock, PKT_SECRET_KEY );
874     if( !node )
875         BUG();
876
877     sk = node->pkt->pkt.secret_key;
878     keyid_from_sk( sk, keyid );
879     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
880
881     if( opt.verbose ) {
882         log_info( "sec  %4u%c/%08lX %s   ",
883                   nbits_from_sk( sk ),
884                   pubkey_letter( sk->pubkey_algo ),
885                   (ulong)keyid[1], datestr_from_sk(sk) );
886         if( uidnode )
887             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
888                                        uidnode->pkt->pkt.user_id->len );
889         putc('\n', stderr);
890     }
891     stats->secret_read++;
892
893     if( !uidnode ) {
894         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
895         return 0;
896     }
897
898     if(sk->protect.algo>110)
899       {
900         log_error(_("key %08lX: secret key with invalid cipher %d "
901                     "- skipped\n"),(ulong)keyid[1],sk->protect.algo);
902         return 0;
903       }
904
905     clear_kbnode_flags( keyblock );
906
907     /* do we have this key already in one of our secrings ? */
908     rc = seckey_available( keyid );
909     if( gpg_err_code (rc) == GPG_ERR_NO_SECKEY && !opt.merge_only ) { 
910         /* 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"), gpg_strerror (rc));
917             keydb_release (hd);
918             return GPG_ERR_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), gpg_strerror (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], gpg_strerror (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 = xcalloc (1, sizeof *pk );
980     rc = get_pubkey( pk, keyid );
981     if( gpg_err_code (rc) == GPG_ERR_NO_PUBKEY ) {
982         log_info( _("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], gpg_strerror (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], gpg_strerror (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], gpg_strerror (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], gpg_strerror (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                  && onode->pkt->pkt.signature->sig_class == 0x20
1034                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
1035                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
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), gpg_strerror (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         xfree (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                       char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1129                                       strlen(unode->pkt->pkt.user_id->name),0);
1130                       log_info( gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
1131                                 _("key %08lX: unsupported public key "
1132                                   "algorithm on user id \"%s\"\n"):
1133                                 _("key %08lX: invalid self-signature "
1134                                   "on user id \"%s\"\n"),
1135                                 (ulong)keyid[1],p);
1136                       xfree (p);
1137                     }
1138                   else
1139                     unode->flag |= 1; /* mark that signature checked */
1140                 }
1141             }
1142             else if( sig->sig_class == 0x18 ) {
1143               /* Note that this works based solely on the timestamps
1144                  like the rest of gpg.  If the standard gets
1145                  revocation targets, this may need to be revised. */
1146
1147                 if( !knode ) {
1148                     log_info( _("key %08lX: no subkey for subkey "
1149                                 "binding signature\n"),(ulong)keyid[1]);
1150                     n->flag |= 4; /* delete this */
1151                 }
1152                 else {
1153                   rc = check_key_signature( keyblock, n, NULL);
1154                   if( rc ) {
1155                     log_info(  gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
1156                             _("key %08lX: unsupported public key algorithm\n"):
1157                             _("key %08lX: invalid subkey binding\n"),
1158                             (ulong)keyid[1]);
1159                     n->flag|=4;
1160                   }
1161                   else {
1162                     /* It's valid, so is it newer? */
1163                     if(sig->timestamp>=bsdate) {
1164                       knode->flag |= 1;  /* the subkey is valid */
1165                       if(bsnode) {
1166                         bsnode->flag|=4; /* Delete the last binding
1167                                             sig since this one is
1168                                             newer */
1169                         log_info(_("key %08lX: removed multiple subkey "
1170                                    "binding\n"),(ulong)keyid[1]);
1171                       }
1172
1173                       bsnode=n;
1174                       bsdate=sig->timestamp;
1175                     }
1176                     else
1177                       n->flag|=4; /* older */
1178                   }
1179                 }
1180             }
1181             else if( sig->sig_class == 0x28 ) {
1182               /* We don't actually mark the subkey as revoked right
1183                  now, so just check that the revocation sig is the
1184                  most recent valid one.  Note that we don't care if
1185                  the binding sig is newer than the revocation sig.
1186                  See the comment in getkey.c:merge_selfsigs_subkey for
1187                  more */
1188                 if( !knode ) {
1189                     log_info( _("key %08lX: no subkey for subkey "
1190                                 "revocation signature\n"),(ulong)keyid[1]);
1191                     n->flag |= 4; /* delete this */
1192                 }
1193                 else {
1194                   rc = check_key_signature( keyblock, n, NULL);
1195                   if( rc ) {
1196                     log_info(  gpg_err_code (rc) == GPG_ERR_PUBKEY_ALGO ?
1197                             _("key %08lX: unsupported public key algorithm\n"):
1198                             _("key %08lX: invalid subkey revocation\n"),
1199                                (ulong)keyid[1]);
1200                     n->flag|=4;
1201                   }
1202                   else {
1203                     /* It's valid, so is it newer? */
1204                     if(sig->timestamp>=rsdate) {
1205                       if(rsnode) {
1206                         rsnode->flag|=4; /* Delete the last revocation
1207                                             sig since this one is
1208                                             newer */
1209                         log_info(_("key %08lX: removed multiple subkey "
1210                                    "revocation signatures\n"),(ulong)keyid[1]);
1211                       }
1212
1213                       rsnode=n;
1214                       rsdate=sig->timestamp;
1215                     }
1216                     else
1217                       n->flag|=4; /* older */
1218                   }
1219                 }
1220             }
1221         }
1222         else
1223           *non_self=1;
1224     }
1225
1226     return 0;
1227 }
1228
1229 /****************
1230  * delete all parts which are invalid and those signatures whose
1231  * public key algorithm is not available in this implemenation;
1232  * but consider RSA as valid, because parse/build_packets knows
1233  * about it.
1234  * returns: true if at least one valid user-id is left over.
1235  */
1236 static int
1237 delete_inv_parts( const char *fname, KBNODE keyblock,
1238                   u32 *keyid, unsigned int options)
1239 {
1240     KBNODE node;
1241     int nvalid=0, uid_seen=0, subkey_seen=0;
1242
1243     for(node=keyblock->next; node; node = node->next ) {
1244         if( node->pkt->pkttype == PKT_USER_ID ) {
1245             uid_seen = 1;
1246             if( (node->flag & 2) || !(node->flag & 1) ) {
1247                 if( opt.verbose ) {
1248                     log_info( _("key %08lX: skipped user ID '"),
1249                                                          (ulong)keyid[1]);
1250                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
1251                                        node->pkt->pkt.user_id->len );
1252                     fputs("'\n", stderr );
1253                 }
1254                 delete_kbnode( node ); /* the user-id */
1255                 /* and all following packets up to the next user-id */
1256                 while( node->next
1257                        && node->next->pkt->pkttype != PKT_USER_ID
1258                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1259                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1260                     delete_kbnode( node->next );
1261                     node = node->next;
1262                 }
1263             }
1264             else
1265                 nvalid++;
1266         }
1267         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1268                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1269             if( (node->flag & 2) || !(node->flag & 1) ) {
1270                 if( opt.verbose ) {
1271                     log_info( _("key %08lX: skipped subkey\n"),
1272                                                          (ulong)keyid[1]);
1273                 }
1274                 delete_kbnode( node ); /* the subkey */
1275                 /* and all following signature packets */
1276                 while( node->next
1277                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1278                     delete_kbnode( node->next );
1279                     node = node->next;
1280                 }
1281             }
1282             else
1283               subkey_seen = 1;
1284         }
1285         else if( node->pkt->pkttype == PKT_SIGNATURE
1286                  && openpgp_pk_test_algo( node->pkt->pkt.signature
1287                                                      ->pubkey_algo, 0)
1288                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1289             delete_kbnode( node ); /* build_packet() can't handle this */
1290         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1291                  !node->pkt->pkt.signature->flags.exportable &&
1292                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1293                  seckey_available( node->pkt->pkt.signature->keyid ) ) {
1294             /* here we violate the rfc a bit by still allowing
1295              * to import non-exportable signature when we have the
1296              * the secret key used to create this signature - it
1297              * seems that this makes sense */
1298             log_info( _("key %08lX: non exportable signature "
1299                                     "(class %02x) - skipped\n"),
1300                                     (ulong)keyid[1],
1301                                      node->pkt->pkt.signature->sig_class );
1302             delete_kbnode( node );
1303         }
1304         else if( node->pkt->pkttype == PKT_SIGNATURE
1305                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1306             if( uid_seen ) {
1307                 log_error( _("key %08lX: revocation certificate "
1308                                      "at wrong place - skipped\n"),
1309                                     (ulong)keyid[1]);
1310                 delete_kbnode( node );
1311             }
1312             else {
1313               /* If the revocation cert is from a different key than
1314                  the one we're working on don't check it - it's
1315                  probably from a revocation key and won't be
1316                  verifiable with this key anyway. */
1317
1318               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1319                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1320                 {
1321                   int rc = check_key_signature( keyblock, node, NULL);
1322                   if( rc )
1323                     {
1324                       log_error( _("key %08lX: invalid revocation "
1325                                    "certificate: %s - skipped\n"),
1326                                  (ulong)keyid[1], gpg_strerror (rc));
1327                       delete_kbnode( node );
1328                     }
1329                 }
1330             }
1331         }
1332         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1333                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1334                   node->pkt->pkt.signature->sig_class == 0x28) &&
1335                  !subkey_seen ) {
1336             log_error( _("key %08lX: subkey signature "
1337                          "in wrong place - skipped\n"),
1338                        (ulong)keyid[1]);
1339             delete_kbnode( node );
1340         }
1341         else if( node->pkt->pkttype == PKT_SIGNATURE
1342                  && !IS_CERT(node->pkt->pkt.signature))
1343           {
1344             log_error(_("key %08lX: unexpected signature class (0x%02X) -"
1345                         " skipped\n"),(ulong)keyid[1],
1346                       node->pkt->pkt.signature->sig_class);
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 ( gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1496                           || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
1497                         {
1498                           /* No, so try and get it */
1499                           if(opt.keyserver_scheme &&
1500                              opt.keyserver_options.auto_key_retrieve)
1501                             {
1502                               log_info(_("WARNING: key %08lX may be revoked: "
1503                                          "fetching revocation key %08lX\n"),
1504                                        (ulong)keyid_from_pk(pk,NULL),
1505                                        (ulong)keyid[1]);
1506                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1507                                                       MAX_FINGERPRINT_LEN);
1508
1509                               /* Do we have it now? */
1510                               rc=get_pubkey_byfprint_fast (NULL,
1511                                                      sig->revkey[idx]->fpr,
1512                                                      MAX_FINGERPRINT_LEN);
1513                             }
1514
1515                           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
1516                               || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
1517                             log_info(_("WARNING: key %08lX may be revoked: "
1518                                        "revocation key %08lX not present.\n"),
1519                                      (ulong)keyid_from_pk(pk,NULL),
1520                                      (ulong)keyid[1]);
1521                         }
1522                     }
1523                 }
1524             }
1525         }
1526     }
1527 }
1528
1529 /****************
1530  * compare and merge the blocks
1531  *
1532  * o compare the signatures: If we already have this signature, check
1533  *   that they compare okay; if not, issue a warning and ask the user.
1534  * o Simply add the signature.  Can't verify here because we may not have
1535  *   the signature's public key yet; verification is done when putting it
1536  *   into the trustdb, which is done automagically as soon as this pubkey
1537  *   is used.
1538  * Note: We indicate newly inserted packets with flag bit 0
1539  */
1540 static int
1541 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1542               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1543 {
1544     KBNODE onode, node;
1545     int rc, found;
1546
1547     /* 1st: handle revocation certificates */
1548     for(node=keyblock->next; node; node=node->next ) {
1549         if( node->pkt->pkttype == PKT_USER_ID )
1550             break;
1551         else if( node->pkt->pkttype == PKT_SIGNATURE
1552                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1553             /* check whether we already have this */
1554             found = 0;
1555             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1556                 if( onode->pkt->pkttype == PKT_USER_ID )
1557                     break;
1558                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1559                          && onode->pkt->pkt.signature->sig_class == 0x20
1560                          && node->pkt->pkt.signature->keyid[0]
1561                             == onode->pkt->pkt.signature->keyid[0]
1562                          && node->pkt->pkt.signature->keyid[1]
1563                             == onode->pkt->pkt.signature->keyid[1] ) {
1564                     found = 1;
1565                     break;
1566                 }
1567             }
1568             if( !found ) {
1569                 char *p=get_user_id_printable (keyid);
1570                 KBNODE n2 = clone_kbnode(node);
1571                 insert_kbnode( keyblock_orig, n2, 0 );
1572                 n2->flag |= 1;
1573                 ++*n_sigs;
1574                 log_info(_("key %08lX: \"%s\" revocation certificate added\n"),
1575                                          (ulong)keyid[1],p);
1576                 xfree (p);
1577             }
1578         }
1579     }
1580
1581     /* 2nd: merge in any direct key (0x1F) sigs */
1582     for(node=keyblock->next; node; node=node->next ) {
1583         if( node->pkt->pkttype == PKT_USER_ID )
1584             break;
1585         else if( node->pkt->pkttype == PKT_SIGNATURE
1586                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1587             /* check whether we already have this */
1588             found = 0;
1589             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1590                 if( onode->pkt->pkttype == PKT_USER_ID )
1591                     break;
1592                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1593                          && onode->pkt->pkt.signature->sig_class == 0x1F
1594                          && !cmp_signatures(onode->pkt->pkt.signature,
1595                                             node->pkt->pkt.signature)) {
1596                     found = 1;
1597                     break;
1598                 }
1599             }
1600             if( !found ) {
1601                 KBNODE n2 = clone_kbnode(node);
1602                 insert_kbnode( keyblock_orig, n2, 0 );
1603                 n2->flag |= 1;
1604                 ++*n_sigs;
1605                 log_info( _("key %08lX: direct key signature added\n"),
1606                                          (ulong)keyid[1]);
1607             }
1608         }
1609     }
1610
1611     /* 3rd: try to merge new certificates in */
1612     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1613         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1614             /* find the user id in the imported keyblock */
1615             for(node=keyblock->next; node; node=node->next )
1616                 if( node->pkt->pkttype == PKT_USER_ID
1617                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1618                                           node->pkt->pkt.user_id ) )
1619                     break;
1620             if( node ) { /* found: merge */
1621                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1622                 if( rc )
1623                     return rc;
1624             }
1625         }
1626     }
1627
1628     /* 4th: add new user-ids */
1629     for(node=keyblock->next; node; node=node->next ) {
1630         if( node->pkt->pkttype == PKT_USER_ID) {
1631             /* do we have this in the original keyblock */
1632             for(onode=keyblock_orig->next; onode; onode=onode->next )
1633                 if( onode->pkt->pkttype == PKT_USER_ID
1634                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1635                                       node->pkt->pkt.user_id ) )
1636                     break;
1637             if( !onode ) { /* this is a new user id: append */
1638                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1639                 if( rc )
1640                     return rc;
1641                 ++*n_uids;
1642             }
1643         }
1644     }
1645
1646     /* 5th: add new subkeys */
1647     for(node=keyblock->next; node; node=node->next ) {
1648         onode = NULL;
1649         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1650             /* do we have this in the original keyblock? */
1651             for(onode=keyblock_orig->next; onode; onode=onode->next )
1652                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1653                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1654                                          node->pkt->pkt.public_key ) )
1655                     break;
1656             if( !onode ) { /* this is a new subkey: append */
1657                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1658                 if( rc )
1659                     return rc;
1660                 ++*n_subk;
1661             }
1662         }
1663         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1664             /* do we have this in the original keyblock? */
1665             for(onode=keyblock_orig->next; onode; onode=onode->next )
1666                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1667                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1668                                          node->pkt->pkt.secret_key ) )
1669                     break;
1670             if( !onode ) { /* this is a new subkey: append */
1671                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1672                 if( rc )
1673                     return rc;
1674                 ++*n_subk;
1675             }
1676         }
1677     }
1678
1679     /* 6th: merge subkey certificates */
1680     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1681         if( !(onode->flag & 1)
1682             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1683                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1684             /* find the subkey in the imported keyblock */
1685             for(node=keyblock->next; node; node=node->next ) {
1686                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1687                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1688                                           node->pkt->pkt.public_key ) )
1689                     break;
1690                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1691                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1692                                           node->pkt->pkt.secret_key ) )
1693                     break;
1694             }
1695             if( node ) { /* found: merge */
1696                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1697                 if( rc )
1698                     return rc;
1699             }
1700         }
1701     }
1702
1703
1704     return 0;
1705 }
1706
1707
1708 /****************
1709  * append the userid starting with NODE and all signatures to KEYBLOCK.
1710  */
1711 static int
1712 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1713                                           const char *fname, u32 *keyid )
1714 {
1715     KBNODE n, n_where=NULL;
1716
1717     assert(node->pkt->pkttype == PKT_USER_ID );
1718
1719     /* find the position */
1720     for( n = keyblock; n; n_where = n, n = n->next ) {
1721         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1722             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1723             break;
1724     }
1725     if( !n )
1726         n_where = NULL;
1727
1728     /* and append/insert */
1729     while( node ) {
1730         /* we add a clone to the original keyblock, because this
1731          * one is released first */
1732         n = clone_kbnode(node);
1733         if( n_where ) {
1734             insert_kbnode( n_where, n, 0 );
1735             n_where = n;
1736         }
1737         else
1738             add_kbnode( keyblock, n );
1739         n->flag |= 1;
1740         node->flag |= 1;
1741         if( n->pkt->pkttype == PKT_SIGNATURE )
1742             ++*n_sigs;
1743
1744         node = node->next;
1745         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1746             break;
1747     }
1748
1749     return 0;
1750 }
1751
1752
1753 /****************
1754  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1755  * (how should we handle comment packets here?)
1756  */
1757 static int
1758 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1759                                     const char *fname, u32 *keyid )
1760 {
1761     KBNODE n, n2;
1762     int found=0;
1763
1764     assert(dst->pkt->pkttype == PKT_USER_ID );
1765     assert(src->pkt->pkttype == PKT_USER_ID );
1766
1767     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1768         if( n->pkt->pkttype != PKT_SIGNATURE )
1769             continue;
1770         if( n->pkt->pkt.signature->sig_class == 0x18
1771             || n->pkt->pkt.signature->sig_class == 0x28 )
1772             continue; /* skip signatures which are only valid on subkeys */
1773         found = 0;
1774         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1775             if( n2->pkt->pkttype == PKT_SIGNATURE
1776                 && n->pkt->pkt.signature->keyid[0]
1777                    == n2->pkt->pkt.signature->keyid[0]
1778                 && n->pkt->pkt.signature->keyid[1]
1779                    == n2->pkt->pkt.signature->keyid[1]
1780                 && n->pkt->pkt.signature->timestamp
1781                    <= n2->pkt->pkt.signature->timestamp
1782                 && n->pkt->pkt.signature->sig_class
1783                    == n2->pkt->pkt.signature->sig_class ) {
1784                 found++;
1785                 break;
1786             }
1787         }
1788         if( !found ) {
1789             /* This signature is new or newer, append N to DST.
1790              * We add a clone to the original keyblock, because this
1791              * one is released first */
1792             n2 = clone_kbnode(n);
1793             insert_kbnode( dst, n2, PKT_SIGNATURE );
1794             n2->flag |= 1;
1795             n->flag |= 1;
1796             ++*n_sigs;
1797         }
1798     }
1799
1800     return 0;
1801 }
1802
1803 /****************
1804  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1805  */
1806 static int
1807 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1808                                     const char *fname, u32 *keyid )
1809 {
1810     KBNODE n, n2;
1811     int found=0;
1812
1813     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1814            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1815
1816     for(n=src->next; n ; n = n->next ) {
1817         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1818             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1819             break;
1820         if( n->pkt->pkttype != PKT_SIGNATURE )
1821             continue;
1822         found = 0;
1823         for(n2=dst->next; n2; n2 = n2->next){
1824             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1825                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1826                 break;
1827             if( n2->pkt->pkttype == PKT_SIGNATURE
1828                 && n->pkt->pkt.signature->keyid[0]
1829                    == n2->pkt->pkt.signature->keyid[0]
1830                 && n->pkt->pkt.signature->keyid[1]
1831                    == n2->pkt->pkt.signature->keyid[1]
1832                 && n->pkt->pkt.signature->timestamp
1833                    <= n2->pkt->pkt.signature->timestamp
1834                 && n->pkt->pkt.signature->sig_class
1835                    == n2->pkt->pkt.signature->sig_class ) {
1836                 found++;
1837                 break;
1838             }
1839         }
1840         if( !found ) {
1841             /* This signature is new or newer, append N to DST.
1842              * We add a clone to the original keyblock, because this
1843              * one is released first */
1844             n2 = clone_kbnode(n);
1845             insert_kbnode( dst, n2, PKT_SIGNATURE );
1846             n2->flag |= 1;
1847             n->flag |= 1;
1848             ++*n_sigs;
1849         }
1850     }
1851
1852     return 0;
1853 }
1854
1855 /****************
1856  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1857  * Mark all new and copied packets by setting flag bit 0.
1858  */
1859 static int
1860 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1861                                           const char *fname, u32 *keyid )
1862 {
1863     KBNODE n;
1864
1865     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1866            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1867
1868     while(  node ) {
1869         /* we add a clone to the original keyblock, because this
1870          * one is released first */
1871         n = clone_kbnode(node);
1872         add_kbnode( keyblock, n );
1873         n->flag |= 1;
1874         node->flag |= 1;
1875         if( n->pkt->pkttype == PKT_SIGNATURE )
1876             ++*n_sigs;
1877
1878         node = node->next;
1879         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1880             break;
1881     }
1882
1883     return 0;
1884 }