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