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