* getkey.c (get_pubkey_byname), import.c (import_one): Fix key selection
[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 && stats->imported==1)
982           {
983             xfree(*fpr);
984             *fpr=fingerprint_from_pk(pk,NULL,fpr_len);
985           }
986         else
987           {
988             xfree(*fpr);
989             *fpr=NULL;
990           }
991
992         revocation_present(keyblock);
993         if(seckey_available(keyid)==0)
994           check_prefs(keyblock);
995       }
996
997     release_kbnode( keyblock_orig );
998     free_public_key( pk_orig );
999
1000     return rc;
1001 }
1002
1003 /* Walk a secret keyblock and produce a public keyblock out of it. */
1004 static KBNODE
1005 sec_to_pub_keyblock(KBNODE sec_keyblock)
1006 {
1007   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
1008
1009   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
1010     {
1011       KBNODE pubnode;
1012
1013       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
1014          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
1015         {
1016           /* Make a public key.  We only need to convert enough to
1017              write the keyblock out. */
1018
1019           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
1020           PACKET *pkt=xmalloc_clear(sizeof(PACKET));
1021           PKT_public_key *pk=xmalloc_clear(sizeof(PKT_public_key));
1022           int n;
1023
1024           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
1025             pkt->pkttype=PKT_PUBLIC_KEY;
1026           else
1027             pkt->pkttype=PKT_PUBLIC_SUBKEY;
1028
1029           pkt->pkt.public_key=pk;
1030
1031           pk->version=sk->version;
1032           pk->timestamp=sk->timestamp;
1033           pk->expiredate=sk->expiredate;
1034           pk->pubkey_algo=sk->pubkey_algo;
1035
1036           n=pubkey_get_npkey(pk->pubkey_algo);
1037           if(n==0)
1038             {
1039               /* we can't properly extract the pubkey without knowing
1040                  the number of MPIs */
1041               release_kbnode(pub_keyblock);
1042               return NULL;
1043             }
1044           else
1045             {
1046               int i;
1047
1048               for(i=0;i<n;i++)
1049                 pk->pkey[i]=mpi_copy(sk->skey[i]);
1050             }
1051
1052           pubnode=new_kbnode(pkt);
1053         }
1054       else
1055         {
1056           pubnode=clone_kbnode(secnode);
1057         }
1058
1059       if(pub_keyblock==NULL)
1060         pub_keyblock=pubnode;
1061       else
1062         add_kbnode(pub_keyblock,pubnode);
1063     }
1064
1065   return pub_keyblock;
1066 }
1067
1068 /****************
1069  * Ditto for secret keys.  Handling is simpler than for public keys.
1070  * We allow secret key importing only when allow is true, this is so
1071  * that a secret key can not be imported accidently and thereby tampering
1072  * with the trust calculation.
1073  */
1074 static int
1075 import_secret_one( const char *fname, KBNODE keyblock, 
1076                    struct stats_s *stats, unsigned int options)
1077 {
1078     PKT_secret_key *sk;
1079     KBNODE node, uidnode;
1080     u32 keyid[2];
1081     int rc = 0;
1082
1083     /* get the key and print some info about it */
1084     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1085     if( !node )
1086         BUG();
1087
1088     sk = node->pkt->pkt.secret_key;
1089     keyid_from_sk( sk, keyid );
1090     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1091
1092     if( opt.verbose )
1093       {
1094         log_info( "sec  %4u%c/%s %s   ",
1095                   nbits_from_sk( sk ),
1096                   pubkey_letter( sk->pubkey_algo ),
1097                   keystr_from_sk(sk), datestr_from_sk(sk) );
1098         if( uidnode )
1099           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1100                              uidnode->pkt->pkt.user_id->len );
1101         putc('\n', stderr);
1102       }
1103     stats->secret_read++;
1104
1105     if( !uidnode )
1106       {
1107         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1108         return 0;
1109       }
1110
1111     if(sk->protect.algo>110)
1112       {
1113         log_error(_("key %s: secret key with invalid cipher %d"
1114                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1115         return 0;
1116       }
1117
1118 #ifdef ENABLE_SELINUX_HACKS
1119     if (1)
1120       {
1121         /* We don't allow to import secret keys because that may be used
1122            to put a secret key into the keyring and the user might later
1123            be tricked into signing stuff with that key.  */
1124         log_error (_("importing secret keys not allowed\n"));
1125         return 0;
1126       }
1127 #endif 
1128     
1129     clear_kbnode_flags( keyblock );
1130
1131     /* do we have this key already in one of our secrings ? */
1132     rc = seckey_available( keyid );
1133     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1134       {
1135         /* simply insert this key */
1136         KEYDB_HANDLE hd = keydb_new (1);
1137
1138         /* get default resource */
1139         rc = keydb_locate_writable (hd, NULL);
1140         if (rc) {
1141           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1142           keydb_release (hd);
1143           return G10ERR_GENERAL;
1144         }
1145         rc = keydb_insert_keyblock (hd, keyblock );
1146         if (rc)
1147           log_error (_("error writing keyring `%s': %s\n"),
1148                      keydb_get_resource_name (hd), g10_errstr(rc) );
1149         keydb_release (hd);
1150         /* we are ready */
1151         if( !opt.quiet )
1152           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1153         stats->secret_imported++;
1154         if (is_status_enabled ()) 
1155           print_import_ok (NULL, sk, 1|16);
1156
1157         if(options&IMPORT_SK2PK)
1158           {
1159             /* Try and make a public key out of this. */
1160
1161             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1162             if(pub_keyblock)
1163               {
1164                 import_one(fname,pub_keyblock,stats,
1165                            NULL,NULL,opt.import_options);
1166                 release_kbnode(pub_keyblock);
1167               }
1168           }
1169
1170         /* Now that the key is definitely incorporated into the keydb,
1171            if we have the public part of this key, we need to check if
1172            the prefs are rational. */
1173         node=get_pubkeyblock(keyid);
1174         if(node)
1175           {
1176             check_prefs(node);
1177             release_kbnode(node);
1178           }
1179       }
1180     else if( !rc )
1181       { /* we can't merge secret keys */
1182         log_error( _("key %s: already in secret keyring\n"),
1183                    keystr_from_sk(sk));
1184         stats->secret_dups++;
1185         if (is_status_enabled ()) 
1186           print_import_ok (NULL, sk, 16);
1187
1188         /* TODO: if we ever do merge secret keys, make sure to handle
1189            the sec_to_pub_keyblock feature as well. */
1190       }
1191     else
1192       log_error( _("key %s: secret key not found: %s\n"),
1193                  keystr_from_sk(sk), g10_errstr(rc));
1194
1195     return rc;
1196 }
1197
1198
1199 /****************
1200  * Import a revocation certificate; this is a single signature packet.
1201  */
1202 static int
1203 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1204 {
1205     PKT_public_key *pk=NULL;
1206     KBNODE onode, keyblock = NULL;
1207     KEYDB_HANDLE hd = NULL;
1208     u32 keyid[2];
1209     int rc = 0;
1210
1211     assert( !node->next );
1212     assert( node->pkt->pkttype == PKT_SIGNATURE );
1213     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1214
1215     keyid[0] = node->pkt->pkt.signature->keyid[0];
1216     keyid[1] = node->pkt->pkt.signature->keyid[1];
1217
1218     pk = xmalloc_clear( sizeof *pk );
1219     rc = get_pubkey( pk, keyid );
1220     if( rc == G10ERR_NO_PUBKEY )
1221       {
1222         log_error(_("key %s: no public key -"
1223                     " can't apply revocation certificate\n"), keystr(keyid));
1224         rc = 0;
1225         goto leave;
1226       }
1227     else if( rc )
1228       {
1229         log_error(_("key %s: public key not found: %s\n"),
1230                   keystr(keyid), g10_errstr(rc));
1231         goto leave;
1232       }
1233
1234     /* read the original keyblock */
1235     hd = keydb_new (0);
1236     {
1237         byte afp[MAX_FINGERPRINT_LEN];
1238         size_t an;
1239         
1240         fingerprint_from_pk (pk, afp, &an);
1241         while (an < MAX_FINGERPRINT_LEN) 
1242             afp[an++] = 0;
1243         rc = keydb_search_fpr (hd, afp);
1244     }
1245     if (rc)
1246       {
1247         log_error (_("key %s: can't locate original keyblock: %s\n"),
1248                    keystr(keyid), g10_errstr(rc));
1249         goto leave;
1250       }
1251     rc = keydb_get_keyblock (hd, &keyblock );
1252     if (rc)
1253       {
1254         log_error (_("key %s: can't read original keyblock: %s\n"),
1255                    keystr(keyid), g10_errstr(rc));
1256         goto leave;
1257       }
1258
1259     /* it is okay, that node is not in keyblock because
1260      * check_key_signature works fine for sig_class 0x20 in this
1261      * special case. */
1262     rc = check_key_signature( keyblock, node, NULL);
1263     if( rc )
1264       {
1265         log_error( _("key %s: invalid revocation certificate"
1266                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1267         goto leave;
1268       }
1269
1270     /* check whether we already have this */
1271     for(onode=keyblock->next; onode; onode=onode->next ) {
1272         if( onode->pkt->pkttype == PKT_USER_ID )
1273             break;
1274         else if( onode->pkt->pkttype == PKT_SIGNATURE
1275                  && !cmp_signatures(node->pkt->pkt.signature,
1276                                     onode->pkt->pkt.signature))
1277           {
1278             rc = 0;
1279             goto leave; /* yes, we already know about it */
1280           }
1281     }
1282
1283
1284     /* insert it */
1285     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1286
1287     /* and write the keyblock back */
1288     rc = keydb_update_keyblock (hd, keyblock );
1289     if (rc)
1290         log_error (_("error writing keyring `%s': %s\n"),
1291                    keydb_get_resource_name (hd), g10_errstr(rc) );
1292     keydb_release (hd); hd = NULL;
1293     /* we are ready */
1294     if( !opt.quiet )
1295       {
1296         char *p=get_user_id_native (keyid);
1297         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1298                   keystr(keyid),p);
1299         xfree(p);
1300       }
1301     stats->n_revoc++;
1302
1303     /* If the key we just revoked was ultimately trusted, remove its
1304        ultimate trust.  This doesn't stop the user from putting the
1305        ultimate trust back, but is a reasonable solution for now. */
1306     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1307       clear_ownertrusts(pk);
1308
1309     revalidation_mark ();
1310
1311   leave:
1312     keydb_release (hd);
1313     release_kbnode( keyblock );
1314     free_public_key( pk );
1315     return rc;
1316 }
1317
1318
1319 /****************
1320  * loop over the keyblock and check all self signatures.
1321  * Mark all user-ids with a self-signature by setting flag bit 0.
1322  * Mark all user-ids with an invalid self-signature by setting bit 1.
1323  * This works also for subkeys, here the subkey is marked.  Invalid or
1324  * extra subkey sigs (binding or revocation) are marked for deletion.
1325  * non_self is set to true if there are any sigs other than self-sigs
1326  * in this keyblock.
1327  */
1328 static int
1329 chk_self_sigs( const char *fname, KBNODE keyblock,
1330                PKT_public_key *pk, u32 *keyid, int *non_self )
1331 {
1332     KBNODE n,knode=NULL;
1333     PKT_signature *sig;
1334     int rc;
1335     u32 bsdate=0,rsdate=0;
1336     KBNODE bsnode=NULL,rsnode=NULL;
1337
1338     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1339       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1340         {
1341           knode=n;
1342           bsdate=0;
1343           rsdate=0;
1344           bsnode=NULL;
1345           rsnode=NULL;
1346           continue;
1347         }
1348       else if( n->pkt->pkttype != PKT_SIGNATURE )
1349             continue;
1350         sig = n->pkt->pkt.signature;
1351         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1352
1353             /* This just caches the sigs for later use.  That way we
1354                import a fully-cached key which speeds things up. */
1355             if(!opt.no_sig_cache)
1356               check_key_signature(keyblock,n,NULL);
1357
1358             if( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1359               {
1360                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1361                 if( !unode )
1362                   {
1363                     log_error( _("key %s: no user ID for signature\n"),
1364                                keystr(keyid));
1365                     return -1;  /* the complete keyblock is invalid */
1366                   }
1367
1368                 /* If it hasn't been marked valid yet, keep trying */
1369                 if(!(unode->flag&1)) {
1370                   rc = check_key_signature( keyblock, n, NULL);
1371                   if( rc )
1372                     {
1373                       if( opt.verbose )
1374                         {
1375                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1376                                       strlen(unode->pkt->pkt.user_id->name),0);
1377                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1378                                     _("key %s: unsupported public key "
1379                                       "algorithm on user ID \"%s\"\n"):
1380                                     _("key %s: invalid self-signature "
1381                                       "on user ID \"%s\"\n"),
1382                                     keystr(keyid),p);
1383                           xfree(p);
1384                         }
1385                     }
1386                   else
1387                     unode->flag |= 1; /* mark that signature checked */
1388                 }
1389               }
1390             else if( sig->sig_class == 0x18 ) {
1391               /* Note that this works based solely on the timestamps
1392                  like the rest of gpg.  If the standard gets
1393                  revocation targets, this may need to be revised. */
1394
1395                 if( !knode )
1396                   {
1397                     if(opt.verbose)
1398                       log_info( _("key %s: no subkey for key binding\n"),
1399                                 keystr(keyid));
1400                     n->flag |= 4; /* delete this */
1401                   }
1402                 else
1403                   {
1404                     rc = check_key_signature( keyblock, n, NULL);
1405                     if( rc )
1406                       {
1407                         if(opt.verbose)
1408                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1409                                    _("key %s: unsupported public key"
1410                                      " algorithm\n"):
1411                                    _("key %s: invalid subkey binding\n"),
1412                                    keystr(keyid));
1413                         n->flag|=4;
1414                       }
1415                     else
1416                       {
1417                         /* It's valid, so is it newer? */
1418                         if(sig->timestamp>=bsdate) {
1419                           knode->flag |= 1;  /* the subkey is valid */
1420                           if(bsnode)
1421                             {
1422                               bsnode->flag|=4; /* Delete the last binding
1423                                                   sig since this one is
1424                                                   newer */
1425                               if(opt.verbose)
1426                                 log_info(_("key %s: removed multiple subkey"
1427                                            " binding\n"),keystr(keyid));
1428                             }
1429
1430                           bsnode=n;
1431                           bsdate=sig->timestamp;
1432                         }
1433                         else
1434                           n->flag|=4; /* older */
1435                       }
1436                   }
1437             }
1438             else if( sig->sig_class == 0x28 ) {
1439               /* We don't actually mark the subkey as revoked right
1440                  now, so just check that the revocation sig is the
1441                  most recent valid one.  Note that we don't care if
1442                  the binding sig is newer than the revocation sig.
1443                  See the comment in getkey.c:merge_selfsigs_subkey for
1444                  more */
1445                 if( !knode )
1446                   {
1447                     if(opt.verbose)
1448                       log_info( _("key %s: no subkey for key revocation\n"),
1449                                 keystr(keyid));
1450                     n->flag |= 4; /* delete this */
1451                   }
1452                 else
1453                   {
1454                     rc = check_key_signature( keyblock, n, NULL);
1455                     if( rc )
1456                       {
1457                         if(opt.verbose)
1458                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1459                                    _("key %s: unsupported public"
1460                                      " key algorithm\n"):
1461                                    _("key %s: invalid subkey revocation\n"),
1462                                    keystr(keyid));
1463                         n->flag|=4;
1464                       }
1465                     else
1466                       {
1467                         /* It's valid, so is it newer? */
1468                         if(sig->timestamp>=rsdate)
1469                           {
1470                             if(rsnode)
1471                               {
1472                                 rsnode->flag|=4; /* Delete the last revocation
1473                                                     sig since this one is
1474                                                     newer */
1475                                 if(opt.verbose)
1476                                   log_info(_("key %s: removed multiple subkey"
1477                                              " revocation\n"),keystr(keyid));
1478                               }
1479
1480                             rsnode=n;
1481                             rsdate=sig->timestamp;
1482                           }
1483                         else
1484                           n->flag|=4; /* older */
1485                       }
1486                   }
1487             }
1488         }
1489         else
1490           *non_self=1;
1491     }
1492
1493     return 0;
1494 }
1495
1496 /****************
1497  * delete all parts which are invalid and those signatures whose
1498  * public key algorithm is not available in this implemenation;
1499  * but consider RSA as valid, because parse/build_packets knows
1500  * about it.
1501  * returns: true if at least one valid user-id is left over.
1502  */
1503 static int
1504 delete_inv_parts( const char *fname, KBNODE keyblock,
1505                   u32 *keyid, unsigned int options)
1506 {
1507     KBNODE node;
1508     int nvalid=0, uid_seen=0, subkey_seen=0;
1509
1510     for(node=keyblock->next; node; node = node->next ) {
1511         if( node->pkt->pkttype == PKT_USER_ID ) {
1512             uid_seen = 1;
1513             if( (node->flag & 2) || !(node->flag & 1) ) {
1514                 if( opt.verbose )
1515                   {
1516                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1517                                            node->pkt->pkt.user_id->len,0);
1518                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1519                               keystr(keyid),p);
1520                     xfree(p);
1521                   }
1522                 delete_kbnode( node ); /* the user-id */
1523                 /* and all following packets up to the next user-id */
1524                 while( node->next
1525                        && node->next->pkt->pkttype != PKT_USER_ID
1526                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1527                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1528                     delete_kbnode( node->next );
1529                     node = node->next;
1530                 }
1531             }
1532             else
1533                 nvalid++;
1534         }
1535         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1536                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1537             if( (node->flag & 2) || !(node->flag & 1) ) {
1538                 if( opt.verbose )
1539                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1540
1541                 delete_kbnode( node ); /* the subkey */
1542                 /* and all following signature packets */
1543                 while( node->next
1544                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1545                     delete_kbnode( node->next );
1546                     node = node->next;
1547                 }
1548             }
1549             else
1550               subkey_seen = 1;
1551         }
1552         else if( node->pkt->pkttype == PKT_SIGNATURE
1553                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1554                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1555             delete_kbnode( node ); /* build_packet() can't handle this */
1556         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1557                  !node->pkt->pkt.signature->flags.exportable &&
1558                  !(options&IMPORT_LOCAL_SIGS) &&
1559                  seckey_available( node->pkt->pkt.signature->keyid ) )
1560           {
1561             /* here we violate the rfc a bit by still allowing
1562              * to import non-exportable signature when we have the
1563              * the secret key used to create this signature - it
1564              * seems that this makes sense */
1565             if(opt.verbose)
1566               log_info( _("key %s: non exportable signature"
1567                           " (class 0x%02X) - skipped\n"),
1568                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1569             delete_kbnode( node );
1570           }
1571         else if( node->pkt->pkttype == PKT_SIGNATURE
1572                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1573             if( uid_seen )
1574               {
1575                 if(opt.verbose)
1576                   log_info( _("key %s: revocation certificate"
1577                               " at wrong place - skipped\n"),keystr(keyid));
1578                 delete_kbnode( node );
1579               }
1580             else {
1581               /* If the revocation cert is from a different key than
1582                  the one we're working on don't check it - it's
1583                  probably from a revocation key and won't be
1584                  verifiable with this key anyway. */
1585
1586               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1587                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1588                 {
1589                   int rc = check_key_signature( keyblock, node, NULL);
1590                   if( rc )
1591                     {
1592                       if(opt.verbose)
1593                         log_info( _("key %s: invalid revocation"
1594                                     " certificate: %s - skipped\n"),
1595                                   keystr(keyid), g10_errstr(rc));
1596                       delete_kbnode( node );
1597                     }
1598                 }
1599             }
1600         }
1601         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1602                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1603                   node->pkt->pkt.signature->sig_class == 0x28) &&
1604                  !subkey_seen )
1605           {
1606             if(opt.verbose)
1607               log_info( _("key %s: subkey signature"
1608                           " in wrong place - skipped\n"), keystr(keyid));
1609             delete_kbnode( node );
1610           }
1611         else if( node->pkt->pkttype == PKT_SIGNATURE
1612                  && !IS_CERT(node->pkt->pkt.signature))
1613           {
1614             if(opt.verbose)
1615               log_info(_("key %s: unexpected signature class (0x%02X) -"
1616                          " skipped\n"),keystr(keyid),
1617                        node->pkt->pkt.signature->sig_class);
1618             delete_kbnode(node);
1619           }
1620         else if( (node->flag & 4) ) /* marked for deletion */
1621           delete_kbnode( node );
1622     }
1623
1624     /* note: because keyblock is the public key, it is never marked
1625      * for deletion and so keyblock cannot change */
1626     commit_kbnode( &keyblock );
1627     return nvalid;
1628 }
1629
1630
1631 /****************
1632  * It may happen that the imported keyblock has duplicated user IDs.
1633  * We check this here and collapse those user IDs together with their
1634  * sigs into one.
1635  * Returns: True if the keyblock hash changed.
1636  */
1637 int
1638 collapse_uids( KBNODE *keyblock )
1639 {
1640     KBNODE n, n2;
1641     int in_uid;
1642     int any=0;
1643
1644   restart:
1645     for( n = *keyblock; n; n = n->next ) {
1646         if( n->pkt->pkttype != PKT_USER_ID )
1647             continue;
1648         for( n2 = n->next; n2; n2 = n2->next ) {
1649             if( n2->pkt->pkttype == PKT_USER_ID
1650                 && !cmp_user_ids( n->pkt->pkt.user_id,
1651                                   n2->pkt->pkt.user_id ) ) {
1652                 /* found a duplicate */
1653                 any = 1;
1654                 if( !n2->next
1655                     || n2->next->pkt->pkttype == PKT_USER_ID
1656                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1657                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1658                     /* no more signatures: delete the user ID
1659                      * and start over */
1660                     remove_kbnode( keyblock, n2 );
1661                 }
1662                 else {
1663                     /* The simple approach: Move one signature and
1664                      * then start over to delete the next one :-( */
1665                     move_kbnode( keyblock, n2->next, n->next );
1666                 }
1667                 goto restart;
1668             }
1669         }
1670     }
1671     if( !any )
1672         return 0;
1673
1674   restart_sig:
1675     /* now we may have duplicate signatures on one user ID: fix this */
1676     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1677         if( n->pkt->pkttype == PKT_USER_ID )
1678             in_uid = 1;
1679         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1680                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1681             in_uid = 0;
1682         else if( in_uid ) {
1683             n2 = n;
1684             do {
1685                 KBNODE ncmp = NULL;
1686                 for( ; n2; n2 = n2->next ) {
1687                     if(    n2->pkt->pkttype == PKT_USER_ID
1688                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1689                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1690                         break;
1691                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1692                         ;
1693                     else if( !ncmp )
1694                         ncmp = n2;
1695                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1696                                                 n2->pkt->pkt.signature )) {
1697                         remove_kbnode( keyblock, n2 );
1698                         goto restart_sig;
1699                     }
1700                 }
1701                 n2 = ncmp? ncmp->next : NULL;
1702             } while( n2 );
1703         }
1704     }
1705
1706     if(!opt.quiet)
1707       {
1708         const char *key="???";
1709
1710         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1711           key=keystr_from_pk(n->pkt->pkt.public_key);
1712         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1713           key=keystr_from_sk(n->pkt->pkt.secret_key);
1714
1715         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1716       }
1717
1718     return 1;
1719 }
1720
1721 /* Check for a 0x20 revocation from a revocation key that is not
1722    present.  This may be called without the benefit of merge_xxxx so
1723    you can't rely on pk->revkey and friends. */
1724 static void
1725 revocation_present(KBNODE keyblock)
1726 {
1727   KBNODE onode,inode;
1728   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1729
1730   for(onode=keyblock->next;onode;onode=onode->next)
1731     {
1732       /* If we reach user IDs, we're done. */
1733       if(onode->pkt->pkttype==PKT_USER_ID)
1734         break;
1735
1736       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1737          onode->pkt->pkt.signature->sig_class==0x1F &&
1738          onode->pkt->pkt.signature->revkey)
1739         {
1740           int idx;
1741           PKT_signature *sig=onode->pkt->pkt.signature;
1742
1743           for(idx=0;idx<sig->numrevkeys;idx++)
1744             {
1745               u32 keyid[2];
1746
1747               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1748                                      MAX_FINGERPRINT_LEN,keyid);
1749
1750               for(inode=keyblock->next;inode;inode=inode->next)
1751                 {
1752                   /* If we reach user IDs, we're done. */
1753                   if(inode->pkt->pkttype==PKT_USER_ID)
1754                     break;
1755
1756                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1757                      inode->pkt->pkt.signature->sig_class==0x20 &&
1758                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1759                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1760                     {
1761                       /* Okay, we have a revocation key, and a
1762                          revocation issued by it.  Do we have the key
1763                          itself? */
1764                       int rc;
1765
1766                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1767                                                    MAX_FINGERPRINT_LEN);
1768                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1769                         {
1770                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
1771
1772                           /* No, so try and get it */
1773                           if(opt.keyserver
1774                              && (opt.keyserver_options.options
1775                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1776                             {
1777                               log_info(_("WARNING: key %s may be revoked:"
1778                                          " fetching revocation key %s\n"),
1779                                        tempkeystr,keystr(keyid));
1780                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1781                                                       MAX_FINGERPRINT_LEN,
1782                                                       opt.keyserver);
1783
1784                               /* Do we have it now? */
1785                               rc=get_pubkey_byfprint_fast (NULL,
1786                                                      sig->revkey[idx]->fpr,
1787                                                      MAX_FINGERPRINT_LEN);
1788                             }
1789
1790                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1791                             log_info(_("WARNING: key %s may be revoked:"
1792                                        " revocation key %s not present.\n"),
1793                                      tempkeystr,keystr(keyid));
1794
1795                           xfree(tempkeystr);
1796                         }
1797                     }
1798                 }
1799             }
1800         }
1801     }
1802 }
1803
1804 /****************
1805  * compare and merge the blocks
1806  *
1807  * o compare the signatures: If we already have this signature, check
1808  *   that they compare okay; if not, issue a warning and ask the user.
1809  * o Simply add the signature.  Can't verify here because we may not have
1810  *   the signature's public key yet; verification is done when putting it
1811  *   into the trustdb, which is done automagically as soon as this pubkey
1812  *   is used.
1813  * Note: We indicate newly inserted packets with flag bit 0
1814  */
1815 static int
1816 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1817               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1818 {
1819     KBNODE onode, node;
1820     int rc, found;
1821
1822     /* 1st: handle revocation certificates */
1823     for(node=keyblock->next; node; node=node->next ) {
1824         if( node->pkt->pkttype == PKT_USER_ID )
1825             break;
1826         else if( node->pkt->pkttype == PKT_SIGNATURE
1827                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1828             /* check whether we already have this */
1829             found = 0;
1830             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1831                 if( onode->pkt->pkttype == PKT_USER_ID )
1832                     break;
1833                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1834                          && onode->pkt->pkt.signature->sig_class == 0x20
1835                          && !cmp_signatures(onode->pkt->pkt.signature,
1836                                             node->pkt->pkt.signature))
1837                   {
1838                     found = 1;
1839                     break;
1840                   }
1841             }
1842             if( !found ) {
1843                 KBNODE n2 = clone_kbnode(node);
1844                 insert_kbnode( keyblock_orig, n2, 0 );
1845                 n2->flag |= 1;
1846                 ++*n_sigs;
1847                 if(!opt.quiet)
1848                   {
1849                     char *p=get_user_id_native (keyid);
1850                     log_info(_("key %s: \"%s\" revocation"
1851                                " certificate added\n"), keystr(keyid),p);
1852                     xfree(p);
1853                   }
1854             }
1855         }
1856     }
1857
1858     /* 2nd: merge in any direct key (0x1F) sigs */
1859     for(node=keyblock->next; node; node=node->next ) {
1860         if( node->pkt->pkttype == PKT_USER_ID )
1861             break;
1862         else if( node->pkt->pkttype == PKT_SIGNATURE
1863                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1864             /* check whether we already have this */
1865             found = 0;
1866             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1867                 if( onode->pkt->pkttype == PKT_USER_ID )
1868                     break;
1869                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1870                          && onode->pkt->pkt.signature->sig_class == 0x1F
1871                          && !cmp_signatures(onode->pkt->pkt.signature,
1872                                             node->pkt->pkt.signature)) {
1873                     found = 1;
1874                     break;
1875                 }
1876             }
1877             if( !found )
1878               {
1879                 KBNODE n2 = clone_kbnode(node);
1880                 insert_kbnode( keyblock_orig, n2, 0 );
1881                 n2->flag |= 1;
1882                 ++*n_sigs;
1883                 if(!opt.quiet)
1884                   log_info( _("key %s: direct key signature added\n"),
1885                             keystr(keyid));
1886               }
1887         }
1888     }
1889
1890     /* 3rd: try to merge new certificates in */
1891     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1892         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1893             /* find the user id in the imported keyblock */
1894             for(node=keyblock->next; node; node=node->next )
1895                 if( node->pkt->pkttype == PKT_USER_ID
1896                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1897                                           node->pkt->pkt.user_id ) )
1898                     break;
1899             if( node ) { /* found: merge */
1900                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1901                 if( rc )
1902                     return rc;
1903             }
1904         }
1905     }
1906
1907     /* 4th: add new user-ids */
1908     for(node=keyblock->next; node; node=node->next ) {
1909         if( node->pkt->pkttype == PKT_USER_ID) {
1910             /* do we have this in the original keyblock */
1911             for(onode=keyblock_orig->next; onode; onode=onode->next )
1912                 if( onode->pkt->pkttype == PKT_USER_ID
1913                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1914                                       node->pkt->pkt.user_id ) )
1915                     break;
1916             if( !onode ) { /* this is a new user id: append */
1917                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1918                 if( rc )
1919                     return rc;
1920                 ++*n_uids;
1921             }
1922         }
1923     }
1924
1925     /* 5th: add new subkeys */
1926     for(node=keyblock->next; node; node=node->next ) {
1927         onode = NULL;
1928         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1929             /* do we have this in the original keyblock? */
1930             for(onode=keyblock_orig->next; onode; onode=onode->next )
1931                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1932                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1933                                          node->pkt->pkt.public_key ) )
1934                     break;
1935             if( !onode ) { /* this is a new subkey: append */
1936                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1937                 if( rc )
1938                     return rc;
1939                 ++*n_subk;
1940             }
1941         }
1942         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1943             /* do we have this in the original keyblock? */
1944             for(onode=keyblock_orig->next; onode; onode=onode->next )
1945                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1946                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1947                                          node->pkt->pkt.secret_key ) )
1948                     break;
1949             if( !onode ) { /* this is a new subkey: append */
1950                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1951                 if( rc )
1952                     return rc;
1953                 ++*n_subk;
1954             }
1955         }
1956     }
1957
1958     /* 6th: merge subkey certificates */
1959     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1960         if( !(onode->flag & 1)
1961             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1962                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1963             /* find the subkey in the imported keyblock */
1964             for(node=keyblock->next; node; node=node->next ) {
1965                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1966                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1967                                           node->pkt->pkt.public_key ) )
1968                     break;
1969                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1970                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1971                                           node->pkt->pkt.secret_key ) )
1972                     break;
1973             }
1974             if( node ) { /* found: merge */
1975                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1976                 if( rc )
1977                     return rc;
1978             }
1979         }
1980     }
1981
1982
1983     return 0;
1984 }
1985
1986
1987 /****************
1988  * append the userid starting with NODE and all signatures to KEYBLOCK.
1989  */
1990 static int
1991 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1992                                           const char *fname, u32 *keyid )
1993 {
1994     KBNODE n, n_where=NULL;
1995
1996     assert(node->pkt->pkttype == PKT_USER_ID );
1997
1998     /* find the position */
1999     for( n = keyblock; n; n_where = n, n = n->next ) {
2000         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2001             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2002             break;
2003     }
2004     if( !n )
2005         n_where = NULL;
2006
2007     /* and append/insert */
2008     while( node ) {
2009         /* we add a clone to the original keyblock, because this
2010          * one is released first */
2011         n = clone_kbnode(node);
2012         if( n_where ) {
2013             insert_kbnode( n_where, n, 0 );
2014             n_where = n;
2015         }
2016         else
2017             add_kbnode( keyblock, n );
2018         n->flag |= 1;
2019         node->flag |= 1;
2020         if( n->pkt->pkttype == PKT_SIGNATURE )
2021             ++*n_sigs;
2022
2023         node = node->next;
2024         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2025             break;
2026     }
2027
2028     return 0;
2029 }
2030
2031
2032 /****************
2033  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2034  * (how should we handle comment packets here?)
2035  */
2036 static int
2037 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2038                                     const char *fname, u32 *keyid )
2039 {
2040     KBNODE n, n2;
2041     int found=0;
2042
2043     assert(dst->pkt->pkttype == PKT_USER_ID );
2044     assert(src->pkt->pkttype == PKT_USER_ID );
2045
2046     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2047         if( n->pkt->pkttype != PKT_SIGNATURE )
2048             continue;
2049         if( n->pkt->pkt.signature->sig_class == 0x18
2050             || n->pkt->pkt.signature->sig_class == 0x28 )
2051             continue; /* skip signatures which are only valid on subkeys */
2052         found = 0;
2053         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2054           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2055             {
2056               found++;
2057               break;
2058             }
2059         if( !found ) {
2060             /* This signature is new or newer, append N to DST.
2061              * We add a clone to the original keyblock, because this
2062              * one is released first */
2063             n2 = clone_kbnode(n);
2064             insert_kbnode( dst, n2, PKT_SIGNATURE );
2065             n2->flag |= 1;
2066             n->flag |= 1;
2067             ++*n_sigs;
2068         }
2069     }
2070
2071     return 0;
2072 }
2073
2074 /****************
2075  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2076  */
2077 static int
2078 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2079                                     const char *fname, u32 *keyid )
2080 {
2081     KBNODE n, n2;
2082     int found=0;
2083
2084     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2085            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2086
2087     for(n=src->next; n ; n = n->next ) {
2088         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2089             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2090             break;
2091         if( n->pkt->pkttype != PKT_SIGNATURE )
2092             continue;
2093         found = 0;
2094         for(n2=dst->next; n2; n2 = n2->next){
2095             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2096                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2097                 break;
2098             if( n2->pkt->pkttype == PKT_SIGNATURE
2099                 && n->pkt->pkt.signature->keyid[0]
2100                    == n2->pkt->pkt.signature->keyid[0]
2101                 && n->pkt->pkt.signature->keyid[1]
2102                    == n2->pkt->pkt.signature->keyid[1]
2103                 && n->pkt->pkt.signature->timestamp
2104                    <= n2->pkt->pkt.signature->timestamp
2105                 && n->pkt->pkt.signature->sig_class
2106                    == n2->pkt->pkt.signature->sig_class ) {
2107                 found++;
2108                 break;
2109             }
2110         }
2111         if( !found ) {
2112             /* This signature is new or newer, append N to DST.
2113              * We add a clone to the original keyblock, because this
2114              * one is released first */
2115             n2 = clone_kbnode(n);
2116             insert_kbnode( dst, n2, PKT_SIGNATURE );
2117             n2->flag |= 1;
2118             n->flag |= 1;
2119             ++*n_sigs;
2120         }
2121     }
2122
2123     return 0;
2124 }
2125
2126 /****************
2127  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2128  * Mark all new and copied packets by setting flag bit 0.
2129  */
2130 static int
2131 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2132                                           const char *fname, u32 *keyid )
2133 {
2134     KBNODE n;
2135
2136     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2137            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2138
2139     while(  node ) {
2140         /* we add a clone to the original keyblock, because this
2141          * one is released first */
2142         n = clone_kbnode(node);
2143         add_kbnode( keyblock, n );
2144         n->flag |= 1;
2145         node->flag |= 1;
2146         if( n->pkt->pkttype == PKT_SIGNATURE )
2147             ++*n_sigs;
2148
2149         node = node->next;
2150         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2151             break;
2152     }
2153
2154     return 0;
2155 }
2156
2157
2158
2159 /* Walk a public keyblock and produce a secret keyblock out of it.
2160    Instead of inserting the secret key parameters (which we don't
2161    have), we insert a stub.  */
2162 static KBNODE
2163 pub_to_sec_keyblock (KBNODE pub_keyblock)
2164 {
2165   KBNODE pubnode, secnode;
2166   KBNODE sec_keyblock = NULL;
2167   KBNODE walkctx = NULL;
2168
2169   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2170     {
2171       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2172           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2173         {
2174           /* Make a secret key.  We only need to convert enough to
2175              write the keyblock out. */
2176           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2177           PACKET *pkt = xmalloc_clear (sizeof *pkt);
2178           PKT_secret_key *sk = xmalloc_clear (sizeof *sk);
2179           int i, n;
2180           
2181           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2182             pkt->pkttype = PKT_SECRET_KEY;
2183           else
2184             pkt->pkttype = PKT_SECRET_SUBKEY;
2185           
2186           pkt->pkt.secret_key = sk;
2187
2188           copy_public_parts_to_secret_key ( pk, sk );
2189           sk->version     = pk->version;
2190           sk->timestamp   = pk->timestamp;
2191         
2192           n = pubkey_get_npkey (pk->pubkey_algo);
2193           if (!n)
2194             n = 1; /* Unknown number of parameters, however the data
2195                       is stored in the first mpi. */
2196           for (i=0; i < n; i++ )
2197             sk->skey[i] = mpi_copy (pk->pkey[i]);
2198   
2199           sk->is_protected = 1;
2200           sk->protect.s2k.mode = 1001;
2201   
2202           secnode = new_kbnode (pkt);
2203         }
2204       else
2205         {
2206           secnode = clone_kbnode (pubnode);
2207         }
2208       
2209       if(!sec_keyblock)
2210         sec_keyblock = secnode;
2211       else
2212         add_kbnode (sec_keyblock, secnode);
2213     }
2214
2215   return sec_keyblock;
2216 }
2217
2218
2219 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2220    stub keys with the serial number SNNUM of the card if one of the
2221    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2222    a duplicate (may happen in case of backed uped keys). 
2223    
2224    Returns: True if anything changed.
2225 */
2226 static int
2227 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock, 
2228                                    const unsigned char *fpr1,
2229                                    const unsigned char *fpr2,
2230                                    const unsigned char *fpr3,
2231                                    const char *serialnostr)
2232 {
2233   KBNODE node;
2234   KBNODE walkctx = NULL;
2235   PKT_secret_key *sk;
2236   byte array[MAX_FINGERPRINT_LEN];
2237   size_t n;
2238   int result = 0;
2239   const char *s;
2240
2241   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2242     {
2243       if (node->pkt->pkttype != PKT_SECRET_KEY
2244           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2245         continue;
2246       sk = node->pkt->pkt.secret_key;
2247       
2248       fingerprint_from_sk (sk, array, &n);
2249       if (n != 20)
2250         continue; /* Can't be a card key.  */
2251       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2252              || (fpr2 && !memcmp (array, fpr2, 20))
2253              || (fpr3 && !memcmp (array, fpr3, 20))) )
2254         continue;  /* No match.  */
2255
2256       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2257         {
2258           /* Standard case: migrate that stub to a key stub.  */
2259           sk->protect.s2k.mode = 1002;
2260           s = serialnostr;
2261           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2262                sk->protect.ivlen++, s += 2)
2263             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2264           result = 1;
2265         }
2266       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2267         {
2268           s = serialnostr;
2269           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2270                sk->protect.ivlen++, s += 2)
2271             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2272               {
2273                 log_info (_("NOTE: a key's S/N does not "
2274                             "match the card's one\n"));
2275                 break;
2276               }
2277         }
2278       else
2279         {
2280           if (node->pkt->pkttype != PKT_SECRET_KEY)
2281             log_info (_("NOTE: primary key is online and stored on card\n"));
2282           else
2283             log_info (_("NOTE: secondary key is online and stored on card\n"));
2284         }
2285     }
2286
2287   return result;
2288 }
2289
2290
2291
2292 /* Check whether a secret key stub exists for the public key PK.  If
2293    not create such a stub key and store it into the secring.  If it
2294    exists, add appropriate subkey stubs and update the secring.
2295    Return 0 if the key could be created. */
2296 int
2297 auto_create_card_key_stub ( const char *serialnostr, 
2298                             const unsigned char *fpr1,
2299                             const unsigned char *fpr2,
2300                             const unsigned char *fpr3)
2301 {
2302   KBNODE pub_keyblock;
2303   KBNODE sec_keyblock;
2304   KEYDB_HANDLE hd;
2305   int rc;
2306
2307   /* We only want to do this for an OpenPGP card.  */
2308   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12) 
2309       || strlen (serialnostr) != 32 )
2310     return G10ERR_GENERAL;
2311
2312   /* First get the public keyring from any of the provided fingerprints. */
2313   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2314        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2315        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2316     ;
2317   else
2318     return G10ERR_GENERAL;
2319  
2320   hd = keydb_new (1);
2321
2322   /* Now check whether there is a secret keyring.  */
2323   {
2324     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2325     byte afp[MAX_FINGERPRINT_LEN];
2326     size_t an;
2327
2328     fingerprint_from_pk (pk, afp, &an);
2329     memset (afp, 0, MAX_FINGERPRINT_LEN);
2330     rc = keydb_search_fpr (hd, afp);
2331   }
2332
2333   if (!rc)
2334     {
2335       rc = keydb_get_keyblock (hd, &sec_keyblock);
2336       if (rc)
2337         {
2338           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2339           rc = G10ERR_GENERAL;
2340         }
2341       else
2342         {
2343           merge_keys_and_selfsig (sec_keyblock);
2344           
2345           /* FIXME: We need to add new subkeys first.  */
2346           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2347                                                  fpr1, fpr2, fpr3,
2348                                                  serialnostr))
2349             {
2350               rc = keydb_update_keyblock (hd, sec_keyblock );
2351               if (rc)
2352                 log_error (_("error writing keyring `%s': %s\n"),
2353                            keydb_get_resource_name (hd), g10_errstr(rc) );
2354             }
2355         }
2356     }
2357   else  /* A secret key does not exists - create it.  */
2358     {
2359       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2360       update_sec_keyblock_with_cardinfo (sec_keyblock,
2361                                          fpr1, fpr2, fpr3,
2362                                          serialnostr);
2363
2364       rc = keydb_locate_writable (hd, NULL);
2365       if (rc)
2366         {
2367           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2368           rc = G10ERR_GENERAL;
2369         }
2370       else
2371         {
2372           rc = keydb_insert_keyblock (hd, sec_keyblock );
2373           if (rc)
2374             log_error (_("error writing keyring `%s': %s\n"),
2375                        keydb_get_resource_name (hd), g10_errstr(rc) );
2376         }
2377     }
2378     
2379   release_kbnode (sec_keyblock);
2380   release_kbnode (pub_keyblock);
2381   keydb_release (hd);
2382   return rc;
2383 }
2384