Switched to GPLv3.
[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(uid1->pkt->pkttype!=PKT_USER_ID)
1658         continue;
1659
1660       for(uid2=uid1->next;uid2;uid2=uid2->next)
1661         {
1662           if(uid2->pkt->pkttype!=PKT_USER_ID)
1663             continue;
1664
1665           if(cmp_user_ids(uid1->pkt->pkt.user_id,
1666                           uid2->pkt->pkt.user_id)==0)
1667             {
1668               /* We have a duplicated uid */
1669               KBNODE sig1,last;
1670
1671               any=1;
1672
1673               /* Now take uid2's signatures, and attach them to
1674                  uid1 */
1675               for(last=uid2;last->next;last=last->next)
1676                 {
1677                   if(last->next->pkt->pkttype==PKT_USER_ID
1678                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
1679                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
1680                     break;
1681                 }
1682
1683               /* Snip out uid2 */
1684               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
1685
1686               /* Now put uid2 in place as part of uid1 */
1687               last->next=uid1->next;
1688               uid1->next=uid2;
1689               remove_kbnode(keyblock,uid2);
1690
1691               /* Now dedupe uid1 */
1692               for(sig1=uid1->next;sig1;sig1=sig1->next)
1693                 {
1694                   KBNODE sig2;
1695
1696                   if(sig1->pkt->pkttype==PKT_USER_ID
1697                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
1698                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
1699                     break;
1700
1701                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
1702                     continue;
1703
1704                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
1705                     {
1706                       if(sig2->pkt->pkttype==PKT_USER_ID
1707                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
1708                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
1709                         break;
1710
1711                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
1712                         continue;
1713
1714                       if(cmp_signatures(sig1->pkt->pkt.signature,
1715                                         sig2->pkt->pkt.signature)==0)
1716                         {
1717                           /* We have a match, so delete the second
1718                              signature */
1719                           remove_kbnode(&uid1,sig2);
1720                           sig2=last;
1721                         }
1722                     }
1723                 }
1724             }
1725         }
1726     }
1727
1728   if(any && !opt.quiet)
1729     {
1730       const char *key="???";
1731
1732       if( (uid1=find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1733         key=keystr_from_pk(uid1->pkt->pkt.public_key);
1734       else if( (uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1735         key=keystr_from_sk(uid1->pkt->pkt.secret_key);
1736
1737       log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1738     }
1739
1740   return any;
1741 }
1742
1743 /* Check for a 0x20 revocation from a revocation key that is not
1744    present.  This may be called without the benefit of merge_xxxx so
1745    you can't rely on pk->revkey and friends. */
1746 static void
1747 revocation_present(KBNODE keyblock)
1748 {
1749   KBNODE onode,inode;
1750   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1751
1752   for(onode=keyblock->next;onode;onode=onode->next)
1753     {
1754       /* If we reach user IDs, we're done. */
1755       if(onode->pkt->pkttype==PKT_USER_ID)
1756         break;
1757
1758       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1759          onode->pkt->pkt.signature->sig_class==0x1F &&
1760          onode->pkt->pkt.signature->revkey)
1761         {
1762           int idx;
1763           PKT_signature *sig=onode->pkt->pkt.signature;
1764
1765           for(idx=0;idx<sig->numrevkeys;idx++)
1766             {
1767               u32 keyid[2];
1768
1769               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1770                                      MAX_FINGERPRINT_LEN,keyid);
1771
1772               for(inode=keyblock->next;inode;inode=inode->next)
1773                 {
1774                   /* If we reach user IDs, we're done. */
1775                   if(inode->pkt->pkttype==PKT_USER_ID)
1776                     break;
1777
1778                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1779                      inode->pkt->pkt.signature->sig_class==0x20 &&
1780                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1781                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1782                     {
1783                       /* Okay, we have a revocation key, and a
1784                          revocation issued by it.  Do we have the key
1785                          itself? */
1786                       int rc;
1787
1788                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1789                                                    MAX_FINGERPRINT_LEN);
1790                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1791                         {
1792                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
1793
1794                           /* No, so try and get it */
1795                           if(opt.keyserver
1796                              && (opt.keyserver_options.options
1797                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1798                             {
1799                               log_info(_("WARNING: key %s may be revoked:"
1800                                          " fetching revocation key %s\n"),
1801                                        tempkeystr,keystr(keyid));
1802                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1803                                                       MAX_FINGERPRINT_LEN,
1804                                                       opt.keyserver);
1805
1806                               /* Do we have it now? */
1807                               rc=get_pubkey_byfprint_fast (NULL,
1808                                                      sig->revkey[idx]->fpr,
1809                                                      MAX_FINGERPRINT_LEN);
1810                             }
1811
1812                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1813                             log_info(_("WARNING: key %s may be revoked:"
1814                                        " revocation key %s not present.\n"),
1815                                      tempkeystr,keystr(keyid));
1816
1817                           xfree(tempkeystr);
1818                         }
1819                     }
1820                 }
1821             }
1822         }
1823     }
1824 }
1825
1826 /****************
1827  * compare and merge the blocks
1828  *
1829  * o compare the signatures: If we already have this signature, check
1830  *   that they compare okay; if not, issue a warning and ask the user.
1831  * o Simply add the signature.  Can't verify here because we may not have
1832  *   the signature's public key yet; verification is done when putting it
1833  *   into the trustdb, which is done automagically as soon as this pubkey
1834  *   is used.
1835  * Note: We indicate newly inserted packets with flag bit 0
1836  */
1837 static int
1838 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1839               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1840 {
1841     KBNODE onode, node;
1842     int rc, found;
1843
1844     /* 1st: handle revocation certificates */
1845     for(node=keyblock->next; node; node=node->next ) {
1846         if( node->pkt->pkttype == PKT_USER_ID )
1847             break;
1848         else if( node->pkt->pkttype == PKT_SIGNATURE
1849                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1850             /* check whether we already have this */
1851             found = 0;
1852             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1853                 if( onode->pkt->pkttype == PKT_USER_ID )
1854                     break;
1855                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1856                          && onode->pkt->pkt.signature->sig_class == 0x20
1857                          && !cmp_signatures(onode->pkt->pkt.signature,
1858                                             node->pkt->pkt.signature))
1859                   {
1860                     found = 1;
1861                     break;
1862                   }
1863             }
1864             if( !found ) {
1865                 KBNODE n2 = clone_kbnode(node);
1866                 insert_kbnode( keyblock_orig, n2, 0 );
1867                 n2->flag |= 1;
1868                 ++*n_sigs;
1869                 if(!opt.quiet)
1870                   {
1871                     char *p=get_user_id_native (keyid);
1872                     log_info(_("key %s: \"%s\" revocation"
1873                                " certificate added\n"), keystr(keyid),p);
1874                     xfree(p);
1875                   }
1876             }
1877         }
1878     }
1879
1880     /* 2nd: merge in any direct key (0x1F) sigs */
1881     for(node=keyblock->next; node; node=node->next ) {
1882         if( node->pkt->pkttype == PKT_USER_ID )
1883             break;
1884         else if( node->pkt->pkttype == PKT_SIGNATURE
1885                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1886             /* check whether we already have this */
1887             found = 0;
1888             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1889                 if( onode->pkt->pkttype == PKT_USER_ID )
1890                     break;
1891                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1892                          && onode->pkt->pkt.signature->sig_class == 0x1F
1893                          && !cmp_signatures(onode->pkt->pkt.signature,
1894                                             node->pkt->pkt.signature)) {
1895                     found = 1;
1896                     break;
1897                 }
1898             }
1899             if( !found )
1900               {
1901                 KBNODE n2 = clone_kbnode(node);
1902                 insert_kbnode( keyblock_orig, n2, 0 );
1903                 n2->flag |= 1;
1904                 ++*n_sigs;
1905                 if(!opt.quiet)
1906                   log_info( _("key %s: direct key signature added\n"),
1907                             keystr(keyid));
1908               }
1909         }
1910     }
1911
1912     /* 3rd: try to merge new certificates in */
1913     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1914         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1915             /* find the user id in the imported keyblock */
1916             for(node=keyblock->next; node; node=node->next )
1917                 if( node->pkt->pkttype == PKT_USER_ID
1918                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1919                                           node->pkt->pkt.user_id ) )
1920                     break;
1921             if( node ) { /* found: merge */
1922                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1923                 if( rc )
1924                     return rc;
1925             }
1926         }
1927     }
1928
1929     /* 4th: add new user-ids */
1930     for(node=keyblock->next; node; node=node->next ) {
1931         if( node->pkt->pkttype == PKT_USER_ID) {
1932             /* do we have this in the original keyblock */
1933             for(onode=keyblock_orig->next; onode; onode=onode->next )
1934                 if( onode->pkt->pkttype == PKT_USER_ID
1935                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1936                                       node->pkt->pkt.user_id ) )
1937                     break;
1938             if( !onode ) { /* this is a new user id: append */
1939                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1940                 if( rc )
1941                     return rc;
1942                 ++*n_uids;
1943             }
1944         }
1945     }
1946
1947     /* 5th: add new subkeys */
1948     for(node=keyblock->next; node; node=node->next ) {
1949         onode = NULL;
1950         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1951             /* do we have this in the original keyblock? */
1952             for(onode=keyblock_orig->next; onode; onode=onode->next )
1953                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1954                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1955                                          node->pkt->pkt.public_key ) )
1956                     break;
1957             if( !onode ) { /* this is a new subkey: append */
1958                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1959                 if( rc )
1960                     return rc;
1961                 ++*n_subk;
1962             }
1963         }
1964         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1965             /* do we have this in the original keyblock? */
1966             for(onode=keyblock_orig->next; onode; onode=onode->next )
1967                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1968                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1969                                          node->pkt->pkt.secret_key ) )
1970                     break;
1971             if( !onode ) { /* this is a new subkey: append */
1972                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1973                 if( rc )
1974                     return rc;
1975                 ++*n_subk;
1976             }
1977         }
1978     }
1979
1980     /* 6th: merge subkey certificates */
1981     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1982         if( !(onode->flag & 1)
1983             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1984                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1985             /* find the subkey in the imported keyblock */
1986             for(node=keyblock->next; node; node=node->next ) {
1987                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1988                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1989                                           node->pkt->pkt.public_key ) )
1990                     break;
1991                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1992                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1993                                           node->pkt->pkt.secret_key ) )
1994                     break;
1995             }
1996             if( node ) { /* found: merge */
1997                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1998                 if( rc )
1999                     return rc;
2000             }
2001         }
2002     }
2003
2004
2005     return 0;
2006 }
2007
2008
2009 /****************
2010  * append the userid starting with NODE and all signatures to KEYBLOCK.
2011  */
2012 static int
2013 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
2014                                           const char *fname, u32 *keyid )
2015 {
2016     KBNODE n, n_where=NULL;
2017
2018     assert(node->pkt->pkttype == PKT_USER_ID );
2019
2020     /* find the position */
2021     for( n = keyblock; n; n_where = n, n = n->next ) {
2022         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2023             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2024             break;
2025     }
2026     if( !n )
2027         n_where = NULL;
2028
2029     /* and append/insert */
2030     while( node ) {
2031         /* we add a clone to the original keyblock, because this
2032          * one is released first */
2033         n = clone_kbnode(node);
2034         if( n_where ) {
2035             insert_kbnode( n_where, n, 0 );
2036             n_where = n;
2037         }
2038         else
2039             add_kbnode( keyblock, n );
2040         n->flag |= 1;
2041         node->flag |= 1;
2042         if( n->pkt->pkttype == PKT_SIGNATURE )
2043             ++*n_sigs;
2044
2045         node = node->next;
2046         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2047             break;
2048     }
2049
2050     return 0;
2051 }
2052
2053
2054 /****************
2055  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2056  * (how should we handle comment packets here?)
2057  */
2058 static int
2059 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2060                                     const char *fname, u32 *keyid )
2061 {
2062     KBNODE n, n2;
2063     int found=0;
2064
2065     assert(dst->pkt->pkttype == PKT_USER_ID );
2066     assert(src->pkt->pkttype == PKT_USER_ID );
2067
2068     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2069         if( n->pkt->pkttype != PKT_SIGNATURE )
2070             continue;
2071         if( n->pkt->pkt.signature->sig_class == 0x18
2072             || n->pkt->pkt.signature->sig_class == 0x28 )
2073             continue; /* skip signatures which are only valid on subkeys */
2074         found = 0;
2075         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2076           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2077             {
2078               found++;
2079               break;
2080             }
2081         if( !found ) {
2082             /* This signature is new or newer, append N to DST.
2083              * We add a clone to the original keyblock, because this
2084              * one is released first */
2085             n2 = clone_kbnode(n);
2086             insert_kbnode( dst, n2, PKT_SIGNATURE );
2087             n2->flag |= 1;
2088             n->flag |= 1;
2089             ++*n_sigs;
2090         }
2091     }
2092
2093     return 0;
2094 }
2095
2096 /****************
2097  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2098  */
2099 static int
2100 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2101                                     const char *fname, u32 *keyid )
2102 {
2103     KBNODE n, n2;
2104     int found=0;
2105
2106     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2107            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2108
2109     for(n=src->next; n ; n = n->next ) {
2110         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2111             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2112             break;
2113         if( n->pkt->pkttype != PKT_SIGNATURE )
2114             continue;
2115         found = 0;
2116         for(n2=dst->next; n2; n2 = n2->next){
2117             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2118                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2119                 break;
2120             if( n2->pkt->pkttype == PKT_SIGNATURE
2121                 && n->pkt->pkt.signature->keyid[0]
2122                    == n2->pkt->pkt.signature->keyid[0]
2123                 && n->pkt->pkt.signature->keyid[1]
2124                    == n2->pkt->pkt.signature->keyid[1]
2125                 && n->pkt->pkt.signature->timestamp
2126                    <= n2->pkt->pkt.signature->timestamp
2127                 && n->pkt->pkt.signature->sig_class
2128                    == n2->pkt->pkt.signature->sig_class ) {
2129                 found++;
2130                 break;
2131             }
2132         }
2133         if( !found ) {
2134             /* This signature is new or newer, append N to DST.
2135              * We add a clone to the original keyblock, because this
2136              * one is released first */
2137             n2 = clone_kbnode(n);
2138             insert_kbnode( dst, n2, PKT_SIGNATURE );
2139             n2->flag |= 1;
2140             n->flag |= 1;
2141             ++*n_sigs;
2142         }
2143     }
2144
2145     return 0;
2146 }
2147
2148 /****************
2149  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2150  * Mark all new and copied packets by setting flag bit 0.
2151  */
2152 static int
2153 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2154                                           const char *fname, u32 *keyid )
2155 {
2156     KBNODE n;
2157
2158     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2159            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2160
2161     while(  node ) {
2162         /* we add a clone to the original keyblock, because this
2163          * one is released first */
2164         n = clone_kbnode(node);
2165         add_kbnode( keyblock, n );
2166         n->flag |= 1;
2167         node->flag |= 1;
2168         if( n->pkt->pkttype == PKT_SIGNATURE )
2169             ++*n_sigs;
2170
2171         node = node->next;
2172         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2173             break;
2174     }
2175
2176     return 0;
2177 }
2178
2179
2180
2181 /* Walk a public keyblock and produce a secret keyblock out of it.
2182    Instead of inserting the secret key parameters (which we don't
2183    have), we insert a stub.  */
2184 static KBNODE
2185 pub_to_sec_keyblock (KBNODE pub_keyblock)
2186 {
2187   KBNODE pubnode, secnode;
2188   KBNODE sec_keyblock = NULL;
2189   KBNODE walkctx = NULL;
2190
2191   while((pubnode = walk_kbnode (pub_keyblock,&walkctx,0)))
2192     {
2193       if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY
2194           || pubnode->pkt->pkttype == PKT_PUBLIC_SUBKEY)
2195         {
2196           /* Make a secret key.  We only need to convert enough to
2197              write the keyblock out. */
2198           PKT_public_key *pk = pubnode->pkt->pkt.public_key;
2199           PACKET *pkt = xmalloc_clear (sizeof *pkt);
2200           PKT_secret_key *sk = xmalloc_clear (sizeof *sk);
2201           int i, n;
2202           
2203           if (pubnode->pkt->pkttype == PKT_PUBLIC_KEY)
2204             pkt->pkttype = PKT_SECRET_KEY;
2205           else
2206             pkt->pkttype = PKT_SECRET_SUBKEY;
2207           
2208           pkt->pkt.secret_key = sk;
2209
2210           copy_public_parts_to_secret_key ( pk, sk );
2211           sk->version     = pk->version;
2212           sk->timestamp   = pk->timestamp;
2213         
2214           n = pubkey_get_npkey (pk->pubkey_algo);
2215           if (!n)
2216             n = 1; /* Unknown number of parameters, however the data
2217                       is stored in the first mpi. */
2218           for (i=0; i < n; i++ )
2219             sk->skey[i] = mpi_copy (pk->pkey[i]);
2220   
2221           sk->is_protected = 1;
2222           sk->protect.s2k.mode = 1001;
2223   
2224           secnode = new_kbnode (pkt);
2225         }
2226       else
2227         {
2228           secnode = clone_kbnode (pubnode);
2229         }
2230       
2231       if(!sec_keyblock)
2232         sec_keyblock = secnode;
2233       else
2234         add_kbnode (sec_keyblock, secnode);
2235     }
2236
2237   return sec_keyblock;
2238 }
2239
2240
2241 /* Walk over the secret keyring SEC_KEYBLOCK and update any simple
2242    stub keys with the serial number SNNUM of the card if one of the
2243    fingerprints FPR1, FPR2 or FPR3 match.  Print a note if the key is
2244    a duplicate (may happen in case of backed uped keys). 
2245    
2246    Returns: True if anything changed.
2247 */
2248 static int
2249 update_sec_keyblock_with_cardinfo (KBNODE sec_keyblock, 
2250                                    const unsigned char *fpr1,
2251                                    const unsigned char *fpr2,
2252                                    const unsigned char *fpr3,
2253                                    const char *serialnostr)
2254 {
2255   KBNODE node;
2256   KBNODE walkctx = NULL;
2257   PKT_secret_key *sk;
2258   byte array[MAX_FINGERPRINT_LEN];
2259   size_t n;
2260   int result = 0;
2261   const char *s;
2262
2263   while((node = walk_kbnode (sec_keyblock, &walkctx, 0)))
2264     {
2265       if (node->pkt->pkttype != PKT_SECRET_KEY
2266           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
2267         continue;
2268       sk = node->pkt->pkt.secret_key;
2269       
2270       fingerprint_from_sk (sk, array, &n);
2271       if (n != 20)
2272         continue; /* Can't be a card key.  */
2273       if ( !((fpr1 && !memcmp (array, fpr1, 20))
2274              || (fpr2 && !memcmp (array, fpr2, 20))
2275              || (fpr3 && !memcmp (array, fpr3, 20))) )
2276         continue;  /* No match.  */
2277
2278       if (sk->is_protected == 1 && sk->protect.s2k.mode == 1001)
2279         {
2280           /* Standard case: migrate that stub to a key stub.  */
2281           sk->protect.s2k.mode = 1002;
2282           s = serialnostr;
2283           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2284                sk->protect.ivlen++, s += 2)
2285             sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
2286           result = 1;
2287         }
2288       else if (sk->is_protected == 1 && sk->protect.s2k.mode == 1002)
2289         {
2290           s = serialnostr;
2291           for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
2292                sk->protect.ivlen++, s += 2)
2293             if (sk->protect.iv[sk->protect.ivlen] != xtoi_2 (s))
2294               {
2295                 log_info (_("NOTE: a key's S/N does not "
2296                             "match the card's one\n"));
2297                 break;
2298               }
2299         }
2300       else
2301         {
2302           if (node->pkt->pkttype != PKT_SECRET_KEY)
2303             log_info (_("NOTE: primary key is online and stored on card\n"));
2304           else
2305             log_info (_("NOTE: secondary key is online and stored on card\n"));
2306         }
2307     }
2308
2309   return result;
2310 }
2311
2312
2313
2314 /* Check whether a secret key stub exists for the public key PK.  If
2315    not create such a stub key and store it into the secring.  If it
2316    exists, add appropriate subkey stubs and update the secring.
2317    Return 0 if the key could be created. */
2318 int
2319 auto_create_card_key_stub ( const char *serialnostr, 
2320                             const unsigned char *fpr1,
2321                             const unsigned char *fpr2,
2322                             const unsigned char *fpr3)
2323 {
2324   KBNODE pub_keyblock;
2325   KBNODE sec_keyblock;
2326   KEYDB_HANDLE hd;
2327   int rc;
2328
2329   /* We only want to do this for an OpenPGP card.  */
2330   if (!serialnostr || strncmp (serialnostr, "D27600012401", 12) 
2331       || strlen (serialnostr) != 32 )
2332     return G10ERR_GENERAL;
2333
2334   /* First get the public keyring from any of the provided fingerprints. */
2335   if ( (fpr1 && !get_keyblock_byfprint (&pub_keyblock, fpr1, 20))
2336        || (fpr2 && !get_keyblock_byfprint (&pub_keyblock, fpr2, 20))
2337        || (fpr3 && !get_keyblock_byfprint (&pub_keyblock, fpr3, 20)))
2338     ;
2339   else
2340     return G10ERR_GENERAL;
2341  
2342   hd = keydb_new (1);
2343
2344   /* Now check whether there is a secret keyring.  */
2345   {
2346     PKT_public_key *pk = pub_keyblock->pkt->pkt.public_key;
2347     byte afp[MAX_FINGERPRINT_LEN];
2348     size_t an;
2349
2350     fingerprint_from_pk (pk, afp, &an);
2351     memset (afp, 0, MAX_FINGERPRINT_LEN);
2352     rc = keydb_search_fpr (hd, afp);
2353   }
2354
2355   if (!rc)
2356     {
2357       rc = keydb_get_keyblock (hd, &sec_keyblock);
2358       if (rc)
2359         {
2360           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
2361           rc = G10ERR_GENERAL;
2362         }
2363       else
2364         {
2365           merge_keys_and_selfsig (sec_keyblock);
2366           
2367           /* FIXME: We need to add new subkeys first.  */
2368           if (update_sec_keyblock_with_cardinfo (sec_keyblock,
2369                                                  fpr1, fpr2, fpr3,
2370                                                  serialnostr))
2371             {
2372               rc = keydb_update_keyblock (hd, sec_keyblock );
2373               if (rc)
2374                 log_error (_("error writing keyring `%s': %s\n"),
2375                            keydb_get_resource_name (hd), g10_errstr(rc) );
2376             }
2377         }
2378     }
2379   else  /* A secret key does not exists - create it.  */
2380     {
2381       sec_keyblock = pub_to_sec_keyblock (pub_keyblock);
2382       update_sec_keyblock_with_cardinfo (sec_keyblock,
2383                                          fpr1, fpr2, fpr3,
2384                                          serialnostr);
2385
2386       rc = keydb_locate_writable (hd, NULL);
2387       if (rc)
2388         {
2389           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
2390           rc = G10ERR_GENERAL;
2391         }
2392       else
2393         {
2394           rc = keydb_insert_keyblock (hd, sec_keyblock );
2395           if (rc)
2396             log_error (_("error writing keyring `%s': %s\n"),
2397                        keydb_get_resource_name (hd), g10_errstr(rc) );
2398         }
2399     }
2400     
2401   release_kbnode (sec_keyblock);
2402   release_kbnode (pub_keyblock);
2403   keydb_release (hd);
2404   return rc;
2405 }
2406