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