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