Fixed memory allocation bug and typos.
[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 = NULL;
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             keystr_from_pk(pk));
568   /* TRANSLATORS: This string is belongs to the previous one.  They are
569      only split up to allow printing of a common prefix. */
570   log_info(_("         algorithms on these user IDs:\n"));
571 }
572
573 static void
574 check_prefs(KBNODE keyblock)
575 {
576   KBNODE node;
577   PKT_public_key *pk;
578   int problem=0;
579   
580   merge_keys_and_selfsig(keyblock);
581   pk=keyblock->pkt->pkt.public_key;
582
583   for(node=keyblock;node;node=node->next)
584     {
585       if(node->pkt->pkttype==PKT_USER_ID
586          && node->pkt->pkt.user_id->created
587          && node->pkt->pkt.user_id->prefs)
588         {
589           PKT_user_id *uid=node->pkt->pkt.user_id;
590           prefitem_t *prefs=uid->prefs;
591           char *user=utf8_to_native(uid->name,strlen(uid->name),0);
592
593           for(;prefs->type;prefs++)
594             {
595               char num[10]; /* prefs->value is a byte, so we're over
596                                safe here */
597
598               sprintf(num,"%u",prefs->value);
599
600               if(prefs->type==PREFTYPE_SYM)
601                 {
602                   if(check_cipher_algo(prefs->value))
603                     {
604                       const char *algo=cipher_algo_to_string(prefs->value);
605                       if(!problem)
606                         check_prefs_warning(pk);
607                       log_info(_("         \"%s\": preference for cipher"
608                                  " algorithm %s\n"),user,algo?algo:num);
609                       problem=1;
610                     }
611                 }
612               else if(prefs->type==PREFTYPE_HASH)
613                 {
614                   if(check_digest_algo(prefs->value))
615                     {
616                       const char *algo=digest_algo_to_string(prefs->value);
617                       if(!problem)
618                         check_prefs_warning(pk);
619                       log_info(_("         \"%s\": preference for digest"
620                                  " algorithm %s\n"),user,algo?algo:num);
621                       problem=1;
622                     }
623                 }
624               else if(prefs->type==PREFTYPE_ZIP)
625                 {
626                   if(check_compress_algo(prefs->value))
627                     {
628                       const char *algo=compress_algo_to_string(prefs->value);
629                       if(!problem)
630                         check_prefs_warning(pk);
631                       log_info(_("         \"%s\": preference for compression"
632                                  " algorithm %s\n"),user,algo?algo:num);
633                       problem=1;
634                     }
635                 }
636             }
637
638           xfree(user);
639         }
640     }
641
642   if(problem)
643     {
644       log_info(_("it is strongly suggested that you update"
645                  " your preferences and\n"));
646       log_info(_("re-distribute this key to avoid potential algorithm"
647                  " mismatch problems\n"));
648
649       if(!opt.batch)
650         {
651           STRLIST sl=NULL,locusr=NULL;
652           size_t fprlen=0;
653           byte fpr[MAX_FINGERPRINT_LEN],*p;
654           char username[(MAX_FINGERPRINT_LEN*2)+1];
655           unsigned int i;
656
657           p=fingerprint_from_pk(pk,fpr,&fprlen);
658           for(i=0;i<fprlen;i++,p++)
659             sprintf(username+2*i,"%02X",*p);
660           add_to_strlist(&locusr,username);
661
662           append_to_strlist(&sl,"updpref");
663           append_to_strlist(&sl,"save");
664
665           keyedit_menu( username, locusr, sl, 1, 1 );
666           free_strlist(sl);
667           free_strlist(locusr);
668         }
669       else if(!opt.quiet)
670         log_info(_("you can update your preferences with:"
671                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
672     }
673 }
674
675 /****************
676  * Try to import one keyblock.  Return an error only in serious cases, but
677  * never for an invalid keyblock.  It uses log_error to increase the
678  * internal errorcount, so that invalid input can be detected by programs
679  * which called g10.
680  */
681 static int
682 import_one( const char *fname, KBNODE keyblock, struct stats_s *stats,
683             unsigned char **fpr,size_t *fpr_len,unsigned int options,
684             int from_sk )
685 {
686     PKT_public_key *pk;
687     PKT_public_key *pk_orig;
688     KBNODE node, uidnode;
689     KBNODE keyblock_orig = NULL;
690     u32 keyid[2];
691     int rc = 0;
692     int new_key = 0;
693     int mod_key = 0;
694     int non_self = 0;
695
696     /* get the key and print some info about it */
697     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
698     if( !node )
699         BUG();
700
701     pk = node->pkt->pkt.public_key;
702
703     keyid_from_pk( pk, keyid );
704     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
705
706     if( opt.verbose && !opt.interactive )
707       {
708         log_info( "pub  %4u%c/%s %s  ",
709                   nbits_from_pk( pk ),
710                   pubkey_letter( pk->pubkey_algo ),
711                   keystr_from_pk(pk), datestr_from_pk(pk) );
712         if( uidnode )
713           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
714                              uidnode->pkt->pkt.user_id->len );
715         putc('\n', stderr);
716       }
717
718     if( !uidnode )
719       {
720         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
721         return 0;
722       }
723     
724     if (opt.interactive) {
725         if(is_status_enabled())
726           print_import_check (pk, uidnode->pkt->pkt.user_id);
727         merge_keys_and_selfsig (keyblock);
728         tty_printf ("\n");
729         show_basic_key_info (keyblock);
730         tty_printf ("\n");
731         if (!cpr_get_answer_is_yes ("import.okay",
732                                     "Do you want to import this key? (y/N) "))
733             return 0;
734     }
735
736     collapse_uids(&keyblock);
737
738     /* Clean the key that we're about to import, to cut down on things
739        that we have to clean later.  This has no practical impact on
740        the end result, but does result in less logging which might
741        confuse the user. */
742     if(options&IMPORT_CLEAN)
743       clean_key(keyblock,opt.verbose,options&IMPORT_MINIMAL,NULL,NULL);
744
745     clear_kbnode_flags( keyblock );
746
747     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
748        && opt.verbose)
749       log_info(_("key %s: PKS subkey corruption repaired\n"),
750                keystr_from_pk(pk));
751
752     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
753     if( rc )
754         return rc== -1? 0:rc;
755
756     /* If we allow such a thing, mark unsigned uids as valid */
757     if( opt.allow_non_selfsigned_uid )
758       for( node=keyblock; node; node = node->next )
759         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
760           {
761             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
762                                       node->pkt->pkt.user_id->len,0);
763             node->flag |= 1;
764             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
765                       keystr_from_pk(pk),user);
766             xfree(user);
767           }
768
769     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
770         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
771         if( !opt.quiet )
772           log_info(_("this may be caused by a missing self-signature\n"));
773         stats->no_user_id++;
774         return 0;
775     }
776
777     /* do we have this key already in one of our pubrings ? */
778     pk_orig = xmalloc_clear( sizeof *pk_orig );
779     rc = get_pubkey_fast ( pk_orig, keyid );
780     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
781       {
782         log_error( _("key %s: public key not found: %s\n"),
783                    keystr(keyid), g10_errstr(rc));
784       }
785     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
786       {
787         if( opt.verbose )
788           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
789         rc = 0;
790         stats->skipped_new_keys++;
791       }
792     else if( rc ) { /* insert this key */
793         KEYDB_HANDLE hd = keydb_new (0);
794
795         rc = keydb_locate_writable (hd, NULL);
796         if (rc) {
797             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
798             keydb_release (hd);
799             return G10ERR_GENERAL;
800         }
801         if( opt.verbose > 1 )
802             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
803
804         rc = keydb_insert_keyblock (hd, keyblock );
805         if (rc)
806            log_error (_("error writing keyring `%s': %s\n"),
807                        keydb_get_resource_name (hd), g10_errstr(rc));
808         else
809           {
810             /* This should not be possible since we delete the
811                ownertrust when a key is deleted, but it can happen if
812                the keyring and trustdb are out of sync.  It can also
813                be made to happen with the trusted-key command. */
814
815             clear_ownertrusts (pk);
816             if(non_self)
817               revalidation_mark ();
818           }
819         keydb_release (hd);
820
821         /* we are ready */
822         if( !opt.quiet )
823           {
824             char *p=get_user_id_native (keyid);
825             log_info( _("key %s: public key \"%s\" imported\n"),
826                       keystr(keyid),p);
827             xfree(p);
828           }
829         if( is_status_enabled() )
830           {
831             char *us = get_long_user_id_string( keyid );
832             write_status_text( STATUS_IMPORTED, us );
833             xfree(us);
834             print_import_ok (pk,NULL, 1);
835           }
836         stats->imported++;
837         if( is_RSA( pk->pubkey_algo ) )
838             stats->imported_rsa++;
839         new_key = 1;
840     }
841     else { /* merge */
842         KEYDB_HANDLE hd;
843         int n_uids, n_sigs, n_subk, n_sigs_cleaned, n_uids_cleaned;
844
845         /* Compare the original against the new key; just to be sure nothing
846          * weird is going on */
847         if( cmp_public_keys( pk_orig, pk ) )
848           {
849             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
850             goto leave;
851           }
852
853         /* now read the original keyblock */
854         hd = keydb_new (0);
855         {
856             byte afp[MAX_FINGERPRINT_LEN];
857             size_t an;
858
859             fingerprint_from_pk (pk_orig, afp, &an);
860             while (an < MAX_FINGERPRINT_LEN) 
861                 afp[an++] = 0;
862             rc = keydb_search_fpr (hd, afp);
863         }
864         if( rc )
865           {
866             log_error (_("key %s: can't locate original keyblock: %s\n"),
867                        keystr(keyid), g10_errstr(rc));
868             keydb_release (hd);
869             goto leave;
870           }
871         rc = keydb_get_keyblock (hd, &keyblock_orig );
872         if (rc)
873           {
874             log_error (_("key %s: can't read original keyblock: %s\n"),
875                        keystr(keyid), g10_errstr(rc));
876             keydb_release (hd);
877             goto leave;
878           }
879
880         /* and try to merge the block */
881         clear_kbnode_flags( keyblock_orig );
882         clear_kbnode_flags( keyblock );
883         n_uids = n_sigs = n_subk = n_sigs_cleaned = n_uids_cleaned = 0;
884         rc = merge_blocks( fname, keyblock_orig, keyblock,
885                            keyid, &n_uids, &n_sigs, &n_subk );
886         if( rc )
887           {
888             keydb_release (hd);
889             goto leave;
890           }
891
892         if(options&IMPORT_CLEAN)
893           clean_key(keyblock_orig,opt.verbose,options&IMPORT_MINIMAL,
894                     &n_uids_cleaned,&n_sigs_cleaned);
895
896         if( n_uids || n_sigs || n_subk || n_sigs_cleaned || n_uids_cleaned) {
897             mod_key = 1;
898             /* keyblock_orig has been updated; write */
899             rc = keydb_update_keyblock (hd, keyblock_orig);
900             if (rc)
901                 log_error (_("error writing keyring `%s': %s\n"),
902                              keydb_get_resource_name (hd), g10_errstr(rc) );
903             else if(non_self)
904               revalidation_mark ();
905
906             /* we are ready */
907             if( !opt.quiet )
908               {
909                 char *p=get_user_id_native(keyid);
910                 if( n_uids == 1 )
911                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
912                            keystr(keyid),p);
913                 else if( n_uids )
914                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
915                             keystr(keyid),p,n_uids);
916                 if( n_sigs == 1 )
917                   log_info( _("key %s: \"%s\" 1 new signature\n"),
918                             keystr(keyid), p);
919                 else if( n_sigs )
920                   log_info( _("key %s: \"%s\" %d new signatures\n"),
921                             keystr(keyid), p, n_sigs );
922                 if( n_subk == 1 )
923                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
924                             keystr(keyid), p);
925                 else if( n_subk )
926                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
927                             keystr(keyid), p, n_subk );
928                 if(n_sigs_cleaned==1)
929                   log_info(_("key %s: \"%s\" %d signature cleaned\n"),
930                            keystr(keyid),p,n_sigs_cleaned);
931                 else if(n_sigs_cleaned)
932                   log_info(_("key %s: \"%s\" %d signatures cleaned\n"),
933                            keystr(keyid),p,n_sigs_cleaned);
934                 if(n_uids_cleaned==1)
935                   log_info(_("key %s: \"%s\" %d user ID cleaned\n"),
936                            keystr(keyid),p,n_uids_cleaned);
937                 else if(n_uids_cleaned)
938                   log_info(_("key %s: \"%s\" %d user IDs cleaned\n"),
939                            keystr(keyid),p,n_uids_cleaned);
940                 xfree(p);
941               }
942
943             stats->n_uids +=n_uids;
944             stats->n_sigs +=n_sigs;
945             stats->n_subk +=n_subk;
946             stats->n_sigs_cleaned +=n_sigs_cleaned;
947             stats->n_uids_cleaned +=n_uids_cleaned;
948
949             if (is_status_enabled ()) 
950                  print_import_ok (pk, NULL,
951                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
952         }
953         else
954           {
955             if (is_status_enabled ()) 
956               print_import_ok (pk, NULL, 0);
957
958             if( !opt.quiet )
959               {
960                 char *p=get_user_id_native(keyid);
961                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
962                 xfree(p);
963               }
964
965             stats->unchanged++;
966           }
967
968         keydb_release (hd); hd = NULL;
969     }
970
971   leave:
972
973     /* Now that the key is definitely incorporated into the keydb, we
974        need to check if a designated revocation is present or if the
975        prefs are not rational so we can warn the user. */
976
977     if(mod_key)
978       {
979         revocation_present(keyblock_orig);
980         if(!from_sk && seckey_available(keyid)==0)
981           check_prefs(keyblock_orig);
982       }
983     else if(new_key)
984       {
985         /* A little explanation for this: we fill in the fingerprint
986            when importing keys as it can be useful to know the
987            fingerprint in certain keyserver-related cases (a keyserver
988            asked for a particular name, but the key doesn't have that
989            name).  However, in cases where we're importing more than
990            one key at a time, we cannot know which key to fingerprint.
991            In these cases, rather than guessing, we do not fingerpring
992            at all, and we must hope the user ID on the keys are
993            useful. */
994         if(fpr)
995           {
996             xfree(*fpr);
997             if(stats->imported==1)
998               *fpr=fingerprint_from_pk(pk,NULL,fpr_len);
999             else
1000               *fpr=NULL;
1001           }
1002
1003         revocation_present(keyblock);
1004         if(!from_sk && seckey_available(keyid)==0)
1005           check_prefs(keyblock);
1006       }
1007
1008     release_kbnode( keyblock_orig );
1009     free_public_key( pk_orig );
1010
1011     return rc;
1012 }
1013
1014 /* Walk a secret keyblock and produce a public keyblock out of it. */
1015 static KBNODE
1016 sec_to_pub_keyblock(KBNODE sec_keyblock)
1017 {
1018   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
1019
1020   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
1021     {
1022       KBNODE pubnode;
1023
1024       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
1025          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
1026         {
1027           /* Make a public key.  We only need to convert enough to
1028              write the keyblock out. */
1029
1030           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
1031           PACKET *pkt=xmalloc_clear(sizeof(PACKET));
1032           PKT_public_key *pk=xmalloc_clear(sizeof(PKT_public_key));
1033           int n;
1034
1035           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
1036             pkt->pkttype=PKT_PUBLIC_KEY;
1037           else
1038             pkt->pkttype=PKT_PUBLIC_SUBKEY;
1039
1040           pkt->pkt.public_key=pk;
1041
1042           pk->version=sk->version;
1043           pk->timestamp=sk->timestamp;
1044           pk->expiredate=sk->expiredate;
1045           pk->pubkey_algo=sk->pubkey_algo;
1046
1047           n=pubkey_get_npkey(pk->pubkey_algo);
1048           if(n==0)
1049             {
1050               /* we can't properly extract the pubkey without knowing
1051                  the number of MPIs */
1052               release_kbnode(pub_keyblock);
1053               return NULL;
1054             }
1055           else
1056             {
1057               int i;
1058
1059               for(i=0;i<n;i++)
1060                 pk->pkey[i]=mpi_copy(sk->skey[i]);
1061             }
1062
1063           pubnode=new_kbnode(pkt);
1064         }
1065       else
1066         {
1067           pubnode=clone_kbnode(secnode);
1068         }
1069
1070       if(pub_keyblock==NULL)
1071         pub_keyblock=pubnode;
1072       else
1073         add_kbnode(pub_keyblock,pubnode);
1074     }
1075
1076   return pub_keyblock;
1077 }
1078
1079 /****************
1080  * Ditto for secret keys.  Handling is simpler than for public keys.
1081  * We allow secret key importing only when allow is true, this is so
1082  * that a secret key can not be imported accidently and thereby tampering
1083  * with the trust calculation.
1084  */
1085 static int
1086 import_secret_one( const char *fname, KBNODE keyblock, 
1087                    struct stats_s *stats, unsigned int options)
1088 {
1089     PKT_secret_key *sk;
1090     KBNODE node, uidnode;
1091     u32 keyid[2];
1092     int rc = 0;
1093
1094     /* get the key and print some info about it */
1095     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1096     if( !node )
1097         BUG();
1098
1099     sk = node->pkt->pkt.secret_key;
1100     keyid_from_sk( sk, keyid );
1101     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1102
1103     if( opt.verbose )
1104       {
1105         log_info( "sec  %4u%c/%s %s   ",
1106                   nbits_from_sk( sk ),
1107                   pubkey_letter( sk->pubkey_algo ),
1108                   keystr_from_sk(sk), datestr_from_sk(sk) );
1109         if( uidnode )
1110           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1111                              uidnode->pkt->pkt.user_id->len );
1112         putc('\n', stderr);
1113       }
1114     stats->secret_read++;
1115
1116     if( !uidnode )
1117       {
1118         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1119         return 0;
1120       }
1121
1122     if(sk->protect.algo>110)
1123       {
1124         log_error(_("key %s: secret key with invalid cipher %d"
1125                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1126         return 0;
1127       }
1128
1129 #ifdef ENABLE_SELINUX_HACKS
1130     if (1)
1131       {
1132         /* We don't allow to import secret keys because that may be used
1133            to put a secret key into the keyring and the user might later
1134            be tricked into signing stuff with that key.  */
1135         log_error (_("importing secret keys not allowed\n"));
1136         return 0;
1137       }
1138 #endif 
1139     
1140     clear_kbnode_flags( keyblock );
1141
1142     /* do we have this key already in one of our secrings ? */
1143     rc = seckey_available( keyid );
1144     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1145       {
1146         /* simply insert this key */
1147         KEYDB_HANDLE hd = keydb_new (1);
1148
1149         /* get default resource */
1150         rc = keydb_locate_writable (hd, NULL);
1151         if (rc) {
1152           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1153           keydb_release (hd);
1154           return G10ERR_GENERAL;
1155         }
1156         rc = keydb_insert_keyblock (hd, keyblock );
1157         if (rc)
1158           log_error (_("error writing keyring `%s': %s\n"),
1159                      keydb_get_resource_name (hd), g10_errstr(rc) );
1160         keydb_release (hd);
1161         /* we are ready */
1162         if( !opt.quiet )
1163           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1164         stats->secret_imported++;
1165         if (is_status_enabled ()) 
1166           print_import_ok (NULL, sk, 1|16);
1167
1168         if(options&IMPORT_SK2PK)
1169           {
1170             /* Try and make a public key out of this. */
1171
1172             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1173             if(pub_keyblock)
1174               {
1175                 import_one(fname,pub_keyblock,stats,
1176                            NULL,NULL,opt.import_options,1);
1177                 release_kbnode(pub_keyblock);
1178               }
1179           }
1180
1181         /* Now that the key is definitely incorporated into the keydb,
1182            if we have the public part of this key, we need to check if
1183            the prefs are rational. */
1184         node=get_pubkeyblock(keyid);
1185         if(node)
1186           {
1187             check_prefs(node);
1188             release_kbnode(node);
1189           }
1190       }
1191     else if( !rc )
1192       { /* we can't merge secret keys */
1193         log_error( _("key %s: already in secret keyring\n"),
1194                    keystr_from_sk(sk));
1195         stats->secret_dups++;
1196         if (is_status_enabled ()) 
1197           print_import_ok (NULL, sk, 16);
1198
1199         /* TODO: if we ever do merge secret keys, make sure to handle
1200            the sec_to_pub_keyblock feature as well. */
1201       }
1202     else
1203       log_error( _("key %s: secret key not found: %s\n"),
1204                  keystr_from_sk(sk), g10_errstr(rc));
1205
1206     return rc;
1207 }
1208
1209
1210 /****************
1211  * Import a revocation certificate; this is a single signature packet.
1212  */
1213 static int
1214 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1215 {
1216     PKT_public_key *pk=NULL;
1217     KBNODE onode, keyblock = NULL;
1218     KEYDB_HANDLE hd = NULL;
1219     u32 keyid[2];
1220     int rc = 0;
1221
1222     assert( !node->next );
1223     assert( node->pkt->pkttype == PKT_SIGNATURE );
1224     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1225
1226     keyid[0] = node->pkt->pkt.signature->keyid[0];
1227     keyid[1] = node->pkt->pkt.signature->keyid[1];
1228
1229     pk = xmalloc_clear( sizeof *pk );
1230     rc = get_pubkey( pk, keyid );
1231     if( rc == G10ERR_NO_PUBKEY )
1232       {
1233         log_error(_("key %s: no public key -"
1234                     " can't apply revocation certificate\n"), keystr(keyid));
1235         rc = 0;
1236         goto leave;
1237       }
1238     else if( rc )
1239       {
1240         log_error(_("key %s: public key not found: %s\n"),
1241                   keystr(keyid), g10_errstr(rc));
1242         goto leave;
1243       }
1244
1245     /* read the original keyblock */
1246     hd = keydb_new (0);
1247     {
1248         byte afp[MAX_FINGERPRINT_LEN];
1249         size_t an;
1250         
1251         fingerprint_from_pk (pk, afp, &an);
1252         while (an < MAX_FINGERPRINT_LEN) 
1253             afp[an++] = 0;
1254         rc = keydb_search_fpr (hd, afp);
1255     }
1256     if (rc)
1257       {
1258         log_error (_("key %s: can't locate original keyblock: %s\n"),
1259                    keystr(keyid), g10_errstr(rc));
1260         goto leave;
1261       }
1262     rc = keydb_get_keyblock (hd, &keyblock );
1263     if (rc)
1264       {
1265         log_error (_("key %s: can't read original keyblock: %s\n"),
1266                    keystr(keyid), g10_errstr(rc));
1267         goto leave;
1268       }
1269
1270     /* it is okay, that node is not in keyblock because
1271      * check_key_signature works fine for sig_class 0x20 in this
1272      * special case. */
1273     rc = check_key_signature( keyblock, node, NULL);
1274     if( rc )
1275       {
1276         log_error( _("key %s: invalid revocation certificate"
1277                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1278         goto leave;
1279       }
1280
1281     /* check whether we already have this */
1282     for(onode=keyblock->next; onode; onode=onode->next ) {
1283         if( onode->pkt->pkttype == PKT_USER_ID )
1284             break;
1285         else if( onode->pkt->pkttype == PKT_SIGNATURE
1286                  && !cmp_signatures(node->pkt->pkt.signature,
1287                                     onode->pkt->pkt.signature))
1288           {
1289             rc = 0;
1290             goto leave; /* yes, we already know about it */
1291           }
1292     }
1293
1294
1295     /* insert it */
1296     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1297
1298     /* and write the keyblock back */
1299     rc = keydb_update_keyblock (hd, keyblock );
1300     if (rc)
1301         log_error (_("error writing keyring `%s': %s\n"),
1302                    keydb_get_resource_name (hd), g10_errstr(rc) );
1303     keydb_release (hd); hd = NULL;
1304     /* we are ready */
1305     if( !opt.quiet )
1306       {
1307         char *p=get_user_id_native (keyid);
1308         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1309                   keystr(keyid),p);
1310         xfree(p);
1311       }
1312     stats->n_revoc++;
1313
1314     /* If the key we just revoked was ultimately trusted, remove its
1315        ultimate trust.  This doesn't stop the user from putting the
1316        ultimate trust back, but is a reasonable solution for now. */
1317     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1318       clear_ownertrusts(pk);
1319
1320     revalidation_mark ();
1321
1322   leave:
1323     keydb_release (hd);
1324     release_kbnode( keyblock );
1325     free_public_key( pk );
1326     return rc;
1327 }
1328
1329
1330 /****************
1331  * loop over the keyblock and check all self signatures.
1332  * Mark all user-ids with a self-signature by setting flag bit 0.
1333  * Mark all user-ids with an invalid self-signature by setting bit 1.
1334  * This works also for subkeys, here the subkey is marked.  Invalid or
1335  * extra subkey sigs (binding or revocation) are marked for deletion.
1336  * non_self is set to true if there are any sigs other than self-sigs
1337  * in this keyblock.
1338  */
1339 static int
1340 chk_self_sigs( const char *fname, KBNODE keyblock,
1341                PKT_public_key *pk, u32 *keyid, int *non_self )
1342 {
1343     KBNODE n,knode=NULL;
1344     PKT_signature *sig;
1345     int rc;
1346     u32 bsdate=0,rsdate=0;
1347     KBNODE bsnode=NULL,rsnode=NULL;
1348
1349     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1350       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1351         {
1352           knode=n;
1353           bsdate=0;
1354           rsdate=0;
1355           bsnode=NULL;
1356           rsnode=NULL;
1357           continue;
1358         }
1359       else if( n->pkt->pkttype != PKT_SIGNATURE )
1360             continue;
1361         sig = n->pkt->pkt.signature;
1362         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1363
1364             /* This just caches the sigs for later use.  That way we
1365                import a fully-cached key which speeds things up. */
1366             if(!opt.no_sig_cache)
1367               check_key_signature(keyblock,n,NULL);
1368
1369             if( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1370               {
1371                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1372                 if( !unode )
1373                   {
1374                     log_error( _("key %s: no user ID for signature\n"),
1375                                keystr(keyid));
1376                     return -1;  /* the complete keyblock is invalid */
1377                   }
1378
1379                 /* If it hasn't been marked valid yet, keep trying */
1380                 if(!(unode->flag&1)) {
1381                   rc = check_key_signature( keyblock, n, NULL);
1382                   if( rc )
1383                     {
1384                       if( opt.verbose )
1385                         {
1386                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1387                                       strlen(unode->pkt->pkt.user_id->name),0);
1388                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1389                                     _("key %s: unsupported public key "
1390                                       "algorithm on user ID \"%s\"\n"):
1391                                     _("key %s: invalid self-signature "
1392                                       "on user ID \"%s\"\n"),
1393                                     keystr(keyid),p);
1394                           xfree(p);
1395                         }
1396                     }
1397                   else
1398                     unode->flag |= 1; /* mark that signature checked */
1399                 }
1400               }
1401             else if( sig->sig_class == 0x18 ) {
1402               /* Note that this works based solely on the timestamps
1403                  like the rest of gpg.  If the standard gets
1404                  revocation targets, this may need to be revised. */
1405
1406                 if( !knode )
1407                   {
1408                     if(opt.verbose)
1409                       log_info( _("key %s: no subkey for key binding\n"),
1410                                 keystr(keyid));
1411                     n->flag |= 4; /* delete this */
1412                   }
1413                 else
1414                   {
1415                     rc = check_key_signature( keyblock, n, NULL);
1416                     if( rc )
1417                       {
1418                         if(opt.verbose)
1419                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1420                                    _("key %s: unsupported public key"
1421                                      " algorithm\n"):
1422                                    _("key %s: invalid subkey binding\n"),
1423                                    keystr(keyid));
1424                         n->flag|=4;
1425                       }
1426                     else
1427                       {
1428                         /* It's valid, so is it newer? */
1429                         if(sig->timestamp>=bsdate) {
1430                           knode->flag |= 1;  /* the subkey is valid */
1431                           if(bsnode)
1432                             {
1433                               bsnode->flag|=4; /* Delete the last binding
1434                                                   sig since this one is
1435                                                   newer */
1436                               if(opt.verbose)
1437                                 log_info(_("key %s: removed multiple subkey"
1438                                            " binding\n"),keystr(keyid));
1439                             }
1440
1441                           bsnode=n;
1442                           bsdate=sig->timestamp;
1443                         }
1444                         else
1445                           n->flag|=4; /* older */
1446                       }
1447                   }
1448             }
1449             else if( sig->sig_class == 0x28 ) {
1450               /* We don't actually mark the subkey as revoked right
1451                  now, so just check that the revocation sig is the
1452                  most recent valid one.  Note that we don't care if
1453                  the binding sig is newer than the revocation sig.
1454                  See the comment in getkey.c:merge_selfsigs_subkey for
1455                  more */
1456                 if( !knode )
1457                   {
1458                     if(opt.verbose)
1459                       log_info( _("key %s: no subkey for key revocation\n"),
1460                                 keystr(keyid));
1461                     n->flag |= 4; /* delete this */
1462                   }
1463                 else
1464                   {
1465                     rc = check_key_signature( keyblock, n, NULL);
1466                     if( rc )
1467                       {
1468                         if(opt.verbose)
1469                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1470                                    _("key %s: unsupported public"
1471                                      " key algorithm\n"):
1472                                    _("key %s: invalid subkey revocation\n"),
1473                                    keystr(keyid));
1474                         n->flag|=4;
1475                       }
1476                     else
1477                       {
1478                         /* It's valid, so is it newer? */
1479                         if(sig->timestamp>=rsdate)
1480                           {
1481                             if(rsnode)
1482                               {
1483                                 rsnode->flag|=4; /* Delete the last revocation
1484                                                     sig since this one is
1485                                                     newer */
1486                                 if(opt.verbose)
1487                                   log_info(_("key %s: removed multiple subkey"
1488                                              " revocation\n"),keystr(keyid));
1489                               }
1490
1491                             rsnode=n;
1492                             rsdate=sig->timestamp;
1493                           }
1494                         else
1495                           n->flag|=4; /* older */
1496                       }
1497                   }
1498             }
1499         }
1500         else
1501           *non_self=1;
1502     }
1503
1504     return 0;
1505 }
1506
1507 /****************
1508  * delete all parts which are invalid and those signatures whose
1509  * public key algorithm is not available in this implemenation;
1510  * but consider RSA as valid, because parse/build_packets knows
1511  * about it.
1512  * returns: true if at least one valid user-id is left over.
1513  */
1514 static int
1515 delete_inv_parts( const char *fname, KBNODE keyblock,
1516                   u32 *keyid, unsigned int options)
1517 {
1518     KBNODE node;
1519     int nvalid=0, uid_seen=0, subkey_seen=0;
1520
1521     for(node=keyblock->next; node; node = node->next ) {
1522         if( node->pkt->pkttype == PKT_USER_ID ) {
1523             uid_seen = 1;
1524             if( (node->flag & 2) || !(node->flag & 1) ) {
1525                 if( opt.verbose )
1526                   {
1527                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1528                                            node->pkt->pkt.user_id->len,0);
1529                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1530                               keystr(keyid),p);
1531                     xfree(p);
1532                   }
1533                 delete_kbnode( node ); /* the user-id */
1534                 /* and all following packets up to the next user-id */
1535                 while( node->next
1536                        && node->next->pkt->pkttype != PKT_USER_ID
1537                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1538                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1539                     delete_kbnode( node->next );
1540                     node = node->next;
1541                 }
1542             }
1543             else
1544                 nvalid++;
1545         }
1546         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1547                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1548             if( (node->flag & 2) || !(node->flag & 1) ) {
1549                 if( opt.verbose )
1550                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1551
1552                 delete_kbnode( node ); /* the subkey */
1553                 /* and all following signature packets */
1554                 while( node->next
1555                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1556                     delete_kbnode( node->next );
1557                     node = node->next;
1558                 }
1559             }
1560             else
1561               subkey_seen = 1;
1562         }
1563         else if( node->pkt->pkttype == PKT_SIGNATURE
1564                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1565                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1566             delete_kbnode( node ); /* build_packet() can't handle this */
1567         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1568                  !node->pkt->pkt.signature->flags.exportable &&
1569                  !(options&IMPORT_LOCAL_SIGS) &&
1570                  seckey_available( node->pkt->pkt.signature->keyid ) )
1571           {
1572             /* here we violate the rfc a bit by still allowing
1573              * to import non-exportable signature when we have the
1574              * the secret key used to create this signature - it
1575              * seems that this makes sense */
1576             if(opt.verbose)
1577               log_info( _("key %s: non exportable signature"
1578                           " (class 0x%02X) - skipped\n"),
1579                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1580             delete_kbnode( node );
1581           }
1582         else if( node->pkt->pkttype == PKT_SIGNATURE
1583                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1584             if( uid_seen )
1585               {
1586                 if(opt.verbose)
1587                   log_info( _("key %s: revocation certificate"
1588                               " at wrong place - skipped\n"),keystr(keyid));
1589                 delete_kbnode( node );
1590               }
1591             else {
1592               /* If the revocation cert is from a different key than
1593                  the one we're working on don't check it - it's
1594                  probably from a revocation key and won't be
1595                  verifiable with this key anyway. */
1596
1597               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1598                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1599                 {
1600                   int rc = check_key_signature( keyblock, node, NULL);
1601                   if( rc )
1602                     {
1603                       if(opt.verbose)
1604                         log_info( _("key %s: invalid revocation"
1605                                     " certificate: %s - skipped\n"),
1606                                   keystr(keyid), g10_errstr(rc));
1607                       delete_kbnode( node );
1608                     }
1609                 }
1610             }
1611         }
1612         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1613                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1614                   node->pkt->pkt.signature->sig_class == 0x28) &&
1615                  !subkey_seen )
1616           {
1617             if(opt.verbose)
1618               log_info( _("key %s: subkey signature"
1619                           " in wrong place - skipped\n"), keystr(keyid));
1620             delete_kbnode( node );
1621           }
1622         else if( node->pkt->pkttype == PKT_SIGNATURE
1623                  && !IS_CERT(node->pkt->pkt.signature))
1624           {
1625             if(opt.verbose)
1626               log_info(_("key %s: unexpected signature class (0x%02X) -"
1627                          " skipped\n"),keystr(keyid),
1628                        node->pkt->pkt.signature->sig_class);
1629             delete_kbnode(node);
1630           }
1631         else if( (node->flag & 4) ) /* marked for deletion */
1632           delete_kbnode( node );
1633     }
1634
1635     /* note: because keyblock is the public key, it is never marked
1636      * for deletion and so keyblock cannot change */
1637     commit_kbnode( &keyblock );
1638     return nvalid;
1639 }
1640
1641
1642 /****************
1643  * It may happen that the imported keyblock has duplicated user IDs.
1644  * We check this here and collapse those user IDs together with their
1645  * sigs into one.
1646  * Returns: True if the keyblock hash changed.
1647  */
1648 int
1649 collapse_uids( KBNODE *keyblock )
1650 {
1651     KBNODE n, n2;
1652     int in_uid;
1653     int any=0;
1654
1655   restart:
1656     for( n = *keyblock; n; n = n->next ) {
1657         if( n->pkt->pkttype != PKT_USER_ID )
1658             continue;
1659         for( n2 = n->next; n2; n2 = n2->next ) {
1660             if( n2->pkt->pkttype == PKT_USER_ID
1661                 && !cmp_user_ids( n->pkt->pkt.user_id,
1662                                   n2->pkt->pkt.user_id ) ) {
1663                 /* found a duplicate */
1664                 any = 1;
1665                 if( !n2->next
1666                     || n2->next->pkt->pkttype == PKT_USER_ID
1667                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1668                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1669                     /* no more signatures: delete the user ID
1670                      * and start over */
1671                     remove_kbnode( keyblock, n2 );
1672                 }
1673                 else {
1674                     /* The simple approach: Move one signature and
1675                      * then start over to delete the next one :-( */
1676                     move_kbnode( keyblock, n2->next, n->next );
1677                 }
1678                 goto restart;
1679             }
1680         }
1681     }
1682     if( !any )
1683         return 0;
1684
1685   restart_sig:
1686     /* now we may have duplicate signatures on one user ID: fix this */
1687     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1688         if( n->pkt->pkttype == PKT_USER_ID )
1689             in_uid = 1;
1690         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1691                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1692             in_uid = 0;
1693         else if( in_uid ) {
1694             n2 = n;
1695             do {
1696                 KBNODE ncmp = NULL;
1697                 for( ; n2; n2 = n2->next ) {
1698                     if(    n2->pkt->pkttype == PKT_USER_ID
1699                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1700                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1701                         break;
1702                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1703                         ;
1704                     else if( !ncmp )
1705                         ncmp = n2;
1706                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1707                                                 n2->pkt->pkt.signature )) {
1708                         remove_kbnode( keyblock, n2 );
1709                         goto restart_sig;
1710                     }
1711                 }
1712                 n2 = ncmp? ncmp->next : NULL;
1713             } while( n2 );
1714         }
1715     }
1716
1717     if(!opt.quiet)
1718       {
1719         const char *key="???";
1720
1721         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1722           key=keystr_from_pk(n->pkt->pkt.public_key);
1723         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1724           key=keystr_from_sk(n->pkt->pkt.secret_key);
1725
1726         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1727       }
1728
1729     return 1;
1730 }
1731
1732 /* Check for a 0x20 revocation from a revocation key that is not
1733    present.  This may be called without the benefit of merge_xxxx so
1734    you can't rely on pk->revkey and friends. */
1735 static void
1736 revocation_present(KBNODE keyblock)
1737 {
1738   KBNODE onode,inode;
1739   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1740
1741   for(onode=keyblock->next;onode;onode=onode->next)
1742     {
1743       /* If we reach user IDs, we're done. */
1744       if(onode->pkt->pkttype==PKT_USER_ID)
1745         break;
1746
1747       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1748          onode->pkt->pkt.signature->sig_class==0x1F &&
1749          onode->pkt->pkt.signature->revkey)
1750         {
1751           int idx;
1752           PKT_signature *sig=onode->pkt->pkt.signature;
1753
1754           for(idx=0;idx<sig->numrevkeys;idx++)
1755             {
1756               u32 keyid[2];
1757
1758               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1759                                      MAX_FINGERPRINT_LEN,keyid);
1760
1761               for(inode=keyblock->next;inode;inode=inode->next)
1762                 {
1763                   /* If we reach user IDs, we're done. */
1764                   if(inode->pkt->pkttype==PKT_USER_ID)
1765                     break;
1766
1767                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1768                      inode->pkt->pkt.signature->sig_class==0x20 &&
1769                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1770                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1771                     {
1772                       /* Okay, we have a revocation key, and a
1773                          revocation issued by it.  Do we have the key
1774                          itself? */
1775                       int rc;
1776
1777                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1778                                                    MAX_FINGERPRINT_LEN);
1779                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1780                         {
1781                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
1782
1783                           /* No, so try and get it */
1784                           if(opt.keyserver
1785                              && (opt.keyserver_options.options
1786                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1787                             {
1788                               log_info(_("WARNING: key %s may be revoked:"
1789                                          " fetching revocation key %s\n"),
1790                                        tempkeystr,keystr(keyid));
1791                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1792                                                       MAX_FINGERPRINT_LEN,
1793                                                       opt.keyserver);
1794
1795                               /* Do we have it now? */
1796                               rc=get_pubkey_byfprint_fast (NULL,
1797                                                      sig->revkey[idx]->fpr,
1798                                                      MAX_FINGERPRINT_LEN);
1799                             }
1800
1801                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1802                             log_info(_("WARNING: key %s may be revoked:"
1803                                        " revocation key %s not present.\n"),
1804                                      tempkeystr,keystr(keyid));
1805
1806                           xfree(tempkeystr);
1807                         }
1808                     }
1809                 }
1810             }
1811         }
1812     }
1813 }
1814
1815 /****************
1816  * compare and merge the blocks
1817  *
1818  * o compare the signatures: If we already have this signature, check
1819  *   that they compare okay; if not, issue a warning and ask the user.
1820  * o Simply add the signature.  Can't verify here because we may not have
1821  *   the signature's public key yet; verification is done when putting it
1822  *   into the trustdb, which is done automagically as soon as this pubkey
1823  *   is used.
1824  * Note: We indicate newly inserted packets with flag bit 0
1825  */
1826 static int
1827 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1828               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1829 {
1830     KBNODE onode, node;
1831     int rc, found;
1832
1833     /* 1st: handle revocation certificates */
1834     for(node=keyblock->next; node; node=node->next ) {
1835         if( node->pkt->pkttype == PKT_USER_ID )
1836             break;
1837         else if( node->pkt->pkttype == PKT_SIGNATURE
1838                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1839             /* check whether we already have this */
1840             found = 0;
1841             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1842                 if( onode->pkt->pkttype == PKT_USER_ID )
1843                     break;
1844                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1845                          && onode->pkt->pkt.signature->sig_class == 0x20
1846                          && !cmp_signatures(onode->pkt->pkt.signature,
1847                                             node->pkt->pkt.signature))
1848                   {
1849                     found = 1;
1850                     break;
1851                   }
1852             }
1853             if( !found ) {
1854                 KBNODE n2 = clone_kbnode(node);
1855                 insert_kbnode( keyblock_orig, n2, 0 );
1856                 n2->flag |= 1;
1857                 ++*n_sigs;
1858                 if(!opt.quiet)
1859                   {
1860                     char *p=get_user_id_native (keyid);
1861                     log_info(_("key %s: \"%s\" revocation"
1862                                " certificate added\n"), keystr(keyid),p);
1863                     xfree(p);
1864                   }
1865             }
1866         }
1867     }
1868
1869     /* 2nd: merge in any direct key (0x1F) sigs */
1870     for(node=keyblock->next; node; node=node->next ) {
1871         if( node->pkt->pkttype == PKT_USER_ID )
1872             break;
1873         else if( node->pkt->pkttype == PKT_SIGNATURE
1874                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1875             /* check whether we already have this */
1876             found = 0;
1877             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1878                 if( onode->pkt->pkttype == PKT_USER_ID )
1879                     break;
1880                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1881                          && onode->pkt->pkt.signature->sig_class == 0x1F
1882                          && !cmp_signatures(onode->pkt->pkt.signature,
1883                                             node->pkt->pkt.signature)) {
1884                     found = 1;
1885                     break;
1886                 }
1887             }
1888             if( !found )
1889               {
1890                 KBNODE n2 = clone_kbnode(node);
1891                 insert_kbnode( keyblock_orig, n2, 0 );
1892                 n2->flag |= 1;
1893                 ++*n_sigs;
1894                 if(!opt.quiet)
1895                   log_info( _("key %s: direct key signature added\n"),
1896                             keystr(keyid));
1897               }
1898         }
1899     }
1900
1901     /* 3rd: try to merge new certificates in */
1902     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1903         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1904             /* find the user id in the imported keyblock */
1905             for(node=keyblock->next; node; node=node->next )
1906                 if( node->pkt->pkttype == PKT_USER_ID
1907                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1908                                           node->pkt->pkt.user_id ) )
1909                     break;
1910             if( node ) { /* found: merge */
1911                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1912                 if( rc )
1913                     return rc;
1914             }
1915         }
1916     }
1917
1918     /* 4th: add new user-ids */
1919     for(node=keyblock->next; node; node=node->next ) {
1920         if( node->pkt->pkttype == PKT_USER_ID) {
1921             /* do we have this in the original keyblock */
1922             for(onode=keyblock_orig->next; onode; onode=onode->next )
1923                 if( onode->pkt->pkttype == PKT_USER_ID
1924                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1925                                       node->pkt->pkt.user_id ) )
1926                     break;
1927             if( !onode ) { /* this is a new user id: append */
1928                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1929                 if( rc )
1930                     return rc;
1931                 ++*n_uids;
1932             }
1933         }
1934     }
1935
1936     /* 5th: add new subkeys */
1937     for(node=keyblock->next; node; node=node->next ) {
1938         onode = NULL;
1939         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1940             /* do we have this in the original keyblock? */
1941             for(onode=keyblock_orig->next; onode; onode=onode->next )
1942                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1943                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1944                                          node->pkt->pkt.public_key ) )
1945                     break;
1946             if( !onode ) { /* this is a new subkey: append */
1947                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1948                 if( rc )
1949                     return rc;
1950                 ++*n_subk;
1951             }
1952         }
1953         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1954             /* do we have this in the original keyblock? */
1955             for(onode=keyblock_orig->next; onode; onode=onode->next )
1956                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1957                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1958                                          node->pkt->pkt.secret_key ) )
1959                     break;
1960             if( !onode ) { /* this is a new subkey: append */
1961                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1962                 if( rc )
1963                     return rc;
1964                 ++*n_subk;
1965             }
1966         }
1967     }
1968
1969     /* 6th: merge subkey certificates */
1970     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1971         if( !(onode->flag & 1)
1972             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1973                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1974             /* find the subkey in the imported keyblock */
1975             for(node=keyblock->next; node; node=node->next ) {
1976                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1977                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1978                                           node->pkt->pkt.public_key ) )
1979                     break;
1980                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1981                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1982                                           node->pkt->pkt.secret_key ) )
1983                     break;
1984             }
1985             if( node ) { /* found: merge */
1986                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1987                 if( rc )
1988                     return rc;
1989             }
1990         }
1991     }
1992
1993
1994     return 0;
1995 }
1996
1997
1998 /****************
1999  * append the userid starting with NODE and all signatures to KEYBLOCK.
2000  */
2001 static int
2002 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
2003                                           const char *fname, u32 *keyid )
2004 {
2005     KBNODE n, n_where=NULL;
2006
2007     assert(node->pkt->pkttype == PKT_USER_ID );
2008
2009     /* find the position */
2010     for( n = keyblock; n; n_where = n, n = n->next ) {
2011         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2012             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2013             break;
2014     }
2015     if( !n )
2016         n_where = NULL;
2017
2018     /* and append/insert */
2019     while( node ) {
2020         /* we add a clone to the original keyblock, because this
2021          * one is released first */
2022         n = clone_kbnode(node);
2023         if( n_where ) {
2024             insert_kbnode( n_where, n, 0 );
2025             n_where = n;
2026         }
2027         else
2028             add_kbnode( keyblock, n );
2029         n->flag |= 1;
2030         node->flag |= 1;
2031         if( n->pkt->pkttype == PKT_SIGNATURE )
2032             ++*n_sigs;
2033
2034         node = node->next;
2035         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2036             break;
2037     }
2038
2039     return 0;
2040 }
2041
2042
2043 /****************
2044  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2045  * (how should we handle comment packets here?)
2046  */
2047 static int
2048 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2049                                     const char *fname, u32 *keyid )
2050 {
2051     KBNODE n, n2;
2052     int found=0;
2053
2054     assert(dst->pkt->pkttype == PKT_USER_ID );
2055     assert(src->pkt->pkttype == PKT_USER_ID );
2056
2057     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2058         if( n->pkt->pkttype != PKT_SIGNATURE )
2059             continue;
2060         if( n->pkt->pkt.signature->sig_class == 0x18
2061             || n->pkt->pkt.signature->sig_class == 0x28 )
2062             continue; /* skip signatures which are only valid on subkeys */
2063         found = 0;
2064         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2065           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2066             {
2067               found++;
2068               break;
2069             }
2070         if( !found ) {
2071             /* This signature is new or newer, append N to DST.
2072              * We add a clone to the original keyblock, because this
2073              * one is released first */
2074             n2 = clone_kbnode(n);
2075             insert_kbnode( dst, n2, PKT_SIGNATURE );
2076             n2->flag |= 1;
2077             n->flag |= 1;
2078             ++*n_sigs;
2079         }
2080     }
2081
2082     return 0;
2083 }
2084
2085 /****************
2086  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2087  */
2088 static int
2089 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2090                                     const char *fname, u32 *keyid )
2091 {
2092     KBNODE n, n2;
2093     int found=0;
2094
2095     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2096            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2097
2098     for(n=src->next; n ; n = n->next ) {
2099         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2100             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2101             break;
2102         if( n->pkt->pkttype != PKT_SIGNATURE )
2103             continue;
2104         found = 0;
2105         for(n2=dst->next; n2; n2 = n2->next){
2106             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2107                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2108                 break;
2109             if( n2->pkt->pkttype == PKT_SIGNATURE
2110                 && n->pkt->pkt.signature->keyid[0]
2111                    == n2->pkt->pkt.signature->keyid[0]
2112                 && n->pkt->pkt.signature->keyid[1]
2113                    == n2->pkt->pkt.signature->keyid[1]
2114                 && n->pkt->pkt.signature->timestamp
2115                    <= n2->pkt->pkt.signature->timestamp
2116                 && n->pkt->pkt.signature->sig_class
2117                    == n2->pkt->pkt.signature->sig_class ) {
2118                 found++;
2119                 break;
2120             }
2121         }
2122         if( !found ) {
2123             /* This signature is new or newer, append N to DST.
2124              * We add a clone to the original keyblock, because this
2125              * one is released first */
2126             n2 = clone_kbnode(n);
2127             insert_kbnode( dst, n2, PKT_SIGNATURE );
2128             n2->flag |= 1;
2129             n->flag |= 1;
2130             ++*n_sigs;
2131         }
2132     }
2133
2134     return 0;
2135 }
2136
2137 /****************
2138  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2139  * Mark all new and copied packets by setting flag bit 0.
2140  */
2141 static int
2142 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2143                                           const char *fname, u32 *keyid )
2144 {
2145     KBNODE n;
2146
2147     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2148            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2149
2150     while(  node ) {
2151         /* we add a clone to the original keyblock, because this
2152          * one is released first */
2153         n = clone_kbnode(node);
2154         add_kbnode( keyblock, n );
2155         n->flag |= 1;
2156         node->flag |= 1;
2157         if( n->pkt->pkttype == PKT_SIGNATURE )
2158             ++*n_sigs;
2159
2160         node = node->next;
2161         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2162             break;
2163     }
2164
2165     return 0;
2166 }
2167
2168
2169
2170 /* Walk a public keyblock and produce a secret keyblock out of it.
2171    Instead of inserting the secret key parameters (which we don't
2172    have), we insert a stub.  */
2173 static KBNODE
2174 pub_to_sec_keyblock (KBNODE pub_keyblock)
2175 {
2176   KBNODE pubnode, secnode;
2177   KBNODE sec_keyblock = NULL;
2178   KBNODE walkctx = NULL;
2179
2180   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2181     {
2182       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2183           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2184         {
2185           /* Make a secret key.  We only need to convert enough to
2186              write the keyblock out. */
2187           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2188           PACKET *pkt = xmalloc_clear (sizeof *pkt);
2189           PKT_secret_key *sk = xmalloc_clear (sizeof *sk);
2190           int i, n;
2191           
2192           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2193             pkt->pkttype = PKT_SECRET_KEY;
2194           else
2195             pkt->pkttype = PKT_SECRET_SUBKEY;
2196           
2197           pkt->pkt.secret_key = sk;
2198
2199           copy_public_parts_to_secret_key ( pk, sk );
2200           sk->version     = pk->version;
2201           sk->timestamp   = pk->timestamp;
2202         
2203           n = pubkey_get_npkey (pk->pubkey_algo);
2204           if (!n)
2205             n = 1; /* Unknown number of parameters, however the data
2206                       is stored in the first mpi. */
2207           for (i=0; i < n; i++ )
2208             sk->skey[i] = mpi_copy (pk->pkey[i]);
2209   
2210           sk->is_protected = 1;
2211           sk->protect.s2k.mode = 1001;
2212   
2213           secnode = new_kbnode (pkt);
2214         }
2215       else
2216         {
2217           secnode = clone_kbnode (pubnode);
2218         }
2219       
2220       if(!sec_keyblock)
2221         sec_keyblock = secnode;
2222       else
2223         add_kbnode (sec_keyblock, secnode);
2224     }
2225
2226   return sec_keyblock;
2227 }
2228
2229
2230 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2231    stub keys with the serial number SNNUM of the card if one of the
2232    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2233    a duplicate (may happen in case of backed uped keys). 
2234    
2235    Returns: True if anything changed.
2236 */
2237 static int
2238 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock, 
2239                                    const unsigned char *fpr1,
2240                                    const unsigned char *fpr2,
2241                                    const unsigned char *fpr3,
2242                                    const char *serialnostr)
2243 {
2244   KBNODE node;
2245   KBNODE walkctx = NULL;
2246   PKT_secret_key *sk;
2247   byte array[MAX_FINGERPRINT_LEN];
2248   size_t n;
2249   int result = 0;
2250   const char *s;
2251
2252   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2253     {
2254       if (node->pkt->pkttype != PKT_SECRET_KEY
2255           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2256         continue;
2257       sk = node->pkt->pkt.secret_key;
2258       
2259       fingerprint_from_sk (sk, array, &n);
2260       if (n != 20)
2261         continue; /* Can't be a card key.  */
2262       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2263              || (fpr2 && !memcmp (array, fpr2, 20))
2264              || (fpr3 && !memcmp (array, fpr3, 20))) )
2265         continue;  /* No match.  */
2266
2267       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2268         {
2269           /* Standard case: migrate that stub to a key stub.  */
2270           sk->protect.s2k.mode = 1002;
2271           s = serialnostr;
2272           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2273                sk->protect.ivlen++, s += 2)
2274             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2275           result = 1;
2276         }
2277       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2278         {
2279           s = serialnostr;
2280           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2281                sk->protect.ivlen++, s += 2)
2282             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2283               {
2284                 log_info (_("NOTE: a key's S/N does not "
2285                             "match the card's one\n"));
2286                 break;
2287               }
2288         }
2289       else
2290         {
2291           if (node->pkt->pkttype != PKT_SECRET_KEY)
2292             log_info (_("NOTE: primary key is online and stored on card\n"));
2293           else
2294             log_info (_("NOTE: secondary key is online and stored on card\n"));
2295         }
2296     }
2297
2298   return result;
2299 }
2300
2301
2302
2303 /* Check whether a secret key stub exists for the public key PK.  If
2304    not create such a stub key and store it into the secring.  If it
2305    exists, add appropriate subkey stubs and update the secring.
2306    Return 0 if the key could be created. */
2307 int
2308 auto_create_card_key_stub ( const char *serialnostr, 
2309                             const unsigned char *fpr1,
2310                             const unsigned char *fpr2,
2311                             const unsigned char *fpr3)
2312 {
2313   KBNODE pub_keyblock;
2314   KBNODE sec_keyblock;
2315   KEYDB_HANDLE hd;
2316   int rc;
2317
2318   /* We only want to do this for an OpenPGP card.  */
2319   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12) 
2320       || strlen (serialnostr) != 32 )
2321     return G10ERR_GENERAL;
2322
2323   /* First get the public keyring from any of the provided fingerprints. */
2324   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2325        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2326        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2327     ;
2328   else
2329     return G10ERR_GENERAL;
2330  
2331   hd = keydb_new (1);
2332
2333   /* Now check whether there is a secret keyring.  */
2334   {
2335     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2336     byte afp[MAX_FINGERPRINT_LEN];
2337     size_t an;
2338
2339     fingerprint_from_pk (pk, afp, &an);
2340     memset (afp, 0, MAX_FINGERPRINT_LEN);
2341     rc = keydb_search_fpr (hd, afp);
2342   }
2343
2344   if (!rc)
2345     {
2346       rc = keydb_get_keyblock (hd, &sec_keyblock);
2347       if (rc)
2348         {
2349           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2350           rc = G10ERR_GENERAL;
2351         }
2352       else
2353         {
2354           merge_keys_and_selfsig (sec_keyblock);
2355           
2356           /* FIXME: We need to add new subkeys first.  */
2357           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2358                                                  fpr1, fpr2, fpr3,
2359                                                  serialnostr))
2360             {
2361               rc = keydb_update_keyblock (hd, sec_keyblock );
2362               if (rc)
2363                 log_error (_("error writing keyring `%s': %s\n"),
2364                            keydb_get_resource_name (hd), g10_errstr(rc) );
2365             }
2366         }
2367     }
2368   else  /* A secret key does not exists - create it.  */
2369     {
2370       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2371       update_sec_keyblock_with_cardinfo (sec_keyblock,
2372                                          fpr1, fpr2, fpr3,
2373                                          serialnostr);
2374
2375       rc = keydb_locate_writable (hd, NULL);
2376       if (rc)
2377         {
2378           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2379           rc = G10ERR_GENERAL;
2380         }
2381       else
2382         {
2383           rc = keydb_insert_keyblock (hd, sec_keyblock );
2384           if (rc)
2385             log_error (_("error writing keyring `%s': %s\n"),
2386                        keydb_get_resource_name (hd), g10_errstr(rc) );
2387         }
2388     }
2389     
2390   release_kbnode (sec_keyblock);
2391   release_kbnode (pub_keyblock);
2392   keydb_release (hd);
2393   return rc;
2394 }
2395