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