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