d13357b6abfb3879535124b1cbdf83053a6c3616
[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(check_compress_algo(pkt->pkt.compressed->algorithm))
368               {
369                 rc = G10ERR_COMPR_ALGO;
370                 goto ready;
371               }
372             else
373               {
374                 compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
375                 pkt->pkt.compressed->buf = NULL;
376                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,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( opt.verbose && !opt.interactive ) {
563         log_info( "pub  %4u%c/%08lX %s   ",
564                   nbits_from_pk( pk ),
565                   pubkey_letter( pk->pubkey_algo ),
566                   (ulong)keyid[1], datestr_from_pk(pk) );
567         if( uidnode )
568             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
569                                        uidnode->pkt->pkt.user_id->len );
570         putc('\n', stderr);
571     }
572     if( !uidnode ) {
573         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
574         return 0;
575     }
576     
577     if (opt.interactive) {
578         if(is_status_enabled())
579           print_import_check (pk, uidnode->pkt->pkt.user_id);
580         merge_keys_and_selfsig (keyblock);
581         tty_printf ("\n");
582         show_basic_key_info (keyblock);
583         tty_printf ("\n");
584         if (!cpr_get_answer_is_yes ("import.okay",
585                                     "Do you want to import this key? (y/N) "))
586             return 0;
587     }
588
589     clear_kbnode_flags( keyblock );
590
591     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
592        && opt.verbose)
593       log_info(_("key %08lX: PKS subkey corruption repaired\n"),
594                (ulong)keyid[1]);
595
596     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
597     if( rc )
598         return rc== -1? 0:rc;
599
600     /* If we allow such a thing, mark unsigned uids as valid */
601     if( opt.allow_non_selfsigned_uid )
602       for( node=keyblock; node; node = node->next )
603         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
604           {
605             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
606                                       node->pkt->pkt.user_id->len,0);
607             node->flag |= 1;
608             log_info( _("key %08lX: accepted non self-signed user ID '%s'\n"),
609                       (ulong)keyid[1],user);
610             m_free(user);
611           }
612
613     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
614         log_error( _("key %08lX: no valid user IDs\n"), (ulong)keyid[1]);
615         if( !opt.quiet )
616           log_info(_("this may be caused by a missing self-signature\n"));
617         stats->no_user_id++;
618         return 0;
619     }
620
621     /* do we have this key already in one of our pubrings ? */
622     pk_orig = m_alloc_clear( sizeof *pk_orig );
623     rc = get_pubkey_fast ( pk_orig, keyid );
624     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY ) {
625         log_error( _("key %08lX: public key not found: %s\n"),
626                                 (ulong)keyid[1], g10_errstr(rc));
627     }
628     else if ( rc && opt.merge_only ) {
629         if( opt.verbose )
630             log_info( _("key %08lX: new key - skipped\n"), (ulong)keyid[1] );
631         rc = 0;
632         stats->skipped_new_keys++;
633     }
634     else if( rc ) { /* insert this key */
635         KEYDB_HANDLE hd = keydb_new (0);
636
637         rc = keydb_locate_writable (hd, NULL);
638         if (rc) {
639             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
640             keydb_release (hd);
641             return G10ERR_GENERAL;
642         }
643         if( opt.verbose > 1 )
644             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
645         rc = keydb_insert_keyblock (hd, keyblock );
646         if (rc)
647            log_error (_("error writing keyring `%s': %s\n"),
648                        keydb_get_resource_name (hd), g10_errstr(rc));
649         else
650           {
651             /* This should not be possible since we delete the
652                ownertrust when a key is deleted, but it can happen if
653                the keyring and trustdb are out of sync.  It can also
654                be made to happen with the trusted-key command. */
655
656             clear_ownertrusts (pk);
657             if(non_self)
658               revalidation_mark ();
659           }
660         keydb_release (hd);
661
662         /* we are ready */
663         if( !opt.quiet ) {
664             char *p=get_user_id_printable (keyid);
665             log_info( _("key %08lX: public key \"%s\" imported\n"),
666                       (ulong)keyid[1],p);
667             m_free(p);
668         }
669         if( is_status_enabled() ) {
670             char *us = get_long_user_id_string( keyid );
671             write_status_text( STATUS_IMPORTED, us );
672             m_free(us);
673             print_import_ok (pk,NULL, 1);
674         }
675         stats->imported++;
676         if( is_RSA( pk->pubkey_algo ) )
677             stats->imported_rsa++;
678         new_key = 1;
679     }
680     else { /* merge */
681         KEYDB_HANDLE hd;
682         int n_uids, n_sigs, n_subk;
683
684         /* Compare the original against the new key; just to be sure nothing
685          * weird is going on */
686         if( cmp_public_keys( pk_orig, pk ) ) {
687             log_error( _("key %08lX: doesn't match our copy\n"),
688                                                           (ulong)keyid[1]);
689             goto leave;
690         }
691
692         /* now read the original keyblock */
693         hd = keydb_new (0);
694         {
695             byte afp[MAX_FINGERPRINT_LEN];
696             size_t an;
697
698             fingerprint_from_pk (pk_orig, afp, &an);
699             while (an < MAX_FINGERPRINT_LEN) 
700                 afp[an++] = 0;
701             rc = keydb_search_fpr (hd, afp);
702         }
703         if( rc ) {
704             log_error (_("key %08lX: can't locate original keyblock: %s\n"),
705                                      (ulong)keyid[1], g10_errstr(rc));
706             keydb_release (hd);
707             goto leave;
708         }
709         rc = keydb_get_keyblock (hd, &keyblock_orig );
710         if (rc) {
711             log_error (_("key %08lX: can't read original keyblock: %s\n"),
712                                             (ulong)keyid[1], g10_errstr(rc));
713             keydb_release (hd);
714             goto leave;
715         }
716
717         collapse_uids( &keyblock );
718         /* and try to merge the block */
719         clear_kbnode_flags( keyblock_orig );
720         clear_kbnode_flags( keyblock );
721         n_uids = n_sigs = n_subk = 0;
722         rc = merge_blocks( fname, keyblock_orig, keyblock,
723                                 keyid, &n_uids, &n_sigs, &n_subk );
724         if( rc ) {
725             keydb_release (hd);
726             goto leave;
727         }
728         if( n_uids || n_sigs || n_subk ) {
729             mod_key = 1;
730             /* keyblock_orig has been updated; write */
731             rc = keydb_update_keyblock (hd, keyblock_orig);
732             if (rc)
733                 log_error (_("error writing keyring `%s': %s\n"),
734                              keydb_get_resource_name (hd), g10_errstr(rc) );
735             else if(non_self)
736               revalidation_mark ();
737
738             /* we are ready */
739             if( !opt.quiet ) {
740                 char *p=get_user_id_printable(keyid);
741                 if( n_uids == 1 )
742                     log_info( _("key %08lX: \"%s\" 1 new user ID\n"),
743                                              (ulong)keyid[1], p);
744                 else if( n_uids )
745                     log_info( _("key %08lX: \"%s\" %d new user IDs\n"),
746                                              (ulong)keyid[1], p, n_uids );
747                 if( n_sigs == 1 )
748                     log_info( _("key %08lX: \"%s\" 1 new signature\n"),
749                                              (ulong)keyid[1], p);
750                 else if( n_sigs )
751                     log_info( _("key %08lX: \"%s\" %d new signatures\n"),
752                                              (ulong)keyid[1], p, n_sigs );
753                 if( n_subk == 1 )
754                     log_info( _("key %08lX: \"%s\" 1 new subkey\n"),
755                                              (ulong)keyid[1], p);
756                 else if( n_subk )
757                     log_info( _("key %08lX: \"%s\" %d new subkeys\n"),
758                                              (ulong)keyid[1], p, n_subk );
759                 m_free(p);
760             }
761
762             stats->n_uids +=n_uids;
763             stats->n_sigs +=n_sigs;
764             stats->n_subk +=n_subk;
765
766             if (is_status_enabled ()) 
767                  print_import_ok (pk, NULL,
768                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
769         }
770         else {
771              if (is_status_enabled ()) 
772                   print_import_ok (pk, NULL, 0);
773         
774             if( !opt.quiet ) {
775                 char *p=get_user_id_printable(keyid);
776                 log_info( _("key %08lX: \"%s\" not changed\n"),
777                           (ulong)keyid[1],p);
778                 m_free(p);
779             }
780             stats->unchanged++;
781         }
782         keydb_release (hd); hd = NULL;
783     }
784
785   leave:
786     release_kbnode( keyblock_orig );
787     free_public_key( pk_orig );
788
789     revocation_present(keyblock);
790
791     return rc;
792 }
793
794 /* Walk a secret keyblock and produce a public keyblock out of it. */
795 static KBNODE
796 sec_to_pub_keyblock(KBNODE sec_keyblock)
797 {
798   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
799
800   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
801     {
802       KBNODE pubnode;
803
804       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
805          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
806         {
807           /* Make a public key.  We only need to convert enough to
808              write the keyblock out. */
809
810           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
811           PACKET *pkt=m_alloc_clear(sizeof(PACKET));
812           PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
813           int n;
814
815           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
816             pkt->pkttype=PKT_PUBLIC_KEY;
817           else
818             pkt->pkttype=PKT_PUBLIC_SUBKEY;
819
820           pkt->pkt.public_key=pk;
821
822           pk->version=sk->version;
823           pk->timestamp=sk->timestamp;
824           pk->expiredate=sk->expiredate;
825           pk->pubkey_algo=sk->pubkey_algo;
826
827           n=pubkey_get_npkey(pk->pubkey_algo);
828           if(n==0)
829             pk->pkey[0]=mpi_copy(sk->skey[0]);
830           else
831             {
832               int i;
833
834               for(i=0;i<n;i++)
835                 pk->pkey[i]=mpi_copy(sk->skey[i]);
836             }
837
838           pubnode=new_kbnode(pkt);
839         }
840       else
841         {
842           pubnode=clone_kbnode(secnode);
843         }
844
845       if(pub_keyblock==NULL)
846         pub_keyblock=pubnode;
847       else
848         add_kbnode(pub_keyblock,pubnode);
849     }
850
851   return pub_keyblock;
852 }
853
854 /****************
855  * Ditto for secret keys.  Handling is simpler than for public keys.
856  * We allow secret key importing only when allow is true, this is so
857  * that a secret key can not be imported accidently and thereby tampering
858  * with the trust calculation.
859  */
860 static int
861 import_secret_one( const char *fname, KBNODE keyblock, 
862                    struct stats_s *stats, unsigned int options)
863 {
864     PKT_secret_key *sk;
865     KBNODE node, uidnode;
866     u32 keyid[2];
867     int rc = 0;
868
869     /* get the key and print some info about it */
870     node = find_kbnode( keyblock, PKT_SECRET_KEY );
871     if( !node )
872         BUG();
873
874     sk = node->pkt->pkt.secret_key;
875     keyid_from_sk( sk, keyid );
876     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
877
878     if( opt.verbose ) {
879         log_info( "sec  %4u%c/%08lX %s   ",
880                   nbits_from_sk( sk ),
881                   pubkey_letter( sk->pubkey_algo ),
882                   (ulong)keyid[1], datestr_from_sk(sk) );
883         if( uidnode )
884             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
885                                        uidnode->pkt->pkt.user_id->len );
886         putc('\n', stderr);
887     }
888     stats->secret_read++;
889
890     if( !uidnode ) {
891         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
892         return 0;
893     }
894
895     if(sk->protect.algo>110)
896       {
897         log_error(_("key %08lX: secret key with invalid cipher %d "
898                     "- skipped\n"),(ulong)keyid[1],sk->protect.algo);
899         return 0;
900       }
901
902     clear_kbnode_flags( keyblock );
903
904     /* do we have this key already in one of our secrings ? */
905     rc = seckey_available( keyid );
906     if( rc == G10ERR_NO_SECKEY && !opt.merge_only ) { /* simply insert this key */
907         KEYDB_HANDLE hd = keydb_new (1);
908
909         /* get default resource */
910         rc = keydb_locate_writable (hd, NULL);
911         if (rc) {
912             log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
913             keydb_release (hd);
914             return G10ERR_GENERAL;
915         }
916         rc = keydb_insert_keyblock (hd, keyblock );
917         if (rc)
918             log_error (_("error writing keyring `%s': %s\n"),
919                        keydb_get_resource_name (hd), g10_errstr(rc) );
920         keydb_release (hd);
921         /* we are ready */
922         if( !opt.quiet )
923             log_info( _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
924         stats->secret_imported++;
925         if (is_status_enabled ()) 
926              print_import_ok (NULL, sk, 1|16);
927
928         if(options&IMPORT_SK2PK)
929           {
930             /* Try and make a public key out of this. */
931
932             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
933             import_one(fname,pub_keyblock,stats,opt.import_options);
934             release_kbnode(pub_keyblock);
935           }
936
937     }
938     else if( !rc ) { /* we can't merge secret keys */
939         log_error( _("key %08lX: already in secret keyring\n"),
940                                                         (ulong)keyid[1]);
941         stats->secret_dups++;
942         if (is_status_enabled ()) 
943              print_import_ok (NULL, sk, 16);
944
945         /* TODO: if we ever do merge secret keys, make sure to handle
946            the sec_to_pub_keyblock feature as well. */
947     }
948     else
949         log_error( _("key %08lX: secret key not found: %s\n"),
950                                 (ulong)keyid[1], g10_errstr(rc));
951
952     return rc;
953 }
954
955
956 /****************
957  * Import a revocation certificate; this is a single signature packet.
958  */
959 static int
960 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
961 {
962     PKT_public_key *pk=NULL;
963     KBNODE onode, keyblock = NULL;
964     KEYDB_HANDLE hd = NULL;
965     u32 keyid[2];
966     int rc = 0;
967
968     assert( !node->next );
969     assert( node->pkt->pkttype == PKT_SIGNATURE );
970     assert( node->pkt->pkt.signature->sig_class == 0x20 );
971
972     keyid[0] = node->pkt->pkt.signature->keyid[0];
973     keyid[1] = node->pkt->pkt.signature->keyid[1];
974
975     pk = m_alloc_clear( sizeof *pk );
976     rc = get_pubkey( pk, keyid );
977     if( rc == G10ERR_NO_PUBKEY ) {
978         log_error( _("key %08lX: no public key - "
979                      "can't apply revocation certificate\n"), (ulong)keyid[1]);
980         rc = 0;
981         goto leave;
982     }
983     else if( rc ) {
984         log_error( _("key %08lX: public key not found: %s\n"),
985                                        (ulong)keyid[1], g10_errstr(rc));
986         goto leave;
987     }
988
989     /* read the original keyblock */
990     hd = keydb_new (0);
991     {
992         byte afp[MAX_FINGERPRINT_LEN];
993         size_t an;
994         
995         fingerprint_from_pk (pk, afp, &an);
996         while (an < MAX_FINGERPRINT_LEN) 
997             afp[an++] = 0;
998         rc = keydb_search_fpr (hd, afp);
999     }
1000     if (rc) {
1001         log_error (_("key %08lX: can't locate original keyblock: %s\n"),
1002                    (ulong)keyid[1], g10_errstr(rc));
1003         goto leave;
1004     }
1005     rc = keydb_get_keyblock (hd, &keyblock );
1006     if (rc) {
1007         log_error (_("key %08lX: can't read original keyblock: %s\n"),
1008                    (ulong)keyid[1], g10_errstr(rc));
1009         goto leave;
1010     }
1011
1012
1013     /* it is okay, that node is not in keyblock because
1014      * check_key_signature works fine for sig_class 0x20 in this
1015      * special case. */
1016     rc = check_key_signature( keyblock, node, NULL);
1017     if( rc ) {
1018         log_error( _("key %08lX: invalid revocation certificate"
1019                   ": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
1020         goto leave;
1021     }
1022
1023
1024     /* check whether we already have this */
1025     for(onode=keyblock->next; onode; onode=onode->next ) {
1026         if( onode->pkt->pkttype == PKT_USER_ID )
1027             break;
1028         else if( onode->pkt->pkttype == PKT_SIGNATURE
1029                  && !cmp_signatures(node->pkt->pkt.signature,
1030                                     onode->pkt->pkt.signature))
1031           {
1032             rc = 0;
1033             goto leave; /* yes, we already know about it */
1034           }
1035     }
1036
1037
1038     /* insert it */
1039     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1040
1041     /* and write the keyblock back */
1042     rc = keydb_update_keyblock (hd, keyblock );
1043     if (rc)
1044         log_error (_("error writing keyring `%s': %s\n"),
1045                    keydb_get_resource_name (hd), g10_errstr(rc) );
1046     keydb_release (hd); hd = NULL;
1047     /* we are ready */
1048     if( !opt.quiet ) {
1049         char *p=get_user_id_printable (keyid);
1050         log_info( _("key %08lX: \"%s\" revocation certificate imported\n"),
1051                                         (ulong)keyid[1],p);
1052         m_free(p);
1053     }
1054     stats->n_revoc++;
1055
1056     /* If the key we just revoked was ultimately trusted, remove its
1057        ultimate trust.  This doesn't stop the user from putting the
1058        ultimate trust back, but is a reasonable solution for now. */
1059     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1060       clear_ownertrusts(pk);
1061
1062     revalidation_mark ();
1063
1064   leave:
1065     keydb_release (hd);
1066     release_kbnode( keyblock );
1067     free_public_key( pk );
1068     return rc;
1069 }
1070
1071
1072 /****************
1073  * loop over the keyblock and check all self signatures.
1074  * Mark all user-ids with a self-signature by setting flag bit 0.
1075  * Mark all user-ids with an invalid self-signature by setting bit 1.
1076  * This works also for subkeys, here the subkey is marked.  Invalid or
1077  * extra subkey sigs (binding or revocation) are marked for deletion.
1078  * non_self is set to true if there are any sigs other than self-sigs
1079  * in this keyblock.
1080  */
1081 static int
1082 chk_self_sigs( const char *fname, KBNODE keyblock,
1083                PKT_public_key *pk, u32 *keyid, int *non_self )
1084 {
1085     KBNODE n,knode=NULL;
1086     PKT_signature *sig;
1087     int rc;
1088     u32 bsdate=0,rsdate=0;
1089     KBNODE bsnode=NULL,rsnode=NULL;
1090
1091     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1092       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1093         {
1094           knode=n;
1095           bsdate=0;
1096           rsdate=0;
1097           bsnode=NULL;
1098           rsnode=NULL;
1099           continue;
1100         }
1101       else if( n->pkt->pkttype != PKT_SIGNATURE )
1102             continue;
1103         sig = n->pkt->pkt.signature;
1104         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1105
1106           /* This just caches the sigs for later use.  That way we
1107              import a fully-cached key which speeds things up. */
1108           if(!opt.no_sig_cache)
1109             check_key_signature(keyblock,n,NULL);
1110
1111             if( (sig->sig_class&~3) == 0x10 ) {
1112                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1113                 if( !unode )  {
1114                     log_error( _("key %08lX: no user ID for signature\n"),
1115                                             (ulong)keyid[1]);
1116                     return -1;  /* the complete keyblock is invalid */
1117                 }
1118
1119                 /* If it hasn't been marked valid yet, keep trying */
1120                 if(!(unode->flag&1)) {
1121                   rc = check_key_signature( keyblock, n, NULL);
1122                   if( rc )
1123                     {
1124                       if( opt.verbose )
1125                         {
1126                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1127                                       strlen(unode->pkt->pkt.user_id->name),0);
1128                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1129                                     _("key %08lX: unsupported public key "
1130                                       "algorithm on user id \"%s\"\n"):
1131                                     _("key %08lX: invalid self-signature "
1132                                       "on user id \"%s\"\n"),
1133                                     (ulong)keyid[1],p);
1134                           m_free(p);
1135                         }
1136                     }
1137                   else
1138                     unode->flag |= 1; /* mark that signature checked */
1139                 }
1140             }
1141             else if( sig->sig_class == 0x18 ) {
1142               /* Note that this works based solely on the timestamps
1143                  like the rest of gpg.  If the standard gets
1144                  revocation targets, this may need to be revised. */
1145
1146                 if( !knode ) {
1147                     if(opt.verbose)
1148                       log_info( _("key %08lX: no subkey for key binding\n"),
1149                                 (ulong)keyid[1]);
1150                     n->flag |= 4; /* delete this */
1151                 }
1152                 else {
1153                   rc = check_key_signature( keyblock, n, NULL);
1154                   if( rc ) {
1155                     if(opt.verbose)
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                         if(opt.verbose)
1171                           log_info(_("key %08lX: removed multiple subkey "
1172                                      "binding\n"),(ulong)keyid[1]);
1173                       }
1174
1175                       bsnode=n;
1176                       bsdate=sig->timestamp;
1177                     }
1178                     else
1179                       n->flag|=4; /* older */
1180                   }
1181                 }
1182             }
1183             else if( sig->sig_class == 0x28 ) {
1184               /* We don't actually mark the subkey as revoked right
1185                  now, so just check that the revocation sig is the
1186                  most recent valid one.  Note that we don't care if
1187                  the binding sig is newer than the revocation sig.
1188                  See the comment in getkey.c:merge_selfsigs_subkey for
1189                  more */
1190                 if( !knode ) {
1191                     if(opt.verbose)
1192                       log_info( _("key %08lX: no subkey for key revocation\n"),
1193                                 (ulong)keyid[1]);
1194                     n->flag |= 4; /* delete this */
1195                 }
1196                 else {
1197                   rc = check_key_signature( keyblock, n, NULL);
1198                   if( rc ) {
1199                       if(opt.verbose)
1200                         log_info(rc == G10ERR_PUBKEY_ALGO ?
1201                             _("key %08lX: unsupported public key algorithm\n"):
1202                             _("key %08lX: invalid subkey revocation\n"),
1203                             (ulong)keyid[1]);
1204
1205                       n->flag|=4;
1206                   }
1207                   else {
1208                     /* It's valid, so is it newer? */
1209                     if(sig->timestamp>=rsdate) {
1210                       if(rsnode) {
1211                         rsnode->flag|=4; /* Delete the last revocation
1212                                             sig since this one is
1213                                             newer */
1214                         if(opt.verbose)
1215                           log_info(_("key %08lX: removed multiple subkey "
1216                                      "revocation\n"),(ulong)keyid[1]);
1217                       }
1218
1219                       rsnode=n;
1220                       rsdate=sig->timestamp;
1221                     }
1222                     else
1223                       n->flag|=4; /* older */
1224                   }
1225                 }
1226             }
1227         }
1228         else
1229           *non_self=1;
1230     }
1231
1232     return 0;
1233 }
1234
1235 /****************
1236  * delete all parts which are invalid and those signatures whose
1237  * public key algorithm is not available in this implemenation;
1238  * but consider RSA as valid, because parse/build_packets knows
1239  * about it.
1240  * returns: true if at least one valid user-id is left over.
1241  */
1242 static int
1243 delete_inv_parts( const char *fname, KBNODE keyblock,
1244                   u32 *keyid, unsigned int options)
1245 {
1246     KBNODE node;
1247     int nvalid=0, uid_seen=0, subkey_seen=0;
1248
1249     for(node=keyblock->next; node; node = node->next ) {
1250         if( node->pkt->pkttype == PKT_USER_ID ) {
1251             uid_seen = 1;
1252             if( (node->flag & 2) || !(node->flag & 1) ) {
1253                 if( opt.verbose ) {
1254                     log_info( _("key %08lX: skipped user ID '"),
1255                                                          (ulong)keyid[1]);
1256                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
1257                                        node->pkt->pkt.user_id->len );
1258                     fputs("'\n", stderr );
1259                 }
1260                 delete_kbnode( node ); /* the user-id */
1261                 /* and all following packets up to the next user-id */
1262                 while( node->next
1263                        && node->next->pkt->pkttype != PKT_USER_ID
1264                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1265                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1266                     delete_kbnode( node->next );
1267                     node = node->next;
1268                 }
1269             }
1270             else
1271                 nvalid++;
1272         }
1273         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1274                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1275             if( (node->flag & 2) || !(node->flag & 1) ) {
1276                 if( opt.verbose ) {
1277                     log_info( _("key %08lX: skipped subkey\n"),
1278                                                          (ulong)keyid[1]);
1279                 }
1280                 delete_kbnode( node ); /* the subkey */
1281                 /* and all following signature packets */
1282                 while( node->next
1283                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1284                     delete_kbnode( node->next );
1285                     node = node->next;
1286                 }
1287             }
1288             else
1289               subkey_seen = 1;
1290         }
1291         else if( node->pkt->pkttype == PKT_SIGNATURE
1292                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1293                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1294             delete_kbnode( node ); /* build_packet() can't handle this */
1295         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1296                  !node->pkt->pkt.signature->flags.exportable &&
1297                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1298                  seckey_available( node->pkt->pkt.signature->keyid ) ) {
1299             /* here we violate the rfc a bit by still allowing
1300              * to import non-exportable signature when we have the
1301              * the secret key used to create this signature - it
1302              * seems that this makes sense */
1303             if(opt.verbose)
1304               log_info( _("key %08lX: non exportable signature "
1305                           "(class %02x) - skipped\n"),
1306                         (ulong)keyid[1], node->pkt->pkt.signature->sig_class );
1307             delete_kbnode( node );
1308         }
1309         else if( node->pkt->pkttype == PKT_SIGNATURE
1310                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1311             if( uid_seen ) {
1312                 if(opt.verbose)
1313                   log_info( _("key %08lX: revocation certificate "
1314                               "at wrong place - skipped\n"), (ulong)keyid[1]);
1315                 delete_kbnode( node );
1316             }
1317             else {
1318               /* If the revocation cert is from a different key than
1319                  the one we're working on don't check it - it's
1320                  probably from a revocation key and won't be
1321                  verifiable with this key anyway. */
1322
1323               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1324                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1325                 {
1326                   int rc = check_key_signature( keyblock, node, NULL);
1327                   if( rc )
1328                     {
1329                       if(opt.verbose)
1330                         log_info( _("key %08lX: invalid revocation "
1331                                     "certificate: %s - skipped\n"),
1332                                   (ulong)keyid[1], g10_errstr(rc));
1333                       delete_kbnode( node );
1334                     }
1335                 }
1336             }
1337         }
1338         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1339                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1340                   node->pkt->pkt.signature->sig_class == 0x28) &&
1341                  !subkey_seen ) {
1342             if(opt.verbose)
1343               log_info( _("key %08lX: subkey signature "
1344                           "in wrong place - skipped\n"), (ulong)keyid[1]);
1345             delete_kbnode( node );
1346         }
1347         else if( node->pkt->pkttype == PKT_SIGNATURE
1348                  && !IS_CERT(node->pkt->pkt.signature))
1349           {
1350             if(opt.verbose)
1351               log_info(_("key %08lX: unexpected signature class (0x%02X) -"
1352                          " skipped\n"),(ulong)keyid[1],
1353                        node->pkt->pkt.signature->sig_class);
1354             delete_kbnode(node);
1355           }
1356         else if( (node->flag & 4) ) /* marked for deletion */
1357             delete_kbnode( node );
1358     }
1359
1360     /* note: because keyblock is the public key, it is never marked
1361      * for deletion and so keyblock cannot change */
1362     commit_kbnode( &keyblock );
1363     return nvalid;
1364 }
1365
1366
1367 /****************
1368  * It may happen that the imported keyblock has duplicated user IDs.
1369  * We check this here and collapse those user IDs together with their
1370  * sigs into one.
1371  * Returns: True if the keyblock hash changed.
1372  */
1373 int
1374 collapse_uids( KBNODE *keyblock )
1375 {
1376     KBNODE n, n2;
1377     int in_uid;
1378     int any=0;
1379     u32 kid1;
1380
1381   restart:
1382     for( n = *keyblock; n; n = n->next ) {
1383         if( n->pkt->pkttype != PKT_USER_ID )
1384             continue;
1385         for( n2 = n->next; n2; n2 = n2->next ) {
1386             if( n2->pkt->pkttype == PKT_USER_ID
1387                 && !cmp_user_ids( n->pkt->pkt.user_id,
1388                                   n2->pkt->pkt.user_id ) ) {
1389                 /* found a duplicate */
1390                 any = 1;
1391                 if( !n2->next
1392                     || n2->next->pkt->pkttype == PKT_USER_ID
1393                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1394                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1395                     /* no more signatures: delete the user ID
1396                      * and start over */
1397                     remove_kbnode( keyblock, n2 );
1398                 }
1399                 else {
1400                     /* The simple approach: Move one signature and
1401                      * then start over to delete the next one :-( */
1402                     move_kbnode( keyblock, n2->next, n->next );
1403                 }
1404                 goto restart;
1405             }
1406         }
1407     }
1408     if( !any )
1409         return 0;
1410
1411   restart_sig:
1412     /* now we may have duplicate signatures on one user ID: fix this */
1413     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1414         if( n->pkt->pkttype == PKT_USER_ID )
1415             in_uid = 1;
1416         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1417                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1418             in_uid = 0;
1419         else if( in_uid ) {
1420             n2 = n;
1421             do {
1422                 KBNODE ncmp = NULL;
1423                 for( ; n2; n2 = n2->next ) {
1424                     if(    n2->pkt->pkttype == PKT_USER_ID
1425                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1426                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1427                         break;
1428                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1429                         ;
1430                     else if( !ncmp )
1431                         ncmp = n2;
1432                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1433                                                 n2->pkt->pkt.signature )) {
1434                         remove_kbnode( keyblock, n2 );
1435                         goto restart_sig;
1436                     }
1437                 }
1438                 n2 = ncmp? ncmp->next : NULL;
1439             } while( n2 );
1440         }
1441     }
1442
1443     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1444         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
1445     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1446         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
1447     else
1448         kid1 = 0;
1449     if(!opt.quiet)
1450       log_info(_("key %08lX: duplicated user ID detected - merged\n"),
1451                (ulong)kid1);
1452
1453     return 1;
1454 }
1455
1456 /* Check for a 0x20 revocation from a revocation key that is not
1457    present.  This gets called without the benefit of merge_xxxx so you
1458    can't rely on pk->revkey and friends. */
1459 static void
1460 revocation_present(KBNODE keyblock)
1461 {
1462   KBNODE onode,inode;
1463   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1464
1465   for(onode=keyblock->next;onode;onode=onode->next)
1466     {
1467       /* If we reach user IDs, we're done. */
1468       if(onode->pkt->pkttype==PKT_USER_ID)
1469         break;
1470
1471       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1472          onode->pkt->pkt.signature->sig_class==0x1F &&
1473          onode->pkt->pkt.signature->revkey)
1474         {
1475           int idx;
1476           PKT_signature *sig=onode->pkt->pkt.signature;
1477
1478           for(idx=0;idx<sig->numrevkeys;idx++)
1479             {
1480               u32 keyid[2];
1481
1482               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1483                                      MAX_FINGERPRINT_LEN,keyid);
1484
1485               for(inode=keyblock->next;inode;inode=inode->next)
1486                 {
1487                   /* If we reach user IDs, we're done. */
1488                   if(inode->pkt->pkttype==PKT_USER_ID)
1489                     break;
1490
1491                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1492                      inode->pkt->pkt.signature->sig_class==0x20 &&
1493                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1494                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1495                     {
1496                       /* Okay, we have a revocation key, and a
1497                          revocation issued by it.  Do we have the key
1498                          itself? */
1499                       int rc;
1500
1501                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1502                                                    MAX_FINGERPRINT_LEN);
1503                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1504                         {
1505                           /* No, so try and get it */
1506                           if(opt.keyserver_scheme &&
1507                              opt.keyserver_options.auto_key_retrieve)
1508                             {
1509                               log_info(_("WARNING: key %08lX may be revoked: "
1510                                          "fetching revocation key %08lX\n"),
1511                                        (ulong)keyid_from_pk(pk,NULL),
1512                                        (ulong)keyid[1]);
1513                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1514                                                       MAX_FINGERPRINT_LEN);
1515
1516                               /* Do we have it now? */
1517                               rc=get_pubkey_byfprint_fast (NULL,
1518                                                      sig->revkey[idx]->fpr,
1519                                                      MAX_FINGERPRINT_LEN);
1520                             }
1521
1522                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1523                             log_info(_("WARNING: key %08lX may be revoked: "
1524                                        "revocation key %08lX not present.\n"),
1525                                      (ulong)keyid_from_pk(pk,NULL),
1526                                      (ulong)keyid[1]);
1527                         }
1528                     }
1529                 }
1530             }
1531         }
1532     }
1533 }
1534
1535 /****************
1536  * compare and merge the blocks
1537  *
1538  * o compare the signatures: If we already have this signature, check
1539  *   that they compare okay; if not, issue a warning and ask the user.
1540  * o Simply add the signature.  Can't verify here because we may not have
1541  *   the signature's public key yet; verification is done when putting it
1542  *   into the trustdb, which is done automagically as soon as this pubkey
1543  *   is used.
1544  * Note: We indicate newly inserted packets with flag bit 0
1545  */
1546 static int
1547 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1548               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1549 {
1550     KBNODE onode, node;
1551     int rc, found;
1552
1553     /* 1st: handle revocation certificates */
1554     for(node=keyblock->next; node; node=node->next ) {
1555         if( node->pkt->pkttype == PKT_USER_ID )
1556             break;
1557         else if( node->pkt->pkttype == PKT_SIGNATURE
1558                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1559             /* check whether we already have this */
1560             found = 0;
1561             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1562                 if( onode->pkt->pkttype == PKT_USER_ID )
1563                     break;
1564                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1565                          && onode->pkt->pkt.signature->sig_class == 0x20
1566                          && !cmp_signatures(onode->pkt->pkt.signature,
1567                                             node->pkt->pkt.signature))
1568                   {
1569                     found = 1;
1570                     break;
1571                   }
1572             }
1573             if( !found ) {
1574                 KBNODE n2 = clone_kbnode(node);
1575                 insert_kbnode( keyblock_orig, n2, 0 );
1576                 n2->flag |= 1;
1577                 ++*n_sigs;
1578                 if(!opt.quiet)
1579                   {
1580                     char *p=get_user_id_printable (keyid);
1581                     log_info(_("key %08lX: \"%s\" revocation "
1582                                "certificate added\n"), (ulong)keyid[1],p);
1583                     m_free(p);
1584                   }
1585             }
1586         }
1587     }
1588
1589     /* 2nd: merge in any direct key (0x1F) sigs */
1590     for(node=keyblock->next; node; node=node->next ) {
1591         if( node->pkt->pkttype == PKT_USER_ID )
1592             break;
1593         else if( node->pkt->pkttype == PKT_SIGNATURE
1594                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1595             /* check whether we already have this */
1596             found = 0;
1597             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1598                 if( onode->pkt->pkttype == PKT_USER_ID )
1599                     break;
1600                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1601                          && onode->pkt->pkt.signature->sig_class == 0x1F
1602                          && !cmp_signatures(onode->pkt->pkt.signature,
1603                                             node->pkt->pkt.signature)) {
1604                     found = 1;
1605                     break;
1606                 }
1607             }
1608             if( !found ) {
1609                 KBNODE n2 = clone_kbnode(node);
1610                 insert_kbnode( keyblock_orig, n2, 0 );
1611                 n2->flag |= 1;
1612                 ++*n_sigs;
1613                 if(!opt.quiet)
1614                   log_info( _("key %08lX: direct key signature added\n"),
1615                             (ulong)keyid[1]);
1616             }
1617         }
1618     }
1619
1620     /* 3rd: try to merge new certificates in */
1621     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1622         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1623             /* find the user id in the imported keyblock */
1624             for(node=keyblock->next; node; node=node->next )
1625                 if( node->pkt->pkttype == PKT_USER_ID
1626                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1627                                           node->pkt->pkt.user_id ) )
1628                     break;
1629             if( node ) { /* found: merge */
1630                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1631                 if( rc )
1632                     return rc;
1633             }
1634         }
1635     }
1636
1637     /* 4th: add new user-ids */
1638     for(node=keyblock->next; node; node=node->next ) {
1639         if( node->pkt->pkttype == PKT_USER_ID) {
1640             /* do we have this in the original keyblock */
1641             for(onode=keyblock_orig->next; onode; onode=onode->next )
1642                 if( onode->pkt->pkttype == PKT_USER_ID
1643                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1644                                       node->pkt->pkt.user_id ) )
1645                     break;
1646             if( !onode ) { /* this is a new user id: append */
1647                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1648                 if( rc )
1649                     return rc;
1650                 ++*n_uids;
1651             }
1652         }
1653     }
1654
1655     /* 5th: add new subkeys */
1656     for(node=keyblock->next; node; node=node->next ) {
1657         onode = NULL;
1658         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1659             /* do we have this in the original keyblock? */
1660             for(onode=keyblock_orig->next; onode; onode=onode->next )
1661                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1662                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1663                                          node->pkt->pkt.public_key ) )
1664                     break;
1665             if( !onode ) { /* this is a new subkey: append */
1666                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1667                 if( rc )
1668                     return rc;
1669                 ++*n_subk;
1670             }
1671         }
1672         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1673             /* do we have this in the original keyblock? */
1674             for(onode=keyblock_orig->next; onode; onode=onode->next )
1675                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1676                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1677                                          node->pkt->pkt.secret_key ) )
1678                     break;
1679             if( !onode ) { /* this is a new subkey: append */
1680                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1681                 if( rc )
1682                     return rc;
1683                 ++*n_subk;
1684             }
1685         }
1686     }
1687
1688     /* 6th: merge subkey certificates */
1689     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1690         if( !(onode->flag & 1)
1691             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1692                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1693             /* find the subkey in the imported keyblock */
1694             for(node=keyblock->next; node; node=node->next ) {
1695                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1696                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1697                                           node->pkt->pkt.public_key ) )
1698                     break;
1699                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1700                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1701                                           node->pkt->pkt.secret_key ) )
1702                     break;
1703             }
1704             if( node ) { /* found: merge */
1705                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1706                 if( rc )
1707                     return rc;
1708             }
1709         }
1710     }
1711
1712
1713     return 0;
1714 }
1715
1716
1717 /****************
1718  * append the userid starting with NODE and all signatures to KEYBLOCK.
1719  */
1720 static int
1721 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1722                                           const char *fname, u32 *keyid )
1723 {
1724     KBNODE n, n_where=NULL;
1725
1726     assert(node->pkt->pkttype == PKT_USER_ID );
1727
1728     /* find the position */
1729     for( n = keyblock; n; n_where = n, n = n->next ) {
1730         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1731             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1732             break;
1733     }
1734     if( !n )
1735         n_where = NULL;
1736
1737     /* and append/insert */
1738     while( node ) {
1739         /* we add a clone to the original keyblock, because this
1740          * one is released first */
1741         n = clone_kbnode(node);
1742         if( n_where ) {
1743             insert_kbnode( n_where, n, 0 );
1744             n_where = n;
1745         }
1746         else
1747             add_kbnode( keyblock, n );
1748         n->flag |= 1;
1749         node->flag |= 1;
1750         if( n->pkt->pkttype == PKT_SIGNATURE )
1751             ++*n_sigs;
1752
1753         node = node->next;
1754         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1755             break;
1756     }
1757
1758     return 0;
1759 }
1760
1761
1762 /****************
1763  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1764  * (how should we handle comment packets here?)
1765  */
1766 static int
1767 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1768                                     const char *fname, u32 *keyid )
1769 {
1770     KBNODE n, n2;
1771     int found=0;
1772
1773     assert(dst->pkt->pkttype == PKT_USER_ID );
1774     assert(src->pkt->pkttype == PKT_USER_ID );
1775
1776     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1777         if( n->pkt->pkttype != PKT_SIGNATURE )
1778             continue;
1779         if( n->pkt->pkt.signature->sig_class == 0x18
1780             || n->pkt->pkt.signature->sig_class == 0x28 )
1781             continue; /* skip signatures which are only valid on subkeys */
1782         found = 0;
1783         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
1784           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
1785             {
1786               found++;
1787               break;
1788             }
1789         if( !found ) {
1790             /* This signature is new or newer, append N to DST.
1791              * We add a clone to the original keyblock, because this
1792              * one is released first */
1793             n2 = clone_kbnode(n);
1794             insert_kbnode( dst, n2, PKT_SIGNATURE );
1795             n2->flag |= 1;
1796             n->flag |= 1;
1797             ++*n_sigs;
1798         }
1799     }
1800
1801     return 0;
1802 }
1803
1804 /****************
1805  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1806  */
1807 static int
1808 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1809                                     const char *fname, u32 *keyid )
1810 {
1811     KBNODE n, n2;
1812     int found=0;
1813
1814     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1815            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1816
1817     for(n=src->next; n ; n = n->next ) {
1818         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1819             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1820             break;
1821         if( n->pkt->pkttype != PKT_SIGNATURE )
1822             continue;
1823         found = 0;
1824         for(n2=dst->next; n2; n2 = n2->next){
1825             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1826                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1827                 break;
1828             if( n2->pkt->pkttype == PKT_SIGNATURE
1829                 && n->pkt->pkt.signature->keyid[0]
1830                    == n2->pkt->pkt.signature->keyid[0]
1831                 && n->pkt->pkt.signature->keyid[1]
1832                    == n2->pkt->pkt.signature->keyid[1]
1833                 && n->pkt->pkt.signature->timestamp
1834                    <= n2->pkt->pkt.signature->timestamp
1835                 && n->pkt->pkt.signature->sig_class
1836                    == n2->pkt->pkt.signature->sig_class ) {
1837                 found++;
1838                 break;
1839             }
1840         }
1841         if( !found ) {
1842             /* This signature is new or newer, append N to DST.
1843              * We add a clone to the original keyblock, because this
1844              * one is released first */
1845             n2 = clone_kbnode(n);
1846             insert_kbnode( dst, n2, PKT_SIGNATURE );
1847             n2->flag |= 1;
1848             n->flag |= 1;
1849             ++*n_sigs;
1850         }
1851     }
1852
1853     return 0;
1854 }
1855
1856 /****************
1857  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1858  * Mark all new and copied packets by setting flag bit 0.
1859  */
1860 static int
1861 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1862                                           const char *fname, u32 *keyid )
1863 {
1864     KBNODE n;
1865
1866     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1867            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1868
1869     while(  node ) {
1870         /* we add a clone to the original keyblock, because this
1871          * one is released first */
1872         n = clone_kbnode(node);
1873         add_kbnode( keyblock, n );
1874         n->flag |= 1;
1875         node->flag |= 1;
1876         if( n->pkt->pkttype == PKT_SIGNATURE )
1877             ++*n_sigs;
1878
1879         node = node->next;
1880         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1881             break;
1882     }
1883
1884     return 0;
1885 }