* options.h, main.h, g10.c (main), import.c (parse_import_options,
[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;
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         }
1078         else if( node->pkt->pkttype == PKT_SIGNATURE
1079                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1080                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1081             delete_kbnode( node ); /* build_packet() can't handle this */
1082         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1083                  !node->pkt->pkt.signature->flags.exportable &&
1084                  !(opt.import_options&IMPORT_ALLOW_LOCAL_SIGS) &&
1085                  seckey_available( node->pkt->pkt.signature->keyid ) ) {
1086             /* here we violate the rfc a bit by still allowing
1087              * to import non-exportable signature when we have the
1088              * the secret key used to create this signature - it
1089              * seems that this makes sense */
1090             log_info( _("key %08lX: non exportable signature "
1091                                     "(class %02x) - skipped\n"),
1092                                     (ulong)keyid[1],
1093                                      node->pkt->pkt.signature->sig_class );
1094             delete_kbnode( node );
1095         }
1096         else if( node->pkt->pkttype == PKT_SIGNATURE
1097                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1098             if( uid_seen ) {
1099                 log_error( _("key %08lX: revocation certificate "
1100                                      "at wrong place - skipped\n"),
1101                                     (ulong)keyid[1]);
1102                 delete_kbnode( node );
1103             }
1104             else {
1105               /* If the revocation cert is from a different key than
1106                  the one we're working on don't check it - it's
1107                  probably from a revocation key and won't be
1108                  verifiable with this key anyway. */
1109
1110               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1111                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1112                 {
1113                   int rc = check_key_signature( keyblock, node, NULL);
1114                   if( rc )
1115                     {
1116                       log_error( _("key %08lX: invalid revocation "
1117                                    "certificate: %s - skipped\n"),
1118                                  (ulong)keyid[1], g10_errstr(rc));
1119                       delete_kbnode( node );
1120                     }
1121                 }
1122             }
1123         }
1124         else if( (node->flag & 4) ) /* marked for deletion */
1125             delete_kbnode( node );
1126     }
1127
1128     /* note: because keyblock is the public key, it is never marked
1129      * for deletion and so keyblock cannot change */
1130     commit_kbnode( &keyblock );
1131     return nvalid;
1132 }
1133
1134
1135 /****************
1136  * It may happen that the imported keyblock has duplicated user IDs.
1137  * We check this here and collapse those user IDs together with their
1138  * sigs into one.
1139  * Returns: True if the keyblock hash changed.
1140  */
1141 int
1142 collapse_uids( KBNODE *keyblock )
1143 {
1144     KBNODE n, n2;
1145     int in_uid;
1146     int any=0;
1147     u32 kid1;
1148
1149   restart:
1150     for( n = *keyblock; n; n = n->next ) {
1151         if( n->pkt->pkttype != PKT_USER_ID )
1152             continue;
1153         for( n2 = n->next; n2; n2 = n2->next ) {
1154             if( n2->pkt->pkttype == PKT_USER_ID
1155                 && !cmp_user_ids( n->pkt->pkt.user_id,
1156                                   n2->pkt->pkt.user_id ) ) {
1157                 /* found a duplicate */
1158                 any = 1;
1159                 if( !n2->next
1160                     || n2->next->pkt->pkttype == PKT_USER_ID
1161                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1162                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1163                     /* no more signatures: delete the user ID
1164                      * and start over */
1165                     remove_kbnode( keyblock, n2 );
1166                 }
1167                 else {
1168                     /* The simple approach: Move one signature and
1169                      * then start over to delete the next one :-( */
1170                     move_kbnode( keyblock, n2->next, n->next );
1171                 }
1172                 goto restart;
1173             }
1174         }
1175     }
1176     if( !any )
1177         return 0;
1178
1179   restart_sig:
1180     /* now we may have duplicate signatures on one user ID: fix this */
1181     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1182         if( n->pkt->pkttype == PKT_USER_ID )
1183             in_uid = 1;
1184         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1185                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1186             in_uid = 0;
1187         else if( in_uid ) {
1188             n2 = n;
1189             do {
1190                 KBNODE ncmp = NULL;
1191                 for( ; n2; n2 = n2->next ) {
1192                     if(    n2->pkt->pkttype == PKT_USER_ID
1193                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1194                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1195                         break;
1196                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1197                         ;
1198                     else if( !ncmp )
1199                         ncmp = n2;
1200                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1201                                                 n2->pkt->pkt.signature )) {
1202                         remove_kbnode( keyblock, n2 );
1203                         goto restart_sig;
1204                     }
1205                 }
1206                 n2 = ncmp? ncmp->next : NULL;
1207             } while( n2 );
1208         }
1209     }
1210
1211     if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1212         kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
1213     else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1214         kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
1215     else
1216         kid1 = 0;
1217     log_info(_("key %08lX: duplicated user ID detected - merged\n"),
1218                                                                  (ulong)kid1);
1219
1220     return 1;
1221 }
1222
1223 /* Check for a 0x20 revocation from a revocation key that is not
1224    present.  This gets called without the benefit of merge_xxxx so you
1225    can't rely on pk->revkey and friends. */
1226 static void
1227 revocation_present(KBNODE keyblock)
1228 {
1229   KBNODE onode,inode;
1230   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1231
1232   for(onode=keyblock->next;onode;onode=onode->next)
1233     {
1234       /* If we reach user IDs, we're done. */
1235       if(onode->pkt->pkttype==PKT_USER_ID)
1236         break;
1237
1238       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1239          onode->pkt->pkt.signature->sig_class==0x1F &&
1240          onode->pkt->pkt.signature->revkey)
1241         {
1242           int idx;
1243           PKT_signature *sig=onode->pkt->pkt.signature;
1244
1245           for(idx=0;idx<sig->numrevkeys;idx++)
1246             {
1247               u32 keyid[2];
1248
1249               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1250                                      MAX_FINGERPRINT_LEN,keyid);
1251
1252               for(inode=keyblock->next;inode;inode=inode->next)
1253                 {
1254                   /* If we reach user IDs, we're done. */
1255                   if(inode->pkt->pkttype==PKT_USER_ID)
1256                     break;
1257
1258                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1259                      inode->pkt->pkt.signature->sig_class==0x20 &&
1260                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1261                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1262                     {
1263                       /* Okay, we have a revocation key, and a
1264                          revocation issued by it.  Do we have the key
1265                          itself? */
1266                       int rc;
1267
1268                       rc=get_pubkey_byfprint(NULL,sig->revkey[idx]->fpr,
1269                                              MAX_FINGERPRINT_LEN);
1270                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1271                         {
1272                           /* No, so try and get it */
1273                           if(opt.keyserver_scheme &&
1274                              opt.keyserver_options.auto_key_retrieve)
1275                             {
1276                               log_info(_("Warning: key %08lX may be revoked: "
1277                                          "fetching revocation key %08lX\n"),
1278                                        (ulong)keyid_from_pk(pk,NULL),
1279                                        (ulong)keyid[1]);
1280                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1281                                                       MAX_FINGERPRINT_LEN);
1282
1283                               /* Do we have it now? */
1284                               rc=get_pubkey_byfprint(NULL,
1285                                                      sig->revkey[idx]->fpr,
1286                                                      MAX_FINGERPRINT_LEN);
1287                             }
1288
1289                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1290                             log_info(_("Warning: key %08lX may be revoked: "
1291                                        "revocation key %08lX not present.\n"),
1292                                      (ulong)keyid_from_pk(pk,NULL),
1293                                      (ulong)keyid[1]);
1294                         }
1295                     }
1296                 }
1297             }
1298         }
1299     }
1300 }
1301
1302 /****************
1303  * compare and merge the blocks
1304  *
1305  * o compare the signatures: If we already have this signature, check
1306  *   that they compare okay; if not, issue a warning and ask the user.
1307  * o Simply add the signature.  Can't verify here because we may not have
1308  *   the signature's public key yet; verification is done when putting it
1309  *   into the trustdb, which is done automagically as soon as this pubkey
1310  *   is used.
1311  * Note: We indicate newly inserted packets with flag bit 0
1312  */
1313 static int
1314 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1315               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1316 {
1317     KBNODE onode, node;
1318     int rc, found;
1319
1320     /* 1st: handle revocation certificates */
1321     for(node=keyblock->next; node; node=node->next ) {
1322         if( node->pkt->pkttype == PKT_USER_ID )
1323             break;
1324         else if( node->pkt->pkttype == PKT_SIGNATURE
1325                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1326             /* check whether we already have this */
1327             found = 0;
1328             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1329                 if( onode->pkt->pkttype == PKT_USER_ID )
1330                     break;
1331                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1332                          && onode->pkt->pkt.signature->sig_class == 0x20
1333                          && node->pkt->pkt.signature->keyid[0]
1334                             == onode->pkt->pkt.signature->keyid[0]
1335                          && node->pkt->pkt.signature->keyid[1]
1336                             == onode->pkt->pkt.signature->keyid[1] ) {
1337                     found = 1;
1338                     break;
1339                 }
1340             }
1341             if( !found ) {
1342                 char *p=get_user_id_native(keyid);
1343                 KBNODE n2 = clone_kbnode(node);
1344                 insert_kbnode( keyblock_orig, n2, 0 );
1345                 n2->flag |= 1;
1346                 ++*n_sigs;
1347                 log_info(_("key %08lX: \"%s\" revocation certificate added\n"),
1348                                          (ulong)keyid[1],p);
1349                 m_free(p);
1350             }
1351         }
1352     }
1353
1354     /* 2nd: merge in any direct key (0x1F) sigs */
1355     for(node=keyblock->next; node; node=node->next ) {
1356         if( node->pkt->pkttype == PKT_USER_ID )
1357             break;
1358         else if( node->pkt->pkttype == PKT_SIGNATURE
1359                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1360             /* check whether we already have this */
1361             found = 0;
1362             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1363                 if( onode->pkt->pkttype == PKT_USER_ID )
1364                     break;
1365                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1366                          && onode->pkt->pkt.signature->sig_class == 0x1F
1367                          && !cmp_signatures(onode->pkt->pkt.signature,
1368                                             node->pkt->pkt.signature)) {
1369                     found = 1;
1370                     break;
1371                 }
1372             }
1373             if( !found ) {
1374                 KBNODE n2 = clone_kbnode(node);
1375                 insert_kbnode( keyblock_orig, n2, 0 );
1376                 n2->flag |= 1;
1377                 ++*n_sigs;
1378                 log_info( _("key %08lX: direct key signature added\n"),
1379                                          (ulong)keyid[1]);
1380             }
1381         }
1382     }
1383
1384     /* 3rd: try to merge new certificates in */
1385     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1386         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1387             /* find the user id in the imported keyblock */
1388             for(node=keyblock->next; node; node=node->next )
1389                 if( node->pkt->pkttype == PKT_USER_ID
1390                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1391                                           node->pkt->pkt.user_id ) )
1392                     break;
1393             if( node ) { /* found: merge */
1394                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1395                 if( rc )
1396                     return rc;
1397             }
1398         }
1399     }
1400
1401     /* 4th: add new user-ids */
1402     for(node=keyblock->next; node; node=node->next ) {
1403         if( node->pkt->pkttype == PKT_USER_ID) {
1404             /* do we have this in the original keyblock */
1405             for(onode=keyblock_orig->next; onode; onode=onode->next )
1406                 if( onode->pkt->pkttype == PKT_USER_ID
1407                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1408                                       node->pkt->pkt.user_id ) )
1409                     break;
1410             if( !onode ) { /* this is a new user id: append */
1411                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1412                 if( rc )
1413                     return rc;
1414                 ++*n_uids;
1415             }
1416         }
1417     }
1418
1419     /* 5th: add new subkeys */
1420     for(node=keyblock->next; node; node=node->next ) {
1421         onode = NULL;
1422         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1423             /* do we have this in the original keyblock? */
1424             for(onode=keyblock_orig->next; onode; onode=onode->next )
1425                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1426                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1427                                          node->pkt->pkt.public_key ) )
1428                     break;
1429             if( !onode ) { /* this is a new subkey: append */
1430                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1431                 if( rc )
1432                     return rc;
1433                 ++*n_subk;
1434             }
1435         }
1436         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1437             /* do we have this in the original keyblock? */
1438             for(onode=keyblock_orig->next; onode; onode=onode->next )
1439                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1440                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1441                                          node->pkt->pkt.secret_key ) )
1442                     break;
1443             if( !onode ) { /* this is a new subkey: append */
1444                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1445                 if( rc )
1446                     return rc;
1447                 ++*n_subk;
1448             }
1449         }
1450     }
1451
1452     /* 6th: merge subkey certificates */
1453     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1454         if( !(onode->flag & 1)
1455             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1456                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1457             /* find the subkey in the imported keyblock */
1458             for(node=keyblock->next; node; node=node->next ) {
1459                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1460                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1461                                           node->pkt->pkt.public_key ) )
1462                     break;
1463                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1464                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1465                                           node->pkt->pkt.secret_key ) )
1466                     break;
1467             }
1468             if( node ) { /* found: merge */
1469                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1470                 if( rc )
1471                     return rc;
1472             }
1473         }
1474     }
1475
1476
1477     return 0;
1478 }
1479
1480
1481 /****************
1482  * append the userid starting with NODE and all signatures to KEYBLOCK.
1483  */
1484 static int
1485 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1486                                           const char *fname, u32 *keyid )
1487 {
1488     KBNODE n, n_where=NULL;
1489
1490     assert(node->pkt->pkttype == PKT_USER_ID );
1491
1492     /* find the position */
1493     for( n = keyblock; n; n_where = n, n = n->next ) {
1494         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1495             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1496             break;
1497     }
1498     if( !n )
1499         n_where = NULL;
1500
1501     /* and append/insert */
1502     while( node ) {
1503         /* we add a clone to the original keyblock, because this
1504          * one is released first */
1505         n = clone_kbnode(node);
1506         if( n_where ) {
1507             insert_kbnode( n_where, n, 0 );
1508             n_where = n;
1509         }
1510         else
1511             add_kbnode( keyblock, n );
1512         n->flag |= 1;
1513         node->flag |= 1;
1514         if( n->pkt->pkttype == PKT_SIGNATURE )
1515             ++*n_sigs;
1516
1517         node = node->next;
1518         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1519             break;
1520     }
1521
1522     return 0;
1523 }
1524
1525
1526 /****************
1527  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1528  * (how should we handle comment packets here?)
1529  */
1530 static int
1531 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1532                                     const char *fname, u32 *keyid )
1533 {
1534     KBNODE n, n2;
1535     int found=0;
1536
1537     assert(dst->pkt->pkttype == PKT_USER_ID );
1538     assert(src->pkt->pkttype == PKT_USER_ID );
1539
1540     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1541         if( n->pkt->pkttype != PKT_SIGNATURE )
1542             continue;
1543         if( n->pkt->pkt.signature->sig_class == 0x18
1544             || n->pkt->pkt.signature->sig_class == 0x28 )
1545             continue; /* skip signatures which are only valid on subkeys */
1546         found = 0;
1547         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next){
1548             if( n2->pkt->pkttype == PKT_SIGNATURE
1549                 && n->pkt->pkt.signature->keyid[0]
1550                    == n2->pkt->pkt.signature->keyid[0]
1551                 && n->pkt->pkt.signature->keyid[1]
1552                    == n2->pkt->pkt.signature->keyid[1]
1553                 && n->pkt->pkt.signature->timestamp
1554                    <= n2->pkt->pkt.signature->timestamp
1555                 && n->pkt->pkt.signature->sig_class
1556                    == n2->pkt->pkt.signature->sig_class ) {
1557                 found++;
1558                 break;
1559             }
1560         }
1561         if( !found ) {
1562             /* This signature is new or newer, append N to DST.
1563              * We add a clone to the original keyblock, because this
1564              * one is released first */
1565             n2 = clone_kbnode(n);
1566             insert_kbnode( dst, n2, PKT_SIGNATURE );
1567             n2->flag |= 1;
1568             n->flag |= 1;
1569             ++*n_sigs;
1570         }
1571     }
1572
1573     return 0;
1574 }
1575
1576 /****************
1577  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1578  */
1579 static int
1580 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1581                                     const char *fname, u32 *keyid )
1582 {
1583     KBNODE n, n2;
1584     int found=0;
1585
1586     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
1587            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
1588
1589     for(n=src->next; n ; n = n->next ) {
1590         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1591             || n->pkt->pkttype == PKT_PUBLIC_KEY )
1592             break;
1593         if( n->pkt->pkttype != PKT_SIGNATURE )
1594             continue;
1595         found = 0;
1596         for(n2=dst->next; n2; n2 = n2->next){
1597             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1598                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
1599                 break;
1600             if( n2->pkt->pkttype == PKT_SIGNATURE
1601                 && n->pkt->pkt.signature->keyid[0]
1602                    == n2->pkt->pkt.signature->keyid[0]
1603                 && n->pkt->pkt.signature->keyid[1]
1604                    == n2->pkt->pkt.signature->keyid[1]
1605                 && n->pkt->pkt.signature->timestamp
1606                    <= n2->pkt->pkt.signature->timestamp
1607                 && n->pkt->pkt.signature->sig_class
1608                    == n2->pkt->pkt.signature->sig_class ) {
1609                 found++;
1610                 break;
1611             }
1612         }
1613         if( !found ) {
1614             /* This signature is new or newer, append N to DST.
1615              * We add a clone to the original keyblock, because this
1616              * one is released first */
1617             n2 = clone_kbnode(n);
1618             insert_kbnode( dst, n2, PKT_SIGNATURE );
1619             n2->flag |= 1;
1620             n->flag |= 1;
1621             ++*n_sigs;
1622         }
1623     }
1624
1625     return 0;
1626 }
1627
1628 /****************
1629  * append the subkey starting with NODE and all signatures to KEYBLOCK.
1630  * Mark all new and copied packets by setting flag bit 0.
1631  */
1632 static int
1633 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
1634                                           const char *fname, u32 *keyid )
1635 {
1636     KBNODE n;
1637
1638     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1639            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
1640
1641     while(  node ) {
1642         /* we add a clone to the original keyblock, because this
1643          * one is released first */
1644         n = clone_kbnode(node);
1645         add_kbnode( keyblock, n );
1646         n->flag |= 1;
1647         node->flag |= 1;
1648         if( n->pkt->pkttype == PKT_SIGNATURE )
1649             ++*n_sigs;
1650
1651         node = node->next;
1652         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1653             break;
1654     }
1655
1656     return 0;
1657 }