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