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