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