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