* import.c (delete_inv_parts): Discard subkey signatures (0x18 and 0x28)
[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 "status.h"
38 #include "keyserver-internal.h"
39
40 struct stats_s {
41     ulong count;
42     ulong no_user_id;
43     ulong imported;
44     ulong imported_rsa;
45     ulong n_uids;
46     ulong n_sigs;
47     ulong n_subk;
48     ulong unchanged;
49     ulong n_revoc;
50     ulong secret_read;
51     ulong secret_imported;
52     ulong secret_dups;
53     ulong skipped_new_keys;
54 };
55
56
57 static int import( IOBUF inp, int fast, const char* fname,
58                    struct stats_s *stats );
59 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
60 static void revocation_present(KBNODE keyblock);
61 static void remove_bad_stuff (KBNODE keyblock);
62 static int import_one( const char *fname, KBNODE keyblock, int fast,
63                        struct stats_s *stats);
64 static int import_secret_one( const char *fname, KBNODE keyblock,
65                               struct stats_s *stats );
66 static int import_revoke_cert( const char *fname, KBNODE node,
67                                struct stats_s *stats);
68 static int chk_self_sigs( const char *fname, KBNODE keyblock,
69                           PKT_public_key *pk, u32 *keyid );
70 static int delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid );
71 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
72                          KBNODE keyblock, u32 *keyid,
73                          int *n_uids, int *n_sigs, int *n_subk );
74 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
75                              const char *fname, u32 *keyid );
76 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
77                              const char *fname, u32 *keyid );
78 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
79                              const char *fname, u32 *keyid );
80 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
81                              const char *fname, u32 *keyid );
82
83
84 int
85 parse_import_options(char *str,unsigned int *options)
86 {
87   char *tok;
88   int hit=0;
89   struct
90   {
91     char *name;
92     unsigned int bit;
93   } import_opts[]=
94     {
95       {"allow-local-sigs",IMPORT_ALLOW_LOCAL_SIGS},
96       {NULL,0}
97     };
98
99   while((tok=strsep(&str," ,")))
100     {
101       int i,rev=0;
102
103       if(ascii_memcasecmp("no-",tok,3)==0)
104         rev=1;
105
106       for(i=0;import_opts[i].name;i++)
107         {
108           if(ascii_strcasecmp(import_opts[i].name,tok)==0)
109             {
110               if(rev)
111                 *options&=~import_opts[i].bit;
112               else
113                 *options|=import_opts[i].bit;
114               hit=1;
115               break;
116             }
117         }
118
119       if(!hit && !import_opts[i].name)
120         return 0;
121     }
122
123   return hit;
124 }
125
126 void *
127 import_new_stats_handle (void)
128 {
129     return m_alloc_clear ( sizeof (struct stats_s) );
130 }
131
132 void
133 import_release_stats_handle (void *p)
134 {
135     m_free (p);
136 }
137
138 /****************
139  * Import the public keys from the given filename. Input may be armored.
140  * This function rejects all keys which are not validly self signed on at
141  * least one userid. Only user ids which are self signed will be imported.
142  * Other signatures are not checked.
143  *
144  * Actually this function does a merge. It works like this:
145  *
146  *  - get the keyblock
147  *  - check self-signatures and remove all userids and their signatures
148  *    without/invalid self-signatures.
149  *  - reject the keyblock, if we have no valid userid.
150  *  - See whether we have this key already in one of our pubrings.
151  *    If not, simply add it to the default keyring.
152  *  - Compare the key and the self-signatures of the new and the one in
153  *    our keyring.  If they are different something weird is going on;
154  *    ask what to do.
155  *  - See whether we have only non-self-signature on one user id; if not
156  *    ask the user what to do.
157  *  - compare the signatures: If we already have this signature, check
158  *    that they compare okay; if not, issue a warning and ask the user.
159  *    (consider looking at the timestamp and use the newest?)
160  *  - Simply add the signature.  Can't verify here because we may not have
161  *    the signature's public key yet; verification is done when putting it
162  *    into the trustdb, which is done automagically as soon as this pubkey
163  *    is used.
164  *  - Proceed with next signature.
165  *
166  *  Key revocation certificates have special handling.
167  *
168  */
169 void
170 import_keys( char **fnames, int nnames, int fast, void *stats_handle )
171 {
172     int i;
173     struct stats_s *stats = stats_handle;
174
175     if (!stats)
176         stats = import_new_stats_handle ();
177
178     if( !fnames && !nnames )
179         nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
180
181     for(i=0; i < nnames; i++ ) {
182         const char *fname = fnames? fnames[i] : NULL;
183         IOBUF inp = iobuf_open(fname);
184         if( !fname )
185             fname = "[stdin]";
186         if( !inp )
187             log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
188         else {
189             int rc = import( inp, fast, fname, stats );
190             iobuf_close(inp);
191             if( rc )
192                 log_error("import from `%s' failed: %s\n", fname,
193                                                            g10_errstr(rc) );
194         }
195         if( !fname )
196             break;
197     }
198     if (!stats_handle) {
199         import_print_stats (stats);
200         import_release_stats_handle (stats);
201     }
202
203 }
204
205 int
206 import_keys_stream( IOBUF inp, int fast, void *stats_handle )
207 {
208     int rc = 0;
209     struct stats_s *stats = stats_handle;
210
211     if (!stats)
212         stats = import_new_stats_handle ();
213
214     rc = import( inp, fast, "[stream]", stats);
215     if (!stats_handle) {
216         import_print_stats (stats);
217         import_release_stats_handle (stats);
218     }
219
220     return rc;
221 }
222
223 static int
224 import( IOBUF inp, int fast, const char* fname, struct stats_s *stats )
225 {
226     PACKET *pending_pkt = NULL;
227     KBNODE keyblock;
228     int rc = 0;
229
230     getkey_disable_caches();
231
232     if( !opt.no_armor ) { /* armored reading is not disabled */
233         armor_filter_context_t *afx = m_alloc_clear( sizeof *afx );
234         afx->only_keyblocks = 1;
235         iobuf_push_filter2( inp, armor_filter, afx, 1 );
236     }
237
238     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
239         remove_bad_stuff (keyblock);
240         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
241             rc = import_one( fname, keyblock, fast, stats );
242         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
243                 rc = import_secret_one( fname, keyblock, stats );
244         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
245                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
246             rc = import_revoke_cert( fname, keyblock, stats );
247         else {
248             log_info( _("skipping block of type %d\n"),
249                                             keyblock->pkt->pkttype );
250         }
251         release_kbnode(keyblock);
252         if( rc )
253             break;
254         if( !(++stats->count % 100) && !opt.quiet )
255             log_info(_("%lu keys so far processed\n"), stats->count );
256     }
257     if( rc == -1 )
258         rc = 0;
259     else if( rc && rc != G10ERR_INV_KEYRING )
260         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
261
262     return rc;
263 }
264
265
266 void
267 import_print_stats (void *hd)
268 {
269     struct stats_s *stats = hd;
270
271     if( !opt.quiet ) {
272         log_info(_("Total number processed: %lu\n"), stats->count );
273         if( stats->skipped_new_keys )
274             log_info(_("      skipped new keys: %lu\n"),
275                                                 stats->skipped_new_keys );
276         if( stats->no_user_id )
277             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
278         if( stats->imported || stats->imported_rsa ) {
279             log_info(_("              imported: %lu"), stats->imported );
280             if( stats->imported_rsa )
281                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
282             putc('\n', stderr);
283         }
284         if( stats->unchanged )
285             log_info(_("             unchanged: %lu\n"), stats->unchanged );
286         if( stats->n_uids )
287             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
288         if( stats->n_subk )
289             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
290         if( stats->n_sigs )
291             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
292         if( stats->n_revoc )
293             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
294         if( stats->secret_read )
295             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
296         if( stats->secret_imported )
297             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
298         if( stats->secret_dups )
299             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
300     }
301
302     if( is_status_enabled() ) {
303         char buf[13*20];
304         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
305                 stats->count,
306                 stats->no_user_id,
307                 stats->imported,
308                 stats->imported_rsa,
309                 stats->unchanged,
310                 stats->n_uids,
311                 stats->n_subk,
312                 stats->n_sigs,
313                 stats->n_revoc,
314                 stats->secret_read,
315                 stats->secret_imported,
316                 stats->secret_dups,
317                 stats->skipped_new_keys );
318         write_status_text( STATUS_IMPORT_RES, buf );
319     }
320 }
321
322
323 /****************
324  * Read the next keyblock from stream A.
325  * PENDING_PKT should be initialzed to NULL
326  * and not chnaged form the caller.
327  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
328  */
329 static int
330 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
331 {
332     int rc;
333     PACKET *pkt;
334     KBNODE root = NULL;
335     int in_cert;
336
337     if( *pending_pkt ) {
338         root = new_kbnode( *pending_pkt );
339         *pending_pkt = NULL;
340         in_cert = 1;
341     }
342     else
343         in_cert = 0;
344     pkt = m_alloc( sizeof *pkt );
345     init_packet(pkt);
346     while( (rc=parse_packet(a, pkt)) != -1 ) {
347         if( rc ) {  /* ignore errors */
348             if( rc != G10ERR_UNKNOWN_PACKET ) {
349                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
350                 rc = G10ERR_INV_KEYRING;
351                 goto ready;
352             }
353             free_packet( pkt );
354             init_packet(pkt);
355             continue;
356         }
357
358         if( !root && pkt->pkttype == PKT_SIGNATURE
359                   && pkt->pkt.signature->sig_class == 0x20 ) {
360             /* this is a revocation certificate which is handled
361              * in a special way */
362             root = new_kbnode( pkt );
363             pkt = NULL;
364             goto ready;
365         }
366
367         /* make a linked list of all packets */
368         switch( pkt->pkttype ) {
369           case PKT_COMPRESSED:
370             if( pkt->pkt.compressed->algorithm < 1
371                 || pkt->pkt.compressed->algorithm > 2 ) {
372                 rc = G10ERR_COMPR_ALGO;
373                 goto ready;
374             }
375             {
376                 compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
377                 cfx->algo = pkt->pkt.compressed->algorithm;
378                 pkt->pkt.compressed->buf = NULL;
379                 iobuf_push_filter2( a, compress_filter, cfx, 1 );
380             }
381             free_packet( pkt );
382             init_packet(pkt);
383             break;
384
385           case PKT_RING_TRUST:
386             /* skip those packets */
387             free_packet( pkt );
388             init_packet(pkt);
389             break;
390
391           case PKT_PUBLIC_KEY:
392           case PKT_SECRET_KEY:
393             if( in_cert ) { /* store this packet */
394                 *pending_pkt = pkt;
395                 pkt = NULL;
396                 goto ready;
397             }
398             in_cert = 1;
399           default:
400             if( in_cert ) {
401                 if( !root )
402                     root = new_kbnode( pkt );
403                 else
404                     add_kbnode( root, new_kbnode( pkt ) );
405                 pkt = m_alloc( sizeof *pkt );
406             }
407             init_packet(pkt);
408             break;
409         }
410     }
411   ready:
412     if( rc == -1 && root )
413         rc = 0;
414
415     if( rc )
416         release_kbnode( root );
417     else
418         *ret_root = root;
419     free_packet( pkt );
420     m_free( pkt );
421     return rc;
422 }
423
424
425 static void
426 remove_bad_stuff (KBNODE keyblock)
427 {
428     KBNODE node;
429
430     for (node=keyblock; node; node = node->next ) {
431         if( node->pkt->pkttype == PKT_SIGNATURE ) {
432             /* delete the subpackets we used to use for the
433                verification cache */
434             delete_sig_subpkt (node->pkt->pkt.signature->unhashed,
435                                SIGSUBPKT_PRIV_VERIFY_CACHE);
436         }
437     }
438 }
439
440 /* Clean the subkeys on a pk so that they each have at most 1 binding
441    sig and at most 1 revocation sig.  This works based solely on the
442    timestamps like the rest of gpg.  If the standard does get
443    revocation targets, this may need to be revised. */
444
445 static int
446 clean_subkeys(KBNODE keyblock,u32 *keyid)
447 {
448   int removed=0;
449   KBNODE node,sknode=keyblock;
450
451   while((sknode=find_kbnode(sknode,PKT_PUBLIC_SUBKEY)))
452     {
453       KBNODE bsnode=NULL,rsnode=NULL;
454       u32 bsdate=0,rsdate=0;
455
456       sknode=sknode->next;
457
458       for(node=sknode;node;node=node->next)
459         {
460           if(node->pkt->pkttype==PKT_SIGNATURE)
461             {
462               PKT_signature *sig=node->pkt->pkt.signature;
463
464               /* We're only interested in valid sigs */
465               if(check_key_signature(keyblock,node,NULL))
466                 continue;
467
468               if(IS_SUBKEY_SIG(sig) && bsdate<=sig->timestamp)
469                 {
470                   bsnode=node;
471                   bsdate=sig->timestamp;
472                 }
473               else if(IS_SUBKEY_REV(sig) && rsdate<=sig->timestamp)
474                 {
475                   rsnode=node;
476                   rsdate=sig->timestamp;
477                 }
478               /* If it's not a subkey sig or rev, then it shouldn't be
479                  here so ignore it. */
480             }
481           else
482             break;
483         }
484
485       /* We now know the most recent binding sig and revocation sig
486          (if any).  If the binding sig is more recent than the
487          revocation sig, strip everything but the binding sig.  If the
488          revocation sig is more recent than the binding sig, strip
489          everything but the binding sig and the revocation sig. */
490
491       if(bsdate>=rsdate)
492         {
493           rsnode=NULL;
494           rsdate=0;
495         }
496
497      for(node=sknode;node;node=node->next)
498         {
499           if(node->pkt->pkttype==PKT_SIGNATURE)
500             {
501               PKT_signature *sig=node->pkt->pkt.signature;
502
503               if(IS_SUBKEY_SIG(sig) && node!=bsnode)
504                 {
505                   delete_kbnode(node);
506                   removed++;
507                 }
508               else if(IS_SUBKEY_REV(sig) && node!=rsnode)
509                 {
510                   delete_kbnode(node);
511                   removed++;
512                 }
513             }
514           else
515             break;
516         }
517     }
518
519   if(removed)
520     {
521       log_info(_("key %08lX: removed multiple subkey binding\n"),
522                (ulong)keyid[1]);
523       commit_kbnode(&keyblock);
524     }
525
526   return removed;
527 }
528
529
530 /****************
531  * Try to import one keyblock.  Return an error only in serious cases, but
532  * never for an invalid keyblock.  It uses log_error to increase the
533  * internal errorcount, so that invalid input can be detected by programs
534  * which called g10.
535  */
536 static int
537 import_one( const char *fname, KBNODE keyblock, int fast,
538             struct stats_s *stats )
539 {
540     PKT_public_key *pk;
541     PKT_public_key *pk_orig;
542     KBNODE node, uidnode;
543     KBNODE keyblock_orig = NULL;
544     u32 keyid[2];
545     int rc = 0;
546     int new_key = 0;
547     int mod_key = 0;
548
549     /* get the key and print some info about it */
550     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
551     if( !node )
552         BUG();
553
554     pk = node->pkt->pkt.public_key;
555     keyid_from_pk( pk, keyid );
556     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
557
558     if( opt.verbose ) {
559         log_info( "pub  %4u%c/%08lX %s   ",
560                   nbits_from_pk( pk ),
561                   pubkey_letter( pk->pubkey_algo ),
562                   (ulong)keyid[1], datestr_from_pk(pk) );
563         if( uidnode )
564             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
565                                        uidnode->pkt->pkt.user_id->len );
566         putc('\n', stderr);
567     }
568     if( !uidnode ) {
569         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
570         return 0;
571     }
572
573     clear_kbnode_flags( keyblock );
574     rc = chk_self_sigs( fname, keyblock , pk, keyid );
575     if( rc )
576         return rc== -1? 0:rc;
577
578     /* If we allow such a thing, mark unsigned uids as valid */
579     if( opt.allow_non_selfsigned_uid )
580       for( node=keyblock; node; node = node->next )
581         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
582           {
583             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
584                                       node->pkt->pkt.user_id->len,0);
585             node->flag |= 1;
586             log_info( _("key %08lX: accepted non self-signed user ID '%s'\n"),
587                       (ulong)keyid[1],user);
588             m_free(user);
589           }
590
591     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
592         if( !opt.quiet ) {
593             log_info( _("key %08lX: no valid user IDs\n"),
594                                                         (ulong)keyid[1]);
595             log_info(_("this may be caused by a missing self-signature\n"));
596         }
597         stats->no_user_id++;
598         return 0;
599     }
600
601     /* do we have this key already in one of our pubrings ? */
602     pk_orig = m_alloc_clear( sizeof *pk_orig );
603     rc = get_pubkey( pk_orig, keyid );
604     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY ) {
605         log_error( _("key %08lX: public key not found: %s\n"),
606                                 (ulong)keyid[1], g10_errstr(rc));
607     }
608     else if ( rc && opt.merge_only ) {
609         if( opt.verbose )
610             log_info( _("key %08lX: new key - skipped\n"), (ulong)keyid[1] );
611         rc = 0;
612         fast = 1; /* so that we don't get into the trustdb update */
613         stats->skipped_new_keys++;
614     }
615     else if( rc ) { /* insert this key */
616         KEYDB_HANDLE hd = keydb_new (0);
617
618         rc = keydb_locate_writable (hd, NULL);
619         if (rc) {
620             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
621             keydb_release (hd);
622             return G10ERR_GENERAL;
623         }
624         if( opt.verbose > 1 )
625             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
626         clean_subkeys(keyblock,keyid);
627         rc = keydb_insert_keyblock (hd, keyblock );
628         if (rc)
629            log_error (_("error writing keyring `%s': %s\n"),
630                        keydb_get_resource_name (hd), g10_errstr(rc));
631         else
632            revalidation_mark ();
633         keydb_release (hd);
634
635         /* we are ready */
636         if( !opt.quiet ) {
637             char *p=get_user_id_native(keyid);
638             log_info( _("key %08lX: public key \"%s\" imported\n"),
639                       (ulong)keyid[1],p);
640             m_free(p);
641         }
642         if( is_status_enabled() ) {
643             char *us = get_long_user_id_string( keyid );
644             write_status_text( STATUS_IMPORTED, us );
645             m_free(us);
646         }
647         stats->imported++;
648         if( is_RSA( pk->pubkey_algo ) )
649             stats->imported_rsa++;
650         new_key = 1;
651     }
652     else { /* merge */
653         KEYDB_HANDLE hd;
654         int n_uids, n_sigs, n_subk;
655
656         /* Compare the original against the new key; just to be sure nothing
657          * weird is going on */
658         if( cmp_public_keys( pk_orig, pk ) ) {
659             log_error( _("key %08lX: doesn't match our copy\n"),
660                                                           (ulong)keyid[1]);
661             goto leave;
662         }
663
664         /* now read the original keyblock */
665         hd = keydb_new (0);
666         {
667             byte afp[MAX_FINGERPRINT_LEN];
668             size_t an;
669
670             fingerprint_from_pk (pk_orig, afp, &an);
671             while (an < MAX_FINGERPRINT_LEN) 
672                 afp[an++] = 0;
673             rc = keydb_search_fpr (hd, afp);
674         }
675         if( rc ) {
676             log_error (_("key %08lX: can't locate original keyblock: %s\n"),
677                                      (ulong)keyid[1], g10_errstr(rc));
678             keydb_release (hd);
679             goto leave;
680         }
681         rc = keydb_get_keyblock (hd, &keyblock_orig );
682         if (rc) {
683             log_error (_("key %08lX: can't read original keyblock: %s\n"),
684                                             (ulong)keyid[1], g10_errstr(rc));
685             keydb_release (hd);
686             goto leave;
687         }
688
689         collapse_uids( &keyblock );
690         /* and try to merge the block */
691         clear_kbnode_flags( keyblock_orig );
692         clear_kbnode_flags( keyblock );
693         n_uids = n_sigs = n_subk = 0;
694         rc = merge_blocks( fname, keyblock_orig, keyblock,
695                                 keyid, &n_uids, &n_sigs, &n_subk );
696         if( rc ) {
697             keydb_release (hd);
698             goto leave;
699         }
700         if( n_uids || n_sigs || n_subk ) {
701             mod_key = 1;
702             /* keyblock_orig has been updated; write */
703             n_sigs-=clean_subkeys(keyblock_orig,keyid);
704             rc = keydb_update_keyblock (hd, keyblock_orig);
705             if (rc)
706                 log_error (_("error writing keyring `%s': %s\n"),
707                              keydb_get_resource_name (hd), g10_errstr(rc) );
708             else
709               revalidation_mark ();
710
711             /* we are ready */
712             if( !opt.quiet ) {
713                 char *p=get_user_id_native(keyid);
714                 if( n_uids == 1 )
715                     log_info( _("key %08lX: \"%s\" 1 new user ID\n"),
716                                              (ulong)keyid[1], p);
717                 else if( n_uids )
718                     log_info( _("key %08lX: \"%s\" %d new user IDs\n"),
719                                              (ulong)keyid[1], p, n_uids );
720                 if( n_sigs == 1 )
721                     log_info( _("key %08lX: \"%s\" 1 new signature\n"),
722                                              (ulong)keyid[1], p);
723                 else if( n_sigs )
724                     log_info( _("key %08lX: \"%s\" %d new signatures\n"),
725                                              (ulong)keyid[1], p, n_sigs );
726                 if( n_subk == 1 )
727                     log_info( _("key %08lX: \"%s\" 1 new subkey\n"),
728                                              (ulong)keyid[1], p);
729                 else if( n_subk )
730                     log_info( _("key %08lX: \"%s\" %d new subkeys\n"),
731                                              (ulong)keyid[1], p, n_subk );
732                 m_free(p);
733             }
734
735             stats->n_uids +=n_uids;
736             stats->n_sigs +=n_sigs;
737             stats->n_subk +=n_subk;
738         }
739         else {
740             if( !opt.quiet ) {
741                 char *p=get_user_id_native(keyid);
742                 log_info( _("key %08lX: \"%s\" not changed\n"),
743                           (ulong)keyid[1],p);
744                 m_free(p);
745             }
746             stats->unchanged++;
747         }
748         keydb_release (hd); hd = NULL;
749     }
750
751   leave:
752     release_kbnode( keyblock_orig );
753     free_public_key( pk_orig );
754
755     revocation_present(keyblock);
756
757     return rc;
758 }
759
760
761 /****************
762  * Ditto for secret keys.  Handling is simpler than for public keys.
763  * We allow secret key importing only when allow is true, this is so
764  * that a secret key can not be imported accidently and thereby tampering
765  * with the trust calculation.
766  */
767 static int
768 import_secret_one( const char *fname, KBNODE keyblock, 
769                    struct stats_s *stats)
770 {
771     PKT_secret_key *sk;
772     KBNODE node, uidnode;
773     u32 keyid[2];
774     int rc = 0;
775
776     /* get the key and print some info about it */
777     node = find_kbnode( keyblock, PKT_SECRET_KEY );
778     if( !node )
779         BUG();
780
781     sk = node->pkt->pkt.secret_key;
782     keyid_from_sk( sk, keyid );
783     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
784
785     if( opt.verbose ) {
786         log_info( "sec  %4u%c/%08lX %s   ",
787                   nbits_from_sk( sk ),
788                   pubkey_letter( sk->pubkey_algo ),
789                   (ulong)keyid[1], datestr_from_sk(sk) );
790         if( uidnode )
791             print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
792                                        uidnode->pkt->pkt.user_id->len );
793         putc('\n', stderr);
794     }
795     stats->secret_read++;
796
797     if( !uidnode ) {
798         log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
799         return 0;
800     }
801
802     clear_kbnode_flags( keyblock );
803
804     /* do we have this key already in one of our secrings ? */
805     rc = seckey_available( keyid );
806     if( rc == G10ERR_NO_SECKEY && !opt.merge_only ) { /* simply insert this key */
807         KEYDB_HANDLE hd = keydb_new (1);
808
809         /* get default resource */
810         rc = keydb_locate_writable (hd, NULL);
811         if (rc) {
812             log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
813             keydb_release (hd);
814             return G10ERR_GENERAL;
815         }
816         rc = keydb_insert_keyblock (hd, keyblock );
817         if (rc)
818             log_error (_("error writing keyring `%s': %s\n"),
819                        keydb_get_resource_name (hd), g10_errstr(rc) );
820         keydb_release (hd);
821         /* we are ready */
822         if( !opt.quiet )
823             log_info( _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
824         stats->secret_imported++;
825     }
826     else if( !rc ) { /* we can't merge secret keys */
827         log_error( _("key %08lX: already in secret keyring\n"),
828                                                         (ulong)keyid[1]);
829         stats->secret_dups++;
830     }
831     else
832         log_error( _("key %08lX: secret key not found: %s\n"),
833                                 (ulong)keyid[1], g10_errstr(rc));
834
835     return rc;
836 }
837
838
839 /****************
840  * Import a revocation certificate; this is a single signature packet.
841  */
842 static int
843 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
844 {
845     PKT_public_key *pk=NULL;
846     KBNODE onode, keyblock = NULL;
847     KEYDB_HANDLE hd = NULL;
848     u32 keyid[2];
849     int rc = 0;
850
851     assert( !node->next );
852     assert( node->pkt->pkttype == PKT_SIGNATURE );
853     assert( node->pkt->pkt.signature->sig_class == 0x20 );
854
855     keyid[0] = node->pkt->pkt.signature->keyid[0];
856     keyid[1] = node->pkt->pkt.signature->keyid[1];
857
858     pk = m_alloc_clear( sizeof *pk );
859     rc = get_pubkey( pk, keyid );
860     if( rc == G10ERR_NO_PUBKEY ) {
861         log_info( _("key %08lX: no public key - "
862                  "can't apply revocation certificate\n"), (ulong)keyid[1]);
863         rc = 0;
864         goto leave;
865     }
866     else if( rc ) {
867         log_error( _("key %08lX: public key not found: %s\n"),
868                                        (ulong)keyid[1], g10_errstr(rc));
869         goto leave;
870     }
871
872     /* read the original keyblock */
873     hd = keydb_new (0);
874     {
875         byte afp[MAX_FINGERPRINT_LEN];
876         size_t an;
877         
878         fingerprint_from_pk (pk, afp, &an);
879         while (an < MAX_FINGERPRINT_LEN) 
880             afp[an++] = 0;
881         rc = keydb_search_fpr (hd, afp);
882     }
883     if (rc) {
884         log_error (_("key %08lX: can't locate original keyblock: %s\n"),
885                    (ulong)keyid[1], g10_errstr(rc));
886         goto leave;
887     }
888     rc = keydb_get_keyblock (hd, &keyblock );
889     if (rc) {
890         log_error (_("key %08lX: can't read original keyblock: %s\n"),
891                    (ulong)keyid[1], g10_errstr(rc));
892         goto leave;
893     }
894
895
896     /* it is okay, that node is not in keyblock because
897      * check_key_signature works fine for sig_class 0x20 in this
898      * special case. */
899     rc = check_key_signature( keyblock, node, NULL);
900     if( rc ) {
901         log_error( _("key %08lX: invalid revocation certificate"
902                   ": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
903         goto leave;
904     }
905
906
907     /* check whether we already have this */
908     for(onode=keyblock->next; onode; onode=onode->next ) {
909         if( onode->pkt->pkttype == PKT_USER_ID )
910             break;
911         else if( onode->pkt->pkttype == PKT_SIGNATURE
912                  && onode->pkt->pkt.signature->sig_class == 0x20
913                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
914                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
915             rc = 0;
916             goto leave; /* yes, we already know about it */
917         }
918     }
919
920
921     /* insert it */
922     insert_kbnode( keyblock, clone_kbnode(node), 0 );
923
924     /* and write the keyblock back */
925     rc = keydb_update_keyblock (hd, keyblock );
926     if (rc)
927         log_error (_("error writing keyring `%s': %s\n"),
928                    keydb_get_resource_name (hd), g10_errstr(rc) );
929     keydb_release (hd); hd = NULL;
930     /* we are ready */
931     if( !opt.quiet ) {
932         char *p=get_user_id_native(keyid);
933         log_info( _("key %08lX: \"%s\" revocation certificate imported\n"),
934                                         (ulong)keyid[1],p);
935         m_free(p);
936     }
937     stats->n_revoc++;
938     revalidation_mark ();
939
940   leave:
941     keydb_release (hd);
942     release_kbnode( keyblock );
943     free_public_key( pk );
944     return rc;
945 }
946
947
948 /****************
949  * loop over the keyblock and check all self signatures.
950  * Mark all user-ids with a self-signature by setting flag bit 0.
951  * Mark all user-ids with an invalid self-signature by setting bit 1.
952  * This works also for subkeys, here the subkey is marked.
953  */
954 static int
955 chk_self_sigs( const char *fname, KBNODE keyblock,
956                PKT_public_key *pk, u32 *keyid )
957 {
958     KBNODE n;
959     PKT_signature *sig;
960     int rc;
961
962     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
963         if( n->pkt->pkttype != PKT_SIGNATURE )
964             continue;
965         sig = n->pkt->pkt.signature;
966         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
967             if( (sig->sig_class&~3) == 0x10 ) {
968                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
969                 if( !unode )  {
970                     log_error( _("key %08lX: no user ID for signature\n"),
971                                             (ulong)keyid[1]);
972                     return -1;  /* the complete keyblock is invalid */
973                 }
974
975                 /* If it hasn't been marked valid yet, keep trying */
976                 if(!(unode->flag&1)) {
977                   rc = check_key_signature( keyblock, n, NULL);
978                   if( rc )
979                     {
980                       char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
981                                       strlen(unode->pkt->pkt.user_id->name),0);
982                       log_info( rc == G10ERR_PUBKEY_ALGO ?
983                                 _("key %08lX: unsupported public key "
984                                   "algorithm on user id \"%s\"\n"):
985                                 _("key %08lX: invalid self-signature "
986                                   "on user id \"%s\"\n"),
987                                 (ulong)keyid[1],p);
988                       m_free(p);
989                     }
990                   else
991                     unode->flag |= 1; /* mark that signature checked */
992                 }
993             }
994             else if( sig->sig_class == 0x18 ) {
995                 KBNODE knode = find_prev_kbnode( keyblock,
996                                                  n, PKT_PUBLIC_SUBKEY );
997                 if( !knode )
998                     knode = find_prev_kbnode( keyblock,
999                                                  n, PKT_SECRET_SUBKEY );
1000
1001                 if( !knode ) {
1002                     log_info( _("key %08lX: no subkey for key binding\n"),
1003                                             (ulong)keyid[1]);
1004                     n->flag |= 4; /* delete this */
1005                 }
1006                 else {
1007                   /* If it hasn't been marked valid yet, keep trying */
1008                   if(!(knode->flag&1)) {
1009                     rc = check_key_signature( keyblock, n, NULL);
1010                     if( rc )
1011                         log_info(  rc == G10ERR_PUBKEY_ALGO ?
1012                            _("key %08lX: unsupported public key algorithm\n"):
1013                            _("key %08lX: invalid subkey binding\n"),
1014                                          (ulong)keyid[1]);
1015                     else
1016                       knode->flag |= 1; /* mark that signature checked */
1017                   }
1018                 }
1019             }
1020         }
1021     }
1022     return 0;
1023 }
1024
1025 /****************
1026  * delete all parts which are invalid and those signatures whose
1027  * public key algorithm is not available in this implemenation;
1028  * but consider RSA as valid, because parse/build_packets knows
1029  * about it.
1030  * returns: true if at least one valid user-id is left over.
1031  */
1032 static int
1033 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
1034 {
1035     KBNODE node;
1036     int nvalid=0, uid_seen=0, subkey_seen=0;
1037
1038     for(node=keyblock->next; node; node = node->next ) {
1039         if( node->pkt->pkttype == PKT_USER_ID ) {
1040             uid_seen = 1;
1041             if( (node->flag & 2) || !(node->flag & 1) ) {
1042                 if( opt.verbose ) {
1043                     log_info( _("key %08lX: skipped user ID '"),
1044                                                          (ulong)keyid[1]);
1045                     print_utf8_string( stderr, node->pkt->pkt.user_id->name,
1046                                        node->pkt->pkt.user_id->len );
1047                     fputs("'\n", stderr );
1048                 }
1049                 delete_kbnode( node ); /* the user-id */
1050                 /* and all following packets up to the next user-id */
1051                 while( node->next
1052                        && node->next->pkt->pkttype != PKT_USER_ID
1053                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1054                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1055                     delete_kbnode( node->next );
1056                     node = node->next;
1057                 }
1058             }
1059             else
1060                 nvalid++;
1061         }
1062         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1063                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1064             if( (node->flag & 2) || !(node->flag & 1) ) {
1065                 if( opt.verbose ) {
1066                     log_info( _("key %08lX: skipped subkey\n"),
1067                                                          (ulong)keyid[1]);
1068                 }
1069                 delete_kbnode( node ); /* the subkey */
1070                 /* and all following signature packets */
1071                 while( node->next
1072                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1073                     delete_kbnode( node->next );
1074                     node = node->next;
1075                 }
1076             }
1077             else
1078               subkey_seen = 1;
1079         }
1080         else if( node->pkt->pkttype == PKT_SIGNATURE
1081                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1082                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1083             delete_kbnode( node ); /* build_packet() can't handle this */
1084         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1085                  !node->pkt->pkt.signature->flags.exportable &&
1086                  !(opt.import_options&IMPORT_ALLOW_LOCAL_SIGS) &&
1087                  seckey_available( node->pkt->pkt.signature->keyid ) ) {
1088             /* here we violate the rfc a bit by still allowing
1089              * to import non-exportable signature when we have the
1090              * the secret key used to create this signature - it
1091              * seems that this makes sense */
1092             log_info( _("key %08lX: non exportable signature "
1093                                     "(class %02x) - skipped\n"),
1094                                     (ulong)keyid[1],
1095                                      node->pkt->pkt.signature->sig_class );
1096             delete_kbnode( node );
1097         }
1098         else if( node->pkt->pkttype == PKT_SIGNATURE
1099                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1100             if( uid_seen ) {
1101                 log_error( _("key %08lX: revocation certificate "
1102                                      "at wrong place - skipped\n"),
1103                                     (ulong)keyid[1]);
1104                 delete_kbnode( node );
1105             }
1106             else {
1107               /* If the revocation cert is from a different key than
1108                  the one we're working on don't check it - it's
1109                  probably from a revocation key and won't be
1110                  verifiable with this key anyway. */
1111
1112               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1113                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1114                 {
1115                   int rc = check_key_signature( keyblock, node, NULL);
1116                   if( rc )
1117                     {
1118                       log_error( _("key %08lX: invalid revocation "
1119                                    "certificate: %s - skipped\n"),
1120                                  (ulong)keyid[1], g10_errstr(rc));
1121                       delete_kbnode( node );
1122                     }
1123                 }
1124             }
1125         }
1126         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1127                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1128                   node->pkt->pkt.signature->sig_class == 0x28) &&
1129                  !subkey_seen ) {
1130             log_error( _("key %08lX: subkey signature "
1131                          "in wrong place - skipped\n"),
1132                        (ulong)keyid[1]);
1133             delete_kbnode( node );
1134         }
1135         else if( (node->flag & 4) ) /* marked for deletion */
1136             delete_kbnode( node );
1137     }
1138
1139     /* note: because keyblock is the public key, it is never marked
1140      * for deletion and so keyblock cannot change */
1141     commit_kbnode( &keyblock );
1142     return nvalid;
1143 }
1144
1145
1146 /****************
1147  * It may happen that the imported keyblock has duplicated user IDs.
1148  * We check this here and collapse those user IDs together with their
1149  * sigs into one.
1150  * Returns: True if the keyblock hash changed.
1151  */
1152 int
1153 collapse_uids( KBNODE *keyblock )
1154 {
1155     KBNODE n, n2;
1156     int in_uid;
1157     int any=0;
1158     u32 kid1;
1159
1160   restart:
1161     for( n = *keyblock; n; n = n->next ) {
1162         if( n->pkt->pkttype != PKT_USER_ID )
1163             continue;
1164         for( n2 = n->next; n2; n2 = n2->next ) {
1165             if( n2->pkt->pkttype == PKT_USER_ID
1166                 && !cmp_user_ids( n->pkt->pkt.user_id,
1167                                   n2->pkt->pkt.user_id ) ) {
1168                 /* found a duplicate */
1169                 any = 1;
1170                 if( !n2->next
1171                     || n2->next->pkt->pkttype == PKT_USER_ID
1172                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1173                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1174                     /* no more signatures: delete the user ID
1175                      * and start over */
1176                     remove_kbnode( keyblock, n2 );
1177                 }
1178                 else {
1179                     /* The simple approach: Move one signature and
1180                      * then start over to delete the next one :-( */
1181                     move_kbnode( keyblock, n2->next, n->next );
1182                 }
1183                 goto restart;
1184             }
1185         }
1186     }
1187     if( !any )
1188         return 0;
1189
1190   restart_sig:
1191     /* now we may have duplicate signatures on one user ID: fix this */
1192     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1193         if( n->pkt->pkttype == PKT_USER_ID )
1194             in_uid = 1;
1195         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1196                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1197             in_uid = 0;
1198         else if( in_uid ) {
1199             n2 = n;
1200             do {
1201                 KBNODE ncmp = NULL;
1202                 for( ; n2; n2 = n2->next ) {
1203                     if(    n2->pkt->pkttype == PKT_USER_ID
1204                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1205                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1206                         break;
1207                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1208                         ;
1209                     else if( !ncmp )
1210                         ncmp = n2;
1211                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1212                                                 n2->pkt->pkt.signature )) {
1213                         remove_kbnode( keyblock, n2 );
1214                         goto restart_sig;
1215                     }
1216                 }
1217                 n2 = ncmp? ncmp->next : NULL;
1218             } while( n2 );
1219         }
1220     }
1221
1222     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1223         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
1224     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1225         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
1226     else
1227         kid1 = 0;
1228     log_info(_("key %08lX: duplicated user ID detected - merged\n"),
1229                                                                  (ulong)kid1);
1230
1231     return 1;
1232 }
1233
1234 /* Check for a 0x20 revocation from a revocation key that is not
1235    present.  This gets called without the benefit of merge_xxxx so you
1236    can't rely on pk->revkey and friends. */
1237 static void
1238 revocation_present(KBNODE keyblock)
1239 {
1240   KBNODE onode,inode;
1241   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1242
1243   for(onode=keyblock->next;onode;onode=onode->next)
1244     {
1245       /* If we reach user IDs, we're done. */
1246       if(onode->pkt->pkttype==PKT_USER_ID)
1247         break;
1248
1249       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1250          onode->pkt->pkt.signature->sig_class==0x1F &&
1251          onode->pkt->pkt.signature->revkey)
1252         {
1253           int idx;
1254           PKT_signature *sig=onode->pkt->pkt.signature;
1255
1256           for(idx=0;idx<sig->numrevkeys;idx++)
1257             {
1258               u32 keyid[2];
1259
1260               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1261                                      MAX_FINGERPRINT_LEN,keyid);
1262
1263               for(inode=keyblock->next;inode;inode=inode->next)
1264                 {
1265                   /* If we reach user IDs, we're done. */
1266                   if(inode->pkt->pkttype==PKT_USER_ID)
1267                     break;
1268
1269                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1270                      inode->pkt->pkt.signature->sig_class==0x20 &&
1271                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1272                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1273                     {
1274                       /* Okay, we have a revocation key, and a
1275                          revocation issued by it.  Do we have the key
1276                          itself? */
1277                       int rc;
1278
1279                       rc=get_pubkey_byfprint(NULL,sig->revkey[idx]->fpr,
1280                                              MAX_FINGERPRINT_LEN);
1281                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1282                         {
1283                           /* No, so try and get it */
1284                           if(opt.keyserver_scheme &&
1285                              opt.keyserver_options.auto_key_retrieve)
1286                             {
1287                               log_info(_("Warning: key %08lX may be revoked: "
1288                                          "fetching revocation key %08lX\n"),
1289                                        (ulong)keyid_from_pk(pk,NULL),
1290                                        (ulong)keyid[1]);
1291                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1292                                                       MAX_FINGERPRINT_LEN);
1293
1294                               /* Do we have it now? */
1295                               rc=get_pubkey_byfprint(NULL,
1296                                                      sig->revkey[idx]->fpr,
1297                                                      MAX_FINGERPRINT_LEN);
1298                             }
1299
1300                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1301                             log_info(_("Warning: key %08lX may be revoked: "
1302                                        "revocation key %08lX not present.\n"),
1303                                      (ulong)keyid_from_pk(pk,NULL),
1304                                      (ulong)keyid[1]);
1305                         }
1306                     }
1307                 }
1308             }
1309         }
1310     }
1311 }
1312
1313 /****************
1314  * compare and merge the blocks
1315  *
1316  * o compare the signatures: If we already have this signature, check
1317  *   that they compare okay; if not, issue a warning and ask the user.
1318  * o Simply add the signature.  Can't verify here because we may not have
1319  *   the signature's public key yet; verification is done when putting it
1320  *   into the trustdb, which is done automagically as soon as this pubkey
1321  *   is used.
1322  * Note: We indicate newly inserted packets with flag bit 0
1323  */
1324 static int
1325 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1326               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1327 {
1328     KBNODE onode, node;
1329     int rc, found;
1330
1331     /* 1st: handle revocation certificates */
1332     for(node=keyblock->next; node; node=node->next ) {
1333         if( node->pkt->pkttype == PKT_USER_ID )
1334             break;
1335         else if( node->pkt->pkttype == PKT_SIGNATURE
1336                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1337             /* check whether we already have this */
1338             found = 0;
1339             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1340                 if( onode->pkt->pkttype == PKT_USER_ID )
1341                     break;
1342                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1343                          && onode->pkt->pkt.signature->sig_class == 0x20
1344                          && node->pkt->pkt.signature->keyid[0]
1345                             == onode->pkt->pkt.signature->keyid[0]
1346                          && node->pkt->pkt.signature->keyid[1]
1347                             == onode->pkt->pkt.signature->keyid[1] ) {
1348                     found = 1;
1349                     break;
1350                 }
1351             }
1352             if( !found ) {
1353                 char *p=get_user_id_native(keyid);
1354                 KBNODE n2 = clone_kbnode(node);
1355                 insert_kbnode( keyblock_orig, n2, 0 );
1356                 n2->flag |= 1;
1357                 ++*n_sigs;
1358                 log_info(_("key %08lX: \"%s\" revocation certificate added\n"),
1359                                          (ulong)keyid[1],p);
1360                 m_free(p);
1361             }
1362         }
1363     }
1364
1365     /* 2nd: merge in any direct key (0x1F) sigs */
1366     for(node=keyblock->next; node; node=node->next ) {
1367         if( node->pkt->pkttype == PKT_USER_ID )
1368             break;
1369         else if( node->pkt->pkttype == PKT_SIGNATURE
1370                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1371             /* check whether we already have this */
1372             found = 0;
1373             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1374                 if( onode->pkt->pkttype == PKT_USER_ID )
1375                     break;
1376                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1377                          && onode->pkt->pkt.signature->sig_class == 0x1F
1378                          && !cmp_signatures(onode->pkt->pkt.signature,
1379                                             node->pkt->pkt.signature)) {
1380                     found = 1;
1381                     break;
1382                 }
1383             }
1384             if( !found ) {
1385                 KBNODE n2 = clone_kbnode(node);
1386                 insert_kbnode( keyblock_orig, n2, 0 );
1387                 n2->flag |= 1;
1388                 ++*n_sigs;
1389                 log_info( _("key %08lX: direct key signature added\n"),
1390                                          (ulong)keyid[1]);
1391             }
1392         }
1393     }
1394
1395     /* 3rd: try to merge new certificates in */
1396     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1397         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1398             /* find the user id in the imported keyblock */
1399             for(node=keyblock->next; node; node=node->next )
1400                 if( node->pkt->pkttype == PKT_USER_ID
1401                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1402                                           node->pkt->pkt.user_id ) )
1403                     break;
1404             if( node ) { /* found: merge */
1405                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1406                 if( rc )
1407                     return rc;
1408             }
1409         }
1410     }
1411
1412     /* 4th: add new user-ids */
1413     for(node=keyblock->next; node; node=node->next ) {
1414         if( node->pkt->pkttype == PKT_USER_ID) {
1415             /* do we have this in the original keyblock */
1416             for(onode=keyblock_orig->next; onode; onode=onode->next )
1417                 if( onode->pkt->pkttype == PKT_USER_ID
1418                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1419                                       node->pkt->pkt.user_id ) )
1420                     break;
1421             if( !onode ) { /* this is a new user id: append */
1422                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1423                 if( rc )
1424                     return rc;
1425                 ++*n_uids;
1426             }
1427         }
1428     }
1429
1430     /* 5th: add new subkeys */
1431     for(node=keyblock->next; node; node=node->next ) {
1432         onode = NULL;
1433         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1434             /* do we have this in the original keyblock? */
1435             for(onode=keyblock_orig->next; onode; onode=onode->next )
1436                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1437                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1438                                          node->pkt->pkt.public_key ) )
1439                     break;
1440             if( !onode ) { /* this is a new subkey: append */
1441                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1442                 if( rc )
1443                     return rc;
1444                 ++*n_subk;
1445             }
1446         }
1447         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1448             /* do we have this in the original keyblock? */
1449             for(onode=keyblock_orig->next; onode; onode=onode->next )
1450                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1451                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1452                                          node->pkt->pkt.secret_key ) )
1453                     break;
1454             if( !onode ) { /* this is a new subkey: append */
1455                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1456                 if( rc )
1457                     return rc;
1458                 ++*n_subk;
1459             }
1460         }
1461     }
1462
1463     /* 6th: merge subkey certificates */
1464     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1465         if( !(onode->flag & 1)
1466             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1467                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1468             /* find the subkey in the imported keyblock */
1469             for(node=keyblock->next; node; node=node->next ) {
1470                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1471                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1472                                           node->pkt->pkt.public_key ) )
1473                     break;
1474                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1475                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1476                                           node->pkt->pkt.secret_key ) )
1477                     break;
1478             }
1479             if( node ) { /* found: merge */
1480                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1481                 if( rc )
1482                     return rc;
1483             }
1484         }
1485     }
1486
1487
1488     return 0;
1489 }
1490
1491
1492 /****************
1493  * append the userid starting with NODE and all signatures to KEYBLOCK.
1494  */
1495 static int
1496 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1497                                           const char *fname, u32 *keyid )
1498 {
1499     KBNODE n, n_where=NULL;
1500
1501     assert(node->pkt->pkttype == PKT_USER_ID );
1502
1503     /* find the position */
1504     for( n = keyblock; n; n_where = n, n = n->next ) {
1505         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1506             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1507             break;
1508     }
1509     if( !n )
1510         n_where = NULL;
1511
1512     /* and append/insert */
1513     while( node ) {
1514         /* we add a clone to the original keyblock, because this
1515          * one is released first */
1516         n = clone_kbnode(node);
1517         if( n_where ) {
1518             insert_kbnode( n_where, n, 0 );
1519             n_where = n;
1520         }
1521         else
1522             add_kbnode( keyblock, n );
1523         n->flag |= 1;
1524         node->flag |= 1;
1525         if( n->pkt->pkttype == PKT_SIGNATURE )
1526             ++*n_sigs;
1527
1528         node = node->next;
1529         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1530             break;
1531     }
1532
1533     return 0;
1534 }
1535
1536
1537 /****************
1538  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1539  * (how should we handle comment packets here?)
1540  */
1541 static int
1542 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1543                                     const char *fname, u32 *keyid )
1544 {
1545     KBNODE n, n2;
1546     int found=0;
1547
1548     assert(dst->pkt->pkttype == PKT_USER_ID );
1549     assert(src->pkt->pkttype == PKT_USER_ID );
1550
1551     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1552         if( n->pkt->pkttype != PKT_SIGNATURE )
1553             continue;
1554         if( n->pkt->pkt.signature->sig_class == 0x18
1555             || n->pkt->pkt.signature->sig_class == 0x28 )
1556             continue; /* skip signatures which are only valid on subkeys */
1557         found = 0;
1558         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1559             if( n2->pkt->pkttype == PKT_SIGNATURE
1560                 && n->pkt->pkt.signature->keyid[0]
1561                    == n2->pkt->pkt.signature->keyid[0]
1562                 && n->pkt->pkt.signature->keyid[1]
1563                    == n2->pkt->pkt.signature->keyid[1]
1564                 && n->pkt->pkt.signature->timestamp
1565                    <= n2->pkt->pkt.signature->timestamp
1566                 && n->pkt->pkt.signature->sig_class
1567                    == n2->pkt->pkt.signature->sig_class ) {
1568                 found++;
1569                 break;
1570             }
1571         }
1572         if( !found ) {
1573             /* This signature is new or newer, append N to DST.
1574              * We add a clone to the original keyblock, because this
1575              * one is released first */
1576             n2 = clone_kbnode(n);
1577             insert_kbnode( dst, n2, PKT_SIGNATURE );
1578             n2->flag |= 1;
1579             n->flag |= 1;
1580             ++*n_sigs;
1581         }
1582     }
1583
1584     return 0;
1585 }
1586
1587 /****************
1588  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1589  */
1590 static int
1591 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1592                                     const char *fname, u32 *keyid )
1593 {
1594     KBNODE n, n2;
1595     int found=0;
1596
1597     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1598            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1599
1600     for(n=src->next; n ; n = n->next ) {
1601         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1602             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1603             break;
1604         if( n->pkt->pkttype != PKT_SIGNATURE )
1605             continue;
1606         found = 0;
1607         for(n2=dst->next; n2; n2 = n2->next){
1608             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1609                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1610                 break;
1611             if( n2->pkt->pkttype == PKT_SIGNATURE
1612                 && n->pkt->pkt.signature->keyid[0]
1613                    == n2->pkt->pkt.signature->keyid[0]
1614                 && n->pkt->pkt.signature->keyid[1]
1615                    == n2->pkt->pkt.signature->keyid[1]
1616                 && n->pkt->pkt.signature->timestamp
1617                    <= n2->pkt->pkt.signature->timestamp
1618                 && n->pkt->pkt.signature->sig_class
1619                    == n2->pkt->pkt.signature->sig_class ) {
1620                 found++;
1621                 break;
1622             }
1623         }
1624         if( !found ) {
1625             /* This signature is new or newer, append N to DST.
1626              * We add a clone to the original keyblock, because this
1627              * one is released first */
1628             n2 = clone_kbnode(n);
1629             insert_kbnode( dst, n2, PKT_SIGNATURE );
1630             n2->flag |= 1;
1631             n->flag |= 1;
1632             ++*n_sigs;
1633         }
1634     }
1635
1636     return 0;
1637 }
1638
1639 /****************
1640  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1641  * Mark all new and copied packets by setting flag bit 0.
1642  */
1643 static int
1644 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1645                                           const char *fname, u32 *keyid )
1646 {
1647     KBNODE n;
1648
1649     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1650            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1651
1652     while(  node ) {
1653         /* we add a clone to the original keyblock, because this
1654          * one is released first */
1655         n = clone_kbnode(node);
1656         add_kbnode( keyblock, n );
1657         n->flag |= 1;
1658         node->flag |= 1;
1659         if( n->pkt->pkttype == PKT_SIGNATURE )
1660             ++*n_sigs;
1661
1662         node = node->next;
1663         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1664             break;
1665     }
1666
1667     return 0;
1668 }