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