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