* keydb.h, getkey.c (get_user_id_printable): Rename to get_user_id_native
[gnupg.git] / g10 / import.c
1 /* import.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28
29 #include "options.h"
30 #include "packet.h"
31 #include "errors.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "trustdb.h"
36 #include "main.h"
37 #include "i18n.h"
38 #include "ttyio.h"
39 #include "status.h"
40 #include "keyserver-internal.h"
41
42 struct stats_s {
43     ulong count;
44     ulong no_user_id;
45     ulong imported;
46     ulong imported_rsa;
47     ulong n_uids;
48     ulong n_sigs;
49     ulong n_subk;
50     ulong unchanged;
51     ulong n_revoc;
52     ulong secret_read;
53     ulong secret_imported;
54     ulong secret_dups;
55     ulong skipped_new_keys;
56     ulong not_imported;
57 };
58
59
60 static int import( IOBUF inp, const char* fname,
61                    struct stats_s *stats, unsigned int options );
62 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
63 static void revocation_present(KBNODE keyblock);
64 static int import_one( const char *fname, KBNODE keyblock,
65                        struct stats_s *stats, unsigned int options);
66 static int import_secret_one( const char *fname, KBNODE keyblock,
67                               struct stats_s *stats, unsigned int options);
68 static int import_revoke_cert( const char *fname, KBNODE node,
69                                struct stats_s *stats);
70 static int chk_self_sigs( const char *fname, KBNODE keyblock,
71                           PKT_public_key *pk, u32 *keyid, int *non_self );
72 static int delete_inv_parts( const char *fname, KBNODE keyblock,
73                              u32 *keyid, unsigned int options );
74 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
75                          KBNODE keyblock, u32 *keyid,
76                          int *n_uids, int *n_sigs, int *n_subk );
77 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
78                              const char *fname, u32 *keyid );
79 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
80                              const char *fname, u32 *keyid );
81 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
82                              const char *fname, u32 *keyid );
83 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
84                              const char *fname, u32 *keyid );
85
86 int
87 parse_import_options(char *str,unsigned int *options,int noisy)
88 {
89   struct parse_options import_opts[]=
90     {
91       {"allow-local-sigs",IMPORT_ALLOW_LOCAL_SIGS,NULL},
92       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
93       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
94       {"fast-import",IMPORT_FAST_IMPORT,NULL},
95       {"convert-sk-to-pk",IMPORT_SK2PK,NULL},
96       {"merge-only",IMPORT_MERGE_ONLY,NULL},
97       {NULL,0,NULL}
98     };
99
100   return parse_options(str,options,import_opts,noisy);
101 }
102
103 void *
104 import_new_stats_handle (void)
105 {
106     return m_alloc_clear ( sizeof (struct stats_s) );
107 }
108
109 void
110 import_release_stats_handle (void *p)
111 {
112     m_free (p);
113 }
114
115 /****************
116  * Import the public keys from the given filename. Input may be armored.
117  * This function rejects all keys which are not validly self signed on at
118  * least one userid. Only user ids which are self signed will be imported.
119  * Other signatures are not checked.
120  *
121  * Actually this function does a merge. It works like this:
122  *
123  *  - get the keyblock
124  *  - check self-signatures and remove all userids and their signatures
125  *    without/invalid self-signatures.
126  *  - reject the keyblock, if we have no valid userid.
127  *  - See whether we have this key already in one of our pubrings.
128  *    If not, simply add it to the default keyring.
129  *  - Compare the key and the self-signatures of the new and the one in
130  *    our keyring.  If they are different something weird is going on;
131  *    ask what to do.
132  *  - See whether we have only non-self-signature on one user id; if not
133  *    ask the user what to do.
134  *  - compare the signatures: If we already have this signature, check
135  *    that they compare okay; if not, issue a warning and ask the user.
136  *    (consider looking at the timestamp and use the newest?)
137  *  - Simply add the signature.  Can't verify here because we may not have
138  *    the signature's public key yet; verification is done when putting it
139  *    into the trustdb, which is done automagically as soon as this pubkey
140  *    is used.
141  *  - Proceed with next signature.
142  *
143  *  Key revocation certificates have special handling.
144  *
145  */
146 static int
147 import_keys_internal( IOBUF inp, char **fnames, int nnames,
148                       void *stats_handle, unsigned int options )
149 {
150     int i, rc = 0;
151     struct stats_s *stats = stats_handle;
152
153     if (!stats)
154         stats = import_new_stats_handle ();
155
156     if (inp) {
157         rc = import( inp, "[stream]", stats, options);
158     }
159     else {
160         if( !fnames && !nnames )
161             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
162
163         for(i=0; i < nnames; i++ ) {
164             const char *fname = fnames? fnames[i] : NULL;
165             IOBUF inp2 = iobuf_open(fname);
166             if( !fname )
167                 fname = "[stdin]";
168             if( !inp2 )
169                 log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
170             else {
171                 rc = import( inp2, fname, stats, options );
172                 iobuf_close(inp2);
173                 /* Must invalidate that ugly cache to actually close it. */
174                 iobuf_ioctl (NULL, 2, 0, (char*)fname);
175                 if( rc )
176                     log_error("import from `%s' failed: %s\n", fname,
177                               g10_errstr(rc) );
178             }
179             if( !fname )
180                 break;
181         }
182     }
183     if (!stats_handle) {
184         import_print_stats (stats);
185         import_release_stats_handle (stats);
186     }
187     /* If no fast import and the trustdb is dirty (i.e. we added a key
188        or userID that had something other than a selfsig, a signature
189        that was other than a selfsig, or any revocation), then
190        update/check the trustdb if the user specified by setting
191        interactive or by not setting no-auto-check-trustdb */
192     if (!(options&IMPORT_FAST_IMPORT) && trustdb_pending_check())
193       {
194         if (opt.interactive)
195           update_trustdb();
196         else if (!opt.no_auto_check_trustdb)
197           check_trustdb();
198       }
199
200     return rc;
201 }
202
203 void
204 import_keys( char **fnames, int nnames,
205              void *stats_handle, unsigned int options )
206 {
207     import_keys_internal( NULL, fnames, nnames, stats_handle, options);
208 }
209
210 int
211 import_keys_stream( IOBUF inp, void *stats_handle, unsigned int options )
212 {
213     return import_keys_internal( inp, NULL, 0, stats_handle, options);
214 }
215
216 static int
217 import( IOBUF inp, const char* fname,
218         struct stats_s *stats, unsigned int options )
219 {
220     PACKET *pending_pkt = NULL;
221     KBNODE keyblock;
222     int rc = 0;
223
224     getkey_disable_caches();
225
226     if( !opt.no_armor ) { /* armored reading is not disabled */
227         armor_filter_context_t *afx = m_alloc_clear( sizeof *afx );
228         afx->only_keyblocks = 1;
229         iobuf_push_filter2( inp, armor_filter, afx, 1 );
230     }
231
232     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
233         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
234             rc = import_one( fname, keyblock, stats, options );
235         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
236                 rc = import_secret_one( fname, keyblock, stats, options );
237         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
238                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
239             rc = import_revoke_cert( fname, keyblock, stats );
240         else {
241             log_info( _("skipping block of type %d\n"),
242                                             keyblock->pkt->pkttype );
243         }
244         release_kbnode(keyblock);
245         /* fixme: we should increment the not imported counter but this
246            does only make sense if we keep on going despite of errors. */
247         if( rc )
248             break;
249         if( !(++stats->count % 100) && !opt.quiet )
250             log_info(_("%lu keys processed so far\n"), stats->count );
251     }
252     if( rc == -1 )
253         rc = 0;
254     else if( rc && rc != G10ERR_INV_KEYRING )
255         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
256
257     return rc;
258 }
259
260
261 void
262 import_print_stats (void *hd)
263 {
264     struct stats_s *stats = hd;
265
266     if( !opt.quiet ) {
267         log_info(_("Total number processed: %lu\n"), stats->count );
268         if( stats->skipped_new_keys )
269             log_info(_("      skipped new keys: %lu\n"),
270                                                 stats->skipped_new_keys );
271         if( stats->no_user_id )
272             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
273         if( stats->imported || stats->imported_rsa ) {
274             log_info(_("              imported: %lu"), stats->imported );
275             if( stats->imported_rsa )
276                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
277             putc('\n', stderr);
278         }
279         if( stats->unchanged )
280             log_info(_("             unchanged: %lu\n"), stats->unchanged );
281         if( stats->n_uids )
282             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
283         if( stats->n_subk )
284             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
285         if( stats->n_sigs )
286             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
287         if( stats->n_revoc )
288             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
289         if( stats->secret_read )
290             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
291         if( stats->secret_imported )
292             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
293         if( stats->secret_dups )
294             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
295         if( stats->not_imported )
296             log_info(_("          not imported: %lu\n"), stats->not_imported );
297     }
298
299     if( is_status_enabled() ) {
300         char buf[14*20];
301         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
302                 stats->count,
303                 stats->no_user_id,
304                 stats->imported,
305                 stats->imported_rsa,
306                 stats->unchanged,
307                 stats->n_uids,
308                 stats->n_subk,
309                 stats->n_sigs,
310                 stats->n_revoc,
311                 stats->secret_read,
312                 stats->secret_imported,
313                 stats->secret_dups,
314                 stats->skipped_new_keys,
315                 stats->not_imported );
316         write_status_text( STATUS_IMPORT_RES, buf );
317     }
318 }
319
320
321 /****************
322  * Read the next keyblock from stream A.
323  * PENDING_PKT should be initialzed to NULL
324  * and not chnaged form the caller.
325  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
326  */
327 static int
328 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
329 {
330     int rc;
331     PACKET *pkt;
332     KBNODE root = NULL;
333     int in_cert;
334
335     if( *pending_pkt ) {
336         root = new_kbnode( *pending_pkt );
337         *pending_pkt = NULL;
338         in_cert = 1;
339     }
340     else
341         in_cert = 0;
342     pkt = m_alloc( sizeof *pkt );
343     init_packet(pkt);
344     while( (rc=parse_packet(a, pkt)) != -1 ) {
345         if( rc ) {  /* ignore errors */
346             if( rc != G10ERR_UNKNOWN_PACKET ) {
347                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
348                 rc = G10ERR_INV_KEYRING;
349                 goto ready;
350             }
351             free_packet( pkt );
352             init_packet(pkt);
353             continue;
354         }
355
356         if( !root && pkt->pkttype == PKT_SIGNATURE
357                   && pkt->pkt.signature->sig_class == 0x20 ) {
358             /* this is a revocation certificate which is handled
359              * in a special way */
360             root = new_kbnode( pkt );
361             pkt = NULL;
362             goto ready;
363         }
364
365         /* make a linked list of all packets */
366         switch( pkt->pkttype ) {
367           case PKT_COMPRESSED:
368             if(check_compress_algo(pkt->pkt.compressed->algorithm))
369               {
370                 rc = G10ERR_COMPR_ALGO;
371                 goto ready;
372               }
373             else
374               {
375                 compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
376                 pkt->pkt.compressed->buf = NULL;
377                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
378               }
379             free_packet( pkt );
380             init_packet(pkt);
381             break;
382
383           case PKT_RING_TRUST:
384             /* skip those packets */
385             free_packet( pkt );
386             init_packet(pkt);
387             break;
388
389           case PKT_PUBLIC_KEY:
390           case PKT_SECRET_KEY:
391             if( in_cert ) { /* store this packet */
392                 *pending_pkt = pkt;
393                 pkt = NULL;
394                 goto ready;
395             }
396             in_cert = 1;
397           default:
398             if( in_cert ) {
399                 if( !root )
400                     root = new_kbnode( pkt );
401                 else
402                     add_kbnode( root, new_kbnode( pkt ) );
403                 pkt = m_alloc( sizeof *pkt );
404             }
405             init_packet(pkt);
406             break;
407         }
408     }
409   ready:
410     if( rc == -1 && root )
411         rc = 0;
412
413     if( rc )
414         release_kbnode( root );
415     else
416         *ret_root = root;
417     free_packet( pkt );
418     m_free( pkt );
419     return rc;
420 }
421
422 /* Walk through the subkeys on a pk to find if we have the PKS
423    disease: multiple subkeys with their binding sigs stripped, and the
424    sig for the first subkey placed after the last subkey.  That is,
425    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
426    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
427    and sub3, as they are already lost, but we can try and rescue sub1
428    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
429    sub2 sub3".  Returns TRUE if the keyblock was modified. */
430
431 static int
432 fix_pks_corruption(KBNODE keyblock)
433 {
434   int changed=0,keycount=0;
435   KBNODE node,last=NULL,sknode=NULL;
436
437   /* First determine if we have the problem at all.  Look for 2 or
438      more subkeys in a row, followed by a single binding sig. */
439   for(node=keyblock;node;last=node,node=node->next)
440     {
441       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
442         {
443           keycount++;
444           if(!sknode)
445             sknode=node;
446         }
447       else if(node->pkt->pkttype==PKT_SIGNATURE &&
448               node->pkt->pkt.signature->sig_class==0x18 &&
449               keycount>=2 && node->next==NULL)
450         {
451           /* We might have the problem, as this key has two subkeys in
452              a row without any intervening packets. */
453
454           /* Sanity check */
455           if(last==NULL)
456             break;
457
458           /* Temporarily attach node to sknode. */
459           node->next=sknode->next;
460           sknode->next=node;
461           last->next=NULL;
462
463           /* Note we aren't checking whether this binding sig is a
464              selfsig.  This is not necessary here as the subkey and
465              binding sig will be rejected later if that is the
466              case. */
467           if(check_key_signature(keyblock,node,NULL))
468             {
469               /* Not a match, so undo the changes. */
470               sknode->next=node->next;
471               last->next=node;
472               node->next=NULL;
473               break;
474             }
475           else
476             {
477               sknode->flag |= 1; /* Mark it good so we don't need to
478                                     check it again */
479               changed=1;
480               break;
481             }
482         }
483       else
484         keycount=0;
485     }
486
487   return changed;
488 }
489
490
491 static void
492 print_import_ok (PKT_public_key *pk, PKT_secret_key *sk, unsigned int reason)
493 {
494   byte array[MAX_FINGERPRINT_LEN], *s;
495   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
496   size_t i, n;
497
498   sprintf (buf, "%u ", reason);
499   p = buf + strlen (buf);
500
501   if (pk)
502     fingerprint_from_pk (pk, array, &n);
503   else
504     fingerprint_from_sk (sk, array, &n);
505   s = array;
506   for (i=0; i < n ; i++, s++, p += 2)
507     sprintf (p, "%02X", *s);
508
509   write_status_text (STATUS_IMPORT_OK, buf);
510 }
511
512 static void
513 print_import_check (PKT_public_key * pk, PKT_user_id * id)
514 {
515     char * buf;
516     byte fpr[24];
517     u32 keyid[2];
518     size_t i, pos = 0, n;
519
520     buf = m_alloc (17+41+id->len+32);
521     keyid_from_pk (pk, keyid);
522     sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
523     pos = 17;
524     fingerprint_from_pk (pk, fpr, &n);
525     for (i = 0; i < n; i++, pos += 2)
526         sprintf (buf+pos, "%02X", fpr[i]);
527     strcat (buf, " ");
528     pos += 1;
529     strcat (buf, id->name);
530     write_status_text (STATUS_IMPORT_CHECK, buf);
531     m_free (buf);
532 }
533
534 static void
535 check_prefs_warning(PKT_public_key *pk)
536 {
537   log_info(_("WARNING: key %s contains preferences for unavailable\n"),
538            keystr_from_pk(pk));
539   log_info(_("algorithms on these user IDs:\n"));
540 }
541
542 static void
543 check_prefs(KBNODE keyblock)
544 {
545   KBNODE node;
546   PKT_public_key *pk;
547   int problem=0;
548   
549   merge_keys_and_selfsig(keyblock);
550   pk=keyblock->pkt->pkt.public_key;
551
552   for(node=keyblock;node;node=node->next)
553     {
554       if(node->pkt->pkttype==PKT_USER_ID
555          && node->pkt->pkt.user_id->created
556          && node->pkt->pkt.user_id->prefs)
557         {
558           PKT_user_id *uid=node->pkt->pkt.user_id;
559           prefitem_t *prefs=uid->prefs;
560           char *user=utf8_to_native(uid->name,strlen(uid->name),0);
561
562           for(;prefs->type;prefs++)
563             {
564               char num[10]; /* prefs->value is a byte, so we're over
565                                safe here */
566
567               sprintf(num,"%u",prefs->value);
568
569               if(prefs->type==PREFTYPE_SYM)
570                 {
571                   if(check_cipher_algo(prefs->value))
572                     {
573                       const char *algo=cipher_algo_to_string(prefs->value);
574                       if(!problem)
575                         check_prefs_warning(pk);
576                       log_info(_("         \"%s\": preference for cipher"
577                                  " algorithm %s\n"),user,algo?algo:num);
578                       problem=1;
579                     }
580                 }
581               else if(prefs->type==PREFTYPE_HASH)
582                 {
583                   if(check_digest_algo(prefs->value))
584                     {
585                       const char *algo=digest_algo_to_string(prefs->value);
586                       if(!problem)
587                         check_prefs_warning(pk);
588                       log_info(_("         \"%s\": preference for digest"
589                                  " algorithm %s\n"),user,algo?algo:num);
590                       problem=1;
591                     }
592                 }
593               else if(prefs->type==PREFTYPE_ZIP)
594                 {
595                   if(check_compress_algo(prefs->value))
596                     {
597                       const char *algo=compress_algo_to_string(prefs->value);
598                       if(!problem)
599                         check_prefs_warning(pk);
600                       log_info(_("         \"%s\": preference for compression"
601                                  " algorithm %s\n"),user,algo?algo:num);
602                       problem=1;
603                     }
604                 }
605             }
606
607           m_free(user);
608         }
609     }
610
611   if(problem)
612     {
613       log_info(_("it is strongly suggested that you update"
614                  " your preferences and\n"));
615       log_info(_("re-distribute this key to avoid potential algorithm"
616                  " mismatch problems\n"));
617
618       if(!opt.batch)
619         {
620           STRLIST sl=NULL,locusr=NULL;
621           size_t fprlen=0;
622           byte fpr[MAX_FINGERPRINT_LEN],*p;
623           char username[(MAX_FINGERPRINT_LEN*2)+1];
624           unsigned int i;
625
626           p=fingerprint_from_pk(pk,fpr,&fprlen);
627           for(i=0;i<fprlen;i++,p++)
628             sprintf(username+2*i,"%02X",*p);
629           add_to_strlist(&locusr,username);
630
631           append_to_strlist(&sl,"updpref");
632           append_to_strlist(&sl,"save");
633
634           keyedit_menu( username, locusr, sl, 1, 1 );
635           free_strlist(sl);
636           free_strlist(locusr);
637         }
638       else if(!opt.quiet)
639         log_info(_("you can update your preferences with:"
640                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
641     }
642 }
643
644 /****************
645  * Try to import one keyblock.  Return an error only in serious cases, but
646  * never for an invalid keyblock.  It uses log_error to increase the
647  * internal errorcount, so that invalid input can be detected by programs
648  * which called g10.
649  */
650 static int
651 import_one( const char *fname, KBNODE keyblock,
652             struct stats_s *stats, unsigned int options )
653 {
654     PKT_public_key *pk;
655     PKT_public_key *pk_orig;
656     KBNODE node, uidnode;
657     KBNODE keyblock_orig = NULL;
658     u32 keyid[2];
659     int rc = 0;
660     int new_key = 0;
661     int mod_key = 0;
662     int non_self = 0;
663
664     /* get the key and print some info about it */
665     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
666     if( !node )
667         BUG();
668
669     pk = node->pkt->pkt.public_key;
670     keyid_from_pk( pk, keyid );
671     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
672
673     if( opt.verbose && !opt.interactive )
674       {
675         log_info( "pub  %4u%c/%s %s  ",
676                   nbits_from_pk( pk ),
677                   pubkey_letter( pk->pubkey_algo ),
678                   keystr_from_pk(pk), datestr_from_pk(pk) );
679         if( uidnode )
680           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
681                              uidnode->pkt->pkt.user_id->len );
682         putc('\n', stderr);
683       }
684
685     if( !uidnode )
686       {
687         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
688         return 0;
689       }
690     
691     if (opt.interactive) {
692         if(is_status_enabled())
693           print_import_check (pk, uidnode->pkt->pkt.user_id);
694         merge_keys_and_selfsig (keyblock);
695         tty_printf ("\n");
696         show_basic_key_info (keyblock);
697         tty_printf ("\n");
698         if (!cpr_get_answer_is_yes ("import.okay",
699                                     "Do you want to import this key? (y/N) "))
700             return 0;
701     }
702
703     clear_kbnode_flags( keyblock );
704
705     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
706        && opt.verbose)
707       log_info(_("key %s: PKS subkey corruption repaired\n"),
708                keystr_from_pk(pk));
709
710     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
711     if( rc )
712         return rc== -1? 0:rc;
713
714     /* If we allow such a thing, mark unsigned uids as valid */
715     if( opt.allow_non_selfsigned_uid )
716       for( node=keyblock; node; node = node->next )
717         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
718           {
719             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
720                                       node->pkt->pkt.user_id->len,0);
721             node->flag |= 1;
722             log_info( _("key %s: accepted non self-signed user ID '%s'\n"),
723                       keystr_from_pk(pk),user);
724             m_free(user);
725           }
726
727     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
728         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
729         if( !opt.quiet )
730           log_info(_("this may be caused by a missing self-signature\n"));
731         stats->no_user_id++;
732         return 0;
733     }
734
735     /* do we have this key already in one of our pubrings ? */
736     pk_orig = m_alloc_clear( sizeof *pk_orig );
737     rc = get_pubkey_fast ( pk_orig, keyid );
738     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
739       {
740         log_error( _("key %s: public key not found: %s\n"),
741                    keystr(keyid), g10_errstr(rc));
742       }
743     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
744       {
745         if( opt.verbose )
746           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
747         rc = 0;
748         stats->skipped_new_keys++;
749       }
750     else if( rc ) { /* insert this key */
751         KEYDB_HANDLE hd = keydb_new (0);
752
753         rc = keydb_locate_writable (hd, NULL);
754         if (rc) {
755             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
756             keydb_release (hd);
757             return G10ERR_GENERAL;
758         }
759         if( opt.verbose > 1 )
760             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
761
762         collapse_uids(&keyblock);
763
764         rc = keydb_insert_keyblock (hd, keyblock );
765         if (rc)
766            log_error (_("error writing keyring `%s': %s\n"),
767                        keydb_get_resource_name (hd), g10_errstr(rc));
768         else
769           {
770             /* This should not be possible since we delete the
771                ownertrust when a key is deleted, but it can happen if
772                the keyring and trustdb are out of sync.  It can also
773                be made to happen with the trusted-key command. */
774
775             clear_ownertrusts (pk);
776             if(non_self)
777               revalidation_mark ();
778           }
779         keydb_release (hd);
780
781         /* we are ready */
782         if( !opt.quiet )
783           {
784             char *p=get_user_id_native (keyid);
785             log_info( _("key %s: public key \"%s\" imported\n"),
786                       keystr(keyid),p);
787             m_free(p);
788           }
789         if( is_status_enabled() )
790           {
791             char *us = get_long_user_id_string( keyid );
792             write_status_text( STATUS_IMPORTED, us );
793             m_free(us);
794             print_import_ok (pk,NULL, 1);
795           }
796         stats->imported++;
797         if( is_RSA( pk->pubkey_algo ) )
798             stats->imported_rsa++;
799         new_key = 1;
800     }
801     else { /* merge */
802         KEYDB_HANDLE hd;
803         int n_uids, n_sigs, n_subk;
804
805         /* Compare the original against the new key; just to be sure nothing
806          * weird is going on */
807         if( cmp_public_keys( pk_orig, pk ) )
808           {
809             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
810             goto leave;
811           }
812
813         /* now read the original keyblock */
814         hd = keydb_new (0);
815         {
816             byte afp[MAX_FINGERPRINT_LEN];
817             size_t an;
818
819             fingerprint_from_pk (pk_orig, afp, &an);
820             while (an < MAX_FINGERPRINT_LEN) 
821                 afp[an++] = 0;
822             rc = keydb_search_fpr (hd, afp);
823         }
824         if( rc )
825           {
826             log_error (_("key %s: can't locate original keyblock: %s\n"),
827                        keystr(keyid), g10_errstr(rc));
828             keydb_release (hd);
829             goto leave;
830           }
831         rc = keydb_get_keyblock (hd, &keyblock_orig );
832         if (rc)
833           {
834             log_error (_("key %s: can't read original keyblock: %s\n"),
835                        keystr(keyid), g10_errstr(rc));
836             keydb_release (hd);
837             goto leave;
838           }
839
840         collapse_uids( &keyblock );
841         /* and try to merge the block */
842         clear_kbnode_flags( keyblock_orig );
843         clear_kbnode_flags( keyblock );
844         n_uids = n_sigs = n_subk = 0;
845         rc = merge_blocks( fname, keyblock_orig, keyblock,
846                                 keyid, &n_uids, &n_sigs, &n_subk );
847         if( rc ) {
848             keydb_release (hd);
849             goto leave;
850         }
851         if( n_uids || n_sigs || n_subk ) {
852             mod_key = 1;
853             /* keyblock_orig has been updated; write */
854             rc = keydb_update_keyblock (hd, keyblock_orig);
855             if (rc)
856                 log_error (_("error writing keyring `%s': %s\n"),
857                              keydb_get_resource_name (hd), g10_errstr(rc) );
858             else if(non_self)
859               revalidation_mark ();
860
861             /* we are ready */
862             if( !opt.quiet )
863               {
864                 char *p=get_user_id_native(keyid);
865                 if( n_uids == 1 )
866                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
867                            keystr(keyid),p);
868                 else if( n_uids )
869                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
870                             keystr(keyid),p,n_uids);
871                 if( n_sigs == 1 )
872                   log_info( _("key %s: \"%s\" 1 new signature\n"),
873                             keystr(keyid), p);
874                 else if( n_sigs )
875                   log_info( _("key %s: \"%s\" %d new signatures\n"),
876                             keystr(keyid), p, n_sigs );
877                 if( n_subk == 1 )
878                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
879                             keystr(keyid), p);
880                 else if( n_subk )
881                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
882                             keystr(keyid), p, n_subk );
883                 m_free(p);
884               }
885
886             stats->n_uids +=n_uids;
887             stats->n_sigs +=n_sigs;
888             stats->n_subk +=n_subk;
889
890             if (is_status_enabled ()) 
891                  print_import_ok (pk, NULL,
892                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
893         }
894         else
895           {
896             if (is_status_enabled ()) 
897               print_import_ok (pk, NULL, 0);
898
899             if( !opt.quiet )
900               {
901                 char *p=get_user_id_native(keyid);
902                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
903                 m_free(p);
904               }
905
906             stats->unchanged++;
907           }
908
909         keydb_release (hd); hd = NULL;
910     }
911
912   leave:
913
914     /* Now that the key is definitely incorporated into the keydb, we
915        need to check if a designated revocation is present or if the
916        prefs are not rational so we can warn the user. */
917
918     if(mod_key)
919       {
920         revocation_present(keyblock_orig);
921         if(seckey_available(keyid)==0)
922           check_prefs(keyblock_orig);
923       }
924     else if(new_key)
925       {
926         revocation_present(keyblock);
927         if(seckey_available(keyid)==0)
928           check_prefs(keyblock);
929       }
930
931     release_kbnode( keyblock_orig );
932     free_public_key( pk_orig );
933
934     return rc;
935 }
936
937 /* Walk a secret keyblock and produce a public keyblock out of it. */
938 static KBNODE
939 sec_to_pub_keyblock(KBNODE sec_keyblock)
940 {
941   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
942
943   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
944     {
945       KBNODE pubnode;
946
947       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
948          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
949         {
950           /* Make a public key.  We only need to convert enough to
951              write the keyblock out. */
952
953           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
954           PACKET *pkt=m_alloc_clear(sizeof(PACKET));
955           PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
956           int n;
957
958           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
959             pkt->pkttype=PKT_PUBLIC_KEY;
960           else
961             pkt->pkttype=PKT_PUBLIC_SUBKEY;
962
963           pkt->pkt.public_key=pk;
964
965           pk->version=sk->version;
966           pk->timestamp=sk->timestamp;
967           pk->expiredate=sk->expiredate;
968           pk->pubkey_algo=sk->pubkey_algo;
969
970           n=pubkey_get_npkey(pk->pubkey_algo);
971           if(n==0)
972             {
973               /* we can't properly extract the pubkey without knowing
974                  the number of MPIs */
975               release_kbnode(pub_keyblock);
976               return NULL;
977             }
978           else
979             {
980               int i;
981
982               for(i=0;i<n;i++)
983                 pk->pkey[i]=mpi_copy(sk->skey[i]);
984             }
985
986           pubnode=new_kbnode(pkt);
987         }
988       else
989         {
990           pubnode=clone_kbnode(secnode);
991         }
992
993       if(pub_keyblock==NULL)
994         pub_keyblock=pubnode;
995       else
996         add_kbnode(pub_keyblock,pubnode);
997     }
998
999   return pub_keyblock;
1000 }
1001
1002 /****************
1003  * Ditto for secret keys.  Handling is simpler than for public keys.
1004  * We allow secret key importing only when allow is true, this is so
1005  * that a secret key can not be imported accidently and thereby tampering
1006  * with the trust calculation.
1007  */
1008 static int
1009 import_secret_one( const char *fname, KBNODE keyblock, 
1010                    struct stats_s *stats, unsigned int options)
1011 {
1012     PKT_secret_key *sk;
1013     KBNODE node, uidnode;
1014     u32 keyid[2];
1015     int rc = 0;
1016
1017     /* get the key and print some info about it */
1018     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1019     if( !node )
1020         BUG();
1021
1022     sk = node->pkt->pkt.secret_key;
1023     keyid_from_sk( sk, keyid );
1024     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1025
1026     if( opt.verbose )
1027       {
1028         log_info( "sec  %4u%c/%s %s   ",
1029                   nbits_from_sk( sk ),
1030                   pubkey_letter( sk->pubkey_algo ),
1031                   keystr_from_sk(sk), datestr_from_sk(sk) );
1032         if( uidnode )
1033           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1034                              uidnode->pkt->pkt.user_id->len );
1035         putc('\n', stderr);
1036       }
1037     stats->secret_read++;
1038
1039     if( !uidnode )
1040       {
1041         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1042         return 0;
1043       }
1044
1045     if(sk->protect.algo>110)
1046       {
1047         log_error(_("key %s: secret key with invalid cipher %d"
1048                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1049         return 0;
1050       }
1051
1052     clear_kbnode_flags( keyblock );
1053
1054     /* do we have this key already in one of our secrings ? */
1055     rc = seckey_available( keyid );
1056     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1057       {
1058         /* simply insert this key */
1059         KEYDB_HANDLE hd = keydb_new (1);
1060
1061         /* get default resource */
1062         rc = keydb_locate_writable (hd, NULL);
1063         if (rc) {
1064           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1065           keydb_release (hd);
1066           return G10ERR_GENERAL;
1067         }
1068         rc = keydb_insert_keyblock (hd, keyblock );
1069         if (rc)
1070           log_error (_("error writing keyring `%s': %s\n"),
1071                      keydb_get_resource_name (hd), g10_errstr(rc) );
1072         keydb_release (hd);
1073         /* we are ready */
1074         if( !opt.quiet )
1075           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1076         stats->secret_imported++;
1077         if (is_status_enabled ()) 
1078           print_import_ok (NULL, sk, 1|16);
1079
1080         if(options&IMPORT_SK2PK)
1081           {
1082             /* Try and make a public key out of this. */
1083
1084             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1085             if(pub_keyblock)
1086               {
1087                 import_one(fname,pub_keyblock,stats,opt.import_options);
1088                 release_kbnode(pub_keyblock);
1089               }
1090           }
1091
1092         /* Now that the key is definitely incorporated into the keydb,
1093            if we have the public part of this key, we need to check if
1094            the prefs are rational. */
1095         node=get_pubkeyblock(keyid);
1096         if(node)
1097           {
1098             check_prefs(node);
1099             release_kbnode(node);
1100           }
1101       }
1102     else if( !rc )
1103       { /* we can't merge secret keys */
1104         log_error( _("key %s: already in secret keyring\n"),
1105                    keystr_from_sk(sk));
1106         stats->secret_dups++;
1107         if (is_status_enabled ()) 
1108           print_import_ok (NULL, sk, 16);
1109
1110         /* TODO: if we ever do merge secret keys, make sure to handle
1111            the sec_to_pub_keyblock feature as well. */
1112       }
1113     else
1114       log_error( _("key %s: secret key not found: %s\n"),
1115                  keystr_from_sk(sk), g10_errstr(rc));
1116
1117     return rc;
1118 }
1119
1120
1121 /****************
1122  * Import a revocation certificate; this is a single signature packet.
1123  */
1124 static int
1125 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1126 {
1127     PKT_public_key *pk=NULL;
1128     KBNODE onode, keyblock = NULL;
1129     KEYDB_HANDLE hd = NULL;
1130     u32 keyid[2];
1131     int rc = 0;
1132
1133     assert( !node->next );
1134     assert( node->pkt->pkttype == PKT_SIGNATURE );
1135     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1136
1137     keyid[0] = node->pkt->pkt.signature->keyid[0];
1138     keyid[1] = node->pkt->pkt.signature->keyid[1];
1139
1140     pk = m_alloc_clear( sizeof *pk );
1141     rc = get_pubkey( pk, keyid );
1142     if( rc == G10ERR_NO_PUBKEY )
1143       {
1144         log_error(_("key %s: no public key -"
1145                     " can't apply revocation certificate\n"), keystr(keyid));
1146         rc = 0;
1147         goto leave;
1148       }
1149     else if( rc )
1150       {
1151         log_error(_("key %s: public key not found: %s\n"),
1152                   keystr(keyid), g10_errstr(rc));
1153         goto leave;
1154       }
1155
1156     /* read the original keyblock */
1157     hd = keydb_new (0);
1158     {
1159         byte afp[MAX_FINGERPRINT_LEN];
1160         size_t an;
1161         
1162         fingerprint_from_pk (pk, afp, &an);
1163         while (an < MAX_FINGERPRINT_LEN) 
1164             afp[an++] = 0;
1165         rc = keydb_search_fpr (hd, afp);
1166     }
1167     if (rc)
1168       {
1169         log_error (_("key %s: can't locate original keyblock: %s\n"),
1170                    keystr(keyid), g10_errstr(rc));
1171         goto leave;
1172       }
1173     rc = keydb_get_keyblock (hd, &keyblock );
1174     if (rc)
1175       {
1176         log_error (_("key %s: can't read original keyblock: %s\n"),
1177                    keystr(keyid), g10_errstr(rc));
1178         goto leave;
1179       }
1180
1181     /* it is okay, that node is not in keyblock because
1182      * check_key_signature works fine for sig_class 0x20 in this
1183      * special case. */
1184     rc = check_key_signature( keyblock, node, NULL);
1185     if( rc )
1186       {
1187         log_error( _("key %s: invalid revocation certificate"
1188                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1189         goto leave;
1190       }
1191
1192     /* check whether we already have this */
1193     for(onode=keyblock->next; onode; onode=onode->next ) {
1194         if( onode->pkt->pkttype == PKT_USER_ID )
1195             break;
1196         else if( onode->pkt->pkttype == PKT_SIGNATURE
1197                  && !cmp_signatures(node->pkt->pkt.signature,
1198                                     onode->pkt->pkt.signature))
1199           {
1200             rc = 0;
1201             goto leave; /* yes, we already know about it */
1202           }
1203     }
1204
1205
1206     /* insert it */
1207     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1208
1209     /* and write the keyblock back */
1210     rc = keydb_update_keyblock (hd, keyblock );
1211     if (rc)
1212         log_error (_("error writing keyring `%s': %s\n"),
1213                    keydb_get_resource_name (hd), g10_errstr(rc) );
1214     keydb_release (hd); hd = NULL;
1215     /* we are ready */
1216     if( !opt.quiet )
1217       {
1218         char *p=get_user_id_native (keyid);
1219         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1220                   keystr(keyid),p);
1221         m_free(p);
1222       }
1223     stats->n_revoc++;
1224
1225     /* If the key we just revoked was ultimately trusted, remove its
1226        ultimate trust.  This doesn't stop the user from putting the
1227        ultimate trust back, but is a reasonable solution for now. */
1228     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1229       clear_ownertrusts(pk);
1230
1231     revalidation_mark ();
1232
1233   leave:
1234     keydb_release (hd);
1235     release_kbnode( keyblock );
1236     free_public_key( pk );
1237     return rc;
1238 }
1239
1240
1241 /****************
1242  * loop over the keyblock and check all self signatures.
1243  * Mark all user-ids with a self-signature by setting flag bit 0.
1244  * Mark all user-ids with an invalid self-signature by setting bit 1.
1245  * This works also for subkeys, here the subkey is marked.  Invalid or
1246  * extra subkey sigs (binding or revocation) are marked for deletion.
1247  * non_self is set to true if there are any sigs other than self-sigs
1248  * in this keyblock.
1249  */
1250 static int
1251 chk_self_sigs( const char *fname, KBNODE keyblock,
1252                PKT_public_key *pk, u32 *keyid, int *non_self )
1253 {
1254     KBNODE n,knode=NULL;
1255     PKT_signature *sig;
1256     int rc;
1257     u32 bsdate=0,rsdate=0;
1258     KBNODE bsnode=NULL,rsnode=NULL;
1259
1260     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1261       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1262         {
1263           knode=n;
1264           bsdate=0;
1265           rsdate=0;
1266           bsnode=NULL;
1267           rsnode=NULL;
1268           continue;
1269         }
1270       else if( n->pkt->pkttype != PKT_SIGNATURE )
1271             continue;
1272         sig = n->pkt->pkt.signature;
1273         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1274
1275           /* This just caches the sigs for later use.  That way we
1276              import a fully-cached key which speeds things up. */
1277           if(!opt.no_sig_cache)
1278             check_key_signature(keyblock,n,NULL);
1279
1280             if( (sig->sig_class&~3) == 0x10 ) {
1281                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1282                 if( !unode )
1283                   {
1284                     log_error( _("key %s: no user ID for signature\n"),
1285                                keystr(keyid));
1286                     return -1;  /* the complete keyblock is invalid */
1287                   }
1288
1289                 /* If it hasn't been marked valid yet, keep trying */
1290                 if(!(unode->flag&1)) {
1291                   rc = check_key_signature( keyblock, n, NULL);
1292                   if( rc )
1293                     {
1294                       if( opt.verbose )
1295                         {
1296                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1297                                       strlen(unode->pkt->pkt.user_id->name),0);
1298                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1299                                     _("key %s: unsupported public key "
1300                                       "algorithm on user id \"%s\"\n"):
1301                                     _("key %s: invalid self-signature "
1302                                       "on user id \"%s\"\n"),
1303                                     keystr(keyid),p);
1304                           m_free(p);
1305                         }
1306                     }
1307                   else
1308                     unode->flag |= 1; /* mark that signature checked */
1309                 }
1310             }
1311             else if( sig->sig_class == 0x18 ) {
1312               /* Note that this works based solely on the timestamps
1313                  like the rest of gpg.  If the standard gets
1314                  revocation targets, this may need to be revised. */
1315
1316                 if( !knode )
1317                   {
1318                     if(opt.verbose)
1319                       log_info( _("key %s: no subkey for key binding\n"),
1320                                 keystr(keyid));
1321                     n->flag |= 4; /* delete this */
1322                   }
1323                 else
1324                   {
1325                     rc = check_key_signature( keyblock, n, NULL);
1326                     if( rc )
1327                       {
1328                         if(opt.verbose)
1329                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1330                                    _("key %s: unsupported public key"
1331                                      " algorithm\n"):
1332                                    _("key %s: invalid subkey binding\n"),
1333                                    keystr(keyid));
1334                         n->flag|=4;
1335                       }
1336                     else
1337                       {
1338                         /* It's valid, so is it newer? */
1339                         if(sig->timestamp>=bsdate) {
1340                           knode->flag |= 1;  /* the subkey is valid */
1341                           if(bsnode)
1342                             {
1343                               bsnode->flag|=4; /* Delete the last binding
1344                                                   sig since this one is
1345                                                   newer */
1346                               if(opt.verbose)
1347                                 log_info(_("key %s: removed multiple subkey"
1348                                            " binding\n"),keystr(keyid));
1349                             }
1350
1351                           bsnode=n;
1352                           bsdate=sig->timestamp;
1353                         }
1354                         else
1355                           n->flag|=4; /* older */
1356                       }
1357                   }
1358             }
1359             else if( sig->sig_class == 0x28 ) {
1360               /* We don't actually mark the subkey as revoked right
1361                  now, so just check that the revocation sig is the
1362                  most recent valid one.  Note that we don't care if
1363                  the binding sig is newer than the revocation sig.
1364                  See the comment in getkey.c:merge_selfsigs_subkey for
1365                  more */
1366                 if( !knode )
1367                   {
1368                     if(opt.verbose)
1369                       log_info( _("key %s: no subkey for key revocation\n"),
1370                                 keystr(keyid));
1371                     n->flag |= 4; /* delete this */
1372                   }
1373                 else
1374                   {
1375                     rc = check_key_signature( keyblock, n, NULL);
1376                     if( rc )
1377                       {
1378                         if(opt.verbose)
1379                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1380                                    _("key %s: unsupported public"
1381                                      " key algorithm\n"):
1382                                    _("key %s: invalid subkey revocation\n"),
1383                                    keystr(keyid));
1384                         n->flag|=4;
1385                       }
1386                     else
1387                       {
1388                         /* It's valid, so is it newer? */
1389                         if(sig->timestamp>=rsdate)
1390                           {
1391                             if(rsnode)
1392                               {
1393                                 rsnode->flag|=4; /* Delete the last revocation
1394                                                     sig since this one is
1395                                                     newer */
1396                                 if(opt.verbose)
1397                                   log_info(_("key %s: removed multiple subkey"
1398                                              " revocation\n"),keystr(keyid));
1399                               }
1400
1401                             rsnode=n;
1402                             rsdate=sig->timestamp;
1403                           }
1404                         else
1405                           n->flag|=4; /* older */
1406                       }
1407                   }
1408             }
1409         }
1410         else
1411           *non_self=1;
1412     }
1413
1414     return 0;
1415 }
1416
1417 /****************
1418  * delete all parts which are invalid and those signatures whose
1419  * public key algorithm is not available in this implemenation;
1420  * but consider RSA as valid, because parse/build_packets knows
1421  * about it.
1422  * returns: true if at least one valid user-id is left over.
1423  */
1424 static int
1425 delete_inv_parts( const char *fname, KBNODE keyblock,
1426                   u32 *keyid, unsigned int options)
1427 {
1428     KBNODE node;
1429     int nvalid=0, uid_seen=0, subkey_seen=0;
1430
1431     for(node=keyblock->next; node; node = node->next ) {
1432         if( node->pkt->pkttype == PKT_USER_ID ) {
1433             uid_seen = 1;
1434             if( (node->flag & 2) || !(node->flag & 1) ) {
1435                 if( opt.verbose )
1436                   {
1437                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1438                                            node->pkt->pkt.user_id->len,0);
1439                     log_info( _("key %s: skipped user ID '%s'\n"),
1440                               keystr(keyid),p);
1441                     m_free(p);
1442                   }
1443                 delete_kbnode( node ); /* the user-id */
1444                 /* and all following packets up to the next user-id */
1445                 while( node->next
1446                        && node->next->pkt->pkttype != PKT_USER_ID
1447                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1448                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1449                     delete_kbnode( node->next );
1450                     node = node->next;
1451                 }
1452             }
1453             else
1454                 nvalid++;
1455         }
1456         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1457                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1458             if( (node->flag & 2) || !(node->flag & 1) ) {
1459                 if( opt.verbose )
1460                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1461
1462                 delete_kbnode( node ); /* the subkey */
1463                 /* and all following signature packets */
1464                 while( node->next
1465                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1466                     delete_kbnode( node->next );
1467                     node = node->next;
1468                 }
1469             }
1470             else
1471               subkey_seen = 1;
1472         }
1473         else if( node->pkt->pkttype == PKT_SIGNATURE
1474                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1475                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1476             delete_kbnode( node ); /* build_packet() can't handle this */
1477         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1478                  !node->pkt->pkt.signature->flags.exportable &&
1479                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1480                  seckey_available( node->pkt->pkt.signature->keyid ) )
1481           {
1482             /* here we violate the rfc a bit by still allowing
1483              * to import non-exportable signature when we have the
1484              * the secret key used to create this signature - it
1485              * seems that this makes sense */
1486             if(opt.verbose)
1487               log_info( _("key %s: non exportable signature"
1488                           " (class %02x) - skipped\n"),
1489                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1490             delete_kbnode( node );
1491           }
1492         else if( node->pkt->pkttype == PKT_SIGNATURE
1493                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1494             if( uid_seen )
1495               {
1496                 if(opt.verbose)
1497                   log_info( _("key %s: revocation certificate"
1498                               " at wrong place - skipped\n"),keystr(keyid));
1499                 delete_kbnode( node );
1500               }
1501             else {
1502               /* If the revocation cert is from a different key than
1503                  the one we're working on don't check it - it's
1504                  probably from a revocation key and won't be
1505                  verifiable with this key anyway. */
1506
1507               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1508                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1509                 {
1510                   int rc = check_key_signature( keyblock, node, NULL);
1511                   if( rc )
1512                     {
1513                       if(opt.verbose)
1514                         log_info( _("key %s: invalid revocation"
1515                                     " certificate: %s - skipped\n"),
1516                                   keystr(keyid), g10_errstr(rc));
1517                       delete_kbnode( node );
1518                     }
1519                 }
1520             }
1521         }
1522         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1523                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1524                   node->pkt->pkt.signature->sig_class == 0x28) &&
1525                  !subkey_seen )
1526           {
1527             if(opt.verbose)
1528               log_info( _("key %s: subkey signature"
1529                           " in wrong place - skipped\n"), keystr(keyid));
1530             delete_kbnode( node );
1531           }
1532         else if( node->pkt->pkttype == PKT_SIGNATURE
1533                  && !IS_CERT(node->pkt->pkt.signature))
1534           {
1535             if(opt.verbose)
1536               log_info(_("key %s: unexpected signature class (0x%02X) -"
1537                          " skipped\n"),keystr(keyid),
1538                        node->pkt->pkt.signature->sig_class);
1539             delete_kbnode(node);
1540           }
1541         else if( (node->flag & 4) ) /* marked for deletion */
1542             delete_kbnode( node );
1543     }
1544
1545     /* note: because keyblock is the public key, it is never marked
1546      * for deletion and so keyblock cannot change */
1547     commit_kbnode( &keyblock );
1548     return nvalid;
1549 }
1550
1551
1552 /****************
1553  * It may happen that the imported keyblock has duplicated user IDs.
1554  * We check this here and collapse those user IDs together with their
1555  * sigs into one.
1556  * Returns: True if the keyblock hash changed.
1557  */
1558 int
1559 collapse_uids( KBNODE *keyblock )
1560 {
1561     KBNODE n, n2;
1562     int in_uid;
1563     int any=0;
1564
1565   restart:
1566     for( n = *keyblock; n; n = n->next ) {
1567         if( n->pkt->pkttype != PKT_USER_ID )
1568             continue;
1569         for( n2 = n->next; n2; n2 = n2->next ) {
1570             if( n2->pkt->pkttype == PKT_USER_ID
1571                 && !cmp_user_ids( n->pkt->pkt.user_id,
1572                                   n2->pkt->pkt.user_id ) ) {
1573                 /* found a duplicate */
1574                 any = 1;
1575                 if( !n2->next
1576                     || n2->next->pkt->pkttype == PKT_USER_ID
1577                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1578                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1579                     /* no more signatures: delete the user ID
1580                      * and start over */
1581                     remove_kbnode( keyblock, n2 );
1582                 }
1583                 else {
1584                     /* The simple approach: Move one signature and
1585                      * then start over to delete the next one :-( */
1586                     move_kbnode( keyblock, n2->next, n->next );
1587                 }
1588                 goto restart;
1589             }
1590         }
1591     }
1592     if( !any )
1593         return 0;
1594
1595   restart_sig:
1596     /* now we may have duplicate signatures on one user ID: fix this */
1597     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1598         if( n->pkt->pkttype == PKT_USER_ID )
1599             in_uid = 1;
1600         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1601                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1602             in_uid = 0;
1603         else if( in_uid ) {
1604             n2 = n;
1605             do {
1606                 KBNODE ncmp = NULL;
1607                 for( ; n2; n2 = n2->next ) {
1608                     if(    n2->pkt->pkttype == PKT_USER_ID
1609                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1610                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1611                         break;
1612                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1613                         ;
1614                     else if( !ncmp )
1615                         ncmp = n2;
1616                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1617                                                 n2->pkt->pkt.signature )) {
1618                         remove_kbnode( keyblock, n2 );
1619                         goto restart_sig;
1620                     }
1621                 }
1622                 n2 = ncmp? ncmp->next : NULL;
1623             } while( n2 );
1624         }
1625     }
1626
1627     if(!opt.quiet)
1628       {
1629         const char *key="???";
1630
1631         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1632           key=keystr_from_pk(n->pkt->pkt.public_key);
1633         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1634           key=keystr_from_sk(n->pkt->pkt.secret_key);
1635
1636         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1637       }
1638
1639     return 1;
1640 }
1641
1642 /* Check for a 0x20 revocation from a revocation key that is not
1643    present.  This may be called without the benefit of merge_xxxx so
1644    you can't rely on pk->revkey and friends. */
1645 static void
1646 revocation_present(KBNODE keyblock)
1647 {
1648   KBNODE onode,inode;
1649   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1650
1651   for(onode=keyblock->next;onode;onode=onode->next)
1652     {
1653       /* If we reach user IDs, we're done. */
1654       if(onode->pkt->pkttype==PKT_USER_ID)
1655         break;
1656
1657       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1658          onode->pkt->pkt.signature->sig_class==0x1F &&
1659          onode->pkt->pkt.signature->revkey)
1660         {
1661           int idx;
1662           PKT_signature *sig=onode->pkt->pkt.signature;
1663
1664           for(idx=0;idx<sig->numrevkeys;idx++)
1665             {
1666               u32 keyid[2];
1667
1668               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1669                                      MAX_FINGERPRINT_LEN,keyid);
1670
1671               for(inode=keyblock->next;inode;inode=inode->next)
1672                 {
1673                   /* If we reach user IDs, we're done. */
1674                   if(inode->pkt->pkttype==PKT_USER_ID)
1675                     break;
1676
1677                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1678                      inode->pkt->pkt.signature->sig_class==0x20 &&
1679                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1680                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1681                     {
1682                       /* Okay, we have a revocation key, and a
1683                          revocation issued by it.  Do we have the key
1684                          itself? */
1685                       int rc;
1686
1687                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1688                                                    MAX_FINGERPRINT_LEN);
1689                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1690                         {
1691                           char *tempkeystr=m_strdup(keystr_from_pk(pk));
1692
1693                           /* No, so try and get it */
1694                           if(opt.keyserver
1695                              && (opt.keyserver_options.options
1696                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1697                             {
1698                               log_info(_("WARNING: key %s may be revoked:"
1699                                          " fetching revocation key %s\n"),
1700                                        tempkeystr,keystr(keyid));
1701                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1702                                                       MAX_FINGERPRINT_LEN);
1703
1704                               /* Do we have it now? */
1705                               rc=get_pubkey_byfprint_fast (NULL,
1706                                                      sig->revkey[idx]->fpr,
1707                                                      MAX_FINGERPRINT_LEN);
1708                             }
1709
1710                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1711                             log_info(_("WARNING: key %s may be revoked:"
1712                                        " revocation key %s not present.\n"),
1713                                      tempkeystr,keystr(keyid));
1714
1715                           m_free(tempkeystr);
1716                         }
1717                     }
1718                 }
1719             }
1720         }
1721     }
1722 }
1723
1724 /****************
1725  * compare and merge the blocks
1726  *
1727  * o compare the signatures: If we already have this signature, check
1728  *   that they compare okay; if not, issue a warning and ask the user.
1729  * o Simply add the signature.  Can't verify here because we may not have
1730  *   the signature's public key yet; verification is done when putting it
1731  *   into the trustdb, which is done automagically as soon as this pubkey
1732  *   is used.
1733  * Note: We indicate newly inserted packets with flag bit 0
1734  */
1735 static int
1736 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1737               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1738 {
1739     KBNODE onode, node;
1740     int rc, found;
1741
1742     /* 1st: handle revocation certificates */
1743     for(node=keyblock->next; node; node=node->next ) {
1744         if( node->pkt->pkttype == PKT_USER_ID )
1745             break;
1746         else if( node->pkt->pkttype == PKT_SIGNATURE
1747                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1748             /* check whether we already have this */
1749             found = 0;
1750             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1751                 if( onode->pkt->pkttype == PKT_USER_ID )
1752                     break;
1753                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1754                          && onode->pkt->pkt.signature->sig_class == 0x20
1755                          && !cmp_signatures(onode->pkt->pkt.signature,
1756                                             node->pkt->pkt.signature))
1757                   {
1758                     found = 1;
1759                     break;
1760                   }
1761             }
1762             if( !found ) {
1763                 KBNODE n2 = clone_kbnode(node);
1764                 insert_kbnode( keyblock_orig, n2, 0 );
1765                 n2->flag |= 1;
1766                 ++*n_sigs;
1767                 if(!opt.quiet)
1768                   {
1769                     char *p=get_user_id_native (keyid);
1770                     log_info(_("key %s: \"%s\" revocation"
1771                                " certificate added\n"), keystr(keyid),p);
1772                     m_free(p);
1773                   }
1774             }
1775         }
1776     }
1777
1778     /* 2nd: merge in any direct key (0x1F) sigs */
1779     for(node=keyblock->next; node; node=node->next ) {
1780         if( node->pkt->pkttype == PKT_USER_ID )
1781             break;
1782         else if( node->pkt->pkttype == PKT_SIGNATURE
1783                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1784             /* check whether we already have this */
1785             found = 0;
1786             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1787                 if( onode->pkt->pkttype == PKT_USER_ID )
1788                     break;
1789                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1790                          && onode->pkt->pkt.signature->sig_class == 0x1F
1791                          && !cmp_signatures(onode->pkt->pkt.signature,
1792                                             node->pkt->pkt.signature)) {
1793                     found = 1;
1794                     break;
1795                 }
1796             }
1797             if( !found )
1798               {
1799                 KBNODE n2 = clone_kbnode(node);
1800                 insert_kbnode( keyblock_orig, n2, 0 );
1801                 n2->flag |= 1;
1802                 ++*n_sigs;
1803                 if(!opt.quiet)
1804                   log_info( _("key %s: direct key signature added\n"),
1805                             keystr(keyid));
1806               }
1807         }
1808     }
1809
1810     /* 3rd: try to merge new certificates in */
1811     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1812         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1813             /* find the user id in the imported keyblock */
1814             for(node=keyblock->next; node; node=node->next )
1815                 if( node->pkt->pkttype == PKT_USER_ID
1816                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1817                                           node->pkt->pkt.user_id ) )
1818                     break;
1819             if( node ) { /* found: merge */
1820                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1821                 if( rc )
1822                     return rc;
1823             }
1824         }
1825     }
1826
1827     /* 4th: add new user-ids */
1828     for(node=keyblock->next; node; node=node->next ) {
1829         if( node->pkt->pkttype == PKT_USER_ID) {
1830             /* do we have this in the original keyblock */
1831             for(onode=keyblock_orig->next; onode; onode=onode->next )
1832                 if( onode->pkt->pkttype == PKT_USER_ID
1833                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1834                                       node->pkt->pkt.user_id ) )
1835                     break;
1836             if( !onode ) { /* this is a new user id: append */
1837                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1838                 if( rc )
1839                     return rc;
1840                 ++*n_uids;
1841             }
1842         }
1843     }
1844
1845     /* 5th: add new subkeys */
1846     for(node=keyblock->next; node; node=node->next ) {
1847         onode = NULL;
1848         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1849             /* do we have this in the original keyblock? */
1850             for(onode=keyblock_orig->next; onode; onode=onode->next )
1851                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1852                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1853                                          node->pkt->pkt.public_key ) )
1854                     break;
1855             if( !onode ) { /* this is a new subkey: append */
1856                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1857                 if( rc )
1858                     return rc;
1859                 ++*n_subk;
1860             }
1861         }
1862         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1863             /* do we have this in the original keyblock? */
1864             for(onode=keyblock_orig->next; onode; onode=onode->next )
1865                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1866                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1867                                          node->pkt->pkt.secret_key ) )
1868                     break;
1869             if( !onode ) { /* this is a new subkey: append */
1870                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1871                 if( rc )
1872                     return rc;
1873                 ++*n_subk;
1874             }
1875         }
1876     }
1877
1878     /* 6th: merge subkey certificates */
1879     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1880         if( !(onode->flag & 1)
1881             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1882                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1883             /* find the subkey in the imported keyblock */
1884             for(node=keyblock->next; node; node=node->next ) {
1885                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1886                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1887                                           node->pkt->pkt.public_key ) )
1888                     break;
1889                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1890                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1891                                           node->pkt->pkt.secret_key ) )
1892                     break;
1893             }
1894             if( node ) { /* found: merge */
1895                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1896                 if( rc )
1897                     return rc;
1898             }
1899         }
1900     }
1901
1902
1903     return 0;
1904 }
1905
1906
1907 /****************
1908  * append the userid starting with NODE and all signatures to KEYBLOCK.
1909  */
1910 static int
1911 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1912                                           const char *fname, u32 *keyid )
1913 {
1914     KBNODE n, n_where=NULL;
1915
1916     assert(node->pkt->pkttype == PKT_USER_ID );
1917
1918     /* find the position */
1919     for( n = keyblock; n; n_where = n, n = n->next ) {
1920         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1921             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1922             break;
1923     }
1924     if( !n )
1925         n_where = NULL;
1926
1927     /* and append/insert */
1928     while( node ) {
1929         /* we add a clone to the original keyblock, because this
1930          * one is released first */
1931         n = clone_kbnode(node);
1932         if( n_where ) {
1933             insert_kbnode( n_where, n, 0 );
1934             n_where = n;
1935         }
1936         else
1937             add_kbnode( keyblock, n );
1938         n->flag |= 1;
1939         node->flag |= 1;
1940         if( n->pkt->pkttype == PKT_SIGNATURE )
1941             ++*n_sigs;
1942
1943         node = node->next;
1944         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1945             break;
1946     }
1947
1948     return 0;
1949 }
1950
1951
1952 /****************
1953  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1954  * (how should we handle comment packets here?)
1955  */
1956 static int
1957 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1958                                     const char *fname, u32 *keyid )
1959 {
1960     KBNODE n, n2;
1961     int found=0;
1962
1963     assert(dst->pkt->pkttype == PKT_USER_ID );
1964     assert(src->pkt->pkttype == PKT_USER_ID );
1965
1966     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1967         if( n->pkt->pkttype != PKT_SIGNATURE )
1968             continue;
1969         if( n->pkt->pkt.signature->sig_class == 0x18
1970             || n->pkt->pkt.signature->sig_class == 0x28 )
1971             continue; /* skip signatures which are only valid on subkeys */
1972         found = 0;
1973         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
1974           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
1975             {
1976               found++;
1977               break;
1978             }
1979         if( !found ) {
1980             /* This signature is new or newer, append N to DST.
1981              * We add a clone to the original keyblock, because this
1982              * one is released first */
1983             n2 = clone_kbnode(n);
1984             insert_kbnode( dst, n2, PKT_SIGNATURE );
1985             n2->flag |= 1;
1986             n->flag |= 1;
1987             ++*n_sigs;
1988         }
1989     }
1990
1991     return 0;
1992 }
1993
1994 /****************
1995  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1996  */
1997 static int
1998 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1999                                     const char *fname, u32 *keyid )
2000 {
2001     KBNODE n, n2;
2002     int found=0;
2003
2004     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2005            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2006
2007     for(n=src->next; n ; n = n->next ) {
2008         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2009             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2010             break;
2011         if( n->pkt->pkttype != PKT_SIGNATURE )
2012             continue;
2013         found = 0;
2014         for(n2=dst->next; n2; n2 = n2->next){
2015             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2016                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2017                 break;
2018             if( n2->pkt->pkttype == PKT_SIGNATURE
2019                 && n->pkt->pkt.signature->keyid[0]
2020                    == n2->pkt->pkt.signature->keyid[0]
2021                 && n->pkt->pkt.signature->keyid[1]
2022                    == n2->pkt->pkt.signature->keyid[1]
2023                 && n->pkt->pkt.signature->timestamp
2024                    <= n2->pkt->pkt.signature->timestamp
2025                 && n->pkt->pkt.signature->sig_class
2026                    == n2->pkt->pkt.signature->sig_class ) {
2027                 found++;
2028                 break;
2029             }
2030         }
2031         if( !found ) {
2032             /* This signature is new or newer, append N to DST.
2033              * We add a clone to the original keyblock, because this
2034              * one is released first */
2035             n2 = clone_kbnode(n);
2036             insert_kbnode( dst, n2, PKT_SIGNATURE );
2037             n2->flag |= 1;
2038             n->flag |= 1;
2039             ++*n_sigs;
2040         }
2041     }
2042
2043     return 0;
2044 }
2045
2046 /****************
2047  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2048  * Mark all new and copied packets by setting flag bit 0.
2049  */
2050 static int
2051 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2052                                           const char *fname, u32 *keyid )
2053 {
2054     KBNODE n;
2055
2056     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2057            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2058
2059     while(  node ) {
2060         /* we add a clone to the original keyblock, because this
2061          * one is released first */
2062         n = clone_kbnode(node);
2063         add_kbnode( keyblock, n );
2064         n->flag |= 1;
2065         node->flag |= 1;
2066         if( n->pkt->pkttype == PKT_SIGNATURE )
2067             ++*n_sigs;
2068
2069         node = node->next;
2070         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2071             break;
2072     }
2073
2074     return 0;
2075 }