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