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