b49b202177883a335d2060f57ece35c71bb03d41
[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->pkt->pkttype == PKT_SIGNATURE
1382                  && !IS_CERT(node->pkt->pkt.signature))
1383           {
1384             log_error(_("key %08lX: unexpected signature class (0x%02X) -"
1385                         " skipped\n"),(ulong)keyid[1],
1386                       node->pkt->pkt.signature->sig_class);
1387             delete_kbnode(node);
1388           }
1389         else if( (node->flag & 4) ) /* marked for deletion */
1390             delete_kbnode( node );
1391     }
1392
1393     /* note: because keyblock is the public key, it is never marked
1394      * for deletion and so keyblock cannot change */
1395     commit_kbnode( &keyblock );
1396     return nvalid;
1397 }
1398
1399
1400 /****************
1401  * It may happen that the imported keyblock has duplicated user IDs.
1402  * We check this here and collapse those user IDs together with their
1403  * sigs into one.
1404  * Returns: True if the keyblock hash changed.
1405  */
1406 int
1407 collapse_uids( KBNODE *keyblock )
1408 {
1409     KBNODE n, n2;
1410     int in_uid;
1411     int any=0;
1412     u32 kid1;
1413
1414   restart:
1415     for( n = *keyblock; n; n = n->next ) {
1416         if( n->pkt->pkttype != PKT_USER_ID )
1417             continue;
1418         for( n2 = n->next; n2; n2 = n2->next ) {
1419             if( n2->pkt->pkttype == PKT_USER_ID
1420                 && !cmp_user_ids( n->pkt->pkt.user_id,
1421                                   n2->pkt->pkt.user_id ) ) {
1422                 /* found a duplicate */
1423                 any = 1;
1424                 if( !n2->next
1425                     || n2->next->pkt->pkttype == PKT_USER_ID
1426                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1427                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1428                     /* no more signatures: delete the user ID
1429                      * and start over */
1430                     remove_kbnode( keyblock, n2 );
1431                 }
1432                 else {
1433                     /* The simple approach: Move one signature and
1434                      * then start over to delete the next one :-( */
1435                     move_kbnode( keyblock, n2->next, n->next );
1436                 }
1437                 goto restart;
1438             }
1439         }
1440     }
1441     if( !any )
1442         return 0;
1443
1444   restart_sig:
1445     /* now we may have duplicate signatures on one user ID: fix this */
1446     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1447         if( n->pkt->pkttype == PKT_USER_ID )
1448             in_uid = 1;
1449         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1450                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1451             in_uid = 0;
1452         else if( in_uid ) {
1453             n2 = n;
1454             do {
1455                 KBNODE ncmp = NULL;
1456                 for( ; n2; n2 = n2->next ) {
1457                     if(    n2->pkt->pkttype == PKT_USER_ID
1458                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1459                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1460                         break;
1461                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1462                         ;
1463                     else if( !ncmp )
1464                         ncmp = n2;
1465                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1466                                                 n2->pkt->pkt.signature )) {
1467                         remove_kbnode( keyblock, n2 );
1468                         goto restart_sig;
1469                     }
1470                 }
1471                 n2 = ncmp? ncmp->next : NULL;
1472             } while( n2 );
1473         }
1474     }
1475
1476     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1477         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
1478     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1479         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
1480     else
1481         kid1 = 0;
1482     log_info(_("key %08lX: duplicated user ID detected - merged\n"),
1483                                                                  (ulong)kid1);
1484
1485     return 1;
1486 }
1487
1488 /* Check for a 0x20 revocation from a revocation key that is not
1489    present.  This gets called without the benefit of merge_xxxx so you
1490    can't rely on pk->revkey and friends. */
1491 static void
1492 revocation_present(KBNODE keyblock)
1493 {
1494   KBNODE onode,inode;
1495   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1496
1497   for(onode=keyblock->next;onode;onode=onode->next)
1498     {
1499       /* If we reach user IDs, we're done. */
1500       if(onode->pkt->pkttype==PKT_USER_ID)
1501         break;
1502
1503       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1504          onode->pkt->pkt.signature->sig_class==0x1F &&
1505          onode->pkt->pkt.signature->revkey)
1506         {
1507           int idx;
1508           PKT_signature *sig=onode->pkt->pkt.signature;
1509
1510           for(idx=0;idx<sig->numrevkeys;idx++)
1511             {
1512               u32 keyid[2];
1513
1514               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1515                                      MAX_FINGERPRINT_LEN,keyid);
1516
1517               for(inode=keyblock->next;inode;inode=inode->next)
1518                 {
1519                   /* If we reach user IDs, we're done. */
1520                   if(inode->pkt->pkttype==PKT_USER_ID)
1521                     break;
1522
1523                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1524                      inode->pkt->pkt.signature->sig_class==0x20 &&
1525                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1526                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1527                     {
1528                       /* Okay, we have a revocation key, and a
1529                          revocation issued by it.  Do we have the key
1530                          itself? */
1531                       int rc;
1532
1533                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1534                                                    MAX_FINGERPRINT_LEN);
1535                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1536                         {
1537                           /* No, so try and get it */
1538                           if(opt.keyserver_scheme &&
1539                              opt.keyserver_options.auto_key_retrieve)
1540                             {
1541                               log_info(_("WARNING: key %08lX may be revoked: "
1542                                          "fetching revocation key %08lX\n"),
1543                                        (ulong)keyid_from_pk(pk,NULL),
1544                                        (ulong)keyid[1]);
1545                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1546                                                       MAX_FINGERPRINT_LEN);
1547
1548                               /* Do we have it now? */
1549                               rc=get_pubkey_byfprint_fast (NULL,
1550                                                      sig->revkey[idx]->fpr,
1551                                                      MAX_FINGERPRINT_LEN);
1552                             }
1553
1554                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1555                             log_info(_("WARNING: key %08lX may be revoked: "
1556                                        "revocation key %08lX not present.\n"),
1557                                      (ulong)keyid_from_pk(pk,NULL),
1558                                      (ulong)keyid[1]);
1559                         }
1560                     }
1561                 }
1562             }
1563         }
1564     }
1565 }
1566
1567 /****************
1568  * compare and merge the blocks
1569  *
1570  * o compare the signatures: If we already have this signature, check
1571  *   that they compare okay; if not, issue a warning and ask the user.
1572  * o Simply add the signature.  Can't verify here because we may not have
1573  *   the signature's public key yet; verification is done when putting it
1574  *   into the trustdb, which is done automagically as soon as this pubkey
1575  *   is used.
1576  * Note: We indicate newly inserted packets with flag bit 0
1577  */
1578 static int
1579 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1580               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1581 {
1582     KBNODE onode, node;
1583     int rc, found;
1584
1585     /* 1st: handle revocation certificates */
1586     for(node=keyblock->next; node; node=node->next ) {
1587         if( node->pkt->pkttype == PKT_USER_ID )
1588             break;
1589         else if( node->pkt->pkttype == PKT_SIGNATURE
1590                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1591             /* check whether we already have this */
1592             found = 0;
1593             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1594                 if( onode->pkt->pkttype == PKT_USER_ID )
1595                     break;
1596                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1597                          && onode->pkt->pkt.signature->sig_class == 0x20
1598                          && node->pkt->pkt.signature->keyid[0]
1599                             == onode->pkt->pkt.signature->keyid[0]
1600                          && node->pkt->pkt.signature->keyid[1]
1601                             == onode->pkt->pkt.signature->keyid[1] ) {
1602                     found = 1;
1603                     break;
1604                 }
1605             }
1606             if( !found ) {
1607                 char *p=get_user_id_printable (keyid);
1608                 KBNODE n2 = clone_kbnode(node);
1609                 insert_kbnode( keyblock_orig, n2, 0 );
1610                 n2->flag |= 1;
1611                 ++*n_sigs;
1612                 log_info(_("key %08lX: \"%s\" revocation certificate added\n"),
1613                                          (ulong)keyid[1],p);
1614                 m_free(p);
1615             }
1616         }
1617     }
1618
1619     /* 2nd: merge in any direct key (0x1F) sigs */
1620     for(node=keyblock->next; node; node=node->next ) {
1621         if( node->pkt->pkttype == PKT_USER_ID )
1622             break;
1623         else if( node->pkt->pkttype == PKT_SIGNATURE
1624                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1625             /* check whether we already have this */
1626             found = 0;
1627             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1628                 if( onode->pkt->pkttype == PKT_USER_ID )
1629                     break;
1630                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1631                          && onode->pkt->pkt.signature->sig_class == 0x1F
1632                          && !cmp_signatures(onode->pkt->pkt.signature,
1633                                             node->pkt->pkt.signature)) {
1634                     found = 1;
1635                     break;
1636                 }
1637             }
1638             if( !found ) {
1639                 KBNODE n2 = clone_kbnode(node);
1640                 insert_kbnode( keyblock_orig, n2, 0 );
1641                 n2->flag |= 1;
1642                 ++*n_sigs;
1643                 log_info( _("key %08lX: direct key signature added\n"),
1644                                          (ulong)keyid[1]);
1645             }
1646         }
1647     }
1648
1649     /* 3rd: try to merge new certificates in */
1650     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1651         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1652             /* find the user id in the imported keyblock */
1653             for(node=keyblock->next; node; node=node->next )
1654                 if( node->pkt->pkttype == PKT_USER_ID
1655                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1656                                           node->pkt->pkt.user_id ) )
1657                     break;
1658             if( node ) { /* found: merge */
1659                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1660                 if( rc )
1661                     return rc;
1662             }
1663         }
1664     }
1665
1666     /* 4th: add new user-ids */
1667     for(node=keyblock->next; node; node=node->next ) {
1668         if( node->pkt->pkttype == PKT_USER_ID) {
1669             /* do we have this in the original keyblock */
1670             for(onode=keyblock_orig->next; onode; onode=onode->next )
1671                 if( onode->pkt->pkttype == PKT_USER_ID
1672                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1673                                       node->pkt->pkt.user_id ) )
1674                     break;
1675             if( !onode ) { /* this is a new user id: append */
1676                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1677                 if( rc )
1678                     return rc;
1679                 ++*n_uids;
1680             }
1681         }
1682     }
1683
1684     /* 5th: add new subkeys */
1685     for(node=keyblock->next; node; node=node->next ) {
1686         onode = NULL;
1687         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1688             /* do we have this in the original keyblock? */
1689             for(onode=keyblock_orig->next; onode; onode=onode->next )
1690                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1691                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1692                                          node->pkt->pkt.public_key ) )
1693                     break;
1694             if( !onode ) { /* this is a new subkey: append */
1695                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1696                 if( rc )
1697                     return rc;
1698                 ++*n_subk;
1699             }
1700         }
1701         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1702             /* do we have this in the original keyblock? */
1703             for(onode=keyblock_orig->next; onode; onode=onode->next )
1704                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1705                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1706                                          node->pkt->pkt.secret_key ) )
1707                     break;
1708             if( !onode ) { /* this is a new subkey: append */
1709                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1710                 if( rc )
1711                     return rc;
1712                 ++*n_subk;
1713             }
1714         }
1715     }
1716
1717     /* 6th: merge subkey certificates */
1718     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1719         if( !(onode->flag & 1)
1720             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1721                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1722             /* find the subkey in the imported keyblock */
1723             for(node=keyblock->next; node; node=node->next ) {
1724                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1725                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1726                                           node->pkt->pkt.public_key ) )
1727                     break;
1728                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1729                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1730                                           node->pkt->pkt.secret_key ) )
1731                     break;
1732             }
1733             if( node ) { /* found: merge */
1734                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1735                 if( rc )
1736                     return rc;
1737             }
1738         }
1739     }
1740
1741
1742     return 0;
1743 }
1744
1745
1746 /****************
1747  * append the userid starting with NODE and all signatures to KEYBLOCK.
1748  */
1749 static int
1750 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1751                                           const char *fname, u32 *keyid )
1752 {
1753     KBNODE n, n_where=NULL;
1754
1755     assert(node->pkt->pkttype == PKT_USER_ID );
1756
1757     /* find the position */
1758     for( n = keyblock; n; n_where = n, n = n->next ) {
1759         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1760             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1761             break;
1762     }
1763     if( !n )
1764         n_where = NULL;
1765
1766     /* and append/insert */
1767     while( node ) {
1768         /* we add a clone to the original keyblock, because this
1769          * one is released first */
1770         n = clone_kbnode(node);
1771         if( n_where ) {
1772             insert_kbnode( n_where, n, 0 );
1773             n_where = n;
1774         }
1775         else
1776             add_kbnode( keyblock, n );
1777         n->flag |= 1;
1778         node->flag |= 1;
1779         if( n->pkt->pkttype == PKT_SIGNATURE )
1780             ++*n_sigs;
1781
1782         node = node->next;
1783         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1784             break;
1785     }
1786
1787     return 0;
1788 }
1789
1790
1791 /****************
1792  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1793  * (how should we handle comment packets here?)
1794  */
1795 static int
1796 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1797                                     const char *fname, u32 *keyid )
1798 {
1799     KBNODE n, n2;
1800     int found=0;
1801
1802     assert(dst->pkt->pkttype == PKT_USER_ID );
1803     assert(src->pkt->pkttype == PKT_USER_ID );
1804
1805     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1806         if( n->pkt->pkttype != PKT_SIGNATURE )
1807             continue;
1808         if( n->pkt->pkt.signature->sig_class == 0x18
1809             || n->pkt->pkt.signature->sig_class == 0x28 )
1810             continue; /* skip signatures which are only valid on subkeys */
1811         found = 0;
1812         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1813             if( n2->pkt->pkttype == PKT_SIGNATURE
1814                 && n->pkt->pkt.signature->keyid[0]
1815                    == n2->pkt->pkt.signature->keyid[0]
1816                 && n->pkt->pkt.signature->keyid[1]
1817                    == n2->pkt->pkt.signature->keyid[1]
1818                 && n->pkt->pkt.signature->timestamp
1819                    <= n2->pkt->pkt.signature->timestamp
1820                 && n->pkt->pkt.signature->sig_class
1821                    == n2->pkt->pkt.signature->sig_class ) {
1822                 found++;
1823                 break;
1824             }
1825         }
1826         if( !found ) {
1827             /* This signature is new or newer, append N to DST.
1828              * We add a clone to the original keyblock, because this
1829              * one is released first */
1830             n2 = clone_kbnode(n);
1831             insert_kbnode( dst, n2, PKT_SIGNATURE );
1832             n2->flag |= 1;
1833             n->flag |= 1;
1834             ++*n_sigs;
1835         }
1836     }
1837
1838     return 0;
1839 }
1840
1841 /****************
1842  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1843  */
1844 static int
1845 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1846                                     const char *fname, u32 *keyid )
1847 {
1848     KBNODE n, n2;
1849     int found=0;
1850
1851     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1852            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1853
1854     for(n=src->next; n ; n = n->next ) {
1855         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1856             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1857             break;
1858         if( n->pkt->pkttype != PKT_SIGNATURE )
1859             continue;
1860         found = 0;
1861         for(n2=dst->next; n2; n2 = n2->next){
1862             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1863                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1864                 break;
1865             if( n2->pkt->pkttype == PKT_SIGNATURE
1866                 && n->pkt->pkt.signature->keyid[0]
1867                    == n2->pkt->pkt.signature->keyid[0]
1868                 && n->pkt->pkt.signature->keyid[1]
1869                    == n2->pkt->pkt.signature->keyid[1]
1870                 && n->pkt->pkt.signature->timestamp
1871                    <= n2->pkt->pkt.signature->timestamp
1872                 && n->pkt->pkt.signature->sig_class
1873                    == n2->pkt->pkt.signature->sig_class ) {
1874                 found++;
1875                 break;
1876             }
1877         }
1878         if( !found ) {
1879             /* This signature is new or newer, append N to DST.
1880              * We add a clone to the original keyblock, because this
1881              * one is released first */
1882             n2 = clone_kbnode(n);
1883             insert_kbnode( dst, n2, PKT_SIGNATURE );
1884             n2->flag |= 1;
1885             n->flag |= 1;
1886             ++*n_sigs;
1887         }
1888     }
1889
1890     return 0;
1891 }
1892
1893 /****************
1894  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1895  * Mark all new and copied packets by setting flag bit 0.
1896  */
1897 static int
1898 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1899                                           const char *fname, u32 *keyid )
1900 {
1901     KBNODE n;
1902
1903     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1904            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1905
1906     while(  node ) {
1907         /* we add a clone to the original keyblock, because this
1908          * one is released first */
1909         n = clone_kbnode(node);
1910         add_kbnode( keyblock, n );
1911         n->flag |= 1;
1912         node->flag |= 1;
1913         if( n->pkt->pkttype == PKT_SIGNATURE )
1914             ++*n_sigs;
1915
1916         node = node->next;
1917         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1918             break;
1919     }
1920
1921     return 0;
1922 }