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