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