Import fixes.
[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;  xfree (kek);
1126   kek = NULL;
1127
1128   main_pk = NULL;
1129   while ((node = walk_kbnode (sec_keyblock, &ctx, 0)))
1130     {
1131       if (node->pkt->pkttype != PKT_SECRET_KEY
1132           && node->pkt->pkttype != PKT_SECRET_SUBKEY)
1133         continue;
1134       pk = node->pkt->pkt.public_key;
1135       if (!main_pk)
1136         main_pk = pk;
1137
1138       ski = pk->seckey_info;
1139       if (!ski)
1140         BUG ();
1141
1142       stats->count++;
1143       stats->secret_read++;
1144
1145       /* For now we ignore the stub keys becuase we don't have real
1146          support for them in gpg-agent.  */
1147       if (ski->s2k.mode == 1001 || ski->s2k.mode == 1002)
1148         continue;
1149
1150       /* Convert our internal secret key object into an S-expression.  */
1151       nskey = pubkey_get_nskey (pk->pubkey_algo);
1152       if (!nskey || nskey > PUBKEY_MAX_NSKEY)
1153         {
1154           err = gpg_error (GPG_ERR_BAD_SECKEY);
1155           log_error ("internal error: %s\n", gpg_strerror (err));
1156           goto leave;
1157         }
1158
1159       init_membuf (&mbuf, 50);
1160       put_membuf_str (&mbuf, "(skey");
1161       for (i=j=0; i < nskey; i++)
1162         {
1163           if (!pk->pkey[i])
1164             ; /* Protected keys only have NPKEY+1 elements.  */
1165           else if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
1166             {
1167               put_membuf_str (&mbuf, " e %b");
1168               format_args_buf_ptr[i] = gcry_mpi_get_opaque (pk->pkey[i], &n);
1169               format_args_buf_int[i] = (n+7)/8;
1170               format_args[j++] = format_args_buf_int + i;
1171               format_args[j++] = format_args_buf_ptr + i;
1172             }
1173           else
1174             {
1175               put_membuf_str (&mbuf, " _ %m");
1176               format_args[j++] = pk->pkey + i;
1177             }
1178         }
1179       put_membuf_str (&mbuf, ")\n");
1180       put_membuf (&mbuf, "", 1);
1181       {
1182         char *format = get_membuf (&mbuf, NULL);
1183         if (!format)
1184           err = gpg_error_from_syserror ();
1185         else
1186           err = gcry_sexp_build_array (&skey, NULL, format, format_args);
1187         xfree (format);
1188       }
1189       if (err)
1190         {
1191           log_error ("error building skey array: %s\n", gpg_strerror (err));
1192           goto leave;
1193         }
1194
1195       if (ski->is_protected)
1196         {
1197           char countbuf[35];
1198           
1199           /* Note that the IVLEN may be zero if we are working on a
1200              dummy key.  We can't express that in an S-expression and
1201              thus we send dummy data for the IV.  */
1202           snprintf (countbuf, sizeof countbuf, "%lu",
1203                     (unsigned long)ski->s2k.count);
1204           err = gcry_sexp_build
1205             (&prot, NULL,
1206              " (protection %s %s %b %d %s %b %s)\n",
1207              ski->sha1chk? "sha1":"sum",
1208              openpgp_cipher_algo_name (ski->algo),
1209              ski->ivlen? (int)ski->ivlen:1,
1210              ski->ivlen? ski->iv: (const unsigned char*)"X",
1211              ski->s2k.mode,
1212              openpgp_md_algo_name (ski->s2k.hash_algo),
1213              (int)sizeof (ski->s2k.salt), ski->s2k.salt,
1214              countbuf);
1215         }
1216       else
1217         err = gcry_sexp_build (&prot, NULL, " (protection none)\n");
1218
1219       tmpsexp = NULL;
1220       xfree (transferkey);
1221       transferkey = NULL;
1222       if (!err)
1223         err = gcry_sexp_build (&tmpsexp, NULL,
1224                                "(openpgp-private-key\n"
1225                                " (version %d)\n"
1226                                " (algo %s)\n"
1227                                " %S\n"
1228                                " (csum %d)\n"
1229                                " %S)\n",
1230                                pk->version,
1231                                openpgp_pk_algo_name (pk->pubkey_algo),
1232                                skey, (int)(unsigned long)ski->csum, prot);
1233       gcry_sexp_release (skey);
1234       gcry_sexp_release (prot);
1235       if (!err)
1236         err = make_canon_sexp_pad (tmpsexp, 1, &transferkey, &transferkeylen);
1237       gcry_sexp_release (tmpsexp);
1238       if (err)
1239         {
1240           log_error ("error building transfer key: %s\n", gpg_strerror (err));
1241           goto leave;
1242         }
1243
1244       /* Wrap the key.  */
1245       wrappedkeylen = transferkeylen + 8;
1246       xfree (wrappedkey);
1247       wrappedkey = xtrymalloc (wrappedkeylen);
1248       if (!wrappedkey)
1249         err = gpg_error_from_syserror ();
1250       else
1251         err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen,
1252                                    transferkey, transferkeylen);
1253       if (err)
1254         goto leave;
1255       xfree (transferkey);
1256       transferkey = NULL;
1257
1258       /* Send the wrapped key to the agent.  */
1259       { 
1260         char *desc = gpg_format_keydesc (pk, 1, 1);
1261         err = agent_import_key (ctrl, desc, &cache_nonce, 
1262                                 wrappedkey, wrappedkeylen);
1263         xfree (desc);
1264       }
1265       if (!err)
1266         {
1267           if (opt.verbose)
1268             log_info (_("key %s: secret key imported\n"),
1269                       keystr_from_pk_with_sub (main_pk, pk));
1270           stats->secret_imported++;
1271         }
1272       else if ( gpg_err_code (err) == GPG_ERR_EEXIST )
1273         {
1274           if (opt.verbose)
1275             log_info (_("key %s: secret key already exists\n"),
1276                       keystr_from_pk_with_sub (main_pk, pk));
1277           err = 0;
1278           stats->secret_dups++;
1279         }
1280       else
1281         {
1282           log_error (_("key %s: error sending to agent: %s\n"),
1283                      keystr_from_pk_with_sub (main_pk, pk),
1284                      gpg_strerror (err));
1285           if (ski->algo == GCRY_CIPHER_IDEA
1286               && gpg_err_code (err) == GPG_ERR_CIPHER_ALGO)
1287             {
1288               write_status (STATUS_RSA_OR_IDEA);
1289               idea_cipher_warn (0);
1290             }
1291           if (gpg_err_code (err) == GPG_ERR_CANCELED)
1292             break; /* Don't try the other subkeys.  */
1293         }
1294     }
1295
1296  leave:
1297   xfree (cache_nonce);
1298   xfree (wrappedkey);
1299   xfree (transferkey);
1300   gcry_cipher_close (cipherhd);
1301   xfree (kek);
1302   return err;
1303 }
1304
1305
1306 /* Walk a secret keyblock and produce a public keyblock out of it.
1307    Returns a new node or NULL on error. */
1308 static kbnode_t
1309 sec_to_pub_keyblock (kbnode_t sec_keyblock)
1310 {
1311   kbnode_t pub_keyblock = NULL;
1312   kbnode_t ctx = NULL;
1313   kbnode_t secnode, pubnode;
1314
1315   while ((secnode = walk_kbnode (sec_keyblock, &ctx, 0)))
1316     {
1317       if (secnode->pkt->pkttype == PKT_SECRET_KEY
1318           || secnode->pkt->pkttype == PKT_SECRET_SUBKEY)
1319         {
1320           /* Make a public key.  */
1321           PACKET *pkt;
1322           PKT_public_key *pk;
1323
1324           pkt = xtrycalloc (1, sizeof *pkt);
1325           pk = pkt? copy_public_key (NULL, secnode->pkt->pkt.public_key): NULL;
1326           if (!pk)
1327             {
1328               xfree (pkt);
1329               release_kbnode (pub_keyblock);
1330               return NULL;
1331             }
1332           if (secnode->pkt->pkttype == PKT_SECRET_KEY)
1333             pkt->pkttype = PKT_PUBLIC_KEY;
1334           else
1335             pkt->pkttype = PKT_PUBLIC_SUBKEY;
1336           pkt->pkt.public_key = pk;
1337
1338           pubnode = new_kbnode (pkt);
1339         }
1340       else
1341         {
1342           pubnode = clone_kbnode (secnode);
1343         }
1344
1345       if (!pub_keyblock)
1346         pub_keyblock = pubnode;
1347       else
1348         add_kbnode (pub_keyblock, pubnode);
1349     }
1350
1351   return pub_keyblock;
1352 }
1353
1354 /****************
1355  * Ditto for secret keys.  Handling is simpler than for public keys.
1356  * We allow secret key importing only when allow is true, this is so
1357  * that a secret key can not be imported accidently and thereby tampering
1358  * with the trust calculation.
1359  */
1360 static int
1361 import_secret_one (ctrl_t ctrl, const char *fname, KBNODE keyblock, 
1362                    struct stats_s *stats, unsigned int options)
1363 {
1364   PKT_public_key *pk;
1365   struct seckey_info *ski;
1366   KBNODE node, uidnode;
1367   u32 keyid[2];
1368   int rc = 0;
1369     
1370   /* Get the key and print some info about it */
1371   node = find_kbnode (keyblock, PKT_SECRET_KEY);
1372   if (!node)
1373     BUG ();
1374   
1375   pk = node->pkt->pkt.public_key;
1376
1377   keyid_from_pk (pk, keyid);
1378   uidnode = find_next_kbnode (keyblock, PKT_USER_ID);
1379   
1380   if (opt.verbose)
1381     {
1382       log_info ("sec  %4u%c/%s %s   ",
1383                 nbits_from_pk (pk),
1384                 pubkey_letter (pk->pubkey_algo),
1385                 keystr_from_pk (pk), datestr_from_pk (pk));
1386       if (uidnode)
1387         print_utf8_buffer (log_get_stream (), uidnode->pkt->pkt.user_id->name,
1388                            uidnode->pkt->pkt.user_id->len);
1389       log_printf ("\n");
1390     }
1391   stats->secret_read++;
1392   
1393   if (!uidnode)
1394     {
1395       log_error( _("key %s: no user ID\n"), keystr_from_pk (pk));
1396       return 0;
1397     }
1398
1399   ski = pk->seckey_info;
1400   if (!ski)
1401     {
1402       /* Actually an internal error.  */
1403       log_error ("key %s: secret key info missing\n", keystr_from_pk (pk));
1404       return 0;
1405     }
1406
1407   /* A quick check to not import keys with an invalid protection
1408      cipher algorithm (only checks the primary key, though).  */
1409   if (ski->algo > 110)
1410     {
1411       log_error (_("key %s: secret key with invalid cipher %d"
1412                    " - skipped\n"), keystr_from_pk (pk), ski->algo);
1413       return 0;
1414     }
1415
1416 #ifdef ENABLE_SELINUX_HACKS
1417   if (1)
1418     {
1419       /* We don't allow to import secret keys because that may be used
1420          to put a secret key into the keyring and the user might later
1421          be tricked into signing stuff with that key.  */
1422       log_error (_("importing secret keys not allowed\n"));
1423       return 0;
1424     }
1425 #endif 
1426     
1427   clear_kbnode_flags (keyblock);
1428   
1429   if (!(options&IMPORT_MERGE_ONLY) || !have_secret_key_with_kid (keyid) )
1430     {
1431       /* We don't have this key, insert as a new key.  */
1432       kbnode_t pub_keyblock;
1433
1434       /* Make a public key out of this. */
1435       pub_keyblock = sec_to_pub_keyblock (keyblock);
1436       if (!pub_keyblock)
1437         log_error ("key %s: failed to create public key from secret key\n",
1438                    keystr_from_pk (pk));
1439       else
1440         {
1441           import_one (ctrl, fname, pub_keyblock, stats,
1442                       NULL, NULL, opt.import_options, 1);
1443           /* Fixme: We should check for an invalid keyblock and
1444              cancel the secret key import in this case.  */
1445           release_kbnode (pub_keyblock);
1446             
1447           /* Read the keyblock again to get the effects of a merge.  */
1448           /* Fixme: we should do this based on the fingerprint or
1449              even better let import_one return the merged
1450              keyblock.  */
1451           node = get_pubkeyblock (keyid);
1452           if (!node)
1453             log_error ("key %s: failed to re-lookup public key\n",
1454                        keystr_from_pk (pk));
1455           else
1456             {
1457               if (!transfer_secret_keys (ctrl, stats, keyblock))
1458                 {
1459                   if (!opt.quiet)
1460                     log_info (_("key %s: secret key imported\n"),
1461                               keystr_from_pk (pk));
1462                   if (is_status_enabled ()) 
1463                     print_import_ok (pk, 1|16);
1464                   check_prefs (ctrl, node);
1465                 }
1466               release_kbnode (node);
1467             }
1468         }
1469     }
1470   else
1471     { 
1472       /* We don't want to merge the secret keys. */
1473       log_error (_("key %s: secret key part already available\n"),
1474                  keystr_from_pk (pk));
1475       if (is_status_enabled ()) 
1476         print_import_ok (pk, 16);
1477     }
1478
1479   return rc;
1480 }
1481
1482
1483 /****************
1484  * Import a revocation certificate; this is a single signature packet.
1485  */
1486 static int
1487 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1488 {
1489     PKT_public_key *pk=NULL;
1490     KBNODE onode, keyblock = NULL;
1491     KEYDB_HANDLE hd = NULL;
1492     u32 keyid[2];
1493     int rc = 0;
1494
1495     (void)fname;
1496
1497     assert( !node->next );
1498     assert( node->pkt->pkttype == PKT_SIGNATURE );
1499     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1500
1501     keyid[0] = node->pkt->pkt.signature->keyid[0];
1502     keyid[1] = node->pkt->pkt.signature->keyid[1];
1503
1504     pk = xmalloc_clear( sizeof *pk );
1505     rc = get_pubkey( pk, keyid );
1506     if( rc == G10ERR_NO_PUBKEY )
1507       {
1508         log_error(_("key %s: no public key -"
1509                     " can't apply revocation certificate\n"), keystr(keyid));
1510         rc = 0;
1511         goto leave;
1512       }
1513     else if( rc )
1514       {
1515         log_error(_("key %s: public key not found: %s\n"),
1516                   keystr(keyid), g10_errstr(rc));
1517         goto leave;
1518       }
1519
1520     /* read the original keyblock */
1521     hd = keydb_new ();
1522     {
1523         byte afp[MAX_FINGERPRINT_LEN];
1524         size_t an;
1525         
1526         fingerprint_from_pk (pk, afp, &an);
1527         while (an < MAX_FINGERPRINT_LEN) 
1528             afp[an++] = 0;
1529         rc = keydb_search_fpr (hd, afp);
1530     }
1531     if (rc)
1532       {
1533         log_error (_("key %s: can't locate original keyblock: %s\n"),
1534                    keystr(keyid), g10_errstr(rc));
1535         goto leave;
1536       }
1537     rc = keydb_get_keyblock (hd, &keyblock );
1538     if (rc)
1539       {
1540         log_error (_("key %s: can't read original keyblock: %s\n"),
1541                    keystr(keyid), g10_errstr(rc));
1542         goto leave;
1543       }
1544
1545     /* it is okay, that node is not in keyblock because
1546      * check_key_signature works fine for sig_class 0x20 in this
1547      * special case. */
1548     rc = check_key_signature( keyblock, node, NULL);
1549     if( rc )
1550       {
1551         log_error( _("key %s: invalid revocation certificate"
1552                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1553         goto leave;
1554       }
1555
1556     /* check whether we already have this */
1557     for(onode=keyblock->next; onode; onode=onode->next ) {
1558         if( onode->pkt->pkttype == PKT_USER_ID )
1559             break;
1560         else if( onode->pkt->pkttype == PKT_SIGNATURE
1561                  && !cmp_signatures(node->pkt->pkt.signature,
1562                                     onode->pkt->pkt.signature))
1563           {
1564             rc = 0;
1565             goto leave; /* yes, we already know about it */
1566           }
1567     }
1568
1569
1570     /* insert it */
1571     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1572
1573     /* and write the keyblock back */
1574     rc = keydb_update_keyblock (hd, keyblock );
1575     if (rc)
1576         log_error (_("error writing keyring `%s': %s\n"),
1577                    keydb_get_resource_name (hd), g10_errstr(rc) );
1578     keydb_release (hd); hd = NULL;
1579     /* we are ready */
1580     if( !opt.quiet )
1581       {
1582         char *p=get_user_id_native (keyid);
1583         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1584                   keystr(keyid),p);
1585         xfree(p);
1586       }
1587     stats->n_revoc++;
1588
1589     /* If the key we just revoked was ultimately trusted, remove its
1590        ultimate trust.  This doesn't stop the user from putting the
1591        ultimate trust back, but is a reasonable solution for now. */
1592     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1593       clear_ownertrusts(pk);
1594
1595     revalidation_mark ();
1596
1597   leave:
1598     keydb_release (hd);
1599     release_kbnode( keyblock );
1600     free_public_key( pk );
1601     return rc;
1602 }
1603
1604
1605 /*
1606  * Loop over the keyblock and check all self signatures.
1607  * Mark all user-ids with a self-signature by setting flag bit 0.
1608  * Mark all user-ids with an invalid self-signature by setting bit 1.
1609  * This works also for subkeys, here the subkey is marked.  Invalid or
1610  * extra subkey sigs (binding or revocation) are marked for deletion.
1611  * non_self is set to true if there are any sigs other than self-sigs
1612  * in this keyblock.
1613  */
1614 static int
1615 chk_self_sigs (const char *fname, kbnode_t keyblock,
1616                PKT_public_key *pk, u32 *keyid, int *non_self )
1617 {
1618   kbnode_t n, knode = NULL;
1619   PKT_signature *sig;
1620   int rc;
1621   u32 bsdate=0, rsdate=0;
1622   kbnode_t bsnode = NULL, rsnode = NULL;
1623   
1624   (void)fname;
1625   (void)pk;
1626
1627   for (n=keyblock; (n = find_next_kbnode (n, 0)); ) 
1628     {
1629       if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1630         {
1631           knode = n;
1632           bsdate = 0;
1633           rsdate = 0;
1634           bsnode = NULL;
1635           rsnode = NULL;
1636           continue;
1637         }
1638
1639       if ( n->pkt->pkttype != PKT_SIGNATURE )
1640         continue;
1641       
1642       sig = n->pkt->pkt.signature;
1643       if ( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
1644         {
1645           *non_self = 1;
1646           continue;
1647         }
1648
1649       /* This just caches the sigs for later use.  That way we
1650          import a fully-cached key which speeds things up. */
1651       if (!opt.no_sig_cache)
1652         check_key_signature (keyblock, n, NULL);
1653       
1654       if ( IS_UID_SIG(sig) || IS_UID_REV(sig) )
1655         {
1656           KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1657           if ( !unode )
1658             {
1659               log_error( _("key %s: no user ID for signature\n"),
1660                          keystr(keyid));
1661               return -1;  /* The complete keyblock is invalid.  */
1662             }
1663           
1664           /* If it hasn't been marked valid yet, keep trying.  */
1665           if (!(unode->flag&1)) 
1666             {
1667               rc = check_key_signature (keyblock, n, NULL);
1668               if ( rc )
1669                 {
1670                   if ( opt.verbose )
1671                     {
1672                       char *p = utf8_to_native 
1673                         (unode->pkt->pkt.user_id->name,
1674                          strlen (unode->pkt->pkt.user_id->name),0);
1675                       log_info (gpg_err_code(rc) == G10ERR_PUBKEY_ALGO ?
1676                                 _("key %s: unsupported public key "
1677                                   "algorithm on user ID \"%s\"\n"):
1678                                 _("key %s: invalid self-signature "
1679                                   "on user ID \"%s\"\n"),
1680                                 keystr (keyid),p);
1681                       xfree (p);
1682                     }
1683                 }
1684               else
1685                 unode->flag |= 1; /* Mark that signature checked. */
1686             }
1687         }
1688       else if (IS_KEY_SIG (sig))
1689         {
1690           rc = check_key_signature (keyblock, n, NULL);
1691           if ( rc )
1692             {
1693               if (opt.verbose)
1694                 log_info (gpg_err_code (rc) == G10ERR_PUBKEY_ALGO ?
1695                           _("key %s: unsupported public key algorithm\n"):
1696                           _("key %s: invalid direct key signature\n"),
1697                           keystr (keyid));
1698               n->flag |= 4;
1699             }
1700         }
1701       else if ( IS_SUBKEY_SIG (sig) ) 
1702         {
1703           /* Note that this works based solely on the timestamps like
1704              the rest of gpg.  If the standard gets revocation
1705              targets, this may need to be revised.  */
1706
1707           if ( !knode )
1708             {
1709               if (opt.verbose)
1710                 log_info (_("key %s: no subkey for key binding\n"),
1711                           keystr (keyid));
1712               n->flag |= 4; /* delete this */
1713             }
1714           else
1715             {
1716               rc = check_key_signature (keyblock, n, NULL);
1717               if ( rc )
1718                 {
1719                   if (opt.verbose)
1720                     log_info (gpg_err_code (rc) == G10ERR_PUBKEY_ALGO ?
1721                               _("key %s: unsupported public key"
1722                                 " algorithm\n"):
1723                               _("key %s: invalid subkey binding\n"),
1724                               keystr (keyid));
1725                   n->flag |= 4;
1726                 }
1727               else
1728                 {
1729                   /* It's valid, so is it newer? */
1730                   if (sig->timestamp >= bsdate) 
1731                     {
1732                       knode->flag |= 1;  /* The subkey is valid.  */
1733                       if (bsnode)
1734                         {
1735                           /* Delete the last binding sig since this
1736                              one is newer */
1737                           bsnode->flag |= 4; 
1738                           if (opt.verbose)
1739                             log_info (_("key %s: removed multiple subkey"
1740                                         " binding\n"),keystr(keyid));
1741                         }
1742                       
1743                       bsnode = n;
1744                       bsdate = sig->timestamp;
1745                     }
1746                   else
1747                     n->flag |= 4; /* older */
1748                 }
1749             }
1750         }
1751       else if ( IS_SUBKEY_REV (sig) )
1752         {
1753           /* We don't actually mark the subkey as revoked right now,
1754              so just check that the revocation sig is the most recent
1755              valid one.  Note that we don't care if the binding sig is
1756              newer than the revocation sig.  See the comment in
1757              getkey.c:merge_selfsigs_subkey for more.  */
1758           if ( !knode )
1759             {
1760               if (opt.verbose)
1761                 log_info (_("key %s: no subkey for key revocation\n"),
1762                           keystr(keyid));
1763               n->flag |= 4; /* delete this */
1764             }
1765           else
1766             {
1767               rc = check_key_signature (keyblock, n, NULL);
1768               if ( rc )
1769                 {
1770                   if(opt.verbose)
1771                     log_info (gpg_err_code (rc) == G10ERR_PUBKEY_ALGO ?
1772                               _("key %s: unsupported public"
1773                                 " key algorithm\n"):
1774                               _("key %s: invalid subkey revocation\n"),
1775                               keystr(keyid));
1776                   n->flag |= 4;
1777                 }
1778               else
1779                 {
1780                   /* It's valid, so is it newer? */
1781                   if (sig->timestamp >= rsdate)
1782                     {
1783                       if (rsnode)
1784                         {
1785                           /* Delete the last revocation sig since
1786                              this one is newer.  */
1787                           rsnode->flag |= 4; 
1788                           if (opt.verbose)
1789                             log_info (_("key %s: removed multiple subkey"
1790                                         " revocation\n"),keystr(keyid));
1791                         }
1792                       
1793                       rsnode = n;
1794                       rsdate = sig->timestamp;
1795                     }
1796                   else
1797                     n->flag |= 4; /* older */
1798                 }
1799             }
1800         }
1801     }
1802
1803   return 0;
1804 }
1805
1806
1807 /****************
1808  * delete all parts which are invalid and those signatures whose
1809  * public key algorithm is not available in this implemenation;
1810  * but consider RSA as valid, because parse/build_packets knows
1811  * about it.
1812  * returns: true if at least one valid user-id is left over.
1813  */
1814 static int
1815 delete_inv_parts( const char *fname, KBNODE keyblock,
1816                   u32 *keyid, unsigned int options)
1817 {
1818     KBNODE node;
1819     int nvalid=0, uid_seen=0, subkey_seen=0;
1820
1821     (void)fname;
1822
1823     for(node=keyblock->next; node; node = node->next ) {
1824         if( node->pkt->pkttype == PKT_USER_ID ) {
1825             uid_seen = 1;
1826             if( (node->flag & 2) || !(node->flag & 1) ) {
1827                 if( opt.verbose )
1828                   {
1829                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1830                                            node->pkt->pkt.user_id->len,0);
1831                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1832                               keystr(keyid),p);
1833                     xfree(p);
1834                   }
1835                 delete_kbnode( node ); /* the user-id */
1836                 /* and all following packets up to the next user-id */
1837                 while( node->next
1838                        && node->next->pkt->pkttype != PKT_USER_ID
1839                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1840                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1841                     delete_kbnode( node->next );
1842                     node = node->next;
1843                 }
1844             }
1845             else
1846                 nvalid++;
1847         }
1848         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1849                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1850             if( (node->flag & 2) || !(node->flag & 1) ) {
1851                 if( opt.verbose )
1852                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1853
1854                 delete_kbnode( node ); /* the subkey */
1855                 /* and all following signature packets */
1856                 while( node->next
1857                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1858                     delete_kbnode( node->next );
1859                     node = node->next;
1860                 }
1861             }
1862             else
1863               subkey_seen = 1;
1864         }
1865         else if (node->pkt->pkttype == PKT_SIGNATURE
1866                 && openpgp_pk_test_algo (node->pkt->pkt.signature->pubkey_algo)
1867                 && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1868             delete_kbnode( node ); /* build_packet() can't handle this */
1869         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1870                  !node->pkt->pkt.signature->flags.exportable &&
1871                  !(options&IMPORT_LOCAL_SIGS) &&
1872                  !have_secret_key_with_kid (node->pkt->pkt.signature->keyid))
1873           {
1874             /* here we violate the rfc a bit by still allowing
1875              * to import non-exportable signature when we have the
1876              * the secret key used to create this signature - it
1877              * seems that this makes sense */
1878             if(opt.verbose)
1879               log_info( _("key %s: non exportable signature"
1880                           " (class 0x%02X) - skipped\n"),
1881                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1882             delete_kbnode( node );
1883           }
1884         else if( node->pkt->pkttype == PKT_SIGNATURE
1885                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1886             if( uid_seen )
1887               {
1888                 if(opt.verbose)
1889                   log_info( _("key %s: revocation certificate"
1890                               " at wrong place - skipped\n"),keystr(keyid));
1891                 delete_kbnode( node );
1892               }
1893             else {
1894               /* If the revocation cert is from a different key than
1895                  the one we're working on don't check it - it's
1896                  probably from a revocation key and won't be
1897                  verifiable with this key anyway. */
1898
1899               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1900                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1901                 {
1902                   int rc = check_key_signature( keyblock, node, NULL);
1903                   if( rc )
1904                     {
1905                       if(opt.verbose)
1906                         log_info( _("key %s: invalid revocation"
1907                                     " certificate: %s - skipped\n"),
1908                                   keystr(keyid), g10_errstr(rc));
1909                       delete_kbnode( node );
1910                     }
1911                 }
1912             }
1913         }
1914         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1915                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1916                   node->pkt->pkt.signature->sig_class == 0x28) &&
1917                  !subkey_seen )
1918           {
1919             if(opt.verbose)
1920               log_info( _("key %s: subkey signature"
1921                           " in wrong place - skipped\n"), keystr(keyid));
1922             delete_kbnode( node );
1923           }
1924         else if( node->pkt->pkttype == PKT_SIGNATURE
1925                  && !IS_CERT(node->pkt->pkt.signature))
1926           {
1927             if(opt.verbose)
1928               log_info(_("key %s: unexpected signature class (0x%02X) -"
1929                          " skipped\n"),keystr(keyid),
1930                        node->pkt->pkt.signature->sig_class);
1931             delete_kbnode(node);
1932           }
1933         else if( (node->flag & 4) ) /* marked for deletion */
1934           delete_kbnode( node );
1935     }
1936
1937     /* note: because keyblock is the public key, it is never marked
1938      * for deletion and so keyblock cannot change */
1939     commit_kbnode( &keyblock );
1940     return nvalid;
1941 }
1942
1943
1944 /****************
1945  * It may happen that the imported keyblock has duplicated user IDs.
1946  * We check this here and collapse those user IDs together with their
1947  * sigs into one.
1948  * Returns: True if the keyblock has changed.
1949  */
1950 int
1951 collapse_uids( KBNODE *keyblock )
1952 {
1953   KBNODE uid1;
1954   int any=0;
1955
1956   for(uid1=*keyblock;uid1;uid1=uid1->next)
1957     {
1958       KBNODE uid2;
1959
1960       if(is_deleted_kbnode(uid1))
1961         continue;
1962
1963       if(uid1->pkt->pkttype!=PKT_USER_ID)
1964         continue;
1965
1966       for(uid2=uid1->next;uid2;uid2=uid2->next)
1967         {
1968           if(is_deleted_kbnode(uid2))
1969             continue;
1970
1971           if(uid2->pkt->pkttype!=PKT_USER_ID)
1972             continue;
1973
1974           if(cmp_user_ids(uid1->pkt->pkt.user_id,
1975                           uid2->pkt->pkt.user_id)==0)
1976             {
1977               /* We have a duplicated uid */
1978               KBNODE sig1,last;
1979
1980               any=1;
1981
1982               /* Now take uid2's signatures, and attach them to
1983                  uid1 */
1984               for(last=uid2;last->next;last=last->next)
1985                 {
1986                   if(is_deleted_kbnode(last))
1987                     continue;
1988
1989                   if(last->next->pkt->pkttype==PKT_USER_ID
1990                      || last->next->pkt->pkttype==PKT_PUBLIC_SUBKEY
1991                      || last->next->pkt->pkttype==PKT_SECRET_SUBKEY)
1992                     break;
1993                 }
1994
1995               /* Snip out uid2 */
1996               (find_prev_kbnode(*keyblock,uid2,0))->next=last->next;
1997
1998               /* Now put uid2 in place as part of uid1 */
1999               last->next=uid1->next;
2000               uid1->next=uid2;
2001               delete_kbnode(uid2);
2002
2003               /* Now dedupe uid1 */
2004               for(sig1=uid1->next;sig1;sig1=sig1->next)
2005                 {
2006                   KBNODE sig2;
2007
2008                   if(is_deleted_kbnode(sig1))
2009                     continue;
2010
2011                   if(sig1->pkt->pkttype==PKT_USER_ID
2012                      || sig1->pkt->pkttype==PKT_PUBLIC_SUBKEY
2013                      || sig1->pkt->pkttype==PKT_SECRET_SUBKEY)
2014                     break;
2015
2016                   if(sig1->pkt->pkttype!=PKT_SIGNATURE)
2017                     continue;
2018
2019                   for(sig2=sig1->next,last=sig1;sig2;last=sig2,sig2=sig2->next)
2020                     {
2021                       if(is_deleted_kbnode(sig2))
2022                         continue;
2023
2024                       if(sig2->pkt->pkttype==PKT_USER_ID
2025                          || sig2->pkt->pkttype==PKT_PUBLIC_SUBKEY
2026                          || sig2->pkt->pkttype==PKT_SECRET_SUBKEY)
2027                         break;
2028
2029                       if(sig2->pkt->pkttype!=PKT_SIGNATURE)
2030                         continue;
2031
2032                       if(cmp_signatures(sig1->pkt->pkt.signature,
2033                                         sig2->pkt->pkt.signature)==0)
2034                         {
2035                           /* We have a match, so delete the second
2036                              signature */
2037                           delete_kbnode(sig2);
2038                           sig2=last;
2039                         }
2040                     }
2041                 }
2042             }
2043         }
2044     }
2045
2046   commit_kbnode(keyblock);
2047
2048   if(any && !opt.quiet)
2049     {
2050       const char *key="???";
2051
2052       if ((uid1 = find_kbnode (*keyblock, PKT_PUBLIC_KEY)) )
2053         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2054       else if ((uid1 = find_kbnode( *keyblock, PKT_SECRET_KEY)) )
2055         key = keystr_from_pk (uid1->pkt->pkt.public_key);
2056
2057       log_info (_("key %s: duplicated user ID detected - merged\n"), key);
2058     }
2059
2060   return any;
2061 }
2062
2063 /* Check for a 0x20 revocation from a revocation key that is not
2064    present.  This may be called without the benefit of merge_xxxx so
2065    you can't rely on pk->revkey and friends. */
2066 static void
2067 revocation_present (ctrl_t ctrl, kbnode_t keyblock)
2068 {
2069   kbnode_t onode, inode;
2070   PKT_public_key *pk = keyblock->pkt->pkt.public_key;
2071
2072   for(onode=keyblock->next;onode;onode=onode->next)
2073     {
2074       /* If we reach user IDs, we're done. */
2075       if(onode->pkt->pkttype==PKT_USER_ID)
2076         break;
2077
2078       if(onode->pkt->pkttype==PKT_SIGNATURE &&
2079          onode->pkt->pkt.signature->sig_class==0x1F &&
2080          onode->pkt->pkt.signature->revkey)
2081         {
2082           int idx;
2083           PKT_signature *sig=onode->pkt->pkt.signature;
2084
2085           for(idx=0;idx<sig->numrevkeys;idx++)
2086             {
2087               u32 keyid[2];
2088
2089               keyid_from_fingerprint(sig->revkey[idx]->fpr,
2090                                      MAX_FINGERPRINT_LEN,keyid);
2091
2092               for(inode=keyblock->next;inode;inode=inode->next)
2093                 {
2094                   /* If we reach user IDs, we're done. */
2095                   if(inode->pkt->pkttype==PKT_USER_ID)
2096                     break;
2097
2098                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
2099                      inode->pkt->pkt.signature->sig_class==0x20 &&
2100                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
2101                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
2102                     {
2103                       /* Okay, we have a revocation key, and a
2104                          revocation issued by it.  Do we have the key
2105                          itself? */
2106                       int rc;
2107
2108                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
2109                                                    MAX_FINGERPRINT_LEN);
2110                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
2111                         {
2112                           char *tempkeystr=xstrdup(keystr_from_pk(pk));
2113
2114                           /* No, so try and get it */
2115                           if(opt.keyserver
2116                              && (opt.keyserver_options.options
2117                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
2118                             {
2119                               log_info(_("WARNING: key %s may be revoked:"
2120                                          " fetching revocation key %s\n"),
2121                                        tempkeystr,keystr(keyid));
2122                               keyserver_import_fprint (ctrl,
2123                                                        sig->revkey[idx]->fpr,
2124                                                        MAX_FINGERPRINT_LEN,
2125                                                        opt.keyserver);
2126
2127                               /* Do we have it now? */
2128                               rc=get_pubkey_byfprint_fast (NULL,
2129                                                      sig->revkey[idx]->fpr,
2130                                                      MAX_FINGERPRINT_LEN);
2131                             }
2132
2133                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
2134                             log_info(_("WARNING: key %s may be revoked:"
2135                                        " revocation key %s not present.\n"),
2136                                      tempkeystr,keystr(keyid));
2137
2138                           xfree(tempkeystr);
2139                         }
2140                     }
2141                 }
2142             }
2143         }
2144     }
2145 }
2146
2147 /****************
2148  * compare and merge the blocks
2149  *
2150  * o compare the signatures: If we already have this signature, check
2151  *   that they compare okay; if not, issue a warning and ask the user.
2152  * o Simply add the signature.  Can't verify here because we may not have
2153  *   the signature's public key yet; verification is done when putting it
2154  *   into the trustdb, which is done automagically as soon as this pubkey
2155  *   is used.
2156  * Note: We indicate newly inserted packets with flag bit 0
2157  */
2158 static int
2159 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
2160               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
2161 {
2162     KBNODE onode, node;
2163     int rc, found;
2164
2165     /* 1st: handle revocation certificates */
2166     for(node=keyblock->next; node; node=node->next ) {
2167         if( node->pkt->pkttype == PKT_USER_ID )
2168             break;
2169         else if( node->pkt->pkttype == PKT_SIGNATURE
2170                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
2171             /* check whether we already have this */
2172             found = 0;
2173             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2174                 if( onode->pkt->pkttype == PKT_USER_ID )
2175                     break;
2176                 else if( onode->pkt->pkttype == PKT_SIGNATURE
2177                          && onode->pkt->pkt.signature->sig_class == 0x20
2178                          && !cmp_signatures(onode->pkt->pkt.signature,
2179                                             node->pkt->pkt.signature))
2180                   {
2181                     found = 1;
2182                     break;
2183                   }
2184             }
2185             if( !found ) {
2186                 KBNODE n2 = clone_kbnode(node);
2187                 insert_kbnode( keyblock_orig, n2, 0 );
2188                 n2->flag |= 1;
2189                 ++*n_sigs;
2190                 if(!opt.quiet)
2191                   {
2192                     char *p=get_user_id_native (keyid);
2193                     log_info(_("key %s: \"%s\" revocation"
2194                                " certificate added\n"), keystr(keyid),p);
2195                     xfree(p);
2196                   }
2197             }
2198         }
2199     }
2200
2201     /* 2nd: merge in any direct key (0x1F) sigs */
2202     for(node=keyblock->next; node; node=node->next ) {
2203         if( node->pkt->pkttype == PKT_USER_ID )
2204             break;
2205         else if( node->pkt->pkttype == PKT_SIGNATURE
2206                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
2207             /* check whether we already have this */
2208             found = 0;
2209             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2210                 if( onode->pkt->pkttype == PKT_USER_ID )
2211                     break;
2212                 else if( onode->pkt->pkttype == PKT_SIGNATURE
2213                          && onode->pkt->pkt.signature->sig_class == 0x1F
2214                          && !cmp_signatures(onode->pkt->pkt.signature,
2215                                             node->pkt->pkt.signature)) {
2216                     found = 1;
2217                     break;
2218                 }
2219             }
2220             if( !found )
2221               {
2222                 KBNODE n2 = clone_kbnode(node);
2223                 insert_kbnode( keyblock_orig, n2, 0 );
2224                 n2->flag |= 1;
2225                 ++*n_sigs;
2226                 if(!opt.quiet)
2227                   log_info( _("key %s: direct key signature added\n"),
2228                             keystr(keyid));
2229               }
2230         }
2231     }
2232
2233     /* 3rd: try to merge new certificates in */
2234     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2235         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
2236             /* find the user id in the imported keyblock */
2237             for(node=keyblock->next; node; node=node->next )
2238                 if( node->pkt->pkttype == PKT_USER_ID
2239                     && !cmp_user_ids( onode->pkt->pkt.user_id,
2240                                           node->pkt->pkt.user_id ) )
2241                     break;
2242             if( node ) { /* found: merge */
2243                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
2244                 if( rc )
2245                     return rc;
2246             }
2247         }
2248     }
2249
2250     /* 4th: add new user-ids */
2251     for(node=keyblock->next; node; node=node->next ) {
2252         if( node->pkt->pkttype == PKT_USER_ID) {
2253             /* do we have this in the original keyblock */
2254             for(onode=keyblock_orig->next; onode; onode=onode->next )
2255                 if( onode->pkt->pkttype == PKT_USER_ID
2256                     && !cmp_user_ids( onode->pkt->pkt.user_id,
2257                                       node->pkt->pkt.user_id ) )
2258                     break;
2259             if( !onode ) { /* this is a new user id: append */
2260                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
2261                 if( rc )
2262                     return rc;
2263                 ++*n_uids;
2264             }
2265         }
2266     }
2267
2268     /* 5th: add new subkeys */
2269     for(node=keyblock->next; node; node=node->next ) {
2270         onode = NULL;
2271         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
2272             /* do we have this in the original keyblock? */
2273             for(onode=keyblock_orig->next; onode; onode=onode->next )
2274                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2275                     && !cmp_public_keys( onode->pkt->pkt.public_key,
2276                                          node->pkt->pkt.public_key ) )
2277                     break;
2278             if( !onode ) { /* this is a new subkey: append */
2279                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
2280                 if( rc )
2281                     return rc;
2282                 ++*n_subk;
2283             }
2284         }
2285         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
2286             /* do we have this in the original keyblock? */
2287             for(onode=keyblock_orig->next; onode; onode=onode->next )
2288                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
2289                     && !cmp_public_keys (onode->pkt->pkt.public_key,
2290                                          node->pkt->pkt.public_key) )
2291                     break;
2292             if( !onode ) { /* this is a new subkey: append */
2293                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
2294                 if( rc )
2295                     return rc;
2296                 ++*n_subk;
2297             }
2298         }
2299     }
2300
2301     /* 6th: merge subkey certificates */
2302     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
2303         if( !(onode->flag & 1)
2304             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
2305                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
2306             /* find the subkey in the imported keyblock */
2307             for(node=keyblock->next; node; node=node->next ) {
2308                 if ((node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2309                      || node->pkt->pkttype == PKT_SECRET_SUBKEY)
2310                     && !cmp_public_keys( onode->pkt->pkt.public_key,
2311                                           node->pkt->pkt.public_key ) )
2312                     break;
2313             }
2314             if( node ) { /* found: merge */
2315                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
2316                 if( rc )
2317                     return rc;
2318             }
2319         }
2320     }
2321
2322
2323     return 0;
2324 }
2325
2326
2327 /****************
2328  * append the userid starting with NODE and all signatures to KEYBLOCK.
2329  */
2330 static int
2331 append_uid (KBNODE keyblock, KBNODE node, int *n_sigs,
2332             const char *fname, u32 *keyid )
2333 {
2334     KBNODE n, n_where=NULL;
2335
2336     (void)fname;
2337     (void)keyid;
2338
2339     assert(node->pkt->pkttype == PKT_USER_ID );
2340
2341     /* find the position */
2342     for( n = keyblock; n; n_where = n, n = n->next ) {
2343         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2344             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
2345             break;
2346     }
2347     if( !n )
2348         n_where = NULL;
2349
2350     /* and append/insert */
2351     while( node ) {
2352         /* we add a clone to the original keyblock, because this
2353          * one is released first */
2354         n = clone_kbnode(node);
2355         if( n_where ) {
2356             insert_kbnode( n_where, n, 0 );
2357             n_where = n;
2358         }
2359         else
2360             add_kbnode( keyblock, n );
2361         n->flag |= 1;
2362         node->flag |= 1;
2363         if( n->pkt->pkttype == PKT_SIGNATURE )
2364             ++*n_sigs;
2365
2366         node = node->next;
2367         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2368             break;
2369     }
2370
2371     return 0;
2372 }
2373
2374
2375 /****************
2376  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
2377  * (how should we handle comment packets here?)
2378  */
2379 static int
2380 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
2381                                     const char *fname, u32 *keyid )
2382 {
2383     KBNODE n, n2;
2384     int found=0;
2385
2386     (void)fname;
2387     (void)keyid;
2388
2389     assert(dst->pkt->pkttype == PKT_USER_ID );
2390     assert(src->pkt->pkttype == PKT_USER_ID );
2391
2392     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
2393         if( n->pkt->pkttype != PKT_SIGNATURE )
2394             continue;
2395         if( n->pkt->pkt.signature->sig_class == 0x18
2396             || n->pkt->pkt.signature->sig_class == 0x28 )
2397             continue; /* skip signatures which are only valid on subkeys */
2398         found = 0;
2399         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
2400           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
2401             {
2402               found++;
2403               break;
2404             }
2405         if( !found ) {
2406             /* This signature is new or newer, append N to DST.
2407              * We add a clone to the original keyblock, because this
2408              * one is released first */
2409             n2 = clone_kbnode(n);
2410             insert_kbnode( dst, n2, PKT_SIGNATURE );
2411             n2->flag |= 1;
2412             n->flag |= 1;
2413             ++*n_sigs;
2414         }
2415     }
2416
2417     return 0;
2418 }
2419
2420 /****************
2421  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2422  */
2423 static int
2424 merge_keysigs (KBNODE dst, KBNODE src, int *n_sigs,
2425                const char *fname, u32 *keyid)
2426 {
2427     KBNODE n, n2;
2428     int found=0;
2429
2430     (void)fname;
2431     (void)keyid;
2432
2433     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2434            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2435
2436     for(n=src->next; n ; n = n->next ) {
2437         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2438             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2439             break;
2440         if( n->pkt->pkttype != PKT_SIGNATURE )
2441             continue;
2442         found = 0;
2443         for(n2=dst->next; n2; n2 = n2->next){
2444             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2445                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2446                 break;
2447             if( n2->pkt->pkttype == PKT_SIGNATURE
2448                 && n->pkt->pkt.signature->keyid[0]
2449                    == n2->pkt->pkt.signature->keyid[0]
2450                 && n->pkt->pkt.signature->keyid[1]
2451                    == n2->pkt->pkt.signature->keyid[1]
2452                 && n->pkt->pkt.signature->timestamp
2453                    <= n2->pkt->pkt.signature->timestamp
2454                 && n->pkt->pkt.signature->sig_class
2455                    == n2->pkt->pkt.signature->sig_class ) {
2456                 found++;
2457                 break;
2458             }
2459         }
2460         if( !found ) {
2461             /* This signature is new or newer, append N to DST.
2462              * We add a clone to the original keyblock, because this
2463              * one is released first */
2464             n2 = clone_kbnode(n);
2465             insert_kbnode( dst, n2, PKT_SIGNATURE );
2466             n2->flag |= 1;
2467             n->flag |= 1;
2468             ++*n_sigs;
2469         }
2470     }
2471
2472     return 0;
2473 }
2474
2475
2476 /*
2477  * Append the subkey starting with NODE and all signatures to KEYBLOCK.
2478  * Mark all new and copied packets by setting flag bit 0.
2479  */
2480 static int
2481 append_key (KBNODE keyblock, KBNODE node, int *n_sigs,
2482             const char *fname, u32 *keyid)
2483 {
2484     KBNODE n;
2485
2486     (void)fname;
2487     (void)keyid;
2488
2489     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2490            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2491
2492     while(  node ) {
2493         /* we add a clone to the original keyblock, because this
2494          * one is released first */
2495         n = clone_kbnode(node);
2496         add_kbnode( keyblock, n );
2497         n->flag |= 1;
2498         node->flag |= 1;
2499         if( n->pkt->pkttype == PKT_SIGNATURE )
2500             ++*n_sigs;
2501
2502         node = node->next;
2503         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2504             break;
2505     }
2506
2507     return 0;
2508 }