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