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