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