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