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