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