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