* import.c (check_prefs_warning, check_prefs): --keyid-format conversion
[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         rc = keydb_insert_keyblock (hd, keyblock );
762         if (rc)
763            log_error (_("error writing keyring `%s': %s\n"),
764                        keydb_get_resource_name (hd), g10_errstr(rc));
765         else
766           {
767             /* This should not be possible since we delete the
768                ownertrust when a key is deleted, but it can happen if
769                the keyring and trustdb are out of sync.  It can also
770                be made to happen with the trusted-key command. */
771
772             clear_ownertrusts (pk);
773             if(non_self)
774               revalidation_mark ();
775           }
776         keydb_release (hd);
777
778         /* we are ready */
779         if( !opt.quiet )
780           {
781             char *p=get_user_id_printable (keyid);
782             log_info( _("key %s: public key \"%s\" imported\n"),
783                       keystr(keyid),p);
784             m_free(p);
785           }
786         if( is_status_enabled() )
787           {
788             char *us = get_long_user_id_string( keyid );
789             write_status_text( STATUS_IMPORTED, us );
790             m_free(us);
791             print_import_ok (pk,NULL, 1);
792           }
793         stats->imported++;
794         if( is_RSA( pk->pubkey_algo ) )
795             stats->imported_rsa++;
796         new_key = 1;
797     }
798     else { /* merge */
799         KEYDB_HANDLE hd;
800         int n_uids, n_sigs, n_subk;
801
802         /* Compare the original against the new key; just to be sure nothing
803          * weird is going on */
804         if( cmp_public_keys( pk_orig, pk ) )
805           {
806             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
807             goto leave;
808           }
809
810         /* now read the original keyblock */
811         hd = keydb_new (0);
812         {
813             byte afp[MAX_FINGERPRINT_LEN];
814             size_t an;
815
816             fingerprint_from_pk (pk_orig, afp, &an);
817             while (an < MAX_FINGERPRINT_LEN) 
818                 afp[an++] = 0;
819             rc = keydb_search_fpr (hd, afp);
820         }
821         if( rc )
822           {
823             log_error (_("key %s: can't locate original keyblock: %s\n"),
824                        keystr(keyid), g10_errstr(rc));
825             keydb_release (hd);
826             goto leave;
827           }
828         rc = keydb_get_keyblock (hd, &keyblock_orig );
829         if (rc)
830           {
831             log_error (_("key %s: can't read original keyblock: %s\n"),
832                        keystr(keyid), g10_errstr(rc));
833             keydb_release (hd);
834             goto leave;
835           }
836
837         collapse_uids( &keyblock );
838         /* and try to merge the block */
839         clear_kbnode_flags( keyblock_orig );
840         clear_kbnode_flags( keyblock );
841         n_uids = n_sigs = n_subk = 0;
842         rc = merge_blocks( fname, keyblock_orig, keyblock,
843                                 keyid, &n_uids, &n_sigs, &n_subk );
844         if( rc ) {
845             keydb_release (hd);
846             goto leave;
847         }
848         if( n_uids || n_sigs || n_subk ) {
849             mod_key = 1;
850             /* keyblock_orig has been updated; write */
851             rc = keydb_update_keyblock (hd, keyblock_orig);
852             if (rc)
853                 log_error (_("error writing keyring `%s': %s\n"),
854                              keydb_get_resource_name (hd), g10_errstr(rc) );
855             else if(non_self)
856               revalidation_mark ();
857
858             /* we are ready */
859             if( !opt.quiet )
860               {
861                 char *p=get_user_id_printable(keyid);
862                 if( n_uids == 1 )
863                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
864                            keystr(keyid),p);
865                 else if( n_uids )
866                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
867                             keystr(keyid),p,n_uids);
868                 if( n_sigs == 1 )
869                   log_info( _("key %s: \"%s\" 1 new signature\n"),
870                             keystr(keyid), p);
871                 else if( n_sigs )
872                   log_info( _("key %s: \"%s\" %d new signatures\n"),
873                             keystr(keyid), p, n_sigs );
874                 if( n_subk == 1 )
875                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
876                             keystr(keyid), p);
877                 else if( n_subk )
878                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
879                             keystr(keyid), p, n_subk );
880                 m_free(p);
881               }
882
883             stats->n_uids +=n_uids;
884             stats->n_sigs +=n_sigs;
885             stats->n_subk +=n_subk;
886
887             if (is_status_enabled ()) 
888                  print_import_ok (pk, NULL,
889                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
890         }
891         else
892           {
893             if (is_status_enabled ()) 
894               print_import_ok (pk, NULL, 0);
895
896             if( !opt.quiet )
897               {
898                 char *p=get_user_id_printable(keyid);
899                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
900                 m_free(p);
901               }
902
903             stats->unchanged++;
904           }
905
906         keydb_release (hd); hd = NULL;
907     }
908
909   leave:
910
911     /* Now that the key is definitely incorporated into the keydb, we
912        need to check if a designated revocation is present or if the
913        prefs are not rational so we can warn the user. */
914
915     if(mod_key)
916       {
917         revocation_present(keyblock_orig);
918         if(seckey_available(keyid)==0)
919           check_prefs(keyblock_orig);
920       }
921     else if(new_key)
922       {
923         revocation_present(keyblock);
924         if(seckey_available(keyid)==0)
925           check_prefs(keyblock);
926       }
927
928     release_kbnode( keyblock_orig );
929     free_public_key( pk_orig );
930
931     return rc;
932 }
933
934 /* Walk a secret keyblock and produce a public keyblock out of it. */
935 static KBNODE
936 sec_to_pub_keyblock(KBNODE sec_keyblock)
937 {
938   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
939
940   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
941     {
942       KBNODE pubnode;
943
944       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
945          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
946         {
947           /* Make a public key.  We only need to convert enough to
948              write the keyblock out. */
949
950           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
951           PACKET *pkt=m_alloc_clear(sizeof(PACKET));
952           PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
953           int n;
954
955           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
956             pkt->pkttype=PKT_PUBLIC_KEY;
957           else
958             pkt->pkttype=PKT_PUBLIC_SUBKEY;
959
960           pkt->pkt.public_key=pk;
961
962           pk->version=sk->version;
963           pk->timestamp=sk->timestamp;
964           pk->expiredate=sk->expiredate;
965           pk->pubkey_algo=sk->pubkey_algo;
966
967           n=pubkey_get_npkey(pk->pubkey_algo);
968           if(n==0)
969             {
970               /* we can't properly extract the pubkey without knowing
971                  the number of MPIs */
972               release_kbnode(pub_keyblock);
973               return NULL;
974             }
975           else
976             {
977               int i;
978
979               for(i=0;i<n;i++)
980                 pk->pkey[i]=mpi_copy(sk->skey[i]);
981             }
982
983           pubnode=new_kbnode(pkt);
984         }
985       else
986         {
987           pubnode=clone_kbnode(secnode);
988         }
989
990       if(pub_keyblock==NULL)
991         pub_keyblock=pubnode;
992       else
993         add_kbnode(pub_keyblock,pubnode);
994     }
995
996   return pub_keyblock;
997 }
998
999 /****************
1000  * Ditto for secret keys.  Handling is simpler than for public keys.
1001  * We allow secret key importing only when allow is true, this is so
1002  * that a secret key can not be imported accidently and thereby tampering
1003  * with the trust calculation.
1004  */
1005 static int
1006 import_secret_one( const char *fname, KBNODE keyblock, 
1007                    struct stats_s *stats, unsigned int options)
1008 {
1009     PKT_secret_key *sk;
1010     KBNODE node, uidnode;
1011     u32 keyid[2];
1012     int rc = 0;
1013
1014     /* get the key and print some info about it */
1015     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1016     if( !node )
1017         BUG();
1018
1019     sk = node->pkt->pkt.secret_key;
1020     keyid_from_sk( sk, keyid );
1021     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1022
1023     if( opt.verbose )
1024       {
1025         log_info( "sec  %4u%c/%s %s   ",
1026                   nbits_from_sk( sk ),
1027                   pubkey_letter( sk->pubkey_algo ),
1028                   keystr_from_sk(sk), datestr_from_sk(sk) );
1029         if( uidnode )
1030           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1031                              uidnode->pkt->pkt.user_id->len );
1032         putc('\n', stderr);
1033       }
1034     stats->secret_read++;
1035
1036     if( !uidnode )
1037       {
1038         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1039         return 0;
1040       }
1041
1042     if(sk->protect.algo>110)
1043       {
1044         log_error(_("key %s: secret key with invalid cipher %d"
1045                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1046         return 0;
1047       }
1048
1049     clear_kbnode_flags( keyblock );
1050
1051     /* do we have this key already in one of our secrings ? */
1052     rc = seckey_available( keyid );
1053     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1054       {
1055         /* simply insert this key */
1056         KEYDB_HANDLE hd = keydb_new (1);
1057
1058         /* get default resource */
1059         rc = keydb_locate_writable (hd, NULL);
1060         if (rc) {
1061           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1062           keydb_release (hd);
1063           return G10ERR_GENERAL;
1064         }
1065         rc = keydb_insert_keyblock (hd, keyblock );
1066         if (rc)
1067           log_error (_("error writing keyring `%s': %s\n"),
1068                      keydb_get_resource_name (hd), g10_errstr(rc) );
1069         keydb_release (hd);
1070         /* we are ready */
1071         if( !opt.quiet )
1072           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1073         stats->secret_imported++;
1074         if (is_status_enabled ()) 
1075           print_import_ok (NULL, sk, 1|16);
1076
1077         if(options&IMPORT_SK2PK)
1078           {
1079             /* Try and make a public key out of this. */
1080
1081             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1082             if(pub_keyblock)
1083               {
1084                 import_one(fname,pub_keyblock,stats,opt.import_options);
1085                 release_kbnode(pub_keyblock);
1086               }
1087           }
1088
1089         /* Now that the key is definitely incorporated into the keydb,
1090            if we have the public part of this key, we need to check if
1091            the prefs are rational. */
1092         node=get_pubkeyblock(keyid);
1093         if(node)
1094           {
1095             check_prefs(node);
1096             release_kbnode(node);
1097           }
1098       }
1099     else if( !rc )
1100       { /* we can't merge secret keys */
1101         log_error( _("key %s: already in secret keyring\n"),
1102                    keystr_from_sk(sk));
1103         stats->secret_dups++;
1104         if (is_status_enabled ()) 
1105           print_import_ok (NULL, sk, 16);
1106
1107         /* TODO: if we ever do merge secret keys, make sure to handle
1108            the sec_to_pub_keyblock feature as well. */
1109       }
1110     else
1111       log_error( _("key %s: secret key not found: %s\n"),
1112                  keystr_from_sk(sk), g10_errstr(rc));
1113
1114     return rc;
1115 }
1116
1117
1118 /****************
1119  * Import a revocation certificate; this is a single signature packet.
1120  */
1121 static int
1122 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1123 {
1124     PKT_public_key *pk=NULL;
1125     KBNODE onode, keyblock = NULL;
1126     KEYDB_HANDLE hd = NULL;
1127     u32 keyid[2];
1128     int rc = 0;
1129
1130     assert( !node->next );
1131     assert( node->pkt->pkttype == PKT_SIGNATURE );
1132     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1133
1134     keyid[0] = node->pkt->pkt.signature->keyid[0];
1135     keyid[1] = node->pkt->pkt.signature->keyid[1];
1136
1137     pk = m_alloc_clear( sizeof *pk );
1138     rc = get_pubkey( pk, keyid );
1139     if( rc == G10ERR_NO_PUBKEY )
1140       {
1141         log_error(_("key %s: no public key -"
1142                     " can't apply revocation certificate\n"), keystr(keyid));
1143         rc = 0;
1144         goto leave;
1145       }
1146     else if( rc )
1147       {
1148         log_error(_("key %s: public key not found: %s\n"),
1149                   keystr(keyid), g10_errstr(rc));
1150         goto leave;
1151       }
1152
1153     /* read the original keyblock */
1154     hd = keydb_new (0);
1155     {
1156         byte afp[MAX_FINGERPRINT_LEN];
1157         size_t an;
1158         
1159         fingerprint_from_pk (pk, afp, &an);
1160         while (an < MAX_FINGERPRINT_LEN) 
1161             afp[an++] = 0;
1162         rc = keydb_search_fpr (hd, afp);
1163     }
1164     if (rc)
1165       {
1166         log_error (_("key %s: can't locate original keyblock: %s\n"),
1167                    keystr(keyid), g10_errstr(rc));
1168         goto leave;
1169       }
1170     rc = keydb_get_keyblock (hd, &keyblock );
1171     if (rc)
1172       {
1173         log_error (_("key %s: can't read original keyblock: %s\n"),
1174                    keystr(keyid), g10_errstr(rc));
1175         goto leave;
1176       }
1177
1178     /* it is okay, that node is not in keyblock because
1179      * check_key_signature works fine for sig_class 0x20 in this
1180      * special case. */
1181     rc = check_key_signature( keyblock, node, NULL);
1182     if( rc )
1183       {
1184         log_error( _("key %s: invalid revocation certificate"
1185                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1186         goto leave;
1187       }
1188
1189     /* check whether we already have this */
1190     for(onode=keyblock->next; onode; onode=onode->next ) {
1191         if( onode->pkt->pkttype == PKT_USER_ID )
1192             break;
1193         else if( onode->pkt->pkttype == PKT_SIGNATURE
1194                  && !cmp_signatures(node->pkt->pkt.signature,
1195                                     onode->pkt->pkt.signature))
1196           {
1197             rc = 0;
1198             goto leave; /* yes, we already know about it */
1199           }
1200     }
1201
1202
1203     /* insert it */
1204     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1205
1206     /* and write the keyblock back */
1207     rc = keydb_update_keyblock (hd, keyblock );
1208     if (rc)
1209         log_error (_("error writing keyring `%s': %s\n"),
1210                    keydb_get_resource_name (hd), g10_errstr(rc) );
1211     keydb_release (hd); hd = NULL;
1212     /* we are ready */
1213     if( !opt.quiet )
1214       {
1215         char *p=get_user_id_printable (keyid);
1216         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1217                   keystr(keyid),p);
1218         m_free(p);
1219       }
1220     stats->n_revoc++;
1221
1222     /* If the key we just revoked was ultimately trusted, remove its
1223        ultimate trust.  This doesn't stop the user from putting the
1224        ultimate trust back, but is a reasonable solution for now. */
1225     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1226       clear_ownertrusts(pk);
1227
1228     revalidation_mark ();
1229
1230   leave:
1231     keydb_release (hd);
1232     release_kbnode( keyblock );
1233     free_public_key( pk );
1234     return rc;
1235 }
1236
1237
1238 /****************
1239  * loop over the keyblock and check all self signatures.
1240  * Mark all user-ids with a self-signature by setting flag bit 0.
1241  * Mark all user-ids with an invalid self-signature by setting bit 1.
1242  * This works also for subkeys, here the subkey is marked.  Invalid or
1243  * extra subkey sigs (binding or revocation) are marked for deletion.
1244  * non_self is set to true if there are any sigs other than self-sigs
1245  * in this keyblock.
1246  */
1247 static int
1248 chk_self_sigs( const char *fname, KBNODE keyblock,
1249                PKT_public_key *pk, u32 *keyid, int *non_self )
1250 {
1251     KBNODE n,knode=NULL;
1252     PKT_signature *sig;
1253     int rc;
1254     u32 bsdate=0,rsdate=0;
1255     KBNODE bsnode=NULL,rsnode=NULL;
1256
1257     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1258       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1259         {
1260           knode=n;
1261           bsdate=0;
1262           rsdate=0;
1263           bsnode=NULL;
1264           rsnode=NULL;
1265           continue;
1266         }
1267       else if( n->pkt->pkttype != PKT_SIGNATURE )
1268             continue;
1269         sig = n->pkt->pkt.signature;
1270         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1271
1272           /* This just caches the sigs for later use.  That way we
1273              import a fully-cached key which speeds things up. */
1274           if(!opt.no_sig_cache)
1275             check_key_signature(keyblock,n,NULL);
1276
1277             if( (sig->sig_class&~3) == 0x10 ) {
1278                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1279                 if( !unode )
1280                   {
1281                     log_error( _("key %s: no user ID for signature\n"),
1282                                keystr(keyid));
1283                     return -1;  /* the complete keyblock is invalid */
1284                   }
1285
1286                 /* If it hasn't been marked valid yet, keep trying */
1287                 if(!(unode->flag&1)) {
1288                   rc = check_key_signature( keyblock, n, NULL);
1289                   if( rc )
1290                     {
1291                       if( opt.verbose )
1292                         {
1293                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1294                                       strlen(unode->pkt->pkt.user_id->name),0);
1295                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1296                                     _("key %s: unsupported public key "
1297                                       "algorithm on user id \"%s\"\n"):
1298                                     _("key %s: invalid self-signature "
1299                                       "on user id \"%s\"\n"),
1300                                     keystr(keyid),p);
1301                           m_free(p);
1302                         }
1303                     }
1304                   else
1305                     unode->flag |= 1; /* mark that signature checked */
1306                 }
1307             }
1308             else if( sig->sig_class == 0x18 ) {
1309               /* Note that this works based solely on the timestamps
1310                  like the rest of gpg.  If the standard gets
1311                  revocation targets, this may need to be revised. */
1312
1313                 if( !knode )
1314                   {
1315                     if(opt.verbose)
1316                       log_info( _("key %s: no subkey for key binding\n"),
1317                                 keystr(keyid));
1318                     n->flag |= 4; /* delete this */
1319                   }
1320                 else
1321                   {
1322                     rc = check_key_signature( keyblock, n, NULL);
1323                     if( rc )
1324                       {
1325                         if(opt.verbose)
1326                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1327                                    _("key %s: unsupported public key"
1328                                      " algorithm\n"):
1329                                    _("key %s: invalid subkey binding\n"),
1330                                    keystr(keyid));
1331                         n->flag|=4;
1332                       }
1333                     else
1334                       {
1335                         /* It's valid, so is it newer? */
1336                         if(sig->timestamp>=bsdate) {
1337                           knode->flag |= 1;  /* the subkey is valid */
1338                           if(bsnode)
1339                             {
1340                               bsnode->flag|=4; /* Delete the last binding
1341                                                   sig since this one is
1342                                                   newer */
1343                               if(opt.verbose)
1344                                 log_info(_("key %s: removed multiple subkey"
1345                                            " binding\n"),keystr(keyid));
1346                             }
1347
1348                           bsnode=n;
1349                           bsdate=sig->timestamp;
1350                         }
1351                         else
1352                           n->flag|=4; /* older */
1353                       }
1354                   }
1355             }
1356             else if( sig->sig_class == 0x28 ) {
1357               /* We don't actually mark the subkey as revoked right
1358                  now, so just check that the revocation sig is the
1359                  most recent valid one.  Note that we don't care if
1360                  the binding sig is newer than the revocation sig.
1361                  See the comment in getkey.c:merge_selfsigs_subkey for
1362                  more */
1363                 if( !knode )
1364                   {
1365                     if(opt.verbose)
1366                       log_info( _("key %s: no subkey for key revocation\n"),
1367                                 keystr(keyid));
1368                     n->flag |= 4; /* delete this */
1369                   }
1370                 else
1371                   {
1372                     rc = check_key_signature( keyblock, n, NULL);
1373                     if( rc )
1374                       {
1375                         if(opt.verbose)
1376                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1377                                    _("key %s: unsupported public"
1378                                      " key algorithm\n"):
1379                                    _("key %s: invalid subkey revocation\n"),
1380                                    keystr(keyid));
1381                         n->flag|=4;
1382                       }
1383                     else
1384                       {
1385                         /* It's valid, so is it newer? */
1386                         if(sig->timestamp>=rsdate)
1387                           {
1388                             if(rsnode)
1389                               {
1390                                 rsnode->flag|=4; /* Delete the last revocation
1391                                                     sig since this one is
1392                                                     newer */
1393                                 if(opt.verbose)
1394                                   log_info(_("key %s: removed multiple subkey"
1395                                              " revocation\n"),keystr(keyid));
1396                               }
1397
1398                             rsnode=n;
1399                             rsdate=sig->timestamp;
1400                           }
1401                         else
1402                           n->flag|=4; /* older */
1403                       }
1404                   }
1405             }
1406         }
1407         else
1408           *non_self=1;
1409     }
1410
1411     return 0;
1412 }
1413
1414 /****************
1415  * delete all parts which are invalid and those signatures whose
1416  * public key algorithm is not available in this implemenation;
1417  * but consider RSA as valid, because parse/build_packets knows
1418  * about it.
1419  * returns: true if at least one valid user-id is left over.
1420  */
1421 static int
1422 delete_inv_parts( const char *fname, KBNODE keyblock,
1423                   u32 *keyid, unsigned int options)
1424 {
1425     KBNODE node;
1426     int nvalid=0, uid_seen=0, subkey_seen=0;
1427
1428     for(node=keyblock->next; node; node = node->next ) {
1429         if( node->pkt->pkttype == PKT_USER_ID ) {
1430             uid_seen = 1;
1431             if( (node->flag & 2) || !(node->flag & 1) ) {
1432                 if( opt.verbose )
1433                   {
1434                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1435                                            node->pkt->pkt.user_id->len,0);
1436                     log_info( _("key %s: skipped user ID '%s'\n"),
1437                               keystr(keyid),p);
1438                     m_free(p);
1439                   }
1440                 delete_kbnode( node ); /* the user-id */
1441                 /* and all following packets up to the next user-id */
1442                 while( node->next
1443                        && node->next->pkt->pkttype != PKT_USER_ID
1444                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1445                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1446                     delete_kbnode( node->next );
1447                     node = node->next;
1448                 }
1449             }
1450             else
1451                 nvalid++;
1452         }
1453         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1454                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1455             if( (node->flag & 2) || !(node->flag & 1) ) {
1456                 if( opt.verbose )
1457                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1458
1459                 delete_kbnode( node ); /* the subkey */
1460                 /* and all following signature packets */
1461                 while( node->next
1462                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1463                     delete_kbnode( node->next );
1464                     node = node->next;
1465                 }
1466             }
1467             else
1468               subkey_seen = 1;
1469         }
1470         else if( node->pkt->pkttype == PKT_SIGNATURE
1471                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1472                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1473             delete_kbnode( node ); /* build_packet() can't handle this */
1474         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1475                  !node->pkt->pkt.signature->flags.exportable &&
1476                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1477                  seckey_available( node->pkt->pkt.signature->keyid ) )
1478           {
1479             /* here we violate the rfc a bit by still allowing
1480              * to import non-exportable signature when we have the
1481              * the secret key used to create this signature - it
1482              * seems that this makes sense */
1483             if(opt.verbose)
1484               log_info( _("key %s: non exportable signature"
1485                           " (class %02x) - skipped\n"),
1486                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1487             delete_kbnode( node );
1488           }
1489         else if( node->pkt->pkttype == PKT_SIGNATURE
1490                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1491             if( uid_seen )
1492               {
1493                 if(opt.verbose)
1494                   log_info( _("key %s: revocation certificate"
1495                               " at wrong place - skipped\n"),keystr(keyid));
1496                 delete_kbnode( node );
1497               }
1498             else {
1499               /* If the revocation cert is from a different key than
1500                  the one we're working on don't check it - it's
1501                  probably from a revocation key and won't be
1502                  verifiable with this key anyway. */
1503
1504               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1505                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1506                 {
1507                   int rc = check_key_signature( keyblock, node, NULL);
1508                   if( rc )
1509                     {
1510                       if(opt.verbose)
1511                         log_info( _("key %s: invalid revocation"
1512                                     " certificate: %s - skipped\n"),
1513                                   keystr(keyid), g10_errstr(rc));
1514                       delete_kbnode( node );
1515                     }
1516                 }
1517             }
1518         }
1519         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1520                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1521                   node->pkt->pkt.signature->sig_class == 0x28) &&
1522                  !subkey_seen )
1523           {
1524             if(opt.verbose)
1525               log_info( _("key %s: subkey signature"
1526                           " in wrong place - skipped\n"), keystr(keyid));
1527             delete_kbnode( node );
1528           }
1529         else if( node->pkt->pkttype == PKT_SIGNATURE
1530                  && !IS_CERT(node->pkt->pkt.signature))
1531           {
1532             if(opt.verbose)
1533               log_info(_("key %s: unexpected signature class (0x%02X) -"
1534                          " skipped\n"),keystr(keyid),
1535                        node->pkt->pkt.signature->sig_class);
1536             delete_kbnode(node);
1537           }
1538         else if( (node->flag & 4) ) /* marked for deletion */
1539             delete_kbnode( node );
1540     }
1541
1542     /* note: because keyblock is the public key, it is never marked
1543      * for deletion and so keyblock cannot change */
1544     commit_kbnode( &keyblock );
1545     return nvalid;
1546 }
1547
1548
1549 /****************
1550  * It may happen that the imported keyblock has duplicated user IDs.
1551  * We check this here and collapse those user IDs together with their
1552  * sigs into one.
1553  * Returns: True if the keyblock hash changed.
1554  */
1555 int
1556 collapse_uids( KBNODE *keyblock )
1557 {
1558     KBNODE n, n2;
1559     int in_uid;
1560     int any=0;
1561
1562   restart:
1563     for( n = *keyblock; n; n = n->next ) {
1564         if( n->pkt->pkttype != PKT_USER_ID )
1565             continue;
1566         for( n2 = n->next; n2; n2 = n2->next ) {
1567             if( n2->pkt->pkttype == PKT_USER_ID
1568                 && !cmp_user_ids( n->pkt->pkt.user_id,
1569                                   n2->pkt->pkt.user_id ) ) {
1570                 /* found a duplicate */
1571                 any = 1;
1572                 if( !n2->next
1573                     || n2->next->pkt->pkttype == PKT_USER_ID
1574                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1575                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1576                     /* no more signatures: delete the user ID
1577                      * and start over */
1578                     remove_kbnode( keyblock, n2 );
1579                 }
1580                 else {
1581                     /* The simple approach: Move one signature and
1582                      * then start over to delete the next one :-( */
1583                     move_kbnode( keyblock, n2->next, n->next );
1584                 }
1585                 goto restart;
1586             }
1587         }
1588     }
1589     if( !any )
1590         return 0;
1591
1592   restart_sig:
1593     /* now we may have duplicate signatures on one user ID: fix this */
1594     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1595         if( n->pkt->pkttype == PKT_USER_ID )
1596             in_uid = 1;
1597         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1598                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1599             in_uid = 0;
1600         else if( in_uid ) {
1601             n2 = n;
1602             do {
1603                 KBNODE ncmp = NULL;
1604                 for( ; n2; n2 = n2->next ) {
1605                     if(    n2->pkt->pkttype == PKT_USER_ID
1606                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1607                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1608                         break;
1609                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1610                         ;
1611                     else if( !ncmp )
1612                         ncmp = n2;
1613                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1614                                                 n2->pkt->pkt.signature )) {
1615                         remove_kbnode( keyblock, n2 );
1616                         goto restart_sig;
1617                     }
1618                 }
1619                 n2 = ncmp? ncmp->next : NULL;
1620             } while( n2 );
1621         }
1622     }
1623
1624     if(!opt.quiet)
1625       {
1626         const char *key="???";
1627
1628         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1629           key=keystr_from_pk(n->pkt->pkt.public_key);
1630         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1631           key=keystr_from_sk(n->pkt->pkt.secret_key);
1632
1633         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1634       }
1635
1636     return 1;
1637 }
1638
1639 /* Check for a 0x20 revocation from a revocation key that is not
1640    present.  This may be called without the benefit of merge_xxxx so
1641    you can't rely on pk->revkey and friends. */
1642 static void
1643 revocation_present(KBNODE keyblock)
1644 {
1645   KBNODE onode,inode;
1646   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1647
1648   for(onode=keyblock->next;onode;onode=onode->next)
1649     {
1650       /* If we reach user IDs, we're done. */
1651       if(onode->pkt->pkttype==PKT_USER_ID)
1652         break;
1653
1654       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1655          onode->pkt->pkt.signature->sig_class==0x1F &&
1656          onode->pkt->pkt.signature->revkey)
1657         {
1658           int idx;
1659           PKT_signature *sig=onode->pkt->pkt.signature;
1660
1661           for(idx=0;idx<sig->numrevkeys;idx++)
1662             {
1663               u32 keyid[2];
1664
1665               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1666                                      MAX_FINGERPRINT_LEN,keyid);
1667
1668               for(inode=keyblock->next;inode;inode=inode->next)
1669                 {
1670                   /* If we reach user IDs, we're done. */
1671                   if(inode->pkt->pkttype==PKT_USER_ID)
1672                     break;
1673
1674                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1675                      inode->pkt->pkt.signature->sig_class==0x20 &&
1676                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1677                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1678                     {
1679                       /* Okay, we have a revocation key, and a
1680                          revocation issued by it.  Do we have the key
1681                          itself? */
1682                       int rc;
1683
1684                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1685                                                    MAX_FINGERPRINT_LEN);
1686                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1687                         {
1688                           char *tempkeystr=m_strdup(keystr_from_pk(pk));
1689
1690                           /* No, so try and get it */
1691                           if(opt.keyserver_scheme &&
1692                              opt.keyserver_options.auto_key_retrieve)
1693                             {
1694                               log_info(_("WARNING: key %s may be revoked:"
1695                                          " fetching revocation key %s\n"),
1696                                        tempkeystr,keystr(keyid));
1697                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1698                                                       MAX_FINGERPRINT_LEN);
1699
1700                               /* Do we have it now? */
1701                               rc=get_pubkey_byfprint_fast (NULL,
1702                                                      sig->revkey[idx]->fpr,
1703                                                      MAX_FINGERPRINT_LEN);
1704                             }
1705
1706                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1707                             log_info(_("WARNING: key %s may be revoked:"
1708                                        " revocation key %s not present.\n"),
1709                                      tempkeystr,keystr(keyid));
1710
1711                           m_free(tempkeystr);
1712                         }
1713                     }
1714                 }
1715             }
1716         }
1717     }
1718 }
1719
1720 /****************
1721  * compare and merge the blocks
1722  *
1723  * o compare the signatures: If we already have this signature, check
1724  *   that they compare okay; if not, issue a warning and ask the user.
1725  * o Simply add the signature.  Can't verify here because we may not have
1726  *   the signature's public key yet; verification is done when putting it
1727  *   into the trustdb, which is done automagically as soon as this pubkey
1728  *   is used.
1729  * Note: We indicate newly inserted packets with flag bit 0
1730  */
1731 static int
1732 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1733               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1734 {
1735     KBNODE onode, node;
1736     int rc, found;
1737
1738     /* 1st: handle revocation certificates */
1739     for(node=keyblock->next; node; node=node->next ) {
1740         if( node->pkt->pkttype == PKT_USER_ID )
1741             break;
1742         else if( node->pkt->pkttype == PKT_SIGNATURE
1743                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1744             /* check whether we already have this */
1745             found = 0;
1746             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1747                 if( onode->pkt->pkttype == PKT_USER_ID )
1748                     break;
1749                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1750                          && onode->pkt->pkt.signature->sig_class == 0x20
1751                          && !cmp_signatures(onode->pkt->pkt.signature,
1752                                             node->pkt->pkt.signature))
1753                   {
1754                     found = 1;
1755                     break;
1756                   }
1757             }
1758             if( !found ) {
1759                 KBNODE n2 = clone_kbnode(node);
1760                 insert_kbnode( keyblock_orig, n2, 0 );
1761                 n2->flag |= 1;
1762                 ++*n_sigs;
1763                 if(!opt.quiet)
1764                   {
1765                     char *p=get_user_id_printable (keyid);
1766                     log_info(_("key %s: \"%s\" revocation"
1767                                " certificate added\n"), keystr(keyid),p);
1768                     m_free(p);
1769                   }
1770             }
1771         }
1772     }
1773
1774     /* 2nd: merge in any direct key (0x1F) sigs */
1775     for(node=keyblock->next; node; node=node->next ) {
1776         if( node->pkt->pkttype == PKT_USER_ID )
1777             break;
1778         else if( node->pkt->pkttype == PKT_SIGNATURE
1779                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1780             /* check whether we already have this */
1781             found = 0;
1782             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1783                 if( onode->pkt->pkttype == PKT_USER_ID )
1784                     break;
1785                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1786                          && onode->pkt->pkt.signature->sig_class == 0x1F
1787                          && !cmp_signatures(onode->pkt->pkt.signature,
1788                                             node->pkt->pkt.signature)) {
1789                     found = 1;
1790                     break;
1791                 }
1792             }
1793             if( !found )
1794               {
1795                 KBNODE n2 = clone_kbnode(node);
1796                 insert_kbnode( keyblock_orig, n2, 0 );
1797                 n2->flag |= 1;
1798                 ++*n_sigs;
1799                 if(!opt.quiet)
1800                   log_info( _("key %s: direct key signature added\n"),
1801                             keystr(keyid));
1802               }
1803         }
1804     }
1805
1806     /* 3rd: try to merge new certificates in */
1807     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1808         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1809             /* find the user id in the imported keyblock */
1810             for(node=keyblock->next; node; node=node->next )
1811                 if( node->pkt->pkttype == PKT_USER_ID
1812                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1813                                           node->pkt->pkt.user_id ) )
1814                     break;
1815             if( node ) { /* found: merge */
1816                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1817                 if( rc )
1818                     return rc;
1819             }
1820         }
1821     }
1822
1823     /* 4th: add new user-ids */
1824     for(node=keyblock->next; node; node=node->next ) {
1825         if( node->pkt->pkttype == PKT_USER_ID) {
1826             /* do we have this in the original keyblock */
1827             for(onode=keyblock_orig->next; onode; onode=onode->next )
1828                 if( onode->pkt->pkttype == PKT_USER_ID
1829                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1830                                       node->pkt->pkt.user_id ) )
1831                     break;
1832             if( !onode ) { /* this is a new user id: append */
1833                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1834                 if( rc )
1835                     return rc;
1836                 ++*n_uids;
1837             }
1838         }
1839     }
1840
1841     /* 5th: add new subkeys */
1842     for(node=keyblock->next; node; node=node->next ) {
1843         onode = NULL;
1844         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1845             /* do we have this in the original keyblock? */
1846             for(onode=keyblock_orig->next; onode; onode=onode->next )
1847                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1848                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1849                                          node->pkt->pkt.public_key ) )
1850                     break;
1851             if( !onode ) { /* this is a new subkey: append */
1852                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1853                 if( rc )
1854                     return rc;
1855                 ++*n_subk;
1856             }
1857         }
1858         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1859             /* do we have this in the original keyblock? */
1860             for(onode=keyblock_orig->next; onode; onode=onode->next )
1861                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1862                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1863                                          node->pkt->pkt.secret_key ) )
1864                     break;
1865             if( !onode ) { /* this is a new subkey: append */
1866                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1867                 if( rc )
1868                     return rc;
1869                 ++*n_subk;
1870             }
1871         }
1872     }
1873
1874     /* 6th: merge subkey certificates */
1875     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1876         if( !(onode->flag & 1)
1877             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1878                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1879             /* find the subkey in the imported keyblock */
1880             for(node=keyblock->next; node; node=node->next ) {
1881                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1882                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1883                                           node->pkt->pkt.public_key ) )
1884                     break;
1885                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1886                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1887                                           node->pkt->pkt.secret_key ) )
1888                     break;
1889             }
1890             if( node ) { /* found: merge */
1891                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1892                 if( rc )
1893                     return rc;
1894             }
1895         }
1896     }
1897
1898
1899     return 0;
1900 }
1901
1902
1903 /****************
1904  * append the userid starting with NODE and all signatures to KEYBLOCK.
1905  */
1906 static int
1907 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1908                                           const char *fname, u32 *keyid )
1909 {
1910     KBNODE n, n_where=NULL;
1911
1912     assert(node->pkt->pkttype == PKT_USER_ID );
1913
1914     /* find the position */
1915     for( n = keyblock; n; n_where = n, n = n->next ) {
1916         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1917             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1918             break;
1919     }
1920     if( !n )
1921         n_where = NULL;
1922
1923     /* and append/insert */
1924     while( node ) {
1925         /* we add a clone to the original keyblock, because this
1926          * one is released first */
1927         n = clone_kbnode(node);
1928         if( n_where ) {
1929             insert_kbnode( n_where, n, 0 );
1930             n_where = n;
1931         }
1932         else
1933             add_kbnode( keyblock, n );
1934         n->flag |= 1;
1935         node->flag |= 1;
1936         if( n->pkt->pkttype == PKT_SIGNATURE )
1937             ++*n_sigs;
1938
1939         node = node->next;
1940         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1941             break;
1942     }
1943
1944     return 0;
1945 }
1946
1947
1948 /****************
1949  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1950  * (how should we handle comment packets here?)
1951  */
1952 static int
1953 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1954                                     const char *fname, u32 *keyid )
1955 {
1956     KBNODE n, n2;
1957     int found=0;
1958
1959     assert(dst->pkt->pkttype == PKT_USER_ID );
1960     assert(src->pkt->pkttype == PKT_USER_ID );
1961
1962     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1963         if( n->pkt->pkttype != PKT_SIGNATURE )
1964             continue;
1965         if( n->pkt->pkt.signature->sig_class == 0x18
1966             || n->pkt->pkt.signature->sig_class == 0x28 )
1967             continue; /* skip signatures which are only valid on subkeys */
1968         found = 0;
1969         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
1970           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
1971             {
1972               found++;
1973               break;
1974             }
1975         if( !found ) {
1976             /* This signature is new or newer, append N to DST.
1977              * We add a clone to the original keyblock, because this
1978              * one is released first */
1979             n2 = clone_kbnode(n);
1980             insert_kbnode( dst, n2, PKT_SIGNATURE );
1981             n2->flag |= 1;
1982             n->flag |= 1;
1983             ++*n_sigs;
1984         }
1985     }
1986
1987     return 0;
1988 }
1989
1990 /****************
1991  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
1992  */
1993 static int
1994 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
1995                                     const char *fname, u32 *keyid )
1996 {
1997     KBNODE n, n2;
1998     int found=0;
1999
2000     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2001            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2002
2003     for(n=src->next; n ; n = n->next ) {
2004         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2005             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2006             break;
2007         if( n->pkt->pkttype != PKT_SIGNATURE )
2008             continue;
2009         found = 0;
2010         for(n2=dst->next; n2; n2 = n2->next){
2011             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2012                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2013                 break;
2014             if( n2->pkt->pkttype == PKT_SIGNATURE
2015                 && n->pkt->pkt.signature->keyid[0]
2016                    == n2->pkt->pkt.signature->keyid[0]
2017                 && n->pkt->pkt.signature->keyid[1]
2018                    == n2->pkt->pkt.signature->keyid[1]
2019                 && n->pkt->pkt.signature->timestamp
2020                    <= n2->pkt->pkt.signature->timestamp
2021                 && n->pkt->pkt.signature->sig_class
2022                    == n2->pkt->pkt.signature->sig_class ) {
2023                 found++;
2024                 break;
2025             }
2026         }
2027         if( !found ) {
2028             /* This signature is new or newer, append N to DST.
2029              * We add a clone to the original keyblock, because this
2030              * one is released first */
2031             n2 = clone_kbnode(n);
2032             insert_kbnode( dst, n2, PKT_SIGNATURE );
2033             n2->flag |= 1;
2034             n->flag |= 1;
2035             ++*n_sigs;
2036         }
2037     }
2038
2039     return 0;
2040 }
2041
2042 /****************
2043  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2044  * Mark all new and copied packets by setting flag bit 0.
2045  */
2046 static int
2047 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2048                                           const char *fname, u32 *keyid )
2049 {
2050     KBNODE n;
2051
2052     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2053            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2054
2055     while(  node ) {
2056         /* we add a clone to the original keyblock, because this
2057          * one is released first */
2058         n = clone_kbnode(node);
2059         add_kbnode( keyblock, n );
2060         n->flag |= 1;
2061         node->flag |= 1;
2062         if( n->pkt->pkttype == PKT_SIGNATURE )
2063             ++*n_sigs;
2064
2065         node = node->next;
2066         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2067             break;
2068     }
2069
2070     return 0;
2071 }