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