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