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