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