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