* options.h, g10.c (main), import.c (parse_import_options, import_one,
[gnupg.git] / g10 / import.c
1 /* import.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003 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 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     release_kbnode( keyblock_orig );
789     free_public_key( pk_orig );
790
791     revocation_present(keyblock);
792
793     return rc;
794 }
795
796 /* Walk a secret keyblock and produce a public keyblock out of it. */
797 static KBNODE
798 sec_to_pub_keyblock(KBNODE sec_keyblock)
799 {
800   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
801
802   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
803     {
804       KBNODE pubnode;
805
806       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
807          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
808         {
809           /* Make a public key.  We only need to convert enough to
810              write the keyblock out. */
811
812           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
813           PACKET *pkt=m_alloc_clear(sizeof(PACKET));
814           PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
815           int n;
816
817           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
818             pkt->pkttype=PKT_PUBLIC_KEY;
819           else
820             pkt->pkttype=PKT_PUBLIC_SUBKEY;
821
822           pkt->pkt.public_key=pk;
823
824           pk->version=sk->version;
825           pk->timestamp=sk->timestamp;
826           pk->expiredate=sk->expiredate;
827           pk->pubkey_algo=sk->pubkey_algo;
828
829           n=pubkey_get_npkey(pk->pubkey_algo);
830           if(n==0)
831             pk->pkey[0]=mpi_copy(sk->skey[0]);
832           else
833             {
834               int i;
835
836               for(i=0;i<n;i++)
837                 pk->pkey[i]=mpi_copy(sk->skey[i]);
838             }
839
840           pubnode=new_kbnode(pkt);
841         }
842       else
843         {
844           pubnode=clone_kbnode(secnode);
845         }
846
847       if(pub_keyblock==NULL)
848         pub_keyblock=pubnode;
849       else
850         add_kbnode(pub_keyblock,pubnode);
851     }
852
853   return pub_keyblock;
854 }
855
856 /****************
857  * Ditto for secret keys.  Handling is simpler than for public keys.
858  * We allow secret key importing only when allow is true, this is so
859  * that a secret key can not be imported accidently and thereby tampering
860  * with the trust calculation.
861  */
862 static int
863 import_secret_one( const char *fname, KBNODE keyblock, 
864                    struct stats_s *stats, unsigned int options)
865 {
866     PKT_secret_key *sk;
867     KBNODE node, uidnode;
868     u32 keyid[2];
869     int rc = 0;
870
871     /* get the key and print some info about it */
872     node = find_kbnode( keyblock, PKT_SECRET_KEY );
873     if( !node )
874         BUG();
875
876     sk = node->pkt->pkt.secret_key;
877     keyid_from_sk( sk, keyid );
878     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
879
880     if( opt.verbose ) {
881         log_info( "sec  %4u%c/%08lX %s   ",
882                   nbits_from_sk( sk ),
883                   pubkey_letter( sk->pubkey_algo ),
884                   (ulong)keyid[1], datestr_from_sk(sk) );
885         if( uidnode )
886             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
887                                        uidnode->pkt->pkt.user_id->len );
888         putc('\n', stderr);
889     }
890     stats->secret_read++;
891
892     if( !uidnode ) {
893         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
894         return 0;
895     }
896
897     if(sk->protect.algo>110)
898       {
899         log_error(_("key %08lX: secret key with invalid cipher %d "
900                     "- skipped\n"),(ulong)keyid[1],sk->protect.algo);
901         return 0;
902       }
903
904     clear_kbnode_flags( keyblock );
905
906     /* do we have this key already in one of our secrings ? */
907     rc = seckey_available( keyid );
908     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
909       {
910         /* 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_error( _("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                  && !cmp_signatures(node->pkt->pkt.signature,
1034                                     onode->pkt->pkt.signature))
1035           {
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                       if( opt.verbose )
1129                         {
1130                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1131                                       strlen(unode->pkt->pkt.user_id->name),0);
1132                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1133                                     _("key %08lX: unsupported public key "
1134                                       "algorithm on user id \"%s\"\n"):
1135                                     _("key %08lX: invalid self-signature "
1136                                       "on user id \"%s\"\n"),
1137                                     (ulong)keyid[1],p);
1138                           m_free(p);
1139                         }
1140                     }
1141                   else
1142                     unode->flag |= 1; /* mark that signature checked */
1143                 }
1144             }
1145             else if( sig->sig_class == 0x18 ) {
1146               /* Note that this works based solely on the timestamps
1147                  like the rest of gpg.  If the standard gets
1148                  revocation targets, this may need to be revised. */
1149
1150                 if( !knode ) {
1151                     if(opt.verbose)
1152                       log_info( _("key %08lX: no subkey for key binding\n"),
1153                                 (ulong)keyid[1]);
1154                     n->flag |= 4; /* delete this */
1155                 }
1156                 else {
1157                   rc = check_key_signature( keyblock, n, NULL);
1158                   if( rc ) {
1159                     if(opt.verbose)
1160                       log_info(rc == G10ERR_PUBKEY_ALGO ?
1161                             _("key %08lX: unsupported public key algorithm\n"):
1162                             _("key %08lX: invalid subkey binding\n"),
1163                             (ulong)keyid[1]);
1164                     n->flag|=4;
1165                   }
1166                   else {
1167                     /* It's valid, so is it newer? */
1168                     if(sig->timestamp>=bsdate) {
1169                       knode->flag |= 1;  /* the subkey is valid */
1170                       if(bsnode) {
1171                         bsnode->flag|=4; /* Delete the last binding
1172                                             sig since this one is
1173                                             newer */
1174                         if(opt.verbose)
1175                           log_info(_("key %08lX: removed multiple subkey "
1176                                      "binding\n"),(ulong)keyid[1]);
1177                       }
1178
1179                       bsnode=n;
1180                       bsdate=sig->timestamp;
1181                     }
1182                     else
1183                       n->flag|=4; /* older */
1184                   }
1185                 }
1186             }
1187             else if( sig->sig_class == 0x28 ) {
1188               /* We don't actually mark the subkey as revoked right
1189                  now, so just check that the revocation sig is the
1190                  most recent valid one.  Note that we don't care if
1191                  the binding sig is newer than the revocation sig.
1192                  See the comment in getkey.c:merge_selfsigs_subkey for
1193                  more */
1194                 if( !knode ) {
1195                     if(opt.verbose)
1196                       log_info( _("key %08lX: no subkey for key revocation\n"),
1197                                 (ulong)keyid[1]);
1198                     n->flag |= 4; /* delete this */
1199                 }
1200                 else {
1201                   rc = check_key_signature( keyblock, n, NULL);
1202                   if( rc ) {
1203                       if(opt.verbose)
1204                         log_info(rc == G10ERR_PUBKEY_ALGO ?
1205                             _("key %08lX: unsupported public key algorithm\n"):
1206                             _("key %08lX: invalid subkey revocation\n"),
1207                             (ulong)keyid[1]);
1208
1209                       n->flag|=4;
1210                   }
1211                   else {
1212                     /* It's valid, so is it newer? */
1213                     if(sig->timestamp>=rsdate) {
1214                       if(rsnode) {
1215                         rsnode->flag|=4; /* Delete the last revocation
1216                                             sig since this one is
1217                                             newer */
1218                         if(opt.verbose)
1219                           log_info(_("key %08lX: removed multiple subkey "
1220                                      "revocation\n"),(ulong)keyid[1]);
1221                       }
1222
1223                       rsnode=n;
1224                       rsdate=sig->timestamp;
1225                     }
1226                     else
1227                       n->flag|=4; /* older */
1228                   }
1229                 }
1230             }
1231         }
1232         else
1233           *non_self=1;
1234     }
1235
1236     return 0;
1237 }
1238
1239 /****************
1240  * delete all parts which are invalid and those signatures whose
1241  * public key algorithm is not available in this implemenation;
1242  * but consider RSA as valid, because parse/build_packets knows
1243  * about it.
1244  * returns: true if at least one valid user-id is left over.
1245  */
1246 static int
1247 delete_inv_parts( const char *fname, KBNODE keyblock,
1248                   u32 *keyid, unsigned int options)
1249 {
1250     KBNODE node;
1251     int nvalid=0, uid_seen=0, subkey_seen=0;
1252
1253     for(node=keyblock->next; node; node = node->next ) {
1254         if( node->pkt->pkttype == PKT_USER_ID ) {
1255             uid_seen = 1;
1256             if( (node->flag & 2) || !(node->flag & 1) ) {
1257                 if( opt.verbose ) {
1258                     log_info( _("key %08lX: skipped user ID '"),
1259                                                          (ulong)keyid[1]);
1260                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
1261                                        node->pkt->pkt.user_id->len );
1262                     fputs("'\n", stderr );
1263                 }
1264                 delete_kbnode( node ); /* the user-id */
1265                 /* and all following packets up to the next user-id */
1266                 while( node->next
1267                        && node->next->pkt->pkttype != PKT_USER_ID
1268                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1269                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1270                     delete_kbnode( node->next );
1271                     node = node->next;
1272                 }
1273             }
1274             else
1275                 nvalid++;
1276         }
1277         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1278                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1279             if( (node->flag & 2) || !(node->flag & 1) ) {
1280                 if( opt.verbose ) {
1281                     log_info( _("key %08lX: skipped subkey\n"),
1282                                                          (ulong)keyid[1]);
1283                 }
1284                 delete_kbnode( node ); /* the subkey */
1285                 /* and all following signature packets */
1286                 while( node->next
1287                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1288                     delete_kbnode( node->next );
1289                     node = node->next;
1290                 }
1291             }
1292             else
1293               subkey_seen = 1;
1294         }
1295         else if( node->pkt->pkttype == PKT_SIGNATURE
1296                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1297                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1298             delete_kbnode( node ); /* build_packet() can't handle this */
1299         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1300                  !node->pkt->pkt.signature->flags.exportable &&
1301                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1302                  seckey_available( node->pkt->pkt.signature->keyid ) ) {
1303             /* here we violate the rfc a bit by still allowing
1304              * to import non-exportable signature when we have the
1305              * the secret key used to create this signature - it
1306              * seems that this makes sense */
1307             if(opt.verbose)
1308               log_info( _("key %08lX: non exportable signature "
1309                           "(class %02x) - skipped\n"),
1310                         (ulong)keyid[1], node->pkt->pkt.signature->sig_class );
1311             delete_kbnode( node );
1312         }
1313         else if( node->pkt->pkttype == PKT_SIGNATURE
1314                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1315             if( uid_seen ) {
1316                 if(opt.verbose)
1317                   log_info( _("key %08lX: revocation certificate "
1318                               "at wrong place - skipped\n"), (ulong)keyid[1]);
1319                 delete_kbnode( node );
1320             }
1321             else {
1322               /* If the revocation cert is from a different key than
1323                  the one we're working on don't check it - it's
1324                  probably from a revocation key and won't be
1325                  verifiable with this key anyway. */
1326
1327               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1328                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1329                 {
1330                   int rc = check_key_signature( keyblock, node, NULL);
1331                   if( rc )
1332                     {
1333                       if(opt.verbose)
1334                         log_info( _("key %08lX: invalid revocation "
1335                                     "certificate: %s - skipped\n"),
1336                                   (ulong)keyid[1], g10_errstr(rc));
1337                       delete_kbnode( node );
1338                     }
1339                 }
1340             }
1341         }
1342         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1343                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1344                   node->pkt->pkt.signature->sig_class == 0x28) &&
1345                  !subkey_seen ) {
1346             if(opt.verbose)
1347               log_info( _("key %08lX: subkey signature "
1348                           "in wrong place - skipped\n"), (ulong)keyid[1]);
1349             delete_kbnode( node );
1350         }
1351         else if( node->pkt->pkttype == PKT_SIGNATURE
1352                  && !IS_CERT(node->pkt->pkt.signature))
1353           {
1354             if(opt.verbose)
1355               log_info(_("key %08lX: unexpected signature class (0x%02X) -"
1356                          " skipped\n"),(ulong)keyid[1],
1357                        node->pkt->pkt.signature->sig_class);
1358             delete_kbnode(node);
1359           }
1360         else if( (node->flag & 4) ) /* marked for deletion */
1361             delete_kbnode( node );
1362     }
1363
1364     /* note: because keyblock is the public key, it is never marked
1365      * for deletion and so keyblock cannot change */
1366     commit_kbnode( &keyblock );
1367     return nvalid;
1368 }
1369
1370
1371 /****************
1372  * It may happen that the imported keyblock has duplicated user IDs.
1373  * We check this here and collapse those user IDs together with their
1374  * sigs into one.
1375  * Returns: True if the keyblock hash changed.
1376  */
1377 int
1378 collapse_uids( KBNODE *keyblock )
1379 {
1380     KBNODE n, n2;
1381     int in_uid;
1382     int any=0;
1383     u32 kid1;
1384
1385   restart:
1386     for( n = *keyblock; n; n = n->next ) {
1387         if( n->pkt->pkttype != PKT_USER_ID )
1388             continue;
1389         for( n2 = n->next; n2; n2 = n2->next ) {
1390             if( n2->pkt->pkttype == PKT_USER_ID
1391                 && !cmp_user_ids( n->pkt->pkt.user_id,
1392                                   n2->pkt->pkt.user_id ) ) {
1393                 /* found a duplicate */
1394                 any = 1;
1395                 if( !n2->next
1396                     || n2->next->pkt->pkttype == PKT_USER_ID
1397                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1398                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1399                     /* no more signatures: delete the user ID
1400                      * and start over */
1401                     remove_kbnode( keyblock, n2 );
1402                 }
1403                 else {
1404                     /* The simple approach: Move one signature and
1405                      * then start over to delete the next one :-( */
1406                     move_kbnode( keyblock, n2->next, n->next );
1407                 }
1408                 goto restart;
1409             }
1410         }
1411     }
1412     if( !any )
1413         return 0;
1414
1415   restart_sig:
1416     /* now we may have duplicate signatures on one user ID: fix this */
1417     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1418         if( n->pkt->pkttype == PKT_USER_ID )
1419             in_uid = 1;
1420         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1421                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1422             in_uid = 0;
1423         else if( in_uid ) {
1424             n2 = n;
1425             do {
1426                 KBNODE ncmp = NULL;
1427                 for( ; n2; n2 = n2->next ) {
1428                     if(    n2->pkt->pkttype == PKT_USER_ID
1429                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1430                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1431                         break;
1432                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1433                         ;
1434                     else if( !ncmp )
1435                         ncmp = n2;
1436                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1437                                                 n2->pkt->pkt.signature )) {
1438                         remove_kbnode( keyblock, n2 );
1439                         goto restart_sig;
1440                     }
1441                 }
1442                 n2 = ncmp? ncmp->next : NULL;
1443             } while( n2 );
1444         }
1445     }
1446
1447     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1448         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
1449     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1450         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
1451     else
1452         kid1 = 0;
1453     if(!opt.quiet)
1454       log_info(_("key %08lX: duplicated user ID detected - merged\n"),
1455                (ulong)kid1);
1456
1457     return 1;
1458 }
1459
1460 /* Check for a 0x20 revocation from a revocation key that is not
1461    present.  This gets called without the benefit of merge_xxxx so you
1462    can't rely on pk->revkey and friends. */
1463 static void
1464 revocation_present(KBNODE keyblock)
1465 {
1466   KBNODE onode,inode;
1467   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1468
1469   for(onode=keyblock->next;onode;onode=onode->next)
1470     {
1471       /* If we reach user IDs, we're done. */
1472       if(onode->pkt->pkttype==PKT_USER_ID)
1473         break;
1474
1475       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1476          onode->pkt->pkt.signature->sig_class==0x1F &&
1477          onode->pkt->pkt.signature->revkey)
1478         {
1479           int idx;
1480           PKT_signature *sig=onode->pkt->pkt.signature;
1481
1482           for(idx=0;idx<sig->numrevkeys;idx++)
1483             {
1484               u32 keyid[2];
1485
1486               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1487                                      MAX_FINGERPRINT_LEN,keyid);
1488
1489               for(inode=keyblock->next;inode;inode=inode->next)
1490                 {
1491                   /* If we reach user IDs, we're done. */
1492                   if(inode->pkt->pkttype==PKT_USER_ID)
1493                     break;
1494
1495                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1496                      inode->pkt->pkt.signature->sig_class==0x20 &&
1497                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1498                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1499                     {
1500                       /* Okay, we have a revocation key, and a
1501                          revocation issued by it.  Do we have the key
1502                          itself? */
1503                       int rc;
1504
1505                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1506                                                    MAX_FINGERPRINT_LEN);
1507                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1508                         {
1509                           /* No, so try and get it */
1510                           if(opt.keyserver_scheme &&
1511                              opt.keyserver_options.auto_key_retrieve)
1512                             {
1513                               log_info(_("WARNING: key %08lX may be revoked: "
1514                                          "fetching revocation key %08lX\n"),
1515                                        (ulong)keyid_from_pk(pk,NULL),
1516                                        (ulong)keyid[1]);
1517                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1518                                                       MAX_FINGERPRINT_LEN);
1519
1520                               /* Do we have it now? */
1521                               rc=get_pubkey_byfprint_fast (NULL,
1522                                                      sig->revkey[idx]->fpr,
1523                                                      MAX_FINGERPRINT_LEN);
1524                             }
1525
1526                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1527                             log_info(_("WARNING: key %08lX may be revoked: "
1528                                        "revocation key %08lX not present.\n"),
1529                                      (ulong)keyid_from_pk(pk,NULL),
1530                                      (ulong)keyid[1]);
1531                         }
1532                     }
1533                 }
1534             }
1535         }
1536     }
1537 }
1538
1539 /****************
1540  * compare and merge the blocks
1541  *
1542  * o compare the signatures: If we already have this signature, check
1543  *   that they compare okay; if not, issue a warning and ask the user.
1544  * o Simply add the signature.  Can't verify here because we may not have
1545  *   the signature's public key yet; verification is done when putting it
1546  *   into the trustdb, which is done automagically as soon as this pubkey
1547  *   is used.
1548  * Note: We indicate newly inserted packets with flag bit 0
1549  */
1550 static int
1551 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1552               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1553 {
1554     KBNODE onode, node;
1555     int rc, found;
1556
1557     /* 1st: handle revocation certificates */
1558     for(node=keyblock->next; node; node=node->next ) {
1559         if( node->pkt->pkttype == PKT_USER_ID )
1560             break;
1561         else if( node->pkt->pkttype == PKT_SIGNATURE
1562                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1563             /* check whether we already have this */
1564             found = 0;
1565             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1566                 if( onode->pkt->pkttype == PKT_USER_ID )
1567                     break;
1568                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1569                          && onode->pkt->pkt.signature->sig_class == 0x20
1570                          && !cmp_signatures(onode->pkt->pkt.signature,
1571                                             node->pkt->pkt.signature))
1572                   {
1573                     found = 1;
1574                     break;
1575                   }
1576             }
1577             if( !found ) {
1578                 KBNODE n2 = clone_kbnode(node);
1579                 insert_kbnode( keyblock_orig, n2, 0 );
1580                 n2->flag |= 1;
1581                 ++*n_sigs;
1582                 if(!opt.quiet)
1583                   {
1584                     char *p=get_user_id_printable (keyid);
1585                     log_info(_("key %08lX: \"%s\" revocation "
1586                                "certificate added\n"), (ulong)keyid[1],p);
1587                     m_free(p);
1588                   }
1589             }
1590         }
1591     }
1592
1593     /* 2nd: merge in any direct key (0x1F) sigs */
1594     for(node=keyblock->next; node; node=node->next ) {
1595         if( node->pkt->pkttype == PKT_USER_ID )
1596             break;
1597         else if( node->pkt->pkttype == PKT_SIGNATURE
1598                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1599             /* check whether we already have this */
1600             found = 0;
1601             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1602                 if( onode->pkt->pkttype == PKT_USER_ID )
1603                     break;
1604                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1605                          && onode->pkt->pkt.signature->sig_class == 0x1F
1606                          && !cmp_signatures(onode->pkt->pkt.signature,
1607                                             node->pkt->pkt.signature)) {
1608                     found = 1;
1609                     break;
1610                 }
1611             }
1612             if( !found ) {
1613                 KBNODE n2 = clone_kbnode(node);
1614                 insert_kbnode( keyblock_orig, n2, 0 );
1615                 n2->flag |= 1;
1616                 ++*n_sigs;
1617                 if(!opt.quiet)
1618                   log_info( _("key %08lX: direct key signature added\n"),
1619                             (ulong)keyid[1]);
1620             }
1621         }
1622     }
1623
1624     /* 3rd: try to merge new certificates in */
1625     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1626         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1627             /* find the user id in the imported keyblock */
1628             for(node=keyblock->next; node; node=node->next )
1629                 if( node->pkt->pkttype == PKT_USER_ID
1630                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1631                                           node->pkt->pkt.user_id ) )
1632                     break;
1633             if( node ) { /* found: merge */
1634                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1635                 if( rc )
1636                     return rc;
1637             }
1638         }
1639     }
1640
1641     /* 4th: add new user-ids */
1642     for(node=keyblock->next; node; node=node->next ) {
1643         if( node->pkt->pkttype == PKT_USER_ID) {
1644             /* do we have this in the original keyblock */
1645             for(onode=keyblock_orig->next; onode; onode=onode->next )
1646                 if( onode->pkt->pkttype == PKT_USER_ID
1647                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1648                                       node->pkt->pkt.user_id ) )
1649                     break;
1650             if( !onode ) { /* this is a new user id: append */
1651                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1652                 if( rc )
1653                     return rc;
1654                 ++*n_uids;
1655             }
1656         }
1657     }
1658
1659     /* 5th: add new subkeys */
1660     for(node=keyblock->next; node; node=node->next ) {
1661         onode = NULL;
1662         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1663             /* do we have this in the original keyblock? */
1664             for(onode=keyblock_orig->next; onode; onode=onode->next )
1665                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1666                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1667                                          node->pkt->pkt.public_key ) )
1668                     break;
1669             if( !onode ) { /* this is a new subkey: append */
1670                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1671                 if( rc )
1672                     return rc;
1673                 ++*n_subk;
1674             }
1675         }
1676         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1677             /* do we have this in the original keyblock? */
1678             for(onode=keyblock_orig->next; onode; onode=onode->next )
1679                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1680                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1681                                          node->pkt->pkt.secret_key ) )
1682                     break;
1683             if( !onode ) { /* this is a new subkey: append */
1684                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1685                 if( rc )
1686                     return rc;
1687                 ++*n_subk;
1688             }
1689         }
1690     }
1691
1692     /* 6th: merge subkey certificates */
1693     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1694         if( !(onode->flag & 1)
1695             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1696                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1697             /* find the subkey in the imported keyblock */
1698             for(node=keyblock->next; node; node=node->next ) {
1699                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1700                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1701                                           node->pkt->pkt.public_key ) )
1702                     break;
1703                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1704                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1705                                           node->pkt->pkt.secret_key ) )
1706                     break;
1707             }
1708             if( node ) { /* found: merge */
1709                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1710                 if( rc )
1711                     return rc;
1712             }
1713         }
1714     }
1715
1716
1717     return 0;
1718 }
1719
1720
1721 /****************
1722  * append the userid starting with NODE and all signatures to KEYBLOCK.
1723  */
1724 static int
1725 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1726                                           const char *fname, u32 *keyid )
1727 {
1728     KBNODE n, n_where=NULL;
1729
1730     assert(node->pkt->pkttype == PKT_USER_ID );
1731
1732     /* find the position */
1733     for( n = keyblock; n; n_where = n, n = n->next ) {
1734         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1735             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1736             break;
1737     }
1738     if( !n )
1739         n_where = NULL;
1740
1741     /* and append/insert */
1742     while( node ) {
1743         /* we add a clone to the original keyblock, because this
1744          * one is released first */
1745         n = clone_kbnode(node);
1746         if( n_where ) {
1747             insert_kbnode( n_where, n, 0 );
1748             n_where = n;
1749         }
1750         else
1751             add_kbnode( keyblock, n );
1752         n->flag |= 1;
1753         node->flag |= 1;
1754         if( n->pkt->pkttype == PKT_SIGNATURE )
1755             ++*n_sigs;
1756
1757         node = node->next;
1758         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1759             break;
1760     }
1761
1762     return 0;
1763 }
1764
1765
1766 /****************
1767  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1768  * (how should we handle comment packets here?)
1769  */
1770 static int
1771 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1772                                     const char *fname, u32 *keyid )
1773 {
1774     KBNODE n, n2;
1775     int found=0;
1776
1777     assert(dst->pkt->pkttype == PKT_USER_ID );
1778     assert(src->pkt->pkttype == PKT_USER_ID );
1779
1780     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1781         if( n->pkt->pkttype != PKT_SIGNATURE )
1782             continue;
1783         if( n->pkt->pkt.signature->sig_class == 0x18
1784             || n->pkt->pkt.signature->sig_class == 0x28 )
1785             continue; /* skip signatures which are only valid on subkeys */
1786         found = 0;
1787         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
1788           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
1789             {
1790               found++;
1791               break;
1792             }
1793         if( !found ) {
1794             /* This signature is new or newer, append N to DST.
1795              * We add a clone to the original keyblock, because this
1796              * one is released first */
1797             n2 = clone_kbnode(n);
1798             insert_kbnode( dst, n2, PKT_SIGNATURE );
1799             n2->flag |= 1;
1800             n->flag |= 1;
1801             ++*n_sigs;
1802         }
1803     }
1804
1805     return 0;
1806 }
1807
1808 /****************
1809  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1810  */
1811 static int
1812 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1813                                     const char *fname, u32 *keyid )
1814 {
1815     KBNODE n, n2;
1816     int found=0;
1817
1818     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1819            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1820
1821     for(n=src->next; n ; n = n->next ) {
1822         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1823             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1824             break;
1825         if( n->pkt->pkttype != PKT_SIGNATURE )
1826             continue;
1827         found = 0;
1828         for(n2=dst->next; n2; n2 = n2->next){
1829             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1830                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1831                 break;
1832             if( n2->pkt->pkttype == PKT_SIGNATURE
1833                 && n->pkt->pkt.signature->keyid[0]
1834                    == n2->pkt->pkt.signature->keyid[0]
1835                 && n->pkt->pkt.signature->keyid[1]
1836                    == n2->pkt->pkt.signature->keyid[1]
1837                 && n->pkt->pkt.signature->timestamp
1838                    <= n2->pkt->pkt.signature->timestamp
1839                 && n->pkt->pkt.signature->sig_class
1840                    == n2->pkt->pkt.signature->sig_class ) {
1841                 found++;
1842                 break;
1843             }
1844         }
1845         if( !found ) {
1846             /* This signature is new or newer, append N to DST.
1847              * We add a clone to the original keyblock, because this
1848              * one is released first */
1849             n2 = clone_kbnode(n);
1850             insert_kbnode( dst, n2, PKT_SIGNATURE );
1851             n2->flag |= 1;
1852             n->flag |= 1;
1853             ++*n_sigs;
1854         }
1855     }
1856
1857     return 0;
1858 }
1859
1860 /****************
1861  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1862  * Mark all new and copied packets by setting flag bit 0.
1863  */
1864 static int
1865 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1866                                           const char *fname, u32 *keyid )
1867 {
1868     KBNODE n;
1869
1870     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1871            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1872
1873     while(  node ) {
1874         /* we add a clone to the original keyblock, because this
1875          * one is released first */
1876         n = clone_kbnode(node);
1877         add_kbnode( keyblock, n );
1878         n->flag |= 1;
1879         node->flag |= 1;
1880         if( n->pkt->pkttype == PKT_SIGNATURE )
1881             ++*n_sigs;
1882
1883         node = node->next;
1884         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1885             break;
1886     }
1887
1888     return 0;
1889 }