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