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