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